typing: fix typing

Author: boriel

src/arch/z80/peephole/evaluator.py

@@ -2,7 +2,7 @@
 
 import re
 from collections.abc import Callable
-from enum import Enum, unique
+from enum import StrEnum, unique
 from typing import Any
 
 from src.api import utils
@@ -13,7 +13,7 @@
 
 
 @unique
-class FN(str, Enum):
+class FN(StrEnum):
     OP_NOT = "!"
     OP_PLUS = "+"
     OP_EQ = "=="
@@ -215,28 +215,31 @@ def eval(self, vars_: dict[str, Any] | None = None) -> str | Evaluator | list[An
             val = self.expression[0]
             if not isinstance(val, str):
                 return val
+
             if val == "$":
                 return val
+
             if not RE_SVAR.match(val):
                 return val
+
             if val not in vars_:
                 raise UnboundVarError(f"Unbound variable '{val}'")
+
             return vars_[val]
 
         if len(self.expression) == 2:
-            oper = self.expression[0]
+            oper = FN(self.expression[0])
             assert oper in UNARY
             operand = self.expression[1].eval(vars_)
-            # FIXME
-            return self.normalize(UNARY[oper](operand))  # type: ignore[index]
+            return self.normalize(UNARY[oper](operand))
 
         if len(self.expression) == 3 and self.expression[1] != FN.OP_COMMA:
-            assert self.expression[1] in BINARY
+            oper = FN(self.expression[1])
+            assert oper in BINARY
             # Do lazy evaluation
             left_ = lambda: self.expression[0].eval(vars_)
             right_ = lambda: self.expression[2].eval(vars_)
-            # FIXME
-            return self.normalize(BINARY[self.expression[1]](left_, right_))  # type: ignore[index]
+            return self.normalize(BINARY[oper](left_, right_))
 
         # It's a list
         return [x.eval(vars_) for i, x in enumerate(self.expression) if not i % 2]

src/arch/z80/peephole/parser.py

@@ -152,11 +152,15 @@ def parse_ifline(if_line: str, lineno: int) -> TreeType | None:
             if not isinstance(op, str) or op not in IF_OPERATORS:
                 errmsg.warning(lineno, f"Unexpected binary operator '{op}'")
                 return None
-            # FIXME
-            if isinstance(left_, list) and len(left_) == 3 and IF_OPERATORS[left_[-2]] > IF_OPERATORS[op]:  # type: ignore[index]
-                expr = [[left_[:-2], left_[-2], [left_[-1], op, right_]]]  # Rebalance tree
-            else:
-                expr = [expr]
+
+            oper = FN(op)
+            if isinstance(left_, list) and len(left_) == 3:
+                oper2 = FN(left_[-2])
+                if IF_OPERATORS[oper2] > IF_OPERATORS[oper]:
+                    expr = [[left_[:-2], left_[-2], [left_[-1], op, right_]]]  # Rebalance tree
+                    continue
+
+            expr = [expr]
 
     if not error_ and paren:
         errmsg.warning(lineno, "unclosed parenthesis in IF section")