Restore override behavior

Author: markshannon

Lib/test/test_generated_cases.py

@@ -666,9 +666,50 @@ def test_macro_push_push(self):
         """
         self.run_cases_test(input, output)
 
+    def test_override_inst(self):
+        input = """
+        inst(OP, (--)) {
+            spam();
+        }
+        override inst(OP, (--)) {
+            ham();
+        }
+        """
+        output = """
+        TARGET(OP) {
+            frame->instr_ptr = next_instr;
+            next_instr += 1;
+            INSTRUCTION_STATS(OP);
+            ham();
+            DISPATCH();
+        }
+        """
+        self.run_cases_test(input, output)
+
+    def test_override_op(self):
+        input = """
+        op(OP, (--)) {
+            spam();
+        }
+        macro(M) = OP;
+        override op(OP, (--)) {
+            ham();
+        }
+        """
+        output = """
+        TARGET(M) {
+            frame->instr_ptr = next_instr;
+            next_instr += 1;
+            INSTRUCTION_STATS(M);
+            ham();
+            DISPATCH();
+        }
+        """
+        self.run_cases_test(input, output)
+
     def test_annotated_inst(self):
         input = """
-        annotation inst(OP, (--)) {
+        guard inst(OP, (--)) {
             ham();
         }
         """
@@ -685,7 +726,7 @@ def test_annotated_inst(self):
 
     def test_annotated_op(self):
         input = """
-        annotation op(OP, (--)) {
+        guard op(OP, (--)) {
             spam();
         }
         macro(M) = OP;

Python/bytecodes.c

@@ -52,6 +52,7 @@
 
 /* Annotations */
 #define guard
+#define override
 #define specializing
 
 // Dummy variables for stack effects.

Tools/cases_generator/analysis.py

@@ -139,12 +139,20 @@ def parse_file(self, filename: str, instrs_idx: dict[str, int]) -> None:
             match thing:
                 case parsing.InstDef(name=name):
                     macro: parsing.Macro | None = None
-                    if thing.kind == "inst":
+                    if thing.kind == "inst" and not thing.annotation == "override":
                         macro = parsing.Macro(name, [parsing.OpName(name)])
                     if name in self.instrs:
+                        if not thing.annotation == "override":
+                            raise psr.make_syntax_error(
+                                f"Duplicate definition of '{name}' @ {thing.context} "
+                                f"previous definition @ {self.instrs[name].inst.context}",
+                                thing_first_token,
+                            )
+                        self.everything[instrs_idx[name]] = thing
+                    if name not in self.instrs and thing.annotation == "override":
                         raise psr.make_syntax_error(
-                            f"Duplicate definition of '{name}' @ {thing.context} "
-                            f"previous definition @ {self.instrs[name].inst.context}",
+                            f"Definition of '{name}' @ {thing.context} is supposed to be "
+                            "an override but no previous definition exists.",
                             thing_first_token,
                         )
                     self.instrs[name] = Instruction(thing)

Tools/cases_generator/lexer.py

@@ -206,19 +206,19 @@ def choice(*opts: str) -> str:
 kwds.append(VOLATILE)
 WHILE = "WHILE"
 kwds.append(WHILE)
-#An instruction in the DSL
+# An instruction in the DSL
 INST = "INST"
 kwds.append(INST)
-#A micro-op in the DSL
+# A micro-op in the DSL
 OP = "OP"
 kwds.append(OP)
-#A macro in the DSL
+# A macro in the DSL
 MACRO = "MACRO"
 kwds.append(MACRO)
 keywords = {name.lower(): name for name in kwds}
 
 ANNOTATION = "ANNOTATION"
-annotations = {"specializing", "guard"}
+annotations = {"specializing", "guard", "override", "register"}
 
 __all__ = []
 __all__.extend(kwds)