Struct TypeEnvironment 

pub struct TypeEnvironment { /* private fields */ }

Implementations

impl TypeEnvironment

pub fn new() -> Self

pub fn define_builtin_functions(&mut self)

Add built-in financial analysis functions

pub fn define(&mut self, name: &str, scheme: TypeScheme)

Define a variable in the current scope

pub fn lookup(&self, name: &str) -> Option<&TypeScheme>

Look up a variable type

pub fn push_scope(&mut self)

Push a new scope

pub fn pop_scope(&mut self)

Pop the current scope

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

Import symbols from a SymbolTable into this TypeEnvironment

This syncs the semantic analyzer’s symbol table with the type inference engine’s environment, allowing the inference engine to see all defined variables, functions, and type aliases.

pub fn import_variable(&mut self, name: &str, legacy_type: &Type)

Import a single variable from a SymbolTable

pub fn import_function(&mut self, name: &str, params: &[Type], returns: &Type)

Import a single function from a SymbolTable

pub fn define_type_alias( &mut self, name: &str, ty: &TypeAnnotation, meta_param_overrides: Option<HashMap<String, Expr>>, )

Define a type alias with optional meta parameter overrides

pub fn lookup_type_alias(&self, name: &str) -> Option<&TypeAliasEntry>

Look up a type alias

pub fn get_type_alias_meta_overrides( &self, name: &str, ) -> Option<&HashMap<String, Expr>>

Get the meta parameter overrides for a type alias

pub fn define_interface(&mut self, interface: &InterfaceDef)

Define an interface

pub fn lookup_interface(&self, name: &str) -> Option<&InterfaceDef>

Look up an interface

pub fn define_trait(&mut self, trait_def: &TraitDef)

Define a trait

pub fn lookup_trait(&self, name: &str) -> Option<&TraitDef>

Look up a trait

pub fn register_trait_impl( &mut self, trait_name: &str, target_type: &str, method_names: Vec<String>, ) -> Result<(), String>

Register a trait implementation with validation

pub fn register_trait_impl_named( &mut self, trait_name: &str, target_type: &str, impl_name: &str, method_names: Vec<String>, ) -> Result<(), String>

Register a named trait implementation

pub fn register_trait_impl_with_assoc_types( &mut self, trait_name: &str, target_type: &str, method_names: Vec<String>, associated_types: HashMap<String, TypeAnnotation>, ) -> Result<(), String>

Register a trait implementation with associated type bindings

pub fn register_trait_impl_with_assoc_types_named( &mut self, trait_name: &str, target_type: &str, impl_name: Option<&str>, method_names: Vec<String>, associated_types: HashMap<String, TypeAnnotation>, ) -> Result<(), String>

Register a named trait implementation with associated type bindings

pub fn type_implements_trait(&self, type_name: &str, trait_name: &str) -> bool

Check if a type implements a trait

pub fn lookup_trait_impl( &self, trait_name: &str, type_name: &str, ) -> Option<&TraitImplEntry>

Look up a trait implementation

pub fn lookup_trait_impl_named( &self, trait_name: &str, type_name: &str, impl_name: &str, ) -> Option<&TraitImplEntry>

Look up a named trait implementation

pub fn resolve_associated_type( &self, trait_name: &str, type_name: &str, assoc_type_name: &str, ) -> Option<&TypeAnnotation>

Resolve an associated type from a trait implementation

pub fn resolve_associated_type_named( &self, trait_name: &str, type_name: &str, impl_name: &str, assoc_type_name: &str, ) -> Option<&TypeAnnotation>

Resolve an associated type from a named trait implementation

pub fn trait_impl_keys(&self) -> HashSet<String>

Get all trait implementation keys (“TraitName::TypeName”) as a set

pub fn register_blanket_impl( &mut self, trait_name: &str, required_bounds: Vec<String>, method_names: Vec<String>, )

Register a blanket implementation: impl<T: Bound> Trait for T

pub fn register_enum(&mut self, enum_def: &EnumDef)

Register an enum definition for exhaustiveness checking

pub fn get_enum(&self, name: &str) -> Option<&EnumDef>

Look up an enum definition by name

pub fn register_record_schema(&mut self, name: &str, schema: RecordSchema)

Register a record schema

pub fn lookup_record_schema(&self, name: &str) -> Option<&RecordSchema>

Look up a record schema

pub fn get_record_field_type( &self, schema_name: &str, field_name: &str, ) -> Option<&TypeAnnotation>

Get field type from a record schema

pub fn record_has_field(&self, schema_name: &str, field_name: &str) -> bool

Check if a record schema has a field

pub fn generalize(&self, ty: &Type) -> TypeScheme

Generalize a type by quantifying free type variables

pub fn register_hoisted_field( &mut self, var_name: &str, field_name: &str, field_type: Type, )

Register a hoisted field for a variable (called during pre-pass)

pub fn get_hoisted_fields(&self, var_name: &str) -> Option<&Vec<HoistedField>>

Get all hoisted fields for a variable

pub fn set_current_access_variable(&mut self, var_name: Option<String>)

Set the current variable being accessed (for property access inference)

pub fn get_current_access_variable(&self) -> Option<&String>

Get the current variable being accessed

pub fn mark_hoisted_field_initialized( &mut self, var_name: &str, field_name: &str, )

Mark a hoisted field as initialized after a write (a.y = ...).

pub fn is_hoisted_field_initialized( &self, var_name: &str, field_name: &str, ) -> bool

Check whether a hoisted field has been initialized by a write.

pub fn get_hoisted_field(&self, field_name: &str) -> Option<Type>

Get a hoisted field type for the current access variable in read context. Field is only visible after it has been initialized by assignment.

pub fn get_hoisted_field_for_assignment(&self, field_name: &str) -> Option<Type>

Get a hoisted field type for the current access variable in assignment context. Assignment targets may reference hoisted fields before first write.

pub fn clear_hoisted_fields(&mut self)

Clear all hoisted fields (for resetting between analyses)

pub fn upsert_object_field( &mut self, var_name: &str, field_name: &str, field_type: Type, )

Evolve an in-scope object variable by adding/updating a field.

This keeps runtime-inferred object types in sync with successful property assignments so later expressions (e.g., a + b) observe the evolved shape.

pub fn begin_evolution(&mut self, var_name: &str, initial_type: SemanticType)

Begin tracking type evolution for a variable

pub fn record_field_assignment( &mut self, var_name: &str, field_name: &str, field_type: SemanticType, ) -> TypeResult<()>

Record a field assignment for type evolution tracking

pub fn get_evolved_type(&self, var_name: &str) -> Option<SemanticType>

Get the current evolved type for a variable

pub fn get_evolution(&self, var_name: &str) -> Option<&TypeEvolution>

Get the type evolution for a variable

pub fn enter_conditional(&mut self)

Enter a conditional block (if/else)

pub fn exit_conditional(&mut self)

Exit a conditional block

pub fn enter_loop(&mut self)

Enter a loop block (for/while)

pub fn exit_loop(&mut self)

Exit a loop block

pub fn in_conditional_context(&self) -> bool

Check if we’re inside a conditional or loop context

pub fn all_evolutions(&self) -> &HashMap<String, TypeEvolution>

Get all type evolutions

Trait Implementations

impl Clone for TypeEnvironment

fn clone(&self) -> TypeEnvironment

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeEnvironment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TypeEnvironment

fn default() -> Self

Returns the “default value” for a type.