crates/codegen/src/ir.rs (1)

783-789: Tightened LOAD_SMALL_INT range is correct; consider clarifying the nearby comment.

Lines 783-784 correctly constrain encoding to 0..=255 for unsigned oparg. Optional nit: the comment at Line 787 still references two’s-complement/i32 semantics, which can be read as supporting negative values.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/ir.rs` around lines 783 - 789, The comment next to the
LOAD_SMALL_INT conversion is misleading about signed two's-complement semantics;
update the comment near the block that checks value.to_i32() and sets
instr.instr = Instruction::LoadSmallInt { i: Arg::marker() } and instr.arg =
OpArg::new(small as u32) to explicitly state that the oparg is an unsigned u32
in the range 0..=255 and that the i32 is being used only to check range before
casting to u32 (remove wording implying negative/two's-complement encoding).

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

6906-6917: Avoid duplicate constant-literal classifiers

This helper duplicates ExprExt::is_constant (Lines 50-60). Keeping both implementations in sync is error-prone; prefer reusing the trait method.

Suggested refactor

     /// Returns true if the expression is a constant with no side effects.
     fn is_const_expression(expr: &ast::Expr) -> bool {
-        matches!(
-            expr,
-            ast::Expr::StringLiteral(_)
-                | ast::Expr::BytesLiteral(_)
-                | ast::Expr::NumberLiteral(_)
-                | ast::Expr::BooleanLiteral(_)
-                | ast::Expr::NoneLiteral(_)
-                | ast::Expr::EllipsisLiteral(_)
-        )
+        expr.is_constant()
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/compile.rs` around lines 6906 - 6917, The
is_const_expression helper duplicates existing logic in the ExprExt trait;
remove or replace its body to call the shared implementation instead of
reimplementing the match. Specifically, in the is_const_expression function use
ExprExt::is_constant (or call expr.is_constant() if the trait is in scope) so
the code delegates to the trait method rather than repeating the literal-match
logic; keep the function signature (fn is_const_expression(expr: &ast::Expr) ->
bool) so callers need no changes.

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

1084-1090: ⚠️ Potential issue | 🟠 Major

CodeFlags::NESTED is still computed too broadly.

self.code_stack.len() > 1 marks scopes under synthetic parents (e.g. <generic parameters of ...>) as nested, even when the effective parent is module scope.

Suggested fix

-        let flags = if self.code_stack.len() > 1 {
+        let is_nested = self
+            .code_stack
+            .iter()
+            .rev()
+            .skip(1)
+            .find(|parent| !parent.metadata.name.starts_with("<generic parameters of "))
+            .is_some_and(|parent| parent.metadata.name != "<module>");
+
+        let flags = if is_nested {
             flags | bytecode::CodeFlags::NESTED
         } else {
             flags
         };

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/compile.rs` around lines 1084 - 1090, The NESTED flag is
being set whenever self.code_stack.len() > 1 which incorrectly marks scopes
whose immediate parent is a synthetic container (e.g., "<generic parameters of
...>") as nested; change the logic that sets bytecode::CodeFlags::NESTED to
inspect the actual parent code object on self.code_stack (e.g., let parent =
self.code_stack.last().unwrap()) and only set CodeFlags::NESTED when that parent
represents a real non-module scope (i.e., not a module-level scope and not
synthetic generic-params/placeholder parents); update the condition around flags
|= bytecode::CodeFlags::NESTED to check parent.kind / parent.is_module() /
parent.is_synthetic() (or equivalent fields on the stack item) so
module-equivalent parents do not cause the NESTED flag to be set.

---

2193-2210: ⚠️ Potential issue | 🟠 Major

Interactive auto-print should only run at true module top level.

The current guard still triggers inside nested module-level blocks (if/try/with) in REPL mode.

Suggested fix

-                let dominated_by_interactive =
-                    self.interactive && !self.ctx.in_func() && !self.ctx.in_class;
+                let at_module_top_level = self.current_code_info().in_conditional_block == 0;
+                let dominated_by_interactive = self.interactive
+                    && !self.ctx.in_func()
+                    && !self.ctx.in_class
+                    && at_module_top_level;

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/compile.rs` around lines 2193 - 2210, The interactive
auto-print gate currently uses dominated_by_interactive = self.interactive &&
!self.ctx.in_func() && !self.ctx.in_class, which still fires inside nested
module-level blocks; change the condition to require true module top-level by
also ensuring the parser's module-block nesting is zero (e.g. &&
self.ctx.block_nesting == 0 or an equivalent accessor like
self.ctx.in_module_top_level()), so update the dominated_by_interactive
calculation and, if needed, add/derive the ctx.block_nesting/in_module_top_level
helper to make the check explicit before emitting the Print intrinsic in
compile_expression handling.

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

6906-6917: Prefer reusing ExprExt::is_constant to avoid duplicated predicates.

This helper duplicates the literal-const check already defined on ast::Expr, which can drift over time.

Refactor suggestion

     fn is_const_expression(expr: &ast::Expr) -> bool {
-        matches!(
-            expr,
-            ast::Expr::StringLiteral(_)
-                | ast::Expr::BytesLiteral(_)
-                | ast::Expr::NumberLiteral(_)
-                | ast::Expr::BooleanLiteral(_)
-                | ast::Expr::NoneLiteral(_)
-                | ast::Expr::EllipsisLiteral(_)
-        )
+        expr.is_constant()
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/codegen/src/compile.rs` around lines 6906 - 6917, The helper
is_const_expression duplicates the literal-const predicate; replace its body to
delegate to the existing extension method by calling ExprExt::is_constant (or
expr.is_constant() if the trait is in scope) instead of matching literals, or
remove the helper and update callers to use ExprExt::is_constant directly;
target the function named is_const_expression and references to ast::Expr to
make this change.