diff --git a/.github/workflows/fuzzer.yml b/.github/workflows/fuzzer.yml
index 64d3bd0..67daabe 100644
--- a/.github/workflows/fuzzer.yml
+++ b/.github/workflows/fuzzer.yml
@@ -44,4 +44,4 @@ jobs:
         run: pip install -r requirements-dev.txt
       - name: Run fuzzer (${{ inputs.iterations }} iterations)
         run: |
-          python fuzz.py -n ${{ inputs.iterations }}
+          python -m scripts.fuzz -n ${{ inputs.iterations }}
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index ced6e37..64a9880 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -16,17 +16,24 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+          - "3.13"
+          - "3.14"
+      fail-fast: false
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Setup python ${{ matrix.py_version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.py_version }}
+      - name: Setup pythonfuzz
+        run: pip install -r requirements-dev.txt
       - name: Run tests
         run: |
-          chmod +x ./run_tests.sh
-          ./run_tests.sh --verbose
+          ./scripts/run_tests.sh --verbose
       - name: Run mini-benchmark
         run: |
-          python ./benchmark.py
+          python -m scripts.benchmark
+      # Just to detect ultra-obvious bugs that our tests missed
+      - name: Run quick fuzzing (20000 iterations)
+        run: python -m scripts.fuzz -n 20000
diff --git a/.idea/inspectionProfiles/project_inspections.xml b/.idea/inspectionProfiles/project_inspections.xml
index 47654a1..3d2e4a3 100644
--- a/.idea/inspectionProfiles/project_inspections.xml
+++ b/.idea/inspectionProfiles/project_inspections.xml
@@ -22,7 +22,7 @@
         </list>
       </option>
     </inspection_tool>
-    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true" editorAttributes="WARNING_ATTRIBUTES">
       <option name="ignoredIdentifiers">
         <list>
           <option value="unittest.case._subtest_msg_sentinel" />
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 1e0a65c..4dcf192 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,7 +3,7 @@
   <component name="Black">
     <option name="sdkName" value="Python 3.11 (programming_lang_2)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11 (programming_lang_2)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.14 (programming_lang_2)" project-jdk-type="Python SDK" />
   <component name="PythonCompatibilityInspectionAdvertiser">
     <option name="version" value="3" />
   </component>
diff --git a/.idea/programming_lang_2.iml b/.idea/programming_lang_2.iml
index 9ece612..ef786b5 100644
--- a/.idea/programming_lang_2.iml
+++ b/.idea/programming_lang_2.iml
@@ -4,8 +4,9 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/.mypy_cache" />
       <excludeFolder url="file://$MODULE_DIR$/venv" />
+      <excludeFolder url="file://$MODULE_DIR$/venv314" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.11 (programming_lang_2)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.14 (programming_lang_2)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>
\ No newline at end of file
diff --git a/detect_unused.sh b/detect_unused.sh
deleted file mode 100644
index 93e1100..0000000
--- a/detect_unused.sh
+++ /dev/null
@@ -1 +0,0 @@
-vulture ./parser ./main.py ./fuzz.py ./test --ignore-decorators="@_register_autowalk_expr*" --exclude="parser/astgen/ast_print.py"
diff --git a/main_example_0.st b/examples/main_example_0.st
similarity index 100%
rename from main_example_0.st
rename to examples/main_example_0.st
diff --git a/main_example_1.st b/examples/main_example_1.st
similarity index 100%
rename from main_example_1.st
rename to examples/main_example_1.st
diff --git a/main_example_2.st b/examples/main_example_2.st
similarity index 100%
rename from main_example_2.st
rename to examples/main_example_2.st
diff --git a/parser/astgen/ast_node.py b/parser/astgen/ast_node.py
index 5994210..6baeca4 100644
--- a/parser/astgen/ast_node.py
+++ b/parser/astgen/ast_node.py
@@ -1,20 +1,28 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+import sys
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Callable, TypeAlias, Iterable, TypeVar
+from typing import Callable, TypeAlias, Iterable, TypeVar, TYPE_CHECKING, Generic
 
-from util import flatten_force
 from ..common import HasRegion, StrRegion
 
-__all__ = [
-    "AstNode", "AstProgramNode", "VarDeclScope", "VarDeclType", "AstDeclNode",
-    "AstRepeat", "AstIf", "AstWhile", "AstAssign", "AstAugAssign", "AstDefine",
-    "AstNumber", "AstString", "AstAnyName", "AstIdent", "AstAttrName",
-    "AstListLiteral", "AstAttribute", "AstItem", "AstCall", "AstOp", "AstBinOp",
-    "AstUnaryOp", 'walk_ast', 'WalkableT', 'WalkerFnT', 'WalkerCallType',
-    "FilteredWalker"
-]
+__all__ = ['AstNode', 'walk_ast', 'WalkableT', 'WalkerFnT', 'WalkerCallType', 'MetadataT']
+
+
+# Pycharm: unknown value (so ignores this branch as it doesn't understand).
+#  mypy-oids: True. Runtime: False
+_TYPE_CHECKING_NOT_PYCHARM = TYPE_CHECKING
+# If we are a compatible type checker or we are a sufficiently new runtime...
+if _TYPE_CHECKING_NOT_PYCHARM or (not TYPE_CHECKING and sys.version_info >= (3, 13)):
+    # If we are an old version, import it (for type checkers, unreachable at runtime)
+    if sys.version_info < (3, 13):
+        from typing_extensions import TypeVar
+    # Now we have a default-able TypeVar from somewhere so can use it
+    MetadataT = TypeVar('MetadataT', default=None)
+else:
+    # We are an old runtime version without default or Pycharm
+    MetadataT = TypeVar('MetadataT')
 
 
 class WalkerCallType(Enum):
@@ -22,17 +30,12 @@ class WalkerCallType(Enum):
     POST = 'post'
 
 
-WalkableL0: TypeAlias = 'AstNode | list[AstNode] | tuple[AstNode, ...] | None'
-WalkableT: TypeAlias = 'WalkableL0 | list[WalkableL0] | tuple[WalkableL0, ...]'
-WalkerFnT: TypeAlias = Callable[[WalkableT, WalkerCallType], bool | None]
-"""Returns True if skip"""
-
-
 @dataclass
-class AstNode(HasRegion):
+class AstNode(HasRegion, Generic[MetadataT]):
     region: StrRegion
     name = None  # type: str
     del name  # So we get better error msg if we forget to add it to a class
+    meta: MetadataT = field(kw_only=True, default=None)
 
     def walk(self, fn: WalkerFnT):
         if fn(self, WalkerCallType.PRE):
@@ -76,333 +79,7 @@ def walk_multiple_objects(cls, fn: WalkerFnT, objs: Iterable[WalkableT]):
 walk_ast = AstNode.walk_obj
 
 
