feat(syntax,parser): core match_expr dispatch + Pattern AST (#61)

hyperpolymath · claude · hyperpolymath · commit 94e0eb5d3e24 · 2026-05-15T04:16:43.000+01:00
Adds `ExprKind::Match { scrutinee, arms }` and `MatchArm { pattern, guard, body }` to `ephapax-syntax`, extends `Pattern` with `Literal` and `Constructor` variants (joining the existing Wildcard/Var/Pair/ Tuple/Unit), and adds `parse_match_expr_core` + `parse_pattern_core` to the core parser. `Rule::match_expr` is now dispatched from both `parse_expression` and `parse_single_expr_core`, so the example from the issue — `match x of | Some(v) => v | None => 0 end` — parses through the core parser direct path instead of failing with `"Unexpected single_expr: match_expr"`. This is option 1 from the issue (structured AST + Pattern, not desugar-to-Case). The runtime path (surface → desugar → core) continues to lower its own `SurfaceExprKind::Match` to nested `ExprKind::Case`, so the surface pipeline is unaffected. The new core variant exists for the core-parser-direct path and tooling consumers that want the structured shape. Downstream consumers (11 exhaustive `match ExprKind` sites across the workspace): Walking arms (subexpression-correct, sound for analyses): - ephapax-analysis/src/{escape,free_vars,liveness}.rs — walk scrutinee + each arm body with pattern's bound_vars in scope - ephapax-linear/src/{linear,affine}.rs — walk subexprs with pattern bindings; TODO marker for proper N-arm branch-agreement - ephapax-wasm/src/lib.rs free-vars collector — walk subexprs Stub-erroring (forward-compatible, honest about scope): - ephapax-typing/src/lib.rs — new `TypeError::NotYetSupportedInCore` variant; the typechecker tells callers to use the surface path - ephapax-wasm/src/lib.rs compile_expr — emits `unreachable` - ephapax-interp/src/lib.rs — returns `RuntimeError::Unimplemented` Structured render: - ephapax-ir/src/lib.rs — `(match scrutinee (arm <pattern> <body>) ...)` with a `pattern_to_sexpr` helper Pass-through (find_let_binding_span): - ephapax-lsp/src/main.rs — recurses through scrutinee + arms Tests (parser-level, hits AC): - `test_parse_core_match_constructor_and_var_patterns` — the AC example with Some(v)/None - `test_parse_core_match_wildcard_pattern` — `_` + literal arms - `test_parse_module_with_core_match` — the AC example wrapped in a module declaration, dispatched via parse_expression Workspace lib tests: 294 pass, 0 fail. Closes #61. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
diff --git a/ephapax-linear/src/affine.rs b/ephapax-linear/src/affine.rs
@@ -311,6 +311,29 @@ impl AffineChecker {
                     }
                 }
             }
+
+            // Core `match`: affine allows arms to disagree on
+            // consumption (the non-consuming arm implicitly drops),
+            // so a simple walk-with-pattern-binding mirrors the
+            // existing arm-disagreement freedom for `if` and `case`.
+            // TODO(ephapax#61 follow-up): N-arm `merge_affine_branches`
+            // for tighter cross-arm reasoning.
+            ExprKind::Match { scrutinee, arms } => {
+                self.walk_expr(scrutinee);
+                for arm in arms {
+                    let bound = arm.pattern.bound_vars();
+                    for v in &bound {
+                        self.ctx.bind(v.clone(), BindingForm::Let, None);
+                    }
+                    if let Some(guard) = &arm.guard {
+                        self.walk_expr(guard);
+                    }
+                    self.walk_expr(&arm.body);
+                    for v in bound.iter().rev() {
+                        self.ctx.unbind(v);
+                    }
+                }
+            }
         }
     }
 
diff --git a/ephapax-linear/src/linear.rs b/ephapax-linear/src/linear.rs
@@ -374,6 +374,31 @@ impl LinearChecker {
                     }
                 }
             }
+
+            // Core `match`: walk scrutinee + each arm body with the
+            // pattern's bound vars in scope. TODO(ephapax#61 follow-up):
+            // implement proper N-arm branch-agreement checking so a
+            // linear var consumed in only some arms is rejected. For
+            // now we simply walk subexpressions to keep the discipline
+            // checker sound on the structural fragment; programs that
+            // produce `ExprKind::Match` today come only from the core
+            // parser direct path and have no existing test coverage.
+            ExprKind::Match { scrutinee, arms } => {
+                self.walk_expr(scrutinee);
+                for arm in arms {
+                    let bound = arm.pattern.bound_vars();
+                    for v in &bound {
+                        self.ctx.bind(v.clone(), BindingForm::Let, None);
+                    }
+                    if let Some(guard) = &arm.guard {
+                        self.walk_expr(guard);
+                    }
+                    self.walk_expr(&arm.body);
+                    for v in bound.iter().rev() {
+                        self.ctx.unbind(v);
+                    }
+                }
+            }
         }
     }
 
diff --git a/src/ephapax-analysis/src/escape.rs b/src/ephapax-analysis/src/escape.rs
@@ -195,6 +195,16 @@ impl EscapeAnalysis {
                 }
             }
 
+            ExprKind::Match { scrutinee, arms } => {
+                Self::analyze_expr(scrutinee, escaping, in_escaping_context);
+                for arm in arms {
+                    if let Some(guard) = &arm.guard {
+                        Self::analyze_expr(guard, escaping, in_escaping_context);
+                    }
+                    Self::analyze_expr(&arm.body, escaping, in_escaping_context);
+                }
+            }
+
             // Literals and string allocations never escape
             ExprKind::Lit(_) | ExprKind::StringNew { .. } => {}
         }
diff --git a/src/ephapax-analysis/src/free_vars.rs b/src/ephapax-analysis/src/free_vars.rs
@@ -194,6 +194,20 @@ impl FreeVarAnalysis {
                 }
             }
 
+            ExprKind::Match { scrutinee, arms } => {
+                Self::collect(scrutinee, free, bound);
+                for arm in arms {
+                    let mut arm_bound = bound.clone();
+                    for v in arm.pattern.bound_vars() {
+                        arm_bound.insert(v);
+                    }
+                    if let Some(guard) = &arm.guard {
+                        Self::collect(guard, free, &mut arm_bound);
+                    }
+                    Self::collect(&arm.body, free, &mut arm_bound);
+                }
+            }
+
             ExprKind::Lit(_) | ExprKind::StringNew { .. } => {}
         }
     }
diff --git a/src/ephapax-analysis/src/liveness.rs b/src/ephapax-analysis/src/liveness.rs
@@ -200,6 +200,21 @@ impl LivenessAnalysis {
                 Self::compute(body, live);
             }
 
+            ExprKind::Match { scrutinee, arms } => {
+                for arm in arms.iter().rev() {
+                    let mut arm_live = HashSet::new();
+                    Self::compute(&arm.body, &mut arm_live);
+                    if let Some(guard) = &arm.guard {
+                        Self::compute(guard, &mut arm_live);
+                    }
+                    for v in arm.pattern.bound_vars() {
+                        arm_live.remove(&v);
+                    }
+                    live.extend(arm_live);
+                }
+                Self::compute(scrutinee, live);
+            }
+
             ExprKind::Lit(_) | ExprKind::StringNew { .. } => {}
         }
     }
diff --git a/src/ephapax-interp/src/lib.rs b/src/ephapax-interp/src/lib.rs
@@ -477,6 +477,9 @@ impl Interpreter {
                     "effect handle not yet implemented in interpreter".into(),
                 ))
             }
+            ExprKind::Match { .. } => Err(RuntimeError::Unimplemented(
+                "core ExprKind::Match not yet implemented in interpreter — use the surface (parse_surface_module → desugar) path which lowers match to nested Case".into(),
+            )),
         }
     }
 
