Section 0: Full Parser Support

Goal: Complete parser support for entire Ori spec grammar (parsing only — evaluator in Section 23)

SPEC: spec/grammar.ebnf (authoritative), spec/06-source-code.md, spec/07-lexical-elements.md

Status: In Progress — Verified 2026-03-29. 3 parser bugs remain (all blocked), down from 24. 4181 spec tests pass, 0 fail. Gap analysis found 3 missing grammar productions (while_expr, labeled_block, capset_decl) and systemic absence of negative parser tests. See 0.8 for full checklist.

OVERVIEW

This section ensures the parser handles every syntactic construct in the Ori specification. It has no dependencies and can be worked on at any time. Other sections may overlap with this work — that’s expected and acceptable.

Why this matters: The formatter, LSP, and other tooling depend on complete parser support. Without it, valid Ori code may fail to parse, blocking downstream work.

Approach:

Audit current parser against each grammar production
Implement missing productions
Add parser tests for each production
Mark items complete as verified

0.1 Lexical Grammar (verified 2026-03-29)

SPEC: grammar.ebnf § LEXICAL GRAMMAR, spec/07-lexical-elements.md

INCOMPLETE MATRIX: Zero #compile_fail negative parser tests in tests/spec/lexical/. Every test suite must include negative tests per tests.md.

0.1.1 Comments

Audit: Line comments // ... — grammar.ebnf § comment [done] (2026-02-10)
- Rust Tests: oric/tests/phases/parse/lexer.rs — 14 comment tests (classification, spans, detached warnings)
- Ori Tests: tests/spec/lexical/comments.ori — 21 tests (verified 2026-03-29)
Audit: Doc comments with markers — grammar.ebnf § doc_comment [done] (2026-02-10)
- // (description), // * (param), // ! (warning), // > (example)
- Rust Tests: oric/tests/phases/parse/lexer.rs — doc comment type tests
- Ori Tests: tests/spec/lexical/comments.ori — all marker types tested

0.1.2 Identifiers

Audit: Standard identifiers letter { letter | digit | "_" } — grammar.ebnf § identifier [done] (2026-02-10)
- Rust Tests: oric/tests/phases/parse/lexer.rs — identifier tokenization
- Ori Tests: tests/spec/lexical/identifiers.ori — 26 tests (verified 2026-03-29)

0.1.3 Keywords

0.1.4 Operators

0.1.5 Delimiters

Audit: All delimiters — grammar.ebnf § delimiter [done] (2026-02-10)
- (, ), [, ], {, }, ,, :, ., @, $
- Rust Tests: implicit through parsing
- Ori Tests: tests/spec/lexical/delimiters.ori — 57 tests (verified 2026-03-29)

0.1.6 Integer Literals

Audit: Decimal integers — grammar.ebnf § decimal_lit [done] (2026-02-10)
- Basic: 42, with underscores: 1_000_000
- Rust Tests: oric/tests/phases/parse/lexer.rs — decimal/hex/binary underscore tests
- Ori Tests: tests/spec/lexical/int_literals.ori — 42 tests (verified 2026-03-29)
Audit: Hexadecimal integers — grammar.ebnf § hex_lit [done] (2026-02-10)
- Basic: 0xFF, with underscores: 0x1A_2B_3C
- Rust Tests: oric/tests/phases/parse/lexer.rs — hex underscore tests
- Ori Tests: tests/spec/lexical/int_literals.ori — hex literals with case/underscore variants

0.1.7 Float Literals

Audit: Basic floats — grammar.ebnf § float_literal [done] (2026-02-10)
- Simple: 3.14, with exponent: 2.5e-8, 1.0E+10
- Rust Tests: oric/tests/phases/parse/lexer.rs — float/scientific notation tests
- Ori Tests: tests/spec/lexical/float_literals.ori — 45 tests (verified 2026-03-29)

0.1.8 String Literals

Audit: Basic strings — grammar.ebnf § string_literal [done] (2026-02-10)
- Simple: "hello", empty: ""
- Rust Tests: oric/tests/phases/parse/lexer.rs — string escape tests
- Ori Tests: tests/spec/lexical/string_literals.ori — 52 tests (verified 2026-03-29)
Audit: Escape sequences — grammar.ebnf § escape [done] (2026-02-10)
- \\, \", \n, \t, \r, \0
- Rust Tests: oric/tests/phases/parse/lexer.rs — escape parsing
- Ori Tests: tests/spec/lexical/string_literals.ori — escapes tested in same file