-# region <FilteredWalker>
-WT = TypeVar('WT', bound=WalkableT)
-VT = TypeVar('VT')
-SpecificCbT = Callable[[WT], bool | None]
-SpecificCbsDict = dict[type[WT] | type, list[Callable[[WT], bool | None]]]
-BothCbT = Callable[[WT, WalkerCallType], bool | None]
-BothCbsDict = dict[type[WT] | type, list[Callable[[WT, WalkerCallType], bool | None]]]
-
-
-class WalkerFilterRegistry:
-    def __init__(self, enter_cbs: SpecificCbsDict = (),
-                 exit_cbs: SpecificCbsDict = (),
-                 both_sbc: BothCbsDict = ()):
-        self.enter_cbs: SpecificCbsDict = dict(enter_cbs)  # Copy them,
-        self.exit_cbs: SpecificCbsDict = dict(exit_cbs)    # also converts default () -> {}
-        self.both_cbs: BothCbsDict = dict(both_sbc)
-
-    def copy(self):
-        return WalkerFilterRegistry(self.enter_cbs, self.exit_cbs, self.both_cbs)
-
-    def register_both(self, t: type[WT], fn: Callable[[WT, WalkerCallType], bool | None]):
-        self.both_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def register_enter(self, t: type[WT], fn: Callable[[WT], bool | None]):
-        self.enter_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def register_exit(self, t: type[WT], fn: Callable[[WT], bool | None]):
-        self.exit_cbs.setdefault(t, []).append(fn)
-        return self
-
-    def __call__(self, *args, **kwargs):
-        return self
-
-    def on_enter(self, *tps: type[WT] | type):
-        """Decorator version of register_enter."""
-        def decor(fn: SpecificCbT):
-            for t in tps:
-                self.register_enter(t, fn)
-            return fn
-        return decor
-
-    def on_exit(self, *tps: type[WT] | type):
-        """Decorator version of register_exit."""
-        def decor(fn: SpecificCbT):
-            for t in tps:
-                self.register_exit(t, fn)
-            return fn
-        return decor
-
-    def on_both(self, *tps: type[WT] | type):
-        """Decorator version of register_both."""
-        def decor(fn: BothCbT):
-            for t in tps:
-                self.register_both(t, fn)
-            return fn
-        return decor
-
-
-class FilteredWalker(WalkerFilterRegistry):
-    def __init__(self):
-        cls_reg = self.class_registry()
-        super().__init__(cls_reg.enter_cbs, cls_reg.exit_cbs, cls_reg.both_cbs)
-
-    @classmethod
-    def class_registry(cls) -> WalkerFilterRegistry:
-        return WalkerFilterRegistry()
-
-    @classmethod
-    def create_cls_registry(cls, fn=None):
-        """Create a class-level registry that can be added to using decorators.
-
-        This can be used in two ways (at the top of your class)::
-
-            # MUST be this name
-            class_registry = FilteredWalker.create_cls_registry()
-
-        or::
-
-            @classmethod
-            @FilteredWalker.create_cls_registry
-            def class_registry(cls):  # MUST be this name
-                pass
-
-        and when registering methods::
-
-            @class_registry.on_enter(AstDefine)
-            def enter_define(self, ...):
-                ...
-
-        The restrictions on name are because we have no other way of detecting
-         it (without metaclass dark magic) as we can't refer to the class while
-         its namespace is being evaluated
-        """
-        if fn is not None and (parent := fn(cls)) is not None:
-            return WalkerFilterRegistry.copy(parent)
-        return WalkerFilterRegistry()
-
-    def __call__(self, o: WalkableT, call_type: WalkerCallType):
-        result = None
-        # Call more specific ones first
-        specific_cbs = self.enter_cbs if call_type == WalkerCallType.PRE else self.exit_cbs
-        for fn in self._get_funcs(specific_cbs, type(o)):
-            result = fn(o) or result
-        for fn in self._get_funcs(self.both_cbs, type(o)):
-            result = fn(o, call_type) or result
-        return result
-
-    @classmethod
-    def _get_funcs(cls, mapping: dict[type[WT] | type, list[VT]], tp: type[WT]) -> list[VT]:
-        """Also looks at superclasses/MRO"""
-        return flatten_force(mapping.get(sub, []) for sub in tp.mro())
-# endregion
-
-
-@dataclass
-class AstProgramNode(AstNode):
-    name = 'program'
-    statements: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.statements,))
-
-
-# region ---- <Statements> ----
-class VarDeclScope(Enum):
-    LET = 'let'
-    GLOBAL = 'global'
-
-
-class VarDeclType(Enum):
-    VARIABLE = 'variable'
-    LIST = 'list'
-
-
-@dataclass
-class AstDeclNode(AstNode):
-    name = 'var_decl'
-    scope: VarDeclScope
-    type: VarDeclType
-    ident: AstIdent
-    value: AstNode | None
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.ident, self.value))
-
-
-@dataclass
-class AstRepeat(AstNode):
-    name = 'repeat'
-    count: AstNode
-    body: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.count, self.body))
-
-
-@dataclass
-class AstIf(AstNode):
-    name = 'if'
-    cond: AstNode
-    if_body: list[AstNode]
-    # elseif = else{if
-    else_body: list[AstNode] | None = None
-    # ^ Separate cases for no block and empty block (can be else {} to easily
-    # add extra blocks in scratch interface)
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.cond, self.if_body, self.else_body))
-
-
-@dataclass
-class AstWhile(AstNode):
-    name = 'while'
-    cond: AstNode
-    body: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.cond, self.body))
-
-
-@dataclass
-class AstAssign(AstNode):
-    name = '='
-    target: AstNode
-    source: AstNode
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.target, self.source))
-
-
-@dataclass
-class AstAugAssign(AstNode):
-    op: str  # maybe attach a StrRegion to the location of the op??
-    target: AstNode
-    source: AstNode
-
-    @property
-    def name(self):
-        return self.op
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.target, self.source))
-
-
-@dataclass
-class AstDefine(AstNode):
-    name = 'def'
-
-    ident: AstIdent
-    params: list[tuple[AstIdent, AstIdent]]  # type, ident
-    body: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.ident, self.params, self.body))
-# endregion ---- </Statements> ----
-
-
-# region ---- <Expressions> ----
-@dataclass
-class AstNumber(AstNode):
-    # No real point in storing the string representation (could always StrRegion.resolve())
-    value: float | int
-
-
-@dataclass
-class AstString(AstNode):
-    value: str  # Values with escapes, etc. resolved
-
-
-@dataclass
-class AstAnyName(AstNode):
-    id: str
-
-    def __post_init__(self):
-        if type(self) == AstAnyName:
-            raise TypeError("AstAnyName must not be instantiated directly.")
-
-
-@dataclass
-class AstIdent(AstAnyName):
-    name = 'ident'
-
-
-@dataclass
-class AstAttrName(AstAnyName):
-    name = 'attr'
-
-
-@dataclass
-class AstListLiteral(AstNode):
-    name = 'list'
-    items: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.items,))
-
-
-@dataclass
-class AstAttribute(AstNode):
-    name = '.'
-    obj: AstNode
-    attr: AstAttrName
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.obj, self.attr))
-
-
-@dataclass
-class AstItem(AstNode):
-    name = 'item'
-    obj: AstNode
-    index: AstNode
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.obj, self.index))
-
-
-@dataclass
-class AstCall(AstNode):
-    name = 'call'
-    obj: AstNode
-    args: list[AstNode]
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.obj, self.args))
-
-
-@dataclass
-class AstOp(AstNode):
-    op: str
-
-
-@dataclass
-class AstBinOp(AstOp):
-    left: AstNode
-    right: AstNode
-
-    valid_ops = [*'+-*/%', '**', '..', '||', '&&',  # ops
-                 '==', '!=', '<', '>', '<=', '>='  # comparisons
-                 ]  # type: list[str]
-
-    def __post_init__(self):
-        assert self.op in self.valid_ops
-
-    @property
-    def name(self):
-        return self.op
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.left, self.right))
-
-
-@dataclass
-class AstUnaryOp(AstOp):
-    operand: AstNode
-
-    valid_ops = ('+', '-', '!')
-
-    def __post_init__(self):
-        assert self.op in self.valid_ops
-
-    @property
-    def name(self):
-        return self.op
-
-    def _walk_members(self, fn: WalkerFnT):
-        self.walk_multiple_objects(fn, (self.operand,))
-# endregion ---- </Expressions> ----
+WalkableL0: TypeAlias = AstNode | list[AstNode] | tuple[AstNode, ...] | None
+WalkableT: TypeAlias = WalkableL0 | list[WalkableL0] | tuple[WalkableL0, ...]
+WalkerFnT: TypeAlias = Callable[[WalkableT, WalkerCallType], bool | None]
+"""Returns True if skip"""
diff --git a/parser/astgen/ast_nodes.py b/parser/astgen/ast_nodes.py
new file mode 100644
index 0000000..a3e3590
--- /dev/null
+++ b/parser/astgen/ast_nodes.py
@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from .ast_node import AstNode, WalkerFnT, MetadataT
+
+__all__ = [
+    "AstNode", "AstProgramNode", "VarDeclScope", "VarDeclType", "AstDeclNode",
+    "AstRepeat", "AstIf", "AstWhile", "AstAssign", "AstAugAssign", "AstDefine",
+    "AstNumber", "AstString", "AstAnyName", "AstIdent", "AstAttrName",
+    "AstListLiteral", "AstAttribute", "AstItem", "AstCall", "AstOp", "AstBinOp",
+    "AstUnaryOp",
+]
+
+
+@dataclass
+class AstProgramNode(AstNode[MetadataT]):
+    name = 'program'
+    statements: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.statements,))
+
+
+# region ---- <Statements> ----
+class VarDeclScope(Enum):
+    LET = 'let'
+    GLOBAL = 'global'
+
+
+class VarDeclType(Enum):
+    VARIABLE = 'variable'
+    LIST = 'list'
+
+
+@dataclass
+class AstDeclNode(AstNode[MetadataT]):
+    name = 'var_decl'
+    scope: VarDeclScope
+    type: VarDeclType
+    ident: AstIdent
+    value: AstNode[MetadataT] | None
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.ident, self.value))
+
+
+@dataclass
+class AstRepeat(AstNode[MetadataT]):
+    name = 'repeat'
+    count: AstNode[MetadataT]
+    body: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.count, self.body))
+
+
+@dataclass
+class AstIf(AstNode[MetadataT]):
+    name = 'if'
+    cond: AstNode[MetadataT]
+    if_body: list[AstNode[MetadataT]]
+    # elseif = else{if
+    else_body: list[AstNode[MetadataT]] | None = None
+    # ^ Separate cases for no block and empty block (can be else {} to easily
+    # add extra blocks in scratch interface)
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.cond, self.if_body, self.else_body))
+
+
+@dataclass
+class AstWhile(AstNode[MetadataT]):
+    name = 'while'
+    cond: AstNode[MetadataT]
+    body: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.cond, self.body))
+
+
+@dataclass
+class AstAssign(AstNode[MetadataT]):
+    name = '='
+    target: AstNode[MetadataT]
+    source: AstNode[MetadataT]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.target, self.source))
+
+
+@dataclass
+class AstAugAssign(AstNode[MetadataT]):
+    op: str  # maybe attach a StrRegion to the location of the op??
+    target: AstNode[MetadataT]
+    source: AstNode[MetadataT]
+
+    @property
+    def name(self):
+        return self.op
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.target, self.source))
+
+
+@dataclass
+class AstDefine(AstNode[MetadataT]):
+    name = 'def'
+
+    ident: AstIdent
+    params: list[tuple[AstIdent, AstIdent]]  # type, ident
+    body: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.ident, self.params, self.body))
+# endregion ---- </Statements> ----
+
+
+# region ---- <Expressions> ----
+@dataclass
+class AstNumber(AstNode[MetadataT]):
+    # No real point in storing the string representation (could always StrRegion.resolve())
+    value: float | int
+
+
+@dataclass
+class AstString(AstNode[MetadataT]):
+    value: str  # Values with escapes, etc. resolved
+
+
+@dataclass
+class AstAnyName(AstNode[MetadataT]):
+    id: str
+
+    def __post_init__(self):
+        if type(self) == AstAnyName:
+            raise TypeError("AstAnyName must not be instantiated directly.")
+
+
+@dataclass
+class AstIdent(AstAnyName):
+    name = 'ident'
+
+
+@dataclass
+class AstAttrName(AstAnyName):
+    name = 'attr'
+
+
+@dataclass
+class AstListLiteral(AstNode[MetadataT]):
+    name = 'list'
+    items: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.items,))
+
+
+@dataclass
+class AstAttribute(AstNode[MetadataT]):
+    name = '.'
+    obj: AstNode[MetadataT]
+    attr: AstAttrName
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.obj, self.attr))
+
+
+@dataclass
+class AstItem(AstNode[MetadataT]):
+    name = 'item'
+    obj: AstNode[MetadataT]
+    index: AstNode[MetadataT]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.obj, self.index))
+
+
+@dataclass
+class AstCall(AstNode[MetadataT]):
+    name = 'call'
+    obj: AstNode[MetadataT]
+    args: list[AstNode[MetadataT]]
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.obj, self.args))
+
+
+@dataclass
+class AstOp(AstNode[MetadataT]):
+    op: str
+
+
+@dataclass
+class AstBinOp(AstOp[MetadataT]):
+    left: AstNode[MetadataT]
+    right: AstNode[MetadataT]
+
+    valid_ops = [*'+-*/%', '**', '..', '||', '&&',  # ops
+                 '==', '!=', '<', '>', '<=', '>='  # comparisons
+                 ]  # type: list[str]
+
+    def __post_init__(self):
+        assert self.op in self.valid_ops
+
+    @property
+    def name(self):
+        return self.op
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.left, self.right))
+
+
+@dataclass
+class AstUnaryOp(AstOp[MetadataT]):
+    operand: AstNode[MetadataT]
+
+    valid_ops = ('+', '-', '!')
+
+    def __post_init__(self):
+        assert self.op in self.valid_ops
+
+    @property
+    def name(self):
+        return self.op
+
+    def _walk_members(self, fn: WalkerFnT):
+        self.walk_multiple_objects(fn, (self.operand,))
+# endregion ---- </Expressions> ----
diff --git a/parser/astgen/astgen.py b/parser/astgen/astgen.py
index 1d2f4fe..bb10256 100644
--- a/parser/astgen/astgen.py
+++ b/parser/astgen/astgen.py
@@ -5,7 +5,7 @@
 from typing import Callable, overload, TypeVar, TypeAlias
 
 from util import flatten_force, is_strict_subclass
-from .ast_node import *
+from .ast_nodes import *
 from .eval_literal import eval_number, eval_string
 from .errors import LocatedAstError
 from ..common import region_union, RegionUnionArgT, HasRegion, StrRegion
@@ -68,7 +68,7 @@ def _detect_autowalk_type_from_annot(fn):
         bound = sig.bind(0, 1)  # simulate call w/ 2 args
     except TypeError as e:  # pragma: no cover
         raise TypeError("Unable to detect node_type (signature may be incompatible)") from e
-    arg2_name: str = (*bound.arguments,)[1]  # get name it's bound to
+    arg2_name: str = tuple(bound.arguments)[1]  # get name it's bound to
     param = sig.parameters[arg2_name]  # lookup the param by name
     if param.kind not in (param.POSITIONAL_ONLY,
                           param.POSITIONAL_OR_KEYWORD):  # pragma: no cover
@@ -111,6 +111,7 @@ def _walk_smt(self, smt: AnyNode) -> list[AstNode]:
         elif isinstance(smt, ConditionalBlock):
             return self._walk_conditional(smt)
         elif isinstance(smt, AssignNode):  # Simple assignment
+            # TODO: maybe separate SetAttr, SetItem, SetVar nodes?
             return [AstAssign(smt.region, self._walk_assign_left(smt.target),
                               self._walk_expr(smt.source))]
         elif isinstance(smt, AssignOpNode):  # Other (aug.) assignment
