Phase-E typed-AST: converge 4 resolvers into canonical typeOf()

[cs01]

Goal

Converge codegen's 4 overlapping type-resolvers into one canonical lookup: ctx.typeOf(expr). Every codegen site reads types through one path that hits the pre-codegen annotator cache first, then falls through to the live resolver.

Why

Before convergence, codegen has 4 ways to ask "what type is this?":

• typeInference.resolveExpressionType(expr) — flat base lookup
• typeInference.resolveExpressionTypeRich(expr) — enriched with sourceKind/fields
• getVariableType(register) — SSA-register-keyed (post-generation)
• pre-codegen annotator cache (filled by semantic/type-annotator.ts)

Two codegen sites could ask at different moments and get different answers — silent-wrong native code. 397 real divergences measured before PR #580.

Plan

Per memory/refactor-plan-2026-04-19.md step 5 ("TypedAST annotator pass").

Shipped

• refactor(type-inference): memoize resolveExpressionTypeRich at the boundary #571 memoize resolveExpressionTypeRich at the boundary
• enable ast type-annotator pass (phase-e step 5, pr1) #573 enable AST annotator pass pre-codegen
• refactor(codegen): migrate array-allocator to typeof() (phase-e step 5, pr2) #575 migrate array-allocator → typeOf
• refactor(codegen): migrate class-allocator to typeof() (phase-e step 5, pr1) #576 migrate class-allocator ternary branch → typeOf
• refactor(codegen): widen VariableAllocatorContext with typeOf + resolveExpressionTypeRich #578 widen VariableAllocatorContext with typeOf/typeRich
• refactor(codegen): enrichResolvedType emits canonical ResolvedType layout #579 enrichResolvedType canonical 11-field layout (rule Add cross compilation support #5 defense)
• fix(codegen): annotator only caches truly-static expression types; unblocks typeOf consumer migrations #580 keystone — annotator only caches truly-static types, unblocked downstream migrations
• refactor(codegen): migrate 4 llvm-generator resolveExpressionType sites to typeOf() #583 migrate 4 llvm-generator sites → typeOf
• refactor(codegen): migrate map-allocator to typeOf() #584 migrate map-allocator → typeOf
• refactor(codegen): drop redundant resolveExpressionType fallback in variable-allocator #592 drop redundant resolveExpressionType fallback in variable-allocator
• refactor(codegen): migrate member.ts to typeOf() #594 migrate member.ts → typeOf (open, in review)

Remaining

• Delete dead public passthroughs at llvm-generator.ts:4246-4251 (resolveExpressionType + Rich) — no external consumers after refactor(codegen): migrate member.ts to typeOf() #594
• Migrate ~212 getVariableType(register) consumers to typeOf(expr) where the AST is available (per-site judgment)
• Step 6 sema extraction phase 2 (isClass migration) — blocked, see memory/sema-migration-blockers.md
• Final cleanup: drop any remaining resolveExpressionTypeRich calls outside type-inference.ts internal recursion and semantic/type-annotator.ts (legitimate cache-filling sink)

Done-when

• Zero callers of typeInference.resolveExpressionType / resolveExpressionTypeRich outside type-inference.ts recursion and type-annotator.ts
• getVariableType either deleted or used only for SSA-register lookup (not as a type resolver)
• Stage 2 native self-host green throughout

[cs01]

Session update 2026-04-20

4 PRs shipped this session:

• refactor(codegen): migrate 4 llvm-generator resolveExpressionType sites to typeOf() #583 migrate 4 llvm-generator sites → typeOf
• refactor(codegen): migrate map-allocator to typeOf() #584 migrate map-allocator → typeOf
• refactor(codegen): drop redundant resolveExpressionType fallback in variable-allocator #592 drop redundant resolveExpressionType fallback in variable-allocator
• refactor(codegen): migrate member.ts to typeOf() #594 migrate member.ts → typeOf

State: every non-type-inference, non-annotator caller of resolveExpressionType / resolveExpressionTypeRich is now routed through typeOf(). Remaining external uses:

• semantic/type-annotator.ts:253 — calls sink.resolveExpressionTypeRich to FILL the typeOf cache. Must stay.
• llvm-generator.ts:4251 — the sink method the annotator depends on. Must stay.
• llvm-generator.ts:4247 — public flat resolveExpressionType passthrough. Dead. Can be deleted in a trivial followup PR.
• type-inference.ts internal recursion — fine, it's the resolver talking to itself.

Next: followup deletes #4247 passthrough. Then the big one: ~212 getVariableType(register) consumers per-site-migrated to typeOf(expr) where the AST is available.

[cs01]

Final session update 2026-04-20

5 PRs shipped this session (up from 4 in my earlier update):

• refactor(codegen): migrate 4 llvm-generator resolveExpressionType sites to typeOf() #583 migrate 4 llvm-generator sites → typeOf
• refactor(codegen): migrate map-allocator to typeOf() #584 migrate map-allocator → typeOf
• refactor(codegen): drop redundant resolveExpressionType fallback in variable-allocator #592 drop redundant resolveExpressionType fallback in variable-allocator
• refactor(codegen): migrate member.ts to typeOf() #594 migrate member.ts → typeOf
• refactor(codegen): delete dead resolveExpressionType public passthrough on LLVMGenerator #596 delete dead public resolveExpressionType passthrough on LLVMGenerator

Main now at 0199152c.

Phase-E step 5 non-type-inference consumer migrations are complete. Remaining external uses of resolveExpressionType / resolveExpressionTypeRich are now exactly:

• semantic/type-annotator.ts:253 — fills typeOf cache (legitimate sink)
• llvm-generator.ts:4251 — public Rich passthrough the annotator needs (legitimate sink)
• type-inference.ts internal recursion (legitimate)

Blocker surfaced: #597 (checkMissingReturns false-positive at 8+ stdlib count). #583 tipped an existing native-compiler fragility past its threshold — documented diagnosis in that issue. Needs LLDB-level native debug, separate session. Does not block current main; blocks new stdlib registrations.

Next steps (for a future session):

1. getVariableType(register) → typeOf(expr) migration — ~212 sites, per-site judgment
2. regression: checkMissingReturns false-positives on transformExpression when chad-native.ts has 8+ registerStdlib calls (introduced in #583) #597 native fragility root-cause
3. Step 6 sema phase 2 (isClass consumer migration) — see memory/sema-migration-blockers.md