Method compile_annotations_closure

crates/codegen/src/compile.rs:4165–4232

Compile function annotations as a closure (PEP 649) Returns true if an __annotate__ closure was created Uses symbol table's annotation_block for proper scoping.

(
        &mut self,
        func_name: &str,
        parameters: &ast::Parameters,
        returns: Option<&ast::Expr>,
    )

    /// Returns true if an __annotate__ closure was created
    /// Uses symbol table's annotation_block for proper scoping.
    fn compile_annotations_closure(
        &mut self,
        func_name: &str,
        parameters: &ast::Parameters,
        returns: Option<&ast::Expr>,
    ) -> CompileResult<bool> {
        // Try to enter annotation scope - returns None if no annotation_block exists
        let Some(saved_ctx) = self.enter_annotation_scope(func_name)? else {
            return Ok(false);
        };

        // Count annotations
        let parameters_iter = core::iter::empty()
            .chain(&parameters.posonlyargs)
            .chain(&parameters.args)
            .chain(&parameters.kwonlyargs)
            .map(|x| &x.parameter)
            .chain(parameters.vararg.as_deref())
            .chain(parameters.kwarg.as_deref());

        let num_annotations: u32 =
            u32::try_from(parameters_iter.filter(|p| p.annotation.is_some()).count())
                .expect("too many annotations")
                + if returns.is_some() { 1 } else { 0 };

        // Compile annotations inside the annotation scope
        let parameters_iter = core::iter::empty()
            .chain(&parameters.posonlyargs)
            .chain(&parameters.args)
            .chain(&parameters.kwonlyargs)
            .map(|x| &x.parameter)
            .chain(parameters.vararg.as_deref())
            .chain(parameters.kwarg.as_deref());

        for param in parameters_iter {
            if let Some(annotation) = &param.annotation {
                self.emit_load_const(ConstantData::Str {
                    value: self.mangle(param.name.as_str()).into_owned().into(),
                });
                self.compile_annotation(annotation)?;
            }
        }

        // Handle return annotation
        if let Some(annotation) = returns {
            self.emit_load_const(ConstantData::Str {
                value: "return".into(),
            });
            self.compile_annotation(annotation)?;
        }

        // Build the map and return it
        emit!(
            self,
            Instruction::BuildMap {
                count: num_annotations,
            }
        );