diff --git a/parser/astgen/filtered_walker.py b/parser/astgen/filtered_walker.py
new file mode 100644
index 0000000..ce6c2ef
--- /dev/null
+++ b/parser/astgen/filtered_walker.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import Callable, TypeVar
+
+from util import flatten_force
+from .ast_node import WalkerCallType, WalkableT, walk_ast
+
+__all__ = ['WalkerFilterRegistry', 'FilteredWalker', 'walk_ast']
+
+VT = TypeVar('VT')
+WT = TypeVar('WT', bound=WalkableT)
+
+SpecificCbT = Callable[[WT], bool | None]
+SpecificCbsDict = dict[type[WT] | type, list[SpecificCbT[WT]]]
+BothCbT = Callable[[WT, 'WalkerCallType'], bool | None]
+BothCbsDict = dict[type[WT] | type, list[BothCbT[WT]]]
+
+
+class WalkerFilterRegistry:
+    def __init__(self, enter_cbs: SpecificCbsDict = (),
+                 exit_cbs: SpecificCbsDict = (),
+                 both_sbc: BothCbsDict = ()):
+        self.enter_cbs: SpecificCbsDict = dict(enter_cbs)  # Copy them,
+        self.exit_cbs: SpecificCbsDict = dict(exit_cbs)    # also converts default () -> {}
+        self.both_cbs: BothCbsDict = dict(both_sbc)
+
+    def copy(self):
+        return WalkerFilterRegistry(self.enter_cbs, self.exit_cbs, self.both_cbs)
+
+    def register_both(self, t: type[WT], fn: Callable[[WT, WalkerCallType], bool | None]):
+        self.both_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def register_enter(self, t: type[WT], fn: Callable[[WT], bool | None]):
+        self.enter_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def register_exit(self, t: type[WT], fn: Callable[[WT], bool | None]):
+        self.exit_cbs.setdefault(t, []).append(fn)
+        return self
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def on_enter(self, *tps: type[WT] | type):
+        """Decorator version of register_enter."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_enter(t, fn)
+            return fn
+        return decor
+
+    def on_exit(self, *tps: type[WT] | type):
+        """Decorator version of register_exit."""
+        def decor(fn: SpecificCbT):
+            for t in tps:
+                self.register_exit(t, fn)
+            return fn
+        return decor
+
+    def on_both(self, *tps: type[WT] | type):
+        """Decorator version of register_both."""
+        def decor(fn: BothCbT):
+            for t in tps:
+                self.register_both(t, fn)
+            return fn
+        return decor
+
+
+class FilteredWalker(WalkerFilterRegistry):
+    def __init__(self):
+        cls_reg = self.class_registry()
+        super().__init__(cls_reg.enter_cbs, cls_reg.exit_cbs, cls_reg.both_cbs)
+
+    @classmethod
+    def class_registry(cls) -> WalkerFilterRegistry:
+        return WalkerFilterRegistry()
+
+    @classmethod
+    def create_cls_registry(cls, fn=None):
+        """Create a class-level registry that can be added to using decorators.
+
+        This can be used in two ways (at the top of your class)::
+
+            # MUST be this name
+            class_registry = FilteredWalker.create_cls_registry()
+
+        or::
+
+            @classmethod
+            @FilteredWalker.create_cls_registry
+            def class_registry(cls):  # MUST be this name
+                pass
+
+        and when registering methods::
+
+            @class_registry.on_enter(AstDefine)
+            def enter_define(self, ...):
+                ...
+
+        The restrictions on name are because we have no other way of detecting
+         it (without metaclass dark magic) as we can't refer to the class while
+         its namespace is being evaluated
+        """
+        if fn is not None and (parent := fn(cls)) is not None:
+            return WalkerFilterRegistry.copy(parent)
+        return WalkerFilterRegistry()
+
+    def walk(self, o: WalkableT):
+        return walk_ast(o, self)
+
+    def __call__(self, o: WalkableT, call_type: WalkerCallType):
+        result = None
+        # Call more specific ones first
+        specific_cbs = self.enter_cbs if call_type == WalkerCallType.PRE else self.exit_cbs
+        for fn in self._get_funcs(specific_cbs, type(o)):
+            if result := result or fn(o):
+                return result  # Don't call later ones if already skipped
+        for fn in self._get_funcs(self.both_cbs, type(o)):
+            if result := result or fn(o, call_type):
+                return result
+        return result
+
+    @classmethod
+    def _get_funcs(cls, mapping: dict[type[WT] | type, list[VT]], tp: type[WT]) -> list[VT]:
+        """Also looks at superclasses/MRO"""
+        return flatten_force([mapping.get(sub, []) for sub in _get_mro(tp)])
+
+
+def _get_mro(tp: type) -> tuple[type, ...]:  # tp.__mro__ but with proper types
+    return tp.__mro__  # .mro() recalculates it every time, hence is slow
diff --git a/parser/common/error.py b/parser/common/error.py
index 847be70..5970bb3 100644
--- a/parser/common/error.py
+++ b/parser/common/error.py
@@ -1,10 +1,6 @@
 from __future__ import annotations
 
-import bisect
-import itertools
 import traceback
-from dataclasses import replace as d_replace
-from typing import Sequence
 
 from .common import HasRegion
 from .str_region import StrRegion
@@ -71,8 +67,6 @@ class BaseParseError(_PolyfillAddNoteMixin, Exception):
 
 
 class BaseLocatedError(BaseParseError, HasRegion):
-    __notes__: list[str]  # but might not exist
-
     def __init__(self, msg: str, region: StrRegion, src: str):
         super().__init__(msg)
         self.msg = msg
@@ -94,7 +88,7 @@ def compute_location(self):
             return
         # noinspection PyBroadException
         try:
-            self.add_note(self.display_region(self._src_text, self.region))
+            self.add_note(self.region.display(self._src_text))
         except Exception:
             short_loc = f'{self.region.start} to {self.region.end - 1}'
             self.add_note(
@@ -105,75 +99,3 @@ def compute_location(self):
     def __str__(self):
         self.compute_location()
         return super().__str__()
-
-    @classmethod
-    def display_region(cls, src: str, region: StrRegion) -> str:
-        if region.end > len(src):  # end excl so ok if 1 beyond string
-            region = d_replace(region, end=len(src))
-        if region.start >= len(src):
-            region = d_replace(region, start=len(src) - 1)
-        if region.is_epsilon():
-            # length=0 but still try to do something
-            region = d_replace(region, end=region.start + 1)
-        lines = src.splitlines(keepends=True)
-        cum_lengths = tuple(itertools.accumulate(tuple(map(len, lines))))
-        start_idx = region.start
-        end_idx = region.end - 1  # its inclusive below so convert excl -> incl
-        start_line, start_col = cls.idx_to_coord(cum_lengths, start_idx)
-        end_line, end_col = cls.idx_to_coord(cum_lengths, end_idx)
-        if start_line == end_line:
-            return cls._display_single_line(lines, start_line, start_col, end_col)
-        assert start_line < end_line
-        return cls._display_multi_line(lines, start_line, start_col, end_line, end_col)
-
-    @classmethod
-    def _display_multi_line(cls, lines: Sequence[str], start_line: int, start_col: int,
-                            end_line: int, end_col: int):
-        if end_line - start_line + 1 > 5:
-            # just print start and end lines
-            lineno_w = len(str(end_line + 1))  # last will always be biggest
-            start_repr = cls._display_single_line(
-                lines, start_line, start_col, len(lines[start_line]) - 1, lineno_w)
-            end_repr = cls._display_single_line(
-                lines, end_line, 0, end_col, lineno_w)
-            return (f'{start_repr}\n'
-                    f'...\n'
-                    f'{end_repr}')
-        lines_repr = []
-        lineno_w = len(str(end_line + 1))
-        for line in range(start_line, end_line + 1):
-            if line == start_line:
-                start_col_inner = start_col
-            else:
-                start_col_inner = 0
-            if line == end_line:
-                end_col_inner = end_col
-            else:
-                end_col_inner = len(lines[line]) - 2  # another for the \n at end
-            line_repr = cls._display_single_line(
-                lines, line, start_col_inner, end_col_inner, lineno_w)
-            lines_repr.append(f'{line_repr}')
-        return '\n'.join(lines_repr)
-
-    @classmethod
-    def _display_single_line(cls, lines: Sequence[str], line: int, start_col: int,
-                             end_col: int, lineno_w: int = None):
-        start_spaces = ' ' * start_col
-        carets = '^' * (end_col - start_col + 1)
-        end_spaces = ' ' * (len(lines[line]) - end_col)
-        if lineno_w is None:
-            lineno_w = len(str(line + 1))
-        (line_str,) = lines[line].splitlines()  # remove \n on end
-        return (f'{line + 1:>{lineno_w}} |  {line_str}\n'
-                f'{""      :>{lineno_w}} |  {start_spaces}{carets}{end_spaces}')
-
-    @classmethod
-    def idx_to_coord(cls, cum_lengths: Sequence[int], idx: int) -> tuple[int, int]:
-        """Converts an index to a **0-based** (line, column) tuple"""
-        line = bisect.bisect_right(cum_lengths, idx)
-        if line == 0:
-            return line, idx
-        # -1 to convert to idx, +1 to for char after last char on prev line
-        line_start_idx = cum_lengths[line - 1]  # - 1 + 1
-        col = idx - line_start_idx
-        return line, col
diff --git a/parser/common/str_region.py b/parser/common/str_region.py
index 20ddd89..c514e6c 100644
--- a/parser/common/str_region.py
+++ b/parser/common/str_region.py
@@ -2,6 +2,11 @@
 
 from dataclasses import dataclass
 
+import bisect
+import itertools
+from dataclasses import replace as d_replace
+from typing import Sequence
+
 __all__ = ['StrRegion']
 
 
@@ -34,3 +39,81 @@ def __or__(self, other: StrRegion):
     def is_epsilon(self):
         """Return true if the length of the region is 0"""
         return self.end <= self.start
+
+    def display(self, src: str):
+        # Logic held in separate class as it is rather complex
+        return _RegionPrinter.display_region(src, self)
+
+
+class _RegionPrinter:
+    @classmethod
+    def display_region(cls, src: str, region: StrRegion) -> str:
+        if region.end > len(src):  # end excl so ok if 1 beyond string
+            region = d_replace(region, end=len(src))
+        if region.start >= len(src):
+            region = d_replace(region, start=len(src) - 1)
+        if region.is_epsilon():
+            # length=0 but still try to do something
+            region = d_replace(region, end=region.start + 1)
+        lines = src.splitlines(keepends=True)
+        cum_lengths = tuple(itertools.accumulate(tuple(map(len, lines))))
+        start_idx = region.start
+        end_idx = region.end - 1  # its inclusive below so convert excl -> incl
+        start_line, start_col = cls._idx_to_coord(cum_lengths, start_idx)
+        end_line, end_col = cls._idx_to_coord(cum_lengths, end_idx)
+        if start_line == end_line:
+            return cls._display_single_line(lines, start_line, start_col, end_col)
+        assert start_line < end_line
+        return cls._display_multi_line(lines, start_line, start_col, end_line, end_col)
+
+    @classmethod
+    def _display_multi_line(cls, lines: Sequence[str], start_line: int, start_col: int,
+                            end_line: int, end_col: int):
+        if end_line - start_line + 1 > 5:
+            # just print start and end lines
+            lineno_w = len(str(end_line + 1))  # last will always be biggest
+            start_repr = cls._display_single_line(
+                lines, start_line, start_col, len(lines[start_line]) - 1, lineno_w)
+            end_repr = cls._display_single_line(
+                lines, end_line, 0, end_col, lineno_w)
+            return (f'{start_repr}\n'
+                    f'...\n'
+                    f'{end_repr}')
+        lines_repr = []
+        lineno_w = len(str(end_line + 1))
+        for line in range(start_line, end_line + 1):
+            if line == start_line:
+                start_col_inner = start_col
+            else:
+                start_col_inner = 0
+            if line == end_line:
+                end_col_inner = end_col
+            else:
+                end_col_inner = len(lines[line]) - 2  # another for the \n at end
+            line_repr = cls._display_single_line(
+                lines, line, start_col_inner, end_col_inner, lineno_w)
+            lines_repr.append(f'{line_repr}')
+        return '\n'.join(lines_repr)
+
+    @classmethod
+    def _display_single_line(cls, lines: Sequence[str], line: int, start_col: int,
+                             end_col: int, lineno_w: int = None):
+        start_spaces = ' ' * start_col
+        carets = '^' * (end_col - start_col + 1)
+        end_spaces = ' ' * (len(lines[line]) - end_col)
+        if lineno_w is None:
+            lineno_w = len(str(line + 1))
+        (line_str,) = lines[line].splitlines()  # remove \n on end
+        return (f'{line + 1:>{lineno_w}} |  {line_str}\n'
+                f'{""      :>{lineno_w}} |  {start_spaces}{carets}{end_spaces}')
+
+    @classmethod
+    def _idx_to_coord(cls, cum_lengths: Sequence[int], idx: int) -> tuple[int, int]:
+        """Converts an index to a **0-based** (line, column) tuple"""
+        line = bisect.bisect_right(cum_lengths, idx)
+        if line == 0:
+            return line, idx
+        # -1 to convert to idx, +1 to for char after last char on prev line
+        line_start_idx = cum_lengths[line - 1]  # - 1 + 1
+        col = idx - line_start_idx
+        return line, col
diff --git a/parser/common/tree_print.py b/parser/common/tree_print.py
index e4d3ce3..40b39c2 100644
--- a/parser/common/tree_print.py
+++ b/parser/common/tree_print.py
@@ -1,11 +1,14 @@
 from __future__ import annotations
 
+import dataclasses
 import dataclasses as dcls
 import enum
 import sys
+from collections import UserString
 from io import StringIO
 from typing import IO, Sequence
 
+from util import dcls_field_default
 from ..astgen.ast_node import AstNode
 from ..cst.base_node import Leaf, AnyNode, Node
 from .str_region import StrRegion
@@ -15,6 +18,37 @@
 ]
 
 
+@dataclasses.dataclass
+class Concat:
+    args: tuple[object, ...]
+
+    def __init__(self, *args: object):
+        self.args = args
+
+
+class ConcatLiteral(UserString):
+    pass
+
+
+@dataclasses.dataclass
+class IndentInfo:
+    """Represents a first/current-line indentation and a possibly-different
+    indentation for the next line."""
+
+    level: int
+    start_level: int = dataclasses.field(default=-1)
+
+    def __post_init__(self):
+        if self.start_level == -1:
+            self.start_level = self.level
+
+    def subindent(self, n=1, indent_first_line=True):
+        return type(self)(self.level + n, -1 if indent_first_line else 0)
+
+    def get_indent(self, first_line: bool = False):
+        return self.start_level if first_line else self.level
+
+
 class TreePrinter:
     def __init__(self, stream: IO[str] = None, indent=2, verbose=False, append_lf=False):
         self.indent = indent
@@ -25,7 +59,7 @@ def __init__(self, stream: IO[str] = None, indent=2, verbose=False, append_lf=Fa
         self.stream = stream
 
     def print(self, obj: object):
-        self._write(obj, 0)
+        self._write(obj, IndentInfo(0))
         if self.append_lf:
             self.stream.write('\n')
 
@@ -38,61 +72,114 @@ def format(self, obj: object):
             self.stream = orig_stream
         return out.getvalue()
 
-    def _write(self, obj: object, level: int):
-        if isinstance(obj, StrRegion):
-            self._indented_write(level, self._fmt_region(obj))
+    def _write(self, obj: object, indent: IndentInfo):
+        # TODO: general dataclass pretty-printing
+        if isinstance(obj, Concat):
+            self._write_concat(obj, indent)
+        elif isinstance(obj, StrRegion):
+            self._write_region(obj, indent)
         elif isinstance(obj, Node):
-            self._write_cst_node(obj, level)
+            self._write_cst_node(obj, indent)
         elif isinstance(obj, Leaf):
-            self._write_cst_leaf(obj, level)
+            self._write_cst_leaf(obj, indent)
         elif isinstance(obj, AstNode):
-            self._write_ast_node(obj, level)
+            self._write_ast_node(obj, indent)
         elif isinstance(obj, list):
-            self._write_seq(obj, level, '[', ']')
+            self._write_seq(obj, indent, '[', ']')
         elif isinstance(obj, tuple):
-            self._write_seq(obj, level, '(', ')', True)
+            self._write_seq(obj, indent, '(', ')', True)
         elif isinstance(obj, enum.Enum):
-            self._indented_write(level, f'{type(obj).__name__}.{obj.name}')
+            self._write_enum(obj, indent)
         else:
-            self._write_fallback(obj, level)
+            self._write_fallback(obj, indent)
+
+    def _write_region(self, obj: StrRegion, indent: IndentInfo):
+        self._indented_write(self._fmt_region(obj), indent, first_line=True)
+
+    def _write_enum(self, obj: enum.Enum, indent: IndentInfo):
+        self._indented_write(f'{type(obj).__name__}.{obj.name}', indent, first_line=True)
 
-    def _write_seq(self, obj: Sequence, level: int, start: str,
+    def _write_concat(self, obj: Concat, indent: IndentInfo):
+        self._indented_write('', indent, first_line=True)  # write start indent
+        for o in obj.args:
+            if isinstance(o, ConcatLiteral):
+                self._indented_write(str(o), 0)
+            else:
+                self._write(o, indent.subindent(0, indent_first_line=False))
+
+    def _write_seq(self, obj: Sequence[object], indent: IndentInfo, start: str,
                    end: str, require_trailing=False):
-        self._indented_write(level, start)
+        self._indented_write(start, indent, first_line=True)
         if len(obj) == 0:
             self.stream.write(end)
             return
         self.stream.write('\n')  # Start items on new line
         for i, c in enumerate(obj):
-            self._write(c, level + 1)
+            self._write(c, indent.subindent())
             if i != len(obj) - 1:
                 self.stream.write(',\n')
             elif require_trailing and len(obj) == 1:
                 self.stream.write(',')
         self.stream.write('\n')  # Put ']' on new line
-        self._indented_write(level, end)
+        self._indented_write(end, indent)
 
-    def _write_cst_node(self, obj: Node, level: int):
+    def _write_cst_node(self, obj: Node, indent: IndentInfo):
         start = self._fmt_node_header(obj, has_more_args=True) + '['
-        self._write_seq(obj.children, level, start, end='])')
+        self._write_seq(obj.children, indent, start, end='])')
 
-    def _write_cst_leaf(self, obj: Leaf, level: int):
-        self._indented_write(level, self._fmt_node_header(obj, has_more_args=False) + ')')
+    def _write_cst_leaf(self, obj: Leaf, indent: IndentInfo):
+        self._indented_write(self._fmt_node_header(obj, has_more_args=False) + ')', indent)
 
-    def _write_ast_node(self, obj: AstNode, level: int):
+    def _write_ast_node(self, obj: AstNode, indent: IndentInfo):
         # TODO Not the ideal formatting (but I don't know what is.
-        values = [getattr(obj, f.name) for f in dcls.fields(obj)]
-        if any(isinstance(v, (AnyNode, AstNode, list, tuple)) for v in values):
-            assert len(values) > 1  # Otherwise wouldn't be complex
-            start = f'{type(obj).__name__}({self._fmt_region(obj.region)},'
-            return self._write_seq(values[1:], level, start, end=')')
-        self._indented_write(level, f'{type(obj).__name__}(')
-        for i, v in enumerate(values):
-            self._write(v, 0)
-            if i != len(values) - 1:
+        field_values = [(f, getattr(obj, f.name)) for f in dcls.fields(obj)]
+        pos_field_values = [(f, v) for f, v in field_values if not f.kw_only]
+        while (pos_field_values and
+               dcls_field_default(pos_field_values[-1][0])
+               == pos_field_values[-1][1]):
+            pos_field_values.pop(-1)  # start from last, remove default ones
+        pos_values = [(None, v) for _f, v in pos_field_values]
+        kw_values = [(f.name, v) for f, v in field_values
+                     if f.kw_only and v != dcls_field_default(f)]
+        values = pos_values + kw_values
+        # Put the named ones at end. NOTE: relies on sort stability
+        values.sort(key=lambda pair: pair[0] is not None)
+        if ('meta', None) in values:  # special case: remove meta= if no metadata
+            values.remove(('meta', None))
+        assert values[0] == (None, obj.region)  # sanity check (region is first arg)
+        args = [
+            v if k is None else Concat(ConcatLiteral(f'{k}='), v)
+            for k, v in values
+        ]
+        if self._is_complex(*args):
+            return self._write_complex_ast_node(obj, args, indent)
+        return self._write_simple_ast_node(obj, args, indent)
+
+    @classmethod
+    def _is_complex(cls, *args: object) -> bool:
+        if len(args) != 1:
+            return any(cls._is_complex(a) for a in args)
+        (a,) = args
+        if isinstance(a, Concat):
+            return cls._is_complex(*a.args)
+        return isinstance(a, (AnyNode, AstNode, list, tuple))
+
+    def _write_simple_ast_node(self, obj: AstNode, args: list[object],
+                               indent: IndentInfo):
+        self._indented_write(f'{type(obj).__name__}(', indent, first_line=True)
+        for i, v in enumerate(args):
+            # The subindent is just in case one of them does contain a
+            self._write(v, indent.subindent(indent_first_line=False))
+            if i != len(args) - 1:
                 self.stream.write(', ')
         self.stream.write(')')
 
+    def _write_complex_ast_node(self, obj: AstNode, args: list[object],
+                                indent: IndentInfo):
+        start = f'{type(obj).__name__}({self._fmt_region(obj.region)},'
+        del args[0]  # Remove the region argument
+        return self._write_seq(args, indent, start, end=')')
+
     def _fmt_node_header(self, obj: AnyNode, has_more_args=True):
         args: list[str] = []
         if type(obj) == Leaf or type(obj) == Node:
@@ -103,10 +190,14 @@ def _fmt_node_header(self, obj: AnyNode, has_more_args=True):
             args.append('')  # Placeholder for next arg so ', ' gets added
         return f'{type(obj).__name__}({", ".join(args)}'
 
-    def _write_fallback(self, obj: object, level: int):
-        self._indented_write(level, repr(obj))
+    def _write_fallback(self, obj: object, level: IndentInfo):
+        lines = repr(obj).splitlines()
+        for i, ln in enumerate(lines):
+            self._indented_write(ln, level, first_line=(i == 0))
 
-    def _indented_write(self, level: int, s: str):
+    def _indented_write(self, s: str, level: IndentInfo | int, first_line: bool = False):
+        if isinstance(level, IndentInfo):
+            level = level.get_indent(first_line=first_line)
         if level:
             self.stream.write(' ' * level * self.indent)
         self.stream.write(s)
diff --git a/parser/cst/cstgen.py b/parser/cst/cstgen.py
index 146001c..1fe291d 100644
--- a/parser/cst/cstgen.py
+++ b/parser/cst/cstgen.py
@@ -530,7 +530,7 @@ def _parse_cat(self, idx: int) -> tuple[AnyNode, int]:
 
     def _parse_comp(self, idx: int) -> tuple[AnyNode, int]:
         first, idx = self._parse_cat(idx)
-        parts = [first]
+        parts: list[AnyNode | OpToken] = [first]
         while self.match_ops(idx, COMPARISONS):
             op_tok = cast(OpToken, self[idx])
             idx += 1
diff --git a/parser/cst/named_node.py b/parser/cst/named_node.py
index 81dd0cd..ab56c86 100644
--- a/parser/cst/named_node.py
+++ b/parser/cst/named_node.py
@@ -53,8 +53,7 @@ def of(cls, token: HasRegion, parent: Node | None = None):
         return cls(token.region, parent)
 
 
-AnyNamedNode: type[_AnyNamedNodeT] | type[NamedLeafCls] = cast(
-    type[_AnyNamedNodeT], NamedLeafCls)
+AnyNamedNode: type[_AnyNamedNodeT] | type[NamedLeafCls] = NamedLeafCls
 
 
 @dataclass
@@ -128,7 +127,7 @@ def register_once(name: str, cls: type[AnyNamedNode]):
             NAME_REGISTRY[name, cls.size] = cls
         else:
             # Cast required because Pycharm stupid
-            NAME_REGISTRY[name, cast(int, arity)] = cls
+            NAME_REGISTRY[name, arity] = cls
 
     def decor(cls: type[AnyNamedNode]):
         for n in names:
diff --git a/parser/cst/token_matcher.py b/parser/cst/token_matcher.py
index 28f2eac..e5d32ac 100644
--- a/parser/cst/token_matcher.py
+++ b/parser/cst/token_matcher.py
@@ -125,7 +125,7 @@ def _issubclass(cls: object, cls_or_tuple: type | tuple[type, ...]):
 class Matcher:
     # start argument is to save memory as then the list slices
     # don't have to be stored separately
-    def __init__(self, pattern: Iterable | type[Token] | Token | BaseMatcher,
+    def __init__(self, pattern: Iterable[BaseMatcher] | type[Token] | Token | BaseMatcher,
                  tokens: list[Token], start: int, src: str):
         self.src = src
         self.pattern = pattern
@@ -161,13 +161,13 @@ def _match(self):
         self.result = self.pattern.matches(self.tokens, self.start, self.src)
 
 
-def matches(pattern: Iterable | type[Token] | Token | BaseMatcher,
+def matches(pattern: Iterable[BaseMatcher] | type[Token] | Token | BaseMatcher,
             tokens: list[Token], start: int, src: str,
             want_complete: bool = False) -> bool:
     return Matcher(pattern, tokens, start, src).match(want_complete).success
 
 
-def match(pattern: Iterable | type[Token] | Token | BaseMatcher,
+def match(pattern: Iterable[BaseMatcher] | type[Token] | Token | BaseMatcher,
           tokens: list[Token], start: int, src: str,
           want_complete: bool = False) -> MatchResult:
     return Matcher(pattern, tokens, start, src).match(want_complete).result
diff --git a/parser/typecheck/name_resolver.py b/parser/typecheck/name_resolver.py
new file mode 100644
index 0000000..39a81f0
--- /dev/null
+++ b/parser/typecheck/name_resolver.py
@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from util.recursive_eq import recursive_eq
+from ..astgen.ast_node import AstNode
+from ..astgen.ast_nodes import AstIdent, AstDeclNode, VarDeclScope, VarDeclType, AstDefine
+from ..astgen.astgen import AstGen
+from ..astgen.filtered_walker import FilteredWalker
+
+from ..common import BaseLocatedError, StrRegion, RegionUnionArgT, region_union
+from .types import TypeInfo, FunctionType, ValType, ListType, BoolType, VoidType, PARAM_TYPES
+
+
+@dataclass
+class NameInfo:
+    decl_scope: Scope
+    ident: str
+    tp_info: TypeInfo
+    # node: AstNode  # <-- Why do we need this?
+    is_param: bool = field(default=False, kw_only=True)
+
+
+@dataclass
+class FuncInfo(NameInfo):
+    tp_info: FunctionType  # Overrides types (doesn't change order)
+    params_info: list[ParamInfo]
+    # Can't just pass default_factory=Scope as it is only defined below
+    subscope: Scope = field(default_factory=lambda: Scope())
+
+    @classmethod
+    def from_param_info(
+            cls, decl_scope: Scope, ident: str, params_info: list[ParamInfo],
+            ret_type: TypeInfo, subscope: Scope = None):
+        subscope = subscope or Scope()
+        tp_info = FunctionType([p.tp for p in params_info], ret_type)
+        return cls(decl_scope, ident, tp_info, params_info, subscope)
+
+
+@dataclass
+class ParamInfo:
+    name: str
+    tp: TypeInfo
+
+
+@dataclass
+class Scope:
+    declared: dict[str, NameInfo] = field(default_factory=dict)
+    used: dict[str, NameInfo] = field(default_factory=dict)
+    """Add references to outer scopes' variables that we use.
+    (so type codegen/type-checker knows what each AstIdent refers to)"""
+
+
+# Prevent declared -> scope cmp recursion error
+Scope.__eq__ = recursive_eq(Scope.__eq__)
+
+
+class NameResolutionError(BaseLocatedError):
+    pass
+
+
+# Variables:
+#  - We can prevent usages before the variable is declared in 2 ways:
+#    - Based on time: very sensible, like JS, but requires too many runtime features
+#    - Based on location: somewhat makes sense except for inner functions -
+#       they may be called later so should be able to access any variables.
+#  - Or we can just ignore it (e.g. `var` in JS) and pretend everything was
+#     declared at the top (but not assigned to - i.e. hoist `var foo;` to top).
+# To minimise accidental errors, option 1.2 is best
+#  (errors shouldn't pass silently, and that method requires no special runtime)
+class NameResolver:
+    def __init__(self, astgen: AstGen):
+        self.astgen = astgen
+        self.src = self.astgen.src
+        self.top_scope: Scope | None = None
+
+    def _init(self):
+        self.ast = self.astgen.parse()
+        self.top_scope = Scope()
+
+    def run(self):
+        if self.top_scope:
+            return self.top_scope
+        self._init()
+        self.run_on_new_scope(self.ast.statements, curr_scope=self.top_scope)
+        return self.top_scope
+
+    def run_on_new_scope(self, block: list[AstNode], parent_scopes: list[Scope] = None,
+                         curr_scope: Scope = None):
+        # TODO: this could be done cleaner with a separate class for the walker
+        def enter_ident(n: AstIdent):
+            for s in reversed(scope_stack):
+                if info := s.declared.get(n.id):
+                    curr_scope.used[n.id] = info
+                    return
+            raise self.err(f"Name '{n.id}' is not defined", n)
+
+        def enter_decl(n: AstDeclNode):
+            # Need semi-special logic here to prevent walking it walking
+            # the AstIdent that is currently being declared.
+            AstNode.walk_obj(n.value, walker)  # Don't walk `n.ident`
+            # Do this after walking (that is when the name is bound)
+            ident = n.ident.id
+            target_scope = curr_scope if n.scope == VarDeclScope.LET else self.top_scope
+            if ident in target_scope.declared:
+                raise self.err("Variable already declared", n.ident)
+            target_scope.declared[ident] = NameInfo(target_scope, ident, (
+                ValType() if n.type == VarDeclType.VARIABLE else ListType()))
+            return True
+
+        def enter_fn_decl(fn: AstDefine):
+            ident = fn.ident.id
+            if ident in curr_scope.declared:
+                raise self.err("Function already declared", fn.ident)
+            subscope = Scope()
+            params: list[ParamInfo] = []
+            for tp_node, name_node in fn.params:
+                if tp_node.id not in PARAM_TYPES:
+                    raise self.err("Unknown parameter type", tp_node)
+                if (name := name_node.id) in subscope.declared:
+                    raise self.err("There is already a parameter of this name", name_node)
+                tp = BoolType() if tp_node.id == 'bool' else ValType()
+                subscope.declared[name] = NameInfo(subscope, name, tp, is_param=True)
+                params.append(ParamInfo(name, tp))
+            curr_scope.declared[ident] = info = FuncInfo.from_param_info(
+                curr_scope, ident, params,
+                ret_type=VoidType(), subscope=subscope)
+            inner_funcs.append((info, fn))  # Store funcs for later walking
+            # Skip walking body, only walk inner after collecting all declared
+            #  variables in outer scope so function can use all variables
+            #  declared in outer scope - even the ones declared below it)
+            return True
+
+        curr_scope = curr_scope or Scope()
+        scope_stack = parent_scopes or []
+        scope_stack.append(curr_scope)
+        inner_funcs: list[tuple[FuncInfo, AstDefine]] = []
+        # Walk self
+        walker = (FilteredWalker()
+                  .register_enter(AstIdent, enter_ident)
+                  .register_enter(AstDeclNode, enter_decl)
+                  .register_enter(AstDefine, enter_fn_decl))
+        walker.walk(block)
+        # Walk sub-functions
+        for fn_info, fn_decl in inner_funcs:
+            fn_info.subscope = self.run_on_new_scope(
+                fn_decl.body, scope_stack, fn_info.subscope)
+        return scope_stack.pop()  # Remove current scope from stack & return it
+
+    def err(self, msg: str, loc: RegionUnionArgT):
+        return NameResolutionError(msg, region_union(loc), self.src)
diff --git a/parser/typecheck/typecheck.py b/parser/typecheck/typecheck.py
index e989aa1..94064ff 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -1,220 +1,237 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+import functools
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TypeAlias
 
-from util.recursive_eq import recursive_eq
-from ..astgen.ast_node import (
-    AstNode, walk_ast, AstIdent, AstDeclNode, AstDefine, VarDeclType,
-    VarDeclScope, FilteredWalker)
-from ..astgen.astgen import AstGen
-from ..common import BaseLocatedError, StrRegion
+from .name_resolver import FuncInfo, Scope, NameResolver
+from .types import TypeInfo, ValType, BoolType, ListType, VoidType, FunctionType
+from ..astgen.ast_nodes import *
+from ..common import BaseLocatedError, region_union, RegionUnionArgT
 
 
-@dataclass
-class TypeInfo:
-    def __post_init__(self):
-        assert type(self) != TypeInfo, "Cannot instantiate TypeInfo directly,use a subclass"
-
-
-@dataclass
-class ValType(TypeInfo):
-    pass
-
-
-@dataclass
-class BoolType(TypeInfo):
-    pass
-
-
-@dataclass
-class ListType(TypeInfo):
-    pass
-
-
-@dataclass
-class VoidType(TypeInfo):
-    """The ``void`` type - represents 'there must not be a value here'.
-
-    For example, this is the return type of function that don't return anything
-    (e.g. all regular user-defined scratch functions).
-    """
-
-
-@dataclass
-class FunctionType(TypeInfo):
-    arg_types: list[TypeInfo]
-    ret_type: TypeInfo
-
-
-@dataclass
-class NameInfo:
-    decl_scope: Scope
-    ident: str
-    tp_info: TypeInfo
-    # node: AstNode  # <-- Why do we need this?
-    is_param: bool = field(default=False, kw_only=True)
-
+class TypecheckError(BaseLocatedError):
+    """Errors raised by the typechecker"""
 
-@dataclass
-class FuncInfo(NameInfo):
-    tp_info: FunctionType  # Overrides types (doesn't change order)
-    params_info: list[ParamInfo]
-    # Can't just pass default_factory=Scope as it is only defined below
-    subscope: Scope = field(default_factory=lambda: Scope())
-
-    @classmethod
-    def from_param_info(
-            cls, decl_scope: Scope, ident: str, params_info: list[ParamInfo],
-            ret_type: TypeInfo, subscope: Scope = None):
-        subscope = subscope or Scope()
-        tp_info = FunctionType([p.tp for p in params_info], ret_type)
-        return cls(decl_scope, ident, tp_info, params_info, subscope)
 
+NodeTypecheckFn: TypeAlias = 'Callable[[Typechecker, AstNode], TypeInfo | None]'
+NodeTypecheckFnStrict: TypeAlias = 'Callable[[Typechecker, AstNode], TypeInfo]'
 
-@dataclass
-class ParamInfo:
-    name: str
-    tp: TypeInfo
+_typecheck_dispatch: dict[type[AstNode], NodeTypecheckFnStrict] = {}
 
 
 @dataclass
-class Scope:
-    declared: dict[str, NameInfo] = field(default_factory=dict)
-    used: dict[str, NameInfo] = field(default_factory=dict)
-    """Add references to outer scopes' variables that we use.
-    (so type codegen/type-checker knows what each AstIdent refers to)"""
-
-
-Scope.__eq__ = recursive_eq(Scope.__eq__)
-
-
-class NameResolutionError(BaseLocatedError):
-    pass
-
-
-# The reason `let` isn't used is because we don't want to imply similarity
-#   between parameters as local variables (where none exists in Scratch).
-#   Also, we might want to use `let` later as a modifier to bind it to
-#     an actual local var.
-# Don't need to `sys.intern` these manually as Python automatically does
-#   this for literals.
-PARAM_TYPES = {'number', 'string', 'val', 'bool'}
-
-
-# Variables:
-#  - We can prevent usages before the variable is declared in 2 ways:
-#    - Based on time: very sensible, like JS, but requires too many runtime features
-#    - Based on location: somewhat makes sense except for inner functions -
-#       they may be called later so should be able to access any variables.
-#  - Or we can just ignore it (e.g. `var` in JS) and pretend everything was
-#     declared at the top (but not assigned to - i.e. hoist `var foo;` to top).
-# To minimise accidental errors, option 1.2 is best
-#  (errors shouldn't pass silently, and that method requires no special runtime)
-class NameResolver:
-    def __init__(self, astgen: AstGen):
-        self.astgen = astgen
-        self.src = self.astgen.src
-        self.top_scope: Scope | None = None
-
-    def _init(self):
-        self.ast = self.astgen.parse()
-        self.top_scope = Scope()
-
-    def run(self):
-        if self.top_scope:
-            return self.top_scope
-        self._init()
-        self.run_on_new_scope(self.ast.statements, curr_scope=self.top_scope)
-        return self.top_scope
-
-    def run_on_new_scope(self, block: list[AstNode], parent_scopes: list[Scope] = None,
-                         curr_scope: Scope = None):
-        def enter_ident(n: AstIdent):
-            for s in scope_stack[::-1]:  # Inefficient, creates a copy!
-                if info := s.declared.get(n.id):
-                    curr_scope.used[n.id] = info
-                    return
-            raise self.err(f"Name '{n.id}' is not defined", n.region)
-
-        def enter_decl(n: AstDeclNode):
-            # Need semi-special logic here to prevent walking it walking
-            # the AstIdent that is currently being declared.
-            AstNode.walk_obj(n.value, walker)  # Don't walk `n.ident`
-            # Do this after walking (that is when the name is bound)
-            ident = n.ident.id
-            target_scope = curr_scope if n.scope == VarDeclScope.LET else self.top_scope
-            if ident in target_scope.declared:
-                raise self.err("Variable already declared", n.region)
-            target_scope.declared[ident] = NameInfo(target_scope, ident, (
-                ValType() if n.type == VarDeclType.VARIABLE else ListType()))
-            return True
-
-        def enter_fn_decl(fn: AstDefine):
-            ident = fn.ident.id
-            if ident in curr_scope.declared:
-                raise self.err("Function already declared", fn.ident.region)
-            subscope = Scope()
-            params: list[ParamInfo] = []
-            for tp_node, name_node in fn.params:
-                if tp_node.id not in PARAM_TYPES:
-                    raise self.err("Unknown parameter type", tp_node.region)
-                if (name := name_node.id) in subscope.declared:
-                    raise self.err("There is already a parameter of this name",
-                                   name_node.region)
-                tp = BoolType() if tp_node.id == 'bool' else ValType()
-                subscope.declared[name] = NameInfo(subscope, name, tp, is_param=True)
-                params.append(ParamInfo(name, tp))
-            curr_scope.declared[ident] = info = FuncInfo.from_param_info(
-                curr_scope, ident, params,
-                ret_type=VoidType(), subscope=subscope)
-            inner_funcs.append((info, fn))  # Store funcs for later walking
-            # Skip walking body, only walk inner after collecting all declared
-            #  variables in outer scope so function can use all variables
-            #  declared in outer scope - even the ones declared below it)
-            return True
-
-        curr_scope = curr_scope or Scope()
-        scope_stack = parent_scopes or []
-        scope_stack.append(curr_scope)
-        inner_funcs: list[tuple[FuncInfo, AstDefine]] = []
-        # Walk self
-        walker = (FilteredWalker()
-                  .register_enter(AstIdent, enter_ident)
-                  .register_enter(AstDeclNode, enter_decl)
-                  .register_enter(AstDefine, enter_fn_decl))
-        walk_ast(block, walker)
-        # Walk sub-functions
-        for fn_info, fn_decl in inner_funcs:
-            fn_info.subscope = self.run_on_new_scope(
-                fn_decl.body, scope_stack, fn_info.subscope)
-        return scope_stack.pop()  # Remove current scope from stack & return it
-
-    def err(self, msg: str, region: StrRegion):
-        return NameResolutionError(msg, region, self.src)
+class TypeMetadata:
+    type: TypeInfo
 
 
 class Typechecker:
+    _curr_scope: Scope
+
     def __init__(self, name_resolver: NameResolver):
         self.resolver = name_resolver
         self.src = self.resolver.src
         self.is_ok: bool | None = None
+        self.typed_ast: AstProgramNode[TypeMetadata] | None = None
 
     def _init(self):
         self.resolver.run()
-        self.ast = self.resolver.ast
+        self.orig_ast = self.resolver.ast
         self.top_scope = self.resolver.top_scope
+        self._curr_scope = self.top_scope
 
-    def run(self):
-        if self.is_ok is None:
-            return self.is_ok
-        self._typecheck()
-        self.is_ok = True
-        return self.is_ok
-
-    def _typecheck(self):
-        walker = FilteredWalker()
-
-        self.ast.walk(walker)
-        ...
-
-
+    def run(self) -> AstProgramNode[TypeMetadata]:
+        if self.typed_ast is not None:
+            return self.typed_ast
+        self._init()
+        self._typecheck(self.orig_ast)
+        # TODO: tests for the output types
+        self.typed_ast = self.orig_ast  # should now have the types
+        return self.typed_ast
+
+    def _node_typechecker(self, tp=None):
+        if tp is None:
+            assert callable(self)
+            tp = self  # Called as decor in this class
+
+        def decor(fn: NodeTypecheckFn):
+            @functools.wraps(fn)
+            def new_fn(self_inner: Typechecker, n: AstNode) -> TypeInfo:
+                n_type = fn(self_inner, n) or VoidType()  # return None = void
+                n.meta = TypeMetadata(n_type)
+                return n_type
+            _typecheck_dispatch[tp] = new_fn
+            return new_fn
+        return decor
+
+    def _typecheck(self, n: AstNode):
+        try:
+            fn = _typecheck_dispatch[type(n)]
+        except KeyError:
+            fn = type(self)._typecheck_node_fallback
+        return fn(self, n)
+
+    def _typecheck_node_fallback(self, n: AstNode):
+        raise NotImplementedError(f"No typechecker function for node "
+                                  f"type {type(n).__name__}")
+
+    @_node_typechecker(AstProgramNode)
+    def _typecheck_program(self, n: AstProgramNode):
+        self._typecheck_block(n.statements)
+
+    def _typecheck_block(self, block: list[AstNode]):
+        for smt in block:
+            self.expect_type(self._typecheck(smt), VoidType(), smt)
+
+    @_node_typechecker(AstDeclNode)
+    def _typecheck_decl(self, n: AstDeclNode):
+        if not n.value:  # Nothing to check
+            return
+        expect = self._resolve_scope(n.scope).declared[n.ident.id].tp_info
+        self.expect_type(self._typecheck(n.value), expect, n)
+
+    @_node_typechecker(AstRepeat)
+    def _typecheck_repeat(self, n: AstRepeat):
+        # For now, we don't differentiate between number/string (as sc doesn't)
+        self.expect_type(self._typecheck(n.count), ValType(), n.count)
+        self._typecheck_block(n.body)
+
+    @_node_typechecker(AstIf)
+    def _typecheck_if(self, n: AstIf):
+        self.expect_type(self._typecheck(n.cond), BoolType(), n.cond)
+        self._typecheck_block(n.if_body)
+        if n.else_body is not None:
+            self._typecheck_block(n.else_body)
+
+    @_node_typechecker(AstWhile)
+    def _typecheck_while(self, n: AstWhile):
+        self.expect_type(self._typecheck(n.cond), BoolType(), n.cond)
+        self._typecheck_block(n.body)
+
+    @_node_typechecker(AstAssign)
+    def _typecheck_assign(self, n: AstAssign):  # super tempted to call this _typecheck_ass
+        if isinstance(n.target, AstIdent):
+            target_tp = self._curr_scope.used[n.target.id].tp_info
+        elif isinstance(n.target, AstItem):  # ls[i] = v
+            target_tp = self._typecheck(n.target)  # Also checks that `ls` is a list
+        elif isinstance(n.target, AstAttribute):
+            raise self.err("Setting attributes is currently unsupported", n.target)
+        else:
+            assert 0, "Unknown simple-assignment type"
+        if target_tp == ListType():
+            raise self.err("Cannot assign directly to list", n)
+        self.expect_type(self._typecheck(n.source), target_tp, n)
+
+    @_node_typechecker(AstAugAssign)
+    def _typecheck_aug_assign(self, n: AstAugAssign):
+        # TODO: change this when desugaring is implemented
+        #  (for now only +=, only on variables)
+        if n.op != '+=':
+            raise self.err(f"The '{n.op}' operator is not implemented", n)
+        if not isinstance(n.target, AstIdent):
+            raise self.err(f"The '+=' operator is only implemented for variables", n)
+        target_tp = self._curr_scope.used[n.target.id].tp_info
+        if target_tp != ValType():
+            raise self.err(f"Cannot apply += to {target_tp}", n)
+        self.expect_type(self._typecheck(n.source), ValType(), n.source)
+
+    @_node_typechecker(AstDefine)
+    def _typecheck_define(self, n: AstDefine):
+        # Don't really need to check much here - type is generated from the
+        # syntax so must be correct. Set _curr_scope and check body
+        func_info = self._curr_scope.declared[n.ident.id]
+        assert isinstance(func_info, FuncInfo)
+        old_scope = self._curr_scope
+        self._curr_scope = func_info.subscope
+        try:
+            self._typecheck_block(n.body)
+        finally:
+            self._curr_scope = old_scope
+
+    @_node_typechecker(AstNumber)
+    def _typecheck_number(self, _n: AstNumber):
+        return ValType()
+
+    @_node_typechecker(AstString)
+    def _typecheck_string(self, _n: AstString):
+        return ValType()
+
+    @_node_typechecker(AstListLiteral)
+    def _typecheck_list(self, n: AstListLiteral):
+        for item in n.items:
+            if self._typecheck(item) != ValType():
+                raise self.err("Can only have ValType()s in list", item)
+        return ListType()
+
+    @_node_typechecker(AstIdent)
+    def _typecheck_ident(self, n: AstIdent):
+        return self._curr_scope.used[n.id].tp_info
+
+    @_node_typechecker(AstAttrName)
+    def _typecheck_attr_name(self, _n: AstAttrName):
+        assert 0, "AstAttrName has no type, cannot be checked on its own"
+
+    @_node_typechecker(AstAttribute)
+    def _typecheck_attribute(self, n: AstAttribute):
+        # TODO: implement this properly, with better types and stuff
+        raise self.err("Attributes are not implemented yet", n)
+
+    @_node_typechecker(AstItem)
+    def _typecheck_item(self, n: AstItem):
+        # TODO: this will require different intrinsics for string vs list getitem
+        container_tp = self._typecheck(n.obj)
+        if container_tp not in (ListType(), ValType()):
+            raise self.err(f"Cannot get item of {container_tp}", n)
+        self.expect_type(self._typecheck(n.index), ValType(), n.index)
+
+    @_node_typechecker(AstCall)
+    def _typecheck_call(self, n: AstCall):
+        called_tp = self._typecheck(n.obj)
+        if not isinstance(called_tp, FunctionType):
+            raise self.err(f"Cannot call {called_tp}", n.obj)
+        if len(called_tp.arg_types) != len(n.args):
+            if n.args and len(n.args) > len(called_tp.arg_types):
+                region = n.args[-1].region  # Highlight extraneous arg
+            else:
+                region = n.region
+            raise self.err(f"Incorrect number of arguments, expected "
+                           f"{len(called_tp.arg_types)}, got {len(n.args)}",
+                           region)
+        for decl_t, arg_node in zip(called_tp.arg_types, n.args):
+            self.expect_type(self._typecheck(arg_node), decl_t, arg_node)
+        return called_tp.ret_type
+
+    _BINARY_OP_TYPES = dict.fromkeys([
+        *'+-*/%', '**', '..', '==', '!=', '<', '>', '<=', '>='
+    ], ValType()) | dict.fromkeys([
+        '&&', '||'
+    ], BoolType())
+
+    _UNARY_OP_TYPES = dict.fromkeys([
+        *'+-'
+    ], ValType()) | dict.fromkeys([
+        '!'
+    ], BoolType())
+
+    # TODO: allow casting bool to val? - auto-cast or explicit?
+    @_node_typechecker(AstBinOp)
+    def _typecheck_bin_op(self, n: AstBinOp):
+        expect_tp = self._BINARY_OP_TYPES[n.op]
+        self.expect_type(self._typecheck(n.left), expect_tp, n.left)
+        self.expect_type(self._typecheck(n.right), expect_tp, n.right)
+
+    @_node_typechecker(AstUnaryOp)
+    def _typecheck_unary_op(self, n: AstUnaryOp):
+        expect_tp = self._UNARY_OP_TYPES[n.op]
+        self.expect_type(self._typecheck(n.operand), expect_tp, n.operand)
+
+    def _resolve_scope(self, scope_tp: VarDeclScope):
+        return self.top_scope if scope_tp == VarDeclScope.GLOBAL else self._curr_scope
+
+    def err(self, msg: str, loc: RegionUnionArgT):
+        return TypecheckError(msg, region_union(loc), self.src)
+
+    def expect_type(self, actual: TypeInfo, exp: TypeInfo, loc: RegionUnionArgT):
+        if exp != actual:
+            raise self.err(f"Expected type {exp}, got type {actual}", loc)
diff --git a/parser/typecheck/types.py b/parser/typecheck/types.py
new file mode 100644
index 0000000..13114f7
--- /dev/null
+++ b/parser/typecheck/types.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class TypeInfo:
+    def __post_init__(self):
+        assert type(self) != TypeInfo, "Cannot instantiate TypeInfo directly, use a subclass"
+
+
+@dataclass
+class ValType(TypeInfo):
+    def __str__(self):
+        return 'val'
+
+
+@dataclass
+class BoolType(TypeInfo):
+    def __str__(self):
+        return 'bool'
+
+
+@dataclass
+class ListType(TypeInfo):
+    def __str__(self):
+        return 'list'
+
+
+@dataclass
+class VoidType(TypeInfo):
+    """The ``void`` type - represents 'there must not be a value here'.
+
+    For example, this is the return type of function that don't return anything
+    (e.g. all regular user-defined scratch functions).
+    """
+
+    def __str__(self):
+        return 'void'
+
+
+@dataclass
+class FunctionType(TypeInfo):
+    arg_types: list[TypeInfo]
+    ret_type: TypeInfo
+
+    def __str__(self):
+        return f'({", ".join(map(str, self.arg_types))}) -> {self.ret_type}'
+
+
+# The reason `let` isn't used is because we don't want to imply similarity
+#   between parameters as local variables (where none exists in Scratch).
+#   Also, we might want to use `let` later as a modifier to bind it to
+#     an actual local var.
+# Don't need to `sys.intern` these manually as Python automatically does
+#   this for literals.
+PARAM_TYPES = {'number', 'string', 'val', 'bool'}
diff --git a/pythonfuzz_corpus/14859c9d0ebc311e45b30e9e30227199c0f80a3c3570f8a2f7590b9a151750e9 b/pythonfuzz_corpus/14859c9d0ebc311e45b30e9e30227199c0f80a3c3570f8a2f7590b9a151750e9
new file mode 100644
index 0000000..2a5e80a
--- /dev/null
+++ b/pythonfuzz_corpus/14859c9d0ebc311e45b30e9e30227199c0f80a3c3570f8a2f7590b9a151750e9
@@ -0,0 +1 @@
+s='\b9';
\ No newline at end of file
diff --git a/pythonfuzz_corpus/317310faf64795d07411a956a1174e1be09db5c2a5b1af012b1da18b5716df59 b/pythonfuzz_corpus/317310faf64795d07411a956a1174e1be09db5c2a5b1af012b1da18b5716df59
new file mode 100644
index 0000000..67c62f0
--- /dev/null
+++ b/pythonfuzz_corpus/317310faf64795d07411a956a1174e1be09db5c2a5b1af012b1da18b5716df59
@@ -0,0 +1 @@
+if++7{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/3244d329e454e10743f260d8125c1e507ad34a80a5044a299fa10475514fb4a5 b/pythonfuzz_corpus/3244d329e454e10743f260d8125c1e507ad34a80a5044a299fa10475514fb4a5
new file mode 100644
index 0000000..5f03e51
--- /dev/null
+++ b/pythonfuzz_corpus/3244d329e454e10743f260d8125c1e507ad34a80a5044a299fa10475514fb4a5
@@ -0,0 +1 @@
+if 7+7{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/354dc5510bff7e22ddca9998c5369eb2aa4de28cea6cc758f140fa5a64cf56dd b/pythonfuzz_corpus/354dc5510bff7e22ddca9998c5369eb2aa4de28cea6cc758f140fa5a64cf56dd
new file mode 100644
index 0000000..0a8715e
--- /dev/null
+++ b/pythonfuzz_corpus/354dc5510bff7e22ddca9998c5369eb2aa4de28cea6cc758f140fa5a64cf56dd
@@ -0,0 +1 @@
+if+7{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/3b1d23b2b400420d8fd298dc2c504837130a18ebe49dcaa95fb37e0c8ad64f5f b/pythonfuzz_corpus/3b1d23b2b400420d8fd298dc2c504837130a18ebe49dcaa95fb37e0c8ad64f5f
new file mode 100644
index 0000000..be00bbc
--- /dev/null
+++ b/pythonfuzz_corpus/3b1d23b2b400420d8fd298dc2c504837130a18ebe49dcaa95fb37e0c8ad64f5f
@@ -0,0 +1 @@
+(!(G+l))()();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/42c1627332dc8dd001716c61e9398bbbdc4ff67b14215eafd4199785f1bb313a b/pythonfuzz_corpus/42c1627332dc8dd001716c61e9398bbbdc4ff67b14215eafd4199785f1bb313a
new file mode 100644
index 0000000..f4bf409
--- /dev/null
+++ b/pythonfuzz_corpus/42c1627332dc8dd001716c61e9398bbbdc4ff67b14215eafd4199785f1bb313a
@@ -0,0 +1 @@
+if+7+7{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/70321dacff04bb342a9c3827833ccb9733befa062d8c385af88ad82155d65001 b/pythonfuzz_corpus/70321dacff04bb342a9c3827833ccb9733befa062d8c385af88ad82155d65001
new file mode 100644
index 0000000..2031ec7
--- /dev/null
+++ b/pythonfuzz_corpus/70321dacff04bb342a9c3827833ccb9733befa062d8c385af88ad82155d65001
@@ -0,0 +1 @@
+s='\U9';
\ No newline at end of file
diff --git a/pythonfuzz_corpus/782c8edef27e6f3c29e566760e8fa74c86e595fb4177dfed07ad8de8f25766df b/pythonfuzz_corpus/782c8edef27e6f3c29e566760e8fa74c86e595fb4177dfed07ad8de8f25766df
new file mode 100644
index 0000000..17d6eae
--- /dev/null
+++ b/pythonfuzz_corpus/782c8edef27e6f3c29e566760e8fa74c86e595fb4177dfed07ad8de8f25766df
@@ -0,0 +1 @@
+if"{"{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/81357d3c3feb4212baecfd78c4ecc0d972165dc848117286a783930305199092 b/pythonfuzz_corpus/81357d3c3feb4212baecfd78c4ecc0d972165dc848117286a783930305199092
new file mode 100644
index 0000000..bcda068
--- /dev/null
+++ b/pythonfuzz_corpus/81357d3c3feb4212baecfd78c4ecc0d972165dc848117286a783930305199092
@@ -0,0 +1 @@
+' 7s9'.e+=' 7+9'.e;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/822a9b1a511012385d2cce061ee6aba9fc124bc5d622e09bdfc414f1801d17f8 b/pythonfuzz_corpus/822a9b1a511012385d2cce061ee6aba9fc124bc5d622e09bdfc414f1801d17f8
new file mode 100644
index 0000000..be28ff0
Binary files /dev/null and b/pythonfuzz_corpus/822a9b1a511012385d2cce061ee6aba9fc124bc5d622e09bdfc414f1801d17f8 differ
diff --git a/pythonfuzz_corpus/a663b9c619dde700de95276254b0c8f16e97e10f7fe0816a519ea782db184bf6 b/pythonfuzz_corpus/a663b9c619dde700de95276254b0c8f16e97e10f7fe0816a519ea782db184bf6
new file mode 100644
index 0000000..b10d392
--- /dev/null
+++ b/pythonfuzz_corpus/a663b9c619dde700de95276254b0c8f16e97e10f7fe0816a519ea782db184bf6
@@ -0,0 +1 @@
+' 7s9'.e/=' 7+6'.e;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/be8c64be404507b0cd644ccb63c64b764943c1e7d377594dd280357dd4f677cc b/pythonfuzz_corpus/be8c64be404507b0cd644ccb63c64b764943c1e7d377594dd280357dd4f677cc
new file mode 100644
index 0000000..2dc52a5
--- /dev/null
+++ b/pythonfuzz_corpus/be8c64be404507b0cd644ccb63c64b764943c1e7d377594dd280357dd4f677cc
@@ -0,0 +1 @@
+[b-K,]-
\ No newline at end of file
diff --git a/pythonfuzz_corpus/c332cb8fc69acb70e1c25b4b024ac6917053b865a19e9e0b42f59dbcafe2d0d5 b/pythonfuzz_corpus/c332cb8fc69acb70e1c25b4b024ac6917053b865a19e9e0b42f59dbcafe2d0d5
new file mode 100644
index 0000000..aa60571
--- /dev/null
+++ b/pythonfuzz_corpus/c332cb8fc69acb70e1c25b4b024ac6917053b865a19e9e0b42f59dbcafe2d0d5
@@ -0,0 +1 @@
+s=' 7+9'.e;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/d35899fceef0e659ce23019b3db6bed25c793dbb086e9a3b9ec92298be497648 b/pythonfuzz_corpus/d35899fceef0e659ce23019b3db6bed25c793dbb086e9a3b9ec92298be497648
new file mode 100644
index 0000000..664c1c7
--- /dev/null
+++ b/pythonfuzz_corpus/d35899fceef0e659ce23019b3db6bed25c793dbb086e9a3b9ec92298be497648
@@ -0,0 +1 @@
+s=' +9'' +9';
\ No newline at end of file
diff --git a/pythonfuzz_corpus/e15ebb71e5a9cfc34b68bc0c93fefc22416edf933b92cfbe78a5b08af7a8e985 b/pythonfuzz_corpus/e15ebb71e5a9cfc34b68bc0c93fefc22416edf933b92cfbe78a5b08af7a8e985
new file mode 100644
index 0000000..43cbe90
--- /dev/null
+++ b/pythonfuzz_corpus/e15ebb71e5a9cfc34b68bc0c93fefc22416edf933b92cfbe78a5b08af7a8e985
@@ -0,0 +1 @@
+s=' +9';
\ No newline at end of file
diff --git a/pythonfuzz_corpus/e5559b5624493e952fc5e81b441cb2677bb978a53c0be900b20d62d349be1f99 b/pythonfuzz_corpus/e5559b5624493e952fc5e81b441cb2677bb978a53c0be900b20d62d349be1f99
new file mode 100644
index 0000000..ab84fe9
--- /dev/null
+++ b/pythonfuzz_corpus/e5559b5624493e952fc5e81b441cb2677bb978a53c0be900b20d62d349be1f99
@@ -0,0 +1 @@
+' 7+9'.es=' 7+9'.e;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/ef13624c32e04ca4269e70eb8b5c63546f5ca03007a3fb7d697a1fcb21e4daa5 b/pythonfuzz_corpus/ef13624c32e04ca4269e70eb8b5c63546f5ca03007a3fb7d697a1fcb21e4daa5
new file mode 100644
index 0000000..68fbebc
--- /dev/null
+++ b/pythonfuzz_corpus/ef13624c32e04ca4269e70eb8b5c63546f5ca03007a3fb7d697a1fcb21e4daa5
@@ -0,0 +1 @@
+s='\+9';
\ No newline at end of file
diff --git a/benchmark.py b/scripts/benchmark.py
similarity index 88%
rename from benchmark.py
rename to scripts/benchmark.py
index 460c717..288b75b 100644
--- a/benchmark.py
+++ b/scripts/benchmark.py
@@ -2,17 +2,17 @@
 import contextlib
 import time
 
-from parser.astgen.ast_node import AstProgramNode
+from parser.astgen.ast_nodes import AstProgramNode
 from parser.astgen.astgen import AstGen
 from parser.common.tree_print import tformat
 from parser.cst.nodes import ProgramNode
 from parser.cst.cstgen import CstGen
 from parser.lexer import Tokenizer, format_tokens
-from parser.typecheck.typecheck import NameResolver, Scope
+from parser.typecheck.name_resolver import Scope, NameResolver
 from util import readfile
 from util.pformat import pformat
 
-PROFILER = True
+PROFILER = False
 
 
 class _Timer:
@@ -69,7 +69,7 @@ def run(self):
                     self.do_name_resolve()
                     self.do_name_resolve_fmt()
         if p:
-            p.dump_stats(f'perf_dump_{self.idx}.prof')
+            p.dump_stats(f'./_exclude/prof/perf_dump_{self.idx}.prof')
         print(f'Perf for idx={self.idx} ({PROFILER=}):')
         for _k, s in sorted(self.lines):
             print(f'  {s}')
@@ -132,20 +132,20 @@ def bench_full(n=200):
         for _ in range(n):
             t0 = time.perf_counter()
             _sc = NameResolver(AstGen(CstGen(Tokenizer(
-                readfile('main_example_2.st'))))).run()
+                readfile('./examples/main_example_2.st'))))).run()
             t1 = time.perf_counter()
             times.append(t1 - t0)
     if p:
-        p.dump_stats('./long_perf.prof')
+        p.dump_stats('./_exclude/prof/bench_full.prof')
     print(f'Bench main_example_2.st, {n} iterations, ({PROFILER=}):')
     print(f'  Min: {min(times)*1000:.2f}ms')
     print(f'  Avg: {sum(times)/n*1000:.2f}ms')
 
 
 def main():
-    benchmark(readfile('main_example_0.st'), 0, do_ast=False)
-    benchmark(readfile('main_example_1.st'), 1, do_name_resolve=False)
-    benchmark(readfile('main_example_2.st'), 2)
+    benchmark(readfile('./examples/main_example_0.st'), 0, do_ast=False)
+    benchmark(readfile('./examples/main_example_1.st'), 1, do_name_resolve=False)
+    benchmark(readfile('./examples/main_example_2.st'), 2)
     bench_full(200)
 
 
diff --git a/scripts/detect_unused.sh b/scripts/detect_unused.sh
new file mode 100755
index 0000000..749b750
--- /dev/null
+++ b/scripts/detect_unused.sh
@@ -0,0 +1 @@
+vulture ./parser ./scripts/fuzz.py ./scripts/benchmark.py ./test --ignore-decorators="@_register_autowalk_expr*" --exclude="parser/astgen/ast_print.py"
diff --git a/fuzz.py b/scripts/fuzz.py
similarity index 90%
rename from fuzz.py
rename to scripts/fuzz.py
index 2893b82..7ea28cf 100644
--- a/fuzz.py
+++ b/scripts/fuzz.py
@@ -4,12 +4,12 @@
 from parser.lexer.tokenizer import Tokenizer
 from parser.cst.cstgen import CstGen
 from parser.common.error import BaseParseError
+from parser.typecheck.typecheck import Typechecker
+from parser.typecheck.name_resolver import NameResolver
 
 from pythonfuzz.fuzzer import Fuzzer
 import pythonfuzz.fuzzer as fuzzer_ns  # For patching pythonfuzz
 
-from parser.typecheck.typecheck import NameResolver
-
 
 class UsePerfCounterInsteadOfTime:
     """Hack to avoid overwriting everyone's time module so we only