0.1.9 Template Literals

0.1.10 Character Literals

Audit: Character literals — grammar.ebnf § char_literal [done] (2026-02-10)
- Simple: 'a', escapes: '\n', '\t', '\'', '\\'
- Rust Tests: oric/tests/phases/parse/lexer.rs — char literal parsing
- Ori Tests: tests/spec/lexical/char_literals.ori — 59 tests (verified 2026-03-29)

0.1.11 Boolean Literals

Audit: Boolean literals — grammar.ebnf § bool_literal [done] (2026-02-10)
- true, false
- Rust Tests: implicit through keyword recognition
- Ori Tests: tests/spec/lexical/bool_literals.ori — 51 tests (verified 2026-03-29)

0.1.12 Duration Literals

Audit: Duration literals — grammar.ebnf § duration_literal [done] (2026-02-10)
- All units: 100ns, 50us, 10ms, 5s, 2m, 1h
- Decimal syntax: 0.5s, 1.5m (compile-time sugar) — tested
- Rust Tests: oric/tests/phases/parse/lexer.rs — 10+ duration tests (units, decimal, many digits)
- Ori Tests: tests/spec/lexical/duration_literals.ori — 60 tests (verified 2026-03-29)

0.1.13 Size Literals

Audit: Size literals — grammar.ebnf § size_literal [done] (2026-02-10)
- All units: 100b, 10kb, 5mb, 1gb, 500tb
- Decimal syntax: 1.5kb, 2.5mb (compile-time sugar) — tested
- Rust Tests: oric/tests/phases/parse/lexer.rs — 5+ size tests (units, decimal)
- Ori Tests: tests/spec/lexical/size_literals.ori — 58 tests (verified 2026-03-29)

0.2 Source Structure (verified 2026-03-29)

SPEC: grammar.ebnf § SOURCE STRUCTURE, spec/06-source-code.md, spec/18-modules.md

0.2.1 Source File

Audit: Source file structure — grammar.ebnf § source_file [done] (2026-02-10)
- [ file_attribute ] { import } { declaration } — imports + types + functions + tests all parse
- Rust Tests: implicit through full-file parsing
- Ori Tests: tests/spec/source/file_structure.ori — 4 tests (verified 2026-03-29)
Audit: File-level attributes — grammar.ebnf § file_attribute [done] (2026-02-13)
- #!target(os: "linux"), #!cfg(debug) — parses correctly, stored in Module.file_attr
- Rust Tests: oric/tests/phases/parse/file_attr.rs — 16 tests, ori_parse::grammar::attr — 5 tests
- Ori Tests: tests/spec/source/file_attr_target.ori, file_attr_cfg.ori, file_attributes.ori

0.2.2 Imports

0.2.3 Re-exports

Audit: Re-export statements — grammar.ebnf § reexport [done] (2026-02-10)
- pub use path { items } — parses correctly (verified via ori parse)
- Ori Tests: tests/spec/modules/reexporter.ori — 1 test

0.2.4 Extensions

0.2.5 FFI

0.3 Declarations (verified 2026-03-29)

SPEC: grammar.ebnf § DECLARATIONS, spec/10-declarations.md

0.3.1 Attributes

0.3.2 Functions

0.3.3 Const Bound Expressions

Audit: Const bound expressions — grammar.ebnf § const_bound_expr [done] (2026-02-13)
- Comparison: N > 0, N == M, N >= 1 — parses correctly
- Logical: N > 0 && N < 100, A || B, !C — parses correctly
- Grouped: (N > 0 && N < 10) || N == 100 — parses correctly
- Rust Tests: ori_parse/src/grammar/item/generics.rs — 5 where clause tests

0.3.4 Type Definitions

0.3.5 Traits

0.3.6 Implementations

0.3.7 Tests

Audit: Test declarations — grammar.ebnf § test [done] (2026-02-14)
- Attached: @t tests @target () -> void = ... — parses correctly (used in 3068 tests)
- Floating: @t tests _ () -> void = ... — parses correctly [done] (2026-02-14)
- Multi-target: @t tests @a tests @b () -> void = ... — parses correctly [done] (2026-02-14)
- Ori Tests: tests/spec/free_floating_test.ori — 3 tests (2 floating with tests _, 1 legacy test_ prefix)
- Rust Tests: ori_parse::grammar::item::function::tests — 5 tests

