01f9be3 | plum

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

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

01f9be3 — Peter John 2026-07-23T18:56:23+05:30

feat(plum-wasm-codegen): compile obj.field = value assignment targets

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +96 -47
plum-wasm-codegen/tests/codegen_tests.rs +57 -0

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

@@ -940,9 +940,16 @@ impl<'a, 'c> ClosureWalker<'a, 'c> {
             ast::Stmt::Assign(a) => {
                 for (target, value) in a.targets.iter().zip(a.values.iter()) {
                     self.walk_expr(value, None);
+                    match target {
+                        ast::AssignTarget::Var(name) => {
-                    let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
+                            let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
-                    self.env.insert(target.clone(), TypeScheme::mono(ty));
+                            self.env.insert(name.clone(), TypeScheme::mono(ty));
-                    self.locals.insert(target.clone());
+                            self.locals.insert(name.clone());
+                        }
+                        ast::AssignTarget::Field(object, _) => {
+                            self.walk_expr(object, None);
+                        }
+                    }
                 }
             }
             ast::Stmt::Return(Some(e)) => self.walk_expr(e, None),
@@ -1335,7 +1342,9 @@ fn fv_collect_bound_block(block: &ast::Block, bound: &mut std::collections::Hash
         match s {
             ast::Stmt::Assign(a) => {
                 for t in &a.targets {
+                    if let ast::AssignTarget::Var(name) = t {
-                    bound.insert(t.clone());
+                        bound.insert(name.clone());
+                    }
                 }
             }
             ast::Stmt::For(f) => {
@@ -1393,6 +1402,11 @@ fn fv_collect_refs_block(
                 for v in &a.values {
                     fv_collect_refs_expr(v, bound, seen, free, env, fn_decls);
                 }
+                for t in &a.targets {
+                    if let ast::AssignTarget::Field(object, _) = t {
+                        fv_collect_refs_expr(object, bound, seen, free, env, fn_decls);
+                    }
+                }
             }
             ast::Stmt::Return(Some(e)) | ast::Stmt::Expr(e) | ast::Stmt::Assert(e) => {
                 fv_collect_refs_expr(e, bound, seen, free, env, fn_decls);
@@ -1573,23 +1587,30 @@ impl<'a> Collector<'a> {
             ast::Stmt::Assign(a) => {
                 for (target, value) in a.targets.iter().zip(a.values.iter()) {
                     self.walk_expr(value);
+                    match target {
+                        ast::AssignTarget::Var(name) => {
-                    let ty = if matches!(value, ast::Expr::Closure(_)) {
+                            let ty = if matches!(value, ast::Expr::Closure(_)) {
-                        // The checker's own closure inference (`infer_expr` on
+                                // The checker's own closure inference (`infer_expr` on
-                        // `Expr::Closure`) infers the return type by recursively
+                                // `Expr::Closure`) infers the return type by recursively
-                        // inferring the body's tail expression with each param bound
+                                // inferring the body's tail expression with each param bound
-                        // to a fresh, unconstrained `TVar` — e.g. a captured/param
+                                // to a fresh, unconstrained `TVar` — e.g. a captured/param
-                        // attribute access (`c.age`) on a `TVar`-typed object isn't a
+                                // attribute access (`c.age`) on a `TVar`-typed object isn't a
-                        // known class, so it errors out entirely, and this call site
+                                // known class, so it errors out entirely, and this call site
-                        // then silently defaults to `TInt` — the *wrong* wasm local
+                                // then silently defaults to `TInt` — the *wrong* wasm local
-                        // width for what's actually always an `i32` pointer. All that
+                                // width for what's actually always an `i32` pointer. All that
-                        // actually matters here is the local's wasm width, and every
+                                // actually matters here is the local's wasm width, and every
-                        // closure value is an i32 pointer regardless of its
+                                // closure value is an i32 pointer regardless of its
-                        // parameter/return types, so skip inference entirely.
+                                // parameter/return types, so skip inference entirely.
-                        PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
+                                PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
-                    } else {
+                            } else {
-                        plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt)
+                                plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt)
-                    };
+                            };
-                    self.bind(target, ty);
+                            self.bind(name, ty);
+                        }
+                        ast::AssignTarget::Field(object, _) => {
+                            self.walk_expr(object);
+                        }
+                    }
                 }
             }
             ast::Stmt::Return(Some(e)) => self.walk_expr(e),
@@ -1981,32 +2002,60 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
     match stmt {
         ast::Stmt::Assign(a) => {
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                match target {
+                    ast::AssignTarget::Var(name) => {
-                // See the matching comment in `Collector::walk_stmt`: the checker's
+                        // See the matching comment in `Collector::walk_stmt`: the checker's
-                // closure inference is unreliable (can error out entirely depending
+                        // closure inference is unreliable (can error out entirely depending
-                // on the body), but every closure value is an i32 pointer regardless
+                        // on the body), but every closure value is an i32 pointer regardless
-                // of its real signature, so don't bother inferring it at all here.
+                        // of its real signature, so don't bother inferring it at all here.
-                let vty = if matches!(value, ast::Expr::Closure(_)) {
+                        let vty = if matches!(value, ast::Expr::Closure(_)) {
-                    PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
+                            PlumType::TFun(Vec::new(), Box::new(PlumType::TUnit))
-                } else {
+                        } else {
-                    infer_local_type(value, ctx)
+                            infer_local_type(value, ctx)
-                };
+                        };
-                compile_expr(value, body, ctx, state)?;
+                        compile_expr(value, body, ctx, state)?;
-                let idx = ctx
+                        let idx = ctx
-                    .locals
+                            .locals
-                    .get(target)
+                            .get(name)
-                    .copied()
+                            .copied()
-                    .ok_or_else(|| format!("undeclared local '{}'", target))?;
+                            .ok_or_else(|| format!("undeclared local '{}'", name))?;
-                Instruction::LocalSet(idx).encode(body);
+                        Instruction::LocalSet(idx).encode(body);
-                ctx.type_env.borrow_mut().insert(target.clone(), TypeScheme::mono(vty));
+                        ctx.type_env.borrow_mut().insert(name.clone(), TypeScheme::mono(vty));
-                // If this assigns a closure *literal*, remember its exact, already-
+                        // If this assigns a closure *literal*, remember its exact, already-
-                // correct signature (computed by the discovery pass) so a later call
+                        // correct signature (computed by the discovery pass) so a later call
-                // to it doesn't have to re-derive one — see `closure_local_sigs`.
+                        // to it doesn't have to re-derive one — see `closure_local_sigs`.
-                if let ast::Expr::Closure(cl) = value {
+                        if let ast::Expr::Closure(cl) = value {
-                    let key = cl.as_ref() as *const ast::Closure as usize;
+                            let key = cl.as_ref() as *const ast::Closure as usize;
-                    if let Some(info) = ctx.closures.get(&key) {
+                            if let Some(info) = ctx.closures.get(&key) {
-                        let mut sig_params = vec![ValType::I32];
+                                let mut sig_params = vec![ValType::I32];
-                        sig_params.extend(info.param_vts.iter().copied());
+                                sig_params.extend(info.param_vts.iter().copied());
-                        ctx.closure_local_sigs.borrow_mut().insert(target.clone(), (sig_params, info.ret_vt));
+                                ctx.closure_local_sigs.borrow_mut().insert(name.clone(), (sig_params, info.ret_vt));
+                            }
+                        }
+                    }
+                    ast::AssignTarget::Field(object, field_name) => {
+                        let obj_ty = infer_local_type(object, ctx);
+                        let class_name = match &obj_ty {
+                            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, field_ty) = fields
+                            .iter()
+                            .position(|(n, _)| n == field_name)
+                            .map(|i| (i, fields[i].1.clone()))
+                            .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                        compile_expr(object, body, ctx, state)?;
+                        compile_expr(value, body, ctx, state)?;
+                        let offset = (field_idx as u64) * 8;
+                        match plum_type_to_valtype(&field_ty) {
+                            ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                            ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                            _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                        };
                     }
                 }
             }

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

@@ -1369,3 +1369,60 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 7);
 }
+#[test]
+fn field_assignment_target_runs_correctly() {
+    let src = "\
+type Counter =
+  value: Int
+bump<Counter>() =
+  self.value = self.value + 1
+main() -> Int =
+  c = Counter(value: 41)
+  c.bump()
+  c.value
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}
+#[test]
+fn chained_field_assignment_target_runs_correctly() {
+    let src = "\
+type Inner =
+  value: Int
+type Outer =
+  inner: Inner
+bump<Outer>() =
+  self.inner.value = self.inner.value + 1
+main() -> Int =
+  o = Outer(inner: Inner(value: 9))
+  o.bump()
+  o.inner.value
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 10);
+}
+#[test]
+fn mixed_multi_assign_with_field_target_runs_correctly() {
+    let src = "\
+type Counter =
+  value: Int
+main() -> Int =
+  c = Counter(value: 5)
+  a, c.value = 100, 7
+  a + c.value
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 107);
+}