More things to compile

youknowone · May 10, 2026 · May 5, 2026 · May 5, 2026 · May 5, 2026 · May 5, 2026
commit 99ba1db4510a1fa15dc6b95c6922c39ced608580
diff --git a/crates/compiler-core/generate.py b/crates/compiler-core/generate.py
@@ -28,6 +28,8 @@
 from generators_common import DEFAULT_INPUT
 from stack import get_stack_effect
 
+STATE = collections.defaultdict(dict)
+
 
 @dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
 class OpcodeGen:
@@ -79,11 +81,11 @@ def fn_as_numeric(self) -> str:
         """
 
     @property
-    def fn_tryfrom_numeric(self) -> str:
+    def fn_try_from_numeric(self) -> str:
         arms = ",\n".join(f"{instr.opcode} => Self::{instr.name}" for instr in self)
         return f"""
         #[must_use]
-        pub const fn from_{self.numeric_repr}(
+        pub const fn try_from_{self.numeric_repr}(
             value: {self.numeric_repr}
         ) -> Result<Self, MarshalError> {{
             Ok(match value {{
@@ -94,13 +96,13 @@ def fn_tryfrom_numeric(self) -> str:
         """
 
     @property
-    def impl_tryfrom_numeric(self) -> str:
+    def impl_try_from_numeric(self) -> str:
         return f"""
         impl TryFrom<{self.numeric_repr}> for {self.name} {{
             type Error = MarshalError;
 
             fn try_from(value: {self.numeric_repr}) -> Result<Self, Self::Error> {{
-                Self::from_{self.numeric_repr}(value)
+                Self::try_from_{self.numeric_repr}(value)
             }}
         }}
         """
@@ -169,6 +171,8 @@ def instrumented(self) -> list:
 
     @property
     def fn_to_base(self) -> str:
+        STATE[self.name]["to_base"] = True
+
         inames = {instr.name for instr in self.instrumented}
         names = {instr.name for instr in self} - inames
 
@@ -181,6 +185,7 @@ def fn_to_base(self) -> str:
 
         arms = arms.strip()
         if not arms:
+            STATE[self.name]["to_base"] = False
             return ""
 
         return f"""
@@ -223,6 +228,8 @@ def fn_to_instrumented(self) -> str:
 
     @property
     def fn_deopt(self) -> str:
+        STATE[self.name]["deopt"] = True
+
         names = {instr.name for instr in self}
 
         deopts = collections.defaultdict(list)
@@ -244,6 +251,7 @@ def fn_deopt(self) -> str:
 
         arms = arms.strip()
         if not arms:
+            STATE[self.name]["deopt"] = False
             return ""
 
         return f"""
@@ -258,6 +266,8 @@ def fn_deopt(self) -> str:
 
     @property
     def fn_cache_entries(self) -> str:
+        STATE[self.name]["cache_entries"] = True
+
         arms = ""
         for instr in self:
             name = instr.name
@@ -277,6 +287,7 @@ def fn_cache_entries(self) -> str:
 
         arms = arms.strip()
         if not arms:
+            STATE[self.name]["cache_entries"] = False
             return ""
 
         return f"""
@@ -290,7 +301,7 @@ def fn_cache_entries(self) -> str:
         """
 
     @property
-    def fn_stack_effect(self) -> str:
+    def fn_stack_effect_info(self) -> str:
         arms = ""
         for instr in self:
             stack = get_stack_effect(instr)
@@ -303,17 +314,21 @@ def fn_stack_effect(self) -> str:
         arms = arms.strip()
 
         return f"""
-        fn stack_effect_info(&self, oparg: u32) -> StackEffect {{
+        pub fn stack_effect_info(&self, oparg: u32) -> StackEffect {{
             // Reason for converting oparg to i32 is because of expressions like `1 + (oparg -1)`
             // that causes underflow errors.
+            #[allow(unused, reason = "This is auto generated code")]
             let oparg = i32::try_from(oparg).expect("oparg does not fit in an `i32`");
 
             let (pushed, popped) = match self {{
                 {arms}
             }};
 
             debug_assert!(u32::try_from(pushed).is_ok());
+            debug_assert!(i32::try_from(pushed).is_ok());
+
             debug_assert!(u32::try_from(popped).is_ok());
+            debug_assert!(i32::try_from(popped).is_ok());
 
             StackEffect::new(pushed as u32, popped as u32)
         }}
@@ -351,6 +366,29 @@ def impl_as_instruction(self) -> str:
         }}
         """
 
+    @property
+    def fn_stack_effect_jump(self) -> str:
+        return """
+        /// Stack effect when the instruction takes its branch (jump=true).
+        ///
+        /// CPython equivalent: `stack_effect(opcode, oparg, jump=True)`.
+        /// For most instructions this equals the fallthrough effect.
+        /// Override for instructions where branch and fallthrough differ
+        /// (e.g. `FOR_ITER`: fallthrough = +1, branch = −1).
+        pub fn stack_effect_jump(&self, oparg: u32) -> i32 {
+            self.stack_effect(oparg)
+        }
+        """
+
+    @property
+    def fn_stack_effect(self) -> str:
+        return """
+        /// Stack effect of [`Self::stack_effect_info`].
+        pub fn stack_effect(&self, oparg: u32) -> i32 {
+            self.stack_effect_info(oparg).effect()
+        }
+        """
+
     def __iter__(self):
         yield from self.instructions
 
@@ -434,6 +472,25 @@ def impl_as_opcode(self) -> str:
         }}
         """
 
+    @property
+    def fn_as_numeric_repr(self) -> str:
+        return f"""
+        #[must_use]
+        pub const fn as_{self.numeric_repr}(self) -> {self.numeric_repr} {{
+            self.as_opcode().as_{self.numeric_repr}()
+        }}
+        """
+
+    @property
+    def impl_as_numeric_repr(self) -> str:
+        return f"""
+        impl From<{self.name}> for {self.numeric_repr} {{
+            fn from(instruction: {self.name}) -> Self {{
+                instruction.as_{self.numeric_repr}()
+            }}
+        }}
+        """
+
     @property
     def fn_label_arg(self) -> str:
 >
@@ -452,14 +509,93 @@ def fn_label_arg(self) -> str:
 
         return f"""
         #[must_use]
-        pub const fn label_arg(&self) -> Option<{TARGET}> {{
+        pub const fn label_arg(&self) -> Option<Arg<{TARGET}>> {{
             Some(match self {{
                 {arms}
                 _ => return None,
             }})
         }}
         """
 
+    @property
+    def fn_to_base(self) -> str:
+        if not STATE[self.opcode_enum]["to_base"]:
+            return ""
+
+        return f"""
+        #[must_use]
+        pub const fn to_base(self) -> Option<Self> {{
+            if let Some(opcode) = self.as_opcode().to_base() {{
+                Some(opcode.as_instruction())
+            }} else {{
+                None
+            }}
+        }}
+        """
+
+    @property
+    def fn_try_from_numeric(self) -> str:
+        return f"""
+        #[must_use]
+        pub const fn try_from_{self.numeric_repr}(
+            value: {self.numeric_repr}
+        ) -> Result<Self, MarshalError> {{
+            match {self.opcode_enum}::try_from_{self.numeric_repr}(value) {{
+                Ok(opcode) => Ok(opcode.as_instruction()),
+                Err(e) => Err(e),
+            }}
+        }}
+        """
+
+    @property
+    def impl_try_from_numeric(self) -> str:
+        return f"""
+        impl TryFrom<{self.numeric_repr}> for {self.name} {{
+            type Error = MarshalError;
+
+            fn try_from(value: {self.numeric_repr}) -> Result<Self, Self::Error> {{
+                Self::try_from_{self.numeric_repr}(value)
+            }}
+        }}
+        """
+
+    @property
+    def fn_stack_effect(self) -> str:
+        return """
+        /// Stack effect of [`Self::stack_effect_info`].
+        pub fn stack_effect(&self, oparg: u32) -> i32 {
+            self.as_opcode().stack_effect(oparg)
+        }
+        """
+
+    @property
+    def fn_cache_entries(self) -> str:
+        if not STATE[self.opcode_enum]["cache_entries"]:
+            return ""
+
+        return f"""
+        #[must_use]
+        pub const fn cache_entries(self) -> usize {{
+            self.as_opcode().cache_entries()
+        }}
+        """
+
+    @property
+    def fn_deopt(self) -> str:
+        if not STATE[self.opcode_enum]["deopt"]:
+            return ""
+
+        return f"""
+        #[must_use]
+        pub const fn deopt(self) -> Option<Self> {{
+            if let Some(opcode) = self.as_opcode().deopt() {{
+                Some(opcode.as_instruction())
+            }} else {{
+                None
+            }}
+        }}
+        """
+
     def __iter__(self):
         yield from self.instructions
 

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
@@ -28,6 +28,21 @@ impl Instruction {
             Opcode::ReturnValue | Opcode::RaiseVarargs | Opcode::Reraise
         )
     }
+
+    /// Map a specialized or instrumented opcode back to its adaptive (base) variant.
+    #[must_use]
+    pub const fn deoptimize(self) -> Self {
+        match self.deopt() {
+            Some(v) => v,
+            None => {
+                // Instrumented opcodes map back to their base
+                match self.to_base() {
+                    Some(v) => v,
+                    None => self,
+                }
+            }
+        }
+    }
-    #[must_use]
-    pub fn stack_effect_jump(&self, oparg: u32) -> i32 {
-        self.as_opcode().stack_effect(oparg)
-    }
+    #[must_use]
+    pub fn stack_effect_jump(&self, oparg: u32) -> i32 {
+        self.as_opcode().stack_effect_jump(oparg)
+    }
-    #[must_use]
-    pub fn stack_effect_jump(&self, oparg: u32) -> i32 {
-        self.as_opcode().stack_effect(oparg)
-    }
+    #[must_use]
+    pub fn stack_effect_jump(&self, oparg: u32) -> i32 {
+        self.as_opcode().stack_effect_jump(oparg)
+    }
 }
 
 impl PseudoInstruction {
@@ -164,7 +179,7 @@ impl AnyInstruction {
     #[must_use]
     pub const fn real_opcode(self) -> Option<Opcode> {
         match self.real() {
-            Some(ins) => Some(ins.opcode()),
+            Some(ins) => Some(ins.as_opcode()),
             _ => None,
         }
     }
@@ -173,7 +188,7 @@ impl AnyInstruction {
     #[must_use]
     pub const fn pseudo_opcode(self) -> Option<PseudoOpcode> {
         match self.pseudo() {
-            Some(ins) => Some(ins.opcode()),
+            Some(ins) => Some(ins.as_opcode()),
             _ => None,
         }
     }