feat(codegen): complete .twasm front-end for the example corpus (2/6 -> 6/6)

Extends the v0 front-end + codegen so all six canonical examples parse, emit
valid wasm, and round-trip through the verifier (Phase 1 / #130):

- parser: ptr<T>/unique<T>/ref<T> field pointers (03); optional/unnamed fn
  params + &mut/&/own region<T> borrow params (05, 06); general annotation-clause
  skip (cost_bound { ... } etc., 05); import region X from "..." {...}|;
  with quoted module source (06, 02); invariant { ... } region constraint
  blocks (02).
- codegen: typed result stubs — Op::{I64Const,F32Const,F64Const} + mappings, so
  representative bodies type-check against f32/i64/f64 result types (03).
- tests: parsed_example_corpus_round_trips round-trips all six examples
  (the #130 soundness gate over real .twasm, not just paint-type/example-01).

Still v0 (type-correct representative bodies, not full region.get/set lowering;
the six canonical examples, not arbitrary .twasm). 31/31 codegen tests pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

crates/typed-wasm-codegen/src/lib.rs

@@ -182,6 +182,9 @@ impl Wty {
 pub enum Op {
     LocalGet(u32),
     I32Const(i32),
+    I64Const(i64),
+    F32Const(f32),
+    F64Const(f64),
     I32Load {
         offset: u64,
     },
@@ -330,6 +333,9 @@ fn op_to_instruction(op: Op) -> Instruction<'static> {
     match op {
         Op::LocalGet(i) => Instruction::LocalGet(i),
         Op::I32Const(c) => Instruction::I32Const(c),
+        Op::I64Const(c) => Instruction::I64Const(c),
+        Op::F32Const(c) => Instruction::F32Const(c.into()),
+        Op::F64Const(c) => Instruction::F64Const(c.into()),
         Op::I32Load { offset } => Instruction::I32Load(memarg(offset, 2)),
         Op::I32Store { offset } => Instruction::I32Store(memarg(offset, 2)),
         Op::F32Load { offset } => Instruction::F32Load(memarg(offset, 2)),

crates/typed-wasm-codegen/src/parser.rs

@@ -208,6 +208,21 @@ impl<'a> Parser<'a> {
                 continue;
             }
 
+            // Check for a constraint block: `invariant { ... }` (and similar
+            // region-body annotation blocks). Skipped — the verifier checks
+            // the schema/carriers, not these source-level constraints.
+            if self.peek_word("invariant") {
+                self.expect("invariant")?;
+                self.skip_whitespace();
+                self.expect("{")?;
+                self.skip_to_brace_close();
+                self.skip_whitespace();
+                if self.peek_char(';') {
+                    self.expect(";")?;
+                }
+                continue;
+            }
+
             let field_name = self.parse_ident();
             self.skip_whitespace();
             self.expect(":")?;
@@ -275,7 +290,31 @@ impl<'a> Parser<'a> {
             self.expect("<")?;
             nullable = true;
         }
-        
+
+        // Check for ptr<Region> / unique<Region> / ref<Region> field pointer
+        // (e.g. `next: opt<ptr<FreeSlot>>`). Field-level region pointers, the
+        // `@Region` form's keyword-with-angle-brackets sibling.
+        if self.peek_word("ptr") || self.peek_word("unique") || self.peek_word("ref") {
+            let kw = self.parse_ident();
+            self.skip_whitespace();
+            self.expect("<")?;
+            self.skip_whitespace();
+            let region_name = self.parse_ident();
+            self.skip_whitespace();
+            self.expect(">")?;
+            if nullable {
+                self.skip_whitespace();
+                self.expect(">")?;
+            }
+            let kind = match kw.as_str() {
+                "unique" => PtrKind::Exclusive,
+                "ref" => PtrKind::Borrow,
+                _ => PtrKind::Owning,
+            };
+            let target = self.region_map.get(&region_name).copied().unwrap_or(0);
+            return Ok((FieldTy::Ptr { kind, target, nullable }, 1));
+        }
+
         // Check for @Region reference
         if self.peek_char('@') {
             self.expect("@")?;
@@ -529,11 +568,19 @@ impl<'a> Parser<'a> {
                 break;
             }
 
-            // Parse parameter: name: type (skip name, just get type)
-            let _param_name = self.parse_ident();
-            self.skip_whitespace();
-            self.expect(":")?;
+            // Parse optional parameter name. Params may be named (`p: &mut
+            // region<T>`, `dt: f32`) or unnamed (`&mut region<Particles>`,
+            // `i32`). Detect a `name:` prefix; if absent, rewind and parse the
+            // type directly.
+            let save = self.pos;
+            let maybe_name = self.parse_ident();
             self.skip_whitespace();
+            if !maybe_name.is_empty() && self.peek_char(':') {
+                self.expect(":")?;
+                self.skip_whitespace();
+            } else {
+                self.pos = save;
+            }
 
             // Parse the type, which may include ownership qualifiers
             let (param_ty, _) = self.parse_param_type()?;
@@ -570,14 +617,27 @@ impl<'a> Parser<'a> {
 
         self.skip_whitespace();
 
-        // Skip effects annotation if present: effects { ... }
-        if self.peek_word("effects") {
-            self.expect("effects")?;
+        // Skip any annotation clauses before the body: `effects { ... }`,
+        // `cost_bound { ... }`, `requires { ... }`, etc. The body is the
+        // first `{` not preceded by an annotation keyword.
+        loop {
             self.skip_whitespace();
-            self.expect("{")?;
-            self.skip_to_brace_close();
+            if self.peek_char('{') {
+                break; // function body
+            }
+            let at = self.pos;
+            if at < self.src.len() && (self.src.as_bytes()[at] as char).is_ascii_alphabetic() {
+                let _annotation = self.parse_ident();
+                self.skip_whitespace();
+                if self.peek_char('{') {
+                    self.expect("{")?;
+                    self.skip_to_brace_close();
+                    continue;
+                }
+            }
+            break;
         }
-        
+
         self.expect("{")?;
 
         // Parse function body and emit placeholder ops
@@ -590,10 +650,15 @@ impl<'a> Parser<'a> {
             body.push(crate::Op::Drop);
         }
 
-        // If function returns a value, emit a constant 0
-        if !results.is_empty() {
-            // For now, assume i32 result
-            body.push(crate::Op::I32Const(0));
+        // If the function returns a value, emit a type-correct zero so the
+        // representative body type-checks against the declared result type.
+        if let Some(&rty) = results.first() {
+            body.push(match rty {
+                Wty::I32 => crate::Op::I32Const(0),
+                Wty::I64 => crate::Op::I64Const(0),
+                Wty::F32 => crate::Op::F32Const(0.0),
+                Wty::F64 => crate::Op::F64Const(0.0),
+            });
         }
 
         let accesses = Vec::new();
@@ -773,13 +838,34 @@ impl<'a> Parser<'a> {
 
     fn parse_import(&mut self) -> Result<(), String> {
         self.expect("import")?;
+        self.skip_whitespace();
+        // Optional `region` keyword: `import region Name from "module" ...`
+        if self.peek_word("region") {
+            self.expect("region")?;
+            self.skip_whitespace();
+        }
         let _name = self.parse_ident();
         self.skip_whitespace();
         self.expect("from")?;
         self.skip_whitespace();
-        let _module = self.parse_ident();
+        // Module source: a quoted string ("game_server") or a bare ident.
+        if self.peek_char('"') {
+            self.expect("\"")?;
+            while self.pos < self.src.len() && self.src.as_bytes()[self.pos] != b'"' {
+                self.pos += 1;
+            }
+            self.expect("\"")?;
+        } else {
+            let _module = self.parse_ident();
+        }
         self.skip_whitespace();
-        self.expect(";")?;
+        // Either a re-declaration body `{ ... }` (multi-module) or a `;`.
+        if self.peek_char('{') {
+            self.expect("{")?;
+            self.skip_to_brace_close();
+        } else if self.peek_char(';') {
+            self.expect(";")?;
+        }
         Ok(())
     }
 }

crates/typed-wasm-codegen/tests/corpus.rs

@@ -153,6 +153,29 @@ fn parsed_paint_type_schemas_round_trip() {
     assert_round_trips(&ex01_module);
 }
 
+/// Round-trip the full example corpus: every `examples/NN-*.twasm` must parse,
+/// emit valid wasm, and pass the verifier. This is the v1.0 end-to-end
+/// soundness gate (#130) over the canonical six real `.twasm` sources — not
+/// just paint-type / example-01. Extending the front-end (ptr<T> fields,
+/// unnamed/borrow fn params, annotation clauses, import-region, invariant
+/// blocks) took this corpus from 2/6 to 6/6.
+#[test]
+fn parsed_example_corpus_round_trips() {
+    let corpus: [(&str, &str); 6] = [
+        ("01-single-module", include_str!("../../../examples/01-single-module.twasm")),
+        ("02-multi-module", include_str!("../../../examples/02-multi-module.twasm")),
+        ("03-ownership-linearity", include_str!("../../../examples/03-ownership-linearity.twasm")),
+        ("04-ecs-game", include_str!("../../../examples/04-ecs-game.twasm")),
+        ("05-tropical-cost", include_str!("../../../examples/05-tropical-cost.twasm")),
+        ("06-epistemic-sync", include_str!("../../../examples/06-epistemic-sync.twasm")),
+    ];
+    for (name, src) in corpus {
+        let module =
+            parser::parse_module(src).unwrap_or_else(|e| panic!("{name}.twasm must parse: {e}"));
+        assert_round_trips(&module);
+    }
+}
+
 #[test]
 fn generated_corpus_round_trips() {
     for seed in 0..512u64 {