feat(stdlib/typecheck): C-proper string primitives + polymorphic ++ (Refs #122)

Option-C enabler: make AffineScript-level string logic compile through
the static pipeline + Deno-ESM backend, resting on a thin honest
host-primitive layer instead of bespoke per-op externs.

typecheck:
- `++` (OpConcat) is now polymorphic over String and [T] — dispatched
  on the synthesised lhs type. Was String-only, so `acc ++ [x]` (how
  stdlib/string.affine's split/join accumulate) failed
  `Unify(Array, String)`.
- `len` broadened from `Array[t]->Int` to `'a->Int` (stdlib/string
  calls it on String and arrays; matches the interpreter + the
  `.length` lowering).
- Bound the honest string/char primitives: string_get/string_sub/
  string_find/to_lowercase/to_uppercase/trim/parse_int/parse_float/
  char_to_int/int_to_char/show (resolve.ml already knew them).

codegen_deno:
- Lower those primitives + `++` (shape-dispatched `__as_concat`, so
  array concat isn't string-coerced) to JS intrinsics. The lowering
  table now applies to ANY matching call head (not only declared
  externs) so AffineScript-level stdlib resolves...
- ...EXCEPT a same-named user definition shadows the intrinsic
  (new ctx.local_fns guard) — fixes a user `fn len(xs: IntList)`
  being hijacked into `.length` (NaN).

Net: ends_with/strip_suffix/find/int_to_string/string-&-array `++`
all work as real AffineScript over the primitive layer
(tests/codegen-deno/string_prims.{affine,harness.mjs}). Full Deno-ESM
suite green (5 harnesses); `dune runtest` unchanged (same 2 pre-existing
E2E Node-CJS vscode failures, 214 tests, zero new regressions).

Note: stdlib/string.affine itself still has a separate Resolution error
(angle-generic `Option<Char>` + unimported Some/None) — that file's own
issue, not the primitive layer; addressed in the consumer migration.

Refs #122.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

lib/codegen_deno.ml

@@ -59,6 +59,10 @@ type codegen_ctx = {
      receiver-first free-function source style (the only form the current
      grammar accepts — no [self]/inherent-[impl]) read as real methods. *)
   assoc : (string, string) Hashtbl.t;
+  (* Top-level functions/consts defined in this program. A user
+     definition shadows a same-named host intrinsic ({!deno_builtins}),
+     so e.g. a user `fn len(xs: IntList)` is NOT lowered to `.length`. *)
+  local_fns : (string, unit) Hashtbl.t;
 }
 
 let create_ctx symbols = {
@@ -68,6 +72,7 @@ let create_ctx symbols = {
   externs = Hashtbl.create 32;
   self_name = None;
   assoc = Hashtbl.create 32;
+  local_fns = Hashtbl.create 64;
 }
 
 let emit ctx str = Buffer.add_string ctx.output str
@@ -117,11 +122,29 @@ const __as_readDirNames = (p) => {
   return names;
 };
 const __as_isNotFound = (e) => (e instanceof Deno.errors.NotFound);
-const __as_endsWith = (s, suffix) => String(s).endsWith(suffix);
-const __as_stripSuffix = (s, suffix) =>
-  String(s).endsWith(suffix) ? String(s).slice(0, -suffix.length) : String(s);
 const __as_wasmInstance = (bytes) =>
   new WebAssembly.Instance(new WebAssembly.Module(bytes)).exports;
+// `++` is overloaded (string concat / array concat); `a + b` would
+// stringify arrays. Dispatch on shape so stdlib/string.affine's
+// `result ++ [x]` and `a ++ b` are both correct.
+const __as_concat = (a, b) => Array.isArray(a) ? a.concat(b) : (a + b);
+// Honest host/runtime primitives underpinning the AffineScript-level
+// stdlib/string.affine (its is_empty/starts_with/ends_with/split/join/
+// replace/... are real AffineScript on top of these).
+const __as_strSub = (s, start, n) => String(s).slice(start, start + n);
+const __as_strGet = (s, i) => String(s)[i];
+const __as_strFind = (s, n) => String(s).indexOf(n);
+const __as_charToInt = (c) => String(c).codePointAt(0);
+const __as_intToChar = (n) => String.fromCodePoint(n);
+const __as_parseInt = (s) => {
+  const n = parseInt(String(s), 10);
+  return Number.isNaN(n) ? None : Some(n);
+};
+const __as_parseFloat = (s) => {
+  const n = parseFloat(String(s));
+  return Number.isNaN(n) ? None : Some(n);
+};
+const __as_show = (v) => (typeof v === "string" ? v : JSON.stringify(v));
 // ---- end runtime ----
 
 |}
@@ -154,12 +177,29 @@ let () =
   b "jsonParse"           (fun a -> Printf.sprintf "JSON.parse(%s)" (arg 0 a));
   (* ---- misc host ---- *)
   b "dateNow"     (fun _ -> "Date.now()");
-  b "numToFixed2" (fun a -> Printf.sprintf "(Number(%s) / 1024).toFixed(2)" (arg 0 a));
-  b "endsWith"    (fun a -> Printf.sprintf "__as_endsWith(%s, %s)" (arg 0 a) (arg 1 a));
-  b "stripSuffix" (fun a -> Printf.sprintf "__as_stripSuffix(%s, %s)" (arg 0 a) (arg 1 a));
   b "wasmInstance" (fun a -> Printf.sprintf "__as_wasmInstance(%s)" (arg 0 a));
   (* Generic JS array push helper (returns the array, fluent). *)
-  b "arrayPush" (fun a -> Printf.sprintf "(%s.push(%s), %s)" (arg 0 a) (arg 1 a) (arg 0 a))
+  b "arrayPush" (fun a -> Printf.sprintf "(%s.push(%s), %s)" (arg 0 a) (arg 1 a) (arg 0 a));
+  (* ---- honest string/number primitives underpinning the
+     AffineScript-level stdlib/string.affine. These are intrinsics (no
+     AffineScript definition exists; the interpreter binds them too),
+     not externs — endsWith/stripSuffix/pathJoin/etc. are NOT here:
+     they are real AffineScript built on `ends_with`/`substring`/`++`. *)
+  b "len"            (fun a -> Printf.sprintf "((%s).length)" (arg 0 a));
+  b "string_length"  (fun a -> Printf.sprintf "((%s).length)" (arg 0 a));
+  b "string_get"     (fun a -> Printf.sprintf "__as_strGet(%s, %s)" (arg 0 a) (arg 1 a));
+  b "string_sub"     (fun a -> Printf.sprintf "__as_strSub(%s, %s, %s)" (arg 0 a) (arg 1 a) (arg 2 a));
+  b "string_find"    (fun a -> Printf.sprintf "__as_strFind(%s, %s)" (arg 0 a) (arg 1 a));
+  b "to_lowercase"   (fun a -> Printf.sprintf "String(%s).toLowerCase()" (arg 0 a));
+  b "to_uppercase"   (fun a -> Printf.sprintf "String(%s).toUpperCase()" (arg 0 a));
+  b "trim"           (fun a -> Printf.sprintf "String(%s).trim()" (arg 0 a));
+  b "int_to_string"  (fun a -> Printf.sprintf "String(%s)" (arg 0 a));
+  b "float_to_string" (fun a -> Printf.sprintf "String(%s)" (arg 0 a));
+  b "parse_int"      (fun a -> Printf.sprintf "__as_parseInt(%s)" (arg 0 a));
+  b "parse_float"    (fun a -> Printf.sprintf "__as_parseFloat(%s)" (arg 0 a));
+  b "char_to_int"    (fun a -> Printf.sprintf "__as_charToInt(%s)" (arg 0 a));
+  b "int_to_char"    (fun a -> Printf.sprintf "__as_intToChar(%s)" (arg 0 a));
+  b "show"           (fun a -> Printf.sprintf "__as_show(%s)" (arg 0 a))
 
 (* ============================================================================
    Identifier sanitisation (JS reserved words -> trailing underscore)
@@ -220,23 +260,34 @@ let rec gen_expr ctx (expr : expr) : string =
               an expression sub-term, so await it (valid: it only occurs
               inside the [async] method bodies we emit). *)
            "(await " ^ recv ^ "." ^ m ^ "(" ^ String.concat ", " rest ^ "))"
+       | ExprVar id
+         when Hashtbl.mem deno_builtins id.name
+              && not (Hashtbl.mem ctx.local_fns id.name) ->
+           (* Honest host/runtime intrinsic (FS/JSON/Date/Wasm extern or
+              a string/number primitive underpinning stdlib/string.affine).
+              Applied to ANY matching call head, not only declared externs,
+              so AffineScript-level stdlib compiled here resolves — but a
+              same-named user definition shadows it (e.g. a user `len`). *)
+           (Hashtbl.find deno_builtins id.name) (List.map (gen_expr ctx) args)
        | ExprVar id when Hashtbl.mem ctx.externs id.name ->
+           (* Declared extern with no intrinsic lowering: assume a
+              same-named host symbol is in scope. *)
            let arg_strs = List.map (gen_expr ctx) args in
-           (match Hashtbl.find_opt deno_builtins id.name with
-            | Some lower -> lower arg_strs
-            | None ->
-                (* Unknown extern: assume a same-named host symbol in scope. *)
-                mangle id.name ^ "(" ^ String.concat ", " arg_strs ^ ")")
+           mangle id.name ^ "(" ^ String.concat ", " arg_strs ^ ")"
        | _ ->
            let arg_strs = List.map (gen_expr ctx) args in
            gen_expr ctx func ^ "(" ^ String.concat ", " arg_strs ^ ")")
+  | ExprBinary (e1, OpConcat, e2) ->
+      (* `++` is string- OR array-concat; dispatch on shape at runtime so
+         `a ++ b` (string) and `acc ++ [x]` (array) are both correct. *)
+      "__as_concat(" ^ gen_expr ctx e1 ^ ", " ^ gen_expr ctx e2 ^ ")"
   | ExprBinary (e1, op, e2) ->
       let op_str = match op with
         | OpAdd -> "+" | OpSub -> "-" | OpMul -> "*" | OpDiv -> "/"
         | OpMod -> "%" | OpEq -> "===" | OpNe -> "!==" | OpLt -> "<"
         | OpLe -> "<=" | OpGt -> ">" | OpGe -> ">=" | OpAnd -> "&&"
         | OpOr -> "||" | OpBitAnd -> "&" | OpBitOr -> "|" | OpBitXor -> "^"
-        | OpShl -> "<<" | OpShr -> ">>" | OpConcat -> "+"
+        | OpShl -> "<<" | OpShr -> ">>" | OpConcat -> "+" (* unreachable *)
       in
       "(" ^ gen_expr ctx e1 ^ " " ^ op_str ^ " " ^ gen_expr ctx e2 ^ ")"
   | ExprUnary (op, e) ->
@@ -734,12 +785,21 @@ let gen_type_decl ctx (td : type_decl) : unit =
 
 let generate (program : program) (symbols : Symbol.t) : string =
   let ctx = create_ctx symbols in
-  (* Register extern names so calls lower via the builtin table. *)
+  (* Register extern names so calls lower via the builtin table, and
+     user-defined top-level names so they shadow host intrinsics. *)
   List.iter (function
     | TopExternFn { ef_name; _ } ->
         Hashtbl.replace ctx.externs ef_name.name ()
     | TopFn fd when fd.fd_body = FnExtern ->
         Hashtbl.replace ctx.externs fd.fd_name.name ()
+    | TopFn fd ->
+        Hashtbl.replace ctx.local_fns fd.fd_name.name ()
+    | TopConst { tc_name; _ } ->
+        Hashtbl.replace ctx.local_fns tc_name.name ()
+    | TopImpl ib ->
+        List.iter (function
+          | ImplFn fd -> Hashtbl.replace ctx.local_fns fd.fd_name.name ()
+          | ImplType _ -> ()) ib.ib_items
     | _ -> ()) program.prog_decls;
 
   emit_line ctx "// Generated by AffineScript compiler (Deno-ESM target, issue #122)";

lib/typecheck.ml

@@ -863,6 +863,20 @@ let rec synth (ctx : context) (expr : expr) : ty result =
         let* () = unify_or_err lhs_ty lhs_ty' in
         let* () = check ctx rhs rhs_ty in
         Ok result_ty
+    end else if (match op with OpConcat -> true | _ -> false) then begin
+      (* `++` is polymorphic over String and [T] (issue #122 v2.5):
+         `a ++ b` (string concat) and `acc ++ [x]` (array concat) — the
+         latter is how stdlib/string.affine's split/join/etc. accumulate.
+         Dispatch on the synthesised lhs type. *)
+      let* lhs_ty = synth ctx lhs in
+      match repr lhs_ty with
+      | TApp (TCon "Array", [elem]) ->
+        let* () = check ctx rhs (TApp (TCon "Array", [elem])) in
+        Ok (TApp (TCon "Array", [elem]))
+      | _ ->
+        let* () = unify_or_err lhs_ty ty_string in
+        let* () = check ctx rhs ty_string in
+        Ok ty_string
     end else begin
       let (lhs_ty, rhs_ty, result_ty) = type_of_binop op in
       let* () = check ctx lhs lhs_ty in
@@ -1180,8 +1194,35 @@ let register_builtins (ctx : context) : unit =
   bind_var ctx "max" int_binop;
   bind_var ctx "min" int_binop;
   bind_var ctx "pow_float" float_binop;
+  (* `len` is polymorphic over String and [T] (issue #122 v2.5):
+     stdlib/string.affine calls `len` on both. Broadened from
+     Array[tv]->Int to 'a->Int (matches the interpreter's dynamic len;
+     the codegen lowers it to `.length`, valid for string and array). *)
   bind_var ctx "len" (let tv = fresh_tyvar 0 in
-    TArrow (TApp (TCon "Array", [tv]), QOmega, ty_int, EPure));
+    TArrow (tv, QOmega, ty_int, EPure));
+  (* Honest string/char primitives underpinning stdlib/string.affine
+     (issue #122 v2.5). Concrete String/Char types; the Deno-ESM backend
+     lowers each to a JS intrinsic. char ::= TCon "Char". *)
+  let ty_char = TCon "Char" in
+  let opt t = TApp (TCon "Option", [t]) in
+  bind_var ctx "string_get"
+    (TArrow (ty_string, QOmega, TArrow (ty_int, QOmega, ty_char, EPure), EPure));
+  bind_var ctx "string_sub"
+    (TArrow (ty_string, QOmega,
+       TArrow (ty_int, QOmega,
+         TArrow (ty_int, QOmega, ty_string, EPure), EPure), EPure));
+  bind_var ctx "string_find"
+    (TArrow (ty_string, QOmega,
+       TArrow (ty_string, QOmega, ty_int, EPure), EPure));
+  bind_var ctx "to_lowercase" (TArrow (ty_string, QOmega, ty_string, EPure));
+  bind_var ctx "to_uppercase" (TArrow (ty_string, QOmega, ty_string, EPure));
+  bind_var ctx "trim"         (TArrow (ty_string, QOmega, ty_string, EPure));
+  bind_var ctx "parse_int"    (TArrow (ty_string, QOmega, opt ty_int, EPure));
+  bind_var ctx "parse_float"  (TArrow (ty_string, QOmega, opt ty_float, EPure));
+  bind_var ctx "char_to_int"  (TArrow (ty_char, QOmega, ty_int, EPure));
+  bind_var ctx "int_to_char"  (TArrow (ty_int, QOmega, ty_char, EPure));
+  bind_var ctx "show"
+    (let tv = fresh_tyvar 0 in TArrow (tv, QOmega, ty_string, EPure));
   bind_var ctx "panic" (TArrow (ty_string, QOmega, ty_never, EPure));
   bind_var ctx "exit" (TArrow (ty_int, QOmega, ty_never, ESingleton "IO"));
   (* TEA runtime — accepts any record, returns unit with IO effect *)

tests/codegen-deno/string_prims.affine

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.5 regression: the honest string/number primitive layer
+// (len/string_sub/string_find/int_to_string + `++` shape dispatch) that
+// lets stdlib/string.affine — real AffineScript — run under Deno-ESM.
+// These mirror the exact primitives stdlib/string.affine is built on.
+
+pub fn ends_with2(s: String, suffix: String) -> Bool {
+  let slen = len(s);
+  let sfxlen = len(suffix);
+  if sfxlen > slen {
+    return false;
+  }
+  return string_sub(s, slen - sfxlen, sfxlen) == suffix;
+}
+
+pub fn strip_suffix(s: String, suffix: String) -> String {
+  if ends_with2(s, suffix) {
+    return string_sub(s, 0, len(s) - len(suffix));
+  }
+  return s;
+}
+
+pub fn find(s: String, needle: String) -> Int = string_find(s, needle);
+
+pub fn n2s(n: Int) -> String = int_to_string(n);
+
+pub fn str_cat(a: String, b: String) -> String = a ++ b;
+
+pub fn arr_cat(xs: [Int]) -> [Int] = xs ++ [99];

tests/codegen-deno/string_prims.harness.mjs

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.5 — honest string/number primitive lowering + `++` shape
+// dispatch (string concat vs array concat).
+import assert from "node:assert/strict";
+import {
+  ends_with2,
+  strip_suffix,
+  find,
+  n2s,
+  str_cat,
+  arr_cat,
+} from "./string_prims.deno.js";
+
+assert.equal(ends_with2("foo.json", ".json"), true, "string_sub/len ends_with");
+assert.equal(ends_with2("foo.txt", ".json"), false, "negative ends_with");
+assert.equal(ends_with2("a", ".json"), false, "suffix longer than string");
+assert.equal(strip_suffix("foo.json", ".json"), "foo", "strip_suffix");
+assert.equal(strip_suffix("foo", ".json"), "foo", "strip_suffix no-op");
+assert.equal(find("ab.cd", "."), 2, "string_find");
+assert.equal(n2s(42), "42", "int_to_string");
+assert.equal(str_cat("a", "b"), "ab", "`++` string concat");
+assert.deepEqual(arr_cat([1, 2]), [1, 2, 99], "`++` array concat (not '1,299')");
+
+console.log("string_prims.harness.mjs OK");