diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000..8a0a668
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,5 @@
+[report]
+exclude_also =
+    if __name__ == ['"]__main__['"]:
+    if TYPE_CHECKING:
+    assert 0\b
diff --git a/.github/workflows/fuzzer.yml b/.github/workflows/fuzzer.yml
index 855c01c..64d3bd0 100644
--- a/.github/workflows/fuzzer.yml
+++ b/.github/workflows/fuzzer.yml
@@ -5,16 +5,34 @@ on:
         description: Number of iterations
         type: number
         default: 250000
+      do_shard:
+        description: Run it on 4 separate machines (`n` on each)?
+        type: boolean
+        default: false
 
 
 jobs:
-  test:
+  fuzzer:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         py_version: 
           - "3.10"
           - "3.11"
+          - "3.12"
+        do_shard:
+          - ${{ inputs.do_shard }}
+        shard_index: [0, 1, 2, 3]
+        exclude:
+          - do_shard: false
+        include:
+          - do_shard: false
+            py_version: "3.10"
+          - do_shard: false
+            py_version: "3.11"
+          - do_shard: false
+            py_version: "3.12"
+    name: ${{ inputs.do_shard && format('Run fuzzer (Python {0}, shard {1})', matrix.py_version, matrix.shard_index) || format('Run fuzzer (Python {0})', matrix.py_version) }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml
index bf3e80a..641b530 100644
--- a/.github/workflows/run_tests.yml
+++ b/.github/workflows/run_tests.yml
@@ -15,6 +15,7 @@ jobs:
         py_version: 
           - "3.10"
           - "3.11"
+          - "3.12"
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
diff --git a/.idea/inspectionProfiles/project_inspections.xml b/.idea/inspectionProfiles/project_inspections.xml
index 75e6952..56fcd9f 100644
--- a/.idea/inspectionProfiles/project_inspections.xml
+++ b/.idea/inspectionProfiles/project_inspections.xml
@@ -1,6 +1,7 @@
 <component name="InspectionProjectProfileManager">
   <profile version="1.0">
     <option name="myName" value="project_inspections" />
+    <inspection_tool class="GrazieInspection" enabled="false" level="GRAMMAR_ERROR" enabled_by_default="false" />
     <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="ourVersions">
         <value>
diff --git a/fuzz.py b/fuzz.py
index 5861262..a06b13e 100644
--- a/fuzz.py
+++ b/fuzz.py
@@ -1,5 +1,6 @@
 import time
 
+from parser.astgen.astgen import AstGen
 from parser.lexer.tokenizer import Tokenizer
 from parser.cst.treegen import TreeGen
 from parser.common.error import BaseParseError
@@ -29,7 +30,7 @@ def fuzz(buf):
     try:
         string = buf.decode("ascii")
         try:
-            TreeGen(Tokenizer(string)).parse()
+            AstGen(TreeGen(Tokenizer(string))).parse()
         except BaseParseError:
             pass
     except UnicodeDecodeError:
@@ -39,11 +40,12 @@ def fuzz(buf):
 if __name__ == '__main__':
     import argparse
     ap = argparse.ArgumentParser("fuzz.py", description="Runs a fuzzer for n iterations")
+    # Use type=float as gh mobile cannot specify integers as workflow args
     ap.add_argument('-n', '--iterations', default=-1,
-                    type=int, help="Number of iterations to run pythonfuzz for")
+                    type=float, help="Number of iterations to run pythonfuzz for")
     ap.add_argument('-i', '--infinite',
                     action='store_const', const=-1, dest='iterations')
     args = ap.parse_args()
 
-    fuzzer = Fuzzer(fuzz, dirs=['./pythonfuzz_corpus'], timeout=30, runs=args.iterations)
+    fuzzer = Fuzzer(fuzz, dirs=['./pythonfuzz_corpus'], timeout=30, runs=int(args.iterations))
     fuzzer.start()
diff --git a/main.py b/main.py
index 15de7e5..3bb43b7 100644
--- a/main.py
+++ b/main.py
@@ -1,6 +1,7 @@
 import cProfile
 import time
 
+from parser.astgen.astgen import AstGen
 from util import readfile
 from parser.cst.treegen import TreeGen
 from parser.lexer import Tokenizer, print_tokens
@@ -14,7 +15,20 @@ def make_tree(src: str):
 PROFILER = True
 
 
-def run(src: str, idx: int = -1):
+def run(src: str, idx: int = -1, do_ast=True):
+    node = ast_node = None
+    ta1 = tp1 = ta0 = 0.0  # will be overwritten
+
+    def doit_trees():
+        nonlocal node, tp1, ta0, ast_node, ta1
+        treegen = TreeGen(tn)
+        node = treegen.parse()
+        tp1 = time.perf_counter()
+        if do_ast:
+            ta0 = time.perf_counter()
+            ast_node = AstGen(treegen).parse()
+            ta1 = time.perf_counter()
+
     tn0 = time.perf_counter()
     tn = Tokenizer(src).tokenize()
     tn1 = time.perf_counter()
@@ -25,24 +39,29 @@ def run(src: str, idx: int = -1):
     tp0 = time.perf_counter()
     if PROFILER:
         with cProfile.Profile() as p:
-            node = TreeGen(tn).parse()
-        tp1 = time.perf_counter()
+            doit_trees()
         p.dump_stats(f'perf_dump_{idx}.prof')
     else:
-        node = TreeGen(tn).parse()
-        tp1 = time.perf_counter()
+        doit_trees()
     print('CST:')
     tpr_cst0 = time.perf_counter()
     tprint(node)
     tpr_cst1 = time.perf_counter()
+    tpr_ast0 = tpr_ast1 = time.perf_counter()
+    if do_ast:
+        tprint(ast_node)
+        tpr_ast1 = time.perf_counter()
     print(rf'Tokens            done in {(tn1 - tn0) * 1000:.2f}ms')
     print(rf'Tokens_print      done in {(tpr_tk1 - tpr_tk0) * 1000:.2f}ms')
     print(rf'CST               done in {(tp1 - tp0) * 1000:.2f}ms')
     print(rf'CST_print         done in {(tpr_cst1 - tpr_cst0) * 1000:.2f}ms')
+    if do_ast:
+        print(rf'AST               done in {(ta1 - ta0) * 1000:.2f}ms')
+        print(rf'AST_print         done in {(tpr_ast1 - tpr_ast0) * 1000:.2f}ms')
 
 
 def main():
-    run(readfile('main_example_0.st'), 0)
+    run(readfile('main_example_0.st'), 0, do_ast=False)
     run(readfile('main_example_1.st'), 1)
 
 
diff --git a/parser/astgen/__init__.py b/parser/astgen/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/parser/astgen/ast_node.py b/parser/astgen/ast_node.py
new file mode 100644
index 0000000..e743aef
--- /dev/null
+++ b/parser/astgen/ast_node.py
@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from ..common import HasRegion, StrRegion
+
+__all__ = [
+    "AstNode", "AstProgramNode", "VarDeclType", "AstDeclNode", "AstRepeat",
+    "AstIf", "AstWhile", "AstAssign", "AstAugAssign", "AstDefine", "AstNumber",
+    "AstString", "AstAnyName", "AstIdent", "AstAttrName", "AstAttribute",
+    "AstItem", "AstCall", "AstOp", "AstBinOp", "AstUnaryOp",
+]
+
+
+@dataclass
+class AstNode(HasRegion):
+    region: StrRegion
+    name = None  # type: str
+    del name  # So we get better error msg if we forget to add it to a class
+
+
+@dataclass
+class AstProgramNode(AstNode):
+    name = 'program'
+    statements: list[AstNode]
+
+
+# region ---- <Statements> ----
+class VarDeclType(Enum):
+    LET = 'let'
+    GLOBAL = 'global'
+
+
+@dataclass
+class AstDeclNode(AstNode):
+    name = 'var_decl'
+    type: VarDeclType
+    decls: list[tuple[AstIdent, AstNode | None]]
+
+
+@dataclass
+class AstRepeat(AstNode):
+    name = 'repeat'
+    count: AstNode
+    body: list[AstNode]
+
+
+@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)
+
+
+@dataclass
+class AstWhile(AstNode):
+    name = 'while'
+    cond: AstNode
+    body: list[AstNode]
+
+
+@dataclass
+class AstAssign(AstNode):
+    name = '='
+    target: AstNode
+    source: AstNode
+
+
+@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
+
+
+@dataclass
+class AstDefine(AstNode):
+    name = 'def'
+
+    ident: AstIdent
+    params: list[tuple[AstIdent, AstIdent]]  # type, ident
+    body: list[AstNode]
+# 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 AstAttribute(AstNode):
+    name = '.'
+    obj: AstNode
+    attr: AstAttrName
+
+
+@dataclass
+class AstItem(AstNode):
+    name = 'item'
+    obj: AstNode
+    index: AstNode
+
+
+@dataclass
+class AstCall(AstNode):
+    name = 'call'
+    obj: AstNode
+    args: list[AstNode]
+
+
+@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
+
+
+@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
+# endregion ---- </Expressions> ----
diff --git a/parser/astgen/astgen.py b/parser/astgen/astgen.py
new file mode 100644
index 0000000..161c5ee
--- /dev/null
+++ b/parser/astgen/astgen.py
@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import inspect
+import sys
+from typing import Callable, overload, TypeVar, TypeAlias
+
+from util import flatten_force, is_strict_subclass
+from .ast_node import *
+from .eval_literal import eval_number, eval_string
+from .errors import LocatedAstError
+from ..common import region_union, RegionUnionArgT, HasRegion
+from ..cst.base_node import AnyNode, Node, Leaf
+from ..cst.named_node import NamedLeafCls, NamedNodeCls, NamedSizedNodeCls
+from ..cst.nodes import *
+from ..cst.treegen import CstGen
+
+# Final syntax lowering/codegen: (???)
+# AST -> blocks, intrinsics, functions -> blocks & intrinsics -> intrinsics
+#     |                                 |
+#  ops to intrinsics             resolve idents
+
+ALLOWED_IN_SMT = (  # Note: use with isinstance
+    CallNode,
+    NopNode,
+    ConditionalBlock,
+    WhileBlock,
+    RepeatBlock,
+    DefineNode,
+    LetNode,
+    GlobalNode,
+    AssignOpNode,
+)
+
+
+AutowalkerT: TypeAlias = Callable[['AstGen', AnyNode], AstNode]
+CT = TypeVar('CT', bound=AutowalkerT)
+
+_AUTOWALK_EXPR_DICT: dict[type[AnyNode], AutowalkerT] = {}
+
+
+@overload
+def _register_autowalk_expr(node_type: type[AnyNode], /) -> Callable[[CT], CT]: ...
+@overload
+def _register_autowalk_expr(cls: CT, /) -> CT: ...
+
+
+def _register_autowalk_expr(node_type: type[AnyNode] = None, /):
+    def decor(fn):
+        _AUTOWALK_EXPR_DICT[
+            node_type if node_type is not None
+            else _detect_autowalk_type_from_annot(fn)
+        ] = fn
+        return fn
+    if node_type is None or isinstance(node_type, type):
+        return decor
+    f, node_type = node_type, None
+    return decor(f)
+
+
+# A lot of coverage ignoring below in the error cases - we don't test this
+# function specifically (if the autowalking works, this must have worked)
+def _detect_autowalk_type_from_annot(fn):
+    # Warning: Introspection black magic below! May contain demons and/or dragons.
+    try:
+        sig = inspect.signature(fn, eval_str=True, globals=globals())
+    except Exception as e:  # pragma: no cover
+        raise TypeError("Unable to detect node_type (cannot resolve annotations)") from e
+    try:
+        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
+    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
+        raise TypeError("Unable to detect node_type (cannot find second positional arg)")
+    if not is_strict_subclass(param.annotation, (
+            NamedLeafCls, NamedNodeCls, NamedSizedNodeCls)):  # pragma: no cover
+        raise TypeError("Unable to detect node_type (annotation is not a node type)")
+    return param.annotation
+
+
+# The job of this is to check that the syntax is valid and the semantics
+# COULD be valid
+# e.g. reject `2 + b = q;`, reject `1 + q;` (cannot represent expr in smt)
+# e.g. accept `abc.d[2] = 3` even if there is no `abc`
+class AstGen:
+    def __init__(self, cst: CstGen):
+        self.cst = cst
+        self.src = self.cst.src
+        self.result: AstNode | None = None
+
+    def parse(self):
+        if not self.result:
+            self.result = self._walk_program(self.cst.parse())
+        return self.result
+
+    def _walk_program(self, root: ProgramNode):
+        return AstProgramNode(root.region, self._walk_block(root.statements))
+
+    def _walk_smt(self, smt: AnyNode) -> list[AstNode]:
+        if isinstance(smt, NopNode):
+            return []
+        elif isinstance(smt, LetNode):
+            return self._walk_var_decl(smt, VarDeclType.LET)
+        elif isinstance(smt, GlobalNode):
+            return self._walk_var_decl(smt, VarDeclType.GLOBAL)
+        elif isinstance(smt, RepeatBlock):
+            return [AstRepeat(smt.region, self._walk_expr(smt.count),
+                              self._walk_block(smt.block))]
+        elif isinstance(smt, WhileBlock):
+            return [AstWhile(smt.region, self._walk_expr(smt.cond),
+                             self._walk_block(smt.block))]
+        elif isinstance(smt, ConditionalBlock):
+            return self._walk_conditional(smt)
+        elif isinstance(smt, AssignNode):  # Simple assignment
+            return [AstAssign(smt.region, self._walk_assign_left(smt.target),
+                              self._walk_expr(smt.source))]
+        elif isinstance(smt, AssignOpNode):  # Other (aug.) assignment
+            return [AstAugAssign(
+                smt.region, smt.name, self._walk_assign_left(smt.target),
+                self._walk_expr(smt.source))]
+        elif isinstance(smt, DefineNode):
+            # Check arg types during name resolution
+            decls = [(self._walk_ident(d.type), self._walk_ident(d.ident))
+                     for d in smt.args_decl.decls]
+            return [AstDefine(smt.region, self._walk_ident(smt.ident),
+                              decls, self._walk_block(smt.block))]
+        elif isinstance(smt, CallNode):
+            # Check that it transforms into smt-intrinsic and
+            # not expr-intrinsic in codegen/typecheck
+            return [self._walk_call(smt)]
+        else:
+            raise self.err(
+                f"Expected statement, not {smt.name!r} expression. Hint: "
+                f"expressions have no side-effect so are not allowed at "
+                f"the root level.", smt.region)
+
+    def _walk_var_decl(self, smt: LetNode | GlobalNode, decl_tp: VarDeclType):
+        decls = [(self._walk_ident(d.ident),
+                  None if d.value is None else self._walk_expr(d.value))
+                 for d in smt.decls]
+        return [AstDeclNode(smt.region, decl_tp, decls)]
+
+    def _walk_assign_left(self, lhs: AnyNode) -> AstNode:
+        if isinstance(lhs, IdentNode):
+            return self._walk_ident(lhs)
+        if isinstance(lhs, GetitemNode):
+            # We're getting the item so there could be anything on the LHS
+            # from the POV of the syntax analysis so use regular method
+            return self._walk_getitem(lhs)
+        if isinstance(lhs, GetattrNode):  # ditto
+            return self._walk_getattr(lhs)
+        raise self.err(f"Cannot assign to {lhs.name!r} expr", lhs)
+
+    def _walk_conditional(self, smt: ConditionalBlock):
+        # Build up else/elseif parts inner-first
+        node = (None if isinstance(smt.else_block, NullElseBlock)
+                else self._walk_block(smt.else_block.block))
+        for elseif in smt.elseif_blocks:
+            # region is current elseif to end
+            node = AstIf(elseif.region | smt.else_block.region,
+                         self._walk_expr(elseif.cond),
+                         self._walk_block(elseif.block), node)
+        return [AstIf(smt.region, self._walk_expr(smt.if_block.cond),
+                      self._walk_block(smt.if_block.block), node)]
+
+    def _walk_block(self, nodes: list[AnyNode] | BlockNode) -> list[AstNode]:
+        if isinstance(nodes, BlockNode):
+            nodes = nodes.statements
+        return flatten_force(map(self._walk_smt, nodes))
+
+    def _walk_expr(self, expr: AnyNode) -> AstNode:
+        return self.autowalk_expr(expr)
+
+    @_register_autowalk_expr  # Don't need to pass the type due to black magic
+    def _walk_number(self, node: NumberNode) -> AstNumber:
+        return AstNumber(node.region, eval_number(self.node_str(node)))
+
+    @_register_autowalk_expr
+    def _walk_string(self, node: StringNode) -> AstString:
+        return AstString(node.region, self._eval_string(node))
+
+    @_register_autowalk_expr
+    def _walk_autocat(self, node: AutocatNode) -> AstString:
+        return AstString(node.region, ''.join(map(self._eval_string, node.parts)))
+
+    @_register_autowalk_expr
+    def _walk_ident(self, ident: IdentNode) -> AstIdent:
+        return AstIdent(ident.region, self.node_str(ident, intern=True))
+
+    @_register_autowalk_expr
+    def _walk_attr_name(self, attr_name: AttrNameNode) -> AstAttrName:
+        return AstAttrName(
+            attr_name.region, self.node_str(attr_name, intern=True))
+
+    @_register_autowalk_expr
+    def _walk_getattr(self, node: GetattrNode) -> AstAttribute:
+        return AstAttribute(node.region, self._walk_expr(node.target),
+                            self._walk_attr_name(node.attr))
+
+    @_register_autowalk_expr
+    def _walk_getitem(self, node: GetitemNode) -> AstItem:
+        return AstItem(node.region, self._walk_expr(node.target),
+                       self._walk_expr(node.item))
+
+    @_register_autowalk_expr
+    def _walk_paren(self, node: ParenNode) -> AstNode:
+        return self._walk_expr(node.contents)
+
+    @_register_autowalk_expr
+    def _walk_call(self, node: CallNode) -> AstCall:
+        return AstCall(node.region, self._walk_expr(node.target),
+                       [self._walk_expr(a) for a in node.arglist.args])
+
+    @_register_autowalk_expr
+    def _walk_unary_op(self, node: UnaryOpNode) -> AstUnaryOp:
+        op = node.name.removesuffix('(unary)')
+        return AstUnaryOp(node.region, op, self._walk_expr(node.operand))
+
+    @_register_autowalk_expr
+    def _walk_binary_op(self, node: BinOpNode) -> AstBinOp:
+        return AstBinOp(node.region, node.name, self._walk_expr(node.left),
+                        self._walk_expr(node.right))
+
+    def _eval_string(self, node: StringNode):
+        return eval_string(self.node_str(node), node.region, self.src)
+
+    def node_str(self, node: HasRegion, intern=False):
+        s = node.region.resolve(self.src)
+        if intern:
+            return sys.intern(s)
+        return s
+
+    def err(self, msg: str, loc: RegionUnionArgT):
+        return LocatedAstError(msg, region_union(loc), self.src)
+
+    def autowalk_expr(self, node: AnyNode):
+        return self._lookup_autowalk_fn(type(node))(self, node)
+
+    @classmethod
+    def _lookup_autowalk_fn(cls, t: type[AnyNode]):
+        assert t != Leaf and t != Node and issubclass(t, AnyNode)
+        if value := _AUTOWALK_EXPR_DICT.get(t):
+            return value
+        for supertype in t.mro():  # See if any supertypes have the autowalker
+            if not issubclass(supertype, AnyNode):
+                continue  # Skip - could be a mixin
+            if value := _AUTOWALK_EXPR_DICT.get(supertype):
+                _AUTOWALK_EXPR_DICT[t] = value  # Add it as cache
+                return value
+        raise LookupError(f"No such autowalk-er declared ({t})")  # pragma: no cover
diff --git a/parser/astgen/errors.py b/parser/astgen/errors.py
new file mode 100644
index 0000000..bfa6e77
--- /dev/null
+++ b/parser/astgen/errors.py
@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from parser.common import BaseParseError, BaseLocatedError
+
+
+class AstParseError(BaseParseError):
+    pass
+
+
+class LocatedAstError(BaseLocatedError, AstParseError):
+    pass
+
+
+class AstStringParseError(LocatedAstError):
+    pass
diff --git a/parser/astgen/eval_literal.py b/parser/astgen/eval_literal.py
new file mode 100644
index 0000000..a2ae949
--- /dev/null
+++ b/parser/astgen/eval_literal.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import unicodedata
+
+from .errors import AstStringParseError
+from ..common import StrRegion
+
+_MISSING = object()
+
+
+def eval_number(src: str):
+    try:
+        return int(src)  # Check int first (so generated code doesn't have useless `.0`s)
+    except ValueError:
+        # All allowed numbers should satisfy float()'s requirements
+        try:
+            return float(src)
+        except ValueError as e:  # pragma: no cover
+            raise AssertionError(
+                "There is a bug in tokenizer's _NumberParser. AST received a "
+                "number node that Python can't parse") from e
+
+
+def eval_string(s: str, region: StrRegion, full_src: str):
+    return _EvalString(s, region, full_src).eval_string()
+
+
+class _EvalString:
+    def __init__(self, s: str, region: StrRegion, full_src: str):
+        self.s = s[1:-1]  # Remove start/end quotes
+        self.region = StrRegion(region.start + 1, region.end - 1)
+        self.full_src = full_src
+
+    def __getitem__(self, item):
+        return self.s[item]
+
+    def eval_string(self):
+        chars = []  # Build it into a list to prevent O(n^2) concat on non-CPython
+        i = 0
+        while i < len(self.s):
+            start_i = i
+            c = self[i]
+            i += 1
+            if c != '\\':
+                chars.append(c)  # The common case (no escape)
+                continue
+            c = self[i]
+            i += 1
+            if (res := _SINGLE_CHAR_ESCAPES.get(c)) is not None:
+                res, i = res, i  # Don't need to consume any extra
+            elif length := _HEX_ESCAPES.get(c):
+                res, i = self._handle_hex_escape(length, i, start_i)
+            elif c == 'N':
+                res, i = self._handle_named_unicode_escape(i, start_i)
+            else:
+                raise self.err(f"Unknown string escape \\{c}", StrRegion(start_i, i))
+            chars.append(res)
+        return ''.join(chars)
+
+    def _handle_hex_escape(self, length, i, start_i):
+        digits = self[i:i + length].lower()
+        i = i + length
+        if len(digits) != length:  # Got less than expected, so end of string
+            raise self.err(
+                f"Unterminated escape in string (expected {length}"
+                f" hex digits)", StrRegion(start_i, i))
+        try:
+            value = int(digits, base=16)
+        except ValueError:
+            # Just report entire escape as error region
+            raise self.err(
+                f"Invalid escape in string (expected {length} hex digits)",
+                StrRegion(start_i, i)) from None
+        return chr(value), i
+
+    # the Very Special Case: \N{......}
+    def _handle_named_unicode_escape(self, i: int, start_i: int):
+        # This method takes over right after the `\N` bit (`{` is next)
+        (c,) = self[i:i + 1] or '\0'  # This makes it end-of-string-proof
+        if c != '{':
+            raise self.err("Expected '{' after \\N in string escape",
+                           StrRegion(start_i, i))
+        i += 1
+        end_idx = self.s.find('}', i)
+        if end_idx == -1:
+            raise self.err(
+                "Expected unicode-name-escape to be terminated by a '}'",
+                StrRegion(start_i, len(self.s)))
+        name = self[i:end_idx]
+        i = end_idx + 1  # Also consume the `}`
+        if not name:
+            raise self.err("Cannot have empty character name in string escape",
+                           StrRegion(start_i, i))
+        try:
+            return unicodedata.lookup(name), i
+        except KeyError as e:
+            raise self.err(
+                f"Unknown unicode character name in escape: '{name}'",
+                StrRegion(start_i, i)) from e
+
+    def err(self, msg: str, subregion: StrRegion):
+        region = StrRegion(self.region.start + subregion.start,
+                           self.region.start + subregion.end)
+        if region.end > self.region.end:  # Clamp to within region
+            region.end = self.region.end
+        if region.start < self.region.start:
+            region.start = self.region.start
+        return AstStringParseError(msg, region, self.full_src)
+
+
+_SINGLE_CHAR_ESCAPES = {
+    '\n': '',       # \<newline> ignored
+    '\\': '\\',     # \\ -> \
+    "'": "'",       # \' -> '
+    '"': '"',       # \" -> "
+    'a': '\a',
+    'b': '\b',
+    'f': '\f',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+    'v': '\v',
+    '0': '\0',
+}
+# noinspection SpellCheckingInspection
+_HEX_ESCAPES = {  # Gives number of extra chars
+    # Where h/H = a hex digit (hexit???)
+    'x': 2,  # \xHH  (2 extra chars)
+    'u': 4,  # \uHHHH
+    'U': 8,  # \Uhhhhhhhh
+}
diff --git a/parser/common/error.py b/parser/common/error.py
index 4cf8d57..847be70 100644
--- a/parser/common/error.py
+++ b/parser/common/error.py
@@ -108,7 +108,7 @@ def __str__(self):
 
     @classmethod
     def display_region(cls, src: str, region: StrRegion) -> str:
-        if region.end > len(src):  # end exc so ok if 1 beyond string
+        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)
@@ -116,10 +116,9 @@ def display_region(cls, src: str, region: StrRegion) -> str:
             # length=0 but still try to do something
             region = d_replace(region, end=region.start + 1)
         lines = src.splitlines(keepends=True)
-        lengths = tuple(map(len, lines))
-        cum_lengths = tuple(itertools.accumulate(lengths))
+        cum_lengths = tuple(itertools.accumulate(tuple(map(len, lines))))
         start_idx = region.start
-        end_idx = region.end - 1  # its inclusive here
+        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:
diff --git a/parser/common/tree_print.py b/parser/common/tree_print.py
index d0b92a3..e4d3ce3 100644
--- a/parser/common/tree_print.py
+++ b/parser/common/tree_print.py
@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import dataclasses as dcls
+import enum
 import sys
 from io import StringIO
 from typing import IO, Sequence
 
+from ..astgen.ast_node import AstNode
 from ..cst.base_node import Leaf, AnyNode, Node
 from .str_region import StrRegion
 
@@ -36,14 +39,20 @@ def format(self, obj: object):
         return out.getvalue()
 
     def _write(self, obj: object, level: int):
-        if isinstance(obj, Node):
-            self._write_node(obj, level)
+        if isinstance(obj, StrRegion):
+            self._indented_write(level, self._fmt_region(obj))
+        elif isinstance(obj, Node):
+            self._write_cst_node(obj, level)
         elif isinstance(obj, Leaf):
-            self._write_leaf(obj, level)
+            self._write_cst_leaf(obj, level)
+        elif isinstance(obj, AstNode):
+            self._write_ast_node(obj, level)
         elif isinstance(obj, list):
             self._write_seq(obj, level, '[', ']')
         elif isinstance(obj, tuple):
             self._write_seq(obj, level, '(', ')', True)
+        elif isinstance(obj, enum.Enum):
+            self._indented_write(level, f'{type(obj).__name__}.{obj.name}')
         else:
             self._write_fallback(obj, level)
 
