diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index ced6e37..6c41a38 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -16,9 +16,12 @@ 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@v5
       - name: Setup python ${{ matrix.py_version }}
         uses: actions/setup-python@v5
         with:
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/benchmark.py b/benchmark.py
index 460c717..3882013 100644
--- a/benchmark.py
+++ b/benchmark.py
@@ -2,7 +2,7 @@
 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
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..9a62b1e 100644
--- a/parser/common/error.py
+++ b/parser/common/error.py
@@ -71,8 +71,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
diff --git a/parser/common/tree_print.py b/parser/common/tree_print.py
index e4d3ce3..bfbc504 100644
--- a/parser/common/tree_print.py
+++ b/parser/common/tree_print.py
@@ -1,8 +1,10 @@
 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
 
@@ -15,6 +17,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 +58,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 +71,107 @@ 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:
+        # TODO: more general: remove kw-only stuff or stuff at end if same as default
+        values = [(f.name if f.kw_only else None, getattr(obj, f.name))
+                  for f in dcls.fields(obj)]
+        # 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 +182,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/typecheck.py b/parser/typecheck/typecheck.py
index e989aa1..d545931 100644
--- a/parser/typecheck/typecheck.py
+++ b/parser/typecheck/typecheck.py
@@ -1,34 +1,40 @@
+
 from __future__ import annotations
 
+import functools
+from collections.abc import Callable
 from dataclasses import dataclass, field
+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.ast_nodes import *
 from ..astgen.astgen import AstGen
-from ..common import BaseLocatedError, StrRegion
+from ..astgen.filtered_walker import FilteredWalker
+from ..common import BaseLocatedError, StrRegion, region_union, RegionUnionArgT
 
 
 @dataclass
 class TypeInfo:
     def __post_init__(self):
-        assert type(self) != TypeInfo, "Cannot instantiate TypeInfo directly,use a subclass"
+        assert type(self) != TypeInfo, "Cannot instantiate TypeInfo directly, use a subclass"
 
 
 @dataclass
 class ValType(TypeInfo):
-    pass
+    def __str__(self):
+        return 'val'
 
 
 @dataclass
 class BoolType(TypeInfo):
-    pass
+    def __str__(self):
+        return 'bool'
 
 
 @dataclass
 class ListType(TypeInfo):
-    pass
+    def __str__(self):
+        return 'list'
 
 
 @dataclass
@@ -39,12 +45,18 @@ class VoidType(TypeInfo):
     (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}'
+
 
 @dataclass
 class NameInfo:
@@ -182,7 +194,7 @@ def enter_fn_decl(fn: AstDefine):
                   .register_enter(AstIdent, enter_ident)
                   .register_enter(AstDeclNode, enter_decl)
                   .register_enter(AstDefine, enter_fn_decl))
-        walk_ast(block, walker)
+        walker.walk(block)
         # Walk sub-functions
         for fn_info, fn_decl in inner_funcs:
             fn_info.subscope = self.run_on_new_scope(
@@ -193,28 +205,227 @@ def err(self, msg: str, region: StrRegion):
         return NameResolutionError(msg, region, self.src)
 
 
+class TypecheckError(BaseLocatedError):
+    """Errors raised by the typechecker"""
+
+
+NodeTypecheckFn: TypeAlias = 'Callable[[Typechecker, AstNode], TypeInfo | None]'
+NodeTypecheckFnStrict: TypeAlias = 'Callable[[Typechecker, AstNode], TypeInfo]'
+
+_typecheck_dispatch: dict[type[AstNode], NodeTypecheckFnStrict] = {}
+
+
+@dataclass
+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/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..18237ed
--- /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.typecheck import ValType, FunctionType, ListType, VoidType
+
+
+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/util/recursive_eq.py b/util/recursive_eq.py
index 2f86c02..7730780 100644
--- a/util/recursive_eq.py
+++ b/util/recursive_eq.py
@@ -2,6 +2,12 @@
 import functools
 
 
+# TODO: this probably has a bug when `a is b` (thanks gpt-5.5 - it's literally
+#  the only model that spots it (I made 12 models them generate tests to see
+#  how they' doing nowadays via LMArena, with somewhat adequate results),
+#  no other one even thinks to test this case. If gpt has the intuition to
+#  think 'what is their identical', then that is genuinely terrifying for
+#  my job prospects.
 def recursive_eq(fn):
     """Must be used as decorator, like reprlib.recursive_repr.
     Works by hypothesising that 2 ids are equal. Then, it tries to compare