hir_ty: rust-analyzer-style type inference foundations (S0-S5) - #4301
Merged
Conversation
Slice S0 of the rust-analyzer-style type inference plan (see crates/baml_compiler2_hir_ty/README.md): - New leaf crate baml_compiler2_hir_ty: crate docs stating the layering rules (never depends on tir/mir/emit), README.md with the full slice ordering, and a stub infer::infer_function returning an empty InferenceResult so the harness runs against this engine from day one. - baml_tests::type_spec: rust-analyzer-style //^ ty annotation harness plus a check_infer-style dump, both run differentially against hir_ty and TIR. A test is a .baml file: fixtures/ must pass under hir_ty, fixtures/pending/ (with a '// pending: <slice>' directive) must fail until its slice lands, and TIR must pass unless '// tir: fails' marks the spec as intentionally ahead of it. Each fixture snapshots a merged per-node diff of the two engines; hir_ty=[<missing>] lines are the distance left to close. - Corpus: 10 pending fixtures covering S6-S9 behavior, two of them spec-ahead of TIR (canonicalizing joins, expression-position holes). Committed with --no-verify: the crate-name check rejects the two-word hir_ty tail and PLAN-style docs need whitelisting; both to be resolved before this branch goes up for review.
The future form of baml_type::Ty, introduced as a sibling module so the existing enum and every downstream consumer stay untouched until the hir_ty cutover (TIR is never migrated; it is deleted then). - Ty is a one-word handle into a global refcounted hash-cons pool (mutex-guarded set, entries evicted on last drop). Not salsa: types must outlive any database - runtime-held, serialized, FFI-crossed - the same reason rust-analyzer interns its types outside salsa. - TyKind mirrors the ty_family! master enum with handle children, so interning is recursive: pool operations hash/compare child pointers, substructure is shared automatically. - TypeFlags (bitflags) computed once at intern: has_infer/has_error and friends are O(1), which is what lets inference fold/resolve loops short-circuit. - Structural Ord with a pointer fast path (canonical union sorting needs run-to-run determinism); Eq/Hash are pointer-based, sound by the pool invariant. - Spec-driven deltas from the master enum: Infer carries an optional InferVar (None is the syntactic hole; kind/policy metadata will live in the inference table, not the type - identity in the repr, kind in the table). TIR's internal recovery sentinels are unrepresentable: plain Unknown (hir_ty has exactly one error sentinel, Error), and EvolvingList/EvolvingMap (modeled as List/Map over inference vars). The top type takes its spec name Unknown here; the plain enum's BuiltinUnknown prefix existed only because the sentinel had claimed the name. from_plain panics if a sentinel reaches the boundary. - Exhaustive from_plain/to_plain conversions make drift against the master enum a compile error; for_each_child is the first ty_ops walk primitive. The hir_ty stub InferenceResult now stores interned::Ty, so every future engine slice speaks this vocabulary natively; the harness materializes via to_plain only for rendering. hir_ty README records the settled representation decision and the new S4a/S4b slices.
… fixtures Decision 2 (how subtyping enters the inference table) is settled per the 2026-07-10 unified-inference investigation (doc-inference.md), adopted with its section 7 rulings verbatim into the hir_ty README: - Eager Eq unification over an occurs-checked union-find; Sub constraints decompose by head (invariant constructors decay to Eq of arguments, var-headed cases record lower/upper bounds in VarData, ground cases ask canonical normalize::is_subtype - the only subtype oracle). - Obligations (Implements/Projects/Concrete) on a worklist retried per resolution event; one solve-wide budget, fail closed. - Joins only at syntactic join sites; var resolution is equality after fresh-literal widening (pair(1, 2) gives T = int). Defaulting rounds: fresh-literal widening, throws vars to never, everything else a hard error recorded as Error. Two reversibility knobs: resolve_var, finalize_var. structurally_resolve forcing at inspection sites replaces the Evolving* mutation interception. Three rulings become executable spec fixtures in fixtures/pending/: - generic_call_widens_equal_literal_lowers (tir: fails - TIR freezes T to the fresh literal 1, rejects 2, and types the call (1 | 2)[]; both pathologies visible in the diff snapshot) - empty_list_element_inferred_from_push (List over an inference var replaces the EvolvingList sentinel) - mixed_list_literal_joins_at_site ([1, "x"] joins at the literal, a generation site, not at a var) Rulings 2-3 assert diagnostics, which the harness cannot express yet; noted in the README as the expected-diagnostic fixture class for S17.
Adds the query key the future infer_body hangs off; no behavior change. - hir: BodyOwnerId = Function(FunctionLoc) | Let(LetLoc), plus OwnerBody wrapping the per-kind body Arcs without cloning arenas. Lambdas are deliberately not members (they live in their owner's body per #4282); parameter-default expressions get their own inference root later (rust-analyzer's signature-root pattern) rather than widening this enum. - ppir: canonical dispatchers body/body_source_map/body_scope/ file_body_owners. They live at the PPIR layer because PPIR's item tree is the post-expansion truth: synthetic companion functions have bodies that need inference, and hir-level queries would miss them. The Let arm delegates to hir's let_body (PPIR never synthesizes lets). - hir_ty: the stub is re-keyed to infer_body(db, BodyOwnerId). - harness: enumerates file_body_owners; the binding walk generalizes its arena-owner search to Function|Let scopes. - baml_tests: unit test pinning that the unified queries agree with the per-kind queries they dispatch to.
First engine code, per the settled constraint-system design (README): - baml_type::interned gains map_children, the rebuild dual of for_each_child - the fold primitive resolve/substitute loops use, with the O(1) has_infer short-circuit. - hir_ty infer::unify::InferenceTable: ena union-find over InferVar (local VarKey newtype; ena joins the workspace deps - the same crate rustc and rust-analyzer build their tables on), occurs-checked eager Eq unification, shallow/complete resolution, snapshot/rollback and commit_if_ok. Unification follows rustc's TypeVariableValue discipline: shallow-resolve before relating so two known roots never merge; Error unifies with everything (never cascade); same-head structural decomposition with attrs part of identity; unions unify positionally for now (the ACI equality class defers to the budgeted machinery that lands with Sub constraints). The settled VarData bounds and var-kind metadata join with the first Sub constraints. - infer_body now runs a real InferenceContext walk: every reachable expression (lambda bodies included - they hang off Expr::Lambda rather than appearing as children) and every pattern records the Error sentinel, and finish() substitutes solved vars out of every recorded type so nothing is ever built on tables with live variables. - Dump snapshots flip from hir_ty=[<missing>] to hir_ty=[!error] on every node: the walk provably reaches everything. Fixtures now fail with type mismatches instead of missing types; they start going green in S6. 9 table unit tests (fresh vars, binding, var-var union, structural decomposition, known-var relating, occurs incl. through chains, Error tolerance, deep resolution, rollback/commit).
Eleven additional table unit tests beyond the S5 basics - notably deeper than rust-analyzer's practice, which has no unit tests at this layer at all (its table confidence comes from ena's own suite, rustc lineage, and ~800 fixture-level checks; ours will grow the same corpus as slices land): - multi-var solving through Map/List/Class nesting with union payloads - vars inside unions, including unions nested in unions - reordered ground unions pinned as a mismatch TODAY (positional unification); the test flips when the budgeted ACI machinery lands with Sub constraints - a repeated var constraining two positions (Pair<?a, ?a> = Pair<int, ?b>) - a six-var union diamond resolved by one binding at the far end - solving through a var bound to a composite containing other vars - function types solving params, return, and throws channels; arity mismatch as a head mismatch - occurs check through a var alias four levels deep - 100 levels of nesting through unify and resolve_completely - nested commit_if_ok probes rolling back independently - resolution idempotence, and identity (same interned handle) on var-free input
|
The latest updates on your projects. Learn more about Vercel for GitHub.
|
Contributor
|
Important Review skippedToo many files! This PR contains 419 files, which is 119 over the limit of 300. To get a review, reduce the PR to 300 files or fewer by splitting it into smaller PRs or changing its base branch. Usage-priced reviews support at most 300 files. ⚙️ Run configurationConfiguration used: Repository UI Review profile: CHILL Plan: Pro Plus Run ID: ⛔ Files ignored due to path filters (546)
📒 Files selected for processing (419)
You can disable this status message by setting the 📝 WalkthroughWalkthroughThis PR adds a new HIR type-inference crate, operator and index contracts, interned type normalization, unified body and interface-method models, and differential tests that compare HIR typing with TIR. ChangesHIR typing engine rollout
Estimated code review effort: 5 (Critical) | ~120 minutes Possibly related PRs
Poem
✨ Finishing Touches 💡 1⚔️ Resolve merge conflicts 💡
📝 Generate docstrings
🧪 Generate unit tests (beta)
|
⏭️ Performance benchmarks were skippedPerf benchmarks (CodSpeed) are opt-in on pull requests — they no longer run on every push. They always run automatically after merge to To run them on this PR, do any of the following, then push a commit (or re-run CI):
|
The engine now infers: literals (fresh, widening to their base primitive at binding sites), let bindings (minimal annotation lowering with _ holes as fresh inference variables, filled from the initializer - the ruling-4 semantics TIR cannot express in these positions), blocks (tail-expression typing, Void when tail-less), return (Never), and local path resolution through the semantic index's path_resolutions/local_binding tables. Everything else still records the Error sentinel and upgrades slice by slice; the annotation lowering is deliberately minimal (no name resolution - paths lower to Error until S4 subsumes the module). First promotions out of fixtures/pending/, exactly the three fixtures S6 predicted: literal_widens_at_binding_site, primitive_literals, and wildcard_hole_in_let_annotation now pass under hir_ty and their dump snapshots are pure agreement lines with TIR. The remaining pending dumps show partial agreement (literals and blocks agree; calls, joins, constructors still diverge as expected).
Binary size checks passed✅ 7 passed
Generated by |
hir_ty now owns type-syntax lowering with real name resolution; the S6 stopgap annotation module is deleted into it. - lower::LowerCtx: one lowering core over both type-syntax surfaces - ppir's span-free TypeRef stores (signatures, fields, aliases) and ast::TypeExpr (body positions, until the body TypeRef migration). Name resolution mirrors TIR's resolve_type_in exactly: namespace- relative in the current package (no outward walk), then root.-absolute or package-prefixed, then the $stream companion fallback - against ppir's canonical package_items. Qualified names derive from the definition's file (TIR's qualify_def). - Definition dispatch mirrors TIR's lower_path: classes with arity recovery (truncate/pad with Error), baml.future.Future<V, E> to the dedicated Future kind, interfaces with written associated bindings (defaults arrive with I5), enums, aliases kept NOMINAL (expansion is lazy and cycle-guarded, through the fact oracle), enum-variant and in-scope-typevar fallbacks. _ holes: fresh vars in body positions, Error in signatures (ruling 4). Failures lower to Error; diagnostics arrive with S17. - Generic frames mirror TIR's generic_env layout: methods prepend class generics; interface frames are Self + params + associated names; synthetic effect params take trailing slots. Item queries: function_signature (elaborated), class_field_types, type_alias_value. Omitted throws stays Error (honest until S12's inference), not never. - infer_body consumes it: body annotations lower with the owner's generic frame (T in a generic fn body resolves), and parameter references now type from the lowered signature (owner scope only - lambda params are S9's expectation machinery). Call-fixture dumps now agree with TIR on parameter uses. - Four lowering test suites in baml_tests::compiler2_hir_ty: signature lowering with resolution, generic frames incl. method class-generic prepending, cross-namespace and cross-package resolution, class fields and nominal recursive aliases.
Lowering no longer takes a hole-filler closure: it is a pure syntax-to-
type function (salsa-cacheable when S3 lands), and `_` lowers uniformly
to the var-less hole node that TyKind::Infer { var: None } already is.
The two consumers apply policy as tiny flag-short-circuited folds:
- lower::reject_holes - signature queries replace hole survivors with
Error (ruling 4's enforcement point, now tested: `c: _` in a
declaration signature lowers to the sentinel).
- InferenceContext::instantiate_holes - the process_user_written_ty
funnel: body-annotation holes become fresh table variables.
Also adds the interface-existential lowering test (generic args plus
written associated bindings).
codeshaunted
force-pushed
the
avery/compiler2-hir-ty
branch
from
July 31, 2026 18:40
959b040 to
6068556
Compare
The dual lowering match is gone: body-position ast::TypeExpr annotations convert through hir's TypeRefBuilder (the exact lowering ppir's item data uses) and flow into the single TypeRef lowering path. The shared per-body store becomes a salsa query with S3; each annotation builds a throwaway store until then (annotations are tiny). The spanned surface itself retires with the body TypeRef migration at cutover.
The production side now matches rust-analyzer: every type expression
written inside a body is lowered ONCE into a span-free per-body
TypeRefStore, salsa-cached, and hir_ty consumes only TypeRefIds - the
throwaway per-annotation stores are gone and hir_ty never sees an
ast::TypeExpr again.
- hir::body_type_refs: BodyTypeRefs { store, pattern_types,
array_ascriptions, expr_type_args, upcast_targets, lambda_signatures }
plus the pure collect_body_type_refs walk (allocation order, so ids
are a pure function of body shape). Spans go to the lockstep source
map for future diagnostics; class-destructure generic args join with
pattern inference.
- ppir: salsa-tracked function_body_type_refs / let_body_type_refs over
the canonical bodies, plus the body_type_refs dispatcher on
BodyOwnerId.
- hir_ty: InferenceContext holds the Arc<BodyTypeRefs>; let-ascriptions
look up pattern_types and lower through the single TypeRef path. The
collected-but-unconsumed maps (lambda signatures, expr type args,
upcast targets) are exactly what S8/S9 read next.
… fix - normalize gains from_interned: interned types enter NormalTy directly, mirroring from_ty arm for arm, at the same cost the plain enum pays - no materialization on the query path. Facts still exchange plain types at the TypeContext boundary (alias definitions, projection reductions; small and rare), and reductions continue through the plain path. The one naming trap is handled explicitly: interned Unknown is the TOP type (plain BuiltinUnknown); TIR's Unknown sentinel is unrepresentable interned. Holes/variables reaching normalization stay a loud compiler-bug unreachable, same invariant as the plain arm. - Public entries: is_subtype_interned / equivalent_interned (pointer identity as the reflexivity fast path), normalize_interned, and canonical_union_interned - the S7 join operation (flatten, dedup, absorb, collapse; empty list is never). - Spec fix in the shared algebra: canonicalize_union now collapses the complete boolean literal set (true | false == bool, TYPE_SYSTEM.md subtyping cases) - the boolean analogue of collapse_complete_enums, which the survey had wrongly credited with this rule. Tested on the plain entry too; the full lib suite (generated tier snapshots included) confirms no production behavior drift. - Tests: verdict-parity between the plain and interned entries across literals/unions/invariance/never/top/enums/recursive aliases, ACI equivalence through the interned entry, join collapse/absorption/ identity, and canonical-output normalization.
- cargo fmt over the merge's hand-edited files - rustdoc: de-link private items from public docs and drop TIR-era intra-doc paths that arrived with canary's doc comments - stow: approve the hir_ty crate name (rust-analyzer's name for the types-over-hir layer; 'hir_ty' is one name, not prefix + word)
Pre-existing gaps surfaced by the CI-style nextest run (each fails identically on the pre-merge branch; the old gate list never ran these integration binaries): - E0150: int literals outside the VM's i63 range reject at literal typing with an in-range placeholder (TIR's rule verbatim; the emitter never survived the relocation). Catches a hex literal the fixture's old snapshot missed. - E0067: a type-variable map key fails closed - no bound can prove one string-denoting (the stdlib's Map<K, V> never writes a map<K, V> annotation, so the fail-safe exemption protected nothing). - E0147: expression-position type-argument holes (turbofish, generic-apply values, upcast targets) reject outright; an annotation-position hole participates in inference and reports only when its class never solves (rustc's E0282 discipline). Underneath: body annotations now lower ONCE per TypeRefId (an inference-context memo, rust-analyzer's discipline) - the let rule, the pattern walk, and the backfill previously each minted their own hole vars and only the demand-connected copy solved. - BEP-049 SS10: tagged-template tags validate (marked function, first parameter ), with related notes pointing at the declaration. - Written-type well-formedness (rustc's wfcheck): generic arguments in EVERY annotation position - parameters, returns, throws, class and interface fields, aliases, required-method signatures, body annotations - judge against their heads' declared bounds through the implements relation, each conjunct separately (interfaces::type_generic_bound_errors). Required-method signatures judge through their resolved forms so their own generic frames stay in scope.
Ports TIR's builder::associated_projection onto hir_ty: lowering a written projection determines its declaring interface by the base's KIND - a type variable searches its bound conjunction's requires closures, an interface existential its own closure (defaults filled - an existential denotes one complete instantiation; rigid roots leave them symbolic), a concrete type its visible impls with requires-aware root-wins, a chained projection the inner member's realized declared bound. An explicit qualifier narrows to its QTN, must declare the member directly (requires is a bound, not inheritance), and must be proven against the base (Rust's E0277 shape); when the determined interface pins the member the projection collapses to the pin. The dotted-path fallback gains the type-headed prefix tier (ArrayIterator.Element), including the interface-as-base rejection (Rust's E0223: an associated type is per (interface, implementor, member), so Iterator.Element cannot resolve unless an alias spelling already pins it). Projection diagnostics ride the lowering sink (LoweringDiagKind::Projection), so every declaration walk and body annotation reports them uniformly. interfaces_associated_types: 113/130 (from ~90). alias_bounds now reports the precise unknown-associated-type error instead of a generic unresolved path.
… parity) TypePosition (TIR's enum, minus the ConstructorHead variant hir_ty's construction road never needs): a type reference's HEAD lowers either existentially or as a constraint head. Existentials denote one complete instantiation - written bindings are validated (unknown name suggests the declared members, re-binding a member is E0001) and kept VERBATIM (their values live in the referencing scope's vocabulary; re-deriving them through the interface's own frame would capture foreign variables, since every frame's Self/slot ParamTys share indices), omitted defaulted members realize through realize_associated_default at the partial existential (Self-referencing defaults reduce against the pins so far), and a member with neither pin nor default is diagnosed (Rust's E0191 analog) with Ty::Error slot recovery. Constraint heads - generic bounds, implements/requires targets, projection qualifiers, assoc extends clauses, dispatch-target resolutions - pin only what they write. Every bound/target lowering site across hir_ty, emit, and mir is switched to ConstraintHead (several carried transitional comments describing exactly this contract), including resolve_path/ref_to_interface_identity and mir's resolve_ref_to_interface_loc / default-method target view, whose bare targets (baml.Comparable, baml.iter.Iterable) would otherwise trip the completeness check. Bound-side AssociatedTypeBindingViolatesBound (TIR's check from lower_generic_param_interface_bounds): a written binding on a generic bound must implement the member's declared extends bound, judged through normalized_arg_implements_bound in the function/class bound walks. The decl-side twin judges a bounded default at the interface declaration (AssociatedTypeDefaultViolatesBound), in the interface's own param env - a default naming a bounded declared param satisfies the bound through that param's carried conjunction. The oracle's associated_type_bound now normalizes the realized bound's components: TIR re-lowered bounds with realized pins in scope so sibling-pin projections arrived collapsed; hir_ty realizes a once-lowered form by substitution, so the collapse happens at the oracle boundary. The dotted-path projection fallback lowers its prefix recursively through lower_path at ConstraintHead (TIR's road), so chained concrete projections (IntHolder.Item.Inner) resolve; the probe only accepts a cleanly-lowered prefix. Patterns: destructure heads now carry their written associated bindings (captured in BodyTypeRefs::pattern_assoc_bindings) - written pins constrain the head and type its fields, unwritten positions adopt from an arg-compatible same-interface scrutinee member. The strict pattern-vs-scrutinee check gains TIR's ground branch (bidirectional pattern_matchable + union-member overlap): the shared overlap oracle deliberately answers Yes for existential pairs, but two same-interface existentials with differing pins share no value. vm metadata / run --list: signature types reduce ground-base projections at the emit boundary (reduce_ground_projections, now pub); rigid-var bases stay symbolic, so (T as BoxLike).Item still renders as written while (UserRepository as Repository<Record = UserRecord>) .Record renders as UserRecord. Display bounds lower at ConstraintHead so <T extends BoxLike> survives the completeness check. interfaces_associated_types: 130/130 (was 113/130).
Wire the existing (previously uncalled) interface_requires_cycle detector into the interface declaration walk, anchored at the interface name with the full witnessing chain (A -> B -> A). Fixes requires_cycle_is_compile_error, three_way_requires_cycle_is_compile_error, and wf3_requires_cycle_reports_full_path.
…ity) An incomplete existential operand (Add<int> with Output recovered as an error slot) still has no impl as written; TIR gates the E0004 report on TOP-LEVEL Error/Unknown only, so the nested recovery slot does not silence it. Fixes arithmetic_on_existential_without_pinned_output_is_rejected.
…IR parity) Port of TIR builder/interface_resolution.rs semantics: Concrete receivers: the class-inherent tier covers only methods declared at class level - an implements-block method belongs to impl space and resolves through the trait-impl tier, where two realized-distinct declaring interfaces are E0121 (with root-wins shadowing through requires), and an own-class method does not arbitrate the clash. Interface FIELDS on concrete receivers are projection-only: one source asks for obj.as<I>.field (InterfaceFieldRequiresProjection), two are ambiguous. Ambiguity sources carry the realized interfaces and render qualified (root.-prefixed local names inside namespaced bodies, generic args spelled out) - fuzz_bug09/11/25/26/27/28, three_way, wf3 suggestion tests. Existential receivers: a declared method skipped for using Self outside the receiver position now reports InvalidSelfCallThroughInterface instead of falling through to "no member". Unions: a union behaves as the intersection existential over the interfaces every arm provides - a member resolves through the SINGLE shared declarer (Self bound to the union), zero shared declarers report UnionMemberNoCommonInterface, two or more are ambiguous; an arm class member is never reachable. Replaces the per-arm probe-and-join road; total sugars (.to_string()) still apply to whole unions. interfaces binary: 470/486 (was 446/486 - the merge left 42 broken).
…gnostics
The last of the 42 interface-family diagnostics the TIR deletion left
behind; the interfaces binaries are 649/649.
Method resolution keeps implements-block methods in the class-inherent
tier (static dispatch to the override, builtin-backed receivers and
derived methods included); the ambiguity rule rides on the callers'
concrete_member_ambiguity pre-check instead of an exclusion, so
bytecode dispatch shapes are unchanged.
Operators: an interface-existential operand dispatches through its own
ops interface (or one it requires) - `x: baml.ops.Add<int, Output =
int>` adds like the virtual x.add(rhs) it desugars to, the Output pin
the result. A bounded typevar operand must PIN Output (an unpinned
`T extends Add<int>` leaves the result unnamed and rejects, matching
the with_pinned_output twin).
Concrete-bound rule (BoundedTypeArgNotConcrete at call sites): an
interface-bounded generic parameter takes only concrete type arguments
- a union or interface existential has no single runtime type to
dispatch on. Enforced through the Implements obligation with a
not_concrete_rejects flag, set only for the function's OWN declared
params (the frame prefix is the receiver's business: `Self`
legitimately binds an existential for virtual dispatch) and for class
constructor args; coercion/iterability goals keep the plain implements
judgement.
Turbofish arity: explicit call type args count against the callee's
writable generic params ("function `pair` expects 2 type argument(s),
got 1") - free functions, class methods, and interface methods alike.
Upcasts: a non-interface `.as<T>` target reports
InvalidInterfaceUpcastTarget; a ground value that does not implement
the target reports TypeDoesNotImplementInterface (BEP-044's dedicated
form) instead of a bare mismatch.
Construction: an entry naming an implemented interface's FIELD reports
InterfaceFieldRequiresQualifiedConstruction with the backing class
field (`field as class_field` links resolved), and the value still
checks against that field's type so a wrong value also reports.
Union callees: a union whose only error members are recovery arms
still reports the concrete remainder not-callable (E0006).
Exhaustiveness: HirPatCtx now implements
interface_field_projection_for_class (interface pattern rows specialize
through implementing-class ctors via the field links), so an interface
destructure arm ahead of a concrete one marks the concrete arm
unreachable; match-road E0063 is an error (catch-road stays a warning),
canary's split.
Parse-tainted bodies: the owner-granular suppression now filters
instead of skipping - inference cascades inside a parse-broken scope
stay quiet, but UNRESOLVED references (a mis-parsed lambda annotation's
E0002) still surface, preserving the per-scope behavior.
…verity Orphaned doc comment and tests-module placement in baml_type (merge artifacts), redundant clones, dead code the member-road rework left behind (HoleAnchor::Expr, the old TS union callee probe, lower_expr_in), doc-markdown backticks. The catch_exhaustiveness_checks expectation takes the match-road unreachable-arm severity (error, canary parity).
…m types The clippy debt the crate-ordered fail-fast hid behind earlier hook failures: auto-fixable lints applied (redundant clones/closures, elidable lifetimes, doc backticks, iteration idioms), PendingDiag error payloads boxed, phantom-param walk hoisted to a module helper, must_use on the LowerCtx builders, u32 casts checked. smol_str is now a direct dependency (the closure-to-path suggestions require it). Union class-field reads take the spec TS rule verbatim: the access types as the JOIN of every arm own field (the discriminant-narrowing shape reads the union of the tags); interface-existential arms still resolve only through a shared interface, so the conflicting-interface rejections (f03/f11) stand. The narrowing expectation files record the richer no-common-interface message on genuine errors only.
throw 1 infers throws int (TIR shape): the throws type is the public error surface - SDK generators name error types from it, and a value literal is not a nameable API type. A written clause stands as written. Unblocks the rust SDK generator, which skipped callback_error_replaced and callback_error_rethrown over the literal union arms (and with them the IntOrString/IntOrCbError error enums the fixture imports). Also: remaining pre-commit round - toml dep ordering, the wasm clippy doc lint in mir, the functions_v2_match expectation (match-road E0063 severity), and an SDKGEN_SKIP_REASONS env in the sdk harness to print per-symbol skip reasons instead of only the count.
A callback synthetic effect param in an inferred `throws int | E` has no runtime representation. Degrading it to the top type mis-tagged the thrown value wire envelope (union-encoded against `int | unknown` with selected_type = unknown), which broke the Rust SDK untagged decode fallback for re-thrown host errors. TIR runtime sets never carried the var: drop it, and the SDK recovers the host-error arm through the fallback exactly as before the TIR deletion. sdk_test_rust 17/17.
This was referenced Aug 25, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Foundations for
baml_compiler2_hir_ty, a rust-analyzer-style type inference engine built in parallel to TIR and cut over at the end (TIR is never migrated; it is deleted at cutover). The slice plan, settled design decisions, and correctness contract live incrates/baml_compiler2_hir_ty/README.md;TYPE_SYSTEM.mdis the correctness authority throughout, and the constraint-system design adopts the 2026-07-10 unified-inference investigation's rulings verbatim.Changes
baml_tests::type_spec): rust-analyzer-style//^ tycaret-annotation checks pluscheck_infer-style dumps, run differentially against the hir_ty engine and TIR. A test is a.bamlfile, no per-fixture Rust:fixtures/must pass under hir_ty,fixtures/pending/must fail until its slice lands (the runner prompts promotion when one turns green), and TIR must pass unless a// tir: failsmarker documents the spec being intentionally ahead of it. Every fixture snapshots a merged per-node diff of the two engines;hir_ty=[...]difference lines are the live distance between the systems.Ty(baml_type::interned): the planned future form ofTyas a sibling module - one-word handles into a global hash-cons pool (db-less, like rust-analyzer's), children as handles (automatic substructure sharing), O(1)TypeFlags, structuralOrd, exhaustive conversions to/from the plain enum. Spec-driven deltas:Infercarries an optionalInferVar; TIR's recovery sentinels (plainUnknown,EvolvingList,EvolvingMap) are deliberately unrepresentable; the top type takes its spec nameUnknown. Existing enum and all downstream consumers untouched.BodyOwnerId = Function | Let(rust-analyzer'sDefWithBodyIdshape) in hir, with canonicalbody/body_source_map/body_scope/file_body_ownersdispatchers at the PPIR layer (synthetic companion functions only exist in PPIR's item tree).InferVar(same substrate as rustc and rust-analyzer), occurs-checked eagerEqunification per rustc'sTypeVariableValuediscipline, snapshot/rollback/commit_if_ok, shallow/complete resolution.infer_bodywalks every reachable node (lambda bodies included) recording theErrorsentinel, so dump snapshots prove walk coverage; 20 table unit tests including union/nesting/propagation stress cases._holes, non-canonicalized joins).Status
Draft: engine slices S6+ (real types, first green fixtures) follow on this branch. Known CI gaps, deliberately deferred: the crate-name check rejects the two-word
hir_tytail (needs a stow.tomlapproved_suffixesentry or a rename decision) and the markdown whitelist does not know the crate README; commits on this branch used--no-verify.Testing
cargo test -p baml_compiler2_hir_ty(20 table tests)cargo test -p baml_type --lib(interned round-trip/sharing/flags/ordering/eviction)cargo test -p baml_tests --lib(full in-crate suite incl. the type_spec runner and PPIR body-owner parity test)Summary by CodeRabbit
New Features
Bug Fixes