@@ -58,25 +67,31 @@ def _write_seq(self, obj: Sequence, level: int, start: str,
             self._write(c, level + 1)
             if i != len(obj) - 1:
                 self.stream.write(',\n')
-            elif require_trailing:
+            elif require_trailing and len(obj) == 1:
                 self.stream.write(',')
         self.stream.write('\n')  # Put ']' on new line
         self._indented_write(level, end)
 
-    def _write_node(self, obj: Node, level: int):
+    def _write_cst_node(self, obj: Node, level: int):
         start = self._fmt_node_header(obj, has_more_args=True) + '['
         self._write_seq(obj.children, level, start, end='])')
 
-    def _write_leaf(self, obj: Leaf, level: int):
+    def _write_cst_leaf(self, obj: Leaf, level: int):
         self._indented_write(level, self._fmt_node_header(obj, has_more_args=False) + ')')
 
-    def _write_fallback(self, obj: object, level: int):
-        self._indented_write(level, repr(obj))
-
-    def _indented_write(self, level: int, s: str):
-        if level:
-            self.stream.write(' ' * level * self.indent)
-        self.stream.write(s)
+    def _write_ast_node(self, obj: AstNode, level: int):
+        # 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:
+                self.stream.write(', ')
+        self.stream.write(')')
 
     def _fmt_node_header(self, obj: AnyNode, has_more_args=True):
         args: list[str] = []
@@ -88,6 +103,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 _indented_write(self, level: int, s: str):
+        if level:
+            self.stream.write(' ' * level * self.indent)
+        self.stream.write(s)
+
     @classmethod
     def _fmt_region(cls, r: StrRegion):
         return f'StrRegion({r.start}, {r.end})'
diff --git a/parser/cst/nodes.py b/parser/cst/nodes.py
index 37859ea..ec43eea 100644
--- a/parser/cst/nodes.py
+++ b/parser/cst/nodes.py
@@ -73,7 +73,7 @@ def target(self):
 
     @property
     def attr(self):
-        return self.children[1]
+        return checked_cast(AttrNameNode, self.children[1])
 
 
 class GetitemNode(NamedSizedNodeCls):
@@ -86,7 +86,7 @@ def target(self):
 
     @property
     def item(self):
-        return checked_cast(AttrNameNode, self.children[1])
+        return self.children[1]
 
 
 class ParenNode(NamedSizedNodeCls):
diff --git a/parser/cst/treegen.py b/parser/cst/treegen.py
index bb34411..bc8e301 100644
--- a/parser/cst/treegen.py
+++ b/parser/cst/treegen.py
@@ -31,7 +31,7 @@ class TreeGen:
     def __init__(self, tokenizer: Tokenizer):
         self.tokenizer = tokenizer
         self.src = self.tokenizer.src
-        self.result: Node | None = None
+        self.result: ProgramNode | None = None
 
     @property
     def all_tokens(self):
@@ -70,6 +70,8 @@ def match(self, start: int, pattern: PatternT, want_full=False):
         return Matcher(pattern, self.tokens, start, self.src).match(want_full)
 
     def parse(self):
+        if self.result:
+            return self.result
         if not self.tokenizer.is_done:
             self.tokenizer.tokenize()
         assert isinstance(self.tokens[-1], EofToken)
@@ -106,11 +108,7 @@ def _parse_smt(self, idx: int) -> tuple[AnyNode, int]:
             smt = NopNode(self.tok_region(idx, idx + 1))
             idx += 1
         else:
-            # can only be an expr
-            # todo for now we are assuming that a smt can contain any expr
-            #  but this could/will change in the future
-            #  although it may be better not to deal with it here
-            #  and instead do a post-processing step
+            # can only be an expr/(LHS of) assignment
             smt, idx = self._parse_expr_or_assign(idx)
         return smt, idx
 
diff --git a/parser/lexer/tokenizer.py b/parser/lexer/tokenizer.py
index e05559c..d4e6e5a 100644
--- a/parser/lexer/tokenizer.py
+++ b/parser/lexer/tokenizer.py
@@ -156,11 +156,11 @@ def _t_string(self, start: int) -> int:
             if self.eof(idx):
                 raise self.err(f"Unexpected EOF in string "
                                f"(expected {q_type} to close string)", idx)
+            # Do just enough parsing here to determine the end of the string
+            #  (resolving escapes is done at the AST stage)
             if self[idx] == q_type:
                 idx += 1
                 return self.add_token(StringToken(StrRegion(start, idx)))
-            # TODO: maybe somehow attach the escapes to the Token
-            #  so it doesn't need to be parsed again
             if self[idx] == '\\':
                 # 1 for the '\', 1 for the next char
                 idx += 2
diff --git a/pythonfuzz_corpus/077d2b5ef5e60b62d730b4933e7bc9f4c59f1cc96efb3add656891ec13d48916 b/pythonfuzz_corpus/077d2b5ef5e60b62d730b4933e7bc9f4c59f1cc96efb3add656891ec13d48916
new file mode 100644
index 0000000..e4cc8df
--- /dev/null
+++ b/pythonfuzz_corpus/077d2b5ef5e60b62d730b4933e7bc9f4c59f1cc96efb3add656891ec13d48916
@@ -0,0 +1 @@
+s;s;s;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/20d9b360ef561575fa1e169b91e594913915060340d50bce6df704038da51b67 b/pythonfuzz_corpus/20d9b360ef561575fa1e169b91e594913915060340d50bce6df704038da51b67
new file mode 100644
index 0000000..a9f78bd
--- /dev/null
+++ b/pythonfuzz_corpus/20d9b360ef561575fa1e169b91e594913915060340d50bce6df704038da51b67
@@ -0,0 +1 @@
+s=+s+s99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/26a1d5fa8f9a8d110eb2ba12650185bf9f3de15950305f8511304ceafa29bf94 b/pythonfuzz_corpus/26a1d5fa8f9a8d110eb2ba12650185bf9f3de15950305f8511304ceafa29bf94
new file mode 100644
index 0000000..05614d8
--- /dev/null
+++ b/pythonfuzz_corpus/26a1d5fa8f9a8d110eb2ba12650185bf9f3de15950305f8511304ceafa29bf94
@@ -0,0 +1 @@
+s=+s9;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/2932dc781da3c609c8ef7dce647001fbf129206e7dd2123c553d0ff1f7439a3d b/pythonfuzz_corpus/2932dc781da3c609c8ef7dce647001fbf129206e7dd2123c553d0ff1f7439a3d
new file mode 100644
index 0000000..33fb570
--- /dev/null
+++ b/pythonfuzz_corpus/2932dc781da3c609c8ef7dce647001fbf129206e7dd2123c553d0ff1f7439a3d
@@ -0,0 +1 @@
+9=s;s;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/3299fca789a8e32844a7a14292f01eb03f942643ea583272d51e1d3983a763e0 b/pythonfuzz_corpus/3299fca789a8e32844a7a14292f01eb03f942643ea583272d51e1d3983a763e0
new file mode 100644
index 0000000..d54c93e
--- /dev/null
+++ b/pythonfuzz_corpus/3299fca789a8e32844a7a14292f01eb03f942643ea583272d51e1d3983a763e0
@@ -0,0 +1 @@
+if6{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/42d3b1ad85d1c5f43c18d55ce9b882fbcaf1e7c1b4f3cf9ea7a82bb1a69df353 b/pythonfuzz_corpus/42d3b1ad85d1c5f43c18d55ce9b882fbcaf1e7c1b4f3cf9ea7a82bb1a69df353
new file mode 100644
index 0000000..3f83966
--- /dev/null
+++ b/pythonfuzz_corpus/42d3b1ad85d1c5f43c18d55ce9b882fbcaf1e7c1b4f3cf9ea7a82bb1a69df353
@@ -0,0 +1 @@
+if+f+E{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/484d402cb5bb17f6ef2a10c2d5629aa09a68312055a79e5c7bb93cb11048763a b/pythonfuzz_corpus/484d402cb5bb17f6ef2a10c2d5629aa09a68312055a79e5c7bb93cb11048763a
new file mode 100644
index 0000000..87722dc
--- /dev/null
+++ b/pythonfuzz_corpus/484d402cb5bb17f6ef2a10c2d5629aa09a68312055a79e5c7bb93cb11048763a
@@ -0,0 +1 @@
+s=s+9;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/4fd1593a9c8a840f28fc2eb0783ba9cff14dcfe1ff542dc5a33543239e1f7597 b/pythonfuzz_corpus/4fd1593a9c8a840f28fc2eb0783ba9cff14dcfe1ff542dc5a33543239e1f7597
new file mode 100644
index 0000000..b7ac811
--- /dev/null
+++ b/pythonfuzz_corpus/4fd1593a9c8a840f28fc2eb0783ba9cff14dcfe1ff542dc5a33543239e1f7597
@@ -0,0 +1 @@
+s=++s.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/513e89f4d71232c4472789e091cbbb5c7390d8fa12e372175f83b15264d71847 b/pythonfuzz_corpus/513e89f4d71232c4472789e091cbbb5c7390d8fa12e372175f83b15264d71847
new file mode 100644
index 0000000..413d02b
--- /dev/null
+++ b/pythonfuzz_corpus/513e89f4d71232c4472789e091cbbb5c7390d8fa12e372175f83b15264d71847
@@ -0,0 +1 @@
+s=s+D;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/5988e40bff12c45f0bf50dc09acca044dc42763fcd5fa4efb97a588d22d51d2b b/pythonfuzz_corpus/5988e40bff12c45f0bf50dc09acca044dc42763fcd5fa4efb97a588d22d51d2b
new file mode 100644
index 0000000..5fdf827
--- /dev/null
+++ b/pythonfuzz_corpus/5988e40bff12c45f0bf50dc09acca044dc42763fcd5fa4efb97a588d22d51d2b
@@ -0,0 +1 @@
+l()();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/59e4c254b954ae8892c4ee45917007d346de1d16826489c581312ebfbc3ff620 b/pythonfuzz_corpus/59e4c254b954ae8892c4ee45917007d346de1d16826489c581312ebfbc3ff620
new file mode 100644
index 0000000..93dcdf9
--- /dev/null
+++ b/pythonfuzz_corpus/59e4c254b954ae8892c4ee45917007d346de1d16826489c581312ebfbc3ff620
@@ -0,0 +1 @@
+if+E{}
\ No newline at end of file
diff --git a/pythonfuzz_corpus/5cab146d6567a8c91c30c24254013dce15a6bff893965f84c2befd9c0af6bcc0 b/pythonfuzz_corpus/5cab146d6567a8c91c30c24254013dce15a6bff893965f84c2befd9c0af6bcc0
new file mode 100644
index 0000000..dded538
--- /dev/null
+++ b/pythonfuzz_corpus/5cab146d6567a8c91c30c24254013dce15a6bff893965f84c2befd9c0af6bcc0
@@ -0,0 +1 @@
+(l)(l)()();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/60d6f073b0279e91e5d62225a01b82f868ff8cfc593118d8cb568aff527c93f9 b/pythonfuzz_corpus/60d6f073b0279e91e5d62225a01b82f868ff8cfc593118d8cb568aff527c93f9
new file mode 100644
index 0000000..422e31f
--- /dev/null
+++ b/pythonfuzz_corpus/60d6f073b0279e91e5d62225a01b82f868ff8cfc593118d8cb568aff527c93f9
@@ -0,0 +1 @@
+s=s+ss+s.99.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/6258296d3e162783851322578c33f158e480b0315faf8de6eec15d2ff5645ccc b/pythonfuzz_corpus/6258296d3e162783851322578c33f158e480b0315faf8de6eec15d2ff5645ccc
new file mode 100644
index 0000000..6f8e307
--- /dev/null
+++ b/pythonfuzz_corpus/6258296d3e162783851322578c33f158e480b0315faf8de6eec15d2ff5645ccc
@@ -0,0 +1 @@
+s=ss.99..99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/66b6e43711763aef09b90631e26ed0a164cb7bde4fdddf8797538aedbf4b58ad b/pythonfuzz_corpus/66b6e43711763aef09b90631e26ed0a164cb7bde4fdddf8797538aedbf4b58ad
new file mode 100644
index 0000000..f107fba
--- /dev/null
+++ b/pythonfuzz_corpus/66b6e43711763aef09b90631e26ed0a164cb7bde4fdddf8797538aedbf4b58ad
@@ -0,0 +1 @@
+s=++s999;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/680bee6028fb47c55bcdcb471003ef3069ea11d6ad3fd38d463c2fa25a934b4b b/pythonfuzz_corpus/680bee6028fb47c55bcdcb471003ef3069ea11d6ad3fd38d463c2fa25a934b4b
new file mode 100644
index 0000000..fb0230a
--- /dev/null
+++ b/pythonfuzz_corpus/680bee6028fb47c55bcdcb471003ef3069ea11d6ad3fd38d463c2fa25a934b4b
@@ -0,0 +1 @@
+s=0+9;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/690d0c06d1b347d9a4c78f508a7611746e2fc8cb438aed9c1a1bf2ae1810cd17 b/pythonfuzz_corpus/690d0c06d1b347d9a4c78f508a7611746e2fc8cb438aed9c1a1bf2ae1810cd17
new file mode 100644
index 0000000..b004b2d
--- /dev/null
+++ b/pythonfuzz_corpus/690d0c06d1b347d9a4c78f508a7611746e2fc8cb438aed9c1a1bf2ae1810cd17
@@ -0,0 +1 @@
+s.sswQ%=99.99;.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/77fe0685a033c4fe03fa14016abc758cb321fcfe956e01857e66207437e08ae8 b/pythonfuzz_corpus/77fe0685a033c4fe03fa14016abc758cb321fcfe956e01857e66207437e08ae8
new file mode 100644
index 0000000..0ad12ef
--- /dev/null
+++ b/pythonfuzz_corpus/77fe0685a033c4fe03fa14016abc758cb321fcfe956e01857e66207437e08ae8
@@ -0,0 +1 @@
+s=9;s;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/7ad640b677846361c4c36ba3a7700b2e22191a88139306bc60e94607e72a68ae b/pythonfuzz_corpus/7ad640b677846361c4c36ba3a7700b2e22191a88139306bc60e94607e72a68ae
new file mode 100644
index 0000000..5741878
--- /dev/null
+++ b/pythonfuzz_corpus/7ad640b677846361c4c36ba3a7700b2e22191a88139306bc60e94607e72a68ae
@@ -0,0 +1 @@
+s=sS++99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/80f1193d00f388f71f9b1a9a1cf0ab91c60d1e733d6486b08b9c912717284471 b/pythonfuzz_corpus/80f1193d00f388f71f9b1a9a1cf0ab91c60d1e733d6486b08b9c912717284471
new file mode 100644
index 0000000..5b08be0
--- /dev/null
+++ b/pythonfuzz_corpus/80f1193d00f388f71f9b1a9a1cf0ab91c60d1e733d6486b08b9c912717284471
@@ -0,0 +1 @@
+s.ss=99.99;.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/94e12e73f43872fd0d0cfa60fbae9eaf144731705e8bc4a91c45523570805249 b/pythonfuzz_corpus/94e12e73f43872fd0d0cfa60fbae9eaf144731705e8bc4a91c45523570805249
new file mode 100644
index 0000000..4e02a8f
--- /dev/null
+++ b/pythonfuzz_corpus/94e12e73f43872fd0d0cfa60fbae9eaf144731705e8bc4a91c45523570805249
@@ -0,0 +1 @@
+(l)();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/9e627583c42de48ec42bbe6d2730803291966137c714513ebb54bc3898a9319d b/pythonfuzz_corpus/9e627583c42de48ec42bbe6d2730803291966137c714513ebb54bc3898a9319d
new file mode 100644
index 0000000..0d660db
--- /dev/null
+++ b/pythonfuzz_corpus/9e627583c42de48ec42bbe6d2730803291966137c714513ebb54bc3898a9319d
@@ -0,0 +1 @@
+s=s;9;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/abfc794ff5e3b13ab81ded628bfee4653a8de67abc1a95e97610ae6e6f8c7f35 b/pythonfuzz_corpus/abfc794ff5e3b13ab81ded628bfee4653a8de67abc1a95e97610ae6e6f8c7f35
new file mode 100644
index 0000000..ec76067
--- /dev/null
+++ b/pythonfuzz_corpus/abfc794ff5e3b13ab81ded628bfee4653a8de67abc1a95e97610ae6e6f8c7f35
@@ -0,0 +1 @@
+s=s+s.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/ac4e066577c6e5261184ada36735ed715335f518cadab7846779cb4ca06e8f57 b/pythonfuzz_corpus/ac4e066577c6e5261184ada36735ed715335f518cadab7846779cb4ca06e8f57
new file mode 100644
index 0000000..a13be61
--- /dev/null
+++ b/pythonfuzz_corpus/ac4e066577c6e5261184ada36735ed715335f518cadab7846779cb4ca06e8f57
@@ -0,0 +1 @@
+s=ss.99.99;.99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/b91894b2d6717af135fd147d437cf5b8f29d16265f69d17d4d46bfbaa5753771 b/pythonfuzz_corpus/b91894b2d6717af135fd147d437cf5b8f29d16265f69d17d4d46bfbaa5753771
new file mode 100644
index 0000000..17ca03e
--- /dev/null
+++ b/pythonfuzz_corpus/b91894b2d6717af135fd147d437cf5b8f29d16265f69d17d4d46bfbaa5753771
@@ -0,0 +1 @@
+l();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/bb2ed601ea019af656018c344f8301548cc226164b61e0a3709bf29d99885755 b/pythonfuzz_corpus/bb2ed601ea019af656018c344f8301548cc226164b61e0a3709bf29d99885755
new file mode 100644
index 0000000..767bc7b
--- /dev/null
+++ b/pythonfuzz_corpus/bb2ed601ea019af656018c344f8301548cc226164b61e0a3709bf29d99885755
@@ -0,0 +1 @@
+ss+=+s99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/cd8fc0e7152409a0a42d8fbfbf0862e516cfd850f94557aa88560a006ba4fc14 b/pythonfuzz_corpus/cd8fc0e7152409a0a42d8fbfbf0862e516cfd850f94557aa88560a006ba4fc14
new file mode 100644
index 0000000..5a10c14
--- /dev/null
+++ b/pythonfuzz_corpus/cd8fc0e7152409a0a42d8fbfbf0862e516cfd850f94557aa88560a006ba4fc14
@@ -0,0 +1 @@
+(!l)(l)()();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/e894014f6c089c97f2f0a13b3a5ed561dc832b868e3f427ca03cb658b0d82455 b/pythonfuzz_corpus/e894014f6c089c97f2f0a13b3a5ed561dc832b868e3f427ca03cb658b0d82455
new file mode 100644
index 0000000..7789ec5
--- /dev/null
+++ b/pythonfuzz_corpus/e894014f6c089c97f2f0a13b3a5ed561dc832b868e3f427ca03cb658b0d82455
@@ -0,0 +1 @@
+s=+99;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/e8f6c8d47847dd889d74087c31851f7736c69e972dd0575ee77ed0a053f70fb7 b/pythonfuzz_corpus/e8f6c8d47847dd889d74087c31851f7736c69e972dd0575ee77ed0a053f70fb7
new file mode 100644
index 0000000..d2c8c82
--- /dev/null
+++ b/pythonfuzz_corpus/e8f6c8d47847dd889d74087c31851f7736c69e972dd0575ee77ed0a053f70fb7
@@ -0,0 +1 @@
+7()()()();
\ No newline at end of file
diff --git a/pythonfuzz_corpus/ee3a787530c004d60dd89cccb25569e73ad29006ac8649558c0a5b24225c7008 b/pythonfuzz_corpus/ee3a787530c004d60dd89cccb25569e73ad29006ac8649558c0a5b24225c7008
new file mode 100644
index 0000000..1ab7db0
--- /dev/null
+++ b/pythonfuzz_corpus/ee3a787530c004d60dd89cccb25569e73ad29006ac8649558c0a5b24225c7008
@@ -0,0 +1 @@
+s=s+9+9;
\ No newline at end of file
diff --git a/pythonfuzz_corpus/f7783aa59585375acab589dc18e9c9b6d66a6d94c36f5716dbe487b342a0a8c5 b/pythonfuzz_corpus/f7783aa59585375acab589dc18e9c9b6d66a6d94c36f5716dbe487b342a0a8c5
new file mode 100644
index 0000000..f9dbc4a
--- /dev/null
+++ b/pythonfuzz_corpus/f7783aa59585375acab589dc18e9c9b6d66a6d94c36f5716dbe487b342a0a8c5
@@ -0,0 +1 @@
+s=I!=0+9;
\ No newline at end of file
diff --git a/run_tests_coverage.sh b/run_tests_coverage.sh
new file mode 100644
index 0000000..6d12118
--- /dev/null
+++ b/run_tests_coverage.sh
@@ -0,0 +1 @@
+./test/coverage/run_coverage.sh "$@"
diff --git a/test/.snapshots/test_astgen.txt b/test/.snapshots/test_astgen.txt
new file mode 100644
index 0000000..0bcb67b
--- /dev/null
+++ b/test/.snapshots/test_astgen.txt
@@ -0,0 +1,254 @@
+"2","14","45","93","122","184","192","204"
+"TestAstGen::test_op_node:0","TestAstGen::test_nop_node:0","TestAstGen::test_aug_assign:0","TestAstGen::test_getattr:0","TestAstGen::test_while_block:0","TestAstGen::test_autocat:0","TestAstGen::test_string_basic:0","TestAstGen::test_unaries:0"
+AstProgramNode(StrRegion(0, 6),
+  [
+    AstAssign(StrRegion(0, 5),
+      AstIdent(StrRegion(0, 1), 's'),
+      AstBinOp(StrRegion(2, 5),
+        '+',
+        AstIdent(StrRegion(2, 3), 's'),
+        AstNumber(StrRegion(4, 5), 9)
+      )
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 66),
+  [
+    AstIf(StrRegion(0, 38),
+      AstNumber(StrRegion(3, 4), 2),
+      [],
+      AstIf(StrRegion(8, 38),
+        AstBinOp(StrRegion(17, 21),
+          '==',
+          AstNumber(StrRegion(17, 18), 1),
+          AstNumber(StrRegion(20, 21), 2)
+        ),
+        [
+          AstCall(StrRegion(24, 27),
+            AstIdent(StrRegion(24, 25), 'a'),
+            []
+          )
+        ],
+        []
+      )
+    ),
+    AstRepeat(StrRegion(41, 53),
+      AstIdent(StrRegion(48, 49), 'a'),
+      []
+    ),
+    AstDefine(StrRegion(54, 65),
+      AstIdent(StrRegion(58, 60), 'fn'),
+      [],
+      []
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 88),
+  [
+    AstAugAssign(StrRegion(0, 11),
+      '+=',
+      AstIdent(StrRegion(0, 1), 'a'),
+      AstBinOp(StrRegion(5, 11),
+        '+',
+        AstNumber(StrRegion(5, 6), 6),
+        AstUnaryOp(StrRegion(9, 11),
+          '!',
+          AstNumber(StrRegion(10, 11), 0)
+        )
+      )
+    ),
+    AstAugAssign(StrRegion(13, 41),
+      '**=',
+      AstItem(StrRegion(13, 26),
+        AstAttribute(StrRegion(13, 16),
+          AstIdent(StrRegion(13, 14), 'a'),
+          AstAttrName(StrRegion(15, 16), 'b')
+        ),
+        AstBinOp(StrRegion(17, 25),
+          '..',
+          AstIdent(StrRegion(17, 18), 'c'),
+          AstString(StrRegion(22, 25), 'w')
+        )
+      ),
+      AstCall(StrRegion(31, 41),
+        AstAttribute(StrRegion(31, 39),
+          AstUnaryOp(StrRegion(32, 36),
+            '-',
+            AstNumber(StrRegion(33, 36), 0.5)
+          ),
+          AstAttrName(StrRegion(38, 39), 'q')
+        ),
+        []
+      )
+    ),
+    AstAugAssign(StrRegion(42, 87),
+      '||=',
+      AstAttribute(StrRegion(42, 45),
+        AstIdent(StrRegion(42, 43), 'a'),
+        AstAttrName(StrRegion(44, 45), 'c')
+      ),
+      AstString(StrRegion(50, 87), '\t\x1b[34;45m("default")\x1b[0m\n')
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 23),
+  [
+    AstAssign(StrRegion(0, 22),
+      AstAttribute(StrRegion(0, 8),
+        AstItem(StrRegion(0, 6),
+          AstAttribute(StrRegion(0, 3),
+            AstIdent(StrRegion(0, 1), 'a'),
+            AstAttrName(StrRegion(2, 3), 'b')
+          ),
+          AstIdent(StrRegion(4, 5), 'c')
+        ),
+        AstAttrName(StrRegion(7, 8), 'd')
+      ),
+      AstItem(StrRegion(11, 22),
+        AstAttribute(StrRegion(11, 19),
+          AstItem(StrRegion(11, 17),
+            AstAttribute(StrRegion(11, 14),
+              AstIdent(StrRegion(11, 12), 'e'),
+              AstAttrName(StrRegion(13, 14), 'f')
+            ),
+            AstIdent(StrRegion(15, 16), 'g')
+          ),
+          AstAttrName(StrRegion(18, 19), 'h')
+        ),
+        AstIdent(StrRegion(20, 21), 'i')
+      )
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 83),
+  [
+    AstWhile(StrRegion(0, 17),
+      AstBinOp(StrRegion(6, 14),
+        '==',
+        AstUnaryOp(StrRegion(6, 8),
+          '-',
+          AstNumber(StrRegion(7, 8), 1)
+        ),
+        AstBinOp(StrRegion(10, 14),
+          '+',
+          AstNumber(StrRegion(10, 11), 1),
+          AstUnaryOp(StrRegion(12, 14),
+            '-',
+            AstNumber(StrRegion(13, 14), 2)
+          )
+        )
+      ),
+      []
+    ),
+    AstWhile(StrRegion(19, 83),
+      AstBinOp(StrRegion(26, 55),
+        '==',
+        AstCall(StrRegion(26, 39),
+          AstAttribute(StrRegion(26, 37),
+            AstAttribute(StrRegion(26, 31),
+              AstIdent(StrRegion(26, 29), 'Abc'),
+              AstAttrName(StrRegion(30, 31), 'd')
+            ),
+            AstAttrName(StrRegion(32, 37), 'lower')
+          ),
+          []
+        ),
+        AstCall(StrRegion(41, 55),
+          AstAttribute(StrRegion(41, 53),
+            AstItem(StrRegion(41, 47),
+              AstIdent(StrRegion(41, 44), 'msg'),
+              AstNumber(StrRegion(45, 46), 0)
+            ),
+            AstAttrName(StrRegion(48, 53), 'lower')
+          ),
+          []
+        )
+      ),
+      [
+        AstCall(StrRegion(60, 80),
+          AstIdent(StrRegion(60, 65), 'print'),
+          [
+            AstBinOp(StrRegion(66, 79),
+              '..',
+              AstString(StrRegion(66, 69), 'q'),
+              AstItem(StrRegion(73, 79),
+                AstIdent(StrRegion(73, 76), 'msg'),
+                AstNumber(StrRegion(77, 78), 0)
+              )
+            )
+          ]
+        )
+      ]
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 36),
+  [
+    AstAssign(StrRegion(0, 35),
+      AstIdent(StrRegion(0, 1), 'b'),
+      AstString(StrRegion(2, 35), 'abc\U0010f9abend1234"\'')
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 27),
+  [
+    AstAssign(StrRegion(0, 13),
+      AstIdent(StrRegion(0, 1), 'a'),
+      AstString(StrRegion(2, 13), 'a\uedf9\t')
+    ),
+    AstAssign(StrRegion(14, 26),
+      AstIdent(StrRegion(14, 15), 'b'),
+      AstString(StrRegion(18, 26), "q\x07'q")
+    )
+  ]
+)
+AstProgramNode(StrRegion(0, 25),
+  [
+    AstAssign(StrRegion(0, 24),
+      AstIdent(StrRegion(0, 1), 'a'),
+      AstBinOp(StrRegion(2, 24),
+        '+',
+        AstBinOp(StrRegion(2, 19),
+          '-',
+          AstUnaryOp(StrRegion(2, 14),
+            '+',
+            AstBinOp(StrRegion(4, 13),
+              '==',
+              AstUnaryOp(StrRegion(4, 7),
+                '-',
+                AstUnaryOp(StrRegion(5, 7),
+                  '!',
+                  AstIdent(StrRegion(6, 7), 'b')
+                )
+              ),
+              AstUnaryOp(StrRegion(9, 13),
+                '!',
+                AstUnaryOp(StrRegion(10, 13),
+                  '-',
+                  AstUnaryOp(StrRegion(11, 13),
+                    '+',
+                    AstIdent(StrRegion(12, 13), 'c')
+                  )
+                )
+              )
+            )
+          ),
+          AstUnaryOp(StrRegion(15, 19),
+            '+',
+            AstUnaryOp(StrRegion(16, 19),
+              '-',
+              AstUnaryOp(StrRegion(17, 19),
+                '-',
+                AstIdent(StrRegion(18, 19), 'r')
+              )
+            )
+          )
+        ),
+        AstUnaryOp(StrRegion(21, 23),
+          '-',
+          AstNumber(StrRegion(22, 23), 9)
+        )
+      )
+    )
+  ]
+)
\ No newline at end of file
diff --git a/test/.snapshots/test_main_examples.txt b/test/.snapshots/test_main_examples.txt
index e141065..5b54501 100644
--- a/test/.snapshots/test_main_examples.txt
+++ b/test/.snapshots/test_main_examples.txt
@@ -1,5 +1,5 @@
-"2","90","175","666"
-"TestMain::test_example_0:tokens","TestMain::test_example_0:cst","TestMain::test_example_1:tokens","TestMain::test_example_1:cst"
+"2","90","175","666","1042"
+"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"
 [IdentNameToken(region=StrRegion(start=0, end=3)),
  WhitespaceToken(region=StrRegion(start=3, end=4)),
  IdentNameToken(region=StrRegion(start=4, end=5)),
@@ -1039,4 +1039,425 @@ ProgramNode(StrRegion(0, 1685), [
     ArgsDeclNode(StrRegion(1680, 1682), []),
     BlockNode(StrRegion(1683, 1685), [])
   ])
-])
\ No newline at end of file
+])
+AstProgramNode(StrRegion(0, 1685),
+  [
+    AstDeclNode(StrRegion(0, 22),
+      VarDeclType.GLOBAL,
+      [
+        (
+          AstIdent(StrRegion(7, 12), 'stack'),
+          AstCall(StrRegion(15, 21),
+            AstIdent(StrRegion(15, 19), 'list'),
+            []
+          )
+        )
+      ]
+    ),
+    AstDeclNode(StrRegion(23, 49),
+      VarDeclType.GLOBAL,
+      [
+        (
+          AstIdent(StrRegion(30, 40), 'COUNT_REFS'),
+          AstIdent(StrRegion(43, 48), 'false')
+        )
+      ]
+    ),
+    AstDefine(StrRegion(398, 508),
+      AstIdent(StrRegion(402, 409), 'POP_TOP'),
+      [],
+      [
+        AstIf(StrRegion(418, 474),
+          AstIdent(StrRegion(421, 431), 'COUNT_REFS'),
+          [
+            AstCall(StrRegion(442, 467),
+              AstIdent(StrRegion(442, 448), 'decref'),
+              [
+                AstItem(StrRegion(449, 466),
+                  AstIdent(StrRegion(449, 454), 'stack'),
+                  AstCall(StrRegion(455, 465),
+                    AstIdent(StrRegion(455, 458), 'len'),
+                    [
+                      AstIdent(StrRegion(459, 464), 'stack')
+                    ]
+                  )
+                )
+              ]
+            )
+          ],
+          None
+        ),
+        AstCall(StrRegion(479, 505),
+          AstIdent(StrRegion(479, 486), 'delitem'),
+          [
+            AstIdent(StrRegion(487, 492), 'stack'),
+            AstCall(StrRegion(494, 504),
+              AstIdent(StrRegion(494, 497), 'len'),
+              [
+                AstIdent(StrRegion(498, 503), 'stack')
+              ]
+            )
+          ]
+        )
+      ]
+    ),
+    AstDefine(StrRegion(510, 660),
+      AstIdent(StrRegion(514, 521), 'ROT_TWO'),
+      [],
+      [
+        AstDeclNode(StrRegion(530, 555),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(534, 541), 'tos_idx'),
+              AstCall(StrRegion(544, 554),
+                AstIdent(StrRegion(544, 547), 'len'),
+                [
+                  AstIdent(StrRegion(548, 553), 'stack')
+                ]
+              )
+            )
+          ]
+        ),
+        AstDeclNode(StrRegion(560, 586),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(564, 568), 'tos0'),
+              AstItem(StrRegion(571, 585),
+                AstIdent(StrRegion(571, 576), 'stack'),
+                AstIdent(StrRegion(577, 584), 'tos_idx')
+              )
+            )
+          ]
+        ),
+        AstAssign(StrRegion(591, 626),
+          AstItem(StrRegion(591, 605),
+            AstIdent(StrRegion(591, 596), 'stack'),
+            AstIdent(StrRegion(597, 604), 'tos_idx')
+          ),
+          AstItem(StrRegion(608, 626),
+            AstIdent(StrRegion(608, 613), 'stack'),
+            AstBinOp(StrRegion(614, 625),
+              '-',
+              AstIdent(StrRegion(614, 621), 'tos_idx'),
+              AstNumber(StrRegion(624, 625), 1)
+            )
+          )
+        ),
+        AstAssign(StrRegion(632, 657),
+          AstItem(StrRegion(632, 650),
+            AstIdent(StrRegion(632, 637), 'stack'),
+            AstBinOp(StrRegion(638, 649),
+              '-',
+              AstIdent(StrRegion(638, 645), 'tos_idx'),
+              AstNumber(StrRegion(648, 649), 1)
+            )
+          ),
+          AstIdent(StrRegion(653, 657), 'tos0')
+        )
+      ]
+    ),
+    AstDefine(StrRegion(662, 972),
+      AstIdent(StrRegion(666, 675), 'ROT_THREE'),
+      [],
+      [
+        AstDeclNode(StrRegion(797, 822),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(801, 808), 'tos_idx'),
+              AstCall(StrRegion(811, 821),
+                AstIdent(StrRegion(811, 814), 'len'),
+                [
+                  AstIdent(StrRegion(815, 820), 'stack')
+                ]
+              )
+            )
+          ]
+        ),
+        AstDeclNode(StrRegion(827, 853),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(831, 835), 'tos0'),
+              AstItem(StrRegion(838, 852),
+                AstIdent(StrRegion(838, 843), 'stack'),
+                AstIdent(StrRegion(844, 851), 'tos_idx')
+              )
+            )
+          ]
+        ),
+        AstAssign(StrRegion(858, 893),
+          AstItem(StrRegion(858, 872),
+            AstIdent(StrRegion(858, 863), 'stack'),
+            AstIdent(StrRegion(864, 871), 'tos_idx')
+          ),
+          AstItem(StrRegion(875, 893),
+            AstIdent(StrRegion(875, 880), 'stack'),
+            AstBinOp(StrRegion(881, 892),
+              '-',
+              AstIdent(StrRegion(881, 888), 'tos_idx'),
+              AstNumber(StrRegion(891, 892), 1)
+            )
+          )
+        ),
+        AstAssign(StrRegion(899, 938),
+          AstItem(StrRegion(899, 917),
+            AstIdent(StrRegion(899, 904), 'stack'),
+            AstBinOp(StrRegion(905, 916),
+              '-',
+              AstIdent(StrRegion(905, 912), 'tos_idx'),
+              AstNumber(StrRegion(915, 916), 1)
+            )
+          ),
+          AstItem(StrRegion(920, 938),
+            AstIdent(StrRegion(920, 925), 'stack'),
+            AstBinOp(StrRegion(926, 937),
+              '-',
+              AstIdent(StrRegion(926, 933), 'tos_idx'),
+              AstNumber(StrRegion(936, 937), 2)
+            )
+          )
+        ),
+        AstAssign(StrRegion(944, 969),
+          AstItem(StrRegion(944, 962),
+            AstIdent(StrRegion(944, 949), 'stack'),
+            AstBinOp(StrRegion(950, 961),
+              '-',
+              AstIdent(StrRegion(950, 957), 'tos_idx'),
+              AstNumber(StrRegion(960, 961), 2)
+            )
+          ),
+          AstIdent(StrRegion(965, 969), 'tos0')
+        )
+      ]
+    ),
+    AstDefine(StrRegion(974, 1100),
+      AstIdent(StrRegion(978, 985), 'DUP_TOP'),
+      [],
+      [
+        AstDeclNode(StrRegion(994, 1024),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(998, 1003), 'value'),
+              AstItem(StrRegion(1006, 1023),
+                AstIdent(StrRegion(1006, 1011), 'stack'),
+                AstCall(StrRegion(1012, 1022),
+                  AstIdent(StrRegion(1012, 1015), 'len'),
+                  [
+                    AstIdent(StrRegion(1016, 1021), 'stack')
+                  ]
+                )
+              )
+            )
+          ]
+        ),
+        AstCall(StrRegion(1029, 1048),
+          AstAttribute(StrRegion(1029, 1041),
+            AstIdent(StrRegion(1029, 1034), 'stack'),
+            AstAttrName(StrRegion(1035, 1041), 'append')
+          ),
+          [
+            AstIdent(StrRegion(1042, 1047), 'value')
+          ]
+        ),
+        AstIf(StrRegion(1054, 1098),
+          AstIdent(StrRegion(1057, 1067), 'COUNT_REFS'),
+          [
+            AstCall(StrRegion(1078, 1091),
+              AstIdent(StrRegion(1078, 1084), 'incref'),
+              [
+                AstIdent(StrRegion(1085, 1090), 'value')
+              ]
+            )
+          ],
+          None
+        )
+      ]
+    ),
+    AstDefine(StrRegion(1102, 1358),
+      AstIdent(StrRegion(1106, 1117), 'DUP_TOP_TWO'),
+      [],
+      [
+        AstDeclNode(StrRegion(1126, 1151),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(1130, 1137), 'tos_idx'),
+              AstCall(StrRegion(1140, 1150),
+                AstIdent(StrRegion(1140, 1143), 'len'),
+                [
+                  AstIdent(StrRegion(1144, 1149), 'stack')
+                ]
+              )
+            )
+          ]
+        ),
+        AstDeclNode(StrRegion(1156, 1182),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(1160, 1164), 'tos0'),
+              AstItem(StrRegion(1167, 1181),
+                AstIdent(StrRegion(1167, 1172), 'stack'),
+                AstIdent(StrRegion(1173, 1180), 'tos_idx')
+              )
+            )
+          ]
+        ),
+        AstDeclNode(StrRegion(1187, 1217),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(1191, 1195), 'tos1'),
+              AstItem(StrRegion(1198, 1216),
+                AstIdent(StrRegion(1198, 1203), 'stack'),
+                AstBinOp(StrRegion(1204, 1215),
+                  '-',
+                  AstIdent(StrRegion(1204, 1211), 'tod_idx'),
+                  AstNumber(StrRegion(1214, 1215), 1)
+                )
+              )
+            )
+          ]
+        ),
+        AstCall(StrRegion(1222, 1240),
+          AstAttribute(StrRegion(1222, 1234),
+            AstIdent(StrRegion(1222, 1227), 'stack'),
+            AstAttrName(StrRegion(1228, 1234), 'append')
+          ),
+          [
+            AstIdent(StrRegion(1235, 1239), 'tos1')
+          ]
+        ),
+        AstCall(StrRegion(1246, 1264),
+          AstAttribute(StrRegion(1246, 1258),
+            AstIdent(StrRegion(1246, 1251), 'stack'),
+            AstAttrName(StrRegion(1252, 1258), 'append')
+          ),
+          [
+            AstIdent(StrRegion(1259, 1263), 'tos0')
+          ]
+        ),
+        AstIf(StrRegion(1291, 1356),
+          AstIdent(StrRegion(1294, 1304), 'COUNT_REFS'),
+          [
+            AstCall(StrRegion(1315, 1327),
+              AstIdent(StrRegion(1315, 1321), 'incref'),
+              [
+                AstIdent(StrRegion(1322, 1326), 'tos0')
+              ]
+            ),
+            AstCall(StrRegion(1337, 1349),
+              AstIdent(StrRegion(1337, 1343), 'incref'),
+              [
+                AstIdent(StrRegion(1344, 1348), 'tos1')
+              ]
+            )
+          ],
+          None
+        )
+      ]
+    ),
+    AstDefine(StrRegion(1360, 1671),
+      AstIdent(StrRegion(1364, 1372), 'ROT_FOUR'),
+      [],
+      [
+        AstDeclNode(StrRegion(1455, 1480),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(1459, 1466), 'tos_idx'),
+              AstCall(StrRegion(1469, 1479),
+                AstIdent(StrRegion(1469, 1472), 'len'),
+                [
+                  AstIdent(StrRegion(1473, 1478), 'stack')
+                ]
+              )
+            )
+          ]
+        ),
+        AstDeclNode(StrRegion(1485, 1507),
+          VarDeclType.LET,
+          [
+            (
+              AstIdent(StrRegion(1489, 1493), 'tos0'),
+              AstItem(StrRegion(1496, 1506),
+                AstIdent(StrRegion(1496, 1501), 'stack'),
+                AstIdent(StrRegion(1502, 1505), 'tos')
+              )
+            )
+          ]
+        ),
+        AstAssign(StrRegion(1512, 1547),
+          AstItem(StrRegion(1512, 1526),
+            AstIdent(StrRegion(1512, 1517), 'stack'),
+            AstIdent(StrRegion(1518, 1525), 'tos_idx')
+          ),
+          AstItem(StrRegion(1529, 1547),
+            AstIdent(StrRegion(1529, 1534), 'stack'),
+            AstBinOp(StrRegion(1535, 1546),
+              '-',
+              AstIdent(StrRegion(1535, 1542), 'tos_idx'),
+              AstNumber(StrRegion(1545, 1546), 1)
+            )
+          )
+        ),
+        AstAssign(StrRegion(1553, 1592),
+          AstItem(StrRegion(1553, 1571),
+            AstIdent(StrRegion(1553, 1558), 'stack'),
+            AstBinOp(StrRegion(1559, 1570),
+              '-',
+              AstIdent(StrRegion(1559, 1566), 'tos_idx'),
+              AstNumber(StrRegion(1569, 1570), 1)
+            )
+          ),
+          AstItem(StrRegion(1574, 1592),
+            AstIdent(StrRegion(1574, 1579), 'stack'),
+            AstBinOp(StrRegion(1580, 1591),
+              '-',
+              AstIdent(StrRegion(1580, 1587), 'tos_idx'),
+              AstNumber(StrRegion(1590, 1591), 2)
+            )
+          )
+        ),
+        AstAssign(StrRegion(1598, 1637),
+          AstItem(StrRegion(1598, 1616),
+            AstIdent(StrRegion(1598, 1603), 'stack'),
+            AstBinOp(StrRegion(1604, 1615),
+              '-',
+              AstIdent(StrRegion(1604, 1611), 'tos_idx'),
+              AstNumber(StrRegion(1614, 1615), 2)
+            )
+          ),
+          AstItem(StrRegion(1619, 1637),
+            AstIdent(StrRegion(1619, 1624), 'stack'),
+            AstBinOp(StrRegion(1625, 1636),
+              '-',
+              AstIdent(StrRegion(1625, 1632), 'tos_idx'),
+              AstNumber(StrRegion(1635, 1636), 3)
+            )
+          )
+        ),
+        AstAssign(StrRegion(1643, 1668),
+          AstItem(StrRegion(1643, 1661),
+            AstIdent(StrRegion(1643, 1648), 'stack'),
+            AstBinOp(StrRegion(1649, 1660),
+              '-',
+              AstIdent(StrRegion(1649, 1656), 'tos_idx'),
+              AstNumber(StrRegion(1659, 1660), 3)
+            )
+          ),
+          AstIdent(StrRegion(1664, 1668), 'tos0')
+        )
+      ]
+    ),
+    AstDefine(StrRegion(1673, 1685),
+      AstIdent(StrRegion(1677, 1680), 'NOP'),
+      [],
+      []
+    )
+  ]
+)
\ No newline at end of file
diff --git a/test/common.py b/test/common.py
index 0f7b0c2..896b169 100644
--- a/test/common.py
+++ b/test/common.py
@@ -5,6 +5,9 @@
 from enum import IntFlag, Enum
 from typing import Sequence, TypeVar
 