diff --git a/src/ephapax-ir/src/lib.rs b/src/ephapax-ir/src/lib.rs
@@ -548,6 +548,61 @@ fn expr_to_sexpr(expr: &Expr) -> SExpr {
             }
             SExpr::List(elems)
         }
+        // `(match scrutinee (arm <pattern> <body>) ...)` — added
+        // ephapax#61 so the structured `match` survives IR round-trip.
+        // Guards render as `(arm <pattern> (guard <e>) <body>)`.
+        ExprKind::Match { scrutinee, arms } => {
+            let mut elems =
+                vec![SExpr::Atom("match".into()), expr_to_sexpr(scrutinee)];
+            for arm in arms {
+                let mut arm_elems = vec![
+                    SExpr::Atom("arm".into()),
+                    pattern_to_sexpr(&arm.pattern),
+                ];
+                if let Some(guard) = &arm.guard {
+                    arm_elems.push(SExpr::List(vec![
+                        SExpr::Atom("guard".into()),
+                        expr_to_sexpr(guard),
+                    ]));
+                }
+                arm_elems.push(expr_to_sexpr(&arm.body));
+                elems.push(SExpr::List(arm_elems));
+            }
+            SExpr::List(elems)
+        }
+    }
+}
+
+fn pattern_to_sexpr(pattern: &ephapax_syntax::Pattern) -> SExpr {
+    use ephapax_syntax::Pattern;
+    match pattern {
+        Pattern::Wildcard => SExpr::Atom("_".into()),
+        Pattern::Unit => SExpr::List(vec![SExpr::Atom("unit".into())]),
+        Pattern::Var(v) => SExpr::List(vec![
+            SExpr::Atom("var".into()),
+            SExpr::Atom(escape_atom(v)),
+        ]),
+        Pattern::Literal(lit) => {
+            SExpr::List(vec![SExpr::Atom("lit".into()), lit_to_sexpr(lit)])
+        }
+        Pattern::Pair(l, r) => SExpr::List(vec![
+            SExpr::Atom("pair".into()),
+            pattern_to_sexpr(l),
+            pattern_to_sexpr(r),
+        ]),
+        Pattern::Tuple(ps) => {
+            let mut elems = vec![SExpr::Atom("tuple".into())];
+            elems.extend(ps.iter().map(pattern_to_sexpr));
+            SExpr::List(elems)
+        }
+        Pattern::Constructor { ctor, args } => {
+            let mut elems = vec![
+                SExpr::Atom("ctor".into()),
+                SExpr::Atom(escape_atom(ctor)),
+            ];
+            elems.extend(args.iter().map(pattern_to_sexpr));
+            SExpr::List(elems)
+        }
     }
 }
 
diff --git a/src/ephapax-lsp/src/main.rs b/src/ephapax-lsp/src/main.rs
@@ -732,6 +732,16 @@ fn find_let_binding_span(expr: &Expr, target: &str) -> Option<Span> {
                 .iter()
                 .find_map(|c| find_let_binding_span(&c.body, target))
         }),
+        ExprKind::Match { scrutinee, arms } => {
+            find_let_binding_span(scrutinee, target).or_else(|| {
+                arms.iter().find_map(|arm| {
+                    arm.guard
+                        .as_deref()
+                        .and_then(|g| find_let_binding_span(g, target))
+                        .or_else(|| find_let_binding_span(&arm.body, target))
+                })
+            })
+        }
         ExprKind::Var(_) | ExprKind::Lit(_) | ExprKind::StringNew { .. } => None,
     }
 }