0.3.8 Constants

Audit: Module-level constants — grammar.ebnf § constant_decl (partial) [done] (2026-02-10)
- let $PI = 3.14159 — parses correctly (verified via ori parse)
- Computed: let $X = 2 + 3 — parses correctly
- Typed: let $MAX_SIZE: int = 1000 — parses correctly [done] (2026-02-14)
- Ori Tests: tests/spec/declarations/constants.ori — exists but all commented out

0.3.9 Capset Declarations

NEEDS TESTS — grammar.ebnf defines capset_decl but no section item or spec tests exist.

Audit: Capset declarations — grammar.ebnf § capset_decl
- Basic: capset Net = Http, Dns, Tls — needs verification and spec tests
- NEEDS TESTS: tests/spec/declarations/capsets.ori — basic capset declaration and usage
/tpr-review passed — independent review found no critical or major issues (or all findings triaged)
/impl-hygiene-review passed — hygiene review clean. MUST run AFTER /tpr-review is clean.
Subsection close-out (0.3) — MANDATORY before starting the next subsection. Run /improve-tooling retrospectively on THIS subsection’s debugging journey (per .claude/skills/improve-tooling/SKILL.md “Per-Subsection Workflow”): which diagnostics/ scripts you ran, where you added dbg!/tracing calls, where output was hard to interpret, where test failures gave unhelpful messages, where you ran the same command sequence repeatedly. Forward-look: what tool/log/diagnostic would shorten the next regression in this code path by 10 minutes? Implement improvements NOW (zero deferral) and commit each via SEPARATE /commit-push using a valid conventional-commit type (build(diagnostics): ... — surfaced by section-0.3 retrospective — build/test/chore/ci/docs are valid; tools(...) is rejected by the lefthook commit-msg hook). Mandatory even when nothing felt painful. If genuinely no gaps, document briefly: “Retrospective 0.3: no tooling gaps”. Update this subsection’s status in section frontmatter to complete.
/sync-claude section-close doc sync — verify Claude artifacts across all section commits. Map changed crates to rules files, check CLAUDE.md, canon.md. Fix drift NOW.
Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files.

0.4 Types

SPEC: grammar.ebnf § TYPES, spec/08-types.md

0.4.1 Type Paths

Audit: Simple type paths — grammar.ebnf § type_path [done] (2026-02-10)
- int, Point, std.math.Complex — parses correctly
- Rust Tests: ori_ir/tests/ — 16 parsed_type tests (primitive, named, generic, nested, associated, function, list, map, tuple, unit)
Audit: Generic type arguments — grammar.ebnf § type_args [done] (2026-02-10)
- Option<int>, Result<T, E>, Map<str, int> — parses correctly
- With const: [int, max 10] — parses correctly [done] (2026-02-13)
- Array<int, $N> — parses correctly [done] (2026-02-13)

0.4.2 Existential Types

Audit: impl Trait — grammar.ebnf § impl_trait_type
- Basic: impl Iterator — BROKEN: parser rejects impl in type position
- Multi-trait: impl Iterator + Clone — blocked by above
- With where: impl Iterator where Item == int — blocked by above

0.4.3 Compound Types

0.4.4 Const Expressions in Types

Audit: Const expressions — grammar.ebnf § const_expr [done] (2026-02-13)
- Literal: 10 in type argument position (e.g., Array<int, 10>) — parses correctly
- Parameter: $N in type argument position — parses correctly
- Arithmetic: $N + 1, $N * 2 in type argument position — parses correctly
- Rust Tests: ori_parse/src/grammar/ty.rs — 4 const expression type arg tests

0.4.5 Trait Objects (verified 2026-03-29)

SPEC: spec/08-types.md § Trait Objects

0.5 Expressions (verified 2026-03-29)

SPEC: grammar.ebnf § EXPRESSIONS, spec/14-expressions.md

INCOMPLETE MATRIX: Zero #compile_fail negative parser tests in tests/spec/expressions/. Missing dedicated while and labeled block tests.

0.5.1 Primary Expressions

Note: Pattern expressions (run, try, match, parallel, nursery, channel, etc.) are valid primary expressions per grammar.ebnf § primary → pattern_expr. See section 0.6 for pattern-specific audit items.

0.5.2 Unsafe Expression

