142a4b5 | plum | pyrossh

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

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

142a4b5 — Peter John 2026-11-01T21:48:09+05:30

perf: Str wraps an exact-length []Byte directly (was Str{Buffer{arr,len}})

Files changed (9) hide show

plum-checker/src/lib.rs +1 -1
plum-cli/src/main.rs +7 -38
plum-runtime/src/main.rs +14 -26
plum-std/Buffer.plum +12 -0
plum-std/ByteSlice.plum +6 -8
plum-std/Str.plum +15 -26
plum-wasm-codegen/src/lib.rs +24 -71
plum-wasm-codegen/tests/codegen_tests.rs +60 -5
plum-wasm-codegen/tests/examples_test.rs +4 -12

plum-checker/src/lib.rs CHANGED Viewed

@@ -768,7 +768,7 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         (PlumType::TFloat, PlumType::TFloat) => Ok(()),
         (PlumType::TBool, PlumType::TBool) => Ok(()),
         (PlumType::TStr, PlumType::TStr) => Ok(()),
-        // `Str` is an ordinary class (`type Str(...) = data: Buffer ...` in
+        // `Str` is an ordinary class (`type Str(...) = bytes: []Byte ...` in
         // `str.plum`) — a bare `Str(...)` construction (e.g. `bytesToStr`'s own
         // body) infers as `TNamed("Str")` via `inferClassCallRaw`, while a `Str`
         // type ANNOTATION (a param/return type, a string literal) resolves via

plum-cli/src/main.rs CHANGED Viewed

@@ -655,8 +655,7 @@ fn randomI64() -> i64 {
     (z ^ (z >> 31)) as i64
 }
-/// `Str` is now a real two-level wasm-gc struct — `Str{data: Buffer{data:
-/// []Byte, len: Int}}` (see `libs/std/str.plum`'s header comment on `Str`'s
+/// `Str` is now a one-field wasm-gc struct — `Str{bytes: []Byte}` (see `libs/std/str.plum`'s header comment on `Str`'s
 /// shape) — not a raw `array<i8>` directly. Unwraps a `Str` `AnyRef` down to
 /// that raw array, for host-side code (`printLn`, `readStrArg`,
 /// `readStrResult`) that needs the actual bytes.
@@ -665,14 +664,8 @@ fn unwrapStrToArray(
     s: &wasmtime::Rooted<wasmtime::AnyRef>,
 ) -> wasmtime::Result<wasmtime::Rooted<wasmtime::ArrayRef>> {
     let str_struct = s.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(bytes_ref)) = str_struct.field(&mut store, 0)? else {
-        return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
+        return Err(wasmtime::Error::msg("Str.bytes is not a []Byte reference"));
-    };
-    let buffer_struct = buffer_ref.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 0)? else {
-        return Err(wasmtime::Error::msg(
-            "Buffer.data is not a []Byte reference",
-        ));
     };
     bytes_ref.unwrap_array(&store)
 }
