Method scan_expression

crates/codegen/src/symboltable.rs:1754–2138

(
        &mut self,
        expression: &ast::Expr,
        context: ExpressionContext,
    )

    }

    fn scan_expression(
        &mut self,
        expression: &ast::Expr,
        context: ExpressionContext,
    ) -> SymbolTableResult {
        use ast::*;

        // Check for expressions not allowed in certain contexts
        // (type parameters, annotations, type aliases, TypeVar bounds/defaults)
        if let Some(keyword) = match expression {
            Expr::Yield(_) | Expr::YieldFrom(_) => Some("yield"),
            Expr::Await(_) => Some("await"),
            Expr::Named(_) => Some("named"),
            _ => None,
        } {
            // Determine the context name for the error message
            // scope_info takes precedence (e.g., "a TypeVar bound")
            let context_name = if let Some(scope_info) = self.scope_info {
                Some(scope_info)
            } else if let Some(table) = self.tables.last()
                && table.typ == CompilerScope::TypeParams
            {
                Some("a type parameter")
            } else if self.in_annotation {
                Some("an annotation")
            } else if self.in_type_alias {
                Some("a type alias")
            } else {
                None
            };

            if let Some(context_name) = context_name {
                return Err(SymbolTableError {
                    error: format!("{keyword} expression cannot be used within {context_name}"),
                    location: Some(
                        self.source_file
                            .to_source_code()
                            .source_location(expression.range().start(), PositionEncoding::Utf8),
                    ),
                });
            }
        }

        match expression {
            Expr::BinOp(ExprBinOp {
                left,
                right,
                range: _,
                ..
            }) => {
                self.scan_expression(left, context)?;
                self.scan_expression(right, context)?;
            }
            Expr::BoolOp(ExprBoolOp {
                values, range: _, ..
            }) => {
                self.scan_expressions(values, context)?;
            }