+from parser.astgen.ast_node import AstNode
+from parser.astgen.astgen import AstGen
+from parser.astgen.errors import LocatedAstError
 from parser.common.error import BaseParseError
 from parser.common.tree_print import tformat
 from parser.cst.base_node import Leaf, AnyNode, Node
@@ -49,6 +52,7 @@ def _tree_format(cls, n: AnyNode):
     def setUpClass(cls) -> None:
         cls.format_dispatch.setdefault(Leaf, cls._tree_format)
         cls.format_dispatch.setdefault(Node, cls._tree_format)
+        cls.format_dispatch.setdefault(AstNode, cls._tree_format)
         super().setUpClass()
 
     @classmethod
@@ -78,15 +82,16 @@ def assertTokensEqual(
         if stream & TokenStreamFlag.FULL:
             self.assertTokenStreamEquals(t.tokens, expected, check_regions)
 
-    def assertValidParse(self, src: str):
+    def assertValidParseCST(self, src: str):
         self.assertIsNotNone(TreeGen(Tokenizer(src)).parse())
 
-    def assertFailsGracefully(self, src: str):
+    def assertFailsGracefullyCST(self, src: str):
         t = TreeGen(Tokenizer(src))
-        with self.assertRaises(CstParseError):
+        with self.assertRaises(CstParseError) as ctx:
             t.parse()
+        return ctx.exception
 
-    def assertNotInternalError(self, src: str):
+    def assertNotInternalErrorCST(self, src: str):
         try:
             TreeGen(Tokenizer(src)).parse()
         except BaseParseError:
@@ -94,7 +99,7 @@ def assertNotInternalError(self, src: str):
         self.assertTrue(True)
 
     @classmethod
-    def raiseInternalErrorsOnly(cls, src: str):
+    def raiseInternalErrorsOnlyCST(cls, src: str):
         try:
             TreeGen(Tokenizer(src)).parse()
         except BaseParseError:
@@ -103,6 +108,19 @@ def raiseInternalErrorsOnly(cls, src: str):
             raise
         return None
 
-    def assertTreeMatchesSnapshot(self, src: str):
+    def assertCstMatchesSnapshot(self, src: str):
         t = TreeGen(Tokenizer(src))
         self.assertMatchesSnapshot(t.parse())
+
+    def assertAstMatchesSnapshot(self, src: str):
+        t = AstGen(TreeGen(Tokenizer(src)))
+        self.assertMatchesSnapshot(t.parse())
+
+    def assertValidParseAST(self, src: str):
+        self.assertIsNotNone(AstGen(TreeGen(Tokenizer(src))).parse())
+
+    def assertFailsGracefullyAST(self, src: str):
+        a = AstGen(TreeGen(Tokenizer(src)))
+        with self.assertRaises(LocatedAstError) as ctx:
+            a.parse()
+        return ctx.exception
diff --git a/test/coverage/inject_colors.py b/test/coverage/inject_colors.py
new file mode 100644
index 0000000..359e366
--- /dev/null
+++ b/test/coverage/inject_colors.py
@@ -0,0 +1,63 @@
+import argparse
+import re
+from pathlib import Path
+
+
+def find_ext(root: Path, ext: str):
+    """ext is including the dot i.e. '``.html``'"""
+    res: Path | None = None
+    for sub in root.iterdir():
+        if sub.is_file() and sub.suffix == ext:
+            assert res is None, f"Multiple candidates for {ext!r} file"
+            res = sub
+    assert res is not None, f"No candidates for {ext!r} file"
+    return res
+
+
+def append_to_file(filepath: str | Path, content: str):
+    with open(filepath, 'a') as f:
+        f.write(content)
+
+
+def readfile(filepath: str | Path):
+    with open(filepath, 'r') as f:
+        return f.read()
+
+
+_DETECT_INJECTION_RE = re.compile(r'Copyright \(c\) 202\d Marcell Perger', re.IGNORECASE)
+
+
+def copy_append_unless_present(src: Path, dest: Path):
+    code = readfile(src)
+    assert _DETECT_INJECTION_RE.search(code) is not None, \
+        "Expected magic detection string to be present in source"
+    if _DETECT_INJECTION_RE.search(readfile(dest)) is None:
+        append_to_file(dest, '\n' + code)
+        return True
+    return False
+
+
+def run(cov_dir: Path):
+    assert cov_dir.exists() and cov_dir.is_dir()
+    css_dest = find_ext(cov_dir, '.css')
+    js_dest = find_ext(cov_dir, '.js')
+    dirname = Path(__file__).parent  # a la Node.js __dirname
+    css_src = dirname/'inject_me.css'
+    js_src = dirname/'inject_me.js'
+    did_inject_1 = copy_append_unless_present(css_src, css_dest)
+    did_inject_2 = copy_append_unless_present(js_src, js_dest)
+    if did_inject_1 and did_inject_2:
+        print('Colors/fixes injected successfully')
+    elif did_inject_1 or did_inject_2:
+        print('Colors/fixes partially injected (was already present in some files)')
+    else:
+        print('Colors/fixes already present')
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser(
+        description="Add colors to HTML coverage that was generated")
+    ap.add_argument('cov_dir', type=Path, default='./htmlcov',
+                    help="Path to HTML coverage dir", nargs='?')
+    args = ap.parse_args()
+    run(args.cov_dir)
diff --git a/test/coverage/inject_me.css b/test/coverage/inject_me.css
new file mode 100644
index 0000000..63cab5c
--- /dev/null
+++ b/test/coverage/inject_me.css
@@ -0,0 +1,49 @@
+/* Copyright (c) 2024 Marcell Perger, available under the MIT license, see
+https://github.com/MarcellPerger1/programming_lang_2 */
+
+/* Add fancy colors, works in dark mode, untested in light mode. */
+/* IMPORTANT: do not remove or change the top line! My build scripts that inject
+ colors into the htmlcov depend on it being there (so they don't append this twice)! */
+tr:has(.red), .red {
+  background-color: #593232 !important;
+}
+tr:has(.orange), .orange {
+  background-color: #71632c !important;
+}
+tr:has(.green), .green {
+  background-color: #294436 !important;
+}
+
+
+#index tr.region td {
+  border-bottom: none;
+  padding: 0px;  /*<a> gets all the padding*/
+}
+
+#index tr.region:hover, #index tr.region:hover a {
+  text-decoration: underline;
+}
+
+#index tr {
+  height: fit-content;
+  td {
+    height: 100%;
+    vertical-align: middle;
+    a {
+      text-decoration: none;
+      color: inherit;
+      padding: .25em .5em;
+      width: calc(100% - 1em);
+      height: calc(100% - .5em);
+      display: flex;
+      align-content: center;
+      align-items: center;
+    }
+  }
+  td a {
+    justify-content: right;
+  }
+  td.name a {
+    justify-content: left;
+  }
+}
diff --git a/test/coverage/inject_me.js b/test/coverage/inject_me.js
new file mode 100644
index 0000000..5d22260
--- /dev/null
+++ b/test/coverage/inject_me.js
@@ -0,0 +1,44 @@
+// Copyright (c) 2024 Marcell Perger, available under the MIT license, see
+// https://github.com/MarcellPerger1/programming_lang_2
+
+// Add fancy colors, works in dark mode, untested in light mode.
+// IMPORTANT: do not remove or change the top line! My build scripts that inject
+//  colors into the htmlcov depend on it being there (so they don't append this twice)!
+function colors_getPercent(ra) {
+  let [a, b] =ra.split(' ').map(Number);
+  if(b==0) return 100;
+  return 100*a / b;
+}
+function colors_getCls(el) {
+  let r = el.dataset.ratio;
+  let pc = colors_getPercent(r);
+  if (pc >= 90) return 'green';
+  if (pc >= 75) return 'orange';
+  return 'red';
+}
+function setColors() {
+  document.querySelectorAll('tr td:last-of-type')
+    .forEach((el) => el.classList.add(colors_getCls(el)));
+}
+function linkifyRow(tr) {
+  let nameField = tr.children[0]
+  let a = nameField.children[0];
+  let href = a.href;
+  [...tr.children].forEach((el, i) => {  // Copy to avoid problems with iterating while modifying
+    if(i==0) return;
+    if(el.querySelector('td > a')) return;  // Already has an <a>
+    let aNew = document.createElement('a');
+    aNew.href = href;
+    aNew.append(...el.childNodes);  // Transfer all children to inner <a>
+    el.append(aNew);
+  })
+}
+function linkifyAll() {
+  document.querySelectorAll('tr.region').forEach(linkifyRow);
+}
+addEventListener('load', () => {
+  if(document.body.classList.contains("indexfile")) {
+    setColors();
+    linkifyAll();
+  }
+});
diff --git a/test/coverage/regenerate_html.sh b/test/coverage/regenerate_html.sh
new file mode 100644
index 0000000..332c73f
--- /dev/null
+++ b/test/coverage/regenerate_html.sh
@@ -0,0 +1,2 @@
+coverage html &&
+ python ./test/coverage/inject_colors.py
diff --git a/test/coverage/run_coverage.sh b/test/coverage/run_coverage.sh
new file mode 100644
index 0000000..1758fc0
--- /dev/null
+++ b/test/coverage/run_coverage.sh
@@ -0,0 +1,4 @@
+coverage run --concurrency=multiprocessing,thread -p -m unittest discover -s ./test/ -t ./ "$@" &&
+ coverage combine &&
+ coverage html &&
+ python ./test/coverage/inject_colors.py
diff --git a/test/snapshottest.py b/test/snapshottest.py
index 4690eac..5f66703 100644
--- a/test/snapshottest.py
+++ b/test/snapshottest.py
@@ -37,9 +37,9 @@ def _safe_cls_name(o: type):
 
 def _open_or_create_rw(path: str):
     try:
-        return open(path, 'r+')
+        return open(path, 'r+', encoding='utf8')
     except FileNotFoundError:
-        return open(path, 'w+')  # Try to create if not exists
+        return open(path, 'w+', encoding='utf8')  # Try to create if not exists
 
 
 _SNAPS_NOT_FOUND_MSG = (
@@ -122,7 +122,7 @@ def setUp(self) -> None:
     @classmethod
     def _read_snapshot_text(cls):
         try:
-            with open(cls.snap_file) as f:
+            with open(cls.snap_file, encoding='utf8') as f:
                 return f.read()
         except FileNotFoundError as orig_err:
             raise SnapshotsNotFound("Snapshot file not found") from orig_err
@@ -213,7 +213,9 @@ def write_queued_snapshots(cls):
             if not changes:
                 continue
             with _open_or_create_rw(path) as f:  # do in one go to reduce chance of racing
-                orig = parse_snap(f.read())  # Use most up-to-date value (no cache)
+                content = f.read()  # Read most up-to-date value (no cache)
+                # Only use .strip() in the condition - whitespace may be part of snapshot
+                orig = parse_snap(content) if content.strip() else {}
                 f.seek(0, os.SEEK_SET)  # go to start
                 format_snap(f, cls._apply_file_changes(orig, changes))
                 # Remove extra garbage that may be left over and not fully overwritten
diff --git a/test/test_astgen.py b/test/test_astgen.py
new file mode 100644
index 0000000..1a24366
--- /dev/null
+++ b/test/test_astgen.py
@@ -0,0 +1,48 @@
+from parser.common import StrRegion
+from test.common import CommonTestCase
+
+
+class TestAstGen(CommonTestCase):
+    def test_op_node(self):
+        self.assertAstMatchesSnapshot('s=s+9;')
+
+    def test_nop_node(self):
+        self.assertAstMatchesSnapshot(
+            'if(2){;}else if (1==2){;a();;} else {};\n'
+            ';repeat(a){;};def fn(){;};')
+
+    def test_while_block(self):
+        self.assertAstMatchesSnapshot(
+            'while -1==1+-2 {};\n'
+            'while (Abc.d.lower()==msg[0].lower()){\n'
+            '  print("q" .. msg[0]);\n'
+            '}')
+
+    def test_aug_assign(self):
+        self.assertAstMatchesSnapshot(
+            'a += 6 + !0;\n'
+            'a.b[c .. "w"] **= (-0.5).q();'
+            'a.c ||= "\\t\\x1b[34;45m(\\"default\\")\\x1b[0m\\n";')
+
+    def test_error(self):
+        err = self.assertFailsGracefullyAST('3 + a;')
+        self.assertEqual(StrRegion(0, 5), err.region)
+        self.assertContains(err.msg.lower(), "expected statement")
+
+        err = self.assertFailsGracefullyAST('b*3 = 8;')
+        self.assertEqual(StrRegion(0, 3), err.region)
+        self.assertContains(err.msg.lower(), "cannot assign")
+
+    def test_getattr(self):
+        self.assertAstMatchesSnapshot('a.b[c].d = e.f[g].h[i];')
+
+    def test_string_basic(self):  # Just test very basic string stuff, rest is in eval_string
+        self.assertAstMatchesSnapshot('a="a\\ueDf9\\t";'
+                                      "b = 'q\\a\\'q';")
+
+    def test_autocat(self):
+        self.assertAstMatchesSnapshot(
+            'b="abc\\U0010f9aB"  ' + "'end1234'\n" + "'\"'" + '"\'";')
+
+    def test_unaries(self):
+        self.assertAstMatchesSnapshot('a=+(-!b==!-+c)-+--r+(-9);')
diff --git a/test/test_eval_literal.py b/test/test_eval_literal.py
new file mode 100644
index 0000000..625e6a4
--- /dev/null
+++ b/test/test_eval_literal.py
@@ -0,0 +1,97 @@
+import ast
+import sys
+
+from parser.astgen.eval_literal import eval_string, eval_number
+from parser.astgen.errors import AstStringParseError
+from parser.common import StrRegion
+from test.common import CommonTestCase
+
+
+class TestEvalNumber(CommonTestCase):
+    def test_float(self):
+        v = eval_number('.3e-7')
+        self.assertEqual(0.3e-7, v)
+        self.assertIsInstance(v, float)
+        v = eval_number('2.0')
+        self.assertEqual(2.0, v)
+        self.assertIsInstance(v, float)
+
+    def test_int(self):
+        v = eval_number('6')
+        self.assertEqual(6, v)
+        self.assertIsInstance(v, int)
+        v = eval_number('-122')
+        self.assertEqual(-122, v)
+        self.assertIsInstance(v, int)
+
+
+class TestEvalStringConsistency(CommonTestCase):
+    # noinspection PyMethodMayBeStatic
+    def _get_result_from_full(self, s: str):
+        return eval_string(f"{s}", StrRegion(2, 2 + len(s)), f"a={s};")
+
+    def test_basic(self):
+        self.assertEqual('a', self._get_result_from_full("'a'"))
+
+    def _assert_err_and_region(self, src: str, region: StrRegion):
+        with self.assertRaises(AstStringParseError) as ctx:
+            self._get_result_from_full(src)
+        self.assertEqual(region, ctx.exception.region)
+        return ctx.exception.msg
+
+    def test_error(self):
+        msg = self._assert_err_and_region(r'"\x7"', StrRegion(3, 6))
+        self.assertContains(msg, "expected 2")
+        self.assertContains(msg.lower(), "unterminated")
+
+        msg = self._assert_err_and_region(r'"\u4fdq"', StrRegion(3, 9))
+        self.assertContains(msg, "expected 4")
+
+        msg = self._assert_err_and_region(r'"\q"', StrRegion(3, 5))
+        self.assertContains(msg, "Unknown string escape \\q")
+
+        msg = self._assert_err_and_region(r'"\N"', StrRegion(3, 5))
+        self.assertContains(msg, "\\N")
+        self.assertContains(msg.lower(), "expected '{'")
+
+        msg = self._assert_err_and_region(r'"\N7"', StrRegion(3, 5))
+        self.assertContains(msg, "\\N")
+        self.assertContains(msg.lower(), "expected '{'")
+
+        msg = self._assert_err_and_region(r'"\N{}"', StrRegion(3, 7))
+        self.assertContains(msg.lower(), "empty character name")
+
+        msg = self._assert_err_and_region(r'"\N{EM DASH"', StrRegion(3, 3 + 10))
+        self.assertContains(msg.lower(), "terminated by a '}'")
+
+        msg = self._assert_err_and_region(
+            r'"\N{i am not a unicode character and if i existed these '
+            r'tests would break}"', StrRegion(3, 3 + 73))
+        self.assertContains(msg.lower(), "unknown unicode character name")
+
+    def test_py_consistency(self):
+        base = r'a\\\a\b\v\f\0\n\rq\t' '\\"' "\\'"
+        for x in (*range(0, 34, 3), *range(34, 256, 9), 255):
+            for u in range(0, 65000, 1387):
+                for big_u in range(0, 0x110000, 0xE4C1):
+                    v2 = (base + f'\\x{x:0>2x}1\\u{u:0>4x}e\\U{big_u:0>8x}'
+                                 '\\N{COPYRIGHT SIGN}\\N{EM DASH}')
+                    for q in ('"', "'"):
+                        v3 = q + v2 + q
+                        src = 'abc=' + v3 + ';\nprint(abc);'
+                        r = StrRegion(4, 4 + len(v3))
+                        self._check_consistent_once(v3, r, src, x, u, big_u, q)
+
+    def _check_consistent_once(self, string_part, reg, src, x, u, big_u, q):
+        my = eval_string(string_part, reg, src)
+        py = ast.literal_eval(string_part)
+        if my != py:
+            print(
+                f'Consistency check failed:\n'
+                f'expected={py!r}\n'
+                f'actual={my!r}\n'
+                f'({x=}, {u=}, U={big_u}, {q=})\n'
+                f'(src is "{src}")',
+                file=sys.stderr)
+            self.assertEqual(py, my, "eval_string consistency "
+                                     "check failed (see above)")
diff --git a/test/test_from_fuzzer.py b/test/test_from_fuzzer.py
index 95f1b7b..fcc1037 100644
--- a/test/test_from_fuzzer.py
+++ b/test/test_from_fuzzer.py
@@ -20,7 +20,7 @@ def setUp(self):
     @staticmethod
     @timeout_decor_async(5, debug=0, pool=True)
     def _inner_once(src: str):
-        return CommonTestCase.raiseInternalErrorsOnly(src)
+        return CommonTestCase.raiseInternalErrorsOnlyCST(src)
 
     async def _test_once(self, p: Path):
         with self.subTest(corp=p.name):
@@ -38,12 +38,12 @@ class FuzzerCrashTestCase(CommonTestCase):
     """Tests for crashes caught by pythonfuzz"""
 
     def test_3610f59833246958fff7d5cbc5b23f8c99496c3c8fda3f5606f5b198713cbb95(self):
-        self.assertNotInternalError('. ')
-        self.assertNotInternalError('.')
+        self.assertNotInternalErrorCST('. ')
+        self.assertNotInternalErrorCST('.')
 
     def test_62428fae4dba4c7722b8d7e1b8ad7bbe7a01ac1603e4421d42df7e0c0ad70f85(self):
-        self.assertNotInternalError('!W>W>W9Jd')
-        self.assertNotInternalError('!W>W>W9Jd\x1e')
+        self.assertNotInternalErrorCST('!W>W>W9Jd')
+        self.assertNotInternalErrorCST('!W>W>W9Jd\x1e')
 
 
 class FuzzerTimeoutTestCase(CommonTestCase):
@@ -54,7 +54,7 @@ class FuzzerTimeoutTestCase(CommonTestCase):
     @staticmethod
     @timeout_decor(5, debug=0)
     def inner_a32460d584fd8a20d1e62007db570eaf41342f248e42c21a33780fd976e45290():
-        return CommonTestCase.raiseInternalErrorsOnly('s/*y')
+        return CommonTestCase.raiseInternalErrorsOnlyCST('s/*y')
 
     def test_a32460d584fd8a20d1e62007db570eaf41342f248e42c21a33780fd976e45290(self):
         self.inner_a32460d584fd8a20d1e62007db570eaf41342f248e42c21a33780fd976e45290()
@@ -63,7 +63,7 @@ def test_a32460d584fd8a20d1e62007db570eaf41342f248e42c21a33780fd976e45290(self):
     @timeout_decor(5, debug=0)
     def inner_ed988ae940f54542ec54fd3c402a009fe2fdb660bd558d76a3612781a5ef6aa2():
         TreeGen(Tokenizer('a;//')).parse()
-        return CommonTestCase.raiseInternalErrorsOnly('a<//')
+        return CommonTestCase.raiseInternalErrorsOnlyCST('a<//')
 
     def test_ed988ae940f54542ec54fd3c402a009fe2fdb660bd558d76a3612781a5ef6aa2(self):
         self.inner_ed988ae940f54542ec54fd3c402a009fe2fdb660bd558d76a3612781a5ef6aa2()
diff --git a/test/test_integration/test_treegen.py b/test/test_integration/test_treegen.py
index 26dd897..e460004 100644
--- a/test/test_integration/test_treegen.py
+++ b/test/test_integration/test_treegen.py
@@ -9,39 +9,39 @@
 
 class TestAutocat(CommonTestCase):
     def test_autocat(self):
-        self.assertTreeMatchesSnapshot('"abc" "="\n  "1" .. a .. "b".d();')
+        self.assertCstMatchesSnapshot('"abc" "="\n  "1" .. a .. "b".d();')
 
 
 class TreeGenTest(CommonTestCase):
     def test_item_chain(self):
-        self.assertTreeMatchesSnapshot('a[7].b.0.fn["c" .. 2] = fn(9).k[7 + r](3,);')
+        self.assertCstMatchesSnapshot('a[7].b.0.fn["c" .. 2] = fn(9).k[7 + r](3,);')
 
     def test_fn_call_in_lvalue(self):
-        self.assertTreeMatchesSnapshot('a(7).b.0.fn()["c" .. 2] = fn(9).k[7 + r](3,);')
+        self.assertCstMatchesSnapshot('a(7).b.0.fn()["c" .. 2] = fn(9).k[7 + r](3,);')
 
     def test_aug_assign(self):
-        self.assertTreeMatchesSnapshot('a[1] += a.2;')
+        self.assertCstMatchesSnapshot('a[1] += a.2;')
 
     def test__mod_supported(self):
-        self.assertTreeMatchesSnapshot('c=a%b;')
+        self.assertCstMatchesSnapshot('c=a%b;')
 
     def test_decl_no_value(self):
-        self.assertTreeMatchesSnapshot('let b;')
+        self.assertCstMatchesSnapshot('let b;')
 
 
 class TestBlocks(CommonTestCase):
     def test_while(self):
-        self.assertTreeMatchesSnapshot('while a || !b && c >= 6 {}')
-        self.assertTreeMatchesSnapshot('while!(7%8){(7.7).abc(6,7,8);}')
+        self.assertCstMatchesSnapshot('while a || !b && c >= 6 {}')
+        self.assertCstMatchesSnapshot('while!(7%8){(7.7).abc(6,7,8);}')
 
     def test_repeat(self):
-        self.assertTreeMatchesSnapshot('repeat a || !b && c >= 6 {}')
-        self.assertTreeMatchesSnapshot('repeat!(7%8){(7.7).abc(6,7,8);}')
+        self.assertCstMatchesSnapshot('repeat a || !b && c >= 6 {}')
+        self.assertCstMatchesSnapshot('repeat!(7%8){(7.7).abc(6,7,8);}')
 
     def test_else_if_else(self):
-        self.assertTreeMatchesSnapshot('if(1){}else if(a||!b&&c!=6){}')
-        self.assertTreeMatchesSnapshot('if(1){}else{a();}')
-        self.assertTreeMatchesSnapshot('if(1){}else if 9{a();}else{b(a, a());}')
+        self.assertCstMatchesSnapshot('if(1){}else if(a||!b&&c!=6){}')
+        self.assertCstMatchesSnapshot('if(1){}else{a();}')
+        self.assertCstMatchesSnapshot('if(1){}else if 9{a();}else{b(a, a());}')
 
     def test_else_cond_null(self):
         src = 'if 0==1{exit();  } startup();'
@@ -57,13 +57,13 @@ def setUp(self) -> None:
         self.setProperCwd()
 
     def test_no_params(self):
-        self.assertTreeMatchesSnapshot('def a() { alert("Called"); }')
+        self.assertCstMatchesSnapshot('def a() { alert("Called"); }')
 
     def test_one_param(self):
-        self.assertTreeMatchesSnapshot('def a(number val){print(val);}')
+        self.assertCstMatchesSnapshot('def a(number val){print(val);}')
 
     def test_two_param(self):
-        self.assertTreeMatchesSnapshot('def a(number a, string b){RESULT=a.."="..b;}')
+        self.assertCstMatchesSnapshot('def a(number a, string b){RESULT=a.."="..b;}')
 
 
 class TestTreeGenErrors(CommonTestCase):
@@ -77,211 +77,211 @@ def test_empty_sqb_error(self):
 
 class TreeGenEofTest(CommonTestCase):
     def test__at_expr_end(self):
-        self.assertFailsGracefully('a.b()')
+        self.assertFailsGracefullyCST('a.b()')
 
     def test__at_assign_end(self):
-        self.assertFailsGracefully('a.b = 8')
+        self.assertFailsGracefullyCST('a.b = 8')
 
     def test__at_let_end(self):
-        self.assertFailsGracefully('let a = 3')
+        self.assertFailsGracefullyCST('let a = 3')
 
     def test__at_global_end(self):
-        self.assertFailsGracefully('global a = 3')
+        self.assertFailsGracefullyCST('global a = 3')
 
     def test__at_decl_item_begin(self):
-        self.assertFailsGracefully('let')
+        self.assertFailsGracefullyCST('let')
 
     def test__at_decl_item_could_be_eq(self):
-        self.assertFailsGracefully('let a')
+        self.assertFailsGracefullyCST('let a')
 
     def test__at_decl_item_after_eq(self):
-        self.assertFailsGracefully('let a=')
+        self.assertFailsGracefullyCST('let a=')
 
     def test__at_def_start(self):
-        self.assertFailsGracefully('def')
+        self.assertFailsGracefullyCST('def')
 
     def test__at_def_name(self):
-        self.assertFailsGracefully('def a')
+        self.assertFailsGracefullyCST('def a')
 
     def test__at_def_lpar(self):
-        self.assertFailsGracefully('def a(')
+        self.assertFailsGracefullyCST('def a(')
 
     def test__at_def_param_type(self):
-        self.assertFailsGracefully('def a(t1')
+        self.assertFailsGracefullyCST('def a(t1')
 
     def test__at_def_param_value(self):
-        self.assertFailsGracefully('def a(t1 name')
+        self.assertFailsGracefullyCST('def a(t1 name')
 
     def test__at_def_param_comma(self):
-        self.assertFailsGracefully('def a(t1 name,')
+        self.assertFailsGracefullyCST('def a(t1 name,')
 
     def test__at_def_param_second_type(self):
-        self.assertFailsGracefully('def a(t1 name,t2')
+        self.assertFailsGracefullyCST('def a(t1 name,t2')
 
     def test__at_def_param_second_name(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2')
 
     def test__at_def_param_second_comma(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2,')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2,')
 
     def test__at_def_rpar_noargs(self):
-        self.assertFailsGracefully('def a()')
+        self.assertFailsGracefullyCST('def a()')
 
     def test__at_def_rpar_1_arg_comma(self):
-        self.assertFailsGracefully('def a(t1 name,)')
+        self.assertFailsGracefullyCST('def a(t1 name,)')
 
     def test__at_def_rpar_1_arg_no_comma(self):
-        self.assertFailsGracefully('def a(t1 name)')
+        self.assertFailsGracefullyCST('def a(t1 name)')
 
     def test__at_def_rpar_2_arg(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2)')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2)')
 
     def test__at_def_lbrace(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2){')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2){')
 
     def test__at_def_rbrace(self):
-        self.assertValidParse('def a(t1 name,t2 name2){}')
+        self.assertValidParseCST('def a(t1 name,t2 name2){}')
 
     def test__at_block_no_semi(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2){let a=1')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2){let a=1')
 
     def test__at_block_semi(self):
-        self.assertFailsGracefully('def a(t1 name,t2 name2){let a=1;')
+        self.assertFailsGracefullyCST('def a(t1 name,t2 name2){let a=1;')
 
     def test__common_flow_kwd(self):
         for name in ('while', 'repeat', 'while'):
             with self.subTest(name=name):
-                self.assertFailsGracefully(f'{name}')
+                self.assertFailsGracefullyCST(f'{name}')
 
     def test__common_flow_cond(self):
         for name in ('while', 'repeat', 'while'):
             with self.subTest(name=name):
-                self.assertFailsGracefully(f'{name} a+1')
+                self.assertFailsGracefullyCST(f'{name} a+1')
 
     def test__common_flow_lbrace(self):
         for name in ('while', 'repeat', 'while'):
             with self.subTest(name=name):
-                self.assertFailsGracefully(f'{name} a + 1 {{')
+                self.assertFailsGracefullyCST(f'{name} a + 1 {{')
 
     def test__if_full(self):
-        self.assertValidParse('if a+1{}')
+        self.assertValidParseCST('if a+1{}')
 
     def test__else_or_elseif__else(self):
-        self.assertFailsGracefully('if 1{}else')
+        self.assertFailsGracefullyCST('if 1{}else')
 
     def test__elseif_else_if(self):
-        self.assertFailsGracefully('if 1{}else if')
+        self.assertFailsGracefullyCST('if 1{}else if')
 
     def test__elseif_expr(self):
-        self.assertFailsGracefully('if 1{}else if 2')
+        self.assertFailsGracefullyCST('if 1{}else if 2')
 
     def test__elseif_lbrace(self):
-        self.assertFailsGracefully('if 1{}else if 2{')
+        self.assertFailsGracefullyCST('if 1{}else if 2{')
 
     def test__else_lbrace(self):
-        self.assertFailsGracefully('if 1{}else {')
+        self.assertFailsGracefullyCST('if 1{}else {')
 
     def test__call_args_lpar(self):
-        self.assertFailsGracefully('a(')
+        self.assertFailsGracefullyCST('a(')
 
     def test__call_args_arg1(self):
-        self.assertFailsGracefully('a(a')
+        self.assertFailsGracefullyCST('a(a')
 
     def test__call_args_arg1_comma(self):
-        self.assertFailsGracefully('a(a,')
+        self.assertFailsGracefullyCST('a(a,')
 
     def test__call_args_comma_rpar(self):
-        self.assertFailsGracefully('a(a,)')
+        self.assertFailsGracefullyCST('a(a,)')
 
     def test__call_args_rpar(self):
-        self.assertFailsGracefully('a(a)')
+        self.assertFailsGracefullyCST('a(a)')
 
     def test__call_args_noargs(self):
-        self.assertFailsGracefully('a()')
+        self.assertFailsGracefullyCST('a()')
 
     def test__string_single(self):
-        self.assertFailsGracefully('"a"')
+        self.assertFailsGracefullyCST('"a"')
 
     def test__string_autocat(self):
-        self.assertFailsGracefully('"a""b"')
+        self.assertFailsGracefullyCST('"a""b"')
 
     def test__number_single(self):
-        self.assertFailsGracefully('5')
+        self.assertFailsGracefullyCST('5')
 
     def test__lpar(self):
-        self.assertFailsGracefully('(')
+        self.assertFailsGracefullyCST('(')
 
     def test__lpar_expr(self):
-        self.assertFailsGracefully('(a')
+        self.assertFailsGracefullyCST('(a')
 
     def test__basic_chain_ident_only(self):
-        self.assertFailsGracefully('a')
+        self.assertFailsGracefullyCST('a')
 
     def test__basic_chain_dot(self):
-        self.assertFailsGracefully('a.')
+        self.assertFailsGracefullyCST('a.')
 
     def test__basic_chain_dot_attr(self):
-        self.assertFailsGracefully('a.b')
+        self.assertFailsGracefullyCST('a.b')
 
     def test__basic_chain_lsqb(self):
-        self.assertFailsGracefully('a[')
+        self.assertFailsGracefullyCST('a[')
 
     def test__basic_chain_getitem_expr(self):
-        self.assertFailsGracefully('a[b')
+        self.assertFailsGracefullyCST('a[b')
 
     def test__basic_chain_rsqb_full(self):
-        self.assertFailsGracefully('a[b]')
+        self.assertFailsGracefullyCST('a[b]')
 
     def test__basic_chain_rsqb_empty(self):
-        self.assertFailsGracefully('a[]')
+        self.assertFailsGracefullyCST('a[]')
 
     def test__basic_chain_call_lpar(self):
-        self.assertFailsGracefully('a(')
+        self.assertFailsGracefullyCST('a(')
 
     def test__basic_chain_call_inner(self):
-        self.assertFailsGracefully('a(b')
+        self.assertFailsGracefullyCST('a(b')
 
     def test__basic_chain_call_rpar_full(self):
-        self.assertFailsGracefully('a(b)')
+        self.assertFailsGracefullyCST('a(b)')
 
     def test__basic_chain_call_rpar_empty(self):
-        self.assertFailsGracefully('a()')
+        self.assertFailsGracefullyCST('a()')
 
     def test__unaries_single(self):
-        self.assertFailsGracefully('+')
+        self.assertFailsGracefullyCST('+')
 
     def test__unaries_many(self):
-        self.assertFailsGracefully('-+--!')
+        self.assertFailsGracefullyCST('-+--!')
 
     def test__unaries_many_expr(self):
-        self.assertFailsGracefully('-+--!a')
+        self.assertFailsGracefullyCST('-+--!a')
 
     def test__pow_op(self):
-        self.assertFailsGracefully('a**')
+        self.assertFailsGracefullyCST('a**')
 
     def test__pow_rhs_unary(self):
-        self.assertFailsGracefully('a**-')
+        self.assertFailsGracefullyCST('a**-')
 
     def test__pow_rhs_unary_expr(self):
-        self.assertFailsGracefully('a**-a')
+        self.assertFailsGracefullyCST('a**-a')
 
     def test__pow_rhs_expr(self):
-        self.assertFailsGracefully('a**b')
+        self.assertFailsGracefullyCST('a**b')
 
     def test__bin_op__op(self):
         for op in BINARY_OPS:
             with self.subTest(op=op):
-                self.assertFailsGracefully(f'a{op}')
+                self.assertFailsGracefullyCST(f'a{op}')
 
     def test__bin_op__expr(self):
         for op in BINARY_OPS:
             with self.subTest(op=op):
-                self.assertFailsGracefully(f'a{op}b')
+                self.assertFailsGracefullyCST(f'a{op}b')
 
     def test__bin_op__success(self):
         for op in set(BINARY_OPS):
             with self.subTest(op=op):
-                self.assertValidParse(f'a{op}b;')
+                self.assertValidParseCST(f'a{op}b;')
 
 
 if __name__ == '__main__':
diff --git a/test/test_main_examples.py b/test/test_main_examples.py
index 907d639..eb6da34 100644
--- a/test/test_main_examples.py
+++ b/test/test_main_examples.py
@@ -1,9 +1,10 @@
 import unittest
 
-from test.common import CommonTestCase
-from util import readfile
+from parser.astgen.astgen import AstGen
 from parser.cst.treegen import TreeGen
 from parser.lexer import Tokenizer
+from test.common import CommonTestCase
+from util import readfile
 
 
 class TestMain(CommonTestCase):
@@ -11,15 +12,17 @@ def setUp(self):
         self.setProperCwd()
         super().setUp()
 
-    def _test_main_example_n(self, n: int):
+    def _test_main_example_n(self, n: int, do_ast: bool = True):
         src = readfile(f'./main_example_{n}.st')
         tk = Tokenizer(src).tokenize()
         self.assertMatchesSnapshot(tk.tokens, 'tokens')
         t = TreeGen(tk)
         self.assertMatchesSnapshot(t.parse(), 'cst')
+        if do_ast:
+            self.assertMatchesSnapshot(AstGen(t).parse(), 'ast')
 
     def test_example_0(self):
-        self._test_main_example_n(0)
+        self._test_main_example_n(0, do_ast=False)
 
     def test_example_1(self):
         self._test_main_example_n(1)
diff --git a/util/__init__.py b/util/__init__.py
index c57299d..4780766 100644
--- a/util/__init__.py
+++ b/util/__init__.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from os import PathLike
-from typing import TypeVar, Any, overload
+from typing import TypeVar, Any, overload, Iterable
 
 from .simple_process_pool import *
 from .timeouts import *
@@ -26,3 +26,15 @@ def checked_cast(typ: type[T | U], val: Any) -> T | U: ...
 def checked_cast(typ: type[T], val: Any) -> T:
     assert isinstance(val, typ)
     return val
+
+
+def flatten_force(seq: Iterable[Iterable[T]]) -> list[T]:
+    return [item for sub in seq for item in sub]
+
+
+def is_strict_subclass(o: object, type_or_types: tuple[type, ...]):
+    try:
+        types = tuple(type_or_types)
+    except TypeError:
+        types = (type_or_types,)
+    return isinstance(o, type) and issubclass(o, types) and o not in types
diff --git a/util/simple_process_pool.py b/util/simple_process_pool.py
index 995bc0f..6cf17d6 100644
--- a/util/simple_process_pool.py
+++ b/util/simple_process_pool.py
@@ -5,8 +5,9 @@
 import multiprocessing.pool
 import os
 import queue
-
+import sys
 import time
+import weakref
 from dataclasses import dataclass, field
 from typing import Callable
 
@@ -18,7 +19,7 @@ class _Task:
 
 
 @dataclass
-class _PoolApplyTimeoutContext:
+class _TimeoutMgr:
     timeout: float | None = None
     timeout_includes_waiting: bool = False
     start: float = field(default_factory=time.perf_counter)
@@ -63,8 +64,7 @@ def _kill_and_restart(self, i: int):
         self.processes[i].kill()
         self.processes[i] = _ProcessWrapper(self, i)
 
-    async def _wait_for_empty_process(
-            self, timeout_ctx: _PoolApplyTimeoutContext, interval: float = 0):
+    async def _wait_for_empty_process(self, timeout_ctx: _TimeoutMgr, interval: float = 0):
         while True:
             for i, p in enumerate(self.processes):
                 self._update_process(i)
@@ -91,7 +91,7 @@ def _update_all_processes(self):
     async def apply(self, fn, args=None, kwargs=None, timeout: float = None,
                     interval: float = 0, timeout_includes_waiting=False):
         key, task = self._create_task(fn, args or (), kwargs or {})
-        timeout_ctx = _PoolApplyTimeoutContext(timeout, timeout_includes_waiting)
+        timeout_ctx = _TimeoutMgr(timeout, timeout_includes_waiting)
         proc_idx = await self._submit_to_empty_process(task, timeout_ctx, interval)
         await self._wait_for_task_result(key, proc_idx, timeout_ctx, interval)
         return self._handle_task_result(key)
@@ -112,7 +112,8 @@ async def _wait_for_task_result(self, key, proc_idx, timeout_ctx, interval):
             await asyncio.sleep(interval)
             self._update_all_processes()
 
-    async def _submit_to_empty_process(self, task, timeout_ctx, interval):
+    async def _submit_to_empty_process(
+            self, task: _Task, timeout_ctx: _TimeoutMgr, interval: float):
         idx, p = await self._wait_for_empty_process(timeout_ctx, interval)
         p.submit(task)
         timeout_ctx.on_start_task()
@@ -142,13 +143,45 @@ def __init__(self, parent: SimpleProcessPool, idx: int):
                             daemon=True)
         self.waiting_for_task = True
         self.p.start()
