Refact/simplify typing

pyproject.toml

@@ -98,10 +98,22 @@ disable_error_code = [
     "union-attr",
     "var-annotated",
 ]
+exclude = [
+    'src/ply/.*\.py$'
+]
+
+[[tool.mypy.overrides]]
+module = [
+  "src.ply.*",
+]
+follow_imports = "skip"
 
 [tool.ruff]
 line-length = 120
 target-version = "py310"
+exclude = [
+    "src/ply"  # PLY, external 3rd party tool
+]
 
 [tool.ruff.lint]
 select = [

src/arch/z80/visitor/translator.py

@@ -794,6 +794,7 @@ def visit_PRINT(self, node):
 
             self.ic_fparam(i.type_, i.t)
             label = {
+                "bool": RuntimeLabel.PRINTU8,
                 "i8": RuntimeLabel.PRINTI8,
                 "u8": RuntimeLabel.PRINTU8,
                 "i16": RuntimeLabel.PRINTI16,

src/arch/z80/visitor/translator_inst_visitor.py

@@ -4,7 +4,7 @@
 from src.arch.z80.backend import Backend
 from src.arch.z80.backend.common import BOOL_t, F16_t, F_t, I8_t, I16_t, I32_t, STR_t, U8_t, U16_t, U32_t
 from src.ast import NodeVisitor
-from src.symbols import sym as symbols
+from src.symbols import sym
 
 
 class TranslatorInstVisitor(NodeVisitor):
@@ -18,8 +18,8 @@ def emit(self, *args: str) -> None:
         self.backend.MEMORY.append(quad)
 
     @staticmethod
-    def TSUFFIX(type_: TYPE | symbols.TYPEREF | symbols.BASICTYPE) -> str:
-        assert isinstance(type_, symbols.TYPE) or TYPE.is_valid(type_)
+    def TSUFFIX(type_: TYPE | sym.TYPEREF | sym.BASICTYPE) -> str:
+        assert isinstance(type_, sym.TYPE) or TYPE.is_valid(type_)
 
         _TSUFFIX = {
             TYPE.byte: I8_t,
@@ -34,48 +34,48 @@ def TSUFFIX(type_: TYPE | symbols.TYPEREF | symbols.BASICTYPE) -> str:
             TYPE.boolean: BOOL_t,
         }
 
-        if isinstance(type_, symbols.TYPEREF):
+        if isinstance(type_, sym.TYPEREF):
             type_ = type_.final
-            assert isinstance(type_, symbols.BASICTYPE)
+            assert isinstance(type_, sym.BASICTYPE)
 
-        if isinstance(type_, symbols.BASICTYPE):
+        if isinstance(type_, sym.BASICTYPE):
             return _TSUFFIX[type_.type_]
 
         return _TSUFFIX[type_]
 
     @classmethod
-    def _no_bool(cls, type_: TYPE | symbols.TYPEREF | symbols.BASICTYPE) -> str:
+    def _no_bool(cls, type_: TYPE | sym.TYPEREF | sym.BASICTYPE) -> str:
         """Returns the corresponding type suffix except for bool which maps to U8_t"""
         return cls.TSUFFIX(type_) if cls.TSUFFIX(type_) != BOOL_t else U8_t
 
     def ic_aaddr(self, t1, t2) -> None:
         self.emit("aaddr", t1, t2)
 
-    def ic_abs(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_abs(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit("abs" + self.TSUFFIX(type_), t1, t2)
 
-    def ic_add(self, type_: TYPE | symbols.BASICTYPE, t1, t2, t3) -> None:
+    def ic_add(self, type_: TYPE | sym.BASICTYPE, t1, t2, t3) -> None:
         self.emit("add" + self.TSUFFIX(type_), t1, t2, t3)
 
-    def ic_aload(self, type_: TYPE | symbols.BASICTYPE, t1, mangle: str) -> None:
+    def ic_aload(self, type_: TYPE | sym.BASICTYPE, t1, mangle: str) -> None:
         self.emit("aload" + self.TSUFFIX(type_), t1, mangle)
 
-    def ic_and(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_and(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit(f"and{self._no_bool(type_)}", t, t1, t2)
 
-    def ic_astore(self, type_: TYPE | symbols.BASICTYPE, addr: str, t) -> None:
+    def ic_astore(self, type_: TYPE | sym.BASICTYPE, addr: str, t) -> None:
         self.emit("astore" + self.TSUFFIX(type_), addr, t)
 
-    def ic_band(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_band(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("band" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_bnot(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_bnot(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit("bnot" + self.TSUFFIX(type_), t1, t2)
 
-    def ic_bor(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_bor(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("bor" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_bxor(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_bxor(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("bxor" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_call(self, label: str, num: int) -> None:
@@ -84,13 +84,13 @@ def ic_call(self, label: str, num: int) -> None:
     def ic_cast(self, t1, type1, type2, t2) -> None:
         self.emit("cast", t1, self.TSUFFIX(type1), self.TSUFFIX(type2), t2)
 
-    def ic_data(self, type_: TYPE | symbols.BASICTYPE, data: list) -> None:
+    def ic_data(self, type_: TYPE | sym.BASICTYPE, data: list) -> None:
         self.emit("data", self.TSUFFIX(type_), data)
 
     def ic_deflabel(self, label: str, t) -> None:
         self.emit("deflabel", label, t)
 
-    def ic_div(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_div(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("div" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_end(self, t) -> None:
@@ -99,22 +99,22 @@ def ic_end(self, t) -> None:
     def ic_enter(self, arg) -> None:
         self.emit("enter", arg)
 
-    def ic_eq(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_eq(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("eq" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_exchg(self) -> None:
         self.emit("exchg")
 
-    def ic_fparam(self, type_: TYPE | symbols.BASICTYPE, t) -> None:
-        self.emit("fparam" + self.TSUFFIX(type_), t)
+    def ic_fparam(self, type_: TYPE | sym.BASICTYPE, t) -> None:
+        self.emit(f"fparam{self._no_bool(type_)}", t)
 
-    def ic_fpload(self, type_: TYPE | symbols.BASICTYPE, t, offset) -> None:
+    def ic_fpload(self, type_: TYPE | sym.BASICTYPE, t, offset) -> None:
         self.emit("fpload" + self.TSUFFIX(type_), t, offset)
 
-    def ic_ge(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_ge(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("ge" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_gt(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_gt(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("gt" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_in(self, t) -> None:
@@ -123,16 +123,16 @@ def ic_in(self, t) -> None:
     def ic_inline(self, asm_code: str) -> None:
         self.emit("inline", asm_code)
 
-    def ic_jgezero(self, type_: TYPE | symbols.BASICTYPE, t, label: str) -> None:
+    def ic_jgezero(self, type_: TYPE | sym.BASICTYPE, t, label: str) -> None:
         self.emit(f"jgezero{self._no_bool(type_)}", t, label)
 
-    def ic_jnzero(self, type_: TYPE | symbols.BASICTYPE, t, label: str) -> None:
+    def ic_jnzero(self, type_: TYPE | sym.BASICTYPE, t, label: str) -> None:
         self.emit(f"jnzero{self._no_bool(type_)}", t, label)
 
     def ic_jump(self, label: str) -> None:
         self.emit("jump", label)
 
-    def ic_jzero(self, type_: TYPE | symbols.BASICTYPE, t, label: str) -> None:
+    def ic_jzero(self, type_: TYPE | sym.BASICTYPE, t, label: str) -> None:
         self.emit(f"jzero{self._no_bool(type_)}", t, label)
 
     def ic_label(self, label: str) -> None:
@@ -141,7 +141,7 @@ def ic_label(self, label: str) -> None:
     def ic_larrd(self, offset, arg1, size, arg2, bound_ptrs) -> None:
         self.emit("larrd", offset, arg1, size, arg2, bound_ptrs)
 
-    def ic_le(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_le(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("le" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_leave(self, convention: str) -> None:
@@ -150,43 +150,43 @@ def ic_leave(self, convention: str) -> None:
     def ic_lenstr(self, t1, t2) -> None:
         self.emit("lenstr", t1, t2)
 
-    def ic_load(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_load(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit("load" + self.TSUFFIX(type_), t1, t2)
 
-    def ic_lt(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_lt(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("lt" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_lvard(self, offset, default_value: list) -> None:
         self.emit("lvard", offset, default_value)
 
-    def ic_lvarx(self, type_: TYPE | symbols.BASICTYPE, offset, default_value: list) -> None:
+    def ic_lvarx(self, type_: TYPE | sym.BASICTYPE, offset, default_value: list) -> None:
         self.emit("lvarx", offset, self.TSUFFIX(type_), default_value)
 
     def ic_memcopy(self, t1, t2, t3) -> None:
         self.emit("memcopy", t1, t2, t3)
 
-    def ic_mod(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_mod(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("mod" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_mul(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_mul(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("mul" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_ne(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_ne(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("ne" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_neg(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_neg(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit("neg" + self.TSUFFIX(type_), t1, t2)
 
     def ic_nop(self) -> None:
         self.emit("nop")
 
-    def ic_not(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_not(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit(f"not{self._no_bool(type_)}", t1, t2)
 
-    def ic_or(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_or(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit(f"or{self._no_bool(type_)}", t, t1, t2)
 
-    def ic_org(self, type_: TYPE | symbols.BASICTYPE) -> None:
+    def ic_org(self, type_: TYPE | sym.BASICTYPE) -> None:
         self.emit("org" + self.TSUFFIX(type_))
 
     def ic_out(self, t1, t2) -> None:
@@ -198,40 +198,40 @@ def ic_paaddr(self, t1, t2) -> None:
     def ic_paddr(self, t1, t2) -> None:
         self.emit("paddr", t1, t2)
 
-    def ic_paload(self, type_: TYPE | symbols.BASICTYPE, t, offset: int) -> None:
+    def ic_paload(self, type_: TYPE | sym.BASICTYPE, t, offset: int) -> None:
         self.emit("paload" + self.TSUFFIX(type_), t, offset)
 
-    def ic_param(self, type_: TYPE | symbols.BASICTYPE, t) -> None:
+    def ic_param(self, type_: TYPE | sym.BASICTYPE, t) -> None:
         self.emit("param" + self.TSUFFIX(type_), t)
 
-    def ic_pastore(self, type_: TYPE | symbols.BASICTYPE, offset, t) -> None:
+    def ic_pastore(self, type_: TYPE | sym.BASICTYPE, offset, t) -> None:
         self.emit("pastore" + self.TSUFFIX(type_), offset, t)
 
-    def ic_pload(self, type_: TYPE | symbols.BASICTYPE, t1, offset) -> None:
+    def ic_pload(self, type_: TYPE | sym.BASICTYPE, t1, offset) -> None:
         self.emit("pload" + self.TSUFFIX(type_), t1, offset)
 
-    def ic_pow(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_pow(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("pow" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_pstore(self, type_: TYPE | symbols.BASICTYPE, offset, t) -> None:
+    def ic_pstore(self, type_: TYPE | sym.BASICTYPE, offset, t) -> None:
         self.emit("pstore" + self.TSUFFIX(type_), offset, t)
 
-    def ic_ret(self, type_: TYPE | symbols.BASICTYPE, t, addr) -> None:
+    def ic_ret(self, type_: TYPE | sym.BASICTYPE, t, addr) -> None:
         self.emit("ret" + self.TSUFFIX(type_), t, addr)
 
     def ic_return(self, addr) -> None:
         self.emit("ret", addr)
 
-    def ic_shl(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_shl(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("shl" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_shr(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_shr(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("shr" + self.TSUFFIX(type_), t, t1, t2)
 
-    def ic_store(self, type_: TYPE | symbols.BASICTYPE, t1, t2) -> None:
+    def ic_store(self, type_: TYPE | sym.BASICTYPE, t1, t2) -> None:
         self.emit("store" + self.TSUFFIX(type_), t1, t2)
 
-    def ic_sub(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_sub(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("sub" + self.TSUFFIX(type_), t, t1, t2)
 
     def ic_var(self, name: str, size_) -> None:
@@ -240,8 +240,8 @@ def ic_var(self, name: str, size_) -> None:
     def ic_vard(self, name: str, data: list) -> None:
         self.emit("vard", name, data)
 
-    def ic_varx(self, name: str, type_: TYPE | symbols.BASICTYPE, default_value: list) -> None:
+    def ic_varx(self, name: str, type_: TYPE | sym.BASICTYPE, default_value: list) -> None:
         self.emit("varx", name, self.TSUFFIX(type_), default_value)
 
-    def ic_xor(self, type_: TYPE | symbols.BASICTYPE, t, t1, t2) -> None:
+    def ic_xor(self, type_: TYPE | sym.BASICTYPE, t, t1, t2) -> None:
         self.emit("xor" + self.TSUFFIX(type_), t, t1, t2)

src/parsetab/tabs.dbm.bak

@@ -1,4 +1,4 @@
-'zxbpp', (0, 66990)
-'asmparse', (67072, 233944)
-'zxnext_asmparse', (301056, 259009)
-'zxbparser', (560128, 641174)
+'zxbpp', (0, 67003)
+'asmparse', (67072, 233956)
+'zxnext_asmparse', (301056, 259034)
+'zxbparser', (560128, 641187)

src/parsetab/tabs.dbm.dir

@@ -1,4 +1,4 @@
-'zxbpp', (0, 66990)
-'asmparse', (67072, 233944)
-'zxnext_asmparse', (301056, 259009)
-'zxbparser', (560128, 641174)
+'zxbpp', (0, 67003)
+'asmparse', (67072, 233956)
+'zxnext_asmparse', (301056, 259034)
+'zxbparser', (560128, 641187)

src/ply/__init__.py

@@ -2,4 +2,4 @@
 # Author: David Beazley (dave@dabeaz.com)
 # https://github.com/dabeaz/ply
 
-__version__ = "2022.10.27"
+__version__ = '2022.10.27'