Audit: Unsafe expressions — grammar.ebnf § unsafe_expr [done] (2026-02-10)
- unsafe(expr) — parsed correctly (verified 2026-02-10; parenthesized form removed by unsafe-semantics-proposal 2026-02-20)
- unsafe { expr } — block-only form (implemented 2026-02-21)

0.5.3 List Literals

Audit: List literals — grammar.ebnf § list_literal [done] (2026-02-10)
- Empty: [], simple: [1, 2, 3] — parse correctly
- With spread: [...a, 4, ...b] — parses correctly (verified via ori parse)

0.5.4 Map Literals

Audit: Map literals — grammar.ebnf § map_literal [done] (2026-02-10)
- Empty: {}, simple: {"a": 1, "b": 2} — parse correctly
- String keys: {"key": value} — parses correctly
- Computed keys: {[expr]: value} — parses correctly (verified via ori parse)
- With spread: {...base, extra: 1} — parses correctly (verified via ori parse)

0.5.5 Struct Literals

Audit: Struct literals — grammar.ebnf § struct_literal [done] (2026-02-10)
- Basic: Point { x: 1, y: 2 } — parses correctly
- Shorthand: Point { x, y } — parses correctly (verified via ori parse)
- With spread: Point { ...base, x: 10 } — parses correctly (verified via ori parse)
- Ori Tests: tests/spec/declarations/struct_types.ori — 39 active tests

0.5.6 Postfix Expressions

0.5.7 Unary Expressions

Audit: Unary operators — grammar.ebnf § unary_expr [done] (2026-02-10)
- Logical not: !condition — parses correctly
- Negation: -number — parses correctly
- Bitwise not: ~bits — parses correctly
- Ori Tests: tests/spec/lexical/operators.ori — 72 tests including unary

0.5.8 Binary Expressions

0.5.9 While Expression

NEEDS TESTS — grammar.ebnf defines while_expr but no section item or dedicated spec tests exist.

Audit: While expressions — grammar.ebnf § while_expr
- Basic: while condition do body — needs verification and spec tests
- Labeled: while:name condition do body — needs verification and spec tests
- NEEDS TESTS: tests/spec/expressions/while.ori — basic, labeled, break, continue, nested

0.5.10 Labeled Blocks

NEEDS TESTS — grammar.ebnf defines labeled_block but no section item or spec tests exist.

Audit: Labeled blocks — grammar.ebnf § labeled_block
- Basic: block:name { body } — needs verification and spec tests
- With break: block:name { ... break:name value } — needs verification and spec tests
- NEEDS TESTS: tests/spec/expressions/labeled_blocks.ori — basic, break with value, nested

0.5.11 Pipe Expression

Parsing works in practice (used in 16+ spec test files). Not documented in section.

Audit: Pipe expressions — grammar.ebnf § pipe_expr (verified 2026-03-29)
- x |> f(a: v) — parses correctly (used in traits/debug/, traits/core/, etc.)
- x |> .method() — parses correctly
- x |> (a -> expr) — parses correctly

0.5.12 Compound Assignment

Tests exist and pass (compound_assignment.ori, 412 lines). Not documented in section.

Audit: Compound assignment — grammar.ebnf § compound_assignment (verified 2026-03-29)
- x += y, x -= y, x *= y, etc. — parse correctly
- Ori Tests: tests/spec/expressions/compound_assignment.ori — 412 lines, comprehensive

0.5.13 Argument Punning

Tests exist and pass. Not documented in section.

Audit: Argument punning — grammar.ebnf § argument_punning (verified 2026-03-29)
- f(x:) = f(x: x) — parses correctly
- Ori Tests: tests/spec/expressions/argument_punning.ori — tests present

0.5.14 With Expression (verified 2026-03-29)

Audit: Capability provision — grammar.ebnf § with_expr [done] (2026-02-10)
- with x = value in expr — parses correctly (verified via ori parse)
- Capability form: with Http = MockHttp in expr — parses correctly [done] (2026-02-13)

0.5.15 Let Binding

Audit: Let expressions — grammar.ebnf § let_expr [done] (2026-02-10)
- Mutable: let x = 42 — parses correctly
- Immutable: let $x = 42 — parses correctly
- Typed: let x: int = 42 — parses correctly
- Ori Tests: extensive coverage across all test files (3068 tests use let bindings)
Audit: Assignment — grammar.ebnf § assignment [done] (2026-02-10)
- x = new_value — parses correctly

0.5.16 Conditional

