Refactor parser to be more type-correct

Also detect whether names that occur in both inputs and outputs
are at the same position.

Author: gvanrossum

Tools/cases_generator/generate_cases.py

@@ -72,13 +72,11 @@ def write_instr(instr: InstDef, predictions: set[str], indent: str, f: TextIO, d
     if dedent < 0:
         indent += " " * -dedent
     # TODO: Is it better to count forward or backward?
-    for i, input in enumerate(reversed(instr.inputs or ()), 1):
+    for i, input in enumerate(reversed(instr.inputs), 1):
         f.write(f"{indent}    PyObject *{input} = PEEK({i});\n")
-    for output in instr.outputs or ():
-        f.write(f"{indent}    PyObject *{output};\n")
-    # input = ", ".join(instr.inputs)
-    # output = ", ".join(instr.outputs)
-    # f.write(f"{indent}    // {input} -- {output}\n")
+    for output in instr.outputs:
+        if output not in instr.inputs:
+            f.write(f"{indent}    PyObject *{output};\n")
     assert instr.block is not None
     blocklines = instr.block.to_text(dedent=dedent).splitlines(True)
     # Remove blank lines from ends
@@ -97,7 +95,7 @@ def write_instr(instr: InstDef, predictions: set[str], indent: str, f: TextIO, d
     # Write the body
     ninputs = len(instr.inputs or ())
     for line in blocklines:
-        if m := re.match(r"(\s*)ERROR_IF\(([^,]+), (\w+)\);\s*$", line):
+        if m := re.match(r"(\s*)ERROR_IF\((.+), (\w+)\);\s*$", line):
             space, cond, label = m.groups()
             # ERROR_IF() must remove the inputs from the stack.
             # The code block is responsible for DECREF()ing them.
@@ -114,7 +112,8 @@ def write_instr(instr: InstDef, predictions: set[str], indent: str, f: TextIO, d
     elif diff < 0:
         f.write(f"{indent}    STACK_SHRINK({-diff});\n")
     for i, output in enumerate(reversed(instr.outputs or ()), 1):
-        f.write(f"{indent}    POKE({i}, {output});\n")
+        if output not in (instr.inputs or ()):
+            f.write(f"{indent}    POKE({i}, {output});\n")
     assert instr.block
 
 def write_cases(f: TextIO, instrs: list[InstDef], supers: list[parser.Super]):

Tools/cases_generator/parser.py

@@ -57,11 +57,28 @@ class Block(Node):
 
 
 @dataclass
-class InstDef(Node):
+class InstHeader(Node):
     name: str
-    inputs: list[str] | None
-    outputs: list[str] | None
-    block: Block | None
+    inputs: list[str]
+    outputs: list[str]
+
+
+@dataclass
+class InstDef(Node):
+    header: InstHeader
+    block: Block
+
+    @property
+    def name(self):
+        return self.header.name
+
+    @property
+    def inputs(self):
+        return self.header.inputs
+
+    @property
+    def outputs(self):
+        return self.header.outputs
 
 
 @dataclass
@@ -82,30 +99,42 @@ class Parser(PLexer):
     def inst_def(self) -> InstDef | None:
         if header := self.inst_header():
             if block := self.block():
-                header.block = block
-                return header
+                return InstDef(header, block)
             raise self.make_syntax_error("Expected block")
         return None
 
     @contextual
-    def inst_header(self):
+    def inst_header(self) -> InstHeader | None:
         # inst(NAME) | inst(NAME, (inputs -- outputs))
         # TODO: Error out when there is something unexpected.
-        # TODO: Make INST a keyword in the lexer.
+        # TODO: Make INST a keyword in the lexer.``
         if (tkn := self.expect(lx.IDENTIFIER)) and tkn.text == "inst":
             if (self.expect(lx.LPAREN)
                     and (tkn := self.expect(lx.IDENTIFIER))):
                 name = tkn.text
                 if self.expect(lx.COMMA):
                     inp, outp = self.stack_effect()
-                    if (self.expect(lx.RPAREN)
-                            and self.peek().kind == lx.LBRACE):
-                        return InstDef(name, inp, outp, [])
+                    if self.expect(lx.RPAREN):
+                        if ((tkn := self.peek())
+                                and tkn.kind == lx.LBRACE):
+                            self.check_overlaps(inp, outp)
+                            return InstHeader(name, inp, outp)
                 elif self.expect(lx.RPAREN):
-                    return InstDef(name, None, None, [])
+                    return InstHeader(name, [], [])
         return None
 
-    def stack_effect(self):
+    def check_overlaps(self, inp: list[str], outp: list[str]):
+        for i, name in enumerate(inp):
+            try:
+                j = outp.index(name)
+            except ValueError:
+                continue
+            else:
+                if i != j:
+                    raise self.make_syntax_error(
+                        f"Input {name!r} at pos {i} repeated in output at different pos {j}")
+
+    def stack_effect(self) -> tuple[list[str], list[str]]:
         # '(' [inputs] '--' [outputs] ')'
         if self.expect(lx.LPAREN):
             inp = self.inputs() or []
@@ -115,7 +144,7 @@ def stack_effect(self):
                     return inp, outp
         raise self.make_syntax_error("Expected stack effect")
 
-    def inputs(self):
+    def inputs(self) -> list[str] | None:
         # input (, input)*
         here = self.getpos()
         if inp := self.input():
@@ -128,7 +157,7 @@ def inputs(self):
         self.setpos(here)
         return None
 
-    def input(self):
+    def input(self) -> str | None:
         # IDENTIFIER
         if (tkn := self.expect(lx.IDENTIFIER)):
             if self.expect(lx.LBRACKET):
@@ -148,7 +177,7 @@ def input(self):
             return "??"
         return None
 
-    def outputs(self):
+    def outputs(self) -> list[str] | None:
         # output (, output)*
         here = self.getpos()
         if outp := self.output():
@@ -161,7 +190,7 @@ def outputs(self):
         self.setpos(here)
         return None
 
-    def output(self):
+    def output(self) -> str | None:
         return self.input()  # TODO: They're not quite the same.
 
     @contextual
@@ -176,7 +205,6 @@ def super_def(self) -> Super | None:
                                 return res
 
     def ops(self) -> list[str] | None:
-        here = self.getpos()
         if tkn := self.expect(lx.IDENTIFIER):
             ops = [tkn.text]
             while self.expect(lx.PLUS):
@@ -197,7 +225,7 @@ def family_def(self) -> Family | None:
                                     return Family(tkn.text, members)
         return None
 
-    def members(self):
+    def members(self) -> list[str] | None:
         here = self.getpos()
         if tkn := self.expect(lx.IDENTIFIER):
             near = self.getpos()
@@ -214,8 +242,8 @@ def block(self) -> Block:
         tokens = self.c_blob()
         return Block(tokens)
 
-    def c_blob(self):
-        tokens = []
+    def c_blob(self) -> list[lx.Token]:
+        tokens: list[lx.Token] = []
         level = 0
         while tkn := self.next(raw=True):
             if tkn.kind in (lx.LBRACE, lx.LPAREN, lx.LBRACKET):