Basic instrumented

youknowone · May 10, 2026 · May 5, 2026 · May 5, 2026 · May 5, 2026 · May 5, 2026
commit c66eaf695d672ca7f206c8e40b2db6d1a2aecf47
diff --git a/crates/compiler-core/generate.py b/crates/compiler-core/generate.py
@@ -32,9 +32,10 @@ class OpcodeGen:
     name: str
     instructions: list
     numeric_repr: str
+    analysis: analyzer.Analysis
 
     def gen(self) -> str:
-        variants = ",\n".join(instr.name for instr in self.instructions)
+        variants = ",\n".join(instr.name for instr in self)
 
         methods = "\n\n".join(
             getattr(self, attr).strip()
@@ -63,9 +64,7 @@ def gen(self) -> str:
 
     @property
     def fn_as_numeric(self) -> str:
-        arms = ",\n".join(
-            f"Self::{instr.name} => {instr.opcode}" for instr in self.instructions
-        )
+        arms = ",\n".join(f"Self::{instr.name} => {instr.opcode}" for instr in self)
         return f"""
         #[must_use]
         pub const fn as_{self.numeric_repr}(self) -> {self.numeric_repr} {{
@@ -77,9 +76,7 @@ def fn_as_numeric(self) -> str:
 
     @property
     def fn_tryfrom_numeric(self) -> str:
-        arms = ",\n".join(
-            f"{instr.opcode} => Self::{instr.name}" for instr in self.instructions
-        )
+        arms = ",\n".join(f"{instr.opcode} => Self::{instr.name}" for instr in self)
         return f"""
         #[must_use]
         pub const fn from_{self.numeric_repr}(
@@ -114,10 +111,10 @@ def impl_into_numeric(self) -> str:
         }}
         """
 
-    def build_has_attr_fn(self, fn_attr: str, prop_attr: str, doc_flag: str):
+    def build_has_attr_fn(self, fn_attr: str, prop_attr: str, doc_flag: str) -> str:
         arms = "|".join(
             f"Self::{instr.name}"
-            for instr in self.instructions
+            for instr in self
             if getattr(instr.properties, prop_attr)
         )
 
@@ -162,6 +159,91 @@ def build_has_attr_fn(self, fn_attr: str, prop_attr: str, doc_flag: str):
         lambda self: self.build_has_attr_fn("exc", "pure", "HAS_PURE_FLAG")
     )
 
+    @property
+    def instrumented(self) -> list:
+        return [instr for instr in self if instr.name.startswith("Instrumented")]
+
+    @property
+    def fn_to_base(self) -> str:
+        inames = {instr.name for instr in self.instrumented}
+        names = {instr.name for instr in self} - inames
+
+        arms = ""
+        for iname in inames:
+            name = iname.removeprefix("Instrumented")
+            if name not in names:
+                continue
+            arms += f"Self::{iname} => Self::{name},\n"
+
+        arms = arms.strip()
+        if not arms:
+            return ""
+
+        inner = f"""
+            Some(match self {{
+                {arms}
+                _ => return None,
+
+            }})
+        """
+
+        return f"""
+        #[must_use]
+        pub const fn to_base(self) -> Option<Self> {{
+            {inner}
+        }}
+        """
+
+    @property
+    def fn_to_instrumented(self) -> str:
+        inames = {instr.name for instr in self.instrumented}
+        names = {instr.name for instr in self} - inames
+
+        arms = ""
+        for iname in inames:
+            name = iname.removeprefix("Instrumented")
+            if name not in names:
+                continue
+            arms += f"Self::{name} => Self::{iname},\n"
+
+        arms = arms.strip()
+        if not arms:
+            return ""
+
+        inner = f"""
+            Some(match self {{
+                {arms}
+                _ => return None,
+
+            }})
+        """
+
+        return f"""
+        #[must_use]
+        pub const fn to_instrumented(self) -> Option<Self> {{
+            {inner}
+        }}
+        """
+
+    @property
+    def fn_deopt(self) -> str:
+        names = {instr.name for instr in self}
+
+        for family in self.analysis.families.values():
+            family_name = to_pascal_case(family.name)
+            if family_name not in names:
+                continue
+            for member in family.members:
+                if member.name == family.name:
+                    continue
+
+                print(family_name, member.name)
+
+        return ""
+
+    def __iter__(self):
+        yield from self.instructions
+
 
 def to_pascal_case(s: str) -> str:
     return s.title().replace("_", "")
@@ -209,8 +291,12 @@ def main():
             instr.name = to_pascal_case(instr.name)
 
         code = OpcodeGen(
-            name=opcode_enum_name, instructions=instructions, numeric_repr=numeric_repr
+            name=opcode_enum_name,
+            instructions=instructions,
+            numeric_repr=numeric_repr,
+            analysis=analysis,
         ).gen()
+
         outfile.write(code)
 
     generated = outfile.getvalue()

diff --git a/crates/compiler-core/src/bytecode/instructions.rs b/crates/compiler-core/src/bytecode/instructions.rs
@@ -734,6 +734,58 @@ impl Opcode {
         )
     }
 
+    #[must_use]
+    pub const fn to_base(self) -> Option<Self> {
+        Some(match self {
+            Self::InstrumentedForIter => Self::ForIter,
+            Self::InstrumentedYieldValue => Self::YieldValue,
+            Self::InstrumentedNotTaken => Self::NotTaken,
+            Self::InstrumentedEndSend => Self::EndSend,
+            Self::InstrumentedJumpBackward => Self::JumpBackward,
+            Self::InstrumentedResume => Self::Resume,
+            Self::InstrumentedJumpForward => Self::JumpForward,
+            Self::InstrumentedPopJumpIfTrue => Self::PopJumpIfTrue,
+            Self::InstrumentedReturnValue => Self::ReturnValue,
+            Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
+            Self::InstrumentedPopJumpIfFalse => Self::PopJumpIfFalse,
+            Self::InstrumentedPopJumpIfNone => Self::PopJumpIfNone,
+            Self::InstrumentedEndFor => Self::EndFor,
+            Self::InstrumentedPopJumpIfNotNone => Self::PopJumpIfNotNone,
+            Self::InstrumentedCall => Self::Call,
+            Self::InstrumentedEndAsyncFor => Self::EndAsyncFor,
+            Self::InstrumentedPopIter => Self::PopIter,
+            Self::InstrumentedCallKw => Self::CallKw,
+            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr,
+            _ => return None,
+        })
+    }
+
+    #[must_use]
+    pub const fn to_instrumented(self) -> Option<Self> {
+        Some(match self {
+            Self::ForIter => Self::InstrumentedForIter,
+            Self::YieldValue => Self::InstrumentedYieldValue,
+            Self::NotTaken => Self::InstrumentedNotTaken,
+            Self::EndSend => Self::InstrumentedEndSend,
+            Self::JumpBackward => Self::InstrumentedJumpBackward,
+            Self::Resume => Self::InstrumentedResume,
+            Self::JumpForward => Self::InstrumentedJumpForward,
+            Self::PopJumpIfTrue => Self::InstrumentedPopJumpIfTrue,
+            Self::ReturnValue => Self::InstrumentedReturnValue,
+            Self::CallFunctionEx => Self::InstrumentedCallFunctionEx,
+            Self::PopJumpIfFalse => Self::InstrumentedPopJumpIfFalse,
+            Self::PopJumpIfNone => Self::InstrumentedPopJumpIfNone,
+            Self::EndFor => Self::InstrumentedEndFor,
+            Self::PopJumpIfNotNone => Self::InstrumentedPopJumpIfNotNone,
+            Self::Call => Self::InstrumentedCall,
+            Self::EndAsyncFor => Self::InstrumentedEndAsyncFor,
+            Self::PopIter => Self::InstrumentedPopIter,
+            Self::CallKw => Self::InstrumentedCallKw,
+            Self::LoadSuperAttr => Self::InstrumentedLoadSuperAttr,
+            _ => return None,
+        })
+    }
+
     #[must_use]
     pub const fn from_u8(value: u8) -> Result<Self, crate::marshal::MarshalError> {
         Ok(match value {