compiler/codegen/src/compile.rs (2)

4040-4062: Use qualified name for lambda closures.

The lambda compilation is passing the simple name "<lambda>" instead of using the qualified name that was already set.

Store and use the qualified name:

 let name = "<lambda>".to_owned();
 let func_flags = self
     .enter_function(&name, parameters.as_deref().unwrap_or(&Default::default()))?;
 
 // Set qualname for lambda
-self.set_qualname();
+let qualname = self.set_qualname();
 
 self.ctx = CompileContext {
     loop_data: Option::None,
     in_class: prev_ctx.in_class,
     func: FunctionContext::Function,
 };
 
 self.current_code_info()
     .metadata
     .consts
     .insert_full(ConstantData::None);
 
 self.compile_expression(body)?;
 self.emit_return_value();
 let code = self.exit_scope();
 
 // Create lambda function with closure
-self.make_closure(code, &name, func_flags)?;
+self.make_closure(code, &qualname, func_flags)?;

---

4512-4607: Use qualified name for comprehension closures.

The comprehension is passing the simple name instead of the qualified name.

 // Set qualname for comprehension
-self.set_qualname();
+let qualname = self.set_qualname();
 
 // ... rest of comprehension compilation ...
 
 // Create comprehension function with closure
-self.make_closure(code, &name, bytecode::MakeFunctionFlags::empty())?;
+self.make_closure(code, &qualname, bytecode::MakeFunctionFlags::empty())?;

compiler/codegen/src/compile.rs (2)

1996-1996: Simplify the iterator by removing unnecessary dereferencing.

The &* dereferencing is unnecessary here.

-        for var in &*code.freevars {
+        for var in &code.freevars {

---

2034-2037: Avoid unnecessary variable shadowing.

The mutable variable shadowing is unnecessary here. You can modify the existing binding directly.

-            let mut idx = idx;
-            if let SymbolScope::Free = symbol.scope {
+            let idx = if let SymbolScope::Free = symbol.scope {
-                idx += parent_code.metadata.cellvars.len();
+                idx + parent_code.metadata.cellvars.len()
+            } else {
+                idx
-            }
+            };

Configuration used: .coderabbit.yml
Review profile: CHILL
Plan: Pro

compiler/codegen/src/compile.rs (1)

2263-2264: Use qualified name instead of simple name for class closures.

The make_closure calls for class definitions are passing the simple class name instead of the qualified name. This is inconsistent with how functions handle it and could lead to incorrect qualified names in the bytecode.

Consider modifying compile_class_body to return both the code object and the qualified name, then use the qualified name in the make_closure calls.

Also applies to: 2324-2325

compiler/codegen/src/compile.rs (2)

4041-4041: Capture and use the qualified name for lambda closures.

The lambda compilation sets the qualified name but doesn't capture it. Consider storing the result of self.set_qualname() and passing it to make_closure for consistency:

-// Set qualname for lambda
-self.set_qualname();
+// Set qualname for lambda
+let qualname = self.set_qualname();

Then use it in the make_closure call:

-self.make_closure(code, &name, func_flags)?;
+self.make_closure(code, &qualname, func_flags)?;

Also applies to: 4058-4059

---

4510-4510: Capture and use the qualified name for comprehension closures.

Similar to lambdas, comprehensions compute but don't use their qualified names. Consider capturing and using the qualified name:

-// Set qualname for comprehension
-self.set_qualname();
+// Set qualname for comprehension
+let qualname = self.set_qualname();

Then use it in the make_closure call:

-self.make_closure(code, name, bytecode::MakeFunctionFlags::empty())?;
+self.make_closure(code, &qualname, bytecode::MakeFunctionFlags::empty())?;

Also applies to: 4603-4604

Configuration used: .coderabbit.yml
Review profile: CHILL
Plan: Pro