@@ -32,7 +32,7 @@ def fuzz(buf):
     try:
         string = buf.decode("ascii")
         try:
-            NameResolver(AstGen(CstGen(Tokenizer(string)))).run()
+            Typechecker(NameResolver(AstGen(CstGen(Tokenizer(string))))).run()
         except BaseParseError:
             pass
     except UnicodeDecodeError:
diff --git a/run_tests.sh b/scripts/run_tests.sh
old mode 100644
new mode 100755
similarity index 100%
rename from run_tests.sh
rename to scripts/run_tests.sh
diff --git a/run_tests_coverage.sh b/scripts/run_tests_coverage.sh
old mode 100644
new mode 100755
similarity index 100%
rename from run_tests_coverage.sh
rename to scripts/run_tests_coverage.sh
diff --git a/run_tests_update.sh b/scripts/run_tests_update.sh
old mode 100644
new mode 100755
similarity index 100%
rename from run_tests_update.sh
rename to scripts/run_tests_update.sh
diff --git a/test/common/common.py b/test/common/common.py
index 57bcd05..51a63f8 100644
--- a/test/common/common.py
+++ b/test/common/common.py
@@ -8,13 +8,15 @@
 from parser.astgen.ast_node import AstNode
 from parser.astgen.astgen import AstGen
 from parser.astgen.errors import LocatedAstError
