plum

# Plum WASM Codegen + Type Checker Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Add a strict type checker (`plum-checker`) and WASM code generator (`plum-wasm-codegen`) to the plum language, wired into `plum-cli` as a `compile` subcommand.

**Architecture:** Parse with `plum-core::AstParser`, type-check with `plum-checker::check_source` (strict — errors halt compilation), then lower to `.wasm` bytes with `plum-wasm-codegen::compile_source`. The hica compiler (`plum/hica/`) is the reference implementation throughout.

**Tech Stack:** Rust, `wasm-encoder = "0.220"`, `wasmparser = "0.220"` (test validation), plum AST from `plum-core`.

## Global Constraints

- Edition 2021 for all new crates (existing plum-core uses 2021; hica uses 2024 — stick with 2021)

- Strict mode: non-empty `Vec<CheckError>` from `check_source` → print errors to stderr, `process::exit(1)`

- v1 scope: `Int`, `Float`, `Bool`, `Str` primitives; top-level `fn`, `Const`; arithmetic/bool/compare ops; `if`/`else`; `for` range (`a..b`); `while`; local `Assign`; `FnCall`; `return`

- Type mapping: `Int → i64`, `Float → f64`, `Bool → i32`, `Str → i32` (pointer), `Unit → no value`

- `main()` is exported as `"main"` in the WASM module

- Follow existing plum AST types exactly — `plum-core::ast::*`

---

## File Map

**New files (create):**

- `plum-checker/Cargo.toml`

- `plum-checker/src/lib.rs` — all checker logic

- `plum-checker/src/types.rs` — `PlumType`, `TypeScheme`, `TypeEnv`, `InferState`, `CheckError`

- `plum-checker/tests/checker_tests.rs`

- `plum-wasm-codegen/Cargo.toml`

- `plum-wasm-codegen/src/lib.rs` — `WasmModule`, `CompileCtx`, `compile_source`

- `plum-wasm-codegen/tests/codegen_tests.rs`

**Modified files:**

- `Cargo.toml` — add `plum-checker` and `plum-wasm-codegen` to `[workspace]`

- `plum-cli/Cargo.toml` — add deps on `plum-checker` and `plum-wasm-codegen`

- `plum-cli/src/main.rs` — add `compile` subcommand

---

## Task 1: Workspace scaffolding

**Files:**

- Modify: `Cargo.toml`

- Create: `plum-checker/Cargo.toml`

- Create: `plum-wasm-codegen/Cargo.toml`

**Interfaces:**

- Produces: two new crates resolvable by `cargo build -p plum-checker` and `cargo build -p plum-wasm-codegen`

- [ ] **Step 1: Add crates to workspace**

Edit `Cargo.toml`:

```toml

[workspace]

members = ["plum-core", "plum-cli", "plum-checker", "plum-wasm-codegen"]

resolver = "2"

```

- [ ] **Step 2: Create plum-checker/Cargo.toml**

```toml

[package]

name = "plum-checker"

version = "0.1.0"

edition = "2021"

[dependencies]

plum-core = { path = "../plum-core" }

```

- [ ] **Step 3: Create plum-wasm-codegen/Cargo.toml**

```toml

[package]

name = "plum-wasm-codegen"

version = "0.1.0"

edition = "2021"

[dependencies]

wasm-encoder = "0.220"

plum-core = { path = "../plum-core" }

plum-checker = { path = "../plum-checker" }

[dev-dependencies]

wasmparser = "0.220"

```

- [ ] **Step 4: Create empty lib stubs so workspace resolves**

Create `plum-checker/src/lib.rs`:

```rust

pub mod types;

```

Create `plum-checker/src/types.rs`:

```rust

// placeholder

```

Create `plum-wasm-codegen/src/lib.rs`:

```rust

// placeholder

```

- [ ] **Step 5: Verify workspace builds**

```

cargo build --workspace

```

Expected: compiles (possibly with unused warnings, no errors).

- [ ] **Step 6: Commit**

```bash

git add Cargo.toml Cargo.lock plum-checker/ plum-wasm-codegen/

git commit -m "chore: scaffold plum-checker and plum-wasm-codegen crates"

```

---

## Task 2: Type definitions (`plum-checker/src/types.rs`)

**Files:**

- Create: `plum-checker/src/types.rs`

**Interfaces:**

- Produces:

  - `pub enum PlumType` with variants: `TInt`, `TFloat`, `TBool`, `TStr`, `TUnit`, `TVar(String)`, `TFun(Vec<PlumType>, Box<PlumType>)`, `TNamed(String)`

  - `pub struct TypeScheme { pub vars: Vec<String>, pub body: Box<PlumType> }`

  - `pub type TypeEnv = std::collections::BTreeMap<String, TypeScheme>`

  - `pub struct InferState { pub counter: u64 }` with `fn fresh_var(&mut self) -> String` and `fn fresh_type(&mut self) -> PlumType`

  - `pub struct CheckError { pub message: String }`

  - `pub type CheckResult<T> = Result<T, Vec<CheckError>>`

- [ ] **Step 1: Write the failing test**

Create `plum-checker/tests/checker_tests.rs`:

```rust

use plum_checker::types::*;

#[test]

fn fresh_vars_are_unique() {

    let mut state = InferState::new();

    let a = state.fresh_var();

    let b = state.fresh_var();

    assert_ne!(a, b);

    assert_eq!(a, "a0");

    assert_eq!(b, "a1");

}

#[test]

fn mono_scheme() {

    let scheme = TypeScheme::mono(PlumType::TInt);

    assert!(scheme.vars.is_empty());

    assert_eq!(*scheme.body, PlumType::TInt);

}

```

- [ ] **Step 2: Run to verify it fails**

```

cargo test -p plum-checker 2>&1 | head -20

```

