Method scan_annotation_inner

crates/codegen/src/symboltable.rs:1257–1308

(
        &mut self,
        annotation: &ast::Expr,
        is_ann_assign: bool,
    )

    }

    fn scan_annotation_inner(
        &mut self,
        annotation: &ast::Expr,
        is_ann_assign: bool,
    ) -> SymbolTableResult {
        let current_scope = self.tables.last().map(|t| t.typ);

        // PEP 649: Only AnnAssign annotations can be conditional.
        // Function parameter/return annotations are never conditional.
        if is_ann_assign && !self.future_annotations {
            let is_conditional = matches!(current_scope, Some(CompilerScope::Module))
                || (matches!(current_scope, Some(CompilerScope::Class))
                    && self.in_conditional_block);

            if is_conditional && !self.tables.last().unwrap().has_conditional_annotations {
                self.tables.last_mut().unwrap().has_conditional_annotations = true;
                self.register_name(
                    "__conditional_annotations__",
                    SymbolUsage::Assigned,
                    annotation.range(),
                )?;
                self.register_name(
                    "__conditional_annotations__",
                    SymbolUsage::Used,
                    annotation.range(),
                )?;
            }
        }

        // Create annotation scope for deferred evaluation
        let line_number = self.line_index_start(annotation.range());
        self.enter_annotation_scope(line_number);

        if self.future_annotations {
            // PEP 563: annotations are stringified at compile time
            // Don't scan expression - symbols would fail to resolve
            // Just create the annotation_block structure
            self.leave_annotation_scope();
            return Ok(());
        }

        // PEP 649: scan expression for symbol references
        // Class annotations are evaluated in class locals (not module globals)
        let was_in_annotation = self.in_annotation;
        self.in_annotation = true;
        let result = self.scan_expression(annotation, ExpressionContext::Load);
        self.in_annotation = was_in_annotation;

        self.leave_annotation_scope();

        result
    }

    fn scan_statement(&mut self, statement: &ast::Stmt) -> SymbolTableResult {
        use ast::*;