Audit: If expressions — grammar.ebnf § if_expr [done] (2026-02-10)
- Simple: if cond then a else b — parses correctly
- Void: if cond then action — parses correctly
- Chained: if c1 then a else if c2 then b else c — parses correctly (verified via ori parse)
- Ori Tests: extensive coverage across test files

0.5.17 For Expression

Audit: For loops — grammar.ebnf § for_expr [done] (2026-02-10)
- Do: for x in items do action — parses correctly
- Yield: for x in items yield x * 2 — parses correctly (verified via ori parse)
- Filter: for x in items if x > 0 yield x — parses correctly (verified via ori parse)
- Labeled: for:outer x in items do ... — parses correctly [done] (2026-02-14)

0.5.18 Loop Expression

Audit: Loop expressions — grammar.ebnf § loop_expr [done] (2026-02-14)
- Basic: loop { body } — parses correctly (verified via ori parse)
- Labeled: loop:name { body } — parses correctly [done] (2026-02-14)

0.5.19 Labels

Audit: Loop labels — grammar.ebnf § label [done] (2026-02-14)
- :name (no space around colon) — parses correctly (verified via labeled for/loop/break/continue)

0.5.20 Lambda

Audit: Simple lambdas — grammar.ebnf § simple_lambda [done] (2026-02-10)
- Single param: x -> x + 1 — parses correctly
- Multiple: (a, b) -> a + b — parses correctly
- No params: () -> 42 — parses correctly
- Ori Tests: extensive coverage (lambdas used throughout test suite)
Audit: Typed lambdas — grammar.ebnf § typed_lambda [done] (2026-02-10)
- (x: int) -> int = x * 2 — parses correctly (verified via ori parse)

0.5.21 Control Flow

0.6 Patterns (verified 2026-03-29)

SPEC: grammar.ebnf § PATTERNS, spec/15-patterns.md

0.6.1 Sequential Patterns

0.6.2 Function Expression Patterns

0.6.3 Type Conversion Patterns

Audit: Type conversion calls — grammar.ebnf § function_val [done] (2026-02-10)
- int(x), float(x), str(x), byte(x) — all parse correctly (verified via ori parse)
- Ori Tests: tests/spec/expressions/type_conversion.ori — if exists; verified parsing via temp files

0.6.4 Channel Constructors

Audit: Channel creation — grammar.ebnf § channel_expr [done] (2026-02-14)
- channel<int>(buffer: 10) — FIXED [done] (2026-02-14): Added FunctionExpKind::Channel variants + parse_channel_expr with generic type args
- channel_in<T>(buffer: 5), channel_out<T>(buffer: 5) — FIXED [done] (2026-02-14)
- channel_all<T>(buffer: 5) — FIXED [done] (2026-02-14)
- channel(buffer: 10) — still works (no generics)

0.6.5 Match Patterns

0.6.6 Binding Patterns

0.7 Constant Expressions (verified 2026-03-29)

SPEC: grammar.ebnf § CONSTANT EXPRESSIONS, spec/12-constants.md, spec/24-constant-expressions.md

0.8 Section Completion Checklist (verified 2026-03-29)

STATUS: In Progress — Re-verified 2026-03-29. 8/10 checklist items complete, 2 blocked. Remaining: 0.4 audit (blocked-by:19, only impl Trait), 0.6 audit (blocked-by:23, only runtime enforcement). All unblocked parser work is complete. 4181 Ori tests pass (confirmed), 42 skipped.

INCOMPLETE MATRIX: Grammar gap analysis found 3 major missing productions (while_expr, labeled_block, capset_decl) and systemic absence of negative parser tests.

Exit Criteria: Every grammar production in grammar.ebnf has verified parser support with tests.

Remaining Parser Bugs (verified 2026-02-13):

Const functions ($name (params)) — rejected
~~Computed constants (let $D = $A + 1)~~ — FIXED [done] (2026-02-14)
impl Trait in type position — rejected
Associated type constraints (where I.Item == int) — == rejected
~~Floating tests (tests _)~~ — FIXED [done] (2026-02-14)
~~Typed constants (let $X: int)~~ — FIXED [done] (2026-02-14)
~~Channel generic syntax (channel<int>)~~ — FIXED [done] (2026-02-14)
~~Struct rest pattern ({ x, .. })~~ — FIXED [done] (2026-02-14)
~~.match() method syntax~~ — FIXED [done] (2026-02-14) — desugars expr.match { arms } to match expr { arms } at parser level
~~with() RAII pattern (acquire:/action:/release:)~~ — FIXED [done] (2026-02-14) — was doc error: spec uses action: not use: (use is reserved keyword)
~~Function-level contracts (pre()/post())~~ — FIXED [done] (2026-02-14)
~~Immutable binding in function body (let $x = 42)~~ — FIXED [done] (2026-02-14)
~~Labeled continue (continue:outer)~~ — FIXED [done] (2026-02-14)
~~Char patterns in match ('a', 'a'..='z')~~ — FIXED [done] (2026-02-14)