Expected: compile error — types not defined.

- [ ] **Step 3: Implement types.rs**

Replace `plum-checker/src/types.rs` with:

```rust

use std::collections::BTreeMap;

#[derive(Debug, Clone, PartialEq)]

pub enum PlumType {

    TInt,

    TFloat,

    TBool,

    TStr,

    TUnit,

    TVar(String),

    TFun(Vec<PlumType>, Box<PlumType>),

    TNamed(String),

}

impl std::fmt::Display for PlumType {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            PlumType::TInt => write!(f, "Int"),

            PlumType::TFloat => write!(f, "Float"),

            PlumType::TBool => write!(f, "Bool"),

            PlumType::TStr => write!(f, "Str"),

            PlumType::TUnit => write!(f, "Unit"),

            PlumType::TVar(n) => write!(f, "{}", n),

            PlumType::TFun(ps, r) => {

                let ps_str: Vec<_> = ps.iter().map(|p| p.to_string()).collect();

                write!(f, "({}) -> {}", ps_str.join(", "), r)

            }

            PlumType::TNamed(n) => write!(f, "{}", n),

        }

    }

}

#[derive(Debug, Clone, PartialEq)]

pub struct TypeScheme {

    pub vars: Vec<String>,

    pub body: Box<PlumType>,

}

impl TypeScheme {

    pub fn mono(t: PlumType) -> Self {

        TypeScheme { vars: vec![], body: Box::new(t) }

    }

}

pub type TypeEnv = BTreeMap<String, TypeScheme>;

pub struct InferState {

    pub counter: u64,

}

impl InferState {

    pub fn new() -> Self {

        InferState { counter: 0 }

    }

    pub fn fresh_var(&mut self) -> String {

        let name = format!("a{}", self.counter);

        self.counter += 1;

        name

    }

    pub fn fresh_type(&mut self) -> PlumType {

        PlumType::TVar(self.fresh_var())

    }

}

#[derive(Debug, Clone)]

pub struct CheckError {

    pub message: String,

}

impl std::fmt::Display for CheckError {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(f, "{}", self.message)

    }

}

pub type CheckResult<T> = Result<T, Vec<CheckError>>;

```

Also update `plum-checker/src/lib.rs`:

```rust

pub mod types;

```

- [ ] **Step 4: Run tests**

```

cargo test -p plum-checker

```

Expected: `fresh_vars_are_unique` PASS, `mono_scheme` PASS.

- [ ] **Step 5: Commit**

```bash

git add plum-checker/src/types.rs plum-checker/src/lib.rs plum-checker/tests/checker_tests.rs

git commit -m "feat(plum-checker): add type definitions"

```

---

## Task 3: Type checker — unification and name resolution

**Files:**

- Modify: `plum-checker/src/lib.rs`

**Interfaces:**

- Consumes: `PlumType`, `TypeEnv`, `InferState`, `CheckError`, `CheckResult` from `types.rs`

- Produces:

  - `pub fn plum_type_from_ast(ty: &plum_core::ast::Type) -> PlumType`

  - `fn unify(t1: &PlumType, t2: &PlumType) -> Result<(), String>`

  - `fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String>`

- [ ] **Step 1: Write failing tests**

Append to `plum-checker/tests/checker_tests.rs`:

```rust

use plum_checker::{plum_type_from_ast, unify};

use plum_checker::types::PlumType;

use plum_core::ast::Type as AstType;

#[test]

fn ast_type_int_maps_to_tint() {

    let ast_ty = AstType { name: "Int".to_string(), generics: vec![] };

    assert_eq!(plum_type_from_ast(&ast_ty), PlumType::TInt);

}

#[test]

fn ast_type_unknown_maps_to_named() {

    let ast_ty = AstType { name: "MyClass".to_string(), generics: vec![] };

    assert_eq!(plum_type_from_ast(&ast_ty), PlumType::TNamed("MyClass".to_string()));

}

#[test]

fn unify_same_types_ok() {

    assert!(unify(&PlumType::TInt, &PlumType::TInt).is_ok());

    assert!(unify(&PlumType::TFloat, &PlumType::TFloat).is_ok());

}

#[test]

fn unify_different_types_err() {

    assert!(unify(&PlumType::TInt, &PlumType::TFloat).is_err());

}

```

- [ ] **Step 2: Run to verify fail**

```

cargo test -p plum-checker 2>&1 | head -20

```

Expected: compile error — functions not defined.

- [ ] **Step 3: Implement in lib.rs**

Replace `plum-checker/src/lib.rs`:

