compiler: string-wall slice 8b — type-directed string ++ lowering

The full fix the slice-8a guard (#575) stood in for. String ++ now lowers
correctly AND completely to wasm (incl. pure variable-to-variable, which
the syntactic guard could not reach).

Channel (type-directed elaboration):
- ast.ml: new ExprStringConcat of expr * expr (not produced by the parser).
- typecheck.ml: synth records each ++ node it types as String concat, by
  physical identity (string_concat_sites); elaborate_string_concat rewrites
  exactly those nodes to ExprStringConcat. Physical-identity keying is sound
  because typecheck and codegen run over the same prog object
  (parse_with_face's lowered prog, shared by resolve/typecheck/codegen);
  ExprBinary carries no span and same-text ++ occurrences are value-equal,
  so == is the correct key.
- bin/main.ml: the wasm path runs elaborate_string_concat after typecheck,
  before Opt.fold_constants_program. The interpreter and non-wasm backends
  keep the original prog (String ++ = ExprBinary _ OpConcat _), so the
  oracle is unchanged and only the wasm backend sees the new node.

Lowering (codegen.ml): byte concat — allocate 4 + la + lb, write the
length word, copy a's then b's bytes — mirroring the list-concat handler
but with 1-byte elements and a single length word (instead of 4-byte i32
elements, which was exactly the bug: the list path copied a string's
[len][utf8] as i32 elements, so "ab" ++ "cd" read byte 2 as the length
word of "cd" = 2 instead of 'c' = 99).

Effect parity (effect_sites.ml): ExprStringConcat recurses like ExprBinary
and is NOT counted as an ExprApp call site, so effect-ordinals stay
identical between the interpreter (which sees ExprBinary) and the wasm
backend (which sees ExprStringConcat) — avoiding a #555-class desync. An
intrinsic-call encoding (ExprApp "__string_concat") would have shifted the
ordinals; the dedicated node avoids that. opt.ml folds its sub-expressions;
interp.ml handles it defensively as ordinary String ++.

The 8a guard is retained as a backstop: any String ++ reaching codegen
un-elaborated still errors loudly rather than emitting garbage.

Tests: tests/codegen/string_concat.{affine,mjs} — executable wasm parity,
byte-exact via the slice-1 reader: the "ab" ++ "cd" byte-2 = 99 regression
(was 2), the var-var case the guard could not catch, chained a ++ b ++ c,
and empty operands; oracle 6513269. test/test_e2e.ml "E2E String-wall
slice 8 guard" gains a lowers-after-elaboration case. Verified: full
run_codegen_wasm_tests.sh green incl. list_concat + slices 1-7 + effect
tests; string ++ correct in if/match/fn/nested contexts.

Design + ledger: proposals/DESIGN-string-concat.adoc (8b LANDED),
proposals/MIGRATION-PLAN.adoc.

https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s

Author: claude

bin/main.ml

@@ -675,7 +675,11 @@ let compile_file face json wasm_gc vscode_ext vscode_adapter vscode_no_lc
                 Affinescript.Wasm_gc_encode.write_gc_module_to_file output gc_module
             end else if Filename.check_suffix output ".cjs" then begin
               (* Issue #35 Phase 1: Node-CJS shim around the compiled wasm. *)
-              let optimized_prog = Affinescript.Opt.fold_constants_program prog in
+              (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
+            let optimized_prog = Affinescript.Opt.fold_constants_program prog in
               match Affinescript.Codegen.generate_module ~loader optimized_prog with
               | Error e ->
                 add { severity = Error; code = "E0810";
@@ -694,7 +698,11 @@ let compile_file face json wasm_gc vscode_ext vscode_adapter vscode_no_lc
                 output_string oc cjs;
                 close_out oc
             end else begin
-              let optimized_prog = Affinescript.Opt.fold_constants_program prog in
+              (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
+            let optimized_prog = Affinescript.Opt.fold_constants_program prog in
               match Affinescript.Codegen.generate_module ~loader optimized_prog with
               | Error e ->
                 add { severity = Error; code = "E0801";
@@ -908,7 +916,11 @@ let compile_file face json wasm_gc vscode_ext vscode_adapter vscode_no_lc
                 `Ok ())
             else if Filename.check_suffix output ".cjs" then
               (* Issue #35 Phase 1: Node-CJS shim around the compiled wasm. *)
-              let optimized_prog = Affinescript.Opt.fold_constants_program prog in
+              (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
+            let optimized_prog = Affinescript.Opt.fold_constants_program prog in
               (match Affinescript.Codegen.generate_module ~loader optimized_prog with
               | Error e ->
                 Format.eprintf "@[<v>Node-CJS codegen error: %s@]@."
@@ -929,7 +941,11 @@ let compile_file face json wasm_gc vscode_ext vscode_adapter vscode_no_lc
                   (if vscode_ext then ", --vscode-extension" else "");
                 `Ok ())
             else
-              let optimized_prog = Affinescript.Opt.fold_constants_program prog in
+              (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
+            let optimized_prog = Affinescript.Opt.fold_constants_program prog in
               (match Affinescript.Codegen.generate_module ~loader optimized_prog with
               | Error e ->
                 Format.eprintf "@[<v>Code generation error: %s@]@."
@@ -1086,6 +1102,10 @@ let compile_to_wasm_module face path
               (Affinescript.Face.format_quantity_error face err);
             Error "Quantity error"
           | Ok () ->
+            (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
             let optimized_prog = Affinescript.Opt.fold_constants_program prog in
             (match Affinescript.Codegen.generate_module ~loader optimized_prog with
             | Error e ->
@@ -1146,6 +1166,10 @@ let verify_file face path =
               (Affinescript.Face.format_quantity_error face err);
             `Error (false, "Quantity error")
           | Ok () ->
+            (* String-wall slice 8b: rewrite String `++` to ExprStringConcat
+               (byte-concat) for the wasm backend before const-folding. No-op
+               unless typecheck recorded String-concat sites. *)
+            let prog = Affinescript.Typecheck.elaborate_string_concat prog in
             let optimized_prog = Affinescript.Opt.fold_constants_program prog in
             (match Affinescript.Codegen.generate_module ~loader optimized_prog with
             | Error e ->

lib/ast.ml

@@ -143,6 +143,15 @@ type expr =
     }
   | ExprRowRestrict of expr * ident                  (** e \ field *)
   | ExprBinary of expr * binary_op * expr
+  | ExprStringConcat of expr * expr
+      (** String concatenation, `a ++ b` where both sides are `String`.
+          Not produced by the parser: it is introduced by a post-typecheck
+          *elaboration* (see {!Typecheck.elaborate_string_concat}) that
+          rewrites the String case of the polymorphic `++` (`ExprBinary (_,
+          OpConcat, _)`) into this node, so the wasm backend can lower it as
+          byte concatenation rather than the list-element copy used for array
+          `++`. The interpreter and non-wasm backends treat it as ordinary
+          string concatenation. String-wall slice 8b. *)
   | ExprUnary of unary_op * expr
   | ExprBlock of block
   | ExprReturn of expr option

lib/codegen.ml

@@ -275,6 +275,8 @@ let rec find_free_vars (bound_vars : string list) (expr : expr) : string list =
     if List.mem id.name bound_vars then [] else [id.name]
   | ExprBinary (e1, _, e2) ->
     find_free_vars bound_vars e1 @ find_free_vars bound_vars e2
+  | ExprStringConcat (e1, e2) ->
+    find_free_vars bound_vars e1 @ find_free_vars bound_vars e2
   | ExprUnary (_, e) ->
     find_free_vars bound_vars e
   | ExprIf ei ->
@@ -562,6 +564,65 @@ let rec gen_expr (ctx : context) (expr : expr) : (context * instr list) result =
     in
     Ok (ctxA, code)
 
+  | ExprStringConcat (left, right) ->
+    (* String byte-concatenation `a ++ b` (both `String`). String-wall slice
+       8b — the type-directed lowering the slice-8a guard stood in for.
+       Introduced by Typecheck.elaborate_string_concat for the String case of
+       the polymorphic `++`, so codegen no longer has to guess string-vs-list.
+
+       String layout (slices 1-7): `[len@+0][utf8 byte i @ +4+i]`. This
+       mirrors the list-concat handler above but copies *1-byte* elements past
+       a *single* length word, instead of 4-byte i32 elements — which is
+       exactly the bug the guard caught: the list path copied a string's
+       [len][utf8] as i32 elements, so `"ab" ++ "cd"` read byte 2 as the
+       length word of "cd" (= 2) instead of 'c' (= 99). Allocate 4 + la + lb
+       bytes, write the length word, copy a's then b's bytes. *)
+    let* (ctx1, left_code)  = gen_expr ctx  left  in
+    let* (ctx2, right_code) = gen_expr ctx1 right in
+    let (ctx3, heap_idx) = ensure_heap_ptr ctx2 in
+    let (ctx4, a)    = alloc_local ctx3 "__scat_a"    in
+    let (ctx5, b)    = alloc_local ctx4 "__scat_b"    in
+    let (ctx6, la)   = alloc_local ctx5 "__scat_la"   in
+    let (ctx7, lb)   = alloc_local ctx6 "__scat_lb"   in
+    let (ctx8, dst)  = alloc_local ctx7 "__scat_dst"  in
+    let (ctx9, k)    = alloc_local ctx8 "__scat_k"    in
+    let (ctxA, zero) = alloc_local ctx9 "__scat_zero" in
+    let copy_bytes src_ptr count dst_base_off =
+      (* for k in 0..count: dst[4 + dst_base_off + k] = src[4 + k]
+         (the +4 that skips the length word is folded into the load/store
+         static offset, matching the slice-1..7 byte idiom). *)
+      [ I32Const 0l; LocalSet k;
+        Block (BtEmpty, [ Loop (BtEmpty, [
+          LocalGet k; LocalGet count; I32GeS; BrIf 1;
+          (* dst slot addr (pre-+4): dst + dst_base_off + k *)
+          LocalGet dst; LocalGet dst_base_off; I32Add; LocalGet k; I32Add;
+          (* value: byte at src + k (+4 via the load offset) *)
+          LocalGet src_ptr; LocalGet k; I32Add;
+          I32Load8U (0, 4);
+          I32Store8 (0, 4);
+          LocalGet k; I32Const 1l; I32Add; LocalSet k;
+          Br 0 ]) ]) ]
+    in
+    let code =
+      left_code @ [LocalSet a] @ right_code @ [LocalSet b] @
+      [ LocalGet a; I32Load (2, 0); LocalSet la;
+        LocalGet b; I32Load (2, 0); LocalSet lb;
+        I32Const 0l; LocalSet zero;
+        (* dst = heap; heap += 4 + (la + lb) *)
+        GlobalGet heap_idx; LocalSet dst;
+        GlobalGet heap_idx;
+        I32Const 4l;
+        LocalGet la; LocalGet lb; I32Add;
+        I32Add; I32Add;
+        GlobalSet heap_idx;
+        (* dst length word = la + lb *)
+        LocalGet dst; LocalGet la; LocalGet lb; I32Add; I32Store (2, 0) ]
+      @ copy_bytes a la zero   (* dst[0..la)  := a's bytes *)
+      @ copy_bytes b lb la     (* dst[la..)   := b's bytes *)
+      @ [ LocalGet dst ]
+    in
+    Ok (ctxA, code)
+
   | ExprBinary (left, op, right) ->
     let* (ctx', left_code) = gen_expr ctx left in
     let* (ctx'', right_code) = gen_expr ctx' right in

lib/effect_sites.ml

@@ -73,7 +73,11 @@ let rec visit_expr (visit : expr -> unit) (e : expr) : unit =
   | ExprField (e, _) | ExprTupleIndex (e, _) | ExprRowRestrict (e, _)
   | ExprSpan (e, _) | ExprUnary (_, e) ->
     go_expr e
-  | ExprIndex (a, b) | ExprBinary (a, _, b) ->
+  | ExprIndex (a, b) | ExprBinary (a, _, b) | ExprStringConcat (a, b) ->
+    (* ExprStringConcat (slice 8b) recurses like ExprBinary and is NOT a call
+       site: string `++` is not an effect operation, so keeping it out of the
+       ExprApp census preserves effect-ordinal parity between the interpreter
+       (which sees the original ExprBinary) and the wasm backend. *)
     go_expr a;
     go_expr b
   | ExprTuple es | ExprArray es -> List.iter go_expr es

lib/interp.ml

@@ -132,6 +132,12 @@ let rec eval (env : env) (expr : expr) : value result =
     let* arg_vals = eval_list env args in
     apply_function func_val arg_vals
 
+  | ExprStringConcat (left, right) ->
+    (* String-wall slice 8b: the interpreter is the oracle and never sees the
+       wasm-only elaboration, but handle it defensively as ordinary String
+       `++` so the node has identical semantics in every backend. *)
+    eval env (ExprBinary (left, OpConcat, right))
+
   | ExprBinary (left, op, right) ->
     let* left_val = eval env left in
     let* right_val = eval env right in

lib/opt.ml

@@ -61,6 +61,16 @@ let rec fold_constants_expr (expr : expr) : expr =
     else
       ExprBinary (left', op, right')
 
+  (* String-wall slice 8b: fold sub-expressions of a String concat (the node
+     itself isn't a constant). Introduced post-typecheck on the wasm path. *)
+  | ExprStringConcat (left, right) ->
+    let left' = fold_constants_expr left in
+    let right' = fold_constants_expr right in
+    if left == left' && right == right' then
+      expr
+    else
+      ExprStringConcat (left', right')
+
   | ExprUnary (op, operand) ->
     let operand' = fold_constants_expr operand in
     if operand == operand' then

lib/typecheck.ml

@@ -736,6 +736,26 @@ and type_of_literal (lit : literal) : ty =
   | LitString _ -> ty_string
   | LitUnit _ -> ty_unit
 
+(** String-wall slice 8b. Physical-identity record of the `++` ([OpConcat])
+    nodes that typed as {b String} concatenation (rather than array concat).
+    Populated by {!synth} while checking, consumed by
+    {!elaborate_string_concat} to rewrite exactly those nodes into
+    {!Ast.ExprStringConcat} for the byte-concat wasm lowering.
+
+    Keyed by physical identity ([==], via [List.memq]) and not by span/value:
+    [ExprBinary] carries no span, and two distinct same-text `++` occurrences
+    are value-equal. This is sound because typecheck and the elaboration run
+    over the {e same} program object — [parse_with_face]'s lowered [prog],
+    shared by resolve/typecheck/codegen — so the node [synth] records is
+    physically the node the elaboration rewrites. Stale entries from a prior
+    compile never match the current [prog]'s nodes, so accumulation across
+    compiles is harmless; {!elaborate_string_concat} clears the list when it
+    consumes it. *)
+let string_concat_sites : expr list ref = ref []
+
+(** Discard any recorded String-concat sites (e.g. before re-checking). *)
+let reset_string_concat_sites () : unit = string_concat_sites := []
+
 (** {1 Expression synthesis (mode ⇒)} *)
 
 (** Synthesize a type for an expression. *)
@@ -1015,7 +1035,7 @@ let rec synth (ctx : context) (expr : expr) : ty result =
      synthesise lhs, walk through repr to pierce variables; if it's a Float,
      pin rhs to Float and return the matching result type; otherwise fall
      through to the legacy [type_of_binop] path which is Int-monomorphic. *)
-  | ExprBinary (lhs, op, rhs) ->
+  | ExprBinary (lhs, op, rhs) as concat_node ->
     let arith_or_bitwise = match op with
       | OpAdd | OpSub | OpMul | OpDiv | OpMod
       | OpBitAnd | OpBitOr | OpBitXor | OpShl | OpShr -> true
@@ -1065,6 +1085,10 @@ let rec synth (ctx : context) (expr : expr) : ty result =
          Ok (TApp (TCon "Array", [elem]))
        | TCon "String" ->
          let* () = check ctx rhs ty_string in
+         (* String-wall slice 8b: record this `++` node (physical identity)
+            as a String concat, so elaborate_string_concat can rewrite it to
+            ExprStringConcat for the byte-concat wasm lowering. *)
+         string_concat_sites := concat_node :: !string_concat_sites;
          Ok ty_string
        | _ ->
          (* lhs type not yet determined (e.g. `let mut acc = []`):
@@ -1077,6 +1101,8 @@ let rec synth (ctx : context) (expr : expr) : ty result =
           | _ ->
             let* () = unify_or_err lhs_ty ty_string in
             let* () = unify_or_err rhs_ty ty_string in
+            (* Slice 8b: also a String concat (lhs was undetermined). *)
+            string_concat_sites := concat_node :: !string_concat_sites;
             Ok ty_string))
     end else begin
       let (lhs_ty, rhs_ty, result_ty) = type_of_binop op in
@@ -1421,6 +1447,121 @@ and synth_and_unify (ctx : context) (expr : expr) (expected : ty) : unit result
   let* got = synth ctx expr in
   unify_or_err expected got
 
+(** {1 String-concat elaboration (slice 8b)} *)
+
+(* Rewrite every `++` node {!synth} recorded as a String concat into
+   [ExprStringConcat], leaving array `++` as [ExprBinary _ OpConcat _]. The
+   traversal mirrors {!Resolve.lower_expr} exactly so it is total over the
+   expression grammar — any constructor it failed to descend into would leave
+   a String `++` un-elaborated, where the slice-8a guard would (loudly) catch
+   the obvious cases and a var-var case could still miscompile. *)
+let rec elab_expr (e : expr) : expr =
+  match e with
+  | ExprBinary (l, op, r) ->
+    let l' = elab_expr l in
+    let r' = elab_expr r in
+    if List.memq e !string_concat_sites
+    then ExprStringConcat (l', r')
+    else ExprBinary (l', op, r')
+  | ExprStringConcat (l, r) -> ExprStringConcat (elab_expr l, elab_expr r)
+  | ExprSpan (e', sp) -> ExprSpan (elab_expr e', sp)
+  | ExprLit _ | ExprVar _ | ExprVariant _ -> e
+  | ExprField (base, fld) -> ExprField (elab_expr base, fld)
+  | ExprLet r ->
+    ExprLet { r with el_value = elab_expr r.el_value;
+                     el_body = Option.map elab_expr r.el_body }
+  | ExprIf r ->
+    ExprIf { ei_cond = elab_expr r.ei_cond;
+             ei_then = elab_expr r.ei_then;
+             ei_else = Option.map elab_expr r.ei_else }
+  | ExprMatch r ->
+    ExprMatch { em_scrutinee = elab_expr r.em_scrutinee;
+                em_arms = List.map elab_arm r.em_arms }
+  | ExprLambda r -> ExprLambda { r with elam_body = elab_expr r.elam_body }
+  | ExprApp (f, args) -> ExprApp (elab_expr f, List.map elab_expr args)
+  | ExprTupleIndex (e1, i) -> ExprTupleIndex (elab_expr e1, i)
+  | ExprIndex (a, i) -> ExprIndex (elab_expr a, elab_expr i)
+  | ExprTuple es -> ExprTuple (List.map elab_expr es)
+  | ExprArray es -> ExprArray (List.map elab_expr es)
+  | ExprRecord r ->
+    ExprRecord
+      { er_fields =
+          List.map (fun (id, eo) -> (id, Option.map elab_expr eo)) r.er_fields;
+        er_spread = Option.map elab_expr r.er_spread }
+  | ExprRowRestrict (e1, id) -> ExprRowRestrict (elab_expr e1, id)
+  | ExprUnary (op, e1) -> ExprUnary (op, elab_expr e1)
+  | ExprBlock b -> ExprBlock (elab_block b)
+  | ExprReturn eo -> ExprReturn (Option.map elab_expr eo)
+  | ExprBreak _ | ExprContinue _ -> e
+  | ExprTry r ->
+    ExprTry { et_body = elab_block r.et_body;
+              et_catch = Option.map (List.map elab_arm) r.et_catch;
+              et_finally = Option.map elab_block r.et_finally }
+  | ExprHandle r ->
+    ExprHandle { eh_body = elab_expr r.eh_body;
+                 eh_handlers = List.map elab_handler r.eh_handlers }
+  | ExprResume eo -> ExprResume (Option.map elab_expr eo)
+  | ExprUnsafe ops -> ExprUnsafe (List.map elab_unsafe ops)
+
+and elab_arm a =
+  { a with ma_guard = Option.map elab_expr a.ma_guard;
+           ma_body = elab_expr a.ma_body }
+
+and elab_handler = function
+  | HandlerReturn (p, e) -> HandlerReturn (p, elab_expr e)
+  | HandlerOp (id, ps, e) -> HandlerOp (id, ps, elab_expr e)
+
+and elab_unsafe = function
+  | UnsafeRead e -> UnsafeRead (elab_expr e)
+  | UnsafeWrite (a, b) -> UnsafeWrite (elab_expr a, elab_expr b)
+  | UnsafeOffset (a, b) -> UnsafeOffset (elab_expr a, elab_expr b)
+  | UnsafeTransmute (t1, t2, e) -> UnsafeTransmute (t1, t2, elab_expr e)
+  | UnsafeForget e -> UnsafeForget (elab_expr e)
+
+and elab_block b =
+  { blk_stmts = List.map elab_stmt b.blk_stmts;
+    blk_expr = Option.map elab_expr b.blk_expr }
+
+and elab_stmt = function
+  | StmtLet r -> StmtLet { r with sl_value = elab_expr r.sl_value }
+  | StmtExpr e -> StmtExpr (elab_expr e)
+  | StmtAssign (a, op, b) -> StmtAssign (elab_expr a, op, elab_expr b)
+  | StmtWhile (e, b) -> StmtWhile (elab_expr e, elab_block b)
+  | StmtFor (p, e, b) -> StmtFor (p, elab_expr e, elab_block b)
+
+let elab_fn_body = function
+  | FnBlock b -> FnBlock (elab_block b)
+  | FnExpr e -> FnExpr (elab_expr e)
+  | FnExtern -> FnExtern
+
+let elab_top = function
+  | TopFn fd -> TopFn { fd with fd_body = elab_fn_body fd.fd_body }
+  | TopConst r -> TopConst { r with tc_value = elab_expr r.tc_value }
+  | TopImpl ib ->
+    TopImpl { ib with ib_items = List.map (function
+      | ImplFn fd -> ImplFn { fd with fd_body = elab_fn_body fd.fd_body }
+      | ImplType _ as it -> it) ib.ib_items }
+  | TopTrait td ->
+    TopTrait { td with trd_items = List.map (function
+      | TraitFnDefault fd ->
+        TraitFnDefault { fd with fd_body = elab_fn_body fd.fd_body }
+      | other -> other) td.trd_items }
+  | (TopType _ | TopEffect _ | TopExternType _ | TopExternFn _) as t -> t
+
+(** Rewrite the String case of `++` to {!Ast.ExprStringConcat} across [program],
+    using the sites {!synth} recorded during type-checking. Pure apart from
+    clearing the recorded sites; returns [program] unchanged when nothing was
+    recorded. Intended to run on the wasm-codegen path only (the interpreter
+    and other backends handle String `++` directly). *)
+let elaborate_string_concat (program : program) : program =
+  let result =
+    match !string_concat_sites with
+    | [] -> program
+    | _ -> { program with prog_decls = List.map elab_top program.prog_decls }
+  in
+  reset_string_concat_sites ();
+  result
+
 (** {1 Declaration checking} *)
 
 (** Register built-in types and functions. *)