Struct TypeInferenceEngine 

pub struct TypeInferenceEngine {
    pub env: TypeEnvironment,
    /* private fields */
}

Fields

env: TypeEnvironment

Type environment tracking variable types

Implementations

impl TypeInferenceEngine

pub fn check_expr(&mut self, expr: &Expr, mode: CheckMode) -> TypeResult<Type>

Check an expression with a given mode

This is the main entry point for bidirectional type checking.

pub fn check_against( &mut self, expr: &Expr, expected: &Type, ) -> TypeResult<Type>

Check an expression against an expected type

The expected type guides inference and provides better error messages.

impl TypeInferenceEngine

pub fn infer_expr(&mut self, expr: &Expr) -> TypeResult<Type>

Infer type of an expression

impl TypeInferenceEngine

pub fn new() -> Self

pub fn register_known_bindings(&mut self, names: &[String])

Register host-known root-scope bindings before program inference.

These names come from host configuration (project/frontmatter/extensions) and prevent false-positive “undefined variable” diagnostics in the shared analyzer.

pub fn find_origin_for_unsolved_constraints( &self, constraints: &[(Type, Type)], ) -> Option<Span>

pub fn resolve_named_to_enum(&self, ty: &SemanticType) -> SemanticType

Resolve a Named type to a full Enum type if the name refers to an enum

This is used for exhaustiveness checking - we need the full enum variant information to verify all cases are covered.

pub fn run_hoisting_prepass(&mut self, program: &Program)

Infer types for a complete program Run the optimistic hoisting pre-pass

This collects all property assignments (e.g., a.b = 2) and registers them as hoisted fields so they’re available during the main type checking pass.

Call this BEFORE infer_program or infer_expr for optimistic hoisting to work.

pub fn infer_program( &mut self, program: &Program, ) -> TypeResult<HashMap<String, Type>>

Infer types for a complete program

This runs the hoisting pre-pass automatically before main type inference.

pub fn infer_program_best_effort( &mut self, program: &Program, ) -> (HashMap<String, Type>, Vec<TypeError>)

Infer types for a complete program and keep successful inferences even when some items fail type checking.

This uses the same inference engine and constraint solver as infer_program and is intended for tooling surfaces that should avoid guessing.

pub fn sync_callable_defaults_from_symbol_table( &mut self, symbol_table: &SymbolTable, )

Rebuild callable default-parameter metadata from the semantic symbol table.

This is used by legacy semantic analysis paths that infer expressions incrementally instead of running whole-program inference.

Trait Implementations

impl Default for TypeInferenceEngine

fn default() -> Self

Returns the “default value” for a type.