```rust

pub mod types;

use types::{PlumType, TypeEnv, TypeScheme, CheckError, CheckResult};

use plum_core::ast;

pub fn plum_type_from_ast(ty: &ast::Type) -> PlumType {

    match ty.name.as_str() {

        "Int" => PlumType::TInt,

        "Float" => PlumType::TFloat,

        "Bool" => PlumType::TBool,

        "Str" => PlumType::TStr,

        "Unit" => PlumType::TUnit,

        other => PlumType::TNamed(other.to_string()),

    }

}

pub fn unify(t1: &PlumType, t2: &PlumType) -> Result<(), String> {

    match (t1, t2) {

        (PlumType::TVar(_), _) | (_, PlumType::TVar(_)) => Ok(()),

        (PlumType::TInt, PlumType::TInt) => Ok(()),

        (PlumType::TFloat, PlumType::TFloat) => Ok(()),

        (PlumType::TBool, PlumType::TBool) => Ok(()),

        (PlumType::TStr, PlumType::TStr) => Ok(()),

        (PlumType::TUnit, PlumType::TUnit) => Ok(()),

        (PlumType::TNamed(a), PlumType::TNamed(b)) if a == b => Ok(()),

        (PlumType::TFun(ps1, r1), PlumType::TFun(ps2, r2)) if ps1.len() == ps2.len() => {

            for (p1, p2) in ps1.iter().zip(ps2.iter()) {

                unify(p1, p2)?;

            }

            unify(r1, r2)

        }

        _ => Err(format!("type mismatch: expected {}, found {}", t1, t2)),

    }

}

fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String> {

    env.get(name)

        .map(|s| *s.body.clone())

        .ok_or_else(|| format!("undefined name '{}'", name))

}

pub fn check_source(source: &ast::Source) -> CheckResult<()> {

    let mut errors: Vec<CheckError> = Vec::new();

    let mut global_env: TypeEnv = TypeEnv::new();

    // First pass: register all top-level function signatures and consts

    for item in &source.items {

        match item {

            ast::Item::Fn(f) => {

                let param_types: Vec<PlumType> = f.params.iter().map(|p| {

                    match &p.ty {

                        ast::ParamType::Type(t) => plum_type_from_ast(t),

                        ast::ParamType::Variadic(t) => plum_type_from_ast(t),

                    }

                }).collect();

                let ret = f.returns.as_ref()

                    .map(|r| PlumType::TNamed(r.name.clone()))

                    .unwrap_or(PlumType::TUnit);

                let scheme = TypeScheme::mono(PlumType::TFun(param_types, Box::new(ret)));

                global_env.insert(f.name.clone(), scheme);

            }

            ast::Item::Const(c) => {

                global_env.insert(c.name.clone(), TypeScheme::mono(PlumType::TVar("_".to_string())));

            }

            _ => {}

        }

    }

    // Second pass: check each function body

    for item in &source.items {

        if let ast::Item::Fn(f) = item {

            let mut local_errors = check_fn(f, &global_env);

            errors.append(&mut local_errors);

        }

    }

    if errors.is_empty() { Ok(()) } else { Err(errors) }

}

fn check_fn(f: &ast::Fn, global_env: &TypeEnv) -> Vec<CheckError> {

    let mut errors = Vec::new();

    let mut env = global_env.clone();

    // Add params to env

    for p in &f.params {

        let ty = match &p.ty {

            ast::ParamType::Type(t) => plum_type_from_ast(t),

            ast::ParamType::Variadic(t) => plum_type_from_ast(t),

        };

        env.insert(p.name.clone(), TypeScheme::mono(ty));

    }

    let declared_ret = f.returns.as_ref()

        .map(|r| {

            let ast_ty = ast::Type { name: r.name.clone(), generics: vec![] };

            plum_type_from_ast(&ast_ty)

        })

        .unwrap_or(PlumType::TUnit);

    match &f.body {

        ast::FnBody::Expr(e) => {

            match infer_expr(e, &env) {

                Ok(t) => {

                    if let Err(msg) = unify(&declared_ret, &t) {

                        errors.push(CheckError { message: format!("fn '{}': return type mismatch: {}", f.name, msg) });

                    }

                }

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': {}", f.name, msg) }),

            }

        }

        ast::FnBody::Block(block) => {

            let mut block_errors = check_block(block, &mut env, &declared_ret, &f.name);

            errors.append(&mut block_errors);

        }

    }

    errors

}

fn check_block(block: &ast::Block, env: &mut TypeEnv, declared_ret: &PlumType, fn_name: &str) -> Vec<CheckError> {

    let mut errors = Vec::new();

    for stmt in &block.stmts {

        let mut stmt_errors = check_stmt(stmt, env, declared_ret, fn_name);

        errors.append(&mut stmt_errors);

    }

    errors

}

fn check_stmt(stmt: &ast::Stmt, env: &mut TypeEnv, declared_ret: &PlumType, fn_name: &str) -> Vec<CheckError> {

    let mut errors = Vec::new();

    match stmt {

        ast::Stmt::Assign(a) => {

            for (target, value) in a.targets.iter().zip(a.values.iter()) {

                match infer_expr(value, env) {

                    Ok(t) => { env.insert(target.clone(), TypeScheme::mono(t)); }

                    Err(msg) => errors.push(CheckError { message: format!("fn '{}': assign '{}': {}", fn_name, target, msg) }),

                }

            }

        }

        ast::Stmt::Return(Some(e)) => {

            match infer_expr(e, env) {

                Ok(t) => {

                    if let Err(msg) = unify(declared_ret, &t) {

                        errors.push(CheckError { message: format!("fn '{}': return type mismatch: {}", fn_name, msg) });

                    }

                }

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': return: {}", fn_name, msg) }),

            }

        }

        ast::Stmt::Return(None) => {

            if let Err(msg) = unify(declared_ret, &PlumType::TUnit) {

                errors.push(CheckError { message: format!("fn '{}': bare return in non-Unit function: {}", fn_name, msg) });

            }

        }

        ast::Stmt::If(if_) => {

            match infer_expr(&if_.condition, env) {

                Ok(t) => {

                    if let Err(msg) = unify(&PlumType::TBool, &t) {

                        errors.push(CheckError { message: format!("fn '{}': if condition must be Bool: {}", fn_name, msg) });

                    }

                }

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': if condition: {}", fn_name, msg) }),

            }

            errors.append(&mut check_block(&if_.body, env, declared_ret, fn_name));

            for ei in &if_.else_ifs {

                match infer_expr(&ei.condition, env) {

                    Ok(t) => {

                        if let Err(msg) = unify(&PlumType::TBool, &t) {

                            errors.push(CheckError { message: format!("fn '{}': else if condition must be Bool: {}", fn_name, msg) });

                        }

                    }

                    Err(msg) => errors.push(CheckError { message: format!("fn '{}': else if condition: {}", fn_name, msg) }),

                }

                errors.append(&mut check_block(&ei.body, env, declared_ret, fn_name));

            }

            if let Some(else_block) = &if_.else_ {

                errors.append(&mut check_block(else_block, env, declared_ret, fn_name));

            }

        }

        ast::Stmt::While(w) => {

            match infer_expr(&w.condition, env) {

                Ok(t) => {

                    if let Err(msg) = unify(&PlumType::TBool, &t) {

                        errors.push(CheckError { message: format!("fn '{}': while condition must be Bool: {}", fn_name, msg) });

                    }

                }

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': while condition: {}", fn_name, msg) }),

            }

            errors.append(&mut check_block(&w.body, env, declared_ret, fn_name));

        }

        ast::Stmt::For(f_stmt) => {

            match infer_expr(&f_stmt.iter, env) {

                Ok(_) => {}

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': for iter: {}", fn_name, msg) }),

            }

            let mut inner_env = env.clone();

            for var in &f_stmt.vars {

                inner_env.insert(var.clone(), TypeScheme::mono(PlumType::TInt));

            }

            errors.append(&mut check_block(&f_stmt.body, &mut inner_env, declared_ret, fn_name));

        }

        ast::Stmt::Expr(e) => {

            if let Err(msg) = infer_expr(e, env) {

                errors.push(CheckError { message: format!("fn '{}': {}", fn_name, msg) });

            }

        }

        ast::Stmt::Assert(e) => {

            match infer_expr(e, env) {

                Ok(t) => {

                    if let Err(msg) = unify(&PlumType::TBool, &t) {

                        errors.push(CheckError { message: format!("fn '{}': assert must be Bool: {}", fn_name, msg) });

                    }

                }

                Err(msg) => errors.push(CheckError { message: format!("fn '{}': assert: {}", fn_name, msg) }),

            }

        }

        ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}

        ast::Stmt::Match(_) => {}

    }

    errors

}

fn infer_expr(expr: &ast::Expr, env: &TypeEnv) -> Result<PlumType, String> {

    match expr {

        ast::Expr::Int(_) => Ok(PlumType::TInt),

        ast::Expr::Float(_) => Ok(PlumType::TFloat),

        ast::Expr::String(_) => Ok(PlumType::TStr),

        ast::Expr::Var(name) => lookup(env, name),

        ast::Expr::Self_ => Ok(PlumType::TVar("Self".to_string())),

        ast::Expr::TypeName(n) => Ok(PlumType::TNamed(n.clone())),

        ast::Expr::Paren(inner) => infer_expr(inner, env),

        ast::Expr::Not(inner) => {

            let t = infer_expr(inner, env)?;

            unify(&PlumType::TBool, &t)?;

            Ok(PlumType::TBool)

        }

        ast::Expr::Unary(u) => infer_expr(&u.operand, env),

        ast::Expr::Binary(b) => {

            let lt = infer_expr(&b.left, env)?;

            let rt = infer_expr(&b.right, env)?;

            unify(&lt, &rt).map_err(|e| format!("binary op: {}", e))?;

            match b.op {

                ast::BinOp::Range => Ok(PlumType::TNamed("Range".to_string())),

                _ => Ok(lt),

            }

        }

        ast::Expr::Bool(b) => {

            let lt = infer_expr(&b.left, env)?;

            let rt = infer_expr(&b.right, env)?;

            unify(&PlumType::TBool, &lt).map_err(|e| format!("bool op left: {}", e))?;

            unify(&PlumType::TBool, &rt).map_err(|e| format!("bool op right: {}", e))?;

            Ok(PlumType::TBool)

        }

        ast::Expr::Compare(c) => {

            let lt = infer_expr(&c.left, env)?;

            let rt = infer_expr(&c.right, env)?;

            unify(&lt, &rt).map_err(|e| format!("compare op: {}", e))?;

            Ok(PlumType::TBool)

        }

        ast::Expr::Ternary(t) => {

            let ct = infer_expr(&t.condition, env)?;

            unify(&PlumType::TBool, &ct).map_err(|e| format!("ternary condition: {}", e))?;

            let tt = infer_expr(&t.then, env)?;

            let et = infer_expr(&t.else_, env)?;

            unify(&tt, &et).map_err(|e| format!("ternary branches: {}", e))?;

            Ok(tt)

        }

        ast::Expr::FnCall(call) => {

            match lookup(env, &call.name) {

                Ok(PlumType::TFun(param_types, ret)) => {

                    if call.args.len() != param_types.len() {

                        return Err(format!("call '{}': expected {} args, got {}", call.name, param_types.len(), call.args.len()));

                    }

                    for (i, (arg, expected)) in call.args.iter().zip(param_types.iter()).enumerate() {

                        let arg_expr = match arg {

                            ast::Arg::Positional(e) => e,

                            ast::Arg::Keyword { value, .. } => value,

                            ast::Arg::Pair { value, .. } => value,

                        };

                        let actual = infer_expr(arg_expr, env)?;

                        unify(expected, &actual).map_err(|e| format!("call '{}' arg {}: {}", call.name, i, e))?;

                    }

                    Ok(*ret)

                }

                Ok(_) => Err(format!("'{}' is not a function", call.name)),

                Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch

            }

        }

        ast::Expr::ClassCall(_) => Ok(PlumType::TVar("_".to_string())),

        ast::Expr::Attribute(_) => Ok(PlumType::TVar("_".to_string())),

    }

}

```