+from parser.common import BaseLocatedError
 from parser.common.error import BaseParseError
+from parser.common.str_region import StrRegion
 from parser.common.tree_print import tformat
 from parser.cst.base_node import Leaf, AnyNode, Node
 from parser.cst.cstgen import CstGen, LocatedCstError
 from parser.lexer import Tokenizer
 from parser.lexer.tokens import Token, OpToken
-from parser.typecheck.typecheck import Scope, NameResolver, NameResolutionError
+from parser.typecheck.name_resolver import Scope, NameResolutionError, NameResolver
 from test.common.snapshottest import SnapshotTestCase
 from test.common.utils import TestCaseUtils
 from util.pformat import pformat
@@ -137,3 +139,16 @@ def assertNameResolveError(self, src: str):
         with self.assertRaises(NameResolutionError) as ctx:
             nr.run()
         return ctx.exception
+
+    def assertRegionEquals(self, expected: StrRegion, actual: StrRegion, src: str | None):
+        if expected == actual:
+            return
+        # Newlines added so that <lhs> != <rhs> output by unittest looks reasonable
+        self.assertEqual(f'\n{expected.display(src)}\n',
+                         f'\n{actual.display(src)}\n ',
+                         "Expected regions to be equal (showing displayed)")
+        self.assertEqual(expected, actual,  # Fallback in case display equal
+                         "Expected regions to be equal (displayed as same)")
+
+    def assertErrorRegion(self, expected: StrRegion, err: BaseLocatedError):
+        self.assertRegionEquals(expected, err.region, err._src_text)
diff --git a/test/test_common/__init__.py b/test/test_common/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/test_common/test_tree_print.py b/test/test_common/test_tree_print.py
new file mode 100644
index 0000000..2486a6c
--- /dev/null
+++ b/test/test_common/test_tree_print.py
@@ -0,0 +1,135 @@
+import enum
+from unittest import TestCase
+
+from parser.common import StrRegion
+from parser.common.tree_print import tformat
+from parser.cst import nodes as cst_nodes
+from parser.astgen import ast_nodes
+from parser.typecheck.types import ValType, ListType, VoidType, FunctionType
+
+
+class _DummyEnum(enum.Enum):
+    A = 1
+    B = 2
+
+
+class TestTreePrinter(TestCase):
+    def assertFormatsTo(self, obj: object, expect: str):
+        actual = tformat(obj, indent=2, verbose=True, append_lf=False)
+        self.assertEqual(expect, actual)
+
+    def test_elemental(self):
+        self.assertFormatsTo(123, '123')
+        self.assertFormatsTo(_DummyEnum.A, '_DummyEnum.A')
+        self.assertFormatsTo(StrRegion(3, 5), 'StrRegion(3, 5)')
+
+    def test_empty_collections(self):
+        self.assertFormatsTo([], '[]')
+        self.assertFormatsTo((), '()')
+
+    def test_flat_element_collections(self):
+        self.assertFormatsTo([2], '[\n  2\n]')
+        self.assertFormatsTo((2,), '(\n  2,\n)')
+        self.assertFormatsTo([2, "aa", StrRegion(3, 5)],
+                             "[\n  2,\n  'aa',\n  StrRegion(3, 5)\n]")
+
+    def test_cst_nodes(self):
+        ae = cst_nodes.AddEqNode(StrRegion(0, 10), None, [
+            cst_nodes.IdentNode(StrRegion(0, 2)),
+            cst_nodes.SubNode(StrRegion(4, 10), None, [
+                cst_nodes.IdentNode(StrRegion(4, 5)),
+                cst_nodes.UMinusNode(StrRegion(6, 10), None, [
+                    cst_nodes.NumberNode(StrRegion(7, 10))
+                ])
+            ])
+        ])
+        self.assertFormatsTo(
+            ae, dedent('''\
+                AddEqNode(StrRegion(0, 10), [
+                  IdentNode(StrRegion(0, 2)),
+                  SubNode(StrRegion(4, 10), [
+                    IdentNode(StrRegion(4, 5)),
+                    UMinusNode(StrRegion(6, 10), [
+                      NumberNode(StrRegion(7, 10))
+                    ])
+                  ])
+                ])'''))
+
+    def test_ast_nodes(self):
+        self.assertFormatsTo(ast_nodes.AstIdent(StrRegion(0, 2), 'ab'),
+                             "AstIdent(StrRegion(0, 2), 'ab')")
+        n = ast_nodes.AstAssign(
+            StrRegion(0, 10),
+            ast_nodes.AstIdent(StrRegion(0, 2), 'ab'),
+            ast_nodes.AstBinOp(
+                StrRegion(3, 10),
+                '+',
+                ast_nodes.AstIdent(StrRegion(3, 4), 'c'),
+                ast_nodes.AstUnaryOp(
+                    StrRegion(5, 10),
+                    '-',
+                    ast_nodes.AstNumber(StrRegion(6, 10), 1000)
+                )
+            )
+        )
+        self.assertFormatsTo(n, dedent('''\
+            AstAssign(StrRegion(0, 10),
+              AstIdent(StrRegion(0, 2), 'ab'),
+              AstBinOp(StrRegion(3, 10),
+                '+',
+                AstIdent(StrRegion(3, 4), 'c'),
+                AstUnaryOp(StrRegion(5, 10),
+                  '-',
+                  AstNumber(StrRegion(6, 10), 1000)
+                )
+              )
+            )'''))
+
+    def test_typed_ast_nodes(self):
+        self.assertFormatsTo(ast_nodes.AstIdent(StrRegion(0, 2), 'ab', meta=ValType()),
+                             "AstIdent(StrRegion(0, 2), 'ab', meta=ValType())")
+        n = ast_nodes.AstAssign(
+            StrRegion(0, 10),
+            ast_nodes.AstIdent(StrRegion(0, 2), 'ab'),
+            ast_nodes.AstBinOp(
+                StrRegion(3, 10),
+                '+',
+                ast_nodes.AstIdent(StrRegion(3, 4), 'c'),
+                ast_nodes.AstUnaryOp(
+                    StrRegion(5, 10),
+                    '-',
+                    ast_nodes.AstNumber(StrRegion(6, 10), 1000),
+                    meta=FunctionType([ListType(), ValType()], VoidType())
+                )
+            ),
+            meta=ValType()
+        )
+        self.assertFormatsTo(n, dedent('''\
+            AstAssign(StrRegion(0, 10),
+              AstIdent(StrRegion(0, 2), 'ab'),
+              AstBinOp(StrRegion(3, 10),
+                '+',
+                AstIdent(StrRegion(3, 4), 'c'),
+                AstUnaryOp(StrRegion(5, 10),
+                  '-',
+                  AstNumber(StrRegion(6, 10), 1000),
+                  meta=FunctionType(arg_types=[ListType(), ValType()], ret_type=VoidType())
+                )
+              ),
+              meta=ValType()
+            )'''))
+
+
+def _indent_size(line: str):
+    return len(line) - len(line.lstrip())
+
+
+def dedent(s: str):
+    s = s.removeprefix('\n')  # if '''<newline> and forgotten \ after the '''
+    content_lines = filter(None, map(str.rstrip, s.splitlines()))
+    amount = min(map(_indent_size, content_lines))
+    result_lines = []
+    for line in s.split('\n'):  # not splitlines to preserve possible newline at EOF
+        num_ws = len(line) - len(line.lstrip())
+        result_lines.append(line[min(amount, num_ws):])  # don't strip more WS than there is
+    return '\n'.join(result_lines)
diff --git a/test/test_e2e/.snapshots/test_main_examples.txt b/test/test_e2e/.snapshots/test_main_examples.txt
index e028cb1..d49e8e7 100644
--- a/test/test_e2e/.snapshots/test_main_examples.txt
+++ b/test/test_e2e/.snapshots/test_main_examples.txt
@@ -1,4 +1,4 @@
-"2","90","188","680","1101","1485","2373","3125","3813"
+"2","90","188","680","1101","1482","2370","3122","3801"
 "TestMain::test_example_0:tokens","TestMain::test_example_0:cst","TestMain::test_example_1:tokens","TestMain::test_example_1:cst","TestMain::test_example_1:ast","TestMain::test_example_2:tokens","TestMain::test_example_2:cst","TestMain::test_example_2:ast","TestMain::test_example_2:name_resolve"
 [IdentNameToken(region=StrRegion(start=0, end=3)),
  WhitespaceToken(region=StrRegion(start=3, end=4)),
@@ -1136,8 +1136,7 @@ AstProgramNode(StrRegion(0, 1683),
                 )
               ]
             )