Fixed since 2026-02-10 (23 items): File attributes, extern as alias, C variadics, pattern params, guard clauses, default params, variadic params, #repr/#target/#cfg attributes, fixed-capacity lists, length placeholder, try ? inside try { }, const generic type args (Array<int, $N>), const expressions in types, const bounds in where clauses (where N > 0), labeled continue (continue:outer), function-level contracts (pre()/post()), computed constants (let $D = $A + 1), struct rest pattern ({ x, .. }), immutable bindings in function bodies (let $x, let ($a, $b), let { $x }, let [$h, ..]), with() RAII pattern (acquire:/action:/release: — was doc error, spec uses action: not use:), .match() method syntax (expr.match { arms } desugars to match expr { arms })

/tpr-review passed — independent review found no critical or major issues (or all findings triaged)
/impl-hygiene-review passed — hygiene review clean. MUST run AFTER /tpr-review is clean.
Subsection close-out (0.8) — MANDATORY before starting the next subsection. Run /improve-tooling retrospectively on THIS subsection’s debugging journey (per .claude/skills/improve-tooling/SKILL.md “Per-Subsection Workflow”): which diagnostics/ scripts you ran, where you added dbg!/tracing calls, where output was hard to interpret, where test failures gave unhelpful messages, where you ran the same command sequence repeatedly. Forward-look: what tool/log/diagnostic would shorten the next regression in this code path by 10 minutes? Implement improvements NOW (zero deferral) and commit each via SEPARATE /commit-push using a valid conventional-commit type (build(diagnostics): ... — surfaced by section-0.8 retrospective — build/test/chore/ci/docs are valid; tools(...) is rejected by the lefthook commit-msg hook). Mandatory even when nothing felt painful. If genuinely no gaps, document briefly: “Retrospective 0.8: no tooling gaps”. Update this subsection’s status in section frontmatter to complete.
/sync-claude section-close doc sync — verify Claude artifacts across all section commits. Map changed crates to rules files, check CLAUDE.md, canon.md. Fix drift NOW.
Repo hygiene check — run diagnostics/repo-hygiene.sh --check and clean any detected temp files.

0.9 Parser Bugs (from Comprehensive Tests) (verified 2026-03-29)

STATUS: Re-verified 2026-03-29. Many items previously marked “STILL BROKEN” now parse correctly. 19+ fixed, 3 remaining blocked.

POLICY: Skipping tests is NOT acceptable. Every test must pass. If a feature is tested, it must work. Fix the code, not the tests.

This section documents parser-only bugs discovered by the comprehensive test suite. Evaluator/type checker bugs are tracked in Section 23: Full Evaluator Support.

0.9.1 Parser/Syntax Bugs — STILL BROKEN (verified 2026-02-13)

These features fail at the parse phase — the parser does not recognize the syntax.

0.9.2 Previously Fixed Bugs — VERIFIED WORKING

These features were previously reported as broken but now parse correctly.

NOTE: Type checker and evaluator bugs have been moved to Section 23: Full Evaluator Support.

Completion Summary

Full Audit Completed: 2026-02-10

Systematic ori parse verification of every grammar production against actual parser behavior.

Previously Fixed (verified working):