- [ ] **Step 4: Run tests**

```

cargo test -p plum-checker

```

Expected: all tests PASS.

- [ ] **Step 5: Commit**

```bash

git add plum-checker/src/lib.rs plum-checker/tests/checker_tests.rs

git commit -m "feat(plum-checker): implement type checker with unification"

```

---

## Task 4: Type checker tests — error cases

**Files:**

- Modify: `plum-checker/tests/checker_tests.rs`

**Interfaces:**

- Consumes: `check_source` from `plum-checker`

- Produces: verified that wrong return types, undeclared vars, and operator mismatches produce errors

- [ ] **Step 1: Write failing tests**

Append to `plum-checker/tests/checker_tests.rs`:

```rust

use plum_checker::check_source;

use plum_core::{ast::*, AstParser};

fn parse(src: &str) -> Source {

    let mut parser = tree_sitter::Parser::new();

    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();

    let tree = parser.parse(src, None).unwrap();

    let ap = AstParser::new(src);

    ap.parse_source(tree.root_node())

}

#[test]

fn valid_add_fn_passes() {

    let src = "add(a: Int, b: Int) -> Int =\n  a + b\n";

    let source = parse(src);

    assert!(check_source(&source).is_ok(), "expected Ok");

}

#[test]

fn wrong_return_type_is_error() {

    let src = "bad() -> Int =\n  True\n";

    let source = parse(src);

    let result = check_source(&source);

    assert!(result.is_err());

    let errs = result.unwrap_err();

    assert!(errs[0].message.contains("return type mismatch"), "got: {}", errs[0].message);

}

#[test]

fn undeclared_var_is_error() {

    let src = "bad() -> Int =\n  x\n";

    let source = parse(src);

    let result = check_source(&source);

    assert!(result.is_err());

}

#[test]

fn type_mismatch_in_binary_op_is_error() {

    let src = "bad() -> Int =\n  1 + 2.0\n";

    let source = parse(src);

    let result = check_source(&source);

    assert!(result.is_err());

}

```

