Section 15D: Bindings & Types

Goal: Implement binding syntax changes and type system simplifications

Source: docs/ori_lang/proposals/approved/

15D.1 Function-Level Contracts: `pre()` / `post()`

Proposal: proposals/approved/checks-proposal.md (semantics), proposals/approved/block-expression-syntax.md (syntax)

Function-level pre() and post() contract declarations for defensive programming. Contracts go between the return type and =:

@divide (a: int, b: int) -> int
    pre(b != 0)
    post(r -> r * b <= a)
= a div b

// Multiple conditions
@transfer (from: Account, to: Account, amount: int) -> (Account, Account)
    pre(amount > 0 | "amount must be positive")
    pre(from.balance >= amount | "insufficient funds")
    post((f, t) -> f.balance == from.balance - amount)
    post((f, t) -> t.balance == to.balance + amount)
= {
    // ... body ...
}

Key Design Decisions

Function-level placement: Contracts go on the declaration between return type and =
Multiple declarations: Use multiple pre() / post() declarations (not list syntax)
| for messages: Custom messages use condition | "message" syntax
Scope constraints: pre() can only access function parameters and module-level bindings; post() can access the result via lambda parameter
Void return: Compile error if post() used on a function returning void
Check modes deferred: check_mode: (enforce/observe/ignore) deferred to future proposal

Implementation

15D.2 `as` Conversion Syntax

Proposal: proposals/approved/as-conversion-proposal.md

Replace int(), float(), str(), byte() with as/as? keyword syntax backed by As<T> and TryAs<T> traits.

LLVM/AOT GAP (verified 2026-03-29): as/as? works in the interpreter but is broken in AOT compilation. lower_cast() in ori_arc/src/lower/collections/mod.rs emits Apply(dst, __cast, [val]) but __cast is NOT a registered protocol builtin and is NOT handled by the LLVM ARC emitter. AOT compilation will fail at link time or crash at runtime.

TEST COVERAGE GAP (verified 2026-03-29): tests/spec/expressions/type_conversion.ori contains comprehensive test cases for as/as? but ALL tests are commented out. Zero active tests for this feature.

// Before (special-cased positional args)
let x = int("42")
let y = float(value)

// After (consistent keyword syntax)
let x = "42" as? int
let y = value as float

Lexer

Implement: as keyword token (verified 2026-03-29)
- TokenKind::As in ori_lexer/src/keywords/mod.rs line 50. Test at line 183 confirms.
- LLVM Support: N/A — lexer token, not codegen
- AOT Tests: No AOT coverage yet

Parser

Implement: Parse expression as Type as conversion expression (verified 2026-03-29)
- ori_parse/src/grammar/expr/postfix.rs line 120 checks for TokenKind::As. Produces ExprKind::Cast { expr, ty, fallible: false }.
- LLVM Support: LLVM codegen for as expression — BROKEN (see LLVM/AOT GAP above)
- AOT Tests: No AOT coverage yet
Implement: Parse expression as? Type as fallible conversion (verified 2026-03-29)
- Same parser function checks for ? after as to set fallible: true.
- LLVM Support: LLVM codegen for as? expression — BROKEN (see LLVM/AOT GAP above)
- AOT Tests: No AOT coverage yet

Type Checker

Implement: Type resolution for as casts (verified 2026-03-29)
- infer_cast() in ori_types/src/infer/expr/operators.rs line 466 resolves target type and returns it.
- [partial] Trait-based validation (As<T>) NOT implemented — any type can be cast to any type at typeck level. Runtime catches invalid casts.
Implement: Validate as only used with As<T> trait implementations
- Ori Tests: tests/compile-fail/as_not_implemented.ori
Implement: Validate as? only used with TryAs<T> trait implementations
- Ori Tests: tests/compile-fail/try_as_not_implemented.ori
Implement: Error when using as for fallible conversion (must use as?)
- Ori Tests: tests/compile-fail/as_fallible_conversion.ori

Codegen (Evaluator)

Implement: Evaluate x as T with hardcoded primitive conversion logic (verified 2026-03-29)
- eval_can_cast() at ori_eval/src/interpreter/can_eval/operators.rs line 119 handles: int->float, int->byte (range checked), int->char, float->int, byte->int, char->int, str->int (fallible), str->float (fallible), str->bool (fallible).
- NOT via trait dispatch — hardcoded conversion logic. Works correctly for all primitive conversions.
Implement: Evaluate x as? T with fallible flag (verified 2026-03-29)
- Same code path with fallible flag. Returns None on failure.

Codegen (LLVM/AOT)

Implement: Register __cast as protocol builtin in ori_ir/src/builtin_constants/protocol/ and handle in LLVM ARC emitter with appropriate LLVM cast instructions (sitofp, fptosi, trunc, zext)
- LLVM Rust Tests: ori_llvm/tests/aot/conversions.rs — as/as? codegen
- AOT Tests: No AOT coverage yet

Migration

