35ca120 | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

35ca120 — Peter John 2026-11-01T22:18:05+05:30

refactor: Str + and == are ordinary Plum methods; concat/eq wasm helpers removed

Files changed (4) hide show

plum-checker/src/lib.rs +2 -1
plum-std/Str.plum +28 -0
plum-wasm-codegen/src/lib.rs +7 -239
plum-wasm-codegen/tests/codegen_tests.rs +2 -1

plum-checker/src/lib.rs CHANGED Viewed

@@ -3498,7 +3498,8 @@ fn startVariant(
 /// True for an operand whose operators are user methods (`add`, `eq`, ...): a
 /// declared class/enum, not a primitive, `Str`, `Bool` or an error name.
 pub fn isOperatorOperand(t: &PlumType) -> bool {
+    matches!(t, PlumType::TStr)
-    matches!(t, PlumType::TNamed(n) | PlumType::TApp(n, _) if n != "Str" && n != "Int" && n != "Float" && n != "Bool" && n != "Byte")
+        || matches!(t, PlumType::TNamed(n) | PlumType::TApp(n, _) if n != "Int" && n != "Float" && n != "Bool" && n != "Byte")
 }
 /// Resolves operator `sym` on a non-primitive left operand to `left.method(right)`,

plum-std/Str.plum CHANGED Viewed

@@ -137,6 +137,34 @@ record Str(bytes: []Byte) =
   fun concat(self, other: Str) -> Str =
     self + other
+  # `a + b`: one exact-length allocation and two bulk copies. Returns an
+  # operand unchanged when the other is empty (Strs are immutable).
+  fun add(self, o: Str) -> Str =
+    n := self.length()
+    m := o.length()
+    if m == 0
+      return self
+    if n == 0
+      return o
+    out := makeBytes(n + m)
+    copyBytes(out, 0, self.bytes, 0, n)
+    copyBytes(out, n, o.bytes, 0, m)
+    return Str(bytes: out)
+  # `a == b` / `a != b`: CONTENT equality (never reference equality).
+  fun eq(self, o: Str) -> Bool =
+    n := self.length()
+    if n != o.length()
+      return false
+    a := self.bytes
+    b := o.bytes
+    i := 0
+    while i < n
+      if a.get(i) != b.get(i)
+        return false
+      i = i + 1
+    return true
   fun toStr(self) -> Str =
     self

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -406,11 +406,9 @@ pub struct CompileCtx<'a> {
     /// Shared runtime helper `(a: ref Str, b: ref Str) -> ref Str`: allocates a new
     /// `array<i8>` exactly long enough to hold `a`'s bytes followed by `b`'s, for
     /// lowering string interpolation (`"{expr}"`).
-    pub string_concat_func: u32,
     /// Shared runtime helper `(a: ref Str, b: ref Str) -> i32`: byte-for-byte
     /// content equality (1/0) — see the comment on its registration site for
     /// why `==`/`!=` on `Str` needs this instead of plain `ref.eq`.
-    pub string_eq_func: u32,
     /// Shared runtime helper `(n: i64) -> ref Str`: allocates a new `array<i8>`
     /// holding `n`'s decimal representation, for interpolating an `Int`.
     /// wasm-gc type-section indices for this program's enums/Str/closures —
@@ -459,8 +457,6 @@ struct LocalCtx<'a> {
     closures: &'a HashMap<(usize, usize), ClosureInfo>,
     closure_call_types: &'a HashMap<ClosureSigKey, u32>,
     named_fn_values: &'a HashMap<(String, PlumType), u32>,
-    string_concat_func: u32,
-    string_eq_func: u32,
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
@@ -2489,8 +2485,6 @@ fn compileSourceInner(
     let start_slot = (start_func_idx - module.func_import_count) as usize;
     module.functions[start_slot].1 = final_start_body;
-    let string_concat_func = registerStringConcatHelper(&mut module, gc_types.byte_array_type_idx);
-    let string_eq_func = registerStringEqHelper(&mut module, gc_types.byte_array_type_idx);
     let ctx = CompileCtx {
         func_ids,
@@ -2510,8 +2504,6 @@ fn compileSourceInner(
         closure_asts,
         closure_call_types,
         named_fn_values,
-        string_concat_func,
-        string_eq_func,
         gc_types,
         singleton_globals,
     };
@@ -2637,187 +2629,6 @@ fn getClosureCallType(module: &mut WasmModule, m: &mut HashMap<ClosureSigKey, u3
     t
 }
-/// Registers `__string_concat(a: ref Str, b: ref Str) -> ref Str`, a hand-written
-/// runtime helper backing string interpolation. Unwraps both `Str` params down
-/// to their raw `array<i8>`s (`unwrapStrToBytes`) — which each track their own
-/// length via `array.len` — allocates a new array sized `len(a) + len(b)`,
-/// does two `array.copy`s (a whole-array-in-one-instruction bulk copy), then
-/// wraps the result back into a real `Str` (`wrapBytesAsStr`).
-fn registerStringConcatHelper(module: &mut WasmModule, byte_array_type_idx: u32) -> u32 {
-    let byte_array_ref = gcRef(byte_array_type_idx);
-    let str_ref = withGcTypes(strGcValtypeOrFallback);
-    let type_idx = module.addType(&[str_ref, str_ref], &[str_ref]);
-    // locals: 0=a (param), 1=b (param), 2=arr_a, 3=arr_b, 4=len_a, 5=len_b,
-    // 6=total_len, 7=result
-    const A: u32 = 0;
-    const B: u32 = 1;
-    const ARR_A: u32 = 2;
-    const ARR_B: u32 = 3;
-    const LEN_A: u32 = 4;
-    const LEN_B: u32 = 5;
-    const TOTAL_LEN: u32 = 6;
-    const RESULT: u32 = 7;
-    let mut body = Vec::new();
-    body.extend(encodeLeb128U32(3)); // three locals groups
-    body.extend(encodeLeb128U32(2)); // arr_a, arr_b: ref
-    byte_array_ref.encode(&mut body);
-    body.extend(encodeLeb128U32(3)); // len_a, len_b, total_len: i32
-    ValType::I32.encode(&mut body);
-    body.extend(encodeLeb128U32(1)); // result: ref
-    byte_array_ref.encode(&mut body);
-    // arr_a = a.bytes; arr_b = b.bytes
-    Instruction::LocalGet(A).encode(&mut body);
-    unwrapStrToBytes(&mut body);
-    Instruction::LocalSet(ARR_A).encode(&mut body);
-    Instruction::LocalGet(B).encode(&mut body);
-    unwrapStrToBytes(&mut body);
-    Instruction::LocalSet(ARR_B).encode(&mut body);
-    // len_a = array.len(arr_a); len_b = array.len(arr_b)
-    Instruction::LocalGet(ARR_A).encode(&mut body);
-    Instruction::ArrayLen.encode(&mut body);
-    Instruction::LocalSet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(ARR_B).encode(&mut body);
-    Instruction::ArrayLen.encode(&mut body);
-    Instruction::LocalSet(LEN_B).encode(&mut body);
-    // total_len = len_a + len_b; result = array.new_default(byte_array_type_idx, total_len)
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(LEN_B).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(TOTAL_LEN).encode(&mut body);
-    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::ArrayNewDefault(byte_array_type_idx).encode(&mut body);
-    Instruction::LocalSet(RESULT).encode(&mut body);
-    // array.copy(dst: result, dst_offset: 0, src: arr_a, src_offset: 0, len: len_a)
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalGet(ARR_A).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::ArrayCopy {
-        array_type_index_dst: byte_array_type_idx,
-        array_type_index_src: byte_array_type_idx,
-    }
-    .encode(&mut body);
-    // array.copy(dst: result, dst_offset: len_a, src: arr_b, src_offset: 0, len: len_b)
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(ARR_B).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalGet(LEN_B).encode(&mut body);
-    Instruction::ArrayCopy {
-        array_type_index_dst: byte_array_type_idx,
-        array_type_index_src: byte_array_type_idx,
-    }
-    .encode(&mut body);
-    // wrap result (the raw array) back into a real Str
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    wrapBytesAsStr(&mut body);
-    Instruction::End.encode(&mut body);
-    module.addFunction(type_idx, &body)
-}
-/// Registers `__string_eq(a: ref Str, b: ref Str) -> i32` (1/0), a hand-written
-/// runtime helper backing `Str`'s `==`/`!=` operator. `Str` is a wasm-gc `ref` —
-/// the general `Compare` codegen's default for reference-typed operands is
-/// `ref.eq` (identity), correct for a payload-free singleton (`End`) or
-/// class-instance identity, but WRONG for `Str`: two independently-heap-allocated
-/// `array<i8>` values holding identical bytes (e.g. two `"a"` literals, or one
-/// literal and a runtime-built string) are different objects and would compare
-/// unequal — silently breaking the extremely common `someStr == "literal"`
-/// pattern (e.g. `Map`'s own `Str`-keyed `get`/`set` comparing keys). This does
-/// a real byte-for-byte comparison instead: same length, then every byte equal.
-fn registerStringEqHelper(module: &mut WasmModule, byte_array_type_idx: u32) -> u32 {
-    let byte_array_ref = gcRef(byte_array_type_idx);
-    let str_ref = withGcTypes(strGcValtypeOrFallback);
-    let type_idx = module.addType(&[str_ref, str_ref], &[ValType::I32]);
-    // locals: 0=a (param), 1=b (param), 2=arr_a, 3=arr_b, 4=len_a, 5=len_b, 6=i
-    const A: u32 = 0;
-    const B: u32 = 1;
-    const ARR_A: u32 = 2;
-    const ARR_B: u32 = 3;
-    const LEN_A: u32 = 4;
-    const LEN_B: u32 = 5;
-    const I: u32 = 6;
-    let mut body = Vec::new();
-    body.extend(encodeLeb128U32(2)); // two locals groups
-    body.extend(encodeLeb128U32(2)); // arr_a, arr_b: ref
-    byte_array_ref.encode(&mut body);
-    body.extend(encodeLeb128U32(3)); // len_a, len_b, i: i32
-    ValType::I32.encode(&mut body);
-    // arr_a = a.bytes; arr_b = b.bytes
-    Instruction::LocalGet(A).encode(&mut body);
-    unwrapStrToBytes(&mut body);
-    Instruction::LocalSet(ARR_A).encode(&mut body);
-    Instruction::LocalGet(B).encode(&mut body);
-    unwrapStrToBytes(&mut body);
-    Instruction::LocalSet(ARR_B).encode(&mut body);
-    Instruction::LocalGet(ARR_A).encode(&mut body);
-    Instruction::ArrayLen.encode(&mut body);
-    Instruction::LocalSet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(ARR_B).encode(&mut body);
-    Instruction::ArrayLen.encode(&mut body);
-    Instruction::LocalSet(LEN_B).encode(&mut body);
-    // if len_a != len_b: return 0
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(LEN_B).encode(&mut body);
-    Instruction::I32Ne.encode(&mut body);
-    Instruction::If(BlockType::Empty).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::Return.encode(&mut body);
-    Instruction::End.encode(&mut body);
-    // i = 0
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
-    // block { loop { if i >= len_a: br 1 (exit loop); if a[i] != b[i]: return 0; i++; br 0 } }
-    Instruction::Block(BlockType::Empty).encode(&mut body);
-    Instruction::Loop(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::I32GeU.encode(&mut body);
-    Instruction::BrIf(1).encode(&mut body);
-    Instruction::LocalGet(ARR_A).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::ArrayGetU(byte_array_type_idx).encode(&mut body);
-    Instruction::LocalGet(ARR_B).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::ArrayGetU(byte_array_type_idx).encode(&mut body);
-    Instruction::I32Ne.encode(&mut body);
-    Instruction::If(BlockType::Empty).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::Return.encode(&mut body);
-    Instruction::End.encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Const(1).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
-    Instruction::Br(0).encode(&mut body);
-    Instruction::End.encode(&mut body); // end loop
-    Instruction::End.encode(&mut body); // end block
-    Instruction::I32Const(1).encode(&mut body);
-    Instruction::End.encode(&mut body); // end function
-    module.addFunction(type_idx, &body)
-}
 /// Hand-written bodies for a handful of `libs/std/str.plum` primitives that can't
 /// be expressed in Plum source at all (byte-level array access, building a new
 /// one-element array) — these three are the whole reason every other `Str` method
@@ -2904,11 +2715,8 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
 /// never loaded `str.plum` at all (see `plum-core::loader::loadAndMerge`'s
 /// best-effort `std/str` prelude), falling back to the raw `array<i8>` type
 /// instead of panicking. Safe specifically because this is only used by the
-/// three string runtime helpers (`registerStringConcatHelper`/
-/// `registerStringEqHelper`), which are
+/// unconditionally registered string runtime helpers, which every compiled
-/// registered UNCONDITIONALLY in every compiled program regardless of
-/// whether it actually uses `Str` — a `Str`-less program (which, by
-/// definition, never calls them) doesn't care what type they claim.
+/// program gets regardless of whether it uses `Str`.
 fn strGcValtypeOrFallback(r: &GcTypeRegistry) -> ValType {
     match r.class_type_idx.get("Str") {
         Some(idx) => gcRef(*idx),
@@ -2929,20 +2737,6 @@ fn wrapBytesAsStr(body: &mut Vec<u8>) {
     Instruction::Call(mk).encode(body);
 }
-/// The inverse of `wrapBytesAsStr`: given a `Str` value on the stack, leaves
-/// its raw `array<i8>` (`self.bytes`) there instead: one `struct.get Str 0`.
-/// A no-op when `Str` isn't registered (the value already IS the array).
-fn unwrapStrToBytes(body: &mut Vec<u8>) {
-    let Some(str_type_idx) = withGcTypes(|r| r.class_type_idx.get("Str").copied()) else {
-        return;
-    };
-    Instruction::StructGet {
-        struct_type_index: str_type_idx,
-        field_index: 0,
-    }
-    .encode(body);
-}
 /// `Array[T]`'s `init`/`get`/`set`/`length` — the intrinsic is backed by ONE wasm-gc `array<anyref>` type
 /// (`GcTypeRegistry::array_type_idx`, see `isArraySpecialization`), so these
 /// compile identically regardless of the concrete `T`.
@@ -4111,8 +3905,6 @@ fn compileFnBodyImpl(
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
         named_fn_values: &ctx.named_fn_values,
-        string_concat_func: ctx.string_concat_func,
-        string_eq_func: ctx.string_eq_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
@@ -6360,15 +6152,9 @@ fn compileExprCore(
         ast::Expr::Binary(b) => {
             let left_ty = inferLocalType(&b.left, ctx);
             let is_float = matches!(left_ty, PlumType::TFloat);
-            let is_str = matches!(left_ty, PlumType::TStr);
             compileExpr(&b.left, body, ctx, state)?;
             compileExpr(&b.right, body, ctx, state)?;
             match b.op {
-                // `Str + Str` (e.g. `libs/std/str.plum`'s `concat`) allocates a new
-                // array holding both operands' bytes via the same runtime helper
-                // string interpolation uses — there's no native wasm "add" for a
-                // GC ref.
-                ast::BinOp::Add if is_str => Instruction::Call(ctx.string_concat_func).encode(body),
                 ast::BinOp::Add => if is_float {
                     Instruction::F64Add
                 } else {
@@ -6482,25 +6268,6 @@ fn compileExprCore(
                     }
                     .encode(body);
                 }
-                // `Str`'s `==`/`!=` needs real byte-for-byte comparison, not
-                // reference identity — see `registerStringEqHelper`'s doc
-                // comment for why plain `ref.eq` silently breaks the (very
-                // common) `someStr == "literal"` pattern.
-                PlumType::TStr => match &c.op {
-                    ast::CmpOp::Eq => {
-                        Instruction::Call(ctx.string_eq_func).encode(body);
-                    }
-                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => {
-                        Instruction::Call(ctx.string_eq_func).encode(body);
-                        Instruction::I32Eqz.encode(body);
-                    }
-                    other => {
-                        return Err(format!(
-                            "codegen: '{:?}' is not supported between Str values",
-                            other
-                        ))
-                    }
-                },
                 PlumType::TBool => match &c.op {
                     ast::CmpOp::Eq => Instruction::I32Eq.encode(body),
                     ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I32Ne.encode(body),
@@ -7306,7 +7073,7 @@ fn compileStaticString(text: &str, body: &mut Vec<u8>, state: &mut ModuleState)
 /// `compileStaticString`; `Str`/`Int`/`Bool`/`Float` interpolated values
 /// converted at runtime — `Float` via `Float.toStr`, see the `TFloat` arm
 /// below), then all parts are left-folded together with the
-/// `__string_concat` runtime helper.
+/// `Str.add` method (chained, left to right).
 fn compileInterpolatedString(
     s: &ast::StringExpr,
     body: &mut Vec<u8>,
@@ -7375,7 +7142,10 @@ fn compileInterpolatedString(
             }
         }
         if !first {
+            let add = *ctx.func_ids.get("Str::add").ok_or_else(|| {
+                "codegen: string interpolation requires `Str.add` (import std/Str)".to_string()
+            })?;
-            Instruction::Call(ctx.string_concat_func).encode(body);
+            Instruction::Call(add).encode(body);
         }
         first = false;
     }
@@ -7619,8 +7389,6 @@ fn compileClosureBody(
         closures: &ctx.closures,
         closure_call_types: &ctx.closure_call_types,
         named_fn_values: &ctx.named_fn_values,
-        string_concat_func: ctx.string_concat_func,
-        string_eq_func: ctx.string_eq_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -3029,7 +3029,8 @@ fun main() -> Int =
   a + b + c + {if d == \"none\" then 4 else 0} + f
 ";
     // a = 2, b = 10, c = 7, d = 4, e = 3
+    // Str `==` is the ordinary `Str.eq` method, so Str.plum must really load.
-    assert_eq!(runInt(&format!("{}{}", STD_HEAD, src)), 26);
+    assert_eq!(runWithCrash("error_slots", &format!("{}{}", STD_HEAD, src)).0, Ok(26));
 }
 // ---- associated consts, statics and `primitive` ----