Skip to content

Commit b7c7b31

Browse files
hyperpolymathclaude
hyperpolymath
and
claude
authored
compiler: string-wall slice 3 — string_sub (runtime-length copy) (#569)
## Phase F slice 3 — variable-string backend wall (runtime-length copy) Third slice of the **variable-string backend** wall (`proposals/MIGRATION-PLAN.adoc` §"The two walls"). Follows slice 1 (read-side indexing, #567) and slice 2 (single-byte construction, #568). Adds the wasm-backend lowering for `string_sub`, which introduces the **two capabilities the rest of the string wall needs**: a *runtime-sized* heap allocation and a *byte-copy loop* — both modelled on the existing list `++` lowering (the canonical allocate-then-copy idiom in `lib/codegen.ml`). `string_sub` was already wired in resolve/typecheck/interp but fell through `gen_call`'s dispatch (`UnboundVariable` at codegen). ### The lowering (`lib/codegen.ml`) Reproduces the interp clamps exactly: ``` slen = String.length s start' = max 0 (min start slen) length' = max 0 (min length (slen - start')) ``` then: 1. **Runtime-sized** allocation: `dst = heap; heap += 4 + length'` (the bump allocator with a runtime byte count, exactly as list `++` allocates `4 + (la+lb)*4`). 2. Store `length'` at `[dst+0]`. 3. **Copy loop**: `Block [ Loop [ k>=length' ? break; dst[4+k] = src[4+start'+k]; k++; continue ] ]`, byte-wise via `I32Load8U`/`I32Store8` — the same `Block`/`Loop`/`BrIf 1`/`Br 0` idiom as the list-`++` element copy, with a 1-byte stride. `min`/`max` use `Select` over the operand pair (operands are locals/constants with no side effects, so evaluating both arms is safe — unlike slice 1's bounds-guarded load, which needed `If`). All clamps are non-negative, so no negative addresses are formed; `length' == 0` exits the loop immediately and yields the empty string. ### Parity (wasm vs interp oracle) — 8/8 `scca` = `string_char_code_at` (the slice-1 reader): | Expression | interp | wasm | |---|---|---| | `scca(string_sub("hello",1,3), 0)` ('e') | 101 | 101 | | `scca(string_sub("hello",1,3), 2)` ('l') | 108 | 108 | | `string_length(string_sub("hello",1,3))` | 3 | 3 | | `string_length(string_sub("hello",0,5))` (full) | 5 | 5 | | `string_length(string_sub("hello",2,100))` (clamp length) | 3 | 3 | | `string_length(string_sub("hello",10,3))` (clamp start) | 0 | 0 | | `scca(string_sub("hello",-1,2), 0)` (neg start → 0, 'h') | 104 | 104 | | `string_length(string_sub("hello",1,0))` (zero length) | 0 | 0 | ### Tests - `test/test_e2e.ml` group **"E2E String-wall slice 3 (string_sub)"** — eight interp-oracle cases (extraction, length, length-clamp, start-clamp, negative-start, zero-length). Runs under `dune runtest`. The interp consumer coverage mandated by `.claude/CLAUDE.md` §"Test-fixture hygiene". - `tests/codegen/string_sub.affine` + `tests/codegen/test_string_sub.mjs` — executable wasm parity via `tools/run_codegen_wasm_tests.sh` (CI). Local verification: full `run_codegen_wasm_tests.sh` green (all three string harnesses, slices 1+2+3, pass; no sibling regressions); interp oracle confirmed against the real library API; wasm executed under Node. `dune runtest` couldn't run in-sandbox (no `alcotest`), but the new tests' logic + API usage was validated against the real `affinescript` library. ### Scope Runtime alloc + copy loop are now established string primitives. Next slices reuse them: concat (`++`/`string_concat`, two copy loops), `string_find` (read-side scan, no alloc), case-fold (copy-with-transform), and the polymorphic `slice` (needs compile-time array-vs-string dispatch). Evidence: `proposals/EVIDENCE-stringwall-slice3.adoc`. https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s --- _Generated by [Claude Code](https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s)_ Co-authored-by: Claude <noreply@anthropic.com>
1 parent 7ada7b3 commit b7c7b31

6 files changed

Lines changed: 347 additions & 5 deletions

File tree

‎lib/codegen.ml‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -981,6 +981,72 @@ let rec gen_expr (ctx : context) (expr : expr) : (context * instr list) result =
981981
in
982982
Ok (ctx_v, code)
983983

984+
| ExprVar id when id.name = "string_sub"
985+
&& List.length args = 3 ->
986+
(* PHASE-F string-wall slice 3: the runtime-length copy op.
987+
`string_sub(s, start, length)` returns the substring of `length`
988+
bytes from `start`, with both clamped to the source — matching the
989+
interp oracle (lib/interp.ml):
990+
slen = len s
991+
start' = max 0 (min start slen)
992+
length'= max 0 (min length (slen - start'))
993+
This introduces the two capabilities the rest of the string wall
994+
needs: a *runtime-sized* heap allocation (4 + length' bytes) and a
995+
*byte-copy loop*, both modelled on the list `++` lowering (the
996+
canonical allocate-then-copy idiom in this file). `min`/`max` use
997+
`Select` over the operand pair (no side effects). *)
998+
let* (ctx1, s_code) = gen_expr ctx (List.nth args 0) in
999+
let* (ctx2, start_code) = gen_expr ctx1 (List.nth args 1) in
1000+
let* (ctx3, len_code) = gen_expr ctx2 (List.nth args 2) in
1001+
let (ctx4, heap_idx) = ensure_heap_ptr ctx3 in
1002+
let (c5, src) = alloc_local ctx4 "__ssub_src" in
1003+
let (c6, slen) = alloc_local c5 "__ssub_slen" in
1004+
let (c7, start_) = alloc_local c6 "__ssub_start" in
1005+
let (c8, len_) = alloc_local c7 "__ssub_len" in
1006+
let (c9, dst) = alloc_local c8 "__ssub_dst" in
1007+
let (c10, k) = alloc_local c9 "__ssub_k" in
1008+
let (c11, tmp) = alloc_local c10 "__ssub_tmp" in
1009+
(* min(a,b) via Select: stack [a; b; a<b] -> a<b ? a : b *)
1010+
let imin_into a_get b_get dst_local =
1011+
a_get @ b_get @ a_get @ b_get @ [ I32LtS; Select; LocalSet dst_local ] in
1012+
(* max(x, 0) via Select: stack [x; 0; x>0] -> x>0 ? x : 0 *)
1013+
let imax0_into x_get dst_local =
1014+
x_get @ [ I32Const 0l ] @ x_get @ [ I32Const 0l; I32GtS; Select; LocalSet dst_local ] in
1015+
let code =
1016+
s_code @ [LocalSet src] @
1017+
start_code @ [LocalSet start_] @ (* start_ temporarily = raw start *)
1018+
len_code @ [LocalSet len_] @ (* len_ temporarily = raw length *)
1019+
(* slen = src[0] *)
1020+
[ LocalGet src; I32Load (2, 0); LocalSet slen ] @
1021+
(* start' = max(0, min(raw_start, slen)) *)
1022+
imin_into [LocalGet start_] [LocalGet slen] tmp @
1023+
imax0_into [LocalGet tmp] start_ @
1024+
(* length' = max(0, min(raw_length, slen - start')) *)
1025+
imin_into [LocalGet len_]
1026+
[LocalGet slen; LocalGet start_; I32Sub] tmp @
1027+
imax0_into [LocalGet tmp] len_ @
1028+
(* dst = heap; heap += 4 + length' *)
1029+
[ GlobalGet heap_idx; LocalSet dst;
1030+
GlobalGet heap_idx; I32Const 4l; LocalGet len_; I32Add; I32Add;
1031+
GlobalSet heap_idx;
1032+
(* dst[0] = length' *)
1033+
LocalGet dst; LocalGet len_; I32Store (2, 0) ] @
1034+
(* copy loop: for k in 0..length': dst[4+k] = src[4 + start' + k] *)
1035+
[ I32Const 0l; LocalSet k;
1036+
Block (BtEmpty, [ Loop (BtEmpty, [
1037+
LocalGet k; LocalGet len_; I32GeS; BrIf 1;
1038+
(* dst slot address (store uses static +4): dst + k *)
1039+
LocalGet dst; LocalGet k; I32Add;
1040+
(* source byte (load uses static +4): src + start' + k *)
1041+
LocalGet src; LocalGet start_; I32Add; LocalGet k; I32Add;
1042+
I32Load8U (0, 4);
1043+
I32Store8 (0, 4);
1044+
LocalGet k; I32Const 1l; I32Add; LocalSet k;
1045+
Br 0 ]) ]) ] @
1046+
[ LocalGet dst ]
1047+
in
1048+
Ok (c11, code)
1049+
9841050
| ExprVar id when (id.name = "env_at" || id.name = "arg_at")
9851051
&& List.length args = 1 ->
9861052
(* ADR-015 S5 (#180): env_at(i) / arg_at(i) — fetch the i-th

‎proposals/EVIDENCE-stringwall-slice3.adoc‎

Lines changed: 140 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,140 @@
1+
// SPDX-License-Identifier: MPL-2.0
2+
// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
3+
= Phase F — string-wall slice 3: string_sub (evidence)
4+
:toc: macro
5+
6+
[IMPORTANT]
7+
====
8+
*Slice landed: the runtime-length copy op.* `string_sub(s, start, length)` —
9+
already wired in resolve/typecheck/interp — gained a wasm-backend lowering
10+
that introduces the two capabilities the rest of the string wall needs: a
11+
*runtime-sized* heap allocation and a *byte-copy loop*. Both are modelled on
12+
the existing list `++` lowering (the canonical allocate-then-copy idiom in
13+
`lib/codegen.ml`).
14+
15+
Third slice of the *variable-string backend* wall
16+
(`proposals/MIGRATION-PLAN.adoc` §"The two walls", Phase F). With runtime
17+
allocation + copy now in hand, the remaining write-side ops (concat, case-fold)
18+
and the read-side scans (`startsWith`, `string_find`) reuse these idioms.
19+
====
20+
21+
toc::[]
22+
23+
== What was missing
24+
25+
[cols="2,1,1,1,1",options="header"]
26+
|===
27+
| Builtin | resolve.ml | typecheck.ml | interp.ml | codegen.ml (wasm)
28+
| `string_char_code_at` / `char_to_int` | ✓ | ✓ | ✓ | ✓ (slice 1)
29+
| `string_from_char_code` | ✓ | ✓ | ✓ | ✓ (slice 2)
30+
| `string_sub` | ✓ | ✓ | ✓ | *was missing -> added*
31+
|===
32+
33+
Before this slice it failed at codegen:
34+
35+
----
36+
Code generation error: (Codegen.UnboundVariable
37+
"Function or variable not found: string_sub")
38+
----
39+
40+
== The lowering (lib/codegen.ml)
41+
42+
Interp oracle (lib/interp.ml):
43+
44+
----
45+
slen = String.length s
46+
start' = max 0 (min start slen)
47+
length' = max 0 (min length (slen - start'))
48+
String.sub s start' length'
49+
----
50+
51+
The wasm lowering, on the `[len: i32 LE][utf8]` ABI:
52+
53+
. Evaluate `s` (-> base pointer), `start`, `length`; load `slen` from `[src+0]`.
54+
. Clamp: `start' = max(0, min(start, slen))`, then
55+
`length' = max(0, min(length, slen - start'))`. `min`/`max` use `Select`
56+
over the operand pair (the operands are locals/constants — no side effects,
57+
so evaluating both arms is safe, unlike the bounds-guarded load in slice 1).
58+
. *Runtime-sized* allocation: `dst = heap; heap += 4 + length'` — the bump
59+
allocator (`ensure_heap_ptr`) with a runtime byte count, exactly as list
60+
`++` allocates `4 + (la+lb)*4`.
61+
. Store `length'` at `[dst+0]`.
62+
. *Copy loop* (`Block [ Loop [ k>=length' ? break; dst[4+k] = src[4+start'+k];
63+
k++; continue ] ]`), byte-wise via `I32Load8U` / `I32Store8`. Same
64+
`Block`/`Loop`/`BrIf 1`/`Br 0` idiom as the list-`++` element copy, with a
65+
1-byte stride instead of 4.
66+
. Return `dst`.
67+
68+
All clamps are non-negative (`max 0`), so no negative addresses are formed.
69+
`length' = 0` exits the loop immediately and yields the empty string.
70+
71+
== Gate evidence
72+
73+
=== Gate 1 — builds
74+
75+
`dune build bin/main.exe` exit 0. The previously-failing op now compiles and
76+
round-trips with the slice-1 reader.
77+
78+
=== Gate 2 — parity (wasm vs interpreter oracle)
79+
80+
Same inputs through both backends agree across normal extraction, both
81+
clamps, negative start, and zero length. Interp oracle confirmed against the
82+
real library API; wasm executed under Node.
83+
84+
[cols="4,1,1",options="header"]
85+
|===
86+
| Expression | interp | wasm
87+
| `scca(string_sub("hello",1,3), 0)` ('e') | 101 | 101
88+
| `scca(string_sub("hello",1,3), 2)` ('l') | 108 | 108
89+
| `string_length(string_sub("hello",1,3))` | 3 | 3
90+
| `string_length(string_sub("hello",0,5))` (full) | 5 | 5
91+
| `string_length(string_sub("hello",2,100))` (clamp length) | 3 | 3
92+
| `string_length(string_sub("hello",10,3))` (clamp start) | 0 | 0
93+
| `scca(string_sub("hello",-1,2), 0)` (neg start -> 0, 'h') | 104 | 104
94+
| `string_length(string_sub("hello",1,0))` (zero length) | 0 | 0
95+
|===
96+
97+
(`scca` = `string_char_code_at`, the slice-1 reader.)
98+
99+
The packed fixture `tests/codegen/string_sub.affine` returns `6843501`
100+
(positional pack of three round-tripped bytes + four length probes); both
101+
backends produce it.
102+
103+
== Tests added
104+
105+
* `test/test_e2e.ml` — group *"E2E String-wall slice 3 (string_sub)"*: eight
106+
interp-oracle cases (extraction, length, length-clamp, start-clamp,
107+
negative-start, zero-length). Runs under `dune runtest`. The interp consumer
108+
coverage mandated by `.claude/CLAUDE.md` §"Test-fixture hygiene".
109+
* `tests/codegen/string_sub.affine` + `tests/codegen/test_string_sub.mjs` —
110+
executable wasm parity, run by `tools/run_codegen_wasm_tests.sh` (CI).
111+
112+
Full `tools/run_codegen_wasm_tests.sh` run: *all* codegen WASM tests pass
113+
(slices 1, 2, and 3 string harnesses), no sibling regressions.
114+
115+
== Corpus impact
116+
117+
The runtime-length allocation + byte-copy loop are now established string
118+
primitives. This unblocks substring extraction directly, and gives the next
119+
slices their building blocks:
120+
121+
* *Concatenation* (`++` on strings, `string_concat`) — allocate
122+
`4 + la + lb`, copy both byte ranges (two copy loops, like list `++`).
123+
* *Case-folding* (`to_lowercase` / `to_uppercase`) — allocate `4 + slen`,
124+
copy with a per-byte transform in the loop body.
125+
* *Scans* (`startsWith`, `string_find`) — comparison loops over slice-1
126+
indexing; no allocation.
127+
128+
== Next slices (variable-string backend wall)
129+
130+
. *Concatenation* — `string_concat` / `++` on strings (two copy loops into a
131+
`4 + la + lb` allocation).
132+
. *Scans* — `string_find` (substring search returning an index), the read-side
133+
loop with no allocation.
134+
. *Case-folding* — `to_lowercase` / `to_uppercase` (copy-with-transform).
135+
. *`slice`* — the polymorphic (array|string) JS-semantics variant with
136+
negative-index normalisation; needs compile-time array-vs-string dispatch.
137+
138+
Each slice: add the codegen arm, an interp-parity e2e group, and a
139+
`tests/codegen/*.mjs` executable check, then re-run the census and drop the
140+
gated count.

‎proposals/MIGRATION-PLAN.adoc‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -39,10 +39,11 @@ toc::[]
3939
== The two walls (what ultimately gates "CLEAR")
4040

4141
. *Variable-string backend* — `String.length`, read-side *indexing*
42-
(`string_char_code_at` / `char_to_int`, slice 1) and single-byte
43-
*construction* (`string_from_char_code`, slice 2) now lower to wasm (Phase F,
44-
see Ledger); `startsWith` / `string_sub` / `slice` / concat / case-fold
45-
(the *runtime-length* ops) do not yet. Gates every STRING-GATED kernel (e.g.
42+
(`string_char_code_at` / `char_to_int`, slice 1), single-byte *construction*
43+
(`string_from_char_code`, slice 2), and *runtime-length substring*
44+
(`string_sub` — runtime-sized alloc + byte-copy loop, slice 3) now lower to
45+
wasm (Phase F, see Ledger); concat / `++` / `string_find` / case-fold /
46+
polymorphic `slice` do not yet. Gates every STRING-GATED kernel (e.g.
4647
`Kernel_IO`, `DeviceType`, i18n) whose work is building/transforming strings
4748
rather than scanning them. Lives in *this* repo's compiler, so it is
4849
attackable here.
@@ -206,7 +207,8 @@ Heuristic:
206207
| C12 | DONE | Render-glue screens/PixiJS bindings (2026-06-05) — *classified, NO_NEW_BRAINS.* All 43 files are host-side senses. *12 bridge files* wrap already-live wasm brains (companionsrenderlogic, devicesrenderlogic, enemiesrenderlogic, toolspickupsrenderlogic, playerrenderlogic, narrativepopupsrenderlogic, balanceanalyser, locationdata, screenglitchfx, screensrunlooplogic, uirenderlogic, verisimprovenrenderlogic). *23 screen/popup files* are effect-gated PixiJS rendering orchestrators (GameI18n string calls, Motion.animate, mutable refs, Navigation APIs). *4 binding files* (Motion, Pixi, PixiSound, PixiUI) are pure `external` FFI declarations wrapping host-side JS libraries. *Phase Ω cluster sequence (C11→C9→C10→C12) complete.* Genuine compiler gates remain: string wall (71 corpus files — `[len:i32][utf8]` layout already in `codegen.ml:375`, only ops missing), effect wall (111 corpus files). Evidence: `migrated/EVIDENCE-C12.adoc`.
207208
| F (string slice 1) | DONE | String-wall slice 1 — *read-side indexing landed in the wasm backend* (2026-06-12, Opus). `string_char_code_at(s, i)` + `char_to_int(c)` (already wired in resolve/typecheck/interp) gained wasm lowerings on the `[len: i32 LE][utf8]` ABI: byte `i` at `base + 4 + i`, bounds-guarded `If` load, `-1` OOB sentinel shared with the interp oracle; `char_to_int` is the i32 identity. A previously STRING-GATED shape (byte indexing into a literal) now *compiles to wasm and parity-greens* vs the interpreter. *Gates:* G1 builds; G2 parity 7/7 (interp oracle vs wasm: 65/66/67/-1/-1/-1/90); type safety preserved (`char_to_int(65)` still a Char/Int error). Tests: `test/test_e2e.ml` group "E2E String-wall slice 1 (indexing)" (interp, `dune runtest`) + `tests/codegen/string_char_code_at.{affine,…mjs}` (executable wasm parity, full `run_codegen_wasm_tests.sh` green, no regressions). Evidence: `proposals/EVIDENCE-stringwall-slice1.adoc`. Unblocks the *indexing/scan* family; allocation-returning string ops (`string_from_char_code`/`string_sub`/`slice`/concat/case-fold) are later slices. NEXT: allocation-returning ABI (`gen_string_alloc` + `string_from_char_code`).
208209
| F (string slice 2) | DONE | String-wall slice 2 — *write-side ABI landed in the wasm backend* (2026-06-12, Opus). `string_from_char_code(n)` (already wired in resolve/typecheck/interp) gained a wasm lowering: bump-allocate `[len: i32 LE = 1][byte]` where the byte is the low 8 bits of `n` (`I32Store8` does the `land 0xff` mask itself, incl. negatives). First heap-allocating string op; reuses the existing `gen_heap_alloc` bump allocator (no new memory machinery). *Gates:* G1 builds; G2 parity 8/8 (interp vs wasm over masking/NUL/255/256/-1/320/length/OOB-after-construction); round-trips with slice-1's reader. Tests: `test/test_e2e.ml` group "E2E String-wall slice 2 (string_from_char_code)" (interp, `dune runtest`) + `tests/codegen/string_from_char_code.{affine,…mjs}` (executable wasm parity; full `run_codegen_wasm_tests.sh` green, no regressions). Evidence: `proposals/EVIDENCE-stringwall-slice2.adoc`. Read+write byte primitives now both present. NEXT: runtime-length allocation ABI for `string_sub`/`slice` (slice 3).
209-
| F+ | TODO | Remaining string-wall slices (runtime-length alloc ABI -> `string_sub`/`slice` -> `startsWith`/`string_find` -> concat/case-fold), then the effect-codegen wall (module-state / `Date.now` / `Console.log`). *Cluster migration complete; string slices 1+2 landed (read+write byte primitives).*
210+
| F (string slice 3) | DONE | String-wall slice 3 — *runtime-length copy op landed in the wasm backend* (2026-06-12, Opus). `string_sub(s, start, length)` (already wired in resolve/typecheck/interp) gained a wasm lowering introducing the two capabilities the rest of the wall needs: a *runtime-sized* heap allocation (`heap += 4 + length'`) and a *byte-copy loop* (`Block`/`Loop`/`BrIf`/`Br`, `I32Load8U`/`I32Store8`), both modelled on the list `++` allocate-then-copy idiom. Interp clamps reproduced exactly: `start' = max 0 (min start slen)`, `length' = max 0 (min length (slen - start'))` (`min`/`max` via `Select`). *Gates:* G1 builds; G2 parity 8/8 (interp vs wasm over extraction/length/clamp-length/clamp-start/negative-start/zero-length); round-trips with slice-1's reader. Tests: `test/test_e2e.ml` group "E2E String-wall slice 3 (string_sub)" (interp, `dune runtest`) + `tests/codegen/string_sub.{affine,…mjs}` (executable wasm parity; full `run_codegen_wasm_tests.sh` green, no regressions). Evidence: `proposals/EVIDENCE-stringwall-slice3.adoc`. Runtime alloc + copy loop now established. NEXT: concat/`string_find`/case-fold (slice 4) reuse these idioms.
211+
| F+ | TODO | Remaining string-wall slices (concat/`++` -> `string_find` scan -> case-fold -> polymorphic `slice`), then the effect-codegen wall (module-state / `Date.now` / `Console.log`). *Cluster migration complete; string slices 1+2+3 landed (read + single-byte write + runtime-length copy).*
210212
| Ω | TODO (access-gated) | Cutover + ReScript extinction.
211213
|===
212214

‎test/test_e2e.ml‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3786,6 +3786,58 @@ let stringwall_alloc_tests = [
37863786
Alcotest.test_case "index past 1-byte string == -1" `Quick test_stringwall_sfcc_oob;
37873787
]
37883788

3789+
(* ---- PHASE-F string-wall slice 3: string_sub ----
3790+
3791+
`string_sub(s, start, length)` gained a wasm-backend lowering: a
3792+
runtime-sized heap allocation plus a byte-copy loop, with the interp's
3793+
clamp semantics (lib/interp.ml: start' = max 0 (min start slen);
3794+
length' = max 0 (min length (slen - start'))). These pin the interp oracle
3795+
the wasm lowering must reproduce; the result is read back via the slice-1
3796+
reader string_char_code_at and via string_length. *)
3797+
3798+
let test_stringwall_sub_byte0 () =
3799+
Alcotest.(check int) "sub(\"hello\",1,3)[0] == 'e'" 101
3800+
(eval_int_fn "fn f() -> Int { string_char_code_at(string_sub(\"hello\", 1, 3), 0) }")
3801+
3802+
let test_stringwall_sub_byte2 () =
3803+
Alcotest.(check int) "sub(\"hello\",1,3)[2] == 'l'" 108
3804+
(eval_int_fn "fn f() -> Int { string_char_code_at(string_sub(\"hello\", 1, 3), 2) }")
3805+
3806+
let test_stringwall_sub_len () =
3807+
Alcotest.(check int) "string_length(sub(\"hello\",1,3)) == 3" 3
3808+
(eval_int_fn "fn f() -> Int { string_length(string_sub(\"hello\", 1, 3)) }")
3809+
3810+
let test_stringwall_sub_full () =
3811+
Alcotest.(check int) "string_length(sub(\"hello\",0,5)) == 5" 5
3812+
(eval_int_fn "fn f() -> Int { string_length(string_sub(\"hello\", 0, 5)) }")
3813+
3814+
let test_stringwall_sub_clamp_len () =
3815+
Alcotest.(check int) "length clamped to slen-start' == 3" 3
3816+
(eval_int_fn "fn f() -> Int { string_length(string_sub(\"hello\", 2, 100)) }")
3817+
3818+
let test_stringwall_sub_clamp_start () =
3819+
Alcotest.(check int) "start past end -> empty (len 0)" 0
3820+
(eval_int_fn "fn f() -> Int { string_length(string_sub(\"hello\", 10, 3)) }")
3821+
3822+
let test_stringwall_sub_neg_start () =
3823+
Alcotest.(check int) "negative start clamps to 0 -> 'h'" 104
3824+
(eval_int_fn "fn f() -> Int { string_char_code_at(string_sub(\"hello\", -1, 2), 0) }")
3825+
3826+
let test_stringwall_sub_zero_len () =
3827+
Alcotest.(check int) "zero length -> empty (len 0)" 0
3828+
(eval_int_fn "fn f() -> Int { string_length(string_sub(\"hello\", 1, 0)) }")
3829+
3830+
let stringwall_sub_tests = [
3831+
Alcotest.test_case "sub(\"hello\",1,3)[0] == 101" `Quick test_stringwall_sub_byte0;
3832+
Alcotest.test_case "sub(\"hello\",1,3)[2] == 108" `Quick test_stringwall_sub_byte2;
3833+
Alcotest.test_case "len sub(\"hello\",1,3) == 3" `Quick test_stringwall_sub_len;
3834+
Alcotest.test_case "len sub full == 5" `Quick test_stringwall_sub_full;
3835+
Alcotest.test_case "length clamp == 3" `Quick test_stringwall_sub_clamp_len;
3836+
Alcotest.test_case "start clamp -> 0" `Quick test_stringwall_sub_clamp_start;
3837+
Alcotest.test_case "neg start -> 'h'" `Quick test_stringwall_sub_neg_start;
3838+
Alcotest.test_case "zero length -> 0" `Quick test_stringwall_sub_zero_len;
3839+
]
3840+
37893841
(* ---- STDLIB-04b: Throws extern `error<T>` (Refs #329) ----
37903842
37913843
`error<T>(msg: String) -> T / Throws` was declared in
@@ -4895,6 +4947,7 @@ let tests =
48954947
("E2E STDLIB-04e Pure #332", stdlib_04e_pure_tests);
48964948
("E2E String-wall slice 1 (indexing)", stringwall_index_tests);
48974949
("E2E String-wall slice 2 (string_from_char_code)", stringwall_alloc_tests);
4950+
("E2E String-wall slice 3 (string_sub)", stringwall_sub_tests);
48984951
("E2E STDLIB-04b error #329", stdlib_04b_error_tests);
48994952
("E2E Vscode Bindings", vscode_bindings_tests);
49004953
("E2E Array Type Sugar", array_type_tests);

0 commit comments

Comments
 (0)