Implement: Remove int(), float(), str(), byte() from parser
Implement: Update error messages to suggest as syntax
/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 (15D.2) — 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-15D.2 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 15D.2: 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.

15D.3 Simplified Bindings with `$` for Immutability

Proposal: proposals/approved/simplified-bindings-proposal.md

Simplify the binding model: let x is mutable, let $x is immutable. Remove mut keyword. Module-level bindings require $ prefix.

// Before
let x = 5         // immutable
let mut x = 5     // mutable
$timeout = 30s    // config variable

// After
let x = 5         // mutable
let $x = 5        // immutable
let $timeout = 30s // module-level constant (let and $ required)

Lexer

Implement: Remove mut from reserved keywords (verified 2026-03-29)
- No mut in ori_lexer/src/keywords/mod.rs. No KwMut token. Fully removed.
- LLVM Support: N/A — lexer keyword removal, not codegen

Parser

Semantic Analysis

Imports

Shadowing

Implement: Allow shadowing to change mutability
- Rust Tests: ori_types/src/check/binding.rs — shadowing mutability change
- Ori Tests: tests/spec/expressions/shadow_mutability.ori
- LLVM Support: LLVM codegen for shadowing mutability change
- LLVM Rust Tests: ori_llvm/tests/binding_tests.rs — shadowing mutability change codegen
- AOT Tests: No AOT coverage yet

Error Messages

15D.4 Remove `dyn` Keyword for Trait Objects

Proposal: proposals/approved/remove-dyn-keyword-proposal.md

Remove the dyn keyword for trait objects. Trait names used directly as types mean “any value implementing this trait.”

// Before
@process (item: dyn Printable) -> void = ...
let items: [dyn Serializable] = ...

// After
@process (item: Printable) -> void = ...
let items: [Serializable] = ...

Implementation

15D.5 Index and Field Assignment

Proposal: proposals/approved/index-assignment-proposal.md

Supersedes: bug-tracker/section-04-codegen-llvm.md::BUG-04-070 (E4003 ARC-lowering symptom), bug-tracker/section-07-tooling-cli.md::BUG-07-016 (typeck-layer naming of the same fix). Both bugs are symptoms of the unimplemented typeck.md §EX-17 desugar; §15D.5’s 5-phase plan IS the fix.

Extend assignment targets to support index expressions (list[i] = x), field access (state.name = x), mixed chains (state.items[i] = x, list[i].name = x), and compound assignment on all forms (list[i] += 1). All forms desugar to copy-on-write reassignment via IndexSet trait (for index) or struct spread (for fields).

let list = [1, 2, 3]
list[0] = 10                          // list = list.updated(key: 0, value: 10)

let state = GameState { score: 0, level: 1 }
state.score = 100                     // state = { ...state, score: 100 }
state.items[i] = new_item             // mixed chain
list[i].name = "new"                  // index then field

list[0] += 5                          // compound: list[0] = list[0] + 5

Phase 1: `IndexSet` Trait and `updated` Method

Implement: Define IndexSet<Key, Value> trait in prelude — @updated (self, key: Key, value: Value) -> Self
- Rust Tests: ori_types/src/infer/ — IndexSet trait resolution
- Ori Tests: tests/spec/traits/index_set/basic.ori
Implement: Register updated as built-in method on [T], {K: V}, [T, max N] in evaluator
- Rust Tests: ori_eval/src/method_dispatch/ — updated method dispatch
- Ori Tests: tests/spec/traits/index_set/updated_method.ori
Implement: updated with ARC-aware copy-on-write in ori_patterns/ori_eval
- Rust Tests: ori_patterns/src/value/ — copy-on-write behavior
- Ori Tests: tests/spec/traits/index_set/cow_behavior.ori

Phase 2: Parser Changes

Implement: Extend parser to accept assignment_target (identifier + index/field chains) on LHS of = and compound operators
- Rust Tests: ori_parse/src/grammar/expr/ — assignment target parsing
- Ori Tests: tests/spec/expressions/index_assignment_syntax.ori
Implement: Emit AST node capturing chain of index/field accesses in assignment target
- Rust Tests: ori_ir/src/ast/expr.rs — AssignTarget AST node
- Ori Tests: tests/spec/expressions/field_assignment_syntax.ori

Phase 3: Type-Directed Desugaring

Implement: Desugar [key] steps to updated() calls (requires IndexSet trait resolution)
- Rust Tests: ori_types/src/infer/expr/ — index assignment desugaring
- Ori Tests: tests/spec/expressions/index_assignment_desugar.ori
Implement: Desugar .field steps to struct spread reconstruction (requires struct type info)
- Rust Tests: ori_types/src/infer/expr/ — field assignment desugaring
- Ori Tests: tests/spec/expressions/field_assignment_desugar.ori
Implement: Handle nested cases, mixed field-index chains, and compound assignment
- Rust Tests: ori_types/src/infer/expr/ — mixed chain desugaring
- Ori Tests: tests/spec/expressions/mixed_chain_assignment.ori

Phase 4: Type Checker Integration

Phase 5: LLVM Support

