5d8ada1 | plum | pyrossh

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

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

5d8ada1 — Peter John 2026-07-19T21:40:57+05:30

feat(plum-wasm-codegen): class/method codegen, strings, match lowering

Generated files not shown: Cargo.lock

Files changed (3) hide show

plum-wasm-codegen/Cargo.toml +2 -0
plum-wasm-codegen/src/lib.rs +681 -200
plum-wasm-codegen/tests/codegen_tests.rs +258 -2

plum-wasm-codegen/Cargo.toml CHANGED Viewed

@@ -6,8 +6,10 @@ edition = "2021"
 [dependencies]
 wasm-encoder = "0.220"
 plum-core = { path = "../plum-core" }
+plum-checker = { path = "../plum-checker" }
 [dev-dependencies]
 wasmparser = "0.220"
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
+wasmtime = "28"

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

@@ -1,6 +1,15 @@
 use wasm_encoder::*;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use plum_core::ast;
+use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
+use plum_checker::{ClassEnv, MethodEnv, EnumVariants};
+/// Bump-allocated heap for class instances starts at the second 64KiB page so it can
+/// never collide with the (small, compile-time-sized) string literal data area below it.
+const HEAP_BASE: u32 = 65536;
+/// String literal data (length-prefixed UTF-8 blobs) is laid out from here upward.
+const STRING_BASE: u32 = 8;
 pub struct WasmModule {
     types: Vec<FuncType>,
@@ -172,31 +181,57 @@ pub struct FuncSig {
     pub ret: Option<ValType>,
 }
+/// Global, read-only lookup tables shared by every function body being compiled.
 pub struct CompileCtx {
-    pub module: WasmModule,
     pub func_ids: HashMap<String, u32>,
     pub func_sigs: HashMap<String, FuncSig>,
+    pub classes: ClassEnv,
+    pub methods: MethodEnv,
-    pub current_locals: HashMap<String, u32>,
+    pub enum_variants: EnumVariants,
-    pub label_count: u32,
+    pub global_env: TypeEnv,
-    pub bump_offset: u32,
+    pub bump_global: u32,
 }
+/// Per-module state that accumulates as function bodies are compiled: the running
+/// offset for placing string literal bytes, and the resulting data segments.
-impl CompileCtx {
+struct ModuleState {
-    pub fn new() -> Self {
-        Self {
-            module: WasmModule::new(),
-            func_ids: HashMap::new(),
-            func_sigs: HashMap::new(),
-            current_locals: HashMap::new(),
-            label_count: 0,
-            bump_offset: 0,
+    next_string_offset: u32,
+    data_segments: Vec<(u32, Vec<u8>)>,
-        }
+}
+struct LocalCtx<'a> {
+    locals: HashMap<String, u32>,
+    /// First local index reserved for `ClassCall` scratch temporaries.
+    classcall_scratch_base: u32,
+    /// `ClassCall` expr identity (pointer address) -> scratch slot offset.
+    classcall_scratch: HashMap<usize, u32>,
+    /// First local index reserved for `match` subject scratch temporaries.
+    match_scratch_base: u32,
+    /// `Match` stmt identity (pointer address) -> scratch slot offset.
+    match_scratch_index: HashMap<usize, u32>,
+    func_ids: &'a HashMap<String, u32>,
+    func_sigs: &'a HashMap<String, FuncSig>,
+    classes: &'a ClassEnv,
+    methods: &'a MethodEnv,
+    enum_variants: &'a EnumVariants,
+    /// Tracks each binding's inferred type as compilation proceeds through
+    /// statements in order, mirroring `plum-checker`'s own env evolution — needed
+    /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
+    type_env: RefCell<TypeEnv>,
+    bump_global: u32,
+}
+fn fn_key(f: &ast::Fn) -> String {
+    match &f.type_param {
+        Some(recv) => format!("{}::{}", recv, f.name),
+        None => f.name.clone(),
     }
 }
+fn param_type_name(pt: &ast::ParamType) -> &str {
-impl Default for CompileCtx {
+    match pt {
-    fn default() -> Self {
+        ast::ParamType::Type(t) => t.name.as_str(),
-        Self::new()
+        ast::ParamType::Variadic(t) => t.name.as_str(),
     }
 }
@@ -207,7 +242,16 @@ fn ast_type_to_wasm(name: &str) -> Option<ValType> {
         "Bool" => Some(ValType::I32),
         "Str" => Some(ValType::I32),
         "Unit" => None,
+        _ => Some(ValType::I32), // class instance / unmodeled type: pointer
+    }
+}
+fn plum_type_to_valtype(t: &PlumType) -> ValType {
+    match t {
-        _ => Some(ValType::I64),
+        PlumType::TInt => ValType::I64,
+        PlumType::TFloat => ValType::F64,
+        PlumType::TBool | PlumType::TStr | PlumType::TNamed(_) => ValType::I32,
+        PlumType::TVar(_) | PlumType::TUnit | PlumType::TFun(_, _) => ValType::I64,
     }
 }
@@ -231,156 +275,335 @@ fn encode_leb128_u32(mut val: u32) -> Vec<u8> {
     bytes
 }
+fn check_ctx_of<'a>(ctx_classes: &'a ClassEnv, ctx_methods: &'a MethodEnv, ctx_enum_variants: &'a EnumVariants) -> plum_checker::CheckCtx<'a> {
+    plum_checker::CheckCtx { classes: ctx_classes, methods: ctx_methods, enum_variants: ctx_enum_variants }
+}
+/// Infers an expression's type using the function's current (mutable, evolving) type
+/// environment. Defaults to `TInt` if inference fails — codegen assumes the source was
+/// already accepted by `plum_checker::check_source`, so a failure here would indicate
+/// codegen is being driven directly on unchecked input (as some tests do).
+fn infer_local_type(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
+    let env = ctx.type_env.borrow();
+    let cctx = check_ctx_of(ctx.classes, ctx.methods, ctx.enum_variants);
+    plum_checker::infer_expr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
+}
 pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
+    let (global_env, classes, methods, enum_variants) = plum_checker::build_global_tables(source);
-    let mut ctx = CompileCtx::new();
+    let mut module = WasmModule::new();
+    module.add_memory(2, None);
+    let mut bump_init = Vec::new();
+    Instruction::I32Const(HEAP_BASE as i32).encode(&mut bump_init);
+    let bump_global = module.add_global(ValType::I32, true, &bump_init);
+    let mut func_ids: HashMap<String, u32> = HashMap::new();
+    let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
-    // First pass: register all function type signatures and allocate function slots
+    // Register every function AND method signature up front (methods get an implicit
+    // leading `self: pointer` param and are keyed as "Receiver::method").
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
+            let mut param_types: Vec<ValType> = Vec::new();
             if f.type_param.is_some() {
-                continue; // skip method impls in v1
+                param_types.push(ValType::I32);
-            }
+            }
-            let param_types: Vec<ValType> = f
-                .params
-                .iter()
-                .map(|p| {
-                    let name = match &p.ty {
+            for p in &f.params {
-                        ast::ParamType::Type(t) => t.name.as_str(),
-                        ast::ParamType::Variadic(t) => t.name.as_str(),
-                    };
-                    ast_type_to_wasm(name).unwrap_or(ValType::I64)
+                param_types.push(ast_type_to_wasm(param_type_name(&p.ty)).unwrap_or(ValType::I32));
-                })
+            }
-                .collect();
             let ret = ret_type_to_wasm(f.returns.as_ref());
             let results_vec: Vec<ValType> = ret.into_iter().collect();