-          ],
-          None
+          ]
         ),
         AstCall(StrRegion(477, 503),
           AstIdent(StrRegion(477, 484), 'delitem'),
@@ -1309,8 +1308,7 @@ AstProgramNode(StrRegion(0, 1683),
                 AstIdent(StrRegion(1083, 1088), 'value')
               ]
             )
-          ],
-          None
+          ]
         )
       ]
     ),
@@ -1384,8 +1382,7 @@ AstProgramNode(StrRegion(0, 1683),
                 AstIdent(StrRegion(1342, 1346), 'tos1')
               ]
             )
-          ],
-          None
+          ]
         )
       ]
     ),
@@ -3233,8 +3230,7 @@ AstProgramNode(StrRegion(0, 3169),
                   ),
                   AstNumber(StrRegion(554, 555), 1)
                 )
-              ],
-              None
+              ]
             )
           ],
           [
@@ -3268,8 +3264,7 @@ AstProgramNode(StrRegion(0, 3169),
                     AstNumber(StrRegion(733, 734), 1)
                   ]
                 )
-              ],
-              None
+              ]
             )
           ]
         )
@@ -3301,8 +3296,7 @@ AstProgramNode(StrRegion(0, 3169),
               ),
               AstNumber(StrRegion(927, 928), 0)
             )
