crates/compiler-core/generate.py (2)

18-21: 💤 Low value

Chain the re-raised exception (B904).

Inside the except KeyError clause, raise the new error with explicit chaining so traceback context is preserved (and to silence the Ruff B904 warning).

♻️ Proposed fix

 try:
     CPYTHON_ROOT = pathlib.Path(os.environ["CPYTHON_ROOT"]).expanduser().resolve()
-except KeyError:
-    raise ValueError("Missing environment variable 'CPYTHON_ROOT'")
+except KeyError as e:
+    raise ValueError("Missing environment variable 'CPYTHON_ROOT'") from e

As per coding guidelines: "Use ruff for linting Python code".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/compiler-core/generate.py` around lines 18 - 21, The except KeyError
block re-raises a new ValueError without exception chaining, triggering Ruff
B904; update the except to capture the original KeyError (e.g., except KeyError
as e) and re-raise the ValueError with explicit chaining using "from e" so the
traceback context for CPYTHON_ROOT resolution
(pathlib.Path(os.environ["CPYTHON_ROOT"]).expanduser().resolve()) is preserved.

---

462-470: 💤 Low value

Walrus binds oparg but the body never reads it (F841).

In fn_as_opcode, the walrus operator assigns oparg only to gate the arms += " { .. }" branch. Since the value isn't used, a plain containment check is clearer and avoids the dead binding flagged by Flake8.

♻️ Proposed fix

-        for instr in self:
-            name = instr.name
-            arms += f"Self::{name}"
-            if oparg := self.metadata.get(name, {}).get("oparg"):
-                arms += " { .. }"
-
-            arms += f"=> {self.opcode_enum}::{name},\n"
+        for instr in self:
+            name = instr.name
+            arms += f"Self::{name}"
+            if "oparg" in self.metadata.get(name, {}):
+                arms += " { .. }"
+
+            arms += f" => {self.opcode_enum}::{name},\n"

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/compiler-core/generate.py` around lines 462 - 470, The walrus in
fn_as_opcode assigns oparg but never uses it, triggering Flake8 F841; replace
the walrus check in the loop (where arms is built for each instr/name) with a
plain containment check against self.metadata for "oparg" (e.g., use if "oparg"
in self.metadata.get(name, {}) or if self.metadata.get(name, {}).get("oparg")
without assignment) so the branch that appends " { .. }" runs without creating
an unused binding.

crates/compiler-core/src/bytecode/instruction.rs (1)

480-498: 💤 Low value

AnyOpcode::deopt can be flattened slightly without losing const-ness.

The if let Some(_) { Some(_) } else { None } shape is forced because Option::map isn't usable in a const fn. That's fine, but a match is a touch shorter and matches the style used by neighbouring real/pseudo accessors above:

♻️ Proposed sketch

     #[must_use]
     pub const fn deopt(&self) -> Option<Self> {
         match self {
-            Self::Real(opcode) => {
-                if let Some(op) = opcode.deopt() {
-                    Some(Self::Real(op))
-                } else {
-                    None
-                }
-            }
-            Self::Pseudo(opcode) => {
-                if let Some(op) = opcode.deopt() {
-                    Some(Self::Pseudo(op))
-                } else {
-                    None
-                }
-            }
+            Self::Real(opcode) => match opcode.deopt() {
+                Some(op) => Some(Self::Real(op)),
+                None => None,
+            },
+            Self::Pseudo(opcode) => match opcode.deopt() {
+                Some(op) => Some(Self::Pseudo(op)),
+                None => None,
+            },
         }
     }

Same match-on-Option pattern is already used by Opcode::deoptimize at the top of this file, so this is also a consistency nit.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/compiler-core/src/bytecode/instruction.rs` around lines 480 - 498, The
AnyOpcode::deopt const fn can be simplified: inside each arm (Self::Real(opcode)
and Self::Pseudo(opcode)) replace the if-let Some/else None pattern with a match
on opcode.deopt() that returns Some(Self::Real(op)) / Some(Self::Pseudo(op)) or
None, preserving const fn and behavior and matching the style used by
Opcode::deoptimize and the nearby accessors.

crates/stdlib/src/_opcode.rs (1)

70-145: ⚡ Quick win

Please add direct _opcode regression coverage.

This changes Python-visible behavior for stack_effect() and the has_* helpers, but the tests below still only snapshot dis.dis. A few focused assertions for valid, invalid, and specialized opcodes would make future generator changes much safer.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/stdlib/src/_opcode.rs` around lines 70 - 145, Add direct unit tests
targeting the _opcode module: call the Python-exposed functions stack_effect
(with jump true/false/None), is_valid, has_arg, has_const, has_name, has_jump,
has_free, has_local, and has_exc to assert expected behavior for (1) a known
valid opcode (e.g., LOAD_CONST or POP_TOP) returns correct stack effects and
true for the corresponding has_* helpers, (2) an invalid opcode integer causes
is_valid False and stack_effect raises/returns the ValueError behavior observed
in the implementation, and (3) a specialized opcode (one whose deopt() is Some)
triggers the ValueError path in stack_effect; keep tests focused and small so
future opcode generator changes are caught without relying only on dis.dis
snapshots.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes