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 → [param_names].

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 → [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 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 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 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.