- [ ] **Step 2: Add tree-sitter-plum to checker dev-dependencies**

Edit `plum-checker/Cargo.toml`:

```toml

[package]

name = "plum-checker"

version = "0.1.0"

edition = "2021"

[dependencies]

plum-core = { path = "../plum-core" }

[dev-dependencies]

tree-sitter = "0.26"

tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }

```

- [ ] **Step 3: Run tests**

```

cargo test -p plum-checker

```

Expected: all tests PASS.

- [ ] **Step 4: Commit**

```bash

git add plum-checker/Cargo.toml plum-checker/tests/checker_tests.rs

git commit -m "test(plum-checker): add error-case tests for type checker"

```

---

## Task 5: WASM module builder (`plum-wasm-codegen/src/lib.rs`)

**Files:**

- Create: `plum-wasm-codegen/src/lib.rs`

**Interfaces:**

- Produces:

  - `pub struct WasmModule` with methods: `new()`, `add_type(params, results) -> u32`, `add_import(module, name, type_idx) -> u32`, `add_function(type_idx, body) -> u32`, `add_export(name, kind, idx)`, `add_memory(min, max) -> u32`, `add_global(val_type, mutable, init) -> u32`, `add_data_segment(offset, data)`, `finish() -> Vec<u8>`

  - `pub struct FuncSig { pub params: Vec<ValType>, pub ret: Option<ValType> }`

  - `pub struct CompileCtx` with fields: `module: WasmModule`, `func_ids: HashMap<String, u32>`, `func_sigs: HashMap<String, FuncSig>`, `current_locals: HashMap<String, u32>`, `label_count: u32`, `bump_offset: u32`

  - `pub fn compile_source(source: &plum_core::ast::Source) -> Result<Vec<u8>, String>`

- [ ] **Step 1: Write a failing codegen test**

Create `plum-wasm-codegen/tests/codegen_tests.rs`:

```rust

use plum_wasm_codegen::compile_source;

use plum_core::AstParser;

fn parse(src: &str) -> plum_core::ast::Source {

    let mut parser = tree_sitter::Parser::new();

    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();

    let tree = parser.parse(src, None).unwrap();

    let ap = AstParser::new(src);

    ap.parse_source(tree.root_node())

}

#[test]

fn compiles_to_valid_wasm() {

    let src = "add(a: Int, b: Int) -> Int =\n  a + b\n";

    let source = parse(src);

    let bytes = compile_source(&source).expect("compile failed");

    // Valid WASM starts with the magic number

    assert_eq!(&bytes[0..4], b"\0asm");

    assert_eq!(&bytes[4..8], &[1, 0, 0, 0]); // version 1

}

#[test]

fn output_validates() {

    let src = "add(a: Int, b: Int) -> Int =\n  a + b\n";

    let source = parse(src);

    let bytes = compile_source(&source).expect("compile failed");

    // wasmparser should accept the output

    let result = wasmparser::validate(&bytes, None);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

}

```

Add dev-dependencies to `plum-wasm-codegen/Cargo.toml`:

```toml

[dev-dependencies]

wasmparser = "0.220"

tree-sitter = "0.26"

tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }

```

- [ ] **Step 2: Run to verify fail**

```

cargo test -p plum-wasm-codegen 2>&1 | head -20

```

Expected: compile error — `compile_source` not defined.

- [ ] **Step 3: Implement WasmModule and CompileCtx**

Replace `plum-wasm-codegen/src/lib.rs`:

```rust

use wasm_encoder::*;

use std::collections::HashMap;

use plum_core::ast;

pub struct WasmModule {

    types: Vec<FuncType>,

    imports: Vec<(String, String, u32)>,

    functions: Vec<(u32, Vec<u8>)>,

    exports: Vec<(String, ExportKind, u32)>,

    memories: Vec<MemoryType>,

    globals: Vec<(ValType, bool, Vec<u8>)>,

    data_segments: Vec<(u32, Vec<u8>)>,

    pub func_import_count: u32,

    pub func_count: u32,

    global_count: u32,

}

impl WasmModule {

    pub fn new() -> Self {

        Self {

            types: Vec::new(),

            imports: Vec::new(),

            functions: Vec::new(),

            exports: Vec::new(),

            memories: Vec::new(),

            globals: Vec::new(),

            data_segments: Vec::new(),

            func_import_count: 0,

            func_count: 0,

            global_count: 0,

        }

    }

    pub fn add_type(&mut self, params: &[ValType], results: &[ValType]) -> u32 {

        let idx = self.types.len() as u32;

        self.types.push(FuncType::new(params.iter().copied(), results.iter().copied()));

        idx

    }

    pub fn add_import(&mut self, module: &str, name: &str, type_idx: u32) -> u32 {

        let idx = self.func_import_count;

        self.imports.push((module.to_string(), name.to_string(), type_idx));

        self.func_import_count += 1;

        idx

    }

    pub fn add_function(&mut self, type_idx: u32, body: &[u8]) -> u32 {

        let idx = self.func_import_count + self.func_count;

        self.functions.push((type_idx, body.to_vec()));

        self.func_count += 1;

        idx

    }

    pub fn add_export(&mut self, name: &str, kind: ExportKind, idx: u32) {

        self.exports.push((name.to_string(), kind, idx));

    }

    pub fn add_memory(&mut self, min: u64, max: Option<u64>) -> u32 {

        let idx = self.memories.len() as u32;

        self.memories.push(MemoryType { minimum: min, maximum: max, memory64: false, shared: false, page_size_log2: None });

        idx

    }

    pub fn add_global(&mut self, val_type: ValType, mutable: bool, init: &[u8]) -> u32 {

        let idx = self.global_count;

        self.globals.push((val_type, mutable, init.to_vec()));

        self.global_count += 1;

        idx

    }

    pub fn add_data_segment(&mut self, offset: u32, data: &[u8]) {

        self.data_segments.push((offset, data.to_vec()));

    }

    pub fn finish(&mut self) -> Vec<u8> {

        let mut module = wasm_encoder::Module::new();

        let mut types = TypeSection::new();

        for ft in &self.types {

            types.ty().function(ft.params().iter().copied(), ft.results().iter().copied());

        }

        module.section(&types);

        if !self.imports.is_empty() {

            let mut imports = ImportSection::new();

            for (module_name, name, type_idx) in &self.imports {

                imports.import(module_name, name, EntityType::Function(*type_idx));

            }

            module.section(&imports);

        }

        let mut funcs = FunctionSection::new();

        for (type_idx, _) in &self.functions {

            funcs.function(*type_idx);

        }

        module.section(&funcs);

        if !self.memories.is_empty() {

            let mut mem = MemorySection::new();

            for mt in &self.memories {

                mem.memory(*mt);

            }

            module.section(&mem);

        }

        if !self.globals.is_empty() {

            let mut globals = GlobalSection::new();

            for (val_type, mutable, init_expr) in &self.globals {

                let expr = ConstExpr::raw(init_expr.iter().copied());

                globals.global(GlobalType { val_type: *val_type, mutable: *mutable, shared: false }, &expr);

            }

            module.section(&globals);

        }

        if !self.exports.is_empty() {

            let mut exports = ExportSection::new();

            for (name, kind, idx) in &self.exports {

                exports.export(name, *kind, *idx);

            }

            module.section(&exports);

        }

        let mut code = CodeSection::new();

        for (_, body_bytes) in &self.functions {

            let func = Function::raw(body_bytes.iter().copied());

            code.function(&func);

        }

        module.section(&code);

        if !self.data_segments.is_empty() {

            let mut data = DataSection::new();

            for (offset, bytes) in &self.data_segments {

                let offset_expr = ConstExpr::i32_const(*offset as i32);

                data.active(0, &offset_expr, bytes.iter().copied());

            }

            module.section(&data);

        }

        module.finish()

    }

}

#[derive(Clone)]

pub struct FuncSig {

    pub params: Vec<ValType>,

    pub ret: Option<ValType>,

}

pub struct CompileCtx {

    pub module: WasmModule,

    pub func_ids: HashMap<String, u32>,

    pub func_sigs: HashMap<String, FuncSig>,

    pub current_locals: HashMap<String, u32>,

    pub label_count: u32,

    pub bump_offset: u32,

}

impl CompileCtx {

    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,

        }

    }

}

fn ast_type_to_wasm(name: &str) -> Option<ValType> {

    match name {

        "Int" => Some(ValType::I64),

        "Float" => Some(ValType::F64),

        "Bool" => Some(ValType::I32),

        "Str" => Some(ValType::I32),

        "Unit" => None,

        _ => Some(ValType::I64),

    }

}

fn ret_type_to_wasm(ret: Option<&ast::ReturnType>) -> Option<ValType> {

    ret.and_then(|r| ast_type_to_wasm(&r.name))

}

fn encode_leb128_u32(mut val: u32) -> Vec<u8> {

    let mut bytes = Vec::new();

    loop {

        let mut byte = (val & 0x7f) as u8;

        val >>= 7;

        if val != 0 { byte |= 0x80; }

        bytes.push(byte);

        if val == 0 { break; }

    }

    bytes

}

pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {

    let mut ctx = CompileCtx::new();

    // Register all function signatures (first pass)

    for item in &source.items {

        if let ast::Item::Fn(f) = item {

            if f.type_param.is_some() { continue; } // skip method impls in v1

            let param_types: Vec<ValType> = f.params.iter().map(|p| {

                let name = match &p.ty {

                    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)

            }).collect();

            let ret = ret_type_to_wasm(f.returns.as_ref());

            let results: &[ValType] = if let Some(r) = ret { &[r][..] } else { &[] };

            // We need to avoid borrow issues: build results vec

            let results_vec: Vec<ValType> = results.to_vec();

            let type_idx = ctx.module.add_type(&param_types, &results_vec);

            let func_idx = ctx.module.add_function(type_idx, &[]);

            ctx.func_ids.insert(f.name.clone(), func_idx);

            ctx.func_sigs.insert(f.name.clone(), FuncSig { params: param_types, ret });

        }

    }

    // Compile each function body (second pass)

    let fns: Vec<ast::Fn> = source.items.iter().filter_map(|item| {

        if let ast::Item::Fn(f) = item {

            if f.type_param.is_none() { Some(f.clone()) } else { None }

        } else { None }

    }).collect();

    let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();

    for f in &fns {

        let body = compile_fn_body(f, &ctx)?;

        compiled_bodies.push((f.name.clone(), body));

    }

    // Patch function bodies back into the module

    for (i, (_, body)) in compiled_bodies.iter().enumerate() {

        ctx.module.functions[i].1 = body.clone();

    }

    // Export main if present

    if let Some(&main_idx) = ctx.func_ids.get("main") {

        ctx.module.add_export("main", ExportKind::Func, main_idx);

    }

    Ok(ctx.module.finish())

}

fn collect_local_names(body: &ast::FnBody) -> Vec<String> {

    let mut names = Vec::new();

    match body {

        ast::FnBody::Block(block) => collect_block_locals(block, &mut names),

        ast::FnBody::Expr(_) => {}

    }

    names

}

fn collect_block_locals(block: &ast::Block, names: &mut Vec<String>) {

    for stmt in &block.stmts {

        collect_stmt_locals(stmt, names);

    }

}

fn collect_stmt_locals(stmt: &ast::Stmt, names: &mut Vec<String>) {

    match stmt {

        ast::Stmt::Assign(a) => {

            for t in &a.targets { if !names.contains(t) { names.push(t.clone()); } }

        }

        ast::Stmt::If(i) => {

            collect_block_locals(&i.body, names);

            for ei in &i.else_ifs { collect_block_locals(&ei.body, names); }

            if let Some(e) = &i.else_ { collect_block_locals(e, names); }

        }

        ast::Stmt::While(w) => collect_block_locals(&w.body, names),

        ast::Stmt::For(f) => {

            for v in &f.vars { if !names.contains(v) { names.push(v.clone()); } }

            collect_block_locals(&f.body, names);

        }

        _ => {}

    }

}

fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx) -> Result<Vec<u8>, String> {

    let mut body = Vec::new();

    let param_count = f.params.len() as u32;

    // Collect all local variable names declared in the body

    let extra_locals = collect_local_names(&f.body);

    // Local section: 0 groups if no extra locals, else 1 group of i64

    let extra_count = extra_locals.len() as u32;

    if extra_count > 0 {

        // 1 group

        body.extend(encode_leb128_u32(1));

        body.extend(encode_leb128_u32(extra_count));

        ValType::I64.encode(&mut body);

    } else {

        body.push(0); // 0 groups

    }

    // Build locals map: params first, then extra

    let mut locals: HashMap<String, u32> = HashMap::new();

    for (i, p) in f.params.iter().enumerate() {

        locals.insert(p.name.clone(), i as u32);

    }

    for (i, name) in extra_locals.iter().enumerate() {

        locals.insert(name.clone(), param_count + i as u32);

    }

    let mut local_ctx = LocalCtx { locals, func_ids: &ctx.func_ids, func_sigs: &ctx.func_sigs };

    match &f.body {

        ast::FnBody::Expr(e) => {

            compile_expr(e, &mut body, &local_ctx)?;

        }

        ast::FnBody::Block(block) => {

            compile_block(block, &mut body, &mut local_ctx)?;

            // If non-unit return, ensure a value is on stack

            let has_ret = f.returns.as_ref().map(|r| r.name != "Unit").unwrap_or(false);

            if !has_ret {

                // nothing to push

            }

        }

    }

    Instruction::End.encode(&mut body);

    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: &mut LocalCtx) -> Result<(), String> {

    for stmt in &block.stmts {

        compile_stmt(stmt, body, ctx)?;

    }

    Ok(())

}

fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &mut LocalCtx) -> Result<(), String> {

    match stmt {

        ast::Stmt::Assign(a) => {

            for (target, value) in a.targets.iter().zip(a.values.iter()) {

                compile_expr(value, body, ctx)?;

                let idx = *ctx.locals.get(target)

                    .ok_or_else(|| format!("undeclared local '{}'", target))?;

                Instruction::LocalSet(idx).encode(body);

            }

        }

        ast::Stmt::Return(Some(e)) => {

            compile_expr(e, body, ctx)?;

            Instruction::Return.encode(body);

        }

        ast::Stmt::Return(None) => {

            Instruction::Return.encode(body);

        }

        ast::Stmt::If(if_) => {

            compile_expr(&if_.condition, body, ctx)?;

            Instruction::If(BlockType::Empty).encode(body);

            compile_block(&if_.body, body, ctx)?;

            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)?;

                    Instruction::If(BlockType::Empty).encode(body);

                    compile_block(&ei.body, body, ctx)?;

                    Instruction::Else.encode(body);

                }

                if let Some(else_block) = &if_.else_ {

                    compile_block(else_block, body, ctx)?;

                }

                for _ in &if_.else_ifs {

                    Instruction::End.encode(body);

                }

            }

            Instruction::End.encode(body);

        }

        ast::Stmt::While(w) => {

            // block { loop { cond; br_if 1 (exit); body; br 0 (loop) } }

            Instruction::Block(BlockType::Empty).encode(body);

            Instruction::Loop(BlockType::Empty).encode(body);

            compile_expr(&w.condition, body, ctx)?;

            Instruction::I32Eqz.encode(body); // invert: exit if cond==false

            Instruction::BrIf(1).encode(body); // break out of block

            compile_block(&w.body, body, ctx)?;

            Instruction::Br(0).encode(body); // loop again

            Instruction::End.encode(body); // end loop

            Instruction::End.encode(body); // end block

        }

        ast::Stmt::For(f) => {

            // Evaluate range iter (BinOp Range emits start/end)

            // Simple for i in start..end pattern

            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.locals.get(var_name)

                        .ok_or_else(|| format!("undeclared loop var '{}'", var_name))?;

                    // i = start

                    compile_expr(&b.left, body, ctx)?;

                    Instruction::LocalSet(var_idx).encode(body);

                    // block { loop { if i >= end break; body; i += 1; br 0 } }

                    Instruction::Block(BlockType::Empty).encode(body);

                    Instruction::Loop(BlockType::Empty).encode(body);

                    // check i >= end (i64 ge_s)

                    Instruction::LocalGet(var_idx).encode(body);

                    compile_expr(&b.right, body, ctx)?;

                    Instruction::I64GeS.encode(body);

                    Instruction::BrIf(1).encode(body);

                    compile_block(&f.body, body, ctx)?;

                    // i += 1

                    Instruction::LocalGet(var_idx).encode(body);

                    Instruction::I64Const(1).encode(body);

                    Instruction::I64Add.encode(body);

                    Instruction::LocalSet(var_idx).encode(body);

                    Instruction::Br(0).encode(body);

                    Instruction::End.encode(body);

                    Instruction::End.encode(body);

                    return Ok(());

                }

            }

            // fallback: evaluate iter and drop

            compile_expr(&f.iter, body, ctx)?;

            Instruction::Drop.encode(body);

        }

        ast::Stmt::Expr(e) => {

            compile_expr(e, body, ctx)?;

            // drop result if not used

            Instruction::Drop.encode(body);

        }

        ast::Stmt::Break => {

            Instruction::Br(1).encode(body);

        }

        ast::Stmt::Continue => {

            Instruction::Br(0).encode(body);

        }

        ast::Stmt::Assert(_) | ast::Stmt::Match(_) | ast::Stmt::Todo => {}

    }

    Ok(())

}

fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {

    match expr {

        ast::Expr::Int(n) => {

            Instruction::I64Const(*n).encode(body);

        }

        ast::Expr::Float(f) => {

            Instruction::F64Const(*f).encode(body);

        }

        ast::Expr::Var(name) => {

            let idx = *ctx.locals.get(name.as_str())

                .ok_or_else(|| format!("undeclared variable '{}'", name))?;

            Instruction::LocalGet(idx).encode(body);

        }

        ast::Expr::Paren(inner) => {

            compile_expr(inner, body, ctx)?;

        }

        ast::Expr::Unary(u) => {

            compile_expr(&u.operand, body, ctx)?;

            match u.op {

                ast::UnOp::Neg => {

                    // negate: 0 - x

                    Instruction::I64Const(0).encode(body);

                    // swap: need operand on stack, then 0-operand

                    // Actually emit operand first, then negate via i64.const(0) swap trick

                    // Re-emit: push 0, push operand, sub (order: 0 - operand not right)

                    // Correct pattern: push operand (already done above as compile_expr),

                    // then we need: we already emitted operand. Use i64.neg alternative:

                    // WASM has no i64.neg directly; use: i64.const(-1) * x or 0 - x

                    // Since operand is already on stack, we need to do: 

                    // [operand] → [0 - operand]  → emit I64Const(0) BEFORE operand

                    // We can't undo — use: operand * -1

                    Instruction::I64Const(-1).encode(body);

                    Instruction::I64Mul.encode(body);

                }

                ast::UnOp::Pos => {}

            }

        }

        ast::Expr::Binary(b) => {

            compile_expr(&b.left, body, ctx)?;

            compile_expr(&b.right, body, ctx)?;

            match b.op {

                ast::BinOp::Add => Instruction::I64Add.encode(body),

                ast::BinOp::Sub => Instruction::I64Sub.encode(body),

                ast::BinOp::Mul => Instruction::I64Mul.encode(body),

                ast::BinOp::Div => 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),

                ast::BinOp::Xor => Instruction::I64Xor.encode(body),

                ast::BinOp::Shl => Instruction::I64Shl.encode(body),

                ast::BinOp::Shr => Instruction::I64ShrS.encode(body),

                ast::BinOp::Range => {

                    // range produces end value on stack (start already consumed)

                    // for range used in For, the For handler handles it specially

                    // here just leave end on stack as a placeholder

                }

            }

        }

        ast::Expr::Bool(b) => {

            compile_expr(&b.left, body, ctx)?;

            compile_expr(&b.right, body, ctx)?;

            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)?;

            Instruction::I32Eqz.encode(body);

        }

        ast::Expr::Compare(c) => {

            compile_expr(&c.left, body, ctx)?;

            compile_expr(&c.right, body, ctx)?;

            match c.op {

                ast::CmpOp::Lt  => Instruction::I64LtS.encode(body),

                ast::CmpOp::Lte => Instruction::I64LeS.encode(body),

                ast::CmpOp::Eq  => Instruction::I64Eq.encode(body),

                ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne.encode(body),

                ast::CmpOp::Gte => Instruction::I64GeS.encode(body),

                ast::CmpOp::Gt  => Instruction::I64GtS.encode(body),

            }

        }

        ast::Expr::Ternary(t) => {

            compile_expr(&t.condition, body, ctx)?;

            Instruction::If(BlockType::Result(ValType::I64)).encode(body);

            compile_expr(&t.then, body, ctx)?;

            Instruction::Else.encode(body);

            compile_expr(&t.else_, body, ctx)?;

            Instruction::End.encode(body);

        }