-          ],
-          None
+          ]
         ),
         AstCall(StrRegion(940, 968),
           AstAttribute(StrRegion(940, 963),
@@ -3389,11 +3383,9 @@ AstProgramNode(StrRegion(0, 3169),
                     AstIdent(StrRegion(1283, 1286), 'ptr')
                   ]
                 )
-              ],
-              None
+              ]
             )
-          ],
-          None
+          ]
         )
       ]
     ),
@@ -3424,8 +3416,7 @@ AstProgramNode(StrRegion(0, 3169),
               ),
               AstNumber(StrRegion(1434, 1435), 1)
             )
-          ],
-          None
+          ]
         )
       ]
     ),
@@ -3469,8 +3460,7 @@ AstProgramNode(StrRegion(0, 3169),
                 )
               ]
             )
-          ],
-          None
+          ]
         ),
         AstCall(StrRegion(1973, 1999),
           AstIdent(StrRegion(1973, 1980), 'delitem'),
@@ -3642,8 +3632,7 @@ AstProgramNode(StrRegion(0, 3169),
                 AstIdent(StrRegion(2579, 2584), 'value')
               ]
             )
-          ],
-          None
+          ]
         )
       ]
     ),
@@ -3717,8 +3706,7 @@ AstProgramNode(StrRegion(0, 3169),
                 AstIdent(StrRegion(2838, 2842), 'tos1')
               ]
             )
