Method enter_scope

crates/codegen/src/compile.rs:1062–1266

Enter a new scope = compiler_enter_scope

(
        &mut self,
        name: &str,
        scope_type: CompilerScope,
        key: usize, // In RustPython, we use the index in symbol_table_stack as key
        lineno: u32,
    )

    /// Enter a new scope
    // = compiler_enter_scope
    fn enter_scope(
        &mut self,
        name: &str,
        scope_type: CompilerScope,
        key: usize, // In RustPython, we use the index in symbol_table_stack as key
        lineno: u32,
    ) -> CompileResult<()> {
        // Allocate a new compiler unit

        // In Rust, we'll create the structure directly
        let source_path = self.source_file.name().to_owned();

        // Lookup symbol table entry using key (_PySymtable_Lookup)
        let ste = match self.symbol_table_stack.get(key) {
            Some(v) => v,
            None => {
                return Err(self.error(CodegenErrorType::SyntaxError(
                    "unknown symbol table entry".to_owned(),
                )));
            }
        };

        // Use varnames from symbol table (already collected in definition order)
        let varname_cache: IndexSet<String> = ste.varnames.iter().cloned().collect();

        // Build cellvars using dictbytype (CELL scope or COMP_CELL flag, sorted)
        let mut cellvar_cache = IndexSet::default();
        // CPython ordering: parameter cells first (in parameter order),
        // then non-parameter cells (alphabetically sorted)
        let cell_symbols: Vec<_> = ste
            .symbols
            .iter()
            .filter(|(_, s)| {
                s.scope == SymbolScope::Cell || s.flags.contains(SymbolFlags::COMP_CELL)
            })
            .map(|(name, sym)| (name.clone(), sym.flags))
            .collect();
        let mut param_cells = Vec::new();
        let mut nonparam_cells = Vec::new();
        for (name, flags) in cell_symbols {
            if flags.contains(SymbolFlags::PARAMETER) {
                param_cells.push(name);
            } else {
                nonparam_cells.push(name);
            }
        }
        // param_cells are already in parameter order (from varname_cache insertion order)
        param_cells.sort_by_key(|n| varname_cache.get_index_of(n.as_str()).unwrap_or(usize::MAX));
        nonparam_cells.sort();
        for name in param_cells {
            cellvar_cache.insert(name);
        }
        for name in nonparam_cells {
            cellvar_cache.insert(name);
        }

        // Handle implicit __class__ cell if needed
        if ste.needs_class_closure {