Struct TypeChecker 

pub struct TypeChecker {
    pub env: TypeEnv,
    pub subst: Substitution,
    pub diags: DiagnosticBag,
    pub impl_table: Option<ImplTable>,
    /* private fields */
}

Bidirectional type checker / inference engine.

Usage

let mut checker = TypeChecker::new();
checker.check_module(&mut air_module);
// inspect checker.diags for errors
// query checker.type_of(node_id) for resolved types

Fields

env: TypeEnv

Scoped variable / function type environment.

subst: Substitution

Accumulated type-variable substitution from unification.

diags: DiagnosticBag

Diagnostics emitted during type checking.

impl_table: Option<ImplTable>

Trait impl table for checking where-clause bounds at call sites. When None, trait-bound checking is skipped.

Implementations

impl TypeChecker

pub fn new() -> Self

Create a new, empty type checker.

pub fn type_of(&self, id: NodeId) -> Option<&Type>

Look up the resolved type for node_id from the side-table.

pub fn record_field_types(&self) -> &HashMap<String, Vec<(String, Type)>>

Record field types: record_name → [(field_name, field_type)].

pub fn record_generic_params(&self) -> &HashMap<String, Vec<String>>

Generic type parameter names for records: record_name → Vec<param_name>.

pub fn effect_op_types(&self) -> &HashMap<String, Vec<(String, Type)>>

Effect operation types: effect_name → [(op_name, fn_type)].

pub fn effect_components(&self) -> &HashMap<String, Vec<String>>

Component effects for composite effects: effect_name → Vec<component_name>.

pub fn method_types(&self) -> &HashMap<String, HashMap<String, Type>>

Inherent impl method signatures: type_name → (method_name → fn_type).

pub fn trait_method_types(&self) -> &HashMap<String, HashMap<String, Type>>

Trait method signatures: trait_name → (method_name → fn_type).

pub fn type_aliases(&self) -> &HashMap<String, Type>

Type alias mappings: alias_name → underlying type.

pub fn fn_where_bounds(&self, name: &str) -> Vec<(TypeVarId, Vec<String>)>

Where-clause trait bounds on a generic function’s type parameters, keyed by the TypeVarId the parameter was assigned during signature collection.

Returns (var_id, [trait_name, …]) pairs — one entry per generic parameter that carries at least one bound. The var_id is the same id that appears as ?<id> in the function’s exported Type string, so the export ABI can encode the bound against the right type variable (Q-xmod-bounds). Returns an empty vec for an unknown or non-generic function, or one with no where-clause bounds.

pub fn insert_record_field_types( &mut self, name: String, fields: Vec<(String, Type)>, )

Insert record field types for an imported record.

pub fn insert_record_generic_params( &mut self, name: String, params: Vec<String>, )

Insert generic parameter names for an imported record/enum.

pub fn insert_trait_method_types( &mut self, name: String, methods: HashMap<String, Type>, )

Insert trait method signatures for an imported trait.

pub fn insert_effect_op_types(&mut self, name: String, ops: Vec<(String, Type)>)

Insert effect operation types for an imported effect.

pub fn insert_effect_components( &mut self, name: String, components: Vec<String>, )

Insert component effects for an imported composite effect.

pub fn register_imported_trait_impl( &mut self, trait_name: String, trait_args: Vec<Type>, target: Type, )

Record a trait impl declared in an imported module (Q-xmod-impl).

trait_args is empty for a plain trait impl (impl Comparable for B) and non-empty for a parameterized one (impl From[A] for B). The recorded impls are folded into the freshly-built impl_table in TypeChecker::check_module, so cross-module .into() resolution and cross-module where-clause bound satisfaction see them.

pub fn insert_type_alias(&mut self, name: String, underlying: Type)

Insert a type alias for an imported type alias.

pub fn insert_method_types( &mut self, type_name: String, methods: HashMap<String, Type>, )

Insert method types for an imported type’s inherent impl.

pub fn seed_imported_generic_fn(&mut self, name: &str, fn_ty: &FnType) -> Type

Seed an imported generic function signature so that each call site gets fresh TypeVarIds (just like local generic functions).

When a generic function is exported, its type string contains the original TypeVarIds (e.g. "Fn(?3) -> ?3"). Without an FnSig entry the call-site instantiation logic in the Call handler is bypassed, causing the first call to bind those vars permanently.

This method re-allocates fresh TypeVarIds, remaps the function type, stores the remapped type in env, and inserts a matching FnSig into fn_sigs.

pub fn seed_imported_generic_fn_with_bounds( &mut self, name: &str, fn_ty: &FnType, bounds: &[(TypeVarId, Vec<String>)], ) -> Type

Like Self::seed_imported_generic_fn but also reconstructs the imported function’s where-clause trait bounds so they are enforced at call sites in the importing module (Q-xmod-bounds).

bounds is (original_type_var_id, [trait_name, …]), where the var id is the one encoded in the export ABI (the ?<id> that appears in the exported type string). Each id is matched to the synthetic generic parameter (T<position>) created for it here, and a TypeConstraint is built so the call-site trait-bound check can enforce it.

pub fn check_module(&mut self, module: &mut AIRNode)

Type-check an AIR module, annotating every node with its resolved type.

Performs two sub-passes:

1. Collect — gather all top-level function signatures.
2. Check — infer/check each top-level item.

pub fn infer_expr(&mut self, expr: &AIRNode) -> Type

Synthesis (public): query the side-table for the type of an expression node, or re-infer it on a temporary clone if not yet visited.

Callers that have already called check_module should use type_of to avoid re-inference overhead.

pub fn check_expr(&mut self, expr: &AIRNode, expected: &Type)

Checking (public): verify that expr has the given expected type.

Emits a diagnostic if the types do not unify. Like infer_expr, this operates on a clone when the node has not yet been visited.

Trait Implementations

impl Default for TypeChecker

fn default() -> Self

Returns the “default value” for a type.