-          ],
-          None
+          ]
         )
       ]
     ),
diff --git a/test/test_e2e/test_main_examples.py b/test/test_e2e/test_main_examples.py
index ada0350..1dab196 100644
--- a/test/test_e2e/test_main_examples.py
+++ b/test/test_e2e/test_main_examples.py
@@ -3,7 +3,7 @@
 from parser.astgen.astgen import AstGen
 from parser.cst.cstgen import CstGen
 from parser.lexer import Tokenizer
-from parser.typecheck.typecheck import NameResolver
+from parser.typecheck.name_resolver import NameResolver
 from test.common import CommonTestCase
 from util import readfile
 
@@ -14,7 +14,7 @@ def setUp(self):
         super().setUp()
 
     def _test_main_example_n(self, n: int, do_ast=True, do_name_resolve=True):
-        src = readfile(f'./main_example_{n}.st')
+        src = readfile(f'./examples/main_example_{n}.st')
         tk = Tokenizer(src).tokenize()
         self.assertMatchesSnapshot(tk.tokens, 'tokens')
         t = CstGen(tk)
diff --git a/test/test_error.py b/test/test_error.py
index b157e11..6d780b8 100644
--- a/test/test_error.py
+++ b/test/test_error.py
@@ -1,13 +1,28 @@
 import unittest
-from unittest.mock import patch
+from unittest.mock import patch, MagicMock
 
 from parser.common import StrRegion
 from parser.common.error import BaseLocatedError
 
 
+class _PatchRegionDisplay:
+    def __init__(self):
+        def _mocked_display(*args, **kwargs):
+            return self._mock(*args, **kwargs)
+        self._mock = MagicMock()
+        self._inner = patch.object(StrRegion, 'display', _mocked_display)
+
+    def __enter__(self):
+        self._inner.__enter__()
+        return self._mock
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self._inner.__exit__(exc_type, exc_val, exc_tb)
+
+
 class TestLocatedError(unittest.TestCase):
     def test_adds_note_once(self):
-        with patch.object(BaseLocatedError, 'display_region') as mock_display:
+        with _PatchRegionDisplay() as mock_display:
             mock_display.return_value = 'mock_return_value'
             err = BaseLocatedError("a_message", StrRegion(0, 2), 'src_str')
             str(err)
@@ -16,15 +31,15 @@ def test_adds_note_once(self):
             self.assertEqual(len(err.get_notes()), 1)
 
     def test_uses_display_return_value(self):
-        with patch.object(BaseLocatedError, 'display_region') as mock_display:
+        with _PatchRegionDisplay() as mock_display:
             mock_display.return_value = 'mock_return_value'
             err = BaseLocatedError("a_message", StrRegion(0, 2), 'src_str')
             str(err)
-            mock_display.assert_called_once_with('src_str', StrRegion(0, 2))
+            mock_display.assert_called_once_with(StrRegion(0, 2), 'src_str')
             self.assertEqual(err.get_notes(), ['mock_return_value'])
 
     def test_only_calls_display_when_needed(self):
-        with patch.object(BaseLocatedError, 'display_region') as mock_display:
+        with _PatchRegionDisplay() as mock_display:
             mock_display.return_value = 'mock_return_value'
             err = BaseLocatedError("a_message", StrRegion(0, 2), 'src_str')
             mock_display.assert_not_called()
diff --git a/test/test_typecheck/test_name_resolve.py b/test/test_typecheck/test_name_resolve.py
index 980e7a0..50f8773 100644
--- a/test/test_typecheck/test_name_resolve.py
+++ b/test/test_typecheck/test_name_resolve.py
@@ -1,9 +1,8 @@
 from unittest.mock import Mock, patch
 
 from parser.common import StrRegion
-from parser.typecheck.typecheck import (
-    NameResolver, Scope, NameInfo, BoolType, ValType, VoidType,
-    FuncInfo, ParamInfo)
+from parser.typecheck.name_resolver import NameInfo, FuncInfo, ParamInfo, Scope, NameResolver
+from parser.typecheck.types import ValType, BoolType, VoidType
 from test.common import CommonTestCase
 
 
@@ -79,24 +78,54 @@ class TestNameResolveErrors(CommonTestCase):
     def test_undefined_var(self):
         err = self.assertNameResolveError('foo = 9;')
         self.assertContains(err.msg, "Name 'foo' is not defined")
-        self.assertEqual(StrRegion(0, 3), err.region)
+        self.assertErrorRegion(StrRegion(0, 3), err)
 
-    def test_var_already_declared(self):
+    def test_var_already_declared_once(self):
         err = self.assertNameResolveError('let foo = 9; let foo;')
         self.assertContains(err.msg, "Variable already declared")
-        self.assertEqual(StrRegion(13, 20), err.region)
+        self.assertErrorRegion(StrRegion(17, 20), err)
+
+    def test_var_already_declared_once_with_value(self):
+        err = self.assertNameResolveError('let foo = 9; let foo = 55;')
+        self.assertContains(err.msg, "Variable already declared")
+        self.assertErrorRegion(StrRegion(17, 20), err)
+
+    def test_var_already_declared_many_first(self):
+        err = self.assertNameResolveError('let foo = 9; let foo, bar;')
+        self.assertContains(err.msg, "Variable already declared")
+        self.assertErrorRegion(StrRegion(17, 20), err)
+
+    def test_var_already_declared_many_mid(self):
+        err = self.assertNameResolveError('let bar = 9; let foo, bar, baz;')
+        self.assertContains(err.msg, "Variable already declared")
+        self.assertErrorRegion(StrRegion(22, 25), err)
+
+    def test_var_already_declared_many_last(self):
+        err = self.assertNameResolveError('let baz = 9; let foo, bar, baz;')
+        self.assertContains(err.msg, "Variable already declared")
+        self.assertErrorRegion(StrRegion(27, 30), err)
 
     def test_fn_already_declared(self):
         err = self.assertNameResolveError('def foo(){}; def foo(){}')
         self.assertContains(err.msg, "Function already declared")
-        self.assertEqual(StrRegion(17, 20), err.region)
+        self.assertErrorRegion(StrRegion(17, 20), err)
 
     def test_unknown_param_type(self):
         err = self.assertNameResolveError('def foo(not_a_type name){};')
         self.assertContains(err.msg, "Unknown parameter type")
-        self.assertEqual(StrRegion(8, 18), err.region)
+        self.assertErrorRegion(StrRegion(8, 18), err)
 
     def test_duplicate_param_name(self):
         err = self.assertNameResolveError('def foo(bool a, val a){};')
         self.assertContains(err.msg, "There is already a parameter of this name")
-        self.assertEqual(StrRegion(20, 21), err.region)
+        self.assertErrorRegion(StrRegion(20, 21), err)
+
+    def test_fn_resued_as_var(self):
+        err = self.assertNameResolveError('def foo(){}; let foo;')
+        self.assertContains(err.msg, "Variable already declared")
+        self.assertErrorRegion(StrRegion(17, 20), err)
+
+    def test_var_resued_as_fn(self):
+        err = self.assertNameResolveError('let foo = 9; def foo(){/*hi*/}')
+        self.assertContains(err.msg, "Function already declared")
+        self.assertErrorRegion(StrRegion(17, 20), err)
diff --git a/util/__init__.py b/util/__init__.py
index 2faf3ce..7ec7b1c 100644
--- a/util/__init__.py
+++ b/util/__init__.py
@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import dataclasses
 from os import PathLike
-from typing import TypeVar, Any, overload, Iterable
+from typing import TypeVar, Any, overload, Iterable, Literal, TypeAlias
 
 from .recursive_eq import recursive_eq
 from .simple_process_pool import *
@@ -39,3 +40,16 @@ def is_strict_subclass(o: object, type_or_types: tuple[type, ...]):
     except TypeError:
         types = (type_or_types,)
     return isinstance(o, type) and issubclass(o, types) and o not in types
+
+
+DataclassesMissingT: TypeAlias = 'Literal[dataclasses._MISSING_TYPE.MISSING]'
+
+
+# (Note: dataclasses._MISSING_TYPE isn't actually a runtime thing, it's just
+# for type checkers to recognise dataclasses.MISSING)
+def dcls_field_default(f: dataclasses.Field[T]) -> T | DataclassesMissingT:
+    if f.default is not dataclasses.MISSING:
+        return f.default
+    if (factory := f.default_factory) is not dataclasses.MISSING:
+        return factory()
+    return dataclasses.MISSING
diff --git a/util/recursive_eq.py b/util/recursive_eq.py
index 2f86c02..3b33320 100644
--- a/util/recursive_eq.py
+++ b/util/recursive_eq.py
@@ -3,7 +3,12 @@
 
 
 def recursive_eq(fn):
-    """Must be used as decorator, like reprlib.recursive_repr.
+    """Allows safe recursive equality comparisons also cnosidering reference
+    identity (like if I modify a will b change?). Must be used as decorator,
+    like reprlib.recursive_repr. Note: may break with multi-threading or
+    super-weird reentrancy (comparing unrelated objects still of the same
+    type in the __eq__ where it has no relation to the current comparison).
+
     Works by hypothesising that 2 ids are equal. Then, it tries to compare
     them. If it encounters one of them again, it checks that the corresponding
     value is the hypothesised value. If so, they're equal. If not, they're
@@ -12,6 +17,8 @@ def recursive_eq(fn):
 
     @functools.wraps(fn)
     def eq(a, b):
+        if a is b:
+            return True  # Prevents nasty stuff like deleting same key twice
         if (bid_exp := hypotheses.get(id(a))) is not None:
             return bid_exp == id(b)
         if (aid_exp := hypotheses.get(id(b))) is not None: