[ASDAlexander77]

Phase 1 of -mm=own (spec §2.2 verdict 1, §2.6, §4.2 step 3, §5). The plan is tslang/docs/superpowers/plans/2026-09-29-own-phase-1.md and the results are in spec §12. Only OwnershipInferencePass.cpp changed. MLIRGen and the lowering are untouched, and gc, rc and none are unaffected.

What changes

Phase 0 allowed a move only into one owner, in the value's own block, with no later use. Phase 1 decides a move by reachability and dominance on the affine CFG:

• Moves into a branch are allowed. Each release of the source that the move can reach must be dominated by it, and is erased. A release the move cannot reach stays: it is the owner on the paths that didn't move. For example: const a = new C(); if (x) { let b = a; return ...; } use(a).
• Moves out of a let: into another let, a field (h.c = a), or a return. The move is measured from rc's retain, because at this level a return is a store into the return slot that comes after the source's scope-exit release.
• Use after move is an error, with a note at the move. This covers a read, an assignment, and any use of an earlier read such as const b = a (reported as 'a' is used here after its value was moved).
• Loops (§2.6): moving a value made outside the loop is rejected. Moving out of a let declared in the loop body is fine.
• Moved on some paths only (a move reaches a release it doesn't dominate) is an error. Fixing it needs drop elaboration, which is later.
• Other changes:
  • c: C | null = null now compiles (a cast of null or undefined is a literal).
  • --di errors name the variable.
  • Only heap-owning values are move candidates, and string literals (immortal) may be held by any number of places. Under --opt and JIT, CSE had merged literals, which gave false loop errors.

Tests

• New positives: own_move_const_branch, own_move_let, own_move_field, own_move_return, own_move_loop_body, own_move_control_flow, own_literal_reuse. Each runs under JIT and AOT, with a churn() before its reads, plus the no-counting check.
• New negatives: own_err_move_some_paths, own_err_assign_after_move, own_err_let_twice, own_err_let_loop, own_err_const_alias_move, own_err_const_alias_field, and a --di naming test.
• Changed negatives: six phase-0 negatives now say "is used here after its value was moved" instead of "takes a second reference". own_err_alias gained a use after its move, because phase 1 accepts a bare let b = a.
• Teeth: with the moved releases kept, every move test fails.

Verification

• Release suite (Windows): 3130/3130.
• Debug own tests: all pass except the known linkname DictionaryAttr assert, which fails on main too. owned-async was excluded; its Debug async-runtime assert also fails on main.
• 1M iterations: own 4.8 MB, the same as rc (gc 6.6, none 547) for let→let, →field and →return, at both -O3 and -O1.
• A fresh-context review found one Critical (a const alias of a moved let read freed memory) and two Important findings (CSE-merged literals; test gaps). All three are fixed in the last commit, each with a test that failed first.
• Linux not run.

Still rejected (spec §12.5, input to phase 2)

• borrows;
• moves on some paths only;
• assigning to a moved let;
• moves out of fields or parameters, or through boxing casts.

const b = a; a = new C(); b.x isn't caught: an assignment isn't a move. rc has the same bug today and prints garbage.

🤖 Generated with Claude Code