d959708 | plum | pyrossh

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

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

d959708 — Peter John 2026-11-01T22:10:50+05:30

refactor: byteToStr in Plum; Int interpolation via Int.toStr; int_to_string wasm helper removed

Files changed (4) hide show

plum-checker/src/lib.rs +2 -5
plum-std/Str.plum +4 -3
plum-wasm-codegen/src/lib.rs +5 -156
plum-wasm-codegen/tests/codegen_tests.rs +53 -20

plum-checker/src/lib.rs CHANGED Viewed

@@ -3376,10 +3376,6 @@ fn inferMethodCall(
             _ => Err(format!("a variadic parameter has no method '{}'", name)),
         };
     }
-    // `Bool.toStr` is a compiler intrinsic ("true"/"false"), not a source method.
-    if matches!(obj_ty, PlumType::TBool) && name == "toStr" && args.is_empty() {
-        return Ok(PlumType::TStr);
-    }
     // A method on a generic parameter: duck-typed — checked when the enclosing generic body is
     // checked per concrete instantiation.
     if let PlumType::TParam(_) = obj_ty {
@@ -3440,7 +3436,8 @@ fn inferMethodCall(
         // A fully concrete generic receiver (`Map[Str, Int]`) is checked in the
         // erased pass too, so a typo'd method is a positioned checker error
         // rather than a late codegen failure.
-        if !hasFreeVars(obj_ty) && (INST_MODE.with(|m| m.get()) || matches!(obj_ty, PlumType::TApp(..))) {
+        if !hasFreeVars(obj_ty) && (INST_MODE.with(|m| m.get())
+            || matches!(obj_ty, PlumType::TApp(..) | PlumType::TInt | PlumType::TBool)) {
             return Err(format!("{} has no method '{}'", obj_ty, name));
         }
         // Otherwise (erased pass): allow, the per-instance pass decides.

plum-std/Str.plum CHANGED Viewed

@@ -393,10 +393,11 @@ record Str(bytes: []Byte) =
   fun words(self) -> Str =
     caseConvert(self, " ", 0)
-# A new 1-byte Str holding `b`'s low 8 bits — a compiler intrinsic (there's no
+# A new 1-byte Str holding `b`'s low 8 bits, the counterpart to `byteAt`.
-# way to build a new array from Plum source), the counterpart to `byteAt`.
 fun byteToStr(b: Int) -> Str =
+  out := makeBytes(1)
+  out.set(0, Byte(b))
-  todo
+  return Str(bytes: out)
 fun isAsciiUpper(b: Int) -> Bool =
   b >= 65 && b <= 90 # 'A'..'Z'

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

@@ -413,7 +413,6 @@ pub struct CompileCtx<'a> {
     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`.
-    pub int_to_string_func: u32,
     /// wasm-gc type-section indices for this program's enums/Str/closures —
     /// every value's real representation (see `docs/superpowers/plans/2026-07-25-wasm-gc-migration.md`).
     pub gc_types: GcTypeRegistry,
@@ -462,7 +461,6 @@ struct LocalCtx<'a> {
     named_fn_values: &'a HashMap<(String, PlumType), u32>,
     string_concat_func: u32,
     string_eq_func: u32,
-    int_to_string_func: u32,
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
@@ -2493,7 +2491,6 @@ fn compileSourceInner(
     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 int_to_string_func = registerIntToStringHelper(&mut module, gc_types.byte_array_type_idx);
     let ctx = CompileCtx {
         func_ids,
@@ -2515,7 +2512,6 @@ fn compileSourceInner(
         named_fn_values,
         string_concat_func,
         string_eq_func,
-        int_to_string_func,
         gc_types,
         singleton_globals,
     };
@@ -2822,138 +2818,6 @@ fn registerStringEqHelper(module: &mut WasmModule, byte_array_type_idx: u32) ->
     module.addFunction(type_idx, &body)
 }
-/// Registers `__int_to_string(n: i64) -> ref Str`, a hand-written runtime helper
-/// backing string interpolation: allocates a new `array<i8>` holding `n`'s decimal
-/// representation (handling a leading `-` for negatives, and `0` correctly via a
-/// do-while digit count that always runs at least once).
-fn registerIntToStringHelper(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(&[ValType::I64], &[str_ref]);
-    // locals: 0=n (param, i64), 1=is_neg (i32), 2=count (i32), 3=total_len (i32),
-    // 4=pos (i32), 5=result (ref), 6=abs_n (i64), 7=temp (i64)
-    // Locals are declared as one group of 4 `i32`s, one group of 1 `ref`, then one
-    // group of 2 `i64`s (see below), so indices must stay grouped by type in that
-    // same order — NOT in whatever order reads best logically.
-    const N: u32 = 0;
-    const IS_NEG: u32 = 1;
-    const COUNT: u32 = 2;
-    const TOTAL_LEN: u32 = 3;
-    const POS: u32 = 4;
-    const RESULT: u32 = 5;
-    const ABS_N: u32 = 6;
-    const TEMP: u32 = 7;
-    let mut body = Vec::new();
-    body.extend(encodeLeb128U32(3)); // three locals groups
-    body.extend(encodeLeb128U32(4)); // is_neg, count, total_len, pos: i32
-    ValType::I32.encode(&mut body);
-    body.extend(encodeLeb128U32(1)); // result: ref
-    byte_array_ref.encode(&mut body);
-    body.extend(encodeLeb128U32(2)); // abs_n, temp: i64
-    ValType::I64.encode(&mut body);
-    // is_neg = n < 0
-    Instruction::LocalGet(N).encode(&mut body);
-    Instruction::I64Const(0).encode(&mut body);
-    Instruction::I64LtS.encode(&mut body);
-    Instruction::LocalSet(IS_NEG).encode(&mut body);
-    // abs_n = if is_neg then (0 - n) else n
-    Instruction::LocalGet(IS_NEG).encode(&mut body);
-    Instruction::If(BlockType::Result(ValType::I64)).encode(&mut body);
-    Instruction::I64Const(0).encode(&mut body);
-    Instruction::LocalGet(N).encode(&mut body);
-    Instruction::I64Sub.encode(&mut body);
-    Instruction::Else.encode(&mut body);
-    Instruction::LocalGet(N).encode(&mut body);
-    Instruction::End.encode(&mut body);
-    Instruction::LocalSet(ABS_N).encode(&mut body);
-    // count digits: do { temp /= 10; count++ } while (temp != 0); temp starts as abs_n
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalSet(COUNT).encode(&mut body);
-    Instruction::LocalGet(ABS_N).encode(&mut body);
-    Instruction::LocalSet(TEMP).encode(&mut body);
-    Instruction::Loop(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(TEMP).encode(&mut body);
-    Instruction::I64Const(10).encode(&mut body);
-    Instruction::I64DivS.encode(&mut body);
-    Instruction::LocalSet(TEMP).encode(&mut body);
-    Instruction::LocalGet(COUNT).encode(&mut body);
-    Instruction::I32Const(1).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(COUNT).encode(&mut body);
-    Instruction::LocalGet(TEMP).encode(&mut body);
-    Instruction::I64Const(0).encode(&mut body);
-    Instruction::I64Ne.encode(&mut body);
-    Instruction::BrIf(0).encode(&mut body);
-    Instruction::End.encode(&mut body);
-    // total_len = count + is_neg
-    Instruction::LocalGet(COUNT).encode(&mut body);
-    Instruction::LocalGet(IS_NEG).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(TOTAL_LEN).encode(&mut body);
-    // result = array.new_default(byte_array_type_idx, total_len) — no length prefix needed,
-    // `array.len` reads it back natively.
-    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::ArrayNewDefault(byte_array_type_idx).encode(&mut body);
-    Instruction::LocalSet(RESULT).encode(&mut body);
-    // pos = total_len; temp = abs_n
-    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::LocalSet(POS).encode(&mut body);
-    Instruction::LocalGet(ABS_N).encode(&mut body);
-    Instruction::LocalSet(TEMP).encode(&mut body);
-    // do { pos--; result[pos] = '0' + temp % 10; temp /= 10 } while (pos > is_neg)
-    Instruction::Loop(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(POS).encode(&mut body);
-    Instruction::I32Const(1).encode(&mut body);
-    Instruction::I32Sub.encode(&mut body);
-    Instruction::LocalSet(POS).encode(&mut body);
-    // array.set(result, pos, value) — stack order [array_ref, index, value]
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::LocalGet(POS).encode(&mut body);
-    // value = '0' + (temp % 10)
-    Instruction::LocalGet(TEMP).encode(&mut body);
-    Instruction::I64Const(10).encode(&mut body);
-    Instruction::I64RemS.encode(&mut body);
-    Instruction::I64Const(48).encode(&mut body);
-    Instruction::I64Add.encode(&mut body);
-    Instruction::I32WrapI64.encode(&mut body);
-    Instruction::ArraySet(byte_array_type_idx).encode(&mut body);
-    // temp /= 10
-    Instruction::LocalGet(TEMP).encode(&mut body);
-    Instruction::I64Const(10).encode(&mut body);
-    Instruction::I64DivS.encode(&mut body);
-    Instruction::LocalSet(TEMP).encode(&mut body);
-    // while (pos > is_neg)
-    Instruction::LocalGet(POS).encode(&mut body);
-    Instruction::LocalGet(IS_NEG).encode(&mut body);
-    Instruction::I32GtU.encode(&mut body);
-    Instruction::BrIf(0).encode(&mut body);
-    Instruction::End.encode(&mut body);
-    // if (is_neg) result[0] = '-'
-    Instruction::LocalGet(IS_NEG).encode(&mut body);
-    Instruction::If(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::I32Const(0).encode(&mut body);
-    Instruction::I32Const(45).encode(&mut body); // '-'
-    Instruction::ArraySet(byte_array_type_idx).encode(&mut body);
-    Instruction::End.encode(&mut body);
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    wrapBytesAsStr(&mut body);
-    Instruction::End.encode(&mut body);
-    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
@@ -2970,22 +2834,6 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
     }
     let byte_array_type_idx = withGcTypes(|r| r.byte_array_type_idx);
     match (f.type_param.as_deref(), f.name.as_str()) {
-        // byteToStr(b: Int) -> Str — a new length-1 Str holding `b`'s low 8 bits,
-        // wrapped into `Str`'s real `{bytes: []Byte}`
-        // shape (see `wrapBytesAsStr`).
-        (None, "byteToStr") => {
-            let mut body = vec![0u8];
-            Instruction::LocalGet(0).encode(&mut body); // b
-            Instruction::I32WrapI64.encode(&mut body);
-            Instruction::ArrayNewFixed {
-                array_type_index: byte_array_type_idx,
-                array_size: 1,
-            }
-            .encode(&mut body);
-            wrapBytesAsStr(&mut body);
-            Instruction::End.encode(&mut body);
-            Some(body)
-        }
         // ByteSlice.length(self) -> Int — `[]Byte` reuses `Str`'s array<i8> wasm
         // type (see the comment on `PlumType::TByteSlice` in `plumTypeToValtype`),
         // so this is byte-for-byte identical to `Str.length` above.
@@ -3057,7 +2905,7 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
 /// 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`/`registerIntToStringHelper`), which are
+/// `registerStringEqHelper`), which are
 /// 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.
@@ -4265,7 +4113,6 @@ fn compileFnBodyImpl(
         named_fn_values: &ctx.named_fn_values,
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
-        int_to_string_func: ctx.int_to_string_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
@@ -7479,8 +7326,11 @@ fn compileInterpolatedString(
                         compileExpr(expr, body, ctx, state)?;
                     }
                     PlumType::TInt => {
+                        // Ordinary `Int.toStr` (`plum-std/Int.plum`), like Float below.
                         compileExpr(expr, body, ctx, state)?;
+                        let func_idx = *ctx.func_ids.get("Int::toStr")
+                            .ok_or_else(|| "codegen: interpolating an Int value requires `Int.toStr` (import std/Int)".to_string())?;
-                        Instruction::Call(ctx.int_to_string_func).encode(body);
+                        Instruction::Call(func_idx).encode(body);
                     }
                     PlumType::TBool => {
                         let str_ref = withGcTypes(|r| plumTypeToGcValtype(&PlumType::TStr, r));
@@ -7771,7 +7621,6 @@ fn compileClosureBody(
         named_fn_values: &ctx.named_fn_values,
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
-        int_to_string_func: ctx.int_to_string_func,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,

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

@@ -79,9 +79,14 @@ fn readStrResult(store: &mut wasmtime::Store<()>, val: &wasmtime::Val) -> String
     let wasmtime::Val::AnyRef(Some(s)) = val else {
         panic!("expected a Str result");
     };
+    // `Str` is a record wrapping one `[]Byte` in field 0.
+    let st = s.unwrap_struct(&*store).expect("Str result should be a struct");
+    let wasmtime::Val::AnyRef(Some(bytes)) = st.field(&mut *store, 0).expect("bytes field") else {
+        panic!("Str.bytes should be a reference");
+    };
-    let arr = s
+    let arr = bytes
-        .unwrap_array(&mut *store)
+        .unwrap_array(&*store)
-        .expect("Str result should be an array");
+        .expect("Str.bytes should be an array");
     let len = arr.len(&mut *store).expect("should read array length");
     let mut buf = vec![0u8; len as usize];
     arr.copy_to_i8_slice(&mut *store, &mut buf)
@@ -97,9 +102,17 @@ fn readStrResult(store: &mut wasmtime::Store<()>, val: &wasmtime::Val) -> String
 #[test]
 fn testBlocksCompileAndRun() {
     let src = "\
+import std/Str
+import std/Int
+import std/Float
 fun add(a: Int, b: Int) -> Int =
   a + b
+fun hardAssertTrap() -> Int =
+  assert add(1, 1) == 99
+  0
 test \"all pass\"
   assert add(1, 2) == 3
   assert add(2, 2) == 4
@@ -109,31 +122,29 @@ test \"one fails, rest still runs\"
   assert add(1, 1) == 99
   assert add(2, 2) == 4
-fun hardAssertTrap() -> Int =
-  assert add(1, 1) == 99
-  0
 test \"hard assert traps\"
   assert hardAssertTrap() == 0
 ";
+    let dir = std::env::temp_dir().join(format!("plum_t3_testblocks_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
-    let source = parse(src);
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
     let (bytes, names) = compileTestSource(&source).expect("test source should compile");
     let result = wasmparser::validate(&bytes);
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
+    // The imported std modules contribute their own tests after this file's.
     assert_eq!(
-        names,
+        names[..3],
-        vec![
-            "all pass",
-            "one fails, rest still runs",
+        ["all pass", "one fails, rest still runs", "hard assert traps"]
-            "hard assert traps"
-        ]
     );
     let engine = gcEngine();
     let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
     let mut store = wasmtime::Store::new(&engine, ());
-    let instance =
+    let mut linker = wasmtime::Linker::new(&engine);
+    linker.define_unknown_imports_as_default_values(&mut store, &module).unwrap();
-        wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
+    let instance = linker.instantiate(&mut store, &module).expect("module should instantiate");
     let allPass = instance
         .get_func(&mut store, "test#all pass")
@@ -1057,6 +1068,10 @@ fn crash_import_not_triggered_by_string_literal() {
 #[test]
 fn catch_inside_string_interpolation_compiles() {
     let src = "\
+import std/Str
+import std/Int
+import std/Float
 fun make() -> error{Nope}!Int =
   return error.Nope
@@ -1064,7 +1079,7 @@ fun main() -> Int =
   s := \"v={make() catch 5}\"
   return 1
 ";
-    assert_eq!(runInt(src), 1);
+    assert_eq!(runMerged::<i64>("catch_interp", src), 1);
 }
 // ---- mixed types via enums (T4) ----
@@ -1626,9 +1641,27 @@ fun main() -> Int =
     let path = dir.join("main.plum");
     std::fs::write(&path, src).unwrap();
     let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
-    // Same as any other method of a std type that was not imported: rejected by the checker or by codegen.
+    // Same as any other method of a std type that was not imported: rejected by the checker.
+    assert!(
-    let rejected = plum_checker::checkSource(&source).is_err() || compileSource(&source).is_err();
+        plum_checker::checkSource(&source).is_err(),
-    assert!(rejected, "Bool.toStr without import std/Bool must be rejected");
+        "Bool.toStr without import std/Bool must be rejected by the checker"
+    );
+}
+#[test]
+fn int_tostr_without_import_is_rejected() {
+    // Unmerged source: nothing from std is loaded, so `Int` has no `toStr`.
+    // (The loader itself also refuses a file that uses Int without importing it.)
+    let src = "\
+fun main() -> Str =
+  n := 5
+  return n.toStr()
+";
+    let source = parse(src);
+    assert!(
+        plum_checker::checkSource(&source).is_err(),
+        "Int.toStr without import std/Int must be rejected by the checker"
+    );
 }
 #[test]