13507fa | plum | pyrossh

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

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

13507fa — Peter John 2026-09-07T15:28:19+05:30

feat(class/enum): mutable fields + Gleam-style spread update

Files changed (9) hide show

plum-checker/src/lib.rs +81 -56
plum-core/src/ast.rs +5 -0
plum-core/src/parser.rs +15 -10
plum-examples/types.plum +33 -0
plum-tooling/tree-sitter-plum/grammar.js +13 -4
plum-tooling/tree-sitter-plum/src/grammar.json +0 -0
plum-tooling/tree-sitter-plum/src/node-types.json +0 -0
plum-tooling/tree-sitter-plum/src/parser.c +0 -0
plum-wasm-codegen/src/lib.rs +77 -25

plum-checker/src/lib.rs CHANGED Viewed

@@ -721,15 +721,13 @@ fn checkStmt(stmt: &ast::Stmt, env: &mut TypeEnv, declared_ret: &PlumType, fn_na
                         let label = format!("{}.{}", describeTargetObject(object), field_name);
                         match (inferExpr(object, env, ctx), inferExpr(value, env, ctx)) {
                             (Ok(PlumType::TNamed(class_name)), Ok(value_ty)) => {
-                                match ctx.classes.get(&class_name).and_then(|fields| {
+                                match lookupFieldType(&class_name, field_name, ctx) {
-                                    fields.iter().find(|(n, _)| n == field_name).map(|(_, ty)| ty.clone())
-                                }) {
-                                    Some(field_ty) => {
+                                    Ok(field_ty) => {
                                         if let Err(msg) = unifyArg(&field_ty, &value_ty, value, ctx) {
                                             errors.push(CheckError { message: format!("fn '{}': assign '{}': {}", fn_name, label, msg) });
                                         }
                                     }
-                                    None => errors.push(CheckError { message: format!("fn '{}': assign '{}': no field '{}' on class '{}'", fn_name, label, field_name, class_name) }),
+                                    Err(msg) => errors.push(CheckError { message: format!("fn '{}': assign '{}': {}", fn_name, label, msg) }),
                                 }
                             }
                             (Ok(other), Ok(_)) => errors.push(CheckError { message: format!("fn '{}': assign '{}': cannot access field on non-class type {}", fn_name, label, other) }),
@@ -899,6 +897,28 @@ fn initCallableWithNoArgs(params: &[PlumType]) -> bool {
     params.is_empty() || matches!(params, [PlumType::TVariadic(_)])
 }
+/// Validates a `Type(..source, ...)` spread entry: `source` must be a bare
+/// variable/`self` (codegen recomputes it once per missing field via a plain
+/// `LocalGet`, rather than allocating a scratch local — an arbitrary expression
+/// would either re-evaluate side effects or require one) and its type must be
+/// `expected_type_name` — for a class construction, that's the class itself;
+/// for a named-payload enum variant, it's the OWNING ENUM (not the variant),
+/// deliberately a plain `unify` rather than `unifyArg`'s syntactic exact-variant
+/// check: a variable's inferred type is always the widened enum, never a
+/// specific variant (see `unifyArg`'s own doc comment), so requiring exact-variant
+/// proof here would reject passing any ordinary variable — the missing-field
+/// reads codegen emits for a spread are already a checked downcast (same
+/// runtime-trapping idiom plain `.field` access on an enum value already uses),
+/// so no static proof beyond "same enum" is needed.
+fn checkSpreadSource(spread: &ast::Expr, label: &str, expected_type_name: &str, env: &TypeEnv, ctx: &CheckCtx) -> Result<(), String> {
+    if !matches!(spread, ast::Expr::Var(_) | ast::Expr::Self_) {
+        return Err(format!("spread source for '{}(..)' must be a variable", label));
+    }
+    let actual = inferExpr(spread, env, ctx)?;
+    unify(&PlumType::TNamed(expected_type_name.to_string()), &actual, ctx)
+        .map_err(|e| format!("spread source for '{}': {}", label, e))
+}
 fn inferClassCallRaw(call: &ast::ClassCall, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
     // A zero-arg `Type()` construction with a nested, no-param `fun init() ->
     // Type = ...` method declared is sugar for calling that method — the
@@ -925,9 +945,14 @@ fn inferClassCallRaw(call: &ast::ClassCall, env: &TypeEnv, ctx: &CheckCtx) -> Re
                     None => return Err(format!("unknown field '{}' on class '{}'", fa.name, call.type_name)),
                 }
             }
+            match &call.spread {
+                Some(spread) => checkSpreadSource(spread, &call.type_name, &call.type_name, env, ctx)?,
+                None => {
-            for (field_name, _) in fields {
+                    for (field_name, _) in fields {
-                if !call.fields.iter().any(|fa| &fa.name == field_name) {
+                        if !call.fields.iter().any(|fa| &fa.name == field_name) {
-                    return Err(format!("class '{}' missing field '{}'", call.type_name, field_name));
+                            return Err(format!("class '{}' missing field '{}'", call.type_name, field_name));
+                        }
+                    }
                 }
             }
             Ok(PlumType::TNamed(call.type_name.clone()))
@@ -950,9 +975,14 @@ fn inferClassCallRaw(call: &ast::ClassCall, env: &TypeEnv, ctx: &CheckCtx) -> Re
                     None => return Err(format!("unknown field '{}' on variant '{}'", fa.name, call.type_name)),
                 }
             }
+            match &call.spread {
+                Some(spread) => checkSpreadSource(spread, &call.type_name, &info.enum_name, env, ctx)?,
+                None => {
-            for field_name in &info.field_names {
+                    for field_name in &info.field_names {
-                if !call.fields.iter().any(|fa| &fa.name == field_name) {
+                        if !call.fields.iter().any(|fa| &fa.name == field_name) {
-                    return Err(format!("variant '{}' missing field '{}'", call.type_name, field_name));
+                            return Err(format!("variant '{}' missing field '{}'", call.type_name, field_name));
+                        }
+                    }
                 }
             }
             Ok(PlumType::TNamed(info.enum_name.clone()))
@@ -1100,6 +1130,45 @@ fn resolveClosureParamFromFieldUsage(
     }
 }
+/// Resolves `class_name`'s field named `field_name` to its type — shared by
+/// `.field` reads (`inferExpr`'s `AttrKind::Field` arm) and `.field = value`
+/// writes (`checkStmt`'s `AssignTarget::Field` arm), so mutation gets the same
+/// class / discriminant-enum-param / single-owning-variant fallback chain
+/// reads already have. See the call sites' own comments for why each fallback
+/// is safe (in particular: exactly one variant may own a given field name;
+/// more than one is ambiguous and a compile error).
+fn lookupFieldType(class_name: &str, field_name: &str, ctx: &CheckCtx) -> Result<PlumType, String> {
+    match ctx.classes.get(class_name) {
+        Some(fields) => fields.iter()
+            .find(|(n, _)| n == field_name)
+            .map(|(_, t)| t.clone())
+            .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
+        None => match ctx.enum_params.get(class_name) {
+            Some(params) => params.iter()
+                .find(|(n, _)| n == field_name)
+                .map(|(_, t)| t.clone())
+                .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
+            None => {
+                let owners: Vec<&EnumVariantInfo> = ctx.enum_variants.values()
+                    .filter(|info| info.enum_name == class_name
+                        && info.field_names.iter().any(|n| n == field_name))
+                    .collect();
+                match owners.as_slice() {
+                    [info] => {
+                        let idx = info.field_names.iter().position(|n| n == field_name).expect("just filtered on this");
+                        Ok(info.field_types[idx].clone())
+                    }
+                    [] => Ok(PlumType::TVar("_".to_string())),
+                    _ => Err(format!(
+                        "field '{}' is ambiguous across multiple variants of enum '{}' — use a match",
+                        field_name, class_name
+                    )),
+                }
+            }
+        },
+    }
+}
 pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
     match expr {
         ast::Expr::Int(_) => Ok(PlumType::TInt),
@@ -1362,51 +1431,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                             PlumType::TNamed(n) => n.as_str(),
                             _ => "Str",
                         };
-                        match ctx.classes.get(class_name) {
-                            Some(fields) => fields.iter()
-                                .find(|(n, _)| n == field_name)
+                        lookupFieldType(class_name, field_name, ctx)
-                                .map(|(_, t)| t.clone())
-                                .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
-                            None => match ctx.enum_params.get(class_name) {
-                                Some(params) => params.iter()
-                                    .find(|(n, _)| n == field_name)
-                                    .map(|(_, t)| t.clone())
-                                    .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
-                                // Not a discriminant enum either: `class_name` might
-                                // still be an ordinary enum whose value provably came
-                                // from a named-payload variant (`Circle(radius: 5)`,
-                                // widened to `TNamed("Shape")` by construction — see
-                                // `inferClassCallRaw`). If exactly ONE of the enum's
-                                // variants declares a field with this name, `.field`
-                                // is safe to allow here: codegen compiles it as a
-                                // checked downcast to that one variant (traps at
-                                // runtime if the value turns out to be a different
-                                // variant), so no static proof the value IS that
-                                // variant is required. If more than one variant
-                                // shares the field name, which one's value would win
-                                // is genuinely ambiguous — require a real `match`
-                                // instead. Zero owners means an unmodeled type
-                                // (unresolved generic, etc.) — allow, codegen will
-                                // catch a genuine mismatch.
-                                None => {
-                                    let owners: Vec<&EnumVariantInfo> = ctx.enum_variants.values()
-                                        .filter(|info| info.enum_name == class_name
-                                            && info.field_names.iter().any(|n| n == field_name))
-                                        .collect();
-                                    match owners.as_slice() {
-                                        [info] => {
-                                            let idx = info.field_names.iter().position(|n| n == field_name).expect("just filtered on this");
-                                            Ok(info.field_types[idx].clone())
-                                        }
-                                        [] => Ok(PlumType::TVar("_".to_string())),
-                                        _ => Err(format!(
-                                            "field '{}' is ambiguous across multiple variants of enum '{}' — use a match",
-                                            field_name, class_name
-                                        )),
-                                    }
-                                }
-                            },
-                        }
                     }
                     // An unresolved generic method return (e.g. `Result[T, E].unwrap()`'s
                     // bare `T`, which this checker's `PlumType` erases entirely — see

plum-core/src/ast.rs CHANGED Viewed

@@ -450,6 +450,11 @@ pub struct ClassCall {
     /// class's own field VALUES can't pin down its type params on their own
     /// (e.g. constructing an empty `List` with nothing to infer `T` from).
     pub generics: Vec<Type>,
+    /// Gleam-style `Type(..source, field: value, ...)` update — fields not
+    /// listed in `fields` are read from `source` instead of being required.
+    /// Restricted to a bare variable/`self` (see `plum-checker`'s `inferClassCallRaw`)
+    /// so codegen can recompute it once per missing field with no scratch local.
+    pub spread: Option<Box<Expr>>,
 }
 #[derive(Debug, Clone, PartialEq)]

plum-core/src/parser.rs CHANGED Viewed

@@ -892,24 +892,29 @@ impl<'a> AstParser<'a> {
                 .map(|n| self.parseType(n))
                 .collect()
         };
+        let mut spread = None;
         let fields = node.child_by_field_name("arguments")
             .map(|args_node| {
-                // class_argument_list: "(" (var_identifier ":" expression),* ")"
+                // class_argument_list: "(" (spread_argument | field_argument),* ")"
-                // Named children alternate: var_identifier, expression, ...
+                // — each named child is one of those two wrapper nodes.
                 let mut cursor = args_node.walk();
-                let named: Vec<Node> = args_node.named_children(&mut cursor).collect();
+                args_node.named_children(&mut cursor).filter_map(|n| match n.kind() {
-                named.chunks(2).filter_map(|chunk| {
-                    if chunk.len() == 2 {
-                        let name = self.text(chunk[0]);
+                    "spread_argument" => {
+                        let vn = n.child_by_field_name("value").expect("spread_argument has a value");
-                        let u = self.unwrapExprNode(chunk[1]);
+                        let u = self.unwrapExprNode(vn);
-                        Some(FieldArg { name, value: self.parseExpression(u) })
+                        spread = Some(Box::new(self.parseExpression(u)));
-                    } else {
                         None
                     }
+                    _ => {
+                        let name = n.child_by_field_name("name").map(|nn| self.text(nn)).unwrap_or_default();
+                        let vn = n.child_by_field_name("value").expect("field_argument has a value");
+                        let u = self.unwrapExprNode(vn);
+                        Some(FieldArg { name, value: self.parseExpression(u) })
+                    }
                 }).collect()
             })
             .unwrap_or_default();
-        ClassCall { type_name, fields, generics }
+        ClassCall { type_name, fields, generics, spread }
     }
     // ---- string literals --------------------------------------------------

plum-examples/types.plum CHANGED Viewed

@@ -202,6 +202,39 @@ test "enum class field construct and destructure runs correctly"
   b := OptionBox(value: Some(42))
   assert b.unwrap(0) == 42
+test "class field mutation and spread update run correctly"
+  p := Point(x: 1, y: 2)
+  p.x = 10
+  assert p.x == 10
+  assert p.y == 2
+  p2 := Point(..p, x: 100)
+  assert p2.x == 100
+  assert p2.y == 2
+  # the spread source is untouched by the update it fed
+  assert p.x == 10
+test "single-variant named-payload enum field mutation and spread update run correctly"
+  v := Vec2(x: 1, y: 2)
+  v.x = 10
+  assert v.x == 10
+  assert v.y == 2
+  v2 := Vec2(..v, x: 100)
+  assert v2.x == 100
+  assert v2.y == 2
+  assert v.x == 10
+test "multi-variant enum field mutation and spread update run correctly"
+  # Same checked-downcast idiom `.field` reads already use on a
+  # multi-variant enum's uniquely-owned field name (see the test above
+  # about `ShapeWithFields`) — traps at runtime if the value is ever the
+  # OTHER variant, no static proof required.
+  c := CircleField(radius: 5)
+  c.radius = 9
+  assert c.radius == 9
+  c2 := CircleField(..c, radius: 50)
+  assert c2.radius == 50
+  assert c.radius == 9
 test "gc type registry produces a well formed type section alongside bump allocator codegen"
   # Task 1 Step 5 of the wasm-gc migration plan: the wasm-gc type registry
   # emits a well-formed type section — a struct type per class, a

plum-tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -562,13 +562,22 @@ module.exports = grammar({
     class_argument_list: ($) =>
       seq(
         "(",
-        optional(
+        optional(seq(
-          commaSep1(seq(field("name", $.var_identifier), ":", field("value", $.expression)),),
+          commaSep1(choice($.spread_argument, $.field_argument)),
-        ),
-        optional(","),
+          optional(","),
+        )),
         ")",
       ),
+    field_argument: ($) =>
+      seq(field("name", $.var_identifier), ":", field("value", $.expression)),
+    // Gleam-style functional-update entry: `Point(..p, x: 10)` — fields not
+    // named after it are read from `p` instead of being required. Only ever
+    // valid as the FIRST argument — enforced by `plum-core`'s parser, not here.
+    spread_argument: ($) =>
+      seq("..", field("value", $.expression)),
     ternary_expression: ($) =>
       prec.right(
         PREC.conditional,

plum-tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/parser.c CHANGED Viewed

Binary file

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

@@ -812,7 +812,7 @@ fn buildGcTypeRegistry(
             let params = enum_params.get(enum_name).cloned().unwrap_or_default();
             let field_types: Vec<FieldType> = params.iter().map(|(_, ty)| FieldType {
                 element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
-                mutable: false,
+                mutable: true,
             }).collect();
             SubType {
                 is_final: false,
@@ -831,7 +831,7 @@ fn buildGcTypeRegistry(
             // subtyping, so no special-casing is needed here.
             let field_types: Vec<FieldType> = info.field_types.iter().map(|ty| FieldType {
                 element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
-                mutable: false,
+                mutable: true,
             }).collect();
             SubType {
                 is_final: true,
@@ -3304,22 +3304,51 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                             PlumType::TNamed(n) => n.clone(),
                             other => return Err(format!("codegen: cannot assign field '{}' on non-class type {}", field_name, other)),
                         };
-                        let fields = ctx
-                            .classes
-                            .get(&class_name)
-                            .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
-                        let field_idx = fields
-                            .iter()
-                            .position(|(n, _)| n == field_name)
-                            .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
-                        let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
-                            .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
                         // struct.set expects [(ref null $t) value] on the stack (ref
                         // pushed first/deeper, value second/on top) — same push order
-                        // this already used for the old memory store.
+                        // this already used for the old memory store. Mirrors the read
+                        // side's class / discriminant-enum-param / single-owning-variant
+                        // fallback chain (`AttrKind::Field` below) so a named-payload
+                        // enum variant's own field can be mutated too, not just a class's.
+                        match ctx.classes.get(&class_name) {
+                            Some(fields) => {
+                                let field_idx = fields
+                                    .iter()
+                                    .position(|(n, _)| n == field_name)
+                                    .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                                let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
+                                    .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
-                        compileExpr(object, body, ctx, state)?;
+                                compileExpr(object, body, ctx, state)?;
-                        compileExpr(value, body, ctx, state)?;
+                                compileExpr(value, body, ctx, state)?;
-                        Instruction::StructSet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
+                                Instruction::StructSet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
+                            }
+                            None => match ctx.enum_params.get(&class_name) {
+                                Some(params) => {
+                                    let field_idx = params
+                                        .iter()
+                                        .position(|(n, _)| n == field_name)
+                                        .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+                                    let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
+                                        .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
+                                    compileExpr(object, body, ctx, state)?;
+                                    compileExpr(value, body, ctx, state)?;
+                                    Instruction::StructSet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
+                                }
+                                None => {
+                                    let (variant_name, info) = ctx.enum_variants.iter()
+                                        .find(|(_, info)| info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name))
+                                        .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+                                    let field_idx = info.field_names.iter().position(|n| n == field_name)
+                                        .expect("just found by this field name");
+                                    let variant_type_idx = *ctx.gc_types.variant_type_idx.get(variant_name)
+                                        .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
+                                    compileExpr(object, body, ctx, state)?;
+                                    Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
+                                    compileExpr(value, body, ctx, state)?;
+                                    Instruction::StructSet { struct_type_index: variant_type_idx, field_index: field_idx as u32 }.encode(body);
+                                }
+                            },
+                        }
                     }
                 }
             }
@@ -4382,7 +4411,7 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
         // the equivalent static method-call expression and let the existing
         // `AttrKind::Method` codegen (below) handle it, rather than duplicating that
         // logic here.
-        ast::Expr::ClassCall(call) if call.fields.is_empty()
+        ast::Expr::ClassCall(call) if call.fields.is_empty() && call.spread.is_none()
             && matches!(ctx.methods.get(&(call.type_name.clone(), "init".to_string())), Some(PlumType::TFun(p, _)) if initCallableWithNoArgs(p)) =>
         {
             let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
@@ -4406,10 +4435,26 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             let variant_idx = *ctx.gc_types.variant_type_idx.get(&call.type_name)
                 .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", call.type_name))?;
             let field_names = info.field_names.clone();
-            for field_name in &field_names {
+            for (field_idx, field_name) in field_names.iter().enumerate() {
-                let fa = call.fields.iter().find(|fa| &fa.name == field_name)
+                match call.fields.iter().find(|fa| &fa.name == field_name) {
+                    Some(fa) => compileExpr(&fa.value, body, ctx, state)?,
+                    // `Circle(..c, radius: 10)` — a field not overridden is read
+                    // straight off the spread source instead (checker only proved
+                    // `c` is SOME value of the owning enum, restricted to a bare
+                    // variable/`self` — see `checkSpreadSource` — not statically
+                    // that it's exactly this variant, so a checked `ref.cast` down
+                    // to this variant's own struct type is needed here, same as
+                    // plain `.field` access on a multi-variant enum value already
+                    // does; recompiling the source is just a cheap `LocalGet`, not
+                    // a re-evaluation of anything with side effects).
+                    None => {
+                        let spread = call.spread.as_ref()
-                    .ok_or_else(|| format!("codegen: variant '{}' missing field '{}'", call.type_name, field_name))?;
+                            .ok_or_else(|| format!("codegen: variant '{}' missing field '{}'", call.type_name, field_name))?;
-                compileExpr(&fa.value, body, ctx, state)?;
+                        compileExpr(spread, body, ctx, state)?;
+                        Instruction::RefCastNonNull(HeapType::Concrete(variant_idx)).encode(body);
+                        Instruction::StructGet { struct_type_index: variant_idx, field_index: field_idx as u32 }.encode(body);
+                    }
+                }
             }
             Instruction::StructNew(variant_idx).encode(body);
         }
@@ -4426,10 +4471,17 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             let class_type_idx = *ctx.gc_types.class_type_idx.get(&call.type_name)
                 .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", call.type_name))?;
-            for (field_name, _) in &fields {
+            for (field_idx, (field_name, _)) in fields.iter().enumerate() {
-                let fa = call.fields.iter().find(|fa| &fa.name == field_name)
+                match call.fields.iter().find(|fa| &fa.name == field_name) {
+                    Some(fa) => compileExpr(&fa.value, body, ctx, state)?,
+                    // See the matching comment in the variant-construction arm above.
+                    None => {
+                        let spread = call.spread.as_ref()
-                    .ok_or_else(|| format!("codegen: class '{}' missing field '{}'", call.type_name, field_name))?;
+                            .ok_or_else(|| format!("codegen: class '{}' missing field '{}'", call.type_name, field_name))?;
-                compileExpr(&fa.value, body, ctx, state)?;
+                        compileExpr(spread, body, ctx, state)?;
+                        Instruction::StructGet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
+                    }
+                }
             }
             Instruction::StructNew(class_type_idx).encode(body);
         }