div operator in match_multiplicative_op()
Spread in function calls (sum(...list))
Context-sensitive keywords (timeout, parallel, cache as identifiers)
List spread ([...a, ...b]), map spread ({...base, key: val})
Tuple destructure in for (for (k, v) in m)
Multiple derives (#derive(Eq, Clone, Debug))
as/as? type conversion operators
Wildcard in for loops (for _ in range)

Verified Parser Bugs — 24 items originally, 19+ fixed, 3 remain (blocked): (verified 2026-03-29)

Guard clauses (if before =) — ~~parser rejects~~ FIXED [done]
List/pattern params (@fib (0: int)) — ~~parser rejects~~ FIXED [done]
Const generics ($ in generics) — ~~parser rejects~~ FIXED [done] (2026-02-13)
Variadic params (...int) — ~~parser rejects~~ FIXED [done]
#repr/#target/#cfg attributes — unknown attribute error
Associated type constraints (where I.Item == int) — == rejected
Const functions ($name (params)) — parser error
~~Computed constants (let $D = $A + 1)~~ — FIXED [done] (2026-02-14)
Fixed-capacity lists ([T, max N]) — comma rejected in type
impl Trait in type position — parser rejects
~~Channel generics (channel<int>)~~ — FIXED [done] (2026-02-14)
Struct rest pattern ({ x, .. }) — .. rejected
.match() method syntax — keyword conflict
with() RAII pattern (acquire:/use:/release:) — named arg rejection
File attributes (#!target(...)) — ! rejected
Extern as alias — rejected
C variadics (... in params) — rejected
~~Floating tests (tests _)~~ — FIXED [done] (2026-02-14)
~~Typed constants (let $X: int = 1000)~~ — FIXED [done] (2026-02-14)
Try ? inside try() — rejected
~~Function-level contracts (pre()/post())~~ — FIXED [done] (2026-02-14)
Length placeholder (#) — attribute marker conflict
~~Immutable binding in function body (let $x = 42)~~ — FIXED [done] (2026-02-14)
~~.match() guard method syntax~~ — RESOLVED: guards now use if syntax (match-arm-comma-separator-proposal)

Known Limitations (Parser works, but semantics incomplete — tracked in Section 23):

?? operator: Parses but evaluator support incomplete
Primitive trait methods: Parse but evaluator doesn’t resolve
Map indexing semantics: Parses but returns wrong type

Notes

This section intentionally overlaps with other roadmap sections
Other sections add semantics; this section ensures syntax parses
Work can proceed in any order within this section
Parser tests should verify both success and error cases
Error messages should include spans for IDE integration

Grammar Inconsistencies Identified

The following grammar inconsistencies were identified during the audit and require resolution:

1. Extension Generics (grammar.ebnf § extension_def) — RESOLVED

Resolution: Updated grammar.ebnf to support generics and any type in extensions:

extension_def = "extend" [ generics ] type [ where_clause ] "{" { method } "}" .

This allows:

extend<T: Clone> [T] { ... }           // Angle bracket generics
extend [T] where T: Clone { ... }       // List type with where clause
extend Iterator where Self.Item: Add { ... }

2. Bounded Trait Objects (grammar.ebnf § type) — RESOLVED

Resolution: Added trait_object_bounds production to grammar.ebnf:

type = type_path [ type_args ]
     | trait_object_bounds            /* Printable + Hashable */
     | list_type | fixed_list_type | map_type | tuple_type | function_type
     | impl_trait_type .

trait_object_bounds = type_path "+" type_path { "+" type_path } .

Resolution Status: All grammar inconsistencies resolved.

0.10 Block Expression Syntax (PRIORITY) (verified 2026-03-29)

Proposal: proposals/approved/block-expression-syntax.md Migration script: scripts/migrate_block_syntax.py

This section blocks all other roadmap work. Every feature built on run()/match()/try() syntax creates migration debt. Complete this before continuing.

Overview

Replace parenthesized function_seq syntax with curly-brace block expressions. Remove run() entirely. Move contracts to function-level pre()/post() declarations.

Old	New
`run(a, b, c)`	`{ a \n b \n c }`
`match(expr, P -> e)`	`match expr { P -> e }`
`try(a, b)`	`try { a \n b }`
`loop(run(a, b))`	`loop { a \n b }`
`unsafe(run(a, b))`	`unsafe { a \n b }`
`run(pre_check: c, body, post_check: r -> c)`	`pre(c) post(r -> c)` on function decl

Implementation

Phase 1: Parser — Block Expressions

Implement: Newline-as-separator tokenization inside { } blocks — N/A: semicolons-only design decision (2026-02-20)
Implement: Block expression parsing ({ block_body }) — semicolons as separators (2026-02-20)
- Rust Tests: ori_parse/src/tests/parser.rs — test_parse_block_expr
- Ori Tests: tests/spec/expressions/block_scope.ori
Implement: Optional semicolon after }-ending expression statements — for...do { }, while...do { }, loop { }, if...then...else { }, match { } no longer require trailing ; when used as statements. Approved proposal: optional-semicolon-after-block-expressions-proposal.md. Grammar updated (grammar.ebnf block_ending_expression production). Parser change in blocks.rs: after parsing an expression, if last token is }, consume ; if present but don’t require it.
- Rust Tests: ori_parse/src/tests/parser.rs — test_optional_semicolon_after_block_expression
- Ori Tests: tests/spec/expressions/ — block expressions without trailing ;
Implement: Block vs map vs struct disambiguation (2-token lookahead) (2026-02-20)
- Rust Tests: ori_parse/src/tests/parser.rs — block/map disambiguation
- Ori Tests: tests/spec/expressions/block_scope.ori
Implement: Balanced delimiter continuation rules — N/A: only needed for newline separators (2026-02-20)

Phase 2: Parser — Construct Migration

Phase 3: Parser — Function-Level Contracts

Phase 4: Migration

Run: scripts/migrate_block_syntax.py on all documentation (.md files) (2026-02-20)
Manual: Migrate pre_check:/post_check: references to function-level pre()/post() (2026-02-21) — README examples, parser context comment, design doc
Run: scripts/migrate_block_syntax.py on all .ori test files (2026-02-20)
Update: grammar.ebnf with new block/match/try rules (2026-02-20)
Update: .claude/rules/ori-syntax.md with new syntax (2026-02-20)
Update: Spec files with new syntax (2026-02-20)
Verify: ./test-all.sh passes with new syntax (10,219 tests passing) (2026-02-20)

Phase 5: Formatter

Implement: Blank-line-before-result enforcement (2026-02-21)
- Block and try-block: emit blank line before result when 2+ statements precede it
- Spec rule: 16-formatting.md:74-85
Implement: Match trailing comma on every arm (2026-02-21)
- Always emit comma after every arm including last (spec: 16-formatting.md:786)
Update: Golden tests updated to match new formatting (19 files) (2026-02-21)
Implement: Contract formatting (pre/post between signature and =)
- IR unblocked: Function now has pre_contracts/post_contracts fields (2026-02-21)
- Still blocked: formatter needs contract emit logic (depends on 15D contract enforcement design)
Fix: Formatter double-emits $ for immutable local bindings (2026-02-21)
- emit_stmt() emits let $ AND emit_binding_pattern() emits $ → produces let $$x
- Root cause: $ prefix emitted in two independent locations (stacked.rs:211, patterns.rs:135-137)
- Parser is correct (strips $, sets Immutable); formatter had the bug
- Fix: Removed $ from emit_stmt in all 3 renderers (stacked, inline, broken); emit_binding_pattern is sole owner

Phase 6: Dead Code Cleanup — `FunctionSeq::Run` Removal

Completed as part of Block Unification plan (plans/block_unify/), commit 01c43e21. Removed FunctionSeq::Run, SeqBinding, CheckExpr, CheckRange and all downstream consumers across 37 files in 9 crates. FunctionSeq reduced from 4 → 3 variants (Try, Match, ForPattern).

Verification Log (2026-03-29)

Verified by: Claude Opus 4.6 (1M context) verification agent Test execution: 4181 spec tests pass, 0 fail, 42 skipped. 277 lexer unit tests pass. 267 oric parse tests pass.

Hygiene audit:

File sizes: All parser source files under 500-line limit. Largest: collections.rs (449), postfix.rs (442).
TODOs/FIXMEs: Zero in ori_parse/src/ and ori_lexer/src/.
Plan annotations: Zero stale plan annotations in parser source.
Phase bleeding: No type checking or evaluation logic in parser code.
Dead code: No commented-out code in parser source.
Sibling test pattern: Proper sibling test files (ty/tests.rs, function/tests.rs, generics/tests.rs, attr/tests.rs, impl_def/tests.rs, config/tests.rs).
Commented-out test files: 4 files (constants.ori, generics.ori, clause_params.ori, where_clause.ori) — all correctly documented as evaluator/typeck blockers.

Findings summary:

4 major findings: 3 missing grammar productions (while_expr, labeled_block, capset_decl), systemic absence of negative parser tests
4 minor findings: pipe_expr/compound_assignment/argument_punning not documented (tests exist and pass), test count claims corrected
5 tracked/known: impl Trait (blocked-by:19), const functions (blocked-by:18), associated type constraints (blocked-by:3), contract formatting (blocked-by:15D), TPR review outstanding