bb8ca38 | plum

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

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

bb8ca38 — Peter John 2026-07-19T19:25:17+05:30

feat(plum-wasm-codegen): implement WasmModule, CompileCtx and compile_source

Files changed (3) hide show

plum-wasm-codegen/Cargo.toml +2 -0
plum-wasm-codegen/src/lib.rs +666 -1
plum-wasm-codegen/tests/codegen_tests.rs +30 -0

plum-wasm-codegen/Cargo.toml CHANGED Viewed

@@ -10,3 +10,5 @@ plum-checker = { path = "../plum-checker" }
 [dev-dependencies]
 wasmparser = "0.220"
+tree-sitter = "0.26"
+tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }

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

@@ -1 +1,666 @@
+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();
-// placeholder
+        // Type section
+        let mut types = TypeSection::new();
+        for ft in &self.types {
+            types.ty().function(ft.params().iter().copied(), ft.results().iter().copied());
+        }
+        module.section(&types);
+        // Import section
+        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);
+        }
+        // Function section
+        if !self.functions.is_empty() {
+            let mut funcs = FunctionSection::new();
+            for (type_idx, _) in &self.functions {
+                funcs.function(*type_idx);
+            }
+            module.section(&funcs);
+        }
+        // Memory section
+        if !self.memories.is_empty() {
+            let mut mem = MemorySection::new();
+            for mt in &self.memories {
+                mem.memory(*mt);
+            }
+            module.section(&mem);
+        }
+        // Global section
+        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);
+        }
+        // Export section
+        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);
+        }
+        // Code section
+        if !self.functions.is_empty() {
+            let mut code = CodeSection::new();
+            for (_, body_bytes) in &self.functions {
+                code.raw(body_bytes);
+            }
+            module.section(&code);
+        }
+        // Data section
+        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()
+    }
+}
+impl Default for WasmModule {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+#[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,
+        }
+    }
+}
+impl Default for CompileCtx {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+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();
+    // First pass: register all function type signatures and allocate function slots
+    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_vec: Vec<ValType> = ret.into_iter().collect();
+            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 });
+        }
+    }
+    // Second pass: compile each function body
+    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 bodies into the module
+    for (i, (_, body)) in compiled_bodies.iter().enumerate() {
+        ctx.module.functions[i].1 = body.clone();
+    }
+    // Export all top-level functions
+    let func_ids_snapshot: Vec<(String, u32)> = ctx.func_ids.iter().map(|(k, v)| (k.clone(), *v)).collect();
+    for (name, idx) in func_ids_snapshot {
+        ctx.module.add_export(&name, ExportKind::Func, idx);
+    }
+    Ok(ctx.module.finish())
+}
+fn collect_local_names(body: &ast::FnBody) -> Vec<String> {
+    let mut names = Vec::new();
+    if let ast::FnBody::Block(block) = body {
+        collect_block_locals(block, &mut names);
+    }
+    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 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;
+    // Encode local declarations: group count, then each group as (count, type)
+    if extra_count > 0 {
+        body.extend(encode_leb128_u32(1)); // 1 group
+        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 locals
+    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 local_ctx = LocalCtx {
+        locals,
+        func_ids: &ctx.func_ids,
+        func_sigs: &ctx.func_sigs,
+    };
+    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)?;
+        }
+        ast::FnBody::Block(block) => {
+            compile_block_as_fn_body(block, &mut body, &local_ctx, has_return_value)?;
+        }
+    }
+    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: &LocalCtx) -> Result<(), String> {
+    for stmt in &block.stmts {
+        compile_stmt(stmt, body, ctx)?;
+    }
+    Ok(())
+}
+/// Compile 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,
+    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)?;
+            }
+            // Last statement: if it's an Expr, leave its value on stack
+            match last {
+                ast::Stmt::Expr(e) => {
+                    compile_expr(e, body, ctx)?;
+                    // do NOT drop — this is the return value
+                }
+                _ => {
+                    compile_stmt(last, body, ctx)?;
+                }
+            }
+            return Ok(());
+        }
+    }
+    for stmt in stmts {
+        compile_stmt(stmt, body, ctx)?;
+    }
+    Ok(())
+}
+fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &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)?;
+            // 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)?;
+            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; 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)?;
+            Instruction::I32Eqz.encode(body);
+            Instruction::BrIf(1).encode(body);
+            compile_block(&w.body, body, ctx)?;
+            Instruction::Br(0).encode(body);
+            Instruction::End.encode(body);
+            Instruction::End.encode(body);
+        }
+        ast::Stmt::For(f) => {
+            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))?;
+                    compile_expr(&b.left, body, ctx)?;
+                    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)?;
+                    Instruction::I64GeS.encode(body);
+                    Instruction::BrIf(1).encode(body);
+                    compile_block(&f.body, body, ctx)?;
+                    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(());
+                }
+            }
+            compile_expr(&f.iter, body, ctx)?;
+            Instruction::Drop.encode(body);
+        }
+        ast::Stmt::Expr(e) => {
+            let has_result = expr_has_result(e, ctx);
+            compile_expr(e, body, ctx)?;
+            if has_result {
+                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(())
+}
+/// 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)
+        }
+        _ => true,
+    }
+}
+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) => {
+            if name == "true" {
+                Instruction::I32Const(1).encode(body);
+            } else if name == "false" {
+                Instruction::I32Const(0).encode(body);
+            } else {
+                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) => {
+            match u.op {
+                ast::UnOp::Neg => {
+                    // WASM has no i64.neg; use i64.const(0) - operand
+                    Instruction::I64Const(0).encode(body);
+                    compile_expr(&u.operand, body, ctx)?;
+                    Instruction::I64Sub.encode(body);
+                }
+                ast::UnOp::Pos => {
+                    compile_expr(&u.operand, body, ctx)?;
+                }
+            }
+        }
+        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 used outside of For: leave end on stack (start consumed)
+                }
+            }
+        }
+        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);
+        }
+        ast::Expr::FnCall(call) => {
+            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)?;
+            }
+            let func_idx = ctx
+                .func_ids
+                .get(&call.name)
+                .ok_or_else(|| format!("unknown function '{}'", call.name))?;
+            Instruction::Call(*func_idx).encode(body);
+        }
+        ast::Expr::Self_ => {
+            return Err("'self' not supported in v1 codegen".to_string());
+        }
+        ast::Expr::TypeName(_) | ast::Expr::ClassCall(_) | ast::Expr::Attribute(_) => {
+            Instruction::I64Const(0).encode(body);
+        }
+        ast::Expr::String(_) => {
+            Instruction::I32Const(0).encode(body);
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,30 @@
+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);
+    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
+}