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