15D.6 Mutable Self

Proposal: proposals/approved/mutable-self-proposal.md

Make self a mutable binding in method bodies with implicit mutation propagation back to the caller. Extends the existing field/index assignment desugaring pattern to method calls.

impl Cursor {
    @advance (self) -> void = {
        self.pos += 1
    }
}

cursor.advance()   // cursor is updated via desugaring

Phase 1: Self Mutability

Implement: Make self a mutable binding in method bodies (type checker)
- Rust Tests: ori_types/src/infer/ — self mutability in methods
- Ori Tests: tests/spec/methods/mutable_self_basic.ori
Implement: Mutation detection dataflow analysis (classify methods as mutating/non-mutating)
- Rust Tests: ori_types/src/infer/ — mutation classification
- Ori Tests: tests/spec/methods/mutation_detection.ori

Phase 2: Call-Site Desugaring

Phase 3: Caller Validation

Implement: Error when calling mutating method on immutable ($) binding
- Rust Tests: ori_types/src/infer/expr/ — immutable receiver error
- Ori Tests: tests/compile-fail/methods/mutating_on_immutable.ori
Implement: Diagnostics for mutation-related errors
- Rust Tests: ori_diagnostic/ — mutation error diagnostics
- Ori Tests: tests/compile-fail/methods/mutation_errors.ori

Phase 4: Trait Integration

Implement: Infer mutation classification across trait implementations
- Rust Tests: ori_types/src/infer/ — trait mutation consistency
- Ori Tests: tests/spec/traits/mutable_self_trait.ori
Implement: Conservative mutating classification for trait objects without local impls
- Rust Tests: ori_types/src/infer/ — trait object mutation
- Ori Tests: tests/spec/traits/mutable_self_trait_object.ori

Phase 5: Extension Support

Implement: Extension methods follow same mutation propagation rules
- Rust Tests: ori_types/src/infer/ — extension mutation propagation
- Ori Tests: tests/spec/methods/mutable_self_extension.ori

Phase 6: Evaluator

Implement: Evaluator support for mutable self in method bodies
- Rust Tests: ori_eval/src/ — mutable self evaluation
- Ori Tests: tests/spec/methods/mutable_self_eval.ori
Implement: Evaluator call-site desugaring (implicit reassignment)
- Rust Tests: ori_eval/src/ — call-site desugaring evaluation
- Ori Tests: tests/spec/methods/mutable_self_propagation.ori

Phase 7: LLVM Support

15D.7 Section Completion Checklist

All implementation items have checkboxes marked [ ]
All spec docs updated
CLAUDE.md updated with syntax changes
Migration tools working
All tests pass: ./test-all.sh
/tpr-review passed — independent Codex review found no critical or major issues (or all findings triaged)
/impl-hygiene-review passed — implementation hygiene review clean (phase boundaries, SSOT, algorithmic DRY, naming). MUST run AFTER /tpr-review is clean.
/improve-tooling retrospective completed — MANDATORY at section close, after both reviews are clean. Reflect on the section’s debugging journey (which diagnostics/ scripts you ran, which command sequences you repeated, where you added ad-hoc dbg!/tracing calls, where output was hard to interpret) and identify any tool/log/diagnostic improvement that would have made this section materially easier OR that would help the next section touching this area. Implement every accepted improvement NOW (zero deferral) and commit each via SEPARATE /commit-push. The retrospective is mandatory even when nothing felt painful — that is exactly when blind spots accumulate. See .claude/skills/improve-tooling/SKILL.md “Retrospective Mode” for the full protocol.

Exit Criteria: Binding and type syntax proposals implemented

Subsection close-out (15D.7) — 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-15D.7 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 15D.7: 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.

Section 15D: Bindings & Types

15D.1 Function-Level Contracts: pre() / post()

Key Design Decisions

Implementation

15D.2 as Conversion Syntax

Lexer

Parser

Type Checker

Codegen (Evaluator)

Codegen (LLVM/AOT)

Migration

15D.3 Simplified Bindings with $ for Immutability

Lexer

Parser

Semantic Analysis

Imports

Shadowing

Error Messages

15D.4 Remove dyn Keyword for Trait Objects

Implementation

15D.5 Index and Field Assignment

Phase 1: IndexSet Trait and updated Method

Phase 2: Parser Changes

Phase 3: Type-Directed Desugaring

Phase 4: Type Checker Integration

Phase 5: LLVM Support

15D.6 Mutable Self

Phase 1: Self Mutability

Phase 2: Call-Site Desugaring

Phase 3: Caller Validation

Phase 4: Trait Integration

Phase 5: Extension Support

Phase 6: Evaluator

Phase 7: LLVM Support

15D.7 Section Completion Checklist

15D.1 Function-Level Contracts: `pre()` / `post()`

15D.2 `as` Conversion Syntax

15D.3 Simplified Bindings with `$` for Immutability

15D.4 Remove `dyn` Keyword for Trait Objects

Phase 1: `IndexSet` Trait and `updated` Method