Struct SymbolTableScopes

pub struct SymbolTableScopes(/* private fields */);

A stack of symbol tables of different scopes. Topmost is the current scope.

Implementations

impl SymbolTableScopes

pub fn new() -> Self

Examples found in repository

examples/async_runtime_example.rs (line 50)

fn generate_and_display(python_code: &str, options: PythonOptions) {
    match parse_enhanced(python_code, "example.py") {
        Ok(ast) => {
            let ctx = CodeGenContext::Module("example".to_string());
            let symbols = SymbolTableScopes::new();
            
            match ast.to_rust(ctx, options, symbols) {
                Ok(tokens) => {
                    let code_str = tokens.to_string();
                    
                    // Pretty print key parts
                    println!("Generated Rust code:");
                    
                    // Extract imports
                    let parts: Vec<&str> = code_str.split(" ; ").collect();
                    for part in &parts {
                        if part.starts_with("use ") {
                            println!("  {}", part.trim());
                        }
                    }
                    
                    // Find main function
                    if let Some(main_start) = code_str.find("# [") {
                        if let Some(main_end) = code_str[main_start..].find("async fn main") {
                            if let Some(brace) = code_str[main_start + main_end..].find(" {") {
                                let main_signature = &code_str[main_start..main_start + main_end + brace + 2];
                                println!("  {}", main_signature.trim());
                                println!("    // ... main function body ...");
                                println!("  }}");
                            }
                        }
                    }
                }
                Err(e) => {
                    println!("❌ Code generation failed: {}", e);
                }
            }
        },
        Err(e) => {
            println!("❌ AST parsing failed: {}", e);
        }
    }
}

pub fn push(&mut self, table: SymbolTable)

pub fn pop(&mut self) -> Option<SymbolTable>

pub fn new_scope(&mut self)

pub fn insert(&mut self, key: String, value: SymbolTableNode)

pub fn get(&self, key: &str) -> Option<&SymbolTableNode>

Trait Implementations

impl Clone for SymbolTableScopes

fn clone(&self) -> SymbolTableScopes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolTableScopes

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

Formats the value using the given formatter.

impl Default for SymbolTableScopes

fn default() -> Self

Returns the “default value” for a type.