Method collect_simple_annotations

crates/codegen/src/compile.rs:4238–4297

Collect simple annotations from module body in AST order (including nested blocks) Returns list of (name, annotation_expr) pairs This must match the order that annotations are compiled to ensure conditional_annotation_index stays in sync with __annotate__ enumeration.

(body: &[ast::Stmt])

    /// This must match the order that annotations are compiled to ensure
    /// conditional_annotation_index stays in sync with __annotate__ enumeration.
    fn collect_simple_annotations(body: &[ast::Stmt]) -> Vec<(&str, &ast::Expr)> {
        fn walk<'a>(stmts: &'a [ast::Stmt], out: &mut Vec<(&'a str, &'a ast::Expr)>) {
            for stmt in stmts {
                match stmt {
                    ast::Stmt::AnnAssign(ast::StmtAnnAssign {
                        target,
                        annotation,
                        simple,
                        ..
                    }) if *simple && matches!(target.as_ref(), ast::Expr::Name(_)) => {
                        if let ast::Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
                            out.push((id.as_str(), annotation.as_ref()));
                        }
                    }
                    ast::Stmt::If(ast::StmtIf {
                        body,
                        elif_else_clauses,
                        ..
                    }) => {
                        walk(body, out);
                        for clause in elif_else_clauses {
                            walk(&clause.body, out);
                        }
                    }
                    ast::Stmt::For(ast::StmtFor { body, orelse, .. })
                    | ast::Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
                        walk(body, out);
                        walk(orelse, out);
                    }
                    ast::Stmt::With(ast::StmtWith { body, .. }) => walk(body, out),
                    ast::Stmt::Try(ast::StmtTry {
                        body,
                        handlers,
                        orelse,
                        finalbody,
                        ..
                    }) => {
                        walk(body, out);
                        for handler in handlers {
                            let ast::ExceptHandler::ExceptHandler(
                                ast::ExceptHandlerExceptHandler { body, .. },
                            ) = handler;
                            walk(body, out);
                        }
                        walk(orelse, out);
                        walk(finalbody, out);
                    }
                    ast::Stmt::Match(ast::StmtMatch { cases, .. }) => {
                        for case in cases {
                            walk(&case.body, out);
                        }
                    }
                    _ => {}
                }
            }
        }
        let mut annotations = Vec::new();
        walk(body, &mut annotations);