RustPython
diff --git a/‎Cargo.lock‎
Lines changed: 0 additions & 1 deletion b/‎Cargo.lock‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎crates/codegen/src/compile.rs‎
Lines changed: 12 additions & 9 deletions b/‎crates/codegen/src/compile.rs‎
Lines changed: 12 additions & 9 deletions
diff --git a/‎crates/compiler-core/Cargo.toml‎
Lines changed: 0 additions & 1 deletion b/‎crates/compiler-core/Cargo.toml‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎crates/compiler-core/src/bytecode.rs‎
Lines changed: 2 additions & 2 deletions b/‎crates/compiler-core/src/bytecode.rs‎
Lines changed: 2 additions & 2 deletions
@@ -1165,7 +1165,7 @@ impl Compiler {
                 arg: OpArgMarker::marker(),
             }
             .into(),
-            arg: OpArg(bytecode::ResumeType::AtFuncStart as u32),
+            arg: OpArg(u32::from(bytecode::ResumeType::AtFuncStart)),
             target: BlockIdx::NULL,
             location,
             end_location,
@@ -1267,16 +1267,19 @@ impl Compiler {
     /// Emit format parameter validation for annotation scope
     /// if format > VALUE_WITH_FAKE_GLOBALS (2): raise NotImplementedError
     fn emit_format_validation(&mut self) -> CompileResult<()> {
-        use bytecode::ComparisonOperator::Greater;
-
         // Load format parameter (first local variable, index 0)
         emit!(self, Instruction::LoadFast(0));
 
         // Load VALUE_WITH_FAKE_GLOBALS constant (2)
         self.emit_load_const(ConstantData::Integer { value: 2.into() });
 
         // Compare: format > 2
-        emit!(self, Instruction::CompareOp { op: Greater });
+        emit!(
+            self,
+            Instruction::CompareOp {
+                op: ComparisonOperator::Greater
+            }
+        );
 
         // Jump to body if format <= 2 (comparison is false)
         let body_block = self.new_block();
@@ -6545,9 +6548,9 @@ impl Compiler {
             self,
             Instruction::Resume {
                 arg: if is_await {
-                    bytecode::ResumeType::AfterAwait as u32
+                    u32::from(bytecode::ResumeType::AfterAwait)
                 } else {
-                    bytecode::ResumeType::AfterYieldFrom as u32
+                    u32::from(bytecode::ResumeType::AfterYieldFrom)
                 }
             }
         );
@@ -6702,7 +6705,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterYield as u32
+                        arg: u32::from(bytecode::ResumeType::AfterYield)
                     }
                 );
             }
@@ -6924,7 +6927,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::Resume {
-                                arg: bytecode::ResumeType::AfterYield as u32
+                                arg: u32::from(bytecode::ResumeType::AfterYield)
                             }
                         );
                         emit!(compiler, Instruction::PopTop);
@@ -8412,7 +8415,7 @@ impl Compiler {
 
                     // Emit BUILD_INTERPOLATION
                     // oparg encoding: (conversion << 2) | has_format_spec
-                    let oparg = (conversion << 2) | (has_format_spec as u32);
+                    let oparg = (conversion << 2) | u32::from(has_format_spec);
                     emit!(self, Instruction::BuildInterpolation { oparg });
 
                     *interp_count += 1;
 
@@ -17,7 +17,6 @@ bitflags = { workspace = true }
 itertools = { workspace = true }
 malachite-bigint = { workspace = true }
 num-complex = { workspace = true }
-num_enum = { workspace = true }
 
 lz4_flex = "0.12"
 
 
@@ -304,8 +304,8 @@ bitflags! {
     }
 }
 
-#[derive(Copy, Clone)]
 #[repr(C)]
+#[derive(Copy, Clone, Debug)]
 pub struct CodeUnit {
     pub op: Instruction,
     pub arg: OpArgByte,
@@ -330,7 +330,7 @@ impl TryFrom<&[u8]> for CodeUnit {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct CodeUnits(Box<[CodeUnit]>);
 
 impl TryFrom<&[u8]> for CodeUnits {
Original file line number	Diff line number	Diff line change
`@@ -304,8 +304,8 @@ bitflags! {`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`307`		`-#[derive(Copy, Clone)]`
`308`	`307`	`#[repr(C)]`
	`308`	`+#[derive(Copy, Clone, Debug)]`
`309`	`309`	`pub struct CodeUnit {`
`310`	`310`	`pub op: Instruction,`
`311`	`311`	`pub arg: OpArgByte,`
`@@ -330,7 +330,7 @@ impl TryFrom<&[u8]> for CodeUnit {`
`330`	`330`	`}`
`331`	`331`	`}`
`332`	`332`
`333`		`-#[derive(Clone)]`
	`333`	`+#[derive(Clone, Debug)]`
`334`	`334`	`pub struct CodeUnits(Box<[CodeUnit]>);`
`335`	`335`
`336`	`336`	`impl TryFrom<&[u8]> for CodeUnits {`