Method parse_lambda

compiler/src/modules/parser/expr.rs:387–431

lambda: fresh chunk, compiles body to Return, emits MakeFunction. */

(&mut self)

    /* lambda: fresh chunk, compiles body to Return, emits MakeFunction. */
    pub(super) fn parse_lambda(&mut self) {
        let mut params = Vec::new();
        let mut defaults = 0u16;
        if !matches!(self.peek(), Some(TokenType::Colon)) {
            loop {
                // Match parse_params prefix detection so *args/**kw names align with ParamKind.
                let prefix = if self.eat_if(TokenType::DoubleStar) { "**" }
                    else if self.eat_if(TokenType::Star) { "*"  }
                    else { "" };
                let nm = self.advance_text();
                params.push(if prefix.is_empty() { nm } else { s!(str prefix, str &nm) });
                if prefix.is_empty() && self.eat_if(TokenType::Equal) {
                    self.expr();
                    defaults += 1;
                    // Trailing `=` marks this param as carrying a default value.
                    if let Some(last) = params.last_mut() { last.push('='); }
                }
                if !self.eat_if(TokenType::Comma) {
                    break;
                }
            }
        }
        self.eat(TokenType::Colon);

        let outer_versions = self.ssa_versions.clone();

        let body = self.with_fresh_chunk(|s| {
            s.ssa_versions = outer_versions;
            // Base name shadows the enclosing scope; prefix/`=` marker must be stripped.
            for p in &params { s.ssa_versions.insert(super::types::param_base_name(p).to_string(), 0); }
            s.expr();
            s.chunk.emit(OpCode::ReturnValue, 0);
        });

        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;
        self.chunk.functions.push((params, body, defaults, u16::MAX));
        self.chunk.emit(OpCode::MakeFunction, fi);
    }
}