Struct SymbolTable 

pub struct SymbolTable {

    pub name: Name,
    pub typ: CompilerScope,
    pub line_number: u32,
    pub block_index: usize,
    pub is_nested: bool,
    pub is_method: bool,
    pub symbols: IndexMap<Name, Symbol, RandomState<rapidhash::::quality::RandomState::{constant#0}, rapidhash::::quality::RandomState::{constant#1}, rapidhash::::quality::RandomState::{constant#2}, rapidhash::::quality::RandomState::{constant#3}>>,
    pub sub_tables: Vec<SymbolTable>,
    pub hidden_annotation_blocks: Vec<SymbolTable>,
    pub next_hidden_annotation_block: usize,
    pub inlined_comprehension_blocks: Vec<SymbolTable>,
    pub next_inlined_comprehension_block: usize,
    pub next_sub_table: usize,
    pub varnames: Vec<Name>,
    pub needs_class_closure: bool,
    pub needs_classdict: bool,
    pub can_see_class_scope: bool,
    pub is_generator: bool,
    pub is_coroutine: bool,
    pub returns_value: bool,
    pub annotations_used: bool,
    pub scope_info: Option<&'static str>,
    pub in_unevaluated_annotation: bool,
    pub comp_inlined: bool,
    pub annotation_block: Option<Box<SymbolTable>>,
    pub skip_enclosing_function_scope: bool,
    pub has_conditional_annotations: bool,
    pub future_annotations: bool,
    pub mangled_names: Option<IndexSet<Name, RandomState<rapidhash::::quality::RandomState::{constant#0}, rapidhash::::quality::RandomState::{constant#1}, rapidhash::::quality::RandomState::{constant#2}, rapidhash::::quality::RandomState::{constant#3}>>>,
}

Captures all symbols in the current scope, and has a list of sub-scopes in this scope.

Fields

name: Name

The name of this symbol table. Often the name of the class or function.

typ: CompilerScope

The type of symbol table

line_number: u32

The line number in the source code where this symboltable begins.

block_index: usize

Monotonic creation order used by public symtable children.

is_nested: bool

is_method: bool

Whether this function-like scope was created directly in a class block.

symbols: IndexMap<Name, Symbol, RandomState<rapidhash::::quality::RandomState::{constant#0}, rapidhash::::quality::RandomState::{constant#1}, rapidhash::::quality::RandomState::{constant#2}, rapidhash::::quality::RandomState::{constant#3}>>

A set of symbols present on this scope level.

sub_tables: Vec<SymbolTable>

A list of sub-scopes in the order as found in the AST nodes.

hidden_annotation_blocks: Vec<SymbolTable>

Annotation scopes registered in st_blocks but not added to ste_children, e.g. future-annotation function signatures.

next_hidden_annotation_block: usize

Cursor pointing to the next hidden annotation block to consume.

inlined_comprehension_blocks: Vec<SymbolTable>

Inlined comprehension scopes removed from ste_children but can still find through st_blocks keyed by the comprehension expression.

next_inlined_comprehension_block: usize

Cursor pointing to the next inlined comprehension block to consume.

next_sub_table: usize

Cursor pointing to the next sub-table to consume during compilation.

varnames: Vec<Name>

Variable names in definition order (parameters first, then locals)

needs_class_closure: bool

Whether this class scope needs an implicit class cell

needs_classdict: bool

Whether this class scope needs an implicit classdict cell

can_see_class_scope: bool

Whether this type param scope can see the parent class scope

is_generator: bool

Whether this scope contains yield/yield from (is a generator function)

is_coroutine: bool

Whether this scope contains await or async comprehension machinery.

returns_value: bool

Whether this scope contains a return statement with a value.

annotations_used: bool

Whether this block visited at least one annotation expression.

scope_info: Option<&'static str>

Optional description of the current type-variable evaluator context.

in_unevaluated_annotation: bool

Whether this annotation block is currently visiting an unevaluated function-local annotation.

comp_inlined: bool

Whether this comprehension scope should be inlined (PEP 709) True for list/set/dict comprehensions in non-generator expressions

annotation_block: Option<Box<SymbolTable>>

PEP 649: Reference to annotation scope for this block Annotations are compiled as a separate __annotate__ function

skip_enclosing_function_scope: bool

True only for deferred function/class/module annotation scopes that should resolve outer names as if they were siblings of the owning function body, matching PEP 649 lookup rules.

has_conditional_annotations: bool

PEP 649: Whether this scope has conditional annotations (annotations inside if/for/while/etc. blocks or at module level)

future_annotations: bool

Whether from __future__ import annotations is active

mangled_names: Option<IndexSet<Name, RandomState<rapidhash::::quality::RandomState::{constant#0}, rapidhash::::quality::RandomState::{constant#1}, rapidhash::::quality::RandomState::{constant#2}, rapidhash::::quality::RandomState::{constant#3}>>>

Names of type parameters that should still be mangled in type param scopes. When Some, only names in this set are mangled; other names are left unmangled. Set on type param blocks for generic classes; inherited by non-class child scopes.

Implementations

impl SymbolTable

pub fn scan_program( program: &ModModule, source_file: SourceFile, ) -> Result<SymbolTable, SymbolTableError>

pub fn scan_program_with_options( program: &ModModule, source_file: SourceFile, allow_top_level_await: bool, future_annotations: bool, recursion_limit: usize, ) -> Result<SymbolTable, SymbolTableError>

pub fn scan_expr( expr: &ModExpression, source_file: SourceFile, ) -> Result<SymbolTable, SymbolTableError>

pub fn scan_expr_with_options( expr: &ModExpression, source_file: SourceFile, allow_top_level_await: bool, future_annotations: bool, recursion_limit: usize, ) -> Result<SymbolTable, SymbolTableError>

pub fn lookup(&self, name: &Name) -> Option<&Symbol>

Trait Implementations

impl Clone for SymbolTable

fn clone(&self) -> SymbolTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolTable

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

Formats the value using the given formatter.