M3: Text-in-composite codegen (type-oracle side-table)

[assapir]

What & why

Codegen recovered LLVM types from runtime BasicValueEnum::get_type() at every READ site and hardcoded f64. That lost the element/field/payload type and corrupted any non-f64 value nested in a composite: Text inside a record or array, nested arrays, and Ok(text)/NotOk(text). Construction was already correct (generate_array/generate_record build real struct types); the bugs were all at reads.

This is the FOUNDATION of M3 and the start of the M4 "authoritative types in codegen" direction: the type checker now produces a side-table of inferred types, and codegen consults it at read sites instead of guessing f64.

The type-oracle side-table API (for downstream M3 waves)

• typechecker::TypeTable = HashMap<Span, Type> — every expression's inferred type, keyed by its source span. infer_expr records each node's result type as a side effect; TypeChecker::check_program now returns the table on success (Result<TypeTable, TypeError>).

• codegen::TypeOracle wraps the table with a single primitive: expr_type(expr) -> Option<&Type>. The checker records the result type of every node, so:

  • element type of arr[i] = expr_type(<the Index node>)
  • type of rec.field = expr_type(<the FieldAccess node>)
  • result of a match = expr_type(<the Match node>)

  i.e. a read site asks for the type of the whole node it's lowering — no per-shape accessors. Codegen installs the oracle via CodeGenerator::with_oracle(ctx, name, program) (or set_type_table if you already hold a table); without it the oracle is empty and read sites fall back to f64 (this is what the IR-only codegen tests rely on).

• value_repr_type(&Type) maps a declared type to its in-composite value representation (what generate_expr materializes and stores inline). It diverges from type_to_llvm for: Array → {ptr,i64} struct (inline value form), Record/Named → pointer (record ABI), Generic → f64 (unresolved payload fallback).

Limitation (tracked): Span is a byte range with no module identity, and << imports lex each module independently, so spans can collide across modules. Today's imported modules are numeric helpers/intrinsics with no composite reads, so this is latent; the robust fix is a stable per-node id. Documented in code + the oracle doc-comment.

Record ABI (unchanged, documented for consumers)

A record/named-type instance is stored as a pointer to its struct: the variable's alloca holds a pointer, and the struct lives behind it. Field reads/writes load that pointer then GEP the field. The struct's field types are the declared field types mapped through value_repr_type, in declaration order — record_field_pointer rebuilds exactly that, and constructor calls are reordered to declaration order before lowering so out-of-order construction can't mis-GEP a slot.

Verification

• examples/composites.ql — a record with a Text field + an array of Text + a nested array, exercised together; deterministic exit 12. Wired into tests/examples_test.rs, which runs it under JIT and native AOT (clang AND gcc).
• tests/composite_text_test.rs — 12 end-to-end run tests (Text record field, mixed fields, array of Text, nested arrays, Ok(text)/NotOk(text), user sum-type Text payloads, plus two regression tests).
• LANGUAGE.md: flipped the Text-in-composite / Text-sum-payload rows to ✅; removed the matching "Known limitation".

Green gate

• cargo build — clean
• cargo test — 321 passed, 0 failed (incl. the native-AOT examples gate: JIT + clang + gcc all agree)
• cargo fmt --check — clean
• cargo clippy --all-targets -- -D warnings — clean

Reviewed with /code-review and /simplify; findings addressed (consolidated the oracle to one primitive, removed a double field-type lookup, made specialize_variant mutate in place, made check_match prefer the concrete arm type, fixed the two latent bugs above).

Note: branched from current main (436cd50); the brief's d5a52dc was stale.

🤖 Generated with Claude Code