+        # weakref.finalize function is the civilized alternative to __del__
+        # with actually sensible semantics, see
+        # https://docs.python.org/3.11/library/weakref.html#weakref.finalize
+        weakref.finalize(self, self._finalize)
+
+    # (No tracing in finalizers so disable coverage for this)
+    def _finalize(self, timeout=0.050):  # pragma: no cover
+        # Give children 50ms to clean up, instead of rudely GC-ing them out of
+        # existence (ruining coverage by not giving them a chance to run atexit)
+        # I know 50ms is a lot, but it takes that long to shut down!
+        #  (Windows processes are very heavyweight!)
+        if not self.close(timeout, force=True):
+            print(f"Process didn't close in {timeout*1000:.0f}ms when being "
+                  f"GCed, so was killed.", file=sys.stderr)
 
     def submit(self, task: _Task):
         self.waiting_for_task = False
         self.tasks_in.put(task.inputs)
 
+    def close(self, timeout=0.050, force=False) -> bool:
+        # First, politely ask it to close
+        if not self.p.is_alive():
+            return True
+        self.tasks_in.put(None)
+        self.p.join(timeout)
+        # If it's no longer alive, it did close
+        if not self.p.is_alive():
+            self.p.close()
+            self._close_queues()
+            return True
+        if force:  # (Didn't close)
+            self.kill()
+        return False
+
     def kill(self):
         self.p.kill()
+        self._close_queues()
+
+    def _close_queues(self):
         self.tasks_in.close()
         self.results_out.close()
 
diff --git a/util/timeouts.py b/util/timeouts.py
index 3a9a5df..0602eea 100644
--- a/util/timeouts.py
+++ b/util/timeouts.py
@@ -22,13 +22,12 @@ def _worker_process(fn, dest, args, kwargs, debug):
     if dest is None:
         # No error handling channel - let caller handle it (e.g. the pool can handle it)
         return fn(*args, **kwargs)
-    # noinspection PyBroadException
     try:
         result = fn(*args, *kwargs)
     except Exception as e:
         print(e)
         dest.put(e)
-        raise
+        raise  # So Python prints it out properly
     else:
         dest.put(result)