Struct SymbolTable

pub struct SymbolTable {
    functions: IndexMap<Location, FunctionSymbol>,
    records: IndexMap<Location, Composite>,
    structs: IndexMap<Vec<Symbol>, Composite>,
    global_consts: IndexMap<Location, Expression>,
    globals: IndexMap<Location, VariableSymbol>,
    all_locals: HashMap<NodeID, LocalTable>,
    local: Option<LocalTable>,
}

Maps global and local symbols to information about them.

Scopes are indexed by the NodeID of the function, block, or iteration.

Fields

functions: IndexMap<Location, FunctionSymbol>

Functions indexed by location.

records: IndexMap<Location, Composite>

Records indexed by location.

structs: IndexMap<Vec<Symbol>, Composite>

Structs indexed by a path.

global_consts: IndexMap<Location, Expression>

Consts that have been successfully evaluated.

globals: IndexMap<Location, VariableSymbol>

Global variables indexed by location.

all_locals: HashMap<NodeID, LocalTable>

Local tables index by the NodeID of the function, iteration, or block they’re contained in.

local: Option<LocalTable>

The current LocalTable we’re looking at.

Implementations

impl SymbolTable

pub fn reset_but_consts(&mut self)

Reset everything except leave global consts that have been evaluated.

pub fn global_scope(&self) -> bool

Are we currently in the global scope?

pub fn iter_structs(&self) -> impl Iterator<Item = (&Vec<Symbol>, &Composite)>

Iterator over all the structs (not records) in this program.

pub fn iter_records(&self) -> impl Iterator<Item = (&Location, &Composite)>

Iterator over all the records in this program.

pub fn iter_functions( &self, ) -> impl Iterator<Item = (&Location, &FunctionSymbol)>

Iterator over all the functions in this program.

pub fn lookup_struct(&self, path: &[Symbol]) -> Option<&Composite>

Access the struct by this name if it exists.

pub fn lookup_record(&self, location: &Location) -> Option<&Composite>

Access the record at this location if it exists.

pub fn lookup_function(&self, location: &Location) -> Option<&FunctionSymbol>

Access the function at this location if it exists.

pub fn lookup_path( &self, program: Symbol, path: &[Symbol], ) -> Option<VariableSymbol>

Attempts to look up a variable by a path.

First, it tries to resolve the symbol as a global using the full path under the given program. If that fails and the path is non-empty, it falls back to resolving the last component of the path as a local symbol.

Arguments

• program - The root symbol representing the program or module context.
• path - A slice of symbols representing the absolute path to the variable.

Returns

An Option<VariableSymbol> containing the resolved symbol if found, otherwise None.

pub fn lookup_local(&self, name: Symbol) -> Option<VariableSymbol>

Access the variable accessible by this name in the current scope.

pub fn enter_scope(&mut self, id: Option<NodeID>)

Enter the scope of this NodeID, creating a table if it doesn’t exist yet.

Passing None means to enter the global scope.

pub fn enter_scope_duped(&mut self, new_id: NodeID, old_id: NodeID)

Enter the new scope with id new_id, duplicating its local symbol table from the scope at old_id.

This is useful for a pass like loop unrolling, in which the loop body must be duplicated multiple times.

pub fn enter_parent(&mut self)

Enter the parent scope of the current scope (or the global scope if there is no local parent scope).

pub fn is_local_to(&self, scope: NodeID, symbol: Symbol) -> bool

Checks if a symbol is local to scope.

pub fn is_defined_in_scope_or_ancestor_until( &self, scope: NodeID, symbol: Symbol, ) -> bool

Checks whether symbol is defined in the current scope (self.local) or any of its ancestor scopes, up to and including scope.

Returns false if the current scope is not a descendant of scope.

pub fn is_local_to_or_in_child_scope( &self, scope: NodeID, symbol: Symbol, ) -> bool

Checks if a symbol is local to scope or any of its child scopes.

pub fn insert_const( &mut self, program: Symbol, path: &[Symbol], value: Expression, )

Insert an evaluated const into the current scope.

pub fn lookup_const( &self, program: Symbol, path: &[Symbol], ) -> Option<Expression>

Find the evaluated const accessible by the given name in the current scope.

pub fn insert_struct( &mut self, program: Symbol, path: &[Symbol], composite: Composite, ) -> Result<()>

Insert a struct at this name.

Since structs are indexed only by name, the program is used only to check shadowing.

pub fn insert_record( &mut self, location: Location, composite: Composite, ) -> Result<()>

Insert a record at this location.

pub fn insert_function( &mut self, location: Location, function: Function, ) -> Result<()>

Insert a function at this location.

pub fn insert_global( &mut self, location: Location, var: VariableSymbol, ) -> Result<()>

Insert a global at this location.

pub fn lookup_global(&self, location: &Location) -> Option<&VariableSymbol>

Access the global at this location if it exists.

fn check_shadow_global(&self, location: &Location, span: Span) -> Result<()>

fn check_shadow_variable( &self, program: Symbol, path: &[Symbol], span: Span, ) -> Result<()>

pub fn insert_variable( &mut self, program: Symbol, path: &[Symbol], var: VariableSymbol, ) -> Result<()>

Insert a variable into the current scope.

pub fn attach_finalizer( &mut self, caller: Location, callee: Location, future_inputs: Vec<Location>, inferred_inputs: Vec<Type>, ) -> Result<()>

Attach a finalizer to a function.

Trait Implementations

impl Debug for SymbolTable

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

Formats the value using the given formatter.

impl Default for SymbolTable

fn default() -> SymbolTable

Returns the “default value” for a type.