match num_typeparam_args {

1 => {

// Stack: [arg1, closure]

emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]

emit!(self, Instruction::PushNull); // [closure, arg1, NULL]

emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]

2 => {

// Stack: [arg1, arg2, closure]

emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]

emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]

emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]

emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]

emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]

}

_ => unreachable!("only defaults and kwdefaults are supported"),

}

// Compile bases and call __build_class__

// Check for starred bases or **kwargs

let has_starred = arguments

.is_some_and(|args| args.args.iter().any(|arg| matches!(arg, Expr::Starred(_))));

let has_double_star =

arguments.is_some_and(|args| args.keywords.iter().any(|kw| kw.arg.is_none()));

if has_starred || has_double_star {

// Use CallFunctionEx for *bases or **kwargs

// Stack has: [__build_class__, NULL, class_func, name]

// Need to build: args tuple = (class_func, name, *bases, .generic_base)

// Compile bases with gather_elements (handles starred)

let (size, unpack) = if let Some(arguments) = arguments {

self.gather_elements(2, &arguments.args)? // 2 = class_func + name already on stack

} else {

// Just class_func and name (no bases)

(2, false)

};

// Add .generic_base as final base

emit!(self, Instruction::LoadName(dot_generic_base));

// Build args tuple

if unpack {

// Starred: gather_elements produced tuples on stack

emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)

emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });

} else {

// No starred: individual elements on stack

// size includes class_func + name + bases count, +1 for .generic_base

emit!(self, Instruction::BuildTuple { size: size + 1 });

}

// Build kwargs if needed

let has_kwargs = arguments.is_some_and(|args| !args.keywords.is_empty());

if has_kwargs {

self.compile_keywords(&arguments.unwrap().keywords)?;

emit!(self, Instruction::CallFunctionEx { has_kwargs });

// Simple case: no starred bases, no **kwargs

// Compile bases normally

let base_count = if let Some(arguments) = arguments {

for arg in &arguments.args {

self.compile_expression(arg)?;

}

arguments.args.len()

} else {

0

};

// Load .generic_base as the last base

emit!(self, Instruction::LoadName(dot_generic_base));

let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;

// Handle keyword arguments (no **kwargs here)

if let Some(arguments) = arguments

&& !arguments.keywords.is_empty()

{

let mut kwarg_names = vec![];

for keyword in &arguments.keywords {

let name = keyword.arg.as_ref().expect(

"keyword argument name must be set (no **kwargs in this branch)",

);

kwarg_names.push(ConstantData::Str {

value: name.as_str().into(),

});

self.compile_expression(&keyword.value)?;

}

self.emit_load_const(ConstantData::Tuple {

elements: kwarg_names,

emit!(

self,

Instruction::CallKw {

nargs: nargs

+ u32::try_from(arguments.keywords.len())

.expect("too many keyword arguments")

}

);

} else {

emit!(self, Instruction::Call { nargs });