diff --git a/src/ephapax-parser/src/lib.rs b/src/ephapax-parser/src/lib.rs
diff --git a/src/ephapax-syntax/src/lib.rs b/src/ephapax-syntax/src/lib.rs
diff --git a/src/ephapax-typing/src/lib.rs b/src/ephapax-typing/src/lib.rs
diff --git a/src/ephapax-wasm/src/lib.rs b/src/ephapax-wasm/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -311,6 +311,29 @@ impl AffineChecker {`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`	`}`
	`314`	`+`
	`315`	+ // Core `match`: affine allows arms to disagree on
	`316`	`+ // consumption (the non-consuming arm implicitly drops),`
	`317`	`+ // so a simple walk-with-pattern-binding mirrors the`
	`318`	+ // existing arm-disagreement freedom for `if` and `case`.
	`319`	+ // TODO(ephapax#61 follow-up): N-arm `merge_affine_branches`
	`320`	`+ // for tighter cross-arm reasoning.`
	`321`	`+ ExprKind::Match { scrutinee, arms } => {`
	`322`	`+ self.walk_expr(scrutinee);`
	`323`	`+ for arm in arms {`
	`324`	`+ let bound = arm.pattern.bound_vars();`
	`325`	`+ for v in &bound {`
	`326`	`+ self.ctx.bind(v.clone(), BindingForm::Let, None);`
	`327`	`+ }`
	`328`	`+ if let Some(guard) = &arm.guard {`
	`329`	`+ self.walk_expr(guard);`
	`330`	`+ }`
	`331`	`+ self.walk_expr(&arm.body);`
	`332`	`+ for v in bound.iter().rev() {`
	`333`	`+ self.ctx.unbind(v);`
	`334`	`+ }`
	`335`	`+ }`
	`336`	`+ }`
`314`	`337`	`}`
`315`	`338`	`}`
`316`	`339`
Original file line number	Diff line number	Diff line change
`@@ -195,6 +195,16 @@ impl EscapeAnalysis {`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
	`198`	`+ ExprKind::Match { scrutinee, arms } => {`
	`199`	`+ Self::analyze_expr(scrutinee, escaping, in_escaping_context);`
	`200`	`+ for arm in arms {`
	`201`	`+ if let Some(guard) = &arm.guard {`
	`202`	`+ Self::analyze_expr(guard, escaping, in_escaping_context);`
	`203`	`+ }`
	`204`	`+ Self::analyze_expr(&arm.body, escaping, in_escaping_context);`
	`205`	`+ }`
	`206`	`+ }`
	`207`	`+`
`198`	`208`	`// Literals and string allocations never escape`
`199`	`209`	`ExprKind::Lit(_) \| ExprKind::StringNew { .. } => {}`
`200`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,20 @@ impl FreeVarAnalysis {`
`194`	`194`	`}`
`195`	`195`	`}`
`196`	`196`
	`197`	`+ ExprKind::Match { scrutinee, arms } => {`
	`198`	`+ Self::collect(scrutinee, free, bound);`
	`199`	`+ for arm in arms {`
	`200`	`+ let mut arm_bound = bound.clone();`
	`201`	`+ for v in arm.pattern.bound_vars() {`
	`202`	`+ arm_bound.insert(v);`
	`203`	`+ }`
	`204`	`+ if let Some(guard) = &arm.guard {`
	`205`	`+ Self::collect(guard, free, &mut arm_bound);`
	`206`	`+ }`
	`207`	`+ Self::collect(&arm.body, free, &mut arm_bound);`
	`208`	`+ }`
	`209`	`+ }`
	`210`	`+`
`197`	`211`	`ExprKind::Lit(_) \| ExprKind::StringNew { .. } => {}`
`198`	`212`	`}`
`199`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -477,6 +477,9 @@ impl Interpreter {`
`477`	`477`	`"effect handle not yet implemented in interpreter".into(),`
`478`	`478`	`))`
`479`	`479`	`}`
	`480`	`+ ExprKind::Match { .. } => Err(RuntimeError::Unimplemented(`
	`481`	`+ "core ExprKind::Match not yet implemented in interpreter — use the surface (parse_surface_module → desugar) path which lowers match to nested Case".into(),`
	`482`	`+ )),`
`480`	`483`	`}`
`481`	`484`	`}`
`482`	`485`