-            let type_idx = ctx.module.add_type(&param_types, &results_vec);
+            let type_idx = module.add_type(&param_types, &results_vec);
-            let func_idx = ctx.module.add_function(type_idx, &[]);
+            let func_idx = module.add_function(type_idx, &[]);
+            let key = fn_key(f);
-            ctx.func_ids.insert(f.name.clone(), func_idx);
+            func_ids.insert(key.clone(), func_idx);
-            ctx.func_sigs.insert(f.name.clone(), FuncSig { params: param_types, ret });
+            func_sigs.insert(key, FuncSig { params: param_types, ret });
         }
     }
-    // Second pass: compile each function body
+    let ctx = CompileCtx { func_ids, func_sigs, classes, methods, enum_variants, global_env, bump_global };
-    let fns: Vec<ast::Fn> = source
+    let fns: Vec<&ast::Fn> = source.items.iter().filter_map(|item| match item {
-        .items
-        .iter()
-        .filter_map(|item| {
-            if let ast::Item::Fn(f) = item {
+        ast::Item::Fn(f) => Some(f),
-                if f.type_param.is_none() {
-                    Some(f.clone())
+        _ => None,
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        })
-        .collect();
+    }).collect();
+    let mut state = ModuleState { next_string_offset: STRING_BASE, data_segments: Vec::new() };
     let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();
     for f in &fns {
-        let body = compile_fn_body(f, &ctx)?;
+        let body = compile_fn_body(f, &ctx, &mut state)?;
-        compiled_bodies.push((f.name.clone(), body));
+        compiled_bodies.push((fn_key(f), body));
+    }
+    // Patch compiled bodies back into their pre-registered function slots.
+    for (name, body) in &compiled_bodies {
+        let idx = *ctx.func_ids.get(name).expect("function was registered in the first pass");
+        let slot = (idx - module.func_import_count) as usize;
+        module.functions[slot].1 = body.clone();
     }
-    // Patch bodies into the module
-    for (i, (_, body)) in compiled_bodies.iter().enumerate() {
+    for (offset, bytes) in &state.data_segments {
-        ctx.module.functions[i].1 = body.clone();
+        module.add_data_segment(*offset, bytes);
     }
-    // Export only main
     if let Some(&main_idx) = ctx.func_ids.get("main") {
-        ctx.module.add_export("main", ExportKind::Func, main_idx);
+        module.add_export("main", ExportKind::Func, main_idx);
     }
-    Ok(ctx.module.finish())
+    Ok(module.finish())
 }
+/// Walks a function body once to determine: (1) every locally-assigned/bound name and
+/// its inferred type, (2) how many `ClassCall` scratch temporaries it needs, and (3)
+/// the subject type for every `match` statement (for its own scratch temporary).
+struct Collector<'a> {
+    env: TypeEnv,
+    cctx: plum_checker::CheckCtx<'a>,
+    named: Vec<(String, PlumType)>,
-fn collect_local_names(body: &ast::FnBody) -> Vec<String> {
+    named_set: std::collections::HashSet<String>,
-    let mut names = Vec::new();
-    if let ast::FnBody::Block(block) = body {
-        collect_block_locals(block, &mut names);
+    classcall_scratch: HashMap<usize, u32>,
-    }
+    match_scratch: HashMap<usize, PlumType>,
-    names
+    next_classcall_slot: u32,
 }
+impl<'a> Collector<'a> {
-fn collect_block_locals(block: &ast::Block, names: &mut Vec<String>) {
+    fn bind(&mut self, name: &str, ty: PlumType) {
-    for stmt in &block.stmts {
-        collect_stmt_locals(stmt, names);
+        if self.named_set.insert(name.to_string()) {
+            self.named.push((name.to_string(), ty.clone()));
+        }
+        self.env.insert(name.to_string(), TypeScheme::mono(ty));
     }
-}
+    fn walk_block(&mut self, block: &ast::Block) {
+        for s in &block.stmts {
+            self.walk_stmt(s);
+        }
+    }
-fn collect_stmt_locals(stmt: &ast::Stmt, names: &mut Vec<String>) {
+    fn walk_stmt(&mut self, stmt: &ast::Stmt) {
-    match stmt {
+        match stmt {
-        ast::Stmt::Assign(a) => {
+            ast::Stmt::Assign(a) => {
+                for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                    self.walk_expr(value);
+                    let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
-            for t in &a.targets {
+                    self.bind(target, ty);
-                if !names.contains(t) {
-                    names.push(t.clone());
                 }
             }
+            ast::Stmt::Return(Some(e)) => self.walk_expr(e),
+            ast::Stmt::Return(None) => {}
+            ast::Stmt::If(i) => {
+                self.walk_expr(&i.condition);
+                self.walk_block(&i.body);
+                for ei in &i.else_ifs {
+                    self.walk_expr(&ei.condition);
+                    self.walk_block(&ei.body);
-        }
+                }
-        ast::Stmt::If(i) => {
-            collect_block_locals(&i.body, names);
-            for ei in &i.else_ifs {
+                if let Some(e) = &i.else_ {
-                collect_block_locals(&ei.body, names);
+                    self.walk_block(e);
+                }
             }
+            ast::Stmt::While(w) => {
+                self.walk_expr(&w.condition);
+                self.walk_block(&w.body);
+            }
+            ast::Stmt::For(f) => {
-            if let Some(e) = &i.else_ {
+                self.walk_expr(&f.iter);
+                for v in &f.vars {
+                    self.bind(v, PlumType::TInt);
+                }
-                collect_block_locals(e, names);
+                self.walk_block(&f.body);
             }
+            ast::Stmt::Expr(e) => self.walk_expr(e),
+            ast::Stmt::Assert(e) => self.walk_expr(e),
+            ast::Stmt::Match(m) => {
+                let subject_ty = if m.subjects.len() == 1 {
+                    self.walk_expr(&m.subjects[0]);
+                    plum_checker::infer_expr(&m.subjects[0], &self.env, &self.cctx).unwrap_or(PlumType::TInt)
+                } else {
+                    for s in &m.subjects {
+                        self.walk_expr(s);
+                    }
+                    PlumType::TInt
+                };
+                self.match_scratch.insert(m as *const ast::Match as usize, subject_ty.clone());
+                for case in &m.cases {
+                    let saved = self.env.clone();
+                    if m.subjects.len() == 1 {
+                        if let Some(ast::CasePattern::Name(n)) = case.patterns.first() {
+                            let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                                && self.cctx.enum_variants.contains_key(n);
+                            if !is_variant {
+                                self.bind(n, subject_ty.clone());
+                            }
+                        }
+                    }
+                    self.walk_block(&case.body);
+                    self.env = saved;
+                }
+            }
+            ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
         }
+    }
+    fn walk_expr(&mut self, expr: &ast::Expr) {
+        match expr {
+            ast::Expr::ClassCall(call) => {
+                let idx = self.next_classcall_slot;
+                self.next_classcall_slot += 1;
-        ast::Stmt::While(w) => collect_block_locals(&w.body, names),
+                self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
+                for fa in &call.fields {
+                    self.walk_expr(&fa.value);
+                }
+            }
+            ast::Expr::Binary(b) => {
+                self.walk_expr(&b.left);
+                self.walk_expr(&b.right);
+            }
-        ast::Stmt::For(f) => {
+            ast::Expr::Bool(b) => {
+                self.walk_expr(&b.left);
+                self.walk_expr(&b.right);
+            }
+            ast::Expr::Compare(c) => {
+                self.walk_expr(&c.left);
+                self.walk_expr(&c.right);
+            }
+            ast::Expr::Not(inner) => self.walk_expr(inner),
+            ast::Expr::Unary(u) => self.walk_expr(&u.operand),
+            ast::Expr::Paren(inner) => self.walk_expr(inner),
+            ast::Expr::Ternary(t) => {
+                self.walk_expr(&t.condition);
+                self.walk_expr(&t.then);
+                self.walk_expr(&t.else_);
+            }
+            ast::Expr::FnCall(call) => {
-            for v in &f.vars {
+                for arg in &call.args {
+                    self.walk_arg(arg);
+                }
+            }
+            ast::Expr::Attribute(a) => {
+                self.walk_expr(&a.object);
+                if let ast::AttrKind::Method(call) = &a.attr {
-                if !names.contains(v) {
+                    for arg in &call.args {
-                    names.push(v.clone());
+                        self.walk_arg(arg);
+                    }
                 }
             }
+            ast::Expr::Int(_)
+            | ast::Expr::Float(_)
+            | ast::Expr::String(_)
+            | ast::Expr::Self_
+            | ast::Expr::Var(_)
+            | ast::Expr::TypeName(_) => {}
+        }
+    }
+    fn walk_arg(&mut self, arg: &ast::Arg) {
+        match arg {
-            collect_block_locals(&f.body, names);
+            ast::Arg::Positional(e) => self.walk_expr(e),
+            ast::Arg::Keyword { value, .. } => self.walk_expr(value),
+            ast::Arg::Pair { value, .. } => self.walk_expr(value),
         }
-        _ => {}
     }
 }
-fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx) -> Result<Vec<u8>, String> {
+fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
-    let param_count = f.params.len() as u32;
-    // Collect extra (non-param) local variable names declared in the body
-    let extra_locals = collect_local_names(&f.body);
-    let extra_count = extra_locals.len() as u32;
+    let mut base_env = ctx.global_env.clone();
+    if let Some(recv) = &f.type_param {
+        base_env.insert("self".to_string(), TypeScheme::mono(PlumType::TNamed(recv.clone())));
+    }
+    for p in &f.params {
+        let ty = match &p.ty {
+            ast::ParamType::Type(t) => plum_checker::plum_type_from_ast(t),
+            ast::ParamType::Variadic(t) => plum_checker::plum_type_from_ast(t),
+        };
+        base_env.insert(p.name.clone(), TypeScheme::mono(ty));
+    }
+    let mut collector = Collector {
+        env: base_env.clone(),
-    // Encode local declarations: group count, then each group as (count, type)
+        cctx: check_ctx_of(&ctx.classes, &ctx.methods, &ctx.enum_variants),
+        named: Vec::new(),
+        named_set: Default::default(),
+        classcall_scratch: HashMap::new(),
+        match_scratch: HashMap::new(),
-    if extra_count > 0 {
+        next_classcall_slot: 0,
-        body.extend(encode_leb128_u32(1)); // 1 group
-        body.extend(encode_leb128_u32(extra_count));
+    };
-        ValType::I64.encode(&mut body);
+    if let ast::FnBody::Block(block) = &f.body {
-    } else {
-        body.push(0); // 0 groups
+        collector.walk_block(block);
     }
-    // Build locals map: params first, then extra locals
+    // ---- assign local indices: [self?][params][named...][classcall scratch...][match scratch...] ----
     let mut locals: HashMap<String, u32> = HashMap::new();
+    let mut groups: Vec<ValType> = Vec::new();
+    let mut idx = 0u32;
-    for (i, p) in f.params.iter().enumerate() {
+    if f.type_param.is_some() {
+        locals.insert("self".to_string(), idx);
+        idx += 1;
+    }
+    for p in &f.params {
-        locals.insert(p.name.clone(), i as u32);
+        locals.insert(p.name.clone(), idx);
+        idx += 1;
+    }
+    for (name, ty) in &collector.named {
+        let vt = plum_type_to_valtype(ty);
+        locals.insert(name.clone(), idx);
+        groups.push(vt);
+        idx += 1;
+    }
+    let classcall_scratch_base = idx;
+    let classcall_count = collector.classcall_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    for _ in 0..classcall_count {
+        groups.push(ValType::I32);
+        idx += 1;
+    }
+    let match_scratch_base = idx;
+    let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
+    for (ptr, ty) in collector.match_scratch.iter() {
+        match_scratch_index.insert(*ptr, idx - match_scratch_base);
+        groups.push(plum_type_to_valtype(ty));
+        idx += 1;
     }
-    for (i, name) in extra_locals.iter().enumerate() {
+    if groups.is_empty() {
+        body.push(0);
+    } else {
-        locals.insert(name.clone(), param_count + i as u32);
+        body.extend(encode_leb128_u32(groups.len() as u32));
+        for g in &groups {
+            body.extend(encode_leb128_u32(1));
+            g.encode(&mut body);
+        }
     }
     let local_ctx = LocalCtx {
         locals,
+        classcall_scratch_base,
+        classcall_scratch: collector.classcall_scratch,
+        match_scratch_base,
+        match_scratch_index,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        classes: &ctx.classes,
+        methods: &ctx.methods,
+        enum_variants: &ctx.enum_variants,
+        type_env: RefCell::new(base_env),
+        bump_global: ctx.bump_global,
     };
     let has_return_value = f.returns.as_ref().map(|r| r.name != "Unit").unwrap_or(false);
     match &f.body {
         ast::FnBody::Expr(e) => {
-            compile_expr(e, &mut body, &local_ctx)?;
+            compile_expr(e, &mut body, &local_ctx, state)?;
         }
         ast::FnBody::Block(block) => {
-            compile_block_as_fn_body(block, &mut body, &local_ctx, has_return_value)?;
+            compile_block_as_fn_body(block, &mut body, &local_ctx, state, has_return_value)?;
         }
     }
@@ -388,89 +611,93 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx) -> Result<Vec<u8>, String> {
     Ok(body)
 }
-struct LocalCtx<'a> {
-    locals: HashMap<String, u32>,
-    func_ids: &'a HashMap<String, u32>,
-    func_sigs: &'a HashMap<String, FuncSig>,
-}
-fn compile_block(block: &ast::Block, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_block(block: &ast::Block, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     for stmt in &block.stmts {
-        compile_stmt(stmt, body, ctx)?;
+        compile_stmt(stmt, body, ctx, state)?;
     }
     Ok(())
 }
-/// Compile a block that is the body of a function. If the function returns a value
+/// Compiles a block that is the body of a function. If the function returns a value
 /// and the last statement is an expression, that expression's value is left on the
 /// stack instead of being dropped.
 fn compile_block_as_fn_body(
     block: &ast::Block,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
+    state: &mut ModuleState,
     has_return_value: bool,
 ) -> Result<(), String> {
     let stmts = &block.stmts;
     if has_return_value {
         if let Some((last, rest)) = stmts.split_last() {
             for stmt in rest {
-                compile_stmt(stmt, body, ctx)?;
+                compile_stmt(stmt, body, ctx, state)?;
             }
-            // Last statement: if it's an Expr, leave its value on stack
             match last {
                 ast::Stmt::Expr(e) => {
-                    compile_expr(e, body, ctx)?;
+                    compile_expr(e, body, ctx, state)?;
                     // do NOT drop — this is the return value
                 }
+                ast::Stmt::Match(m) => {
+                    compile_match(m, body, ctx, state)?;
+                    // Every arm of a tail-position match must itself `return`; if a
+                    // non-exhaustive match falls through, trap rather than continue
+                    // with the required-but-never-produced result value missing.
+                    // This also satisfies wasm validation, which requires a value at
+                    // the function's `end` regardless of whether every branch inside
+                    // the match's (BlockType::Empty) if/else chain already returned.
+                    Instruction::Unreachable.encode(body);
+                }
                 _ => {
-                    compile_stmt(last, body, ctx)?;
+                    compile_stmt(last, body, ctx, state)?;
                 }
             }
             return Ok(());
         }
     }
     for stmt in stmts {
-        compile_stmt(stmt, body, ctx)?;
+        compile_stmt(stmt, body, ctx, state)?;
     }
     Ok(())
 }
-fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     match stmt {
         ast::Stmt::Assign(a) => {
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                let vty = infer_local_type(value, ctx);
-                compile_expr(value, body, ctx)?;
+                compile_expr(value, body, ctx, state)?;
-                let idx = *ctx
+                let idx = ctx
                     .locals
                     .get(target)
+                    .copied()
                     .ok_or_else(|| format!("undeclared local '{}'", target))?;
                 Instruction::LocalSet(idx).encode(body);
+                ctx.type_env.borrow_mut().insert(target.clone(), TypeScheme::mono(vty));
             }
         }
         ast::Stmt::Return(Some(e)) => {
-            compile_expr(e, body, ctx)?;
+            compile_expr(e, body, ctx, state)?;
             Instruction::Return.encode(body);
         }
         ast::Stmt::Return(None) => {
             Instruction::Return.encode(body);
         }
         ast::Stmt::If(if_) => {
-            compile_expr(&if_.condition, body, ctx)?;
+            compile_expr(&if_.condition, body, ctx, state)?;
-            // Condition is i64 (Bool is I32 but comparison results in I32)
-            // Convert to i32 for if: if condition came from compare ops it's already i32
-            // Use I32WrapI64 if needed — but compare ops return i32 already
             Instruction::If(BlockType::Empty).encode(body);
-            compile_block(&if_.body, body, ctx)?;
+            compile_block(&if_.body, body, ctx, state)?;
             if !if_.else_ifs.is_empty() || if_.else_.is_some() {
                 Instruction::Else.encode(body);
                 for ei in &if_.else_ifs {
-                    compile_expr(&ei.condition, body, ctx)?;
+                    compile_expr(&ei.condition, body, ctx, state)?;
                     Instruction::If(BlockType::Empty).encode(body);
-                    compile_block(&ei.body, body, ctx)?;
+                    compile_block(&ei.body, body, ctx, state)?;
                     Instruction::Else.encode(body);
                 }
                 if let Some(else_block) = &if_.else_ {
-                    compile_block(else_block, body, ctx)?;
+                    compile_block(else_block, body, ctx, state)?;
                 }
                 for _ in &if_.else_ifs {
                     Instruction::End.encode(body);
@@ -479,13 +706,12 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::End.encode(body);
         }
         ast::Stmt::While(w) => {
-            // block { loop { cond; i32.eqz; br_if 1; body; br 0 } }
             Instruction::Block(BlockType::Empty).encode(body);
             Instruction::Loop(BlockType::Empty).encode(body);
-            compile_expr(&w.condition, body, ctx)?;
+            compile_expr(&w.condition, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
             Instruction::BrIf(1).encode(body);
-            compile_block(&w.body, body, ctx)?;
+            compile_block(&w.body, body, ctx, state)?;
             Instruction::Br(0).encode(body);
             Instruction::End.encode(body);
             Instruction::End.encode(body);
@@ -494,19 +720,21 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             if let ast::Expr::Binary(b) = &f.iter {
                 if matches!(b.op, ast::BinOp::Range) && f.vars.len() == 1 {
                     let var_name = &f.vars[0];
-                    let var_idx = *ctx
+                    let var_idx = ctx
                         .locals
                         .get(var_name)
+                        .copied()
                         .ok_or_else(|| format!("undeclared loop var '{}'", var_name))?;
+                    ctx.type_env.borrow_mut().insert(var_name.clone(), TypeScheme::mono(PlumType::TInt));
-                    compile_expr(&b.left, body, ctx)?;
+                    compile_expr(&b.left, body, ctx, state)?;
                     Instruction::LocalSet(var_idx).encode(body);
                     Instruction::Block(BlockType::Empty).encode(body);
                     Instruction::Loop(BlockType::Empty).encode(body);
                     Instruction::LocalGet(var_idx).encode(body);
-                    compile_expr(&b.right, body, ctx)?;
+                    compile_expr(&b.right, body, ctx, state)?;
                     Instruction::I64GeS.encode(body);
                     Instruction::BrIf(1).encode(body);
-                    compile_block(&f.body, body, ctx)?;
+                    compile_block(&f.body, body, ctx, state)?;
                     Instruction::LocalGet(var_idx).encode(body);
                     Instruction::I64Const(1).encode(body);
                     Instruction::I64Add.encode(body);
@@ -517,12 +745,12 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                     return Ok(());
                 }
             }
-            compile_expr(&f.iter, body, ctx)?;
+            compile_expr(&f.iter, body, ctx, state)?;
             Instruction::Drop.encode(body);
         }
         ast::Stmt::Expr(e) => {
             let has_result = expr_has_result(e, ctx);
-            compile_expr(e, body, ctx)?;
+            compile_expr(e, body, ctx, state)?;
             if has_result {
                 Instruction::Drop.encode(body);
             }
@@ -533,7 +761,10 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
         ast::Stmt::Continue => {
             Instruction::Br(0).encode(body);
         }
+        ast::Stmt::Match(m) => {
+            compile_match(m, body, ctx, state)?;
+        }
-        ast::Stmt::Assert(_) | ast::Stmt::Match(_) | ast::Stmt::Todo => {}
+        ast::Stmt::Assert(_) | ast::Stmt::Todo => {}
     }
     Ok(())
 }
@@ -541,14 +772,139 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
 /// Returns true if the expression leaves a value on the wasm stack.
 fn expr_has_result(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
     match expr {
+        ast::Expr::FnCall(call) => ctx.func_sigs.get(&call.name).map(|s| s.ret.is_some()).unwrap_or(true),
+        ast::Expr::Attribute(attr) => match &attr.attr {
-        ast::Expr::FnCall(call) => {
+            ast::AttrKind::Method(call) => {
+                if let PlumType::TNamed(class_name) = infer_local_type(&attr.object, ctx) {
+                    let key = format!("{}::{}", class_name, call.name);
-            ctx.func_sigs.get(&call.name).map(|s| s.ret.is_some()).unwrap_or(true)
+                    ctx.func_sigs.get(&key).map(|s| s.ret.is_some()).unwrap_or(true)
+                } else {
+                    true
-        }
+                }
+            }
+            ast::AttrKind::Field(_) => true,
+        },
         _ => true,
     }
 }
+fn compile_match(m: &ast::Match, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
+    if m.subjects.len() != 1 {
+        return Err("codegen: multi-subject match is not yet supported".to_string());
+    }
+    let subject = &m.subjects[0];
+    let subject_ty = infer_local_type(subject, ctx);
+    let subject_vt = plum_type_to_valtype(&subject_ty);
+    let key = m as *const ast::Match as usize;
+    let slot = *ctx
+        .match_scratch_index
+        .get(&key)
+        .ok_or_else(|| "internal codegen error: missing match scratch slot".to_string())?;
+    let scratch_local = ctx.match_scratch_base + slot;
+    compile_expr(subject, body, ctx, state)?;
+    Instruction::LocalSet(scratch_local).encode(body);
+    compile_match_arms(&m.cases, subject_vt, scratch_local, body, ctx, state)
+}
+fn compile_match_arms(
+    cases: &[ast::Case],
+    subject_vt: ValType,
+    scratch_local: u32,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let (case, rest) = match cases.split_first() {
+        None => return Ok(()),
+        Some(pair) => pair,
+    };
+    let pat = case.patterns.first().ok_or_else(|| "codegen: match case has no pattern".to_string())?;
+    match pat {
+        ast::CasePattern::Wildcard => {
+            // Any cases after a wildcard are unreachable, matching real match semantics.
+            compile_block(&case.body, body, ctx, state)
+        }
+        ast::CasePattern::Name(n) => {
+            let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                && ctx.enum_variants.contains_key(n);
+            if is_variant {
+                compile_variant_eq_arm(n, subject_vt, scratch_local, case, rest, body, ctx, state)
+            } else {
+                let idx = ctx
+                    .locals
+                    .get(n)
+                    .copied()
+                    .ok_or_else(|| format!("internal codegen error: missing binding local '{}'", n))?;
+                Instruction::LocalGet(scratch_local).encode(body);
+                Instruction::LocalSet(idx).encode(body);
+                ctx.type_env.borrow_mut().insert(n.clone(), TypeScheme::mono(plum_type_from_valtype_hint(subject_vt)));
+                compile_block(&case.body, body, ctx, state)
+                // A binding arm always matches — any following cases are unreachable.
+            }
+        }
+        ast::CasePattern::Int(n) => {
+            if subject_vt != ValType::I64 {
+                return Err("codegen: integer match pattern against a non-Int subject".to_string());
+            }
+            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::I64Const(*n).encode(body);
+            Instruction::I64Eq.encode(body);
+            Instruction::If(BlockType::Empty).encode(body);
+            compile_block(&case.body, body, ctx, state)?;
+            Instruction::Else.encode(body);
+            compile_match_arms(rest, subject_vt, scratch_local, body, ctx, state)?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
+        ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
+        ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
+        ast::CasePattern::Class { .. } => Err("codegen: constructor match patterns are not yet supported".to_string()),
+    }
+}
+#[allow(clippy::too_many_arguments)]
+fn compile_variant_eq_arm(
+    name: &str,
+    subject_vt: ValType,
+    scratch_local: u32,
+    case: &ast::Case,
+    rest: &[ast::Case],
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    // Only Bool's own variants have a concrete runtime representation in v1.5.
+    let tag = match name {
+        "True" => 1i32,
+        "False" => 0i32,
+        other => return Err(format!("codegen: enum variant pattern '{}' is not yet supported (only True/False)", other)),
+    };
+    if subject_vt != ValType::I32 {
+        return Err("codegen: Bool match pattern against a non-Bool subject".to_string());
+    }
+    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::I32Const(tag).encode(body);
+    Instruction::I32Eq.encode(body);
+    Instruction::If(BlockType::Empty).encode(body);
+    compile_block(&case.body, body, ctx, state)?;
+    Instruction::Else.encode(body);
+    compile_match_arms(rest, subject_vt, scratch_local, body, ctx, state)?;
+    Instruction::End.encode(body);
+    Ok(())
+}
+fn plum_type_from_valtype_hint(vt: ValType) -> PlumType {
+    match vt {
+        ValType::I64 => PlumType::TInt,
+        ValType::F64 => PlumType::TFloat,
+        _ => PlumType::TVar("_".to_string()),
+    }
+}
-fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     match expr {
         ast::Expr::Int(n) => {
             Instruction::I64Const(*n).encode(body);
@@ -557,42 +913,40 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::F64Const(*f).encode(body);
         }
         ast::Expr::Var(name) => {
-            if name == "true" {
-                Instruction::I32Const(1).encode(body);
-            } else if name == "false" {
-                Instruction::I32Const(0).encode(body);
-            } else {
-                let idx = *ctx
+            let idx = *ctx
-                    .locals
+                .locals
-                    .get(name.as_str())
+                .get(name.as_str())
-                    .ok_or_else(|| format!("undeclared variable '{}'", name))?;
+                .ok_or_else(|| format!("undeclared variable '{}'", name))?;
-                Instruction::LocalGet(idx).encode(body);
+            Instruction::LocalGet(idx).encode(body);
-            }
         }
         ast::Expr::Paren(inner) => {
-            compile_expr(inner, body, ctx)?;
+            compile_expr(inner, body, ctx, state)?;
         }
-        ast::Expr::Unary(u) => {
+        ast::Expr::Unary(u) => match u.op {
-            match u.op {
-                ast::UnOp::Neg => {
+            ast::UnOp::Neg => {
+                if matches!(infer_local_type(&u.operand, ctx), PlumType::TFloat) {
+                    compile_expr(&u.operand, body, ctx, state)?;
+                    Instruction::F64Neg.encode(body);
+                } else {
-                    // WASM has no i64.neg; use i64.const(0) - operand
+                    // WASM has no i64.neg; use 0 - operand.
                     Instruction::I64Const(0).encode(body);
-                    compile_expr(&u.operand, body, ctx)?;
+                    compile_expr(&u.operand, body, ctx, state)?;
                     Instruction::I64Sub.encode(body);
                 }
-                ast::UnOp::Pos => {
-                    compile_expr(&u.operand, body, ctx)?;
-                }
             }
+            ast::UnOp::Pos => {
+                compile_expr(&u.operand, body, ctx, state)?;
-        }
+            }
+        },
         ast::Expr::Binary(b) => {
+            let is_float = matches!(infer_local_type(&b.left, ctx), PlumType::TFloat);
-            compile_expr(&b.left, body, ctx)?;
+            compile_expr(&b.left, body, ctx, state)?;
-            compile_expr(&b.right, body, ctx)?;
+            compile_expr(&b.right, body, ctx, state)?;
             match b.op {
-                ast::BinOp::Add => Instruction::I64Add.encode(body),
+                ast::BinOp::Add => if is_float { Instruction::F64Add } else { Instruction::I64Add }.encode(body),
-                ast::BinOp::Sub => Instruction::I64Sub.encode(body),
+                ast::BinOp::Sub => if is_float { Instruction::F64Sub } else { Instruction::I64Sub }.encode(body),
-                ast::BinOp::Mul => Instruction::I64Mul.encode(body),
+                ast::BinOp::Mul => if is_float { Instruction::F64Mul } else { Instruction::I64Mul }.encode(body),
-                ast::BinOp::Div => Instruction::I64DivS.encode(body),
+                ast::BinOp::Div => if is_float { Instruction::F64Div } else { Instruction::I64DivS }.encode(body),
                 ast::BinOp::Mod => Instruction::I64RemS.encode(body),
                 ast::BinOp::BitOr => Instruction::I64Or.encode(body),
                 ast::BinOp::BitAnd => Instruction::I64And.encode(body),
@@ -600,40 +954,55 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                 ast::BinOp::Shl => Instruction::I64Shl.encode(body),
                 ast::BinOp::Shr => Instruction::I64ShrS.encode(body),
                 ast::BinOp::Range => {
-                    // Range used outside of For: leave end on stack (start consumed)
+                    // Range used outside of `for`: leave end on stack (start consumed).
                 }
             }
         }
         ast::Expr::Bool(b) => {
-            compile_expr(&b.left, body, ctx)?;
+            compile_expr(&b.left, body, ctx, state)?;
-            compile_expr(&b.right, body, ctx)?;
+            compile_expr(&b.right, body, ctx, state)?;
             match b.op {
                 ast::BoolOp::And => Instruction::I32And.encode(body),
                 ast::BoolOp::Or => Instruction::I32Or.encode(body),
             }
         }
         ast::Expr::Not(inner) => {
-            compile_expr(inner, body, ctx)?;
+            compile_expr(inner, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
         }
         ast::Expr::Compare(c) => {
+            let is_float = matches!(infer_local_type(&c.left, ctx), PlumType::TFloat);
-            compile_expr(&c.left, body, ctx)?;
+            compile_expr(&c.left, body, ctx, state)?;
-            compile_expr(&c.right, body, ctx)?;
+            compile_expr(&c.right, body, ctx, state)?;
+            if is_float {
-            match c.op {
+                match c.op {
+                    ast::CmpOp::Lt => Instruction::F64Lt,
+                    ast::CmpOp::Lte => Instruction::F64Le,
+                    ast::CmpOp::Eq => Instruction::F64Eq,
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::F64Ne,
+                    ast::CmpOp::Gte => Instruction::F64Ge,
+                    ast::CmpOp::Gt => Instruction::F64Gt,
+                }
+                .encode(body);
+            } else {
+                match c.op {
-                ast::CmpOp::Lt => Instruction::I64LtS.encode(body),
+                    ast::CmpOp::Lt => Instruction::I64LtS,
-                ast::CmpOp::Lte => Instruction::I64LeS.encode(body),
+                    ast::CmpOp::Lte => Instruction::I64LeS,
-                ast::CmpOp::Eq => Instruction::I64Eq.encode(body),
+                    ast::CmpOp::Eq => Instruction::I64Eq,
-                ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne.encode(body),
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne,
-                ast::CmpOp::Gte => Instruction::I64GeS.encode(body),
+                    ast::CmpOp::Gte => Instruction::I64GeS,
-                ast::CmpOp::Gt => Instruction::I64GtS.encode(body),
+                    ast::CmpOp::Gt => Instruction::I64GtS,
+                }
+                .encode(body);
             }
         }
         ast::Expr::Ternary(t) => {
+            let result_vt = plum_type_to_valtype(&infer_local_type(&t.then, ctx));
-            compile_expr(&t.condition, body, ctx)?;
+            compile_expr(&t.condition, body, ctx, state)?;
-            Instruction::If(BlockType::Result(ValType::I64)).encode(body);
+            Instruction::If(BlockType::Result(result_vt)).encode(body);
-            compile_expr(&t.then, body, ctx)?;
+            compile_expr(&t.then, body, ctx, state)?;
             Instruction::Else.encode(body);
-            compile_expr(&t.else_, body, ctx)?;
+            compile_expr(&t.else_, body, ctx, state)?;
             Instruction::End.encode(body);
         }
         ast::Expr::FnCall(call) => {
@@ -643,7 +1012,7 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                     ast::Arg::Keyword { value, .. } => value,
                     ast::Arg::Pair { value, .. } => value,
                 };
-                compile_expr(arg_expr, body, ctx)?;
+                compile_expr(arg_expr, body, ctx, state)?;
             }
             let func_idx = ctx
                 .func_ids
@@ -652,13 +1021,125 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::Call(*func_idx).encode(body);
         }
         ast::Expr::Self_ => {
+            let idx = ctx
+                .locals
+                .get("self")
+                .copied()
-            return Err("'self' not supported in v1 codegen".to_string());
+                .ok_or_else(|| "codegen: 'self' used outside a method".to_string())?;
+            Instruction::LocalGet(idx).encode(body);
         }
-        ast::Expr::TypeName(_) | ast::Expr::ClassCall(_) | ast::Expr::Attribute(_) => {
+        ast::Expr::TypeName(n) => match n.as_str() {
+            "True" => Instruction::I32Const(1).encode(body),
+            "False" => Instruction::I32Const(0).encode(body),
+            other => return Err(format!("codegen: type name '{}' is not yet supported as a value", other)),
+        },
+        ast::Expr::ClassCall(call) => {
+            let fields = ctx
+                .classes
+                .get(&call.type_name)
+                .ok_or_else(|| format!("codegen: unknown class '{}'", call.type_name))?
+                .clone();
+            let size = (fields.len() as i32) * 8;
+            let scratch_key = expr as *const ast::Expr as usize;
+            let scratch_idx = *ctx
+                .classcall_scratch
+                .get(&scratch_key)
+                .ok_or_else(|| "internal codegen error: missing classcall scratch slot".to_string())?;
+            let scratch_local = ctx.classcall_scratch_base + scratch_idx;
+            // base = bump_global; bump_global += size (runtime bump allocation, so every
+            // call — even inside a loop — gets a fresh, non-overlapping region).
+            Instruction::GlobalGet(ctx.bump_global).encode(body);
+            Instruction::LocalSet(scratch_local).encode(body);
+            Instruction::GlobalGet(ctx.bump_global).encode(body);
-            Instruction::I64Const(0).encode(body);
+            Instruction::I32Const(size).encode(body);
+            Instruction::I32Add.encode(body);
+            Instruction::GlobalSet(ctx.bump_global).encode(body);
+            for fa in &call.fields {
+                let (field_idx, field_ty) = fields
+                    .iter()
+                    .position(|(n, _)| n == &fa.name)
+                    .map(|i| (i, fields[i].1.clone()))
+                    .ok_or_else(|| format!("codegen: unknown field '{}' on class '{}'", fa.name, call.type_name))?;
+                Instruction::LocalGet(scratch_local).encode(body);
+                compile_expr(&fa.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),
+                };
+            }
+            Instruction::LocalGet(scratch_local).encode(body);
         }
+        ast::Expr::Attribute(attr) => {
+            let obj_ty = infer_local_type(&attr.object, ctx);
+            match &attr.attr {
+                ast::AttrKind::Field(field_name) => {
+                    let class_name = match &obj_ty {
+                        PlumType::TNamed(n) => n.clone(),
+                        other => return Err(format!("codegen: cannot access 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(&attr.object, body, ctx, state)?;
+                    let offset = (field_idx as u64) * 8;
+                    match plum_type_to_valtype(&field_ty) {
+                        ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                        ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                        _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                    };
+                }
+                ast::AttrKind::Method(call) => {
+                    let class_name = match &obj_ty {
+                        PlumType::TNamed(n) => n.clone(),
+                        other => return Err(format!("codegen: cannot call method '{}' on non-class type {}", call.name, other)),
+                    };
+                    let key = format!("{}::{}", class_name, call.name);
+                    let func_idx = *ctx
+                        .func_ids
+                        .get(&key)
+                        .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, call.name))?;
+                    compile_expr(&attr.object, body, ctx, state)?; // push self
+                    for arg in &call.args {
+                        let arg_expr = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        compile_expr(arg_expr, body, ctx, state)?;
+                    }
+                    Instruction::Call(func_idx).encode(body);
+                }
+            }
+        }
-        ast::Expr::String(_) => {
+        ast::Expr::String(s) => {
+            let mut text = String::new();
+            for part in &s.parts {
+                match part {
+                    ast::StringPart::Text(t) => text.push_str(t),
+                    ast::StringPart::Interp(_) => {
+                        return Err("codegen: string interpolation is not yet supported".to_string());
+                    }
+                }
+            }
+            let bytes = text.as_bytes();
+            let offset = state.next_string_offset;
+            let mut data = Vec::with_capacity(4 + bytes.len());
+            data.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
+            data.extend_from_slice(bytes);
+            state.next_string_offset += data.len() as u32;
+            state.data_segments.push((offset, data));
-            Instruction::I32Const(0).encode(body);
+            Instruction::I32Const(offset as i32).encode(body);
         }
     }
     Ok(())

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

@@ -31,8 +31,12 @@ fn output_validates() {
 #[test]
 fn factorial_compiles() {
-    // Simple recursive function that the v1 codegen can handle
+    let src = "\
-    let src = "factorial(x: Int) -> Int =\n  x\n";
+factorial(x: Int) -> Int =
+  if x < 2
+    return 1
+  return x * factorial(x - 1)
+";
     let source = parse(src);
     let bytes = compile_source(&source).expect("factorial should compile");
     assert_eq!(&bytes[0..4], b"\0asm");
@@ -49,3 +53,255 @@ fn give42_compiles_and_exports() {
     let result = wasmparser::validate(&bytes);
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
 }
+fn assert_valid(src: &str) -> Vec<u8> {
+    let source = parse(src);
+    let bytes = compile_source(&source).unwrap_or_else(|e| panic!("compile failed for {:?}: {}", src, e));
+    let result = wasmparser::validate(&bytes);
+    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
+    bytes
+}
+#[test]
+fn bool_literals_compile() {
+    assert_valid("main() -> Bool =\n  True\n");
+    assert_valid("main() -> Bool =\n  False\n");
+}
+#[test]
+fn string_literal_compiles() {
+    assert_valid("main() -> Str =\n  \"hello\"\n");
+}
+#[test]
+fn empty_string_literal_compiles() {
+    assert_valid("main() -> Str =\n  \"\"\n");
+}
+#[test]
+fn string_interpolation_is_a_clear_error() {
+    let src = "main() -> Str =\n  x = 1\n  \"{x}\"\n";
+    let source = parse(src);
+    let err = compile_source(&source).expect_err("interpolation should not silently compile");
+    assert!(err.contains("interpolation"), "got: {}", err);
+}
+#[test]
+fn float_arithmetic_and_negation_compile() {
+    assert_valid("main(x: Float) -> Float =\n  y = -x\n  y + 1.5\n");
+}
+#[test]
+fn class_field_and_method_compile() {
+    let src = "\
+type Cat =
+  name: Str
+  age: Int
+getAge<Cat>() -> Int =
+  self.age
+makeCat() -> Int =
+  c = Cat(name: \"x\", age: 3)
+  c.getAge()
+";
+    assert_valid(src);
+}
+#[test]
+fn nested_class_call_compiles() {
+    let src = "\
+type Pair =
+  a: Int
+  b: Int
+type Wrapper =
+  inner: Pair
+  tag: Int
+make() -> Int =
+  w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)
+  w.tag
+";
+    assert_valid(src);
+}
+#[test]
+fn match_with_int_and_wildcard_compiles() {
+    let src = "main(a: Int) -> Int =\n  match a\n    1 =>\n      return 10\n    _ =>\n      return 0\n";
+    assert_valid(src);
+}
+#[test]
+fn match_binding_pattern_compiles() {
+    let src = "main(a: Int) -> Int =\n  match a\n    x =>\n      return x\n";
+    assert_valid(src);
+}
+#[test]
+fn match_bool_variant_pattern_compiles() {
+    let src = "main(a: Bool) -> Int =\n  match a\n    True =>\n      return 1\n    False =>\n      return 0\n";
+    assert_valid(src);
+}
+#[test]
+fn match_string_pattern_is_a_clear_error() {
+    let src = "main(a: Str) -> Int =\n  match a\n    \"x\" =>\n      1\n    _ =>\n      0\n";
+    let source = parse(src);
+    let err = compile_source(&source).expect_err("string match patterns are not yet supported");
+    assert!(err.contains("string match"), "got: {}", err);
+}
+/// Runs `main`'s wasm bytes and returns its i64 result. wasm's own validator
+/// (via wasmparser, above) only proves the module is well-formed — it can't catch
+/// wrong *values*, so these tests actually execute the compiled output.
+fn run_main(bytes: &[u8]) -> i64 {
+    let engine = wasmtime::Engine::default();
+    let module = wasmtime::Module::new(&engine, bytes).expect("module should be loadable");
+    let mut store = wasmtime::Store::new(&engine, ());
+    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
+    let main = instance
+        .get_typed_func::<(), i64>(&mut store, "main")
+        .expect("main should have signature () -> i64");
+    main.call(&mut store, ()).expect("main should not trap")
+}
+#[test]
+fn factorial_runs_correctly() {
+    let src = "\
+factorial(x: Int) -> Int =
+  if x < 2
+    return 1
+  return x * factorial(x - 1)
+main() -> Int =
+  factorial(5)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 120);
+}
+#[test]
+fn class_field_and_method_run_correctly() {
+    let src = "\
+type Cat =
+  name: Str
+  age: Int
+getAge<Cat>() -> Int =
+  self.age
+main() -> Int =
+  c = Cat(name: \"x\", age: 7)
+  c.getAge()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn nested_class_call_runs_correctly() {
+    let src = "\
+type Pair =
+  a: Int
+  b: Int
+type Wrapper =
+  inner: Pair
+  tag: Int
+main() -> Int =
+  w = Wrapper(inner: Pair(a: 11, b: 22), tag: 99)
+  w.inner.b
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 22);
+}
+#[test]
+fn repeated_class_call_in_a_loop_does_not_alias() {
+    // Regression test: class instances are bump-allocated at *runtime* (via a
+    // mutable wasm global), not at a compile-time-fixed address — otherwise every
+    // iteration's `Box(...)` would alias the same memory and this would sum to 5*4=20
+    // instead of 0+1+2+3+4=10.
+    let src = "\
+type Box =
+  v: Int
+sumBoxes() -> Int =
+  total = 0
+  for i in 0..5
+    b = Box(v: i)
+    total = total + b.v
+  return total
+main() -> Int =
+  sumBoxes()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 10);
+}
+#[test]
+fn match_int_and_wildcard_run_correctly() {
+    let src = "\
+classify(a: Int) -> Int =
+  match a
+    1 =>
+      return 100
+    2 =>
+      return 200
+    _ =>
+      return 0
+main() -> Int =
+  classify(2)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 200);
+}
+#[test]
+fn match_bool_variant_pattern_runs_correctly() {
+    // Regression test: True/False are built-in Bool variants and must be treated as
+    // tag comparisons, not bindings, even without an explicit `enum Bool` in this
+    // source file — otherwise the first arm always "matches" (as a rebinding) and
+    // `pick(False)` would wrongly return 1.
+    let src = "\
+pick(a: Bool) -> Int =
+  match a
+    True =>
+      return 1
+    False =>
+      return 0
+main() -> Int =
+  pick(False)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 0);
+}
+#[test]
+fn lowercase_single_word_function_call_runs_correctly() {
+    // Regression test: `factorial(...)` (an all-lowercase, no-uppercase, no-underscore
+    // callee) used to fail to parse at all — `var_identifier` and `fn_identifier` both
+    // matched its text and the grammar's lexer would nondeterministically commit to
+    // `var_identifier`, breaking every such call site.
+    let src = "\
+double(n: Int) -> Int =
+  n * 2
+main() -> Int =
+  double(21)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}