Struct InferenceContext 

pub struct InferenceContext<'a> { /* private fields */ }

Type inference context for a single function call or expression.

Implementations

impl<'a> InferenceContext<'a>

pub fn new(interner: &'a dyn TypeDatabase) -> Self

pub fn with_resolver( interner: &'a dyn TypeDatabase, resolver: &'a dyn TypeResolver, ) -> Self

pub fn fresh_var(&mut self) -> InferenceVar

Create a fresh inference variable

pub fn fresh_type_param(&mut self, name: Atom, is_const: bool) -> InferenceVar

Create an inference variable for a type parameter

pub fn register_type_param( &mut self, name: Atom, var: InferenceVar, is_const: bool, )

Register an existing inference variable as representing a type parameter.

This is useful when the caller needs to compute a unique placeholder name (and corresponding placeholder TypeId) after allocating the inference variable.

pub fn find_type_param(&self, name: Atom) -> Option<InferenceVar>

Look up an inference variable by type parameter name

pub fn is_var_const(&mut self, var: InferenceVar) -> bool

Check if an inference variable is a const type parameter

pub fn probe(&mut self, var: InferenceVar) -> Option<TypeId>

Probe the current value of an inference variable

pub fn unify_var_type( &mut self, var: InferenceVar, ty: TypeId, ) -> Result<(), InferenceError>

Unify an inference variable with a concrete type

pub fn unify_vars( &mut self, a: InferenceVar, b: InferenceVar, ) -> Result<(), InferenceError>

Unify two inference variables

pub fn resolve_all(&mut self) -> Result<Vec<(Atom, TypeId)>, InferenceError>

Resolve all type parameters to concrete types

pub fn interner(&self) -> &dyn TypeDatabase

Get the interner reference

pub fn add_lower_bound(&mut self, var: InferenceVar, ty: TypeId)

Add a lower bound constraint: ty <: var This is used when an argument type flows into a type parameter. Updated to use NakedTypeVariable (highest priority) for direct argument inference.

pub fn add_candidate( &mut self, var: InferenceVar, ty: TypeId, priority: InferencePriority, )

Add an inference candidate for a variable.

pub fn add_property_candidate( &mut self, var: InferenceVar, ty: TypeId, priority: InferencePriority, )

Add an inference candidate for a variable that originates from object property inference. Object-property candidates are tracked so the resolver can apply tighter union handling for repeated property positions (e.g. { bar: T; baz: T }).

pub fn add_property_candidate_with_index( &mut self, var: InferenceVar, ty: TypeId, priority: InferencePriority, object_property_index: u32, object_property_name: Option<Atom>, )

Add an inference candidate for a variable that originates from an object property. object_property_index captures the source property order and enables deterministic tie-breaking when repeated property candidates collapse to a union.

pub fn add_upper_bound(&mut self, var: InferenceVar, ty: TypeId)

Add an upper bound constraint: var <: ty This is used for extends constraints on type parameters.

pub fn get_constraints(&mut self, var: InferenceVar) -> Option<ConstraintSet>

Get the constraints for a variable

pub fn all_candidates_are_return_type(&mut self, var: InferenceVar) -> bool

Check if all inference candidates for a variable have ReturnType priority. This indicates the type was inferred from callback return types (Round 2), not from direct arguments (Round 1).

pub fn get_literal_candidates(&mut self, var: InferenceVar) -> Vec<TypeId>

Get the original un-widened literal candidate types for an inference variable.

pub const fn collect_constraint(&mut self, _source: TypeId, _target: TypeId)

Collect a constraint from an assignment: source flows into target If target is an inference variable, source becomes a lower bound. If source is an inference variable, target becomes an upper bound.

impl<'a> InferenceContext<'a>

pub fn best_common_type(&self, types: &[TypeId]) -> TypeId

Calculate the best common type from a set of types. This implements Rule #32: Best Common Type (BCT) Inference.

Algorithm:

1. Filter out duplicates and never types
2. Try to find a single candidate that is a supertype of all others
3. Try to find a common base class (e.g., Dog + Cat -> Animal)
4. If not found, create a union of all candidates

impl<'a> InferenceContext<'a>

pub fn infer_from_types( &mut self, source: TypeId, target: TypeId, priority: InferencePriority, ) -> Result<(), InferenceError>

Perform structural type inference from a source type to a target type.

This is the core algorithm for inferring type parameters from function arguments. It walks the structure of both types, collecting constraints for type parameters.

Arguments

• source - The type from the value argument (e.g., string from identity("hello"))
• target - The type from the parameter (e.g., T from function identity<T>(x: T))
• priority - The inference priority (e.g., NakedTypeVariable for direct arguments)

Type Inference Algorithm

TypeScript uses structural type inference with the following rules:

1. Direct Parameter Match: If target is a type parameter T we’re inferring, add source as a lower bound candidate for T.

2. Structural Recursion: For complex types, recurse into the structure:

   • Objects: Match properties recursively
   • Arrays: Match element types
   • Functions: Match parameters (contravariant) and return types (covariant)

3. Variance Handling:

   • Covariant positions (properties, arrays, return types): infer(source, target)
   • Contravariant positions (function parameters): infer(target, source) (swapped!)

Example

let mut ctx = InferenceContext::new(&interner);
let t_var = ctx.fresh_type_param(interner.intern_string("T"), false);

// Inference: identity("hello") should infer T = string
ctx.infer_from_types(string_type, t_type, InferencePriority::NakedTypeVariable)?;

impl<'a> InferenceContext<'a>

pub fn resolve_with_constraints( &mut self, var: InferenceVar, ) -> Result<TypeId, InferenceError>

Resolve an inference variable using its collected constraints.

Algorithm:

1. If already unified to a concrete type, return that
2. Otherwise, compute the best common type from lower bounds
3. Validate against upper bounds
4. If no lower bounds, use the constraint (upper bound) or default

pub fn resolve_with_constraints_by<F>( &mut self, var: InferenceVar, is_subtype: F, ) -> Result<TypeId, InferenceError>

where F: FnMut(TypeId, TypeId) -> bool,

Resolve an inference variable using its collected constraints and a custom assignability check for upper-bound validation.

pub fn resolve_all_with_constraints( &mut self, ) -> Result<Vec<(Atom, TypeId)>, InferenceError>

Resolve all type parameters using constraints.

pub fn infer_from_conditional( &mut self, var: InferenceVar, check_type: TypeId, extends_type: TypeId, true_type: TypeId, false_type: TypeId, )

Infer type parameters from a conditional type. When a type parameter appears in a conditional type, we can sometimes infer its value from the check and extends clauses.

pub fn compute_variance( &self, ty: TypeId, target_param: Atom, ) -> (u32, u32, u32, u32)

Compute the variance of a type parameter within a type. Returns (covariant_count, contravariant_count, invariant_count, bivariant_count)

pub fn is_invariant_position(&self, ty: TypeId, target_param: Atom) -> bool

Check if a type parameter is invariant at a given position.

pub fn is_bivariant_position(&self, ty: TypeId, target_param: Atom) -> bool

Check if a type parameter is bivariant at a given position.

pub fn get_variance(&self, ty: TypeId, target_param: Atom) -> &'static str

Get the variance of a type parameter as a string.

pub fn infer_from_context( &mut self, var: InferenceVar, context_type: TypeId, ) -> Result<(), InferenceError>

Try to infer a type parameter from its usage context. This implements bidirectional type inference where the context (e.g., return type, variable declaration) provides constraints.

pub fn strengthen_constraints(&mut self) -> Result<(), InferenceError>

Strengthen constraints by analyzing relationships between type parameters. For example, if T <: U and we know T = string, then U must be at least string.

pub fn validate_variance(&mut self) -> Result<(), InferenceError>

Validate that resolved types respect variance constraints.

pub fn fix_current_variables(&mut self) -> Result<(), InferenceError>

Fix (resolve) inference variables that have candidates from Round 1.

This is called after processing non-contextual arguments to “fix” type variables that have enough information, before processing contextual arguments (like lambdas) in Round 2.

The fixing process:

1. Finds variables with candidates but no resolved type yet
2. Computes their best current type from candidates
3. Sets the resolved field to prevent Round 2 from overriding

Variables without candidates are NOT fixed (they might get info from Round 2).

pub fn get_current_substitution(&mut self) -> TypeSubstitution

Get the current best substitution for all type parameters.

This returns a TypeSubstitution mapping each type parameter to its current best type (either resolved or the best candidate so far). Used in Round 2 to provide contextual types to lambda arguments.