Skip to content

Commit f510c1f

Browse files
hyperpolymathclaude
hyperpolymath
and
claude
authored
compiler: string-wall slice 1 — read-side string indexing in the wasm backend (#567)
## Phase F slice 1 — variable-string backend wall First slice of the **variable-string backend** wall (`proposals/MIGRATION-PLAN.adoc` §"The two walls"). The idaptik ReScript→AffineScript→wasm migration is gated on two compiler walls; this attacks the string wall's read-side. Adds wasm-backend lowerings for two string builtins that were **already wired in resolve/typecheck/interp** but fell through `gen_call`'s dispatch to the generic named-function path — failing at codegen as `UnboundVariable`: | Builtin | resolve | typecheck | interp | wasm codegen | |---|---|---|---|---| | `string_length` | ✓ | ✓ | ✓ | ✓ (pre-existing) | | `string_char_code_at` | ✓ | ✓ | ✓ | **added** | | `char_to_int` | ✓ | ✓ | ✓ | **added** | ### The lowering (`lib/codegen.ml`) String layout is `[len: i32 LE][utf8 bytes...]`; byte `i` lives at `base + 4 + i`. - **`string_char_code_at(s, i)`** — total function, `-1` on out-of-bounds (the same absent-byte sentinel the interp oracle returns, so both backends agree). The bounds test guards the load via `If` (not `Select`): an OOB `I32Load8U` could trap or read foreign linear memory, so the load must not execute when the index is out of range. - **`char_to_int(c)`** — identity on the wasm value lattice (a `Char` is already an i32 byte code, cf. `LitChar` → `I32Const (Char.code c)`). A previously STRING-GATED shape (byte indexing into a string literal) now compiles to wasm and parity-greens against the interpreter. ### Tests - `test/test_e2e.ml` group **"E2E String-wall slice 1 (indexing)"** — seven interp-oracle cases (in-bounds bytes, both OOB directions, empty string, `char_to_int`). The interp consumer coverage mandated by `.claude/CLAUDE.md` §"Test-fixture hygiene". Runs under `dune runtest`. - `tests/codegen/string_char_code_at.affine` + `tests/codegen/test_string_char_code_at.mjs` — executable **wasm parity** via `tools/run_codegen_wasm_tests.sh` (CI). `main()` returns a positional base-256 pack of the same constants pinned interp-side. Local verification: full `run_codegen_wasm_tests.sh` green (no sibling regressions); interp oracle confirmed against the real library API (`Parse_driver.parse_string` → `Interp.eval_program` → `apply_function`); wasm executed under Node. Type safety preserved — `char_to_int(65)` (Int where Char required) still rejected as a Char/Int unification error. ### Parity (wasm vs interp oracle) | Expression | interp | wasm | |---|---|---| | `string_char_code_at("ABC", 0/1/2)` | 65/66/67 | 65/66/67 | | `string_char_code_at("ABC", -1)` / `("ABC", 9)` / `("", 0)` | -1 | -1 | | `char_to_int('Z')` | 90 | 90 | ### Scope Unblocks the **indexing/scan** family (first-byte dispatch, manual scanning, char-class checks). Allocation-returning string ops (`string_from_char_code`, `string_sub`, `slice`, concat, case-fold) are later slices — next is the allocation-returning ABI (`gen_string_alloc` + `string_from_char_code`). Evidence: `proposals/EVIDENCE-stringwall-slice1.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 3e53f1d commit f510c1f

6 files changed

Lines changed: 347 additions & 5 deletions

File tree

‎lib/codegen.ml‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -907,6 +907,50 @@ let rec gen_expr (ctx : context) (expr : expr) : (context * instr list) result =
907907
let* (ctx_with_arg, arg_code) = gen_expr ctx (List.hd args) in
908908
Ok (ctx_with_arg, arg_code @ [I32Load (2, 0)])
909909

910+
| ExprVar id when id.name = "string_char_code_at"
911+
&& List.length args = 2 ->
912+
(* PHASE-F string-wall slice 1 (proposals/MIGRATION-PLAN.adoc
913+
§"The two walls"). String indexing on the read-side
914+
`[len: i32 LE][utf8 bytes...]` ABI: byte `i` lives at
915+
`base + 4 + i`. Total function — out-of-bounds (i < 0 OR
916+
i >= len) returns -1, matching the interp oracle
917+
(lib/interp.ml `string_char_code_at`) so the absent-byte
918+
sentinel is shared across both backends. The bounds test must
919+
guard the load: an OOB `I32Load8U` could trap or read foreign
920+
linear memory, so this is `If`, not `Select` (which would
921+
evaluate the load unconditionally). *)
922+
let* (ctx1, s_code) = gen_expr ctx (List.nth args 0) in
923+
let* (ctx2, i_code) = gen_expr ctx1 (List.nth args 1) in
924+
let (ctx3, base_local) = alloc_local ctx2 "__scca_base" in
925+
let (ctx4, idx_local) = alloc_local ctx3 "__scca_idx" in
926+
let code =
927+
s_code @ [LocalSet base_local] @
928+
i_code @ [LocalSet idx_local] @
929+
(* condition: (idx >= 0) && (idx < len), len = i32 at base+0 *)
930+
[ LocalGet idx_local; I32Const 0l; I32GeS ] @
931+
[ LocalGet idx_local; LocalGet base_local; I32Load (2, 0); I32LtS ] @
932+
[ I32And ] @
933+
[ If (BtType I32,
934+
(* in-bounds: zero-extend byte at base + idx + 4 *)
935+
[ LocalGet base_local; LocalGet idx_local; I32Add;
936+
I32Load8U (0, 4) ],
937+
(* out-of-bounds sentinel, shared with the interp oracle *)
938+
[ I32Const (-1l) ]) ]
939+
in
940+
Ok (ctx4, code)
941+
942+
| ExprVar id when id.name = "char_to_int"
943+
&& List.length args = 1 ->
944+
(* PHASE-F string-wall slice 1. `char_to_int` is identity on the
945+
wasm value lattice: a Char is already an i32 byte code (cf. the
946+
`LitChar` lowering to `I32Const (Char.code c)`), and
947+
`string_char_code_at` likewise yields the raw code. Evaluate the
948+
argument and leave its value in place — no conversion
949+
instruction is required. Faithful to the interp oracle
950+
(`Char.code`) for every value the wasm backend can produce. *)
951+
let* (ctx_with_arg, arg_code) = gen_expr ctx (List.hd args) in
952+
Ok (ctx_with_arg, arg_code)
953+
910954
| ExprVar id when (id.name = "env_at" || id.name = "arg_at")
911955
&& List.length args = 1 ->
912956
(* ADR-015 S5 (#180): env_at(i) / arg_at(i) — fetch the i-th

‎proposals/EVIDENCE-stringwall-slice1.adoc‎

Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
// SPDX-License-Identifier: MPL-2.0
2+
// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
3+
= Phase F — string-wall slice 1: string indexing (evidence)
4+
:toc: macro
5+
6+
[IMPORTANT]
7+
====
8+
*Slice landed: read-side string indexing in the wasm backend.* The
9+
`string_char_code_at(s, i)` and `char_to_int(c)` builtins — already present
10+
in resolve/typecheck/interp — gained wasm-backend lowerings on the
11+
`[len: i32 LE][utf8 bytes...]` ABI. A previously STRING-GATED shape (byte
12+
indexing into a string literal) now compiles to wasm *and* parity-greens
13+
against the interpreter oracle.
14+
15+
This is the first slice of the *variable-string backend* wall
16+
(`proposals/MIGRATION-PLAN.adoc` §"The two walls", Phase F). It removes the
17+
wall for the *indexing/scan* family; allocation-returning string ops
18+
(`string_from_char_code`, `string_sub`, `slice`, concat, case-folding) remain
19+
for later slices.
20+
====
21+
22+
toc::[]
23+
24+
== What was missing
25+
26+
The string-builtin surface was wired end-to-end *except* the wasm backend:
27+
28+
[cols="2,1,1,1,1",options="header"]
29+
|===
30+
| Builtin | resolve.ml | typecheck.ml | interp.ml | codegen.ml (wasm)
31+
| `string_length` | ✓ | ✓ | ✓ | ✓ (pre-existing, `I32Load (2,0)`)
32+
| `string_char_code_at` | ✓ | ✓ | ✓ | *was missing -> added*
33+
| `char_to_int` | ✓ | ✓ | ✓ | *was missing -> added*
34+
|===
35+
36+
Before this slice, compiling `string_char_code_at(s, i)` failed at codegen:
37+
38+
----
39+
Code generation error: (Codegen.UnboundVariable
40+
"Function or variable not found: string_char_code_at")
41+
----
42+
43+
The builtin fell through the `gen_call` dispatch to the generic
44+
named-function path, which only knows user functions + the already-handled
45+
builtins — hence "unbound". The fix is a dispatch arm that emits the load
46+
sequence, exactly as `string_length` already does for length.
47+
48+
== The lowering (lib/codegen.ml)
49+
50+
String layout is `[len: i32 LE]` at the base pointer, with utf8 bytes
51+
starting at offset 4. Byte `i` therefore lives at `base + 4 + i`.
52+
53+
`string_char_code_at(s, i)` — total function, `-1` on out-of-bounds (the
54+
shared absent-byte sentinel; the interp oracle returns the same):
55+
56+
----
57+
s_code; LocalSet base
58+
i_code; LocalSet idx
59+
;; condition: (idx >= 0) && (idx < len)
60+
LocalGet idx; I32Const 0; I32GeS
61+
LocalGet idx; LocalGet base; I32Load; I32LtS
62+
I32And
63+
If (result i32)
64+
;; in-bounds: zero-extend byte at base + idx + 4
65+
then: LocalGet base; LocalGet idx; I32Add; I32Load8U (offset=4)
66+
;; out-of-bounds sentinel
67+
else: I32Const -1
68+
----
69+
70+
The bounds test *guards* the load (`If`, not `Select`): an out-of-bounds
71+
`I32Load8U` could trap or read foreign linear memory, so the load must not
72+
execute unless the index is in range. `Select` would evaluate both arms.
73+
74+
`char_to_int(c)` — identity on the wasm value lattice. A `Char` is already
75+
an i32 byte code (`LitChar` lowers to `I32Const (Char.code c)`), so the arm
76+
just evaluates the argument and leaves it; no conversion instruction.
77+
78+
== Gate evidence
79+
80+
=== Gate 1 — builds
81+
82+
`dune build bin/main.exe` exit 0. The previously-failing probe now compiles:
83+
84+
----
85+
$ affinescript compile idx.affine -o idx.wasm # fn main = string_char_code_at("ABC",1)
86+
Compiled idx.affine -> idx.wasm (WASM) # exit 0
87+
----
88+
89+
=== Gate 2 — parity (wasm vs interpreter oracle)
90+
91+
Same inputs through both backends agree. Interp oracle confirmed against the
92+
real library API (`Parse_driver.parse_string` -> `Interp.eval_program` ->
93+
`Value.lookup_env "f"` -> `apply_function`); wasm executed under Node.
94+
95+
[cols="3,1,1",options="header"]
96+
|===
97+
| Expression | interp | wasm
98+
| `string_char_code_at("ABC", 0)` | 65 | 65
99+
| `string_char_code_at("ABC", 1)` | 66 | 66
100+
| `string_char_code_at("ABC", 2)` | 67 | 67
101+
| `string_char_code_at("ABC", -1)` | -1 | -1
102+
| `string_char_code_at("ABC", 9)` | -1 | -1
103+
| `string_char_code_at("", 0)` | -1 | -1
104+
| `char_to_int('Z')` | 90 | 90
105+
|===
106+
107+
The packed fixture `tests/codegen/string_char_code_at.affine` returns
108+
`4276896` (positional base-256 pack of the three in-bounds bytes, minus the
109+
three `-1` sentinels, plus `char_to_int('Z')`); both backends produce it.
110+
111+
=== Type safety preserved
112+
113+
`char_to_int(65)` (Int where Char is required) is still rejected:
114+
`Unification error: (Unify.TypeMismatch (Char, Int))`. The wasm identity
115+
lowering does not loosen the front-end Char/Int distinction.
116+
117+
== Tests added
118+
119+
* `test/test_e2e.ml` — group *"E2E String-wall slice 1 (indexing)"*: seven
120+
interp-oracle cases (in-bounds bytes, both OOB directions, empty string,
121+
`char_to_int`). Runs under `dune runtest`. This is the interp consumer
122+
coverage mandated by `.claude/CLAUDE.md` §"Test-fixture hygiene".
123+
* `tests/codegen/string_char_code_at.affine` +
124+
`tests/codegen/test_string_char_code_at.mjs` — executable wasm parity,
125+
run by `tools/run_codegen_wasm_tests.sh` (CI). Asserts `main()` against the
126+
oracle constant; the same constants are pinned interp-side above.
127+
128+
Full `tools/run_codegen_wasm_tests.sh` run: *all* codegen WASM tests pass,
129+
including the new harness, no sibling regressions.
130+
131+
== Corpus impact
132+
133+
This slice unblocks the *indexing/scan* shape — code that reads bytes out of
134+
a string and compares/branches on them (first-byte dispatch, manual scanning,
135+
char-class checks). It does *not* yet unblock string-gated kernels whose work
136+
is dominated by *building new strings* (`*ToString`/`*FromString`
137+
serialisers, `String.replaceAll` interpolation, translation-dict lookups
138+
keyed by string), which need the allocation-returning ops in later slices.
139+
140+
== Next slices (variable-string backend wall)
141+
142+
. *Allocation-returning ABI* — a shared `gen_string_alloc` helper writing the
143+
`[len][bytes]` shape into the heap, then `string_from_char_code(n)` as its
144+
first consumer (one-byte string `[1][n & 0xff]`).
145+
. *`string_sub` / `slice`* — bounded copy loops over the byte range.
146+
. *`startsWith` / `string_find`* — prefix/substring scans (read-side; can
147+
build on this slice's indexing without allocation).
148+
. *Concat + case-folding* — `to_lowercase` / `to_uppercase` / `++` on strings.
149+
150+
Each slice: add the codegen arm, an interp-parity e2e group, and a
151+
`tests/codegen/*.mjs` executable check, then re-run the census and drop the
152+
gated count.

‎proposals/MIGRATION-PLAN.adoc‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -38,10 +38,12 @@ toc::[]
3838

3939
== The two walls (what ultimately gates "CLEAR")
4040

41-
. *Variable-string backend* — `String.length` / indexing / `startsWith` /
42-
`fromCharCode` cannot lower to wasm yet. Gates every STRING-GATED kernel
43-
(e.g. `Kernel_IO`, `DeviceType`, i18n). Lives in *this* repo's compiler,
44-
so it is attackable here.
41+
. *Variable-string backend* — `String.length` + read-side *indexing*
42+
(`string_char_code_at` / `char_to_int`) now lower to wasm (Phase F slice 1,
43+
see Ledger); `startsWith` / `fromCharCode` / `string_sub` / concat / case-fold
44+
do not yet. Gates every STRING-GATED kernel (e.g. `Kernel_IO`, `DeviceType`,
45+
i18n) whose work is building/transforming strings rather than scanning them.
46+
Lives in *this* repo's compiler, so it is attackable here.
4547
. *Effect codegen* — module-level mutable state / `Date.now` / `Console.log`
4648
cannot lower ("references an unbound binding"). Gates every EFFECT-GATED
4749
kernel (e.g. `Kernel_Quantum`). Also a compiler task.
@@ -200,7 +202,8 @@ Heuristic:
200202
| C9 | DONE | Game-loop / AffineTEA / VeriSim types (2026-06-05) — *classified, NO_NEW_BRAINS.* All 16 files are host-side senses. *4 bridge files* wrap already-live wasm brains: `AffineTEA.res` → `titlescreen.wasm` (TEA title-screen state machine), `AffineTEARouter.res` → `router.wasm` (affine nav back-stack), `PixiCoprocessor.res` → `pixi.wasm` (AffineScript PixiJS scene driver), `VmCoprocessor.res` → `vmcoprocessor.wasm` (C2). *8 VeriSimDB/Burble HTTP clients* (`SaveGame`, `VeriSimDrift`, `VeriSimFederation`, `VeriSimHexad`, `VeriSimProvenance`, `VeriSimSearch`, `VeriSimVcl`, `BurbleIntegration`) are async `fetch` wrappers — effect-gated throughout. `VeriSimTypes.res` enum variants (`modality`/`hexadStatus`/`driftLevel`) appear integer-clean but `modalityToString`/`modalityFromString` use string literals and all enums are used only in string-bearing records — string-wall gated, no standalone computation. `VeriSimError.res` constructors all carry `string` payloads — string-wall gated. `Main.res` / `GameLoop.res` are effect-gated orchestration; GameLoop integer counters are trivial increments interleaved with float physics and mutable JS objects. No 4-gate run. Evidence: `migrated/EVIDENCE-C9.adoc`. NEXT: C10.
201203
| C10 | DONE | Utils/tools/companions/narrative/proven (2026-06-05) — *classified, NO_NEW_BRAINS.* All 21 files are host-side senses. *9 bridge files* wrap already-live wasm brains: `moletairecoprocessors.wasm` (Moletaire behaviour FSM), `moletairehunger.wasm` (hunger ordinals), `missionbriefing.wasm` (mission briefing state machine), `safefloat.wasm` (safe-float arithmetic), `passwordcracker.wasm` (password-crack score), `portscanner.wasm` (port-scan classifier), `colorpalette.wasm` (color lookup), `fontscale.wasm` (font-scale arithmetic), `gamei18n.wasm` (plural-form + language-cycle). Float-wall: `MoletaireHunger.res` (f64 gravity/hunger physics — integer enum functions already in `moletairehunger.wasm`), `SafeAngle.res` (Math.atan2/cos/sin/mod_float, all f64). String-wall: `ProvenError.res` (all constructors carry string fields), `MoletairePersistence.res` (equipmentToString/FromString), `Locales.res` (5-language translation dicts, ~650 string pairs), `PolyglotI18n.res` (String.replaceAll, async fetch of locale JSON). Effect-gated: `Announcer.res` (AccessibilitySettings + DomA11y), `DomA11y.res` (%raw DOM), `ColorPalette.res` (AccessibilitySettings mutable refs; color tables already in wasm), `KeyboardNav.res` (%raw window events), `PanicHandler.res` (Console.error), `UserSettings.res` (Storage/Audio/DesktopIntegration; stance enum string-serialized). No 4-gate run. Evidence: `migrated/EVIDENCE-C10.adoc`. NEXT: C12.
202204
| 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`.
203-
| F+ | TODO | Compiler walls (string backend, then effects). *Cluster migration complete; these are the next milestones.*
205+
| 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`).
206+
| F+ | TODO | Remaining string-wall slices (allocation-returning ABI -> `string_from_char_code` -> `string_sub`/`slice` -> `startsWith`/`string_find` -> concat/case-fold), then the effect-codegen wall (module-state / `Date.now` / `Console.log`). *Cluster migration complete; string slice 1 landed.*
204207
| Ω | TODO (access-gated) | Cutover + ReScript extinction.
205208
|===
206209

‎test/test_e2e.ml‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3676,6 +3676,69 @@ let stdlib_04e_pure_tests = [
36763676
Alcotest.test_case "#332 string_length(\"hello\") == 5" `Quick test_stdlib_04e_string_length;
36773677
]
36783678

3679+
(* ---- PHASE-F string-wall slice 1: string indexing ----
3680+
3681+
`string_char_code_at(s, i)` + `char_to_int(c)` gained wasm-backend
3682+
lowerings in lib/codegen.ml (the read-side `[len: i32 LE][utf8]` ABI).
3683+
The interp bindings already existed (lib/interp.ml); these tests pin the
3684+
interp oracle whose values the new wasm lowerings must reproduce — the
3685+
parity reference for the matching tests/codegen/*.mjs executable check.
3686+
3687+
Oracle semantics (lib/interp.ml `string_char_code_at`): byte 0..255 at
3688+
index i, or -1 when i < 0 OR i >= length (the shared absent-byte
3689+
sentinel). `char_to_int` is `Char.code`. *)
3690+
3691+
let eval_int_fn src =
3692+
let prog = Parse_driver.parse_string ~file:"<stringwall>" src in
3693+
match Interp.eval_program prog with
3694+
| Error e -> Alcotest.failf "interp failed: %s" (Value.show_eval_error e)
3695+
| Ok env ->
3696+
(match Value.lookup_env "f" env with
3697+
| Ok fn ->
3698+
(match Interp.apply_function fn [] with
3699+
| Ok (Value.VInt n) -> n
3700+
| Ok v -> Alcotest.failf "expected VInt, got %s" (Value.show_value v)
3701+
| Error e -> Alcotest.failf "apply failed: %s" (Value.show_eval_error e))
3702+
| Error e -> Alcotest.failf "lookup f failed: %s" (Value.show_eval_error e))
3703+
3704+
let test_stringwall_scca_first () =
3705+
Alcotest.(check int) "string_char_code_at(\"ABC\",0) == 'A'" 65
3706+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"ABC\", 0) }")
3707+
3708+
let test_stringwall_scca_mid () =
3709+
Alcotest.(check int) "string_char_code_at(\"ABC\",1) == 'B'" 66
3710+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"ABC\", 1) }")
3711+
3712+
let test_stringwall_scca_last () =
3713+
Alcotest.(check int) "string_char_code_at(\"ABC\",2) == 'C'" 67
3714+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"ABC\", 2) }")
3715+
3716+
let test_stringwall_scca_oob_neg () =
3717+
Alcotest.(check int) "negative index -> -1 sentinel" (-1)
3718+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"ABC\", -1) }")
3719+
3720+
let test_stringwall_scca_oob_past () =
3721+
Alcotest.(check int) "index past end -> -1 sentinel" (-1)
3722+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"ABC\", 9) }")
3723+
3724+
let test_stringwall_scca_empty () =
3725+
Alcotest.(check int) "index into empty string -> -1 sentinel" (-1)
3726+
(eval_int_fn "fn f() -> Int { string_char_code_at(\"\", 0) }")
3727+
3728+
let test_stringwall_char_to_int () =
3729+
Alcotest.(check int) "char_to_int('Z') == 90" 90
3730+
(eval_int_fn "fn f() -> Int { char_to_int('Z') }")
3731+
3732+
let stringwall_index_tests = [
3733+
Alcotest.test_case "scca(\"ABC\",0) == 65" `Quick test_stringwall_scca_first;
3734+
Alcotest.test_case "scca(\"ABC\",1) == 66" `Quick test_stringwall_scca_mid;
3735+
Alcotest.test_case "scca(\"ABC\",2) == 67" `Quick test_stringwall_scca_last;
3736+
Alcotest.test_case "scca neg index == -1" `Quick test_stringwall_scca_oob_neg;
3737+
Alcotest.test_case "scca past-end index == -1" `Quick test_stringwall_scca_oob_past;
3738+
Alcotest.test_case "scca empty string == -1" `Quick test_stringwall_scca_empty;
3739+
Alcotest.test_case "char_to_int('Z') == 90" `Quick test_stringwall_char_to_int;
3740+
]
3741+
36793742
(* ---- STDLIB-04b: Throws extern `error<T>` (Refs #329) ----
36803743
36813744
`error<T>(msg: String) -> T / Throws` was declared in
@@ -4783,6 +4846,7 @@ let tests =
47834846
("E2E STDLIB-04a Mut #328", stdlib_04a_mut_tests);
47844847
("E2E STDLIB-04d IO #331", stdlib_04d_io_tests);
47854848
("E2E STDLIB-04e Pure #332", stdlib_04e_pure_tests);
4849+
("E2E String-wall slice 1 (indexing)", stringwall_index_tests);
47864850
("E2E STDLIB-04b error #329", stdlib_04b_error_tests);
47874851
("E2E Vscode Bindings", vscode_bindings_tests);
47884852
("E2E Array Type Sugar", array_type_tests);

0 commit comments

Comments
 (0)