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 — Re-verified 2026-02-14. ~3 parser bugs remain (down from ~24). 23 items previously broken now parse correctly. Remaining gaps: const functions, .match() method syntax. See § 0.8 for full bug list.

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

SPEC: grammar.ebnf § LEXICAL GRAMMAR, spec/07-lexical-elements.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 — 30+ tests
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 — 40+ tests (letters, digits, underscores, case sensitivity)

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 — 70+ tests (all delimiter types in context)

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 — 50+ tests (decimal, hex, binary, underscores, negative, boundary)
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 — 50+ tests (basic, exponents, underscores, precision)

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 — 60+ tests
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 — 60+ tests (letters, digits, punctuation, escapes)

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 — 60+ tests (truth tables, De Morgan’s, short-circuit)

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 — 70+ tests (all units, decimal, cross-unit equivalences)

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 — 70+ tests (all units, decimal, SI units verified: 1kb == 1000b)

0.2 Source Structure

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 — 6 tests
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

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.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

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

Audit: Simple trait objects — spec/08-types.md § Trait Objects [done] (2026-02-10)
- Trait name as type: @display (item: Printable) -> void — parses correctly (verified via ori parse)
- In collections: [Printable], {str: Printable} — parses correctly [done] (2026-02-13)
- Ori Tests: tests/spec/types/trait_objects.ori — tests exist
Audit: Bounded trait objects — spec/08-types.md § Bounded Trait Objects [done] (2026-02-14)
- Multiple bounds: Printable + Hashable — parses correctly as TraitBounds variant [done] (2026-02-14)
- As parameter type: @store (item: Printable + Hashable) -> void — parses correctly [done] (2026-02-14)
- Grammar: trait_object_bounds already in grammar.ebnf; parser now implements it [done] (2026-02-14)

0.5 Expressions

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

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 — 80+ tests including unary

0.5.8 Binary Expressions

0.5.9 With Expression

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.10 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.11 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.12 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.13 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.14 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.15 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.16 Control Flow

Audit: Break expression — grammar.ebnf § break_expr [done] (2026-02-14)
- Simple: break — parses correctly
- With value: break result — parses correctly (verified via loop test)
- Labeled: break:outer, break:outer result — parses correctly [done] (2026-02-14)
Audit: Continue expression — grammar.ebnf § continue_expr [done] (2026-02-14)
- Simple: continue — parses correctly (verified via ori parse)
- With value: continue replacement — parses correctly [done] (2026-02-13)
- Labeled: continue:outer — parses correctly [done] (2026-02-14)

0.6 Patterns

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

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

0.8 Section Completion Checklist

STATUS: In Progress — Re-verified 2026-02-14. 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. 3176 Ori tests pass, 1443 Rust tests pass.

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 })

0.9 Parser Bugs (from Comprehensive Tests)

STATUS: Re-verified 2026-02-13. Many items previously marked “STILL BROKEN” now parse correctly.

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, ~5 remain:

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)

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: 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).

Remove: FunctionSeq::Run variant from ori_ir/src/ast/patterns/seq/mod.rs (2026-02-20)
Remove: Formatter dead paths (2026-02-20):
- ori_fmt/src/formatter/stacked.rs — emit_function_seq() Run arm + emit_run_with_checks()
- ori_fmt/src/rules/run_rule.rs — entire module (RunRule, RunContext, is_run())
- ori_fmt/src/width/mod.rs — FunctionSeq::Run arm in width calculation
Remove: Type checker dead paths: ori_types/src/infer/expr/sequences.rs, ori_types/src/infer/expr/mod.rs (2026-02-20)
Remove: Canon lowering dead paths: ori_canon/src/lower/sequences.rs (2026-02-20)
Remove: Incremental copier dead paths: ori_parse/src/incremental/copier.rs (2026-02-20)
Remove: Visitor dead paths: ori_ir/src/visitor.rs (2026-02-20)
Remove: Test references: ori_fmt/src/width/tests.rs, ori_ir/src/ast/patterns/seq/tests.rs, ori_types/src/infer/expr/tests.rs (2026-02-20)
Verify: ./test-all.sh passes after removal (10,215+ tests passing) (2026-02-20)