Method func_def_inner

compiler/src/modules/parser/literals.rs:524–558

def/async def: parses signature, compiles body, emits MakeFunction/MakeCoroutine+decorators+StoreName. */

(&mut self, decorators: u16, is_async: bool)

    /* def/async def: parses signature, compiles body, emits MakeFunction/MakeCoroutine+decorators+StoreName. */
    pub(super) fn func_def_inner(&mut self, decorators: u16, is_async: bool) {
        // Missing name: non-syncing diagnostic + synthetic name so signature+body still parse.
        let fname = if matches!(self.peek(), Some(TokenType::Name)) {
            self.advance_text()
        } else {
            self.diag_at_peek("expected function name");
            "<missing>".to_string()
        };
        let (params, defaults) = self.parse_params();
        let body = self.compile_body(&params);

        // Propagate free names to parent chunk so nested defs capture grandparent vars.
        let param_slots: crate::util::fx::FxHashSet<String> = params.iter()
            .map(|p| s!(str super::types::param_base_name(p), "_0")).collect();
        for name in &body.names {
            if !param_slots.contains(name.as_str()) {
                self.chunk.push_name(name);
            }
        }

        let fi = self.chunk.functions.len() as u16;
        let name_slot = self.push_ssa_name(&fname, self.current_version(&fname) + 1);
        self.chunk.functions.push((params, body, defaults, name_slot));
        self.chunk.emit(if is_async { OpCode::MakeCoroutine } else { OpCode::MakeFunction }, fi);

        for _ in 0..decorators {
            let pos = self.last_end as u32;
            self.chunk.emit(OpCode::Call, 1);
            self.chunk.record_call_pos(pos);
        }

        let ver = self.increment_version(&fname);
        let i = self.push_ssa_name(&fname, ver);
        self.chunk.emit(OpCode::StoreName, i);
    }

    pub(super) fn parse_params(&mut self) -> (Vec<String>, u16) {
        // No `(`: diagnostic, consume `:` so compile_body starts at Indent correctly.