Struct TypeChecker 

pub struct TypeChecker {

    pub scopes: Vec<HashMap<String, ScopeItem>>,
    pub source_file: Option<SourceFile>,
    pub root_module: Module,
    pub errors: Vec<Error>,
    pub return_type_stack: Vec<TypeAnnotation>,
    pub loop_depth: u32,
    pub stdlib_fn_names: HashSet<String>,
    pub hovers: Vec<(Span, String)>,
    pub base_dir: Option<PathBuf>,
    pub importing: Vec<PathBuf>,
    pub imported: HashSet<PathBuf>,
    pub ast_arena: Ast,
    pub records: HashMap<String, Vec<(String, TypeAnnotation)>>,
    pub tags: HashMap<String, Vec<String>>,
}

The stateful type checker, threaded through the entire AST walk.

Fields

scopes: Vec<HashMap<String, ScopeItem>>

Stack of scopes, each mapping variable/function names to their ScopeItem.

source_file: Option<SourceFile>

Source file attached for Ariadne error rendering; None in LSP-less contexts.

root_module: Module

The stdlib module tree, used to resolve stdlib call paths.

errors: Vec<Error>

All type errors accumulated during the check pass.

return_type_stack: Vec<TypeAnnotation>

Stack of expected return types, pushed/popped on function and lambda entry/exit.

loop_depth: u32

Nesting depth of loops - used to validate break and continue.

stdlib_fn_names: HashSet<String>

Flat set of all stdlib function names for fast single-name lookup.

hovers: Vec<(Span, String)>

(span, markdown) pairs collected at every declaration and usage site, consumed by the LSP hover provider.

base_dir: Option<PathBuf>

importing: Vec<PathBuf>

imported: HashSet<PathBuf>

ast_arena: Ast

records: HashMap<String, Vec<(String, TypeAnnotation)>>

Maps record type names to their declared (field name, field type) list.

tags: HashMap<String, Vec<String>>

Maps tag (enum) type names to their declared variant name list.

Implementations

impl TypeChecker

pub fn check_binary_operator( &mut self, left: CheckType, right: CheckType, op: &TokenType, span: Span, ) -> CheckType

impl TypeChecker

pub fn check_index_assign( &mut self, target: ExprId, index: ExprId, value: ExprId, span: Span, ) -> CheckType

impl TypeChecker

pub fn check_unary_operator( &mut self, operand: CheckType, _operand_span: Span, op: &TokenType, span: Span, ) -> CheckType

impl TypeChecker

pub fn assign(&mut self, name: &str, value_type: CheckType, span: Span)

Checks that assigning value_type to name is valid.

Walks scopes from innermost to outermost. Emits an error if:

• The variable is declared const
• The value type doesn’t match the declared type
• The name is not declared in any scope (with a “did you mean?” suggestion)

impl TypeChecker

pub fn check_call_path( &mut self, path: &[String], arg_types: &[(CheckType, Span)], span: Span, ) -> CheckType

Resolves a call path and checks argument types.

Resolution order:

1. Full stdlib path (std::io::print) via [root_module]
2. Single-name stdlib shorthand (print) via [stdlib_fn_names]
3. User-defined name via [lookup]
4. Error - unknown function, with a “did you mean?” suggestion from stdlib keywords

Stdlib calls always return CheckType::Unknown since their return types are not tracked statically.

pub fn check_call_value( &mut self, callee_type: CheckType, arg_types: &[(CheckType, Span)], span: Span, ) -> CheckType

Checks that a resolved callee value is callable and receives the correct arguments.

• Unknown and Known(Fn) pass through without argument checking
• Function { params, return_type } validates arity and argument types, then returns Known(return_type)
• Anything else emits a “not callable” error

impl TypeChecker

pub fn declare( &mut self, name: String, item_type: CheckType, is_const: bool, span: Span, )

Declares name in the current (innermost) scope.

For constants, emits an error if the name is already declared in the same scope. On success, pushes a hover entry showing the kind, name, and type.

impl TypeChecker

pub fn push_scope(&mut self)

Pushes a new empty scope onto the scope stack.

pub fn pop_scope(&mut self)

Pops the innermost scope from the stack.

pub fn lookup(&mut self, name: &str, span: Span) -> CheckType

Looks up name in all scopes from innermost to outermost.

On success, pushes a hover entry with the variable’s type and kind, then returns the CheckType. On failure, emits an undefined variable error with a “did you mean?” suggestion and returns CheckType::Unknown.

impl TypeChecker

pub fn check_expression(&mut self, expression: ExprId) -> CheckType

impl TypeChecker

pub fn check_statement(&mut self, statement: &Statement)

fn import_module(&mut self, path: &[String], span: Span)

impl TypeChecker

pub fn current_return_type(&self) -> Option<&TypeAnnotation>

Returns the expected return type of the current function or lambda, if any.

pub fn push_return_type(&mut self, ty: TypeAnnotation)

Pushes ty as the expected return type when entering a function or lambda body.

pub fn pop_return_type(&mut self)

Pops the expected return type when exiting a function or lambda body.

pub fn loop_depth(&self) -> u32

pub fn enter_loop(&mut self)

pub fn exit_loop(&mut self)

pub fn check_block(&mut self, statements: &[Statement])

Checks all statements in statements inside a fresh scope.

pub fn check_is_null(&mut self, item_type: &CheckType, span: Span) -> bool

Emits a "value is null" error if item_type is [CheckType::Known(Null)].

Returns false if null, true otherwise.

pub(crate) fn to_type_annotation(item_type: &CheckType) -> TypeAnnotation

Converts a CheckType to a TypeAnnotation, mapping Unknown to Null.

pub(crate) fn is_hashable_key_type(ty: &TypeAnnotation) -> bool

impl TypeChecker

pub fn new() -> Self

pub fn with_source_file(self, file: SourceFile) -> Self

pub fn set_source_file(&mut self, file: SourceFile)

pub fn with_base_dir(self, dir: impl Into<PathBuf>) -> Self

pub fn with_ast_arena(self, arena: Ast) -> Self

pub fn check(&mut self, statements: &[Statement]) -> &[Error]

pub fn err(&self, message: impl Into<String>, span: Span) -> Error

pub fn error(&mut self, message: impl Into<String>, span: Span)

pub fn error_with_help( &mut self, message: impl Into<String>, span: Span, help: Option<&str>, )

pub fn push_hover(&mut self, span: Span, text: impl Into<String>)

fn push_stdlib_hover(&mut self, path: &[String], span: Span)

Trait Implementations

impl Default for TypeChecker

fn default() -> Self

Returns the “default value” for a type.