Struct ConstraintGenerator 

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

Constraint generator that walks RIR and generates type constraints.

This is Phase 1 of HM inference: constraint generation. The constraints are later solved by the Unifier to determine concrete types.

Implementations

impl<'a> ConstraintGenerator<'a>

pub fn new( rir: &'a Rir, interner: &'a ThreadedRodeo, functions: &'a HashMap<Spur, FunctionSig>, structs: &'a HashMap<Spur, Type>, enums: &'a HashMap<Spur, Type>, methods: &'a HashMap<(StructId, Spur), MethodSig>, enum_methods: &'a HashMap<(EnumId, Spur), MethodSig>, type_pool: &'a TypeInternPool, ) -> Self

Create a new constraint generator.

pub fn with_type_subst( self, type_subst: Option<&'a HashMap<Spur, Type>>, ) -> Self

Set type substitutions for Self and type parameters (builder pattern).

The type_subst map provides type substitutions for names like “Self” that should be resolved to concrete types during constraint generation. This is used for method bodies where Self { ... } struct literals need to know the concrete struct type.

pub fn int_literal_vars(&self) -> &[TypeVarId]

Get the type variables allocated for integer literals.

pub fn fresh_var(&mut self) -> TypeVarId

Allocate a fresh type variable.

pub fn add_constraint(&mut self, constraint: Constraint)

Add a constraint.

pub fn record_type(&mut self, inst_ref: InstRef, ty: InferType)

Record the type of an expression.

pub fn get_type(&self, inst_ref: InstRef) -> Option<&InferType>

Get the recorded type of an expression.

pub fn constraints(&self) -> &[Constraint]

Get all collected constraints.

pub fn take_constraints(self) -> Vec<Constraint>

Take ownership of the collected constraints.

pub fn expr_types(&self) -> &HashMap<InstRef, InferType>

Get the expression type mapping.

pub fn into_parts( self, ) -> (Vec<Constraint>, Vec<TypeVarId>, Vec<TypeVarId>, HashMap<InstRef, InferType>, u32)

Consume the constraint generator and return (constraints, int_literal_vars, float_literal_vars, expr_types, type_var_count).

This is useful when you need ownership of the expression types map. The type_var_count can be used to pre-size the unifier’s substitution for better performance.

pub fn generate( &mut self, inst_ref: InstRef, ctx: &mut ConstraintContext<'_>, ) -> ExprInfo

Generate constraints for an expression.

Returns the inferred type of the expression. Records the type in expr_types and adds constraints to constraints.