@@ -699,8 +692,7 @@ fn readStrArg(
 /// the host-side counterpart to `readStrArg`. Allocates the raw `array<i8>`
 /// (needs the import's own reported `FuncType` to find the concrete nested
 /// array type — a generic `ArrayRef` type would be the wrong, unrelated top
-/// array type), then wraps it in a fresh `Buffer` struct and a `Str` struct
+/// array type), then wraps it in a fresh `Str` struct, mirroring `str.plum`'s real shape.
-/// around that, mirroring `str.plum`'s real shape.
 fn makeStrResult(
     mut caller: impl wasmtime::AsContextMut,
     func_ty: &wasmtime::FuncType,
@@ -718,18 +710,7 @@ fn makeStrResult(
         .as_concrete_struct()
         .ok_or_else(|| wasmtime::Error::msg("expected a concrete struct return type"))?
         .clone();
-    let buffer_ty = str_ty
-        .field(0)
-        .and_then(|f| match f.element_type() {
-            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => {
-                rt.heap_type().as_concrete_struct().cloned()
-            }
-            _ => None,
-        })
-        .ok_or_else(|| {
-            wasmtime::Error::msg("expected Str.data to be a concrete Buffer struct type")
-        })?;
-    let array_ty = buffer_ty
+    let array_ty = str_ty
         .field(0)
         .and_then(|f| match f.element_type() {
             wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => {
@@ -737,28 +718,16 @@ fn makeStrResult(
             }
             _ => None,
         })
-        .ok_or_else(|| {
-            wasmtime::Error::msg("expected Buffer.data to be a concrete []Byte array type")
+        .ok_or_else(|| wasmtime::Error::msg("expected Str.bytes to be a concrete []Byte array type"))?;
-        })?;
     let array_pre = wasmtime::ArrayRefPre::new(&mut caller, array_ty);
     let arr = wasmtime::ArrayRef::new_from_i8_slice(&mut caller, &array_pre, bytes)?;
-    let buffer_pre = wasmtime::StructRefPre::new(&mut caller, buffer_ty);
-    let buffer = wasmtime::StructRef::new(
-        &mut caller,
-        &buffer_pre,
-        &[
-            wasmtime::Val::AnyRef(Some(arr.to_anyref())),
-            wasmtime::Val::I64(bytes.len() as i64),
-        ],
-    )?;
     let str_pre = wasmtime::StructRefPre::new(&mut caller, str_ty);
     let str_val = wasmtime::StructRef::new(
         &mut caller,
         &str_pre,
-        &[wasmtime::Val::AnyRef(Some(buffer.to_anyref()))],
+        &[wasmtime::Val::AnyRef(Some(arr.to_anyref()))],
     )?;
     Ok(str_val.to_anyref())
 }

plum-runtime/src/main.rs CHANGED Viewed

@@ -289,20 +289,15 @@ fn randomI64() -> i64 {
 /// fresh per `plum build` invocation, not linked against `plum-cli`, so the
 /// logic is duplicated rather than shared.
 ///
-/// `Str` is a real two-level wasm-gc struct — `Str{data: Buffer{data: []Byte,
+/// `Str` is a one-field wasm-gc struct — `Str{bytes: []Byte}` — not a raw
-/// len: Int}}` (see `libs/std/str.plum`'s header comment) — not a raw
 /// `array<i8>` directly. Unwraps a `Str` `AnyRef` down to that raw array.
 fn unwrapStrToArray(
     mut store: impl wasmtime::AsContextMut,
     s: &wasmtime::Rooted<wasmtime::AnyRef>,
 ) -> wasmtime::Result<wasmtime::Rooted<wasmtime::ArrayRef>> {
     let str_struct = s.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut store, 0)? else {
+    let wasmtime::Val::AnyRef(Some(bytes_ref)) = str_struct.field(&mut store, 0)? else {
-        return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
-    };
-    let buffer_struct = buffer_ref.unwrap_struct(&store)?;
-    let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut store, 0)? else {
-        return Err(wasmtime::Error::msg("Buffer.data is not a []Byte reference"));
+        return Err(wasmtime::Error::msg("Str.bytes is not a []Byte reference"));
     };
     bytes_ref.unwrap_array(&store)
 }
@@ -321,8 +316,7 @@ fn readStrArg(caller: &mut wasmtime::Caller<'_, ()>, val: &wasmtime::Val) -> was
 /// Builds a new `Str` value from raw bytes — allocates the raw `array<i8>`
 /// (needs the import's own reported `FuncType` to find the concrete nested
 /// array type — a generic `ArrayRef` type would be the wrong, unrelated top
-/// array type), then wraps it in a fresh `Buffer` struct and a `Str` struct
+/// array type), then wraps it in a fresh `Str` struct, mirroring `str.plum`'s real shape.
-/// around that, mirroring `str.plum`'s real shape.
 fn makeStrResult(
     mut caller: impl wasmtime::AsContextMut,
     func_ty: &wasmtime::FuncType,
@@ -336,31 +330,25 @@ fn makeStrResult(
     let str_ty = ref_ty.heap_type().as_concrete_struct()
         .ok_or_else(|| wasmtime::Error::msg("expected a concrete struct return type"))?
         .clone();
-    let buffer_ty = str_ty.field(0)
-        .and_then(|f| match f.element_type() {
-            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_struct().cloned(),
-            _ => None,
-        })
-        .ok_or_else(|| wasmtime::Error::msg("expected Str.data to be a concrete Buffer struct type"))?;
-    let array_ty = buffer_ty.field(0)
+    let array_ty = str_ty
+        .field(0)
         .and_then(|f| match f.element_type() {
-            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => rt.heap_type().as_concrete_array().cloned(),
+            wasmtime::StorageType::ValType(wasmtime::ValType::Ref(rt)) => {
+                rt.heap_type().as_concrete_array().cloned()
+            }
             _ => None,
         })
-        .ok_or_else(|| wasmtime::Error::msg("expected Buffer.data to be a concrete []Byte array type"))?;
+        .ok_or_else(|| wasmtime::Error::msg("expected Str.bytes to be a concrete []Byte array type"))?;
     let array_pre = wasmtime::ArrayRefPre::new(&mut caller, array_ty);
     let arr = wasmtime::ArrayRef::new_from_i8_slice(&mut caller, &array_pre, bytes)?;
-    let buffer_pre = wasmtime::StructRefPre::new(&mut caller, buffer_ty);
+    let str_pre = wasmtime::StructRefPre::new(&mut caller, str_ty);
-    let buffer = wasmtime::StructRef::new(
+    let str_val = wasmtime::StructRef::new(
         &mut caller,
-        &buffer_pre,
+        &str_pre,
-        &[wasmtime::Val::AnyRef(Some(arr.to_anyref())), wasmtime::Val::I64(bytes.len() as i64)],
+        &[wasmtime::Val::AnyRef(Some(arr.to_anyref()))],
     )?;
-    let str_pre = wasmtime::StructRefPre::new(&mut caller, str_ty);
-    let str_val = wasmtime::StructRef::new(&mut caller, &str_pre, &[wasmtime::Val::AnyRef(Some(buffer.to_anyref()))])?;
     Ok(str_val.to_anyref())
 }

plum-std/Buffer.plum CHANGED Viewed

@@ -79,3 +79,15 @@ fun exerciseBufferInit() -> Str =
 test "Buffer() with no args runs init() and works immediately"
   assert exerciseBufferInit() == "hello world"
+test "toStr length equals bytes written, even after capacity doubling"
+  b := Buffer()
+  i := 0
+  while i < 100
+    b.write("ab")
+    i = i + 1
+  b.writeByte(Byte(33))
+  s := b.toStr()
+  assert s.length() == 201
+  assert b.length() == 201
+  assert s.byteAt(200) == 33

plum-std/ByteSlice.plum CHANGED Viewed

@@ -7,9 +7,8 @@ import std/Float
 # ByteSlice is `[]Byte` — Plum's counterpart to Go's byte slice: a
 # fixed-length, mutable sequence of raw bytes backed directly by a wasm-gc
 # `array<i8>` (see `plum-wasm-codegen`'s `PlumType::TByteSlice`) — the same
-# raw array type `Buffer`'s own `data` field uses underneath (`Str` itself is
+# raw array type `Buffer`'s own `data` field uses underneath (`Str` is a record wrapping one of these;
-# now a real two-level struct wrapping a `Buffer`, not this array directly;
-# see `str.plum`'s header comment). Every method here, and `makeBytes`/
+# see `Str.plum`). Every method here, and `makeBytes`/
 # `copyBytes` below, is a compiler intrinsic (see `compileIntrinsicFnBody`)
 # — there's no way to express raw array length/indexing/construction/copying
 # in Plum source itself; `copyStrToBytes`/`bytesToStr` build on top of them
@@ -39,16 +38,15 @@ fun copyBytes(dst: []Byte, dstStart: Int, src: []Byte, srcStart: Int, n: Int) ->
   todo
 # Like `copyBytes`, but the source is a `Str` — ordinary Plum glue over
-# `copyBytes` itself, reaching through `Str`'s real `data: Buffer` field to
+# `copyBytes` itself, reaching through `Str`'s `bytes: []Byte` field.
-# its own `data: []Byte` (see `str.plum`'s header comment on `Str`'s shape).
 fun copyStrToBytes(dst: []Byte, dstStart: Int, src: Str, srcStart: Int, n: Int) -> Unit =
-  copyBytes(dst, dstStart, src.data.data, srcStart, n)
+  copyBytes(dst, dstStart, src.bytes, srcStart, n)
 # Copies out `n` bytes of `src` starting at `start` into a fresh, independent
 # `Str` — never aliases `src`, so mutating `src` afterwards can't
 # retroactively change an already-returned `Str`. Ordinary Plum: allocate a
-# right-sized `[]Byte`, copy into it, wrap it in a fresh `Buffer`/`Str` pair.
+# right-sized `[]Byte`, copy into it, wrap it in a fresh `Str`.
 fun bytesToStr(src: []Byte, start: Int, n: Int) -> Str =
   data := makeBytes(n)
   copyBytes(data, 0, src, start, n)
-  return Str(data: Buffer(data: data, len: n))
+  return Str(bytes: data)

plum-std/Str.plum CHANGED Viewed

@@ -7,37 +7,26 @@ import std/Float
 import std/Byte
 import std/ByteSlice
-# A Str is an immutable byte sequence, backed by a real `Buffer` in its
+# A Str is an immutable byte sequence: an ordinary record wrapping one raw
-# `data` field, not a compiler special case: `Str` is an ordinary
-# wasm-gc struct wrapping a `Buffer` (itself a wasm-gc struct wrapping a raw
-# `[]Byte`), the same generic struct-of-fields codegen every other class
+# `[]Byte` (`bytes`) whose length is exactly the string's length. Not a
-# gets. Only `byteToStr` (build a length-1 `Str` from a raw byte) and the
-# string-literal/concatenation/equality/int-to-string runtime helpers still
-# need to know that shape directly (see `plum-wasm-codegen`'s
-# `compileIntrinsicFnBody`/`registerStringConcatHelper`/etc) — everything
+# compiler special case. Only `byteToStr` and the string-literal/concat/
+# equality/int-to-string runtime helpers know that shape directly (see
-# else, including `length`/`byteAt` below, is expressed by just calling
+# `plum-wasm-codegen`'s `wrapBytesAsStr`/`unwrapStrToBytes`).
-# through to `Buffer`.
 #
-# `Str` values are never actually MUTATED in place — a `Buffer` is mutable,
+# `Str` values are never mutated: nothing may write into a published Str's
-# but nothing here ever reassigns an existing `Str`'s `data` field or writes
-# into its `Buffer` after construction; building a "changed" string always
+# `bytes`. Building a "changed" string always means a fresh array and Str.
-# means constructing a brand new `Str`/`Buffer` pair (`Buffer.write`'s own
-# callers are always building up a FRESH buffer before wrapping it, never
-# mutating an already-published `Str`'s backing storage).
-record Str(data: Buffer) =
+record Str(bytes: []Byte) =
-  # Number of bytes in the string — `self.data` (a `Buffer`) already tracks
+  # Number of bytes in the string (the array's exact length).
-  # this, so unlike `byteAt`/`byteToStr` this needs no compiler intrinsic of
-  # its own.
   fun length(self) -> Int =
-    self.data.length()
+    self.bytes.length()
   # The raw byte value (0-255) at index `i`. Traps if `i` is out of range —
-  # `self.data.data` (the `Buffer`'s own `[]Byte`) is a compiler intrinsic
+  # `self.bytes` is a compiler intrinsic
   # (see `libs/std/bytes.plum`'s `ByteSlice.get`), converted from `Byte` to
   # a plain `Int` since that's this method's established contract.
   fun byteAt(self, i: Int) -> Int =
-    self.data.data.get(i).toInt()
+    self.bytes.get(i).toInt()
   # FNV-1a over the raw UTF-8 bytes — used by `Map[K, V]` (see
   # `map.plum`) to bucket `Str` keys. Not cryptographic, just a well-known,
@@ -279,7 +268,7 @@ record Str(data: Buffer) =
     en := if e > len then len else e
     if s >= en
       return ""
-    return bytesToStr(self.data.data, s, en - s)
+    return bytesToStr(self.bytes, s, en - s)
   fun toLower(self) -> Str =
     mapCase(self, false)
@@ -295,7 +284,7 @@ record Str(data: Buffer) =
       cl := self.codePointByteLength(i)
       if i + cl > n
         cl = n - i
-      copyBytes(out, n - i - cl, self.data.data, i, cl)
+      copyBytes(out, n - i - cl, self.bytes, i, cl)
       i = i + cl
     return bytesToStr(out, 0, n)

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

@@ -919,7 +919,7 @@ pub struct GcTypeRegistry {
     pub known_enums: HashSet<String>,
     /// The single shared `array<i8>` type index `[]Byte`/`Buffer`'s own
     /// `data` field use — NOT `Str`'s own representation (`Str` is an
-    /// ordinary class, `data: Buffer`; see `libs/std/Str.plum`'s header).
+    /// ordinary record, `bytes: []Byte`; see `libs/std/Str.plum`'s header).
     pub byte_array_type_idx: u32,
     /// The single shared closure-value struct type index — `{table_idx: i32, env:
     /// anyref}` — every closure (and zero-capture "trampoline") uses regardless of
@@ -937,7 +937,7 @@ pub struct GcTypeRegistry {
     /// harmlessly never read as such) until/unless the program actually
     /// instantiates `Array` at least once.
     pub array_type_idx: u32,
-    /// Helper `(arr: array<i8>, len: i64) -> Str` building `Str{Buffer{arr,len}}`; `None` when the program has no `Str`/`Buffer`.
+    /// Helper `(arr: array<i8>) -> Str` building `Str{arr}`; `None` when the program has no `Str`.
     pub mk_str_fn: Option<u32>,
     /// `!T` (keyed by `T`) -> its heap box struct `{leaves of T..., code: i32}`.
     pub err_box: HashMap<PlumType, u32>,
@@ -2278,20 +2278,12 @@ fn compileSourceInner(
     module.nameFunction(start_func_idx, "start");
     module.setStartFunction(start_func_idx);
-    if let (Some(&buffer_idx), Some(&str_idx)) = (
-        gc_types.class_type_idx.get("Buffer"),
-        gc_types.class_type_idx.get("Str"),
+    if let Some(&str_idx) = gc_types.class_type_idx.get("Str") {
-    ) {
         let mut b = vec![0u8];
         Instruction::LocalGet(0).encode(&mut b);
-        Instruction::LocalGet(1).encode(&mut b);
-        Instruction::StructNew(buffer_idx).encode(&mut b);
         Instruction::StructNew(str_idx).encode(&mut b);
         Instruction::End.encode(&mut b);
-        let t = module.addType(
-            &[gcRef(gc_types.byte_array_type_idx), ValType::I64],
+        let t = module.addType(&[gcRef(gc_types.byte_array_type_idx)], &[gcRef(str_idx)]);
-            &[gcRef(str_idx)],
-        );
         gc_types.mk_str_fn = Some(module.addFunction(t, &b));
     }
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
@@ -2683,7 +2675,7 @@ fn registerStringConcatHelper(module: &mut WasmModule, byte_array_type_idx: u32)
     body.extend(encodeLeb128U32(1)); // result: ref
     byte_array_ref.encode(&mut body);
-    // arr_a = a.data.data; arr_b = b.data.data
+    // arr_a = a.bytes; arr_b = b.bytes
     Instruction::LocalGet(A).encode(&mut body);
     unwrapStrToBytes(&mut body);
     Instruction::LocalSet(ARR_A).encode(&mut body);
@@ -2734,10 +2726,7 @@ fn registerStringConcatHelper(module: &mut WasmModule, byte_array_type_idx: u32)
     // wrap result (the raw array) back into a real Str
     Instruction::LocalGet(RESULT).encode(&mut body);
-    wrapBytesAsStr(&mut body, |b| {
+    wrapBytesAsStr(&mut body);
-        Instruction::LocalGet(TOTAL_LEN).encode(b);
-        Instruction::I64ExtendI32U.encode(b);
-    });
     Instruction::End.encode(&mut body);
     module.addFunction(type_idx, &body)
@@ -2774,7 +2763,7 @@ fn registerStringEqHelper(module: &mut WasmModule, byte_array_type_idx: u32) ->
     body.extend(encodeLeb128U32(3)); // len_a, len_b, i: i32
     ValType::I32.encode(&mut body);
-    // arr_a = a.data.data; arr_b = b.data.data
+    // arr_a = a.bytes; arr_b = b.bytes
     Instruction::LocalGet(A).encode(&mut body);
     unwrapStrToBytes(&mut body);
     Instruction::LocalSet(ARR_A).encode(&mut body);
@@ -2962,10 +2951,7 @@ fn registerIntToStringHelper(module: &mut WasmModule, byte_array_type_idx: u32)
     Instruction::End.encode(&mut body);
     Instruction::LocalGet(RESULT).encode(&mut body);
-    wrapBytesAsStr(&mut body, |b| {
+    wrapBytesAsStr(&mut body);
-        Instruction::LocalGet(TOTAL_LEN).encode(b);
-        Instruction::I64ExtendI32U.encode(b);
-    });
     Instruction::End.encode(&mut body);
     module.addFunction(type_idx, &body)
@@ -2988,7 +2974,7 @@ 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 `{data: Buffer{data: []Byte, len: Int}}`
+        // wrapped into `Str`'s real `{bytes: []Byte}`
         // shape (see `wrapBytesAsStr`).
         (None, "byteToStr") => {
             let mut body = vec![0u8];
@@ -2999,9 +2985,7 @@ fn compileIntrinsicFnBody(f: &ast::Fn, subst: &Subst) -> Option<Vec<u8>> {
                 array_size: 1,
             }
             .encode(&mut body);
-            wrapBytesAsStr(&mut body, |b| {
+            wrapBytesAsStr(&mut body);
-                Instruction::I64Const(1).encode(b);
-            });
             Instruction::End.encode(&mut body);
             Some(body)
         }
@@ -3087,47 +3071,24 @@ fn strGcValtypeOrFallback(r: &GcTypeRegistry) -> ValType {
     }
 }
-/// Wraps a just-pushed raw `array<i8>` (top of the value stack) — together
+/// Wraps a just-pushed raw `array<i8>` (top of the value stack, whose length
-/// with `push_len`, which must push its length as an `i64` — into `Str`'s
-/// real two-level `{data: Buffer{data: []Byte, len: Int}}` representation:
+/// IS the string's length) into `Str`'s `{bytes: []Byte}` representation via
-/// `struct.new Buffer(arr, len)`, then `struct.new Str(buffer)`. Every codegen
-/// site that builds a `Str` value directly from raw bytes (`byteToStr`,
+/// `mk_str_fn`. Every codegen site that builds a `Str` from raw bytes goes
-/// string literals, the string-concat/int-to-string runtime helpers) goes
-/// through this, so the wrapping logic stays in one place.
+/// through this.
-fn wrapBytesAsStr(body: &mut Vec<u8>, push_len: impl FnOnce(&mut Vec<u8>)) {
+fn wrapBytesAsStr(body: &mut Vec<u8>) {
-    let types = withGcTypes(|r| {
-        r.class_type_idx
-            .get("Buffer")
-            .copied()
-            .zip(r.class_type_idx.get("Str").copied())
-    });
-    // No real `Str`/`Buffer` registered at all (see `strGcValtypeOrFallback`'s
+    // No real `Str` registered at all (see `strGcValtypeOrFallback`'s doc
-    // doc comment) — a raw `array<i8>` already IS this program's "Str", so
+    // comment) — a raw `array<i8>` already IS this program's "Str".
-    // there's nothing to wrap; the array left on the stack by the caller is
-    // the whole value.
-    let Some((buffer_type_idx, str_type_idx)) = types else {
+    let Some(mk) = withGcTypes(|r| r.mk_str_fn) else {
         return;
     };
-    let _ = (buffer_type_idx, str_type_idx);
-    push_len(body);
-    let mk = withGcTypes(|r| r.mk_str_fn).expect("mk_str_fn registered with Str/Buffer");
     Instruction::Call(mk).encode(body);
 }
-/// The inverse of `wrapBytesAsStr`: given a `Str` value already on the stack,
+/// The inverse of `wrapBytesAsStr`: given a `Str` value on the stack, leaves
-/// leaves its raw `array<i8>` (`self.data.data`) on the stack instead —
+/// its raw `array<i8>` (`self.bytes`) there instead: one `struct.get Str 0`.
-/// `struct.get Str 0` (unwrap to the `Buffer`), then `struct.get Buffer 0`
-/// (unwrap to the `[]Byte`). A no-op in the same "Str isn't really
-/// registered" fallback case `wrapBytesAsStr` documents — the value already
-/// on the stack IS the raw array in that case.
+/// A no-op when `Str` isn't registered (the value already IS the array).
 fn unwrapStrToBytes(body: &mut Vec<u8>) {
-    let types = withGcTypes(|r| {
-        r.class_type_idx
-            .get("Buffer")
-            .copied()
-            .zip(r.class_type_idx.get("Str").copied())
+    let Some(str_type_idx) = withGcTypes(|r| r.class_type_idx.get("Str").copied()) else {
-    });
-    let Some((buffer_type_idx, str_type_idx)) = types else {
         return;
     };
     Instruction::StructGet {
@@ -3135,11 +3096,6 @@ fn unwrapStrToBytes(body: &mut Vec<u8>) {
         field_index: 0,
     }
     .encode(body);
-    Instruction::StructGet {
-        struct_type_index: buffer_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
@@ -7139,7 +7095,7 @@ fn compileFieldRead(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    // `Str` is an ordinary class (`data: Buffer`) with no name of its own carried
+    // `Str` is an ordinary record (`bytes: []Byte`) with no name of its own carried
     // in `PlumType::TStr` — resolve it via the literal name "Str", same as a
     // `TNamed`/`TApp` does via its own name.
     let class_name = match (plum_checker::nominalName(obj_ty), obj_ty) {
@@ -7498,10 +7454,7 @@ fn compileStaticString(text: &str, body: &mut Vec<u8>, state: &mut ModuleState)
         array_data_index: data_index,
     }
     .encode(body);
-    let len = bytes.len() as i64;
-    wrapBytesAsStr(body, |b| {
+    wrapBytesAsStr(body);
-        Instruction::I64Const(len).encode(b);
-    });
 }
 /// Lowers a string literal that contains at least one `{expr}` interpolation.

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

@@ -2327,14 +2327,10 @@ fn runWithCrash(name: &str, src: &str) -> (Result<i64, String>, Vec<String>) {
                 .func_new("plum", "crash", ty, |mut caller, params, _| {
                     let wasmtime::Val::AnyRef(Some(s)) = &params[0] else { panic!("Str expected") };
                     let st = s.unwrap_struct(&caller).unwrap();
-                    let wasmtime::Val::AnyRef(Some(buf)) = st.field(&mut caller, 0).unwrap() else { panic!() };
-                    let bs = buf.unwrap_struct(&caller).unwrap();
-                    let wasmtime::Val::AnyRef(Some(arr)) = bs.field(&mut caller, 0).unwrap() else { panic!() };
+                    let wasmtime::Val::AnyRef(Some(arr)) = st.field(&mut caller, 0).unwrap() else { panic!() };
-                    let wasmtime::Val::I64(len) = bs.field(&mut caller, 1).unwrap() else { panic!() };
                     let arr = arr.unwrap_array(&caller).unwrap();
                     let mut b = vec![0u8; arr.len(&caller).unwrap() as usize];
                     arr.copy_to_i8_slice(&mut caller, &mut b).unwrap();
-                    b.truncate(len as usize);
                     caller.data_mut().push(String::from_utf8_lossy(&b).into_owned());
                     Ok(())
                 })
@@ -3134,3 +3130,62 @@ fun main() -> Int =
 ", STD_HEAD));
     assert!(msg.contains("can't take self"), "{msg}");
 }
+/// `Str` is a record with ONE field, the exact-length `[]Byte`: the type
+/// section holds a struct whose single field is a ref to an `array<i8>`, and
+/// the only 2-field array-first struct is `Buffer` itself.
+#[test]
+fn strIsOneStructWithOneByteArrayField() {
+    let src = "import std/Str\nimport std/Int\nimport std/Float\n\nfun main() -> Int =\n  \"hello\".length()\n";
+    let dir = std::env::temp_dir().join(format!("plum_strshape_{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("main.plum");
+    std::fs::write(&path, src).unwrap();
+    let source = plum_core::loadAndMerge(&path, &repoRoot()).expect("load");
+    let bytes = compileSource(&source).expect("compile failed");
+    let _ = std::fs::remove_dir_all(&dir);
+    let mut byte_arrays = std::collections::HashSet::new();
+    let (mut one_field, mut buffer_like) = (0, 0);
+    let mut idx = 0u32;
+    for payload in wasmparser::Parser::new(0).parse_all(&bytes) {
+        if let wasmparser::Payload::TypeSection(s) = payload.unwrap() {
+            for g in s {
+                for t in g.unwrap().types() {
+                    match &t.composite_type.inner {
+                        wasmparser::CompositeInnerType::Array(a) => {
+                            if matches!(a.0.element_type, wasmparser::StorageType::I8) {
+                                byte_arrays.insert(idx);
+                            }
+                        }
+                        wasmparser::CompositeInnerType::Struct(st) => {
+                            let is_arr = |f: &wasmparser::FieldType| match f.element_type {
+                                wasmparser::StorageType::Val(wasmparser::ValType::Ref(r)) => {
+                                    matches!(r.heap_type(), wasmparser::HeapType::Concrete(u) if u.as_module_index().map_or(false, |i| byte_arrays.contains(&i)))
+                                }
+                                _ => false,
+                            };
+                            if st.fields.len() == 1 && is_arr(&st.fields[0]) {
+                                one_field += 1;
+                            }
+                            if st.fields.len() == 2 && is_arr(&st.fields[0]) {
+                                buffer_like += 1;
+                            }
+                        }
+                        _ => {}
+                    }
+                    idx += 1;
+                }
+            }
+        }
+    }
+    assert_eq!(one_field, 1, "expected exactly Str{{bytes}}");
+    // Buffer{data, len} still exists as its own record (Str imports it).
+    assert_eq!(buffer_like, 1);
+    assert_eq!(runWithCrash("strshape", src).0.unwrap(), 5);
+}
+#[test]
+fn bufferToStrLengthExactAfterDoubling() {
+    let src = "import std/Str\nimport std/Buffer\nimport std/Int\nimport std/Float\n\nfun main() -> Int =\n  b := Buffer()\n  i := 0\n  while i < 37\n    b.write(\"abc\")\n    i = i + 1\n  b.toStr().length() * 1000 + b.length()\n";
+    assert_eq!(runWithCrash("bufexact", src).0.unwrap(), 111111);
+}

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

@@ -123,9 +123,8 @@ fn ioExampleCompilesAndRunsCorrectly() {
         .func()
         .cloned()
         .expect("plum::printLn import should be a function");
-    // `Str` is a real two-level struct now — `Str{data: Buffer{data: []Byte,
-    // len: Int}}` (see `libs/std/str.plum`'s header comment) — not a raw
+    // `Str` is a one-field struct now — `Str{bytes: []Byte}` (see `libs/std/str.plum`'s header comment) — not a raw
-    // `array<i8>` directly, so unwrap through both `struct.get`s before
+    // `array<i8>` directly, so unwrap through the `struct.get` before
     // reading the actual bytes (mirrors `plum-cli`'s `unwrapStrToArray`).
     let print_ln = wasmtime::Func::new(
         &mut store,
@@ -135,15 +134,8 @@ fn ioExampleCompilesAndRunsCorrectly() {
                 return Err(wasmtime::Error::msg("printLn expects a Str argument"));
             };
             let str_struct = s.unwrap_struct(&caller)?;
-            let wasmtime::Val::AnyRef(Some(buffer_ref)) = str_struct.field(&mut caller, 0)? else {
+            let wasmtime::Val::AnyRef(Some(bytes_ref)) = str_struct.field(&mut caller, 0)? else {
-                return Err(wasmtime::Error::msg("Str.data is not a Buffer reference"));
+                return Err(wasmtime::Error::msg("Str.bytes is not a []Byte reference"));
-            };
-            let buffer_struct = buffer_ref.unwrap_struct(&caller)?;
-            let wasmtime::Val::AnyRef(Some(bytes_ref)) = buffer_struct.field(&mut caller, 0)?
-            else {
-                return Err(wasmtime::Error::msg(
-                    "Buffer.data is not a []Byte reference",
-                ));
             };
             let arr = bytes_ref.unwrap_array(&caller)?;
             let len = arr.len(&caller)?;