jaclang 0.7.30__py3-none-any.whl → 0.7.31__py3-none-any.whl

jaclang/compiler/parser.py

@@ -5,8 +5,7 @@ from __future__ import annotations
 import keyword
 import logging
 import os
-from typing import Callable, TypeAlias
-
+from typing import Callable, TypeAlias, TypeVar
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler import jac_lark as jl  # type: ignore
@@ -15,6 +14,9 @@ from jaclang.compiler.passes.ir_pass import Pass
 from jaclang.vendor.lark import Lark, Transformer, Tree, logger
 
 
+T = TypeVar("T", bound=ast.AstNode)
+
+
 class JacParser(Pass):
     """Jac Parser."""
 
@@ -76,12 +78,12 @@ class JacParser(Pass):
             orig_src=mod.loc.orig_src,
             name=token.type,
             value=token.value,
-            line=token.line if token.line is not None else 0,
-            end_line=token.end_line if token.end_line is not None else 0,
-            col_start=token.column if token.column is not None else 0,
-            col_end=token.end_column if token.end_column is not None else 0,
-            pos_start=token.start_pos if token.start_pos is not None else 0,
-            pos_end=token.end_pos if token.end_pos is not None else 0,
+            line=token.line or 0,
+            end_line=token.end_line or 0,
+            col_start=token.column or 0,
+            col_end=token.end_column or 0,
+            pos_start=token.start_pos or 0,
+            pos_end=token.end_pos or 0,
             kid=[],
         )
 
@@ -130,6 +132,10 @@ class JacParser(Pass):
             super().__init__(*args, **kwargs)
             self.parse_ref = parser
             self.terminals: list[ast.Token] = []
+            # TODO: Once the kid is removed from the ast, we can get rid of this
+            # node_idx and directly pop(0) kid as we process the nodes.
+            self.node_idx = 0
+            self.cur_nodes: list[ast.AstNode] = []
 
         def ice(self) -> Exception:
             """Raise internal compiler error."""
@@ -138,32 +144,119 @@ class JacParser(Pass):
                 f"{self.parse_ref.__class__.__name__} - Internal Compiler Error, Invalid Parse Tree!"
             )
 
-        def nu(self, node: ast.T) -> ast.T:
-            """Update node."""
+        def _node_update(self, node: T) -> T:
             self.parse_ref.cur_node = node
             if node not in self.parse_ref.node_list:
                 self.parse_ref.node_list.append(node)
             return node
 
-        def start(self, kid: list[ast.Module]) -> ast.Module:
+        def _call_userfunc(
+            self, tree: jl.Tree, new_children: None | list[ast.AstNode] = None
+        ) -> ast.AstNode:
+            self.cur_nodes = new_children or tree.children  # type: ignore[assignment]
+            try:
+                return self._node_update(super()._call_userfunc(tree, new_children))
+            finally:
+                self.cur_nodes = []
+                self.node_idx = 0
+
+        def _call_userfunc_token(self, token: jl.Token) -> ast.AstNode:
+            return self._node_update(super()._call_userfunc_token(token))
+
+        def _binary_expr_unwind(self, kid: list[ast.AstNode]) -> ast.Expr:
+            """Binary expression helper."""
+            if len(kid) > 1:
+                if (
+                    isinstance(kid[0], ast.Expr)
+                    and isinstance(
+                        kid[1],
+                        (ast.Token, ast.DisconnectOp, ast.ConnectOp),
+                    )
+                    and isinstance(kid[2], ast.Expr)
+                ):
+                    return ast.BinaryExpr(
+                        left=kid[0],
+                        op=kid[1],
+                        right=kid[2],
+                        kid=kid,
+                    )
+                else:
+                    raise self.ice()
+            elif isinstance(kid[0], ast.Expr):
+                return kid[0]
+            else:
+                raise self.ice()
+
+        # ******************************************************************* #
+        # Parser Helper functions.                                            #
+        # ******************************************************************* #
+
+        def match(self, ty: type[T]) -> T | None:
+            """Return a node matching type 'ty' if possible from the current nodes."""
+            if (self.node_idx < len(self.cur_nodes)) and isinstance(
+                self.cur_nodes[self.node_idx], ty
+            ):
+                self.node_idx += 1
+                return self.cur_nodes[self.node_idx - 1]  # type: ignore[return-value]
+            return None
+
+        def consume(self, ty: type[T]) -> T:
+            """Consume and return the specified type, if it's not exists, will be an internal compiler error."""
+            if node := self.match(ty):
+                return node
+            raise self.ice()
+
+        def match_token(self, tok: Tok) -> ast.Token | None:
+            """Match a token with the given type and return it."""
+            if token := self.match(ast.Token):
+                if token.name == tok.name:
+                    return token
+                self.node_idx -= (
+                    1  # We're already matched but wrong token so undo matching it.
+                )
+            return None
+
+        def consume_token(self, tok: Tok) -> ast.Token:
+            """Consume a token with the given type and return it."""
+            if token := self.match_token(tok):
+                return token
+            raise self.ice()
+
+        def match_many(self, ty: type[T]) -> list[T]:
+            """Match 0 or more of the given type and return the list."""
+            nodes: list[ast.AstNode] = []
+            while node := self.match(ty):
+                nodes.append(node)
+            return nodes  # type: ignore[return-value]
+
+        def consume_many(self, ty: type[T]) -> list[T]:
+            """Match 1 or more of the given type and return the list."""
+            nodes: list[ast.AstNode] = [self.consume(ty)]
+            while node := self.match(ty):
+                nodes.append(node)
+            return nodes  # type: ignore[return-value]
+
+        # ******************************************************************* #
+        # Parsing Rules                                                       #
+        # ******************************************************************* #
+
+        def start(self, _: None) -> ast.Module:
             """Grammar rule.
 
             start: module
             """
-            kid[0]._in_mod_nodes = self.parse_ref.node_list
-            return self.nu(kid[0])
+            module = self.consume(ast.Module)
+            module._in_mod_nodes = self.parse_ref.node_list
+            return module
 
-        def module(
-            self, kid: list[ast.ElementStmt | ast.String | ast.EmptyToken]
-        ) -> ast.Module:
+        def module(self, _: None) -> ast.Module:
             """Grammar rule.
 
-            module: (doc_tag? element (element_with_doc | element)*)?
-            doc_tag (element_with_doc (element_with_doc | element)*)?
+            module: (toplevel_stmt (tl_stmt_with_doc | toplevel_stmt)*)?
+                | STRING (tl_stmt_with_doc | toplevel_stmt)*
             """
-            doc = kid[0] if len(kid) and isinstance(kid[0], ast.String) else None
-            body = kid[1:] if doc else kid
-            body = [i for i in body if isinstance(i, ast.ElementStmt)]
+            doc = self.match(ast.String)
+            body = self.match_many(ast.ElementStmt)
             mod = ast.Module(
                 name=self.parse_ref.mod_path.split(os.path.sep)[-1].rstrip(".jac"),
                 source=self.parse_ref.source,
@@ -172,28 +265,24 @@ class JacParser(Pass):
                 is_imported=False,
                 terminals=self.terminals,
                 kid=(
-                    kid
-                    if len(kid)
-                    else [ast.EmptyToken(ast.JacSource("", self.parse_ref.mod_path))]
+                    self.cur_nodes
+                    or [ast.EmptyToken(ast.JacSource("", self.parse_ref.mod_path))]
                 ),
             )
-            return self.nu(mod)
+            return mod
 
-        def element_with_doc(
-            self, kid: list[ast.ElementStmt | ast.String]
-        ) -> ast.ElementStmt:
+        def tl_stmt_with_doc(self, _: None) -> ast.ElementStmt:
             """Grammar rule.
 
-            element_with_doc: doc_tag element
+            tl_stmt_with_doc: doc_tag toplevel_stmt
             """
-            if isinstance(kid[1], ast.ElementStmt) and isinstance(kid[0], ast.String):
-                kid[1].doc = kid[0]
-                kid[1].add_kids_left([kid[0]])
-                return self.nu(kid[1])
-            else:
-                raise self.ice()
+            doc = self.consume(ast.String)
+            element = self.consume(ast.ElementStmt)
+            element.doc = doc
+            element.add_kids_left([doc])
+            return element
 
-        def element(self, kid: list[ast.AstNode]) -> ast.ElementStmt:
+        def toplevel_stmt(self, _: None) -> ast.ElementStmt:
             """Grammar rule.
 
             element: py_code_block
@@ -204,270 +293,219 @@ class JacParser(Pass):
                 | test
                 | global_var
             """
-            if isinstance(kid[0], ast.ElementStmt):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.ElementStmt)
 
-        def global_var(self, kid: list[ast.AstNode]) -> ast.GlobalVars:
+        def global_var(self, _: None) -> ast.GlobalVars:
             """Grammar rule.
 
             global_var: (KW_LET | KW_GLOBAL) access_tag? assignment_list SEMI
             """
-            is_frozen = isinstance(kid[0], ast.Token) and kid[0].name == Tok.KW_LET
-            access = kid[1] if isinstance(kid[1], ast.SubTag) else None
-            assignments = kid[2] if access else kid[1]
-            if isinstance(assignments, ast.SubNodeList):
-                return self.nu(
-                    ast.GlobalVars(
-                        access=access,
-                        assignments=assignments,
-                        is_frozen=is_frozen,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            is_frozen = self.consume(ast.Token).name == Tok.KW_LET
+            access_tag = self.match(ast.SubTag)
+            assignments = self.consume(ast.SubNodeList)
+            return ast.GlobalVars(
+                access=access_tag,
+                assignments=assignments,
+                is_frozen=is_frozen,
+                kid=self.cur_nodes,
+            )
 
-        def access_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Token]:
+        def access_tag(self, _: None) -> ast.SubTag[ast.Token]:
             """Grammar rule.
 
             access_tag: COLON ( KW_PROT | KW_PUB | KW_PRIV )
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Token):
-                return self.nu(
-                    ast.SubTag[ast.Token](
-                        tag=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.COLON)
+            access = self.consume(ast.Token)
+            return ast.SubTag[ast.Token](tag=access, kid=self.cur_nodes)
 
-        def test(self, kid: list[ast.AstNode]) -> ast.Test:
+        def test(self, _: None) -> ast.Test:
             """Grammar rule.
 
             test: KW_TEST NAME? code_block
             """
-            name = kid[1] if isinstance(kid[1], ast.Name) else kid[0]
-            codeblock = kid[2] if name != kid[0] else kid[1]
-            if isinstance(codeblock, ast.SubNodeList) and isinstance(
-                name, (ast.Name, ast.Token)
-            ):
-                return self.nu(
-                    ast.Test(
-                        name=name,
-                        body=codeblock,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            # Q(thakee): Why the name should be KW_TEST if no name present?
+            test_tok = self.consume_token(Tok.KW_TEST)
+            name = self.match(ast.Name) or test_tok
+            codeblock = self.consume(ast.SubNodeList)
+            return ast.Test(
+                name=name,
+                body=codeblock,
+                kid=self.cur_nodes,
+            )
 
-        def free_code(self, kid: list[ast.AstNode]) -> ast.ModuleCode:
+        def free_code(self, _: None) -> ast.ModuleCode:
             """Grammar rule.
 
             free_code: KW_WITH KW_ENTRY sub_name? code_block
             """
-            name = kid[2] if isinstance(kid[2], ast.SubTag) else None
-            codeblock = kid[3] if name else kid[2]
-            if isinstance(codeblock, ast.SubNodeList):
-                return self.nu(
-                    ast.ModuleCode(
-                        name=name,
-                        body=codeblock,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
-
-        def doc_tag(self, kid: list[ast.AstNode]) -> ast.String:
-            """Grammar rule.
-
-            doc_tag: ( STRING | DOC_STRING )
-            """
-            if isinstance(kid[0], ast.String):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_WITH)
+            self.consume_token(Tok.KW_ENTRY)
+            name = self.match(ast.SubTag)
+            codeblock = self.consume(ast.SubNodeList)
+            return ast.ModuleCode(
+                name=name,
+                body=codeblock,
+                kid=self.cur_nodes,
+            )
 
-        def py_code_block(self, kid: list[ast.AstNode]) -> ast.PyInlineCode:
+        def py_code_block(self, _: None) -> ast.PyInlineCode:
             """Grammar rule.
 
             py_code_block: PYNLINE
             """
-            if isinstance(kid[0], ast.Token):
-                return self.nu(
-                    ast.PyInlineCode(
-                        code=kid[0],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            pyinline = self.consume_token(Tok.PYNLINE)
+            return ast.PyInlineCode(
+                code=pyinline,
+                kid=self.cur_nodes,
+            )
 
-        def import_stmt(self, kid: list[ast.AstNode]) -> ast.Import:
+        def import_stmt(self, _: None) -> ast.Import:
             """Grammar rule.
 
             import_stmt: KW_IMPORT sub_name? KW_FROM from_path LBRACE import_items RBRACE
-                    | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
-                    | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
-                    | include_stmt
+                       | KW_IMPORT sub_name? KW_FROM from_path COMMA import_items SEMI  //Deprecated
+                       | KW_IMPORT sub_name? import_path (COMMA import_path)* SEMI
+                       | include_stmt
             """
-            if len(kid) == 1 and isinstance(kid[0], ast.Import):
-                return self.nu(kid[0])
-            chomp = [*kid]
-            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
-            chomp = chomp[2:] if lang else chomp[1:]
-            from_path = chomp[1] if isinstance(chomp[1], ast.ModulePath) else None
-            if from_path:
-                items = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
+            if import_stmt := self.match(ast.Import):  # Include Statement.
+                return import_stmt
+
+            # TODO: kid will be removed so let's keep as it is for now.
+            kid = self.cur_nodes
+
+            from_path: ast.ModulePath | None = None
+            self.consume_token(Tok.KW_IMPORT)
+            lang = self.match(ast.SubTag)
+
+            if self.match_token(Tok.KW_FROM):
+                from_path = self.consume(ast.ModulePath)
+                self.consume(ast.Token)  # LBRACE or COMMA
+                items = self.consume(ast.SubNodeList)
+                if self.consume(ast.Token).name == Tok.SEMI:  # RBRACE or SEMI
+                    self.parse_ref.warning(
+                        "Deprecated syntax, use braces for multiple imports (e.g, import from mymod {a, b, c})",
+                    )
             else:
-                paths = [i for i in kid if isinstance(i, ast.ModulePath)]
+                paths = [self.consume(ast.ModulePath)]
+                while self.match_token(Tok.COMMA):
+                    paths.append(self.consume(ast.ModulePath))
+                self.consume_token(Tok.SEMI)
                 items = ast.SubNodeList[ast.ModulePath](
-                    items=paths, delim=Tok.COMMA, kid=kid[2 if lang else 1 : -1]
+                    items=paths,
+                    delim=Tok.COMMA,
+                    # TODO: kid will be removed so let's keep as it is for now.
+                    kid=self.cur_nodes[2 if lang else 1 : -1],
                 )
                 kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
 
             is_absorb = False
-            if isinstance(items, ast.SubNodeList):
-                ret = self.nu(
-                    ast.Import(
-                        hint=lang,
-                        from_loc=from_path,
-                        items=items,
-                        is_absorb=is_absorb,
-                        kid=kid,
-                    )
-                )
-                if (
-                    from_path
-                    and isinstance(kid[-1], ast.Token)
-                    and kid[-1].name == Tok.SEMI
-                ):
-                    self.parse_ref.warning(
-                        "Deprecated syntax, use braces for multiple imports (e.g, import from mymod {a, b, c})",
-                    )
-                return ret
-            else:
-                raise self.ice()
+            return ast.Import(
+                hint=lang,
+                from_loc=from_path,
+                items=items,
+                is_absorb=is_absorb,
+                kid=kid,
+            )
 
-        def from_path(self, kid: list[ast.AstNode]) -> ast.ModulePath:
+        def from_path(self, _: None) -> ast.ModulePath:
             """Grammar rule.
 
             from_path: (DOT | ELLIPSIS)* import_path
-                    | (DOT | ELLIPSIS)+
+                     | (DOT | ELLIPSIS)+
             """
             level = 0
-            for i in kid:
-                if isinstance(i, ast.Token):
-                    if i.name == Tok.DOT:
-                        level += 1
-                    elif i.name == Tok.ELLIPSIS:
-                        level += 3
-            if isinstance(kid[-1], ast.ModulePath):
-                ret = kid[-1]
-                adds = [i for i in kid if isinstance(i, ast.Token)]
-                ret.level = level
-                ret.add_kids_left(adds)
-                return ret
-            else:
-                return self.nu(
-                    ast.ModulePath(
-                        path=None,
-                        level=level,
-                        alias=None,
-                        kid=kid,
-                    )
-                )
+            while True:
+                if self.match_token(Tok.DOT):
+                    level += 1
+                elif self.match_token(Tok.ELLIPSIS):
+                    level += 3
+                else:
+                    break
+            if import_path := self.match(ast.ModulePath):
+                kids = [i for i in self.cur_nodes if isinstance(i, ast.Token)]
+                import_path.level = level
+                import_path.add_kids_left(kids)
+                return import_path
 
-        def include_stmt(self, kid: list[ast.AstNode]) -> ast.Import:
+            return ast.ModulePath(
+                path=None,
+                level=level,
+                alias=None,
+                kid=self.cur_nodes,
+            )
+
+        def include_stmt(self, _: None) -> ast.Import:
             """Grammar rule.
 
-            include_stmt: KW_INCLUDE sub_name import_path SEMI
+            include_stmt: KW_INCLUDE sub_name? import_path SEMI
             """
-            lang = kid[1] if isinstance(kid[1], ast.SubTag) else None
-            from_path = kid[2] if lang else kid[1]
-            if not isinstance(from_path, ast.ModulePath):
-                raise self.ice()
+            kid = self.cur_nodes  # TODO: Will be removed.
+            self.consume_token(Tok.KW_INCLUDE)
+            lang = self.match(ast.SubTag)
+            from_path = self.consume(ast.ModulePath)
             items = ast.SubNodeList[ast.ModulePath](
                 items=[from_path], delim=Tok.COMMA, kid=[from_path]
             )
-            kid = (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
+            kid = (
+                (kid[:2] if lang else kid[:1]) + [items] + kid[-1:]
+            )  # TODO: Will be removed.
             is_absorb = True
-            return self.nu(
-                ast.Import(
-                    hint=lang,
-                    from_loc=None,
-                    items=items,
-                    is_absorb=is_absorb,
-                    kid=kid,
-                )
+            return ast.Import(
+                hint=lang,
+                from_loc=None,
+                items=items,
+                is_absorb=is_absorb,
+                kid=kid,
             )
 
-        def import_path(self, kid: list[ast.AstNode]) -> ast.ModulePath:
+        def import_path(self, _: None) -> ast.ModulePath:
             """Grammar rule.
 
             import_path: named_ref (DOT named_ref)* (KW_AS NAME)?
             """
-            valid_path = [i for i in kid if isinstance(i, ast.Name)]
-            alias = (
-                kid[-1]
-                if len(kid) > 2
-                and isinstance(kid[-1], ast.Name)
-                and isinstance(kid[-2], ast.Token)
-                and kid[-2].name == Tok.KW_AS
-                else None
+            valid_path = [self.consume(ast.Name)]
+            while self.match_token(Tok.DOT):
+                valid_path.append(self.consume(ast.Name))
+            alias = self.consume(ast.Name) if self.match_token(Tok.KW_AS) else None
+            return ast.ModulePath(
+                path=valid_path,
+                level=0,
+                alias=alias,
+                kid=self.cur_nodes,
             )
-            if alias is not None:
-                valid_path = valid_path[:-1]
 
-            return self.nu(
-                ast.ModulePath(
-                    path=valid_path,
-                    level=0,
-                    alias=alias,
-                    kid=kid,
-                )
-            )
-
-        def import_items(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ModuleItem]:
+        def import_items(self, _: None) -> ast.SubNodeList[ast.ModuleItem]:
             """Grammar rule.
 
             import_items: (import_item COMMA)* import_item COMMA?
             """
+            items = [self.consume(ast.ModuleItem)]
+            while self.match_token(Tok.COMMA):
+                if module_item := self.match(ast.ModuleItem):
+                    items.append(module_item)
             ret = ast.SubNodeList[ast.ModuleItem](
-                items=[i for i in kid if isinstance(i, ast.ModuleItem)],
+                items=items,
                 delim=Tok.COMMA,
-                kid=kid,
+                kid=self.cur_nodes,
             )
-            return self.nu(ret)
+            return ret
 
-        def import_item(self, kid: list[ast.AstNode]) -> ast.ModuleItem:
+        def import_item(self, _: None) -> ast.ModuleItem:
             """Grammar rule.
 
             import_item: named_ref (KW_AS NAME)?
             """
-            name = kid[0]
-            alias = kid[2] if len(kid) > 1 else None
-            if isinstance(name, ast.Name) and (
-                alias is None or isinstance(alias, ast.Name)
-            ):
-                return self.nu(
-                    ast.ModuleItem(
-                        name=name,
-                        alias=alias,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            name = self.consume(ast.Name)
+            alias = self.consume(ast.Name) if self.match_token(Tok.KW_AS) else None
+            return ast.ModuleItem(
+                name=name,
+                alias=alias,
+                kid=self.cur_nodes,
+            )
 
         def architype(
-            self, kid: list[ast.AstNode]
+            self, _: None
         ) -> ast.ArchSpec | ast.ArchDef | ast.Enum | ast.EnumDef:
             """Grammar rule.
 
@@ -475,52 +513,49 @@ class JacParser(Pass):
                     | architype_def
                     | enum
             """
-            if isinstance(kid[0], ast.SubNodeList):
-                if isinstance(kid[1], ast.ArchSpec):
-                    kid[1].decorators = kid[0]
-                    kid[1].add_kids_left([kid[0]])
-                    return self.nu(kid[1])
-                else:
-                    raise self.ice()
+            archspec: ast.ArchSpec | ast.ArchDef | ast.Enum | ast.EnumDef | None = None
 
-            elif isinstance(kid[0], (ast.ArchSpec, ast.ArchDef, ast.Enum, ast.EnumDef)):
-                return self.nu(kid[0])
+            decorators = self.match(ast.SubNodeList)
+            if decorators is not None:
+                archspec = self.consume(ast.ArchSpec)
+                archspec.decorators = decorators
+                archspec.add_kids_left([decorators])
             else:
-                raise self.ice()
+                archspec = (
+                    self.match(ast.ArchSpec)
+                    or self.match(ast.ArchDef)
+                    or self.match(ast.Enum)
+                    or self.consume(ast.EnumDef)
+                )
+            return archspec
 
-        def architype_decl(self, kid: list[ast.AstNode]) -> ast.ArchSpec:
+        def architype_decl(self, _: None) -> ast.ArchSpec:
             """Grammar rule.
 
             architype_decl: arch_type access_tag? STRING? NAME inherited_archs? (member_block | SEMI)
             """
-            arch_type = kid[0]
-            access = kid[1] if isinstance(kid[1], ast.SubTag) else None
-            semstr = (
-                kid[2]
-                if (access and isinstance(kid[2], ast.String))
-                else kid[1] if isinstance(kid[1], ast.String) else None
+            arch_type = self.consume(ast.Token)
+            access = self.match(ast.SubTag)
+            semstr = self.match(ast.String)
+            name = self.consume(ast.Name)
+            sub_list1 = self.match(ast.SubNodeList)
+            sub_list2 = self.match(ast.SubNodeList)
+            if self.match_token(Tok.SEMI):
+                inh, body = sub_list1, None
+            else:
+                body = (
+                    sub_list2 or sub_list1
+                )  # if sub_list2 is None then body is sub_list1
+                inh = sub_list2 and sub_list1  # if sub_list2 is None then inh is None.
+            return ast.Architype(
+                arch_type=arch_type,
+                name=name,
+                semstr=semstr,
+                access=access,
+                base_classes=inh,
+                body=body,
+                kid=self.cur_nodes,
             )
-            name = (
-                kid[3]
-                if (access and semstr)
-                else kid[2] if (access or semstr) else kid[1]
-            )
-            inh = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
-            body = kid[-1] if isinstance(kid[-1], ast.SubNodeList) else None
-            if isinstance(arch_type, ast.Token) and isinstance(name, ast.Name):
-                return self.nu(
-                    ast.Architype(
-                        arch_type=arch_type,
-                        name=name,
-                        semstr=semstr,
-                        access=access,
-                        base_classes=inh,
-                        body=body,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
         def architype_def(self, kid: list[ast.AstNode]) -> ast.ArchDef:
             """Grammar rule.
@@ -530,12 +565,10 @@ class JacParser(Pass):
             if isinstance(kid[0], ast.ArchRefChain) and isinstance(
                 kid[1], ast.SubNodeList
             ):
-                return self.nu(
-                    ast.ArchDef(
-                        target=kid[0],
-                        body=kid[1],
-                        kid=kid,
-                    )
+                return ast.ArchDef(
+                    target=kid[0],
+                    body=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -549,7 +582,7 @@ class JacParser(Pass):
                     | KW_NODE
             """
             if isinstance(kid[0], ast.Token):
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
@@ -560,12 +593,10 @@ class JacParser(Pass):
             """
             valid_decors = [i for i in kid if isinstance(i, ast.Expr)]
             if len(valid_decors) == len(kid) / 2:
-                return self.nu(
-                    ast.SubNodeList[ast.Expr](
-                        items=valid_decors,
-                        delim=Tok.DECOR_OP,
-                        kid=kid,
-                    )
+                return ast.SubNodeList[ast.Expr](
+                    items=valid_decors,
+                    delim=Tok.DECOR_OP,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -577,12 +608,10 @@ class JacParser(Pass):
                            | COLON (atomic_chain COMMA)* atomic_chain COLON
             """
             valid_inh = [i for i in kid if isinstance(i, ast.Expr)]
-            return self.nu(
-                ast.SubNodeList[ast.Expr](
-                    items=valid_inh,
-                    delim=Tok.COMMA,
-                    kid=kid,
-                )
+            return ast.SubNodeList[ast.Expr](
+                items=valid_inh,
+                delim=Tok.COMMA,
+                kid=kid,
             )
 
         def sub_name(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Name]:
@@ -591,11 +620,9 @@ class JacParser(Pass):
             sub_name: COLON NAME
             """
             if isinstance(kid[1], ast.Name):
-                return self.nu(
-                    ast.SubTag[ast.Name](
-                        tag=kid[1],
-                        kid=kid,
-                    )
+                return ast.SubTag[ast.Name](
+                    tag=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -608,7 +635,7 @@ class JacParser(Pass):
                     | NAME
             """
             if isinstance(kid[0], ast.NameAtom):
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
@@ -623,60 +650,47 @@ class JacParser(Pass):
                         | KW_HERE
             """
             if isinstance(kid[0], ast.Name):
-                return self.nu(ast.SpecialVarRef(var=kid[0]))
+                return ast.SpecialVarRef(var=kid[0])
             else:
                 raise self.ice()
 
-        def enum(self, kid: list[ast.AstNode]) -> ast.Enum | ast.EnumDef:
+        def enum(self, _: None) -> ast.Enum | ast.EnumDef:
             """Grammar rule.
 
             enum: decorators? enum_decl
                 | enum_def
             """
-            if isinstance(kid[0], ast.SubNodeList):
-                if isinstance(kid[1], ast.Enum):
-                    kid[1].decorators = kid[0]
-                    kid[1].add_kids_left([kid[0]])
-                    return self.nu(kid[1])
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], (ast.Enum, ast.EnumDef)):
-                return self.nu(kid[0])
-            else:
-
-                raise self.ice()
+            if decorator := self.match(ast.SubNodeList):
+                enum_decl = self.consume(ast.Enum)
+                enum_decl.decorators = decorator
+                enum_decl.add_kids_left([decorator])
+                return enum_decl
+            return self.match(ast.Enum) or self.consume(ast.EnumDef)
 
-        def enum_decl(self, kid: list[ast.AstNode]) -> ast.Enum:
+        def enum_decl(self, _: None) -> ast.Enum:
             """Grammar rule.
 
             enum_decl: KW_ENUM access_tag? STRING? NAME inherited_archs? (enum_block | SEMI)
             """
-            access = kid[1] if isinstance(kid[1], ast.SubTag) else None
-            semstr = (
-                kid[2]
-                if (access and isinstance(kid[2], ast.String))
-                else kid[1] if isinstance(kid[1], ast.String) else None
+            self.consume_token(Tok.KW_ENUM)
+            access = self.match(ast.SubTag)
+            semstr = self.match(ast.String)
+            name = self.consume(ast.Name)
+            sub_list1 = self.match(ast.SubNodeList)
+            sub_list2 = self.match(ast.SubNodeList)
+            if self.match_token(Tok.SEMI):
+                inh, body = sub_list1, None
+            else:
+                body = sub_list2 or sub_list1
+                inh = sub_list2 and sub_list1
+            return ast.Enum(
+                semstr=semstr,
+                name=name,
+                access=access,
+                base_classes=inh,
+                body=body,
+                kid=self.cur_nodes,
             )
-            name = (
-                kid[3]
-                if (access and semstr)
-                else kid[2] if (access or semstr) else kid[1]
-            )
-            inh = kid[-2] if isinstance(kid[-2], ast.SubNodeList) else None
-            body = kid[-1] if isinstance(kid[-1], ast.SubNodeList) else None
-            if isinstance(name, ast.Name):
-                return self.nu(
-                    ast.Enum(
-                        semstr=semstr,
-                        name=name,
-                        access=access,
-                        base_classes=inh,
-                        body=body,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
         def enum_def(self, kid: list[ast.AstNode]) -> ast.EnumDef:
             """Grammar rule.
@@ -686,12 +700,10 @@ class JacParser(Pass):
             if isinstance(kid[0], ast.ArchRefChain) and isinstance(
                 kid[1], ast.SubNodeList
             ):
-                return self.nu(
-                    ast.EnumDef(
-                        target=kid[0],
-                        body=kid[1],
-                        kid=kid,
-                    )
+                return ast.EnumDef(
+                    target=kid[0],
+                    body=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -705,9 +717,9 @@ class JacParser(Pass):
             """
             ret = ast.SubNodeList[ast.EnumBlockStmt](items=[], delim=Tok.COMMA, kid=kid)
             ret.items = [i for i in kid if isinstance(i, ast.EnumBlockStmt)]
-            return self.nu(ret)
+            return ret
 
-        def enum_stmt(self, kid: list[ast.AstNode]) -> ast.EnumBlockStmt:
+        def enum_stmt(self, _: None) -> ast.EnumBlockStmt:
             """Grammar rule.
 
             enum_stmt: NAME (COLON STRING)? EQ expression
@@ -717,81 +729,43 @@ class JacParser(Pass):
                     | abstract_ability
                     | ability
             """
-            if isinstance(kid[0], (ast.PyInlineCode, ast.Ability)):
-                return self.nu(kid[0])
-            elif isinstance(kid[0], (ast.Name)):
-                if (
-                    len(kid) >= 3
-                    and isinstance(kid[-1], ast.Expr)
-                    and not isinstance(kid[-1], ast.String)
-                ):
-                    semstr = (
-                        kid[2]
-                        if len(kid) > 3 and isinstance(kid[2], ast.String)
-                        else None
-                    )
-                    targ = ast.SubNodeList[ast.Expr](
-                        items=[kid[0]], delim=Tok.COMMA, kid=[kid[0]]
-                    )
-                    kid[0] = targ
-                    return self.nu(
-                        ast.Assignment(
-                            target=targ,
-                            value=kid[-1],
-                            type_tag=None,
-                            kid=kid,
-                            semstr=semstr,
-                            is_enum_stmt=True,
-                        )
-                    )
-                else:
-                    semstr = (
-                        kid[2]
-                        if len(kid) == 3 and isinstance(kid[2], ast.String)
-                        else None
-                    )
-                    targ = ast.SubNodeList[ast.Expr](
-                        items=[kid[0]], delim=Tok.COMMA, kid=[kid[0]]
-                    )
-                    kid[0] = targ
-                    return self.nu(
-                        ast.Assignment(
-                            target=targ,
-                            value=None,
-                            type_tag=None,
-                            kid=kid,
-                            semstr=semstr,
-                            is_enum_stmt=True,
-                        )
-                    )
-            elif isinstance(kid[0], (ast.PyInlineCode, ast.ModuleCode)):
-                return self.nu(kid[0])
-            raise self.ice()
-
-        def ability(
-            self, kid: list[ast.AstNode]
-        ) -> ast.Ability | ast.AbilityDef | ast.FuncCall:
+            if stmt := (
+                self.match(ast.PyInlineCode)
+                or self.match(ast.ModuleCode)
+                or self.match(ast.Ability)
+            ):
+                return stmt
+            name = self.consume(ast.Name)
+            semstr = self.consume(ast.String) if self.match_token(Tok.COLON) else None
+            expr = self.consume(ast.Expr) if self.match_token(Tok.EQ) else None
+            targ = ast.SubNodeList[ast.Expr](items=[name], delim=Tok.COMMA, kid=[name])
+            self.cur_nodes[0] = targ
+            return ast.Assignment(
+                target=targ,
+                value=expr,
+                type_tag=None,
+                kid=self.cur_nodes,
+                semstr=semstr,
+                is_enum_stmt=True,
+            )
+
+        def ability(self, _: None) -> ast.Ability | ast.AbilityDef | ast.FuncCall:
             """Grammer rule.
 
             ability: decorators? KW_ASYNC? ability_decl
                     | decorators? genai_ability
                     | ability_def
             """
-            chomp = [*kid]
-            decorators = chomp[0] if isinstance(chomp[0], ast.SubNodeList) else None
-            chomp = chomp[1:] if decorators else chomp
-            is_async = (
-                chomp[0]
-                if isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_ASYNC
-                else None
-            )
-            ability = chomp[1] if is_async else chomp[0]
-            if not isinstance(ability, (ast.Ability, ast.AbilityDef)):
-                raise self.ice()
-            if is_async and isinstance(ability, ast.Ability):
+            ability: ast.Ability | ast.AbilityDef | None = None
+            decorators = self.match(ast.SubNodeList)
+            is_async = self.match_token(Tok.KW_ASYNC)
+            ability = self.match(ast.Ability)
+            if is_async and ability:
                 ability.is_async = True
                 ability.add_kids_left([is_async])
-            if isinstance(decorators, ast.SubNodeList):
+            if ability is None:
+                ability = self.consume(ast.AbilityDef)
+            if decorators:
                 for dec in decorators.items:
                     if (
                         isinstance(dec, ast.NameAtom)
@@ -801,55 +775,43 @@ class JacParser(Pass):
                         ability.is_static = True
                         decorators.items.remove(dec)  # noqa: B038
                         break
-                if len(decorators.items):
+                if decorators.items:
                     ability.decorators = decorators
                     ability.add_kids_left([decorators])
-                return self.nu(ability)
-            return self.nu(ability)
+                return ability
+            return ability
 
-        def ability_decl(self, kid: list[ast.AstNode]) -> ast.Ability:
+        def ability_decl(self, _: None) -> ast.Ability:
             """Grammar rule.
 
             ability_decl: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING?
                 named_ref (func_decl | event_clause) (code_block | SEMI)
             """
-            chomp = [*kid]
-            is_override = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_OVERRIDE
-            )
-            chomp = chomp[1:] if is_override else chomp
-            is_static = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_STATIC
+            signature: ast.FuncSignature | ast.EventSignature | None = None
+            body: ast.SubNodeList | None = None
+            is_override = self.match_token(Tok.KW_OVERRIDE) is not None
+            is_static = self.match_token(Tok.KW_STATIC) is not None
+            self.consume_token(Tok.KW_CAN)
+            access = self.match(ast.SubTag)
+            semstr = self.match(ast.String)
+            name = self.consume(ast.NameAtom)
+            signature = self.match(ast.FuncSignature) or self.consume(
+                ast.EventSignature
+            )
+            if (body := self.match(ast.SubNodeList)) is None:
+                self.consume_token(Tok.SEMI)
+            return ast.Ability(
+                name_ref=name,
+                is_async=False,
+                is_override=is_override,
+                is_static=is_static,
+                is_abstract=False,
+                access=access,
+                semstr=semstr,
+                signature=signature,
+                body=body,
+                kid=self.cur_nodes,
             )
-            chomp = chomp[2:] if is_static else chomp[1:]
-            access = chomp[0] if isinstance(chomp[0], ast.SubTag) else None
-            chomp = chomp[1:] if access else chomp
-            semstr = chomp[0] if isinstance(chomp[0], ast.String) else None
-            chomp = chomp[1:] if semstr else chomp
-            name = chomp[0]
-            chomp = chomp[1:]
-            signature = chomp[0]
-            chomp = chomp[1:]
-            body = chomp[0] if isinstance(chomp[0], ast.SubNodeList) else None
-            if isinstance(name, ast.NameAtom) and isinstance(
-                signature, (ast.FuncSignature, ast.EventSignature)
-            ):
-                return self.nu(
-                    ast.Ability(
-                        name_ref=name,
-                        is_async=False,
-                        is_override=is_override,
-                        is_static=is_static,
-                        is_abstract=False,
-                        access=access,
-                        semstr=semstr,
-                        signature=signature,
-                        body=body,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
         def ability_def(self, kid: list[ast.AstNode]) -> ast.AbilityDef:
             """Grammar rule.
@@ -861,137 +823,99 @@ class JacParser(Pass):
                 and isinstance(kid[1], (ast.FuncSignature, ast.EventSignature))
                 and isinstance(kid[2], ast.SubNodeList)
             ):
-                return self.nu(
-                    ast.AbilityDef(
-                        target=kid[0],
-                        signature=kid[1],
-                        body=kid[2],
-                        kid=kid,
-                    )
+                return ast.AbilityDef(
+                    target=kid[0],
+                    signature=kid[1],
+                    body=kid[2],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
 
         # We need separate production rule for abstract_ability because we don't
         # want to allow regular abilities outside of classed to be abstract.
-        def abstract_ability(self, kid: list[ast.AstNode]) -> ast.Ability:
+        def abstract_ability(self, _: None) -> ast.Ability:
             """Grammar rule.
 
             abstract_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING?
                 named_ref (func_decl | event_clause) KW_ABSTRACT SEMI
             """
-            chomp = [*kid]
-            is_override = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_OVERRIDE
-            )
-            chomp = chomp[1:] if is_override else chomp
-            is_static = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_STATIC
-            )
-            chomp = chomp[1:] if is_static else chomp
-            chomp = chomp[1:]
-            access = chomp[0] if isinstance(chomp[0], ast.SubTag) else None
-            chomp = chomp[1:] if access else chomp
-            semstr = chomp[0] if isinstance(chomp[0], ast.String) else None
-            chomp = chomp[1:] if semstr else chomp
-            name = chomp[0]
-            chomp = chomp[1:]
-            signature = chomp[0]
-            chomp = chomp[1:]
-            if isinstance(name, ast.NameAtom) and isinstance(
-                signature, (ast.FuncSignature, ast.EventSignature)
-            ):
-                return self.nu(
-                    ast.Ability(
-                        name_ref=name,
-                        is_async=False,
-                        is_override=is_override,
-                        is_static=is_static,
-                        is_abstract=True,
-                        access=access,
-                        semstr=semstr,
-                        signature=signature,
-                        body=None,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
-
-        def genai_ability(self, kid: list[ast.AstNode]) -> ast.Ability:
+            signature: ast.FuncSignature | ast.EventSignature | None = None
+            is_override = self.match_token(Tok.KW_OVERRIDE) is not None
+            is_static = self.match_token(Tok.KW_STATIC) is not None
+            self.consume_token(Tok.KW_CAN)
+            access = self.match(ast.SubTag)
+            semstr = self.match(ast.String)
+            name = self.consume(ast.NameAtom)
+            signature = self.match(ast.FuncSignature) or self.consume(
+                ast.EventSignature
+            )
+            self.consume_token(Tok.KW_ABSTRACT)
+            self.consume_token(Tok.SEMI)
+            return ast.Ability(
+                name_ref=name,
+                is_async=False,
+                is_override=is_override,
+                is_static=is_static,
+                is_abstract=True,
+                access=access,
+                semstr=semstr,
+                signature=signature,
+                body=None,
+                kid=self.cur_nodes,
+            )
+
+        def genai_ability(self, _: None) -> ast.Ability:
             """Grammar rule.
 
             genai_ability: KW_OVERRIDE? KW_STATIC? KW_CAN access_tag? STRING?
             named_ref (func_decl) KW_BY atomic_call SEMI
             """
-            chomp = [*kid]
-            is_override = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_OVERRIDE
-            )
-            chomp = chomp[1:] if is_override else chomp
-            is_static = (
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_STATIC
+            is_override = self.match_token(Tok.KW_OVERRIDE) is not None
+            is_static = self.match_token(Tok.KW_STATIC) is not None
+            self.consume_token(Tok.KW_CAN)
+            access = self.match(ast.SubTag)
+            semstr = self.match(ast.String)
+            name = self.consume(ast.NameAtom)
+            signature = self.match(ast.FuncSignature) or self.consume(
+                ast.EventSignature
+            )
+            self.consume_token(Tok.KW_BY)
+            body = self.consume(ast.FuncCall)
+            self.consume_token(Tok.SEMI)
+            return ast.Ability(
+                name_ref=name,
+                is_async=False,
+                is_override=is_override,
+                is_static=is_static,
+                is_abstract=False,
+                access=access,
+                semstr=semstr,
+                signature=signature,
+                body=body,
+                kid=self.cur_nodes,
             )
-            chomp = chomp[1:] if is_static else chomp
-            chomp = chomp[1:]
-            access = chomp[0] if isinstance(chomp[0], ast.SubTag) else None
-            chomp = chomp[1:] if access else chomp
-            semstr = chomp[0] if isinstance(chomp[0], ast.String) else None
-            chomp = chomp[1:] if semstr else chomp
-            name = chomp[0]
-            chomp = chomp[1:]
-            signature = chomp[0]
-            chomp = chomp[1:]
-            has_by = isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_BY
-            chomp = chomp[1:] if has_by else chomp
-            if (
-                isinstance(name, ast.NameAtom)
-                and isinstance(signature, (ast.FuncSignature, ast.EventSignature))
-                and isinstance(chomp[0], ast.FuncCall)
-                and has_by
-            ):
-                return self.nu(
-                    ast.Ability(
-                        name_ref=name,
-                        is_async=False,
-                        is_override=is_override,
-                        is_static=is_static,
-                        is_abstract=False,
-                        access=access,
-                        semstr=semstr,
-                        signature=signature,
-                        body=chomp[0],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
-        def event_clause(self, kid: list[ast.AstNode]) -> ast.EventSignature:
+        def event_clause(self, _: None) -> ast.EventSignature:
             """Grammar rule.
 
             event_clause: KW_WITH expression? (KW_EXIT | KW_ENTRY) (STRING? RETURN_HINT expression)?
             """
-            type_specs = kid[1] if isinstance(kid[1], ast.Expr) else None
-            return_spec = kid[-1] if isinstance(kid[-1], ast.Expr) else None
-            semstr = (
-                kid[-3] if return_spec and isinstance(kid[-3], ast.String) else None
+            return_spec: ast.Expr | None = None
+            semstr: ast.String | None = None
+            self.consume_token(Tok.KW_WITH)
+            type_specs = self.match(ast.Expr)
+            event = self.match_token(Tok.KW_EXIT) or self.consume_token(Tok.KW_ENTRY)
+            if semstr := self.match(ast.String):
+                self.consume_token(Tok.RETURN_HINT)
+                return_spec = self.consume(ast.Expr)
+            return ast.EventSignature(
+                semstr=semstr,
+                event=event,
+                arch_tag_info=type_specs,
+                return_type=return_spec,
+                kid=self.cur_nodes,
             )
-            event = kid[2] if type_specs else kid[1]
-            if isinstance(event, ast.Token) and (
-                isinstance(return_spec, ast.Expr) or return_spec is None
-            ):
-                return self.nu(
-                    ast.EventSignature(
-                        semstr=semstr,
-                        event=event,
-                        arch_tag_info=type_specs,
-                        return_type=return_spec,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
         def func_decl(self, kid: list[ast.AstNode]) -> ast.FuncSignature:
             """Grammar rule.
@@ -1012,21 +936,17 @@ class JacParser(Pass):
             if (isinstance(params, ast.SubNodeList) or params is None) and (
                 isinstance(return_spec, ast.Expr) or return_spec is None
             ):
-                return self.nu(
-                    ast.FuncSignature(
-                        semstr=semstr,
-                        params=params,
-                        return_type=return_spec,
-                        kid=(
-                            kid
-                            if len(kid)
-                            else [
-                                ast.EmptyToken(
-                                    ast.JacSource("", self.parse_ref.mod_path)
-                                )
-                            ]
-                        ),
-                    )
+                return ast.FuncSignature(
+                    semstr=semstr,
+                    params=params,
+                    return_type=return_spec,
+                    kid=(
+                        kid
+                        if len(kid)
+                        else [
+                            ast.EmptyToken(ast.JacSource("", self.parse_ref.mod_path))
+                        ]
+                    ),
                 )
             else:
                 raise self.ice()
@@ -1043,7 +963,7 @@ class JacParser(Pass):
                 delim=Tok.COMMA,
                 kid=kid,
             )
-            return self.nu(ret)
+            return ret
 
         def param_var(self, kid: list[ast.AstNode]) -> ast.ParamVar:
             """Grammar rule.
@@ -1074,15 +994,13 @@ class JacParser(Pass):
                 )
             )
             if isinstance(name, ast.Name) and isinstance(type_tag, ast.SubTag):
-                return self.nu(
-                    ast.ParamVar(
-                        semstr=semstr,
-                        name=name,
-                        type_tag=type_tag,
-                        value=value,
-                        unpack=star,
-                        kid=kid,
-                    )
+                return ast.ParamVar(
+                    semstr=semstr,
+                    name=name,
+                    type_tag=type_tag,
+                    value=value,
+                    unpack=star,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -1102,7 +1020,7 @@ class JacParser(Pass):
             ret.items = [i for i in kid if isinstance(i, ast.ArchBlockStmt)]
             ret.left_enc = kid[0] if isinstance(kid[0], ast.Token) else None
             ret.right_enc = kid[-1] if isinstance(kid[-1], ast.Token) else None
-            return self.nu(ret)
+            return ret
 
         def member_stmt(self, kid: list[ast.AstNode]) -> ast.ArchBlockStmt:
             """Grammar rule.
@@ -1114,7 +1032,7 @@ class JacParser(Pass):
                         | doc_tag? has_stmt
             """
             if isinstance(kid[0], ast.ArchBlockStmt):
-                ret = self.nu(kid[0])
+                ret = kid[0]
             elif (
                 isinstance(kid[1], ast.ArchBlockStmt)
                 and isinstance(kid[1], ast.AstDocNode)
@@ -1122,7 +1040,7 @@ class JacParser(Pass):
             ):
                 kid[1].doc = kid[0]
                 kid[1].add_kids_left([kid[0]])
-                ret = self.nu(kid[1])
+                ret = kid[1]
             else:
                 raise self.ice()
             if isinstance(ret, ast.Ability):
@@ -1145,14 +1063,12 @@ class JacParser(Pass):
             chomp = chomp[1:] if access else chomp
             assign = chomp[0]
             if isinstance(assign, ast.SubNodeList):
-                return self.nu(
-                    ast.ArchHas(
-                        vars=assign,
-                        is_static=is_static,
-                        is_frozen=is_freeze,
-                        access=access,
-                        kid=kid,
-                    )
+                return ast.ArchHas(
+                    vars=assign,
+                    is_static=is_static,
+                    is_frozen=is_freeze,
+                    access=access,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -1176,12 +1092,10 @@ class JacParser(Pass):
                 assign = kid[0]
                 new_kid = [assign]
             valid_kid = [i for i in new_kid if isinstance(i, ast.HasVar)]
-            return self.nu(
-                ast.SubNodeList[ast.HasVar](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=new_kid,
-                )
+            return ast.SubNodeList[ast.HasVar](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=new_kid,
             )
 
         def typed_has_clause(self, kid: list[ast.AstNode]) -> ast.HasVar:
@@ -1195,35 +1109,27 @@ class JacParser(Pass):
             defer = isinstance(kid[-1], ast.Token) and kid[-1].name == Tok.KW_POST_INIT
             value = kid[-1] if not defer and isinstance(kid[-1], ast.Expr) else None
             if isinstance(name, ast.Name) and isinstance(type_tag, ast.SubTag):
-                return self.nu(
-                    ast.HasVar(
-                        semstr=semstr,
-                        name=name,
-                        type_tag=type_tag,
-                        defer=defer,
-                        value=value,
-                        kid=kid,
-                    )
+                return ast.HasVar(
+                    semstr=semstr,
+                    name=name,
+                    type_tag=type_tag,
+                    defer=defer,
+                    value=value,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
 
-        def type_tag(self, kid: list[ast.AstNode]) -> ast.SubTag[ast.Expr]:
+        def type_tag(self, _: None) -> ast.SubTag[ast.Expr]:
             """Grammar rule.
 
             type_tag: COLON expression
             """
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.SubTag[ast.Expr](
-                        tag=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.COLON)
+            tag = self.consume(ast.Expr)
+            return ast.SubTag[ast.Expr](tag=tag, kid=self.cur_nodes)
 
-        def builtin_type(self, kid: list[ast.AstNode]) -> ast.Token:
+        def builtin_type(self, _: None) -> ast.Token:
             """Grammar rule.
 
             builtin_type: TYP_TYPE
@@ -1238,22 +1144,18 @@ class JacParser(Pass):
                         | TYP_BYTES
                         | TYP_STRING
             """
-            if isinstance(kid[0], ast.Token):
-                return self.nu(
-                    ast.BuiltinType(
-                        name=kid[0].name,
-                        orig_src=self.parse_ref.source,
-                        value=kid[0].value,
-                        line=kid[0].loc.first_line,
-                        end_line=kid[0].loc.last_line,
-                        col_start=kid[0].loc.col_start,
-                        col_end=kid[0].loc.col_end,
-                        pos_start=kid[0].pos_start,
-                        pos_end=kid[0].pos_end,
-                    )
-                )
-            else:
-                raise self.ice()
+            token = self.consume(ast.Token)
+            return ast.BuiltinType(
+                name=token.name,
+                orig_src=self.parse_ref.source,
+                value=token.value,
+                line=token.loc.first_line,
+                end_line=token.loc.last_line,
+                col_start=token.loc.col_start,
+                col_end=token.loc.col_end,
+                pos_start=token.pos_start,
+                pos_end=token.pos_end,
+            )
 
         def code_block(
             self, kid: list[ast.AstNode]
@@ -1266,14 +1168,12 @@ class JacParser(Pass):
             right_enc = kid[-1] if isinstance(kid[-1], ast.Token) else None
             valid_stmt = [i for i in kid if isinstance(i, ast.CodeBlockStmt)]
             if len(valid_stmt) == len(kid) - 2:
-                return self.nu(
-                    ast.SubNodeList[ast.CodeBlockStmt](
-                        items=valid_stmt,
-                        delim=Tok.WS,
-                        left_enc=left_enc,
-                        right_enc=right_enc,
-                        kid=kid,
-                    )
+                return ast.SubNodeList[ast.CodeBlockStmt](
+                    items=valid_stmt,
+                    delim=Tok.WS,
+                    left_enc=left_enc,
+                    right_enc=right_enc,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -1308,7 +1208,7 @@ class JacParser(Pass):
                     | SEMI
             """
             if isinstance(kid[0], ast.CodeBlockStmt) and len(kid) < 2:
-                return self.nu(kid[0])
+                return kid[0]
             elif isinstance(kid[0], ast.Token) and kid[0].name == Tok.KW_YIELD:
                 return ast.ExprStmt(
                     expr=(
@@ -1329,7 +1229,7 @@ class JacParser(Pass):
                 )
             elif isinstance(kid[0], ast.CodeBlockStmt):
                 kid[0].add_kids_right([kid[1]])
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
@@ -1339,294 +1239,215 @@ class JacParser(Pass):
             typed_ctx_block: RETURN_HINT expression code_block
             """
             if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.TypedCtxBlock(
-                        type_ctx=kid[1],
-                        body=kid[2],
-                        kid=kid,
-                    )
+                return ast.TypedCtxBlock(
+                    type_ctx=kid[1],
+                    body=kid[2],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
 
-        def if_stmt(self, kid: list[ast.AstNode]) -> ast.IfStmt:
+        def if_stmt(self, _: None) -> ast.IfStmt:
             """Grammar rule.
 
             if_stmt: KW_IF expression code_block (elif_stmt | else_stmt)?
             """
-            if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.IfStmt(
-                        condition=kid[1],
-                        body=kid[2],
-                        else_body=(
-                            kid[3]
-                            if len(kid) > 3
-                            and isinstance(kid[3], (ast.ElseStmt, ast.ElseIf))
-                            else None
-                        ),
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_IF)
+            condition = self.consume(ast.Expr)
+            body = self.consume(ast.SubNodeList)
+            else_body = self.match(ast.ElseStmt) or self.match(ast.ElseIf)
+            return ast.IfStmt(
+                condition=condition,
+                body=body,
+                else_body=else_body,
+                kid=self.cur_nodes,
+            )
 
-        def elif_stmt(self, kid: list[ast.AstNode]) -> ast.ElseIf:
+        def elif_stmt(self, _: None) -> ast.ElseIf:
             """Grammar rule.
 
             elif_stmt: KW_ELIF expression code_block (elif_stmt | else_stmt)?
             """
-            if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.ElseIf(
-                        condition=kid[1],
-                        body=kid[2],
-                        else_body=(
-                            kid[3]
-                            if len(kid) > 3
-                            and isinstance(kid[3], (ast.ElseStmt, ast.ElseIf))
-                            else None
-                        ),
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_ELIF)
+            condition = self.consume(ast.Expr)
+            body = self.consume(ast.SubNodeList)
+            else_body = self.match(ast.ElseStmt) or self.match(ast.ElseIf)
+            return ast.ElseIf(
+                condition=condition,
+                body=body,
+                else_body=else_body,
+                kid=self.cur_nodes,
+            )
 
-        def else_stmt(self, kid: list[ast.AstNode]) -> ast.ElseStmt:
+        def else_stmt(self, _: None) -> ast.ElseStmt:
             """Grammar rule.
 
             else_stmt: KW_ELSE code_block
             """
-            if isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.ElseStmt(
-                        body=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_ELSE)
+            body = self.consume(ast.SubNodeList)
+            return ast.ElseStmt(
+                body=body,
+                kid=self.cur_nodes,
+            )
 
-        def try_stmt(self, kid: list[ast.AstNode]) -> ast.TryStmt:
+        def try_stmt(self, _: None) -> ast.TryStmt:
             """Grammar rule.
 
             try_stmt: KW_TRY code_block except_list? else_stmt? finally_stmt?
             """
-            chomp = [*kid][1:]
-            block = chomp[0]
-            chomp = chomp[1:]
-            except_list = (
-                chomp[0]
-                if len(chomp) and isinstance(chomp[0], ast.SubNodeList)
-                else None
-            )
-            chomp = chomp[1:] if except_list else chomp
-            else_stmt = (
-                chomp[0] if len(chomp) and isinstance(chomp[0], ast.ElseStmt) else None
+            self.consume_token(Tok.KW_TRY)
+            block = self.consume(ast.SubNodeList)
+            except_list = self.match(ast.SubNodeList)
+            else_stmt = self.match(ast.ElseStmt)
+            finally_stmt = self.match(ast.FinallyStmt)
+            return ast.TryStmt(
+                body=block,
+                excepts=except_list,
+                else_body=else_stmt,
+                finally_body=finally_stmt,
+                kid=self.cur_nodes,
             )
-            chomp = chomp[1:] if else_stmt else chomp
-            finally_stmt = (
-                chomp[0]
-                if len(chomp) and isinstance(chomp[0], ast.FinallyStmt)
-                else None
-            )
-            if isinstance(block, ast.SubNodeList):
-                return self.nu(
-                    ast.TryStmt(
-                        body=block,
-                        excepts=except_list,
-                        else_body=else_stmt,
-                        finally_body=finally_stmt,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
 
-        def except_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.Except]:
+        def except_list(self, _: None) -> ast.SubNodeList[ast.Except]:
             """Grammar rule.
 
             except_list: except_def+
             """
-            valid_kid = [i for i in kid if isinstance(i, ast.Except)]
-            if len(valid_kid) == len(kid):
-                return self.nu(
-                    ast.SubNodeList[ast.Except](
-                        items=valid_kid,
-                        delim=Tok.WS,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            items = [self.consume(ast.Except)]
+            while expt := self.match(ast.Except):
+                items.append(expt)
+            return ast.SubNodeList[ast.Except](
+                items=items,
+                delim=Tok.WS,
+                kid=self.cur_nodes,
+            )
 
-        def except_def(self, kid: list[ast.AstNode]) -> ast.Except:
+        def except_def(self, _: None) -> ast.Except:
             """Grammar rule.
 
             except_def: KW_EXCEPT expression (KW_AS NAME)? code_block
             """
-            ex_type = kid[1]
-            name = kid[3] if len(kid) > 3 and isinstance(kid[3], ast.Name) else None
-            body = kid[-1]
-            if isinstance(ex_type, ast.Expr) and isinstance(body, ast.SubNodeList):
-                return self.nu(
-                    ast.Except(
-                        ex_type=ex_type,
-                        name=name,
-                        body=body,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            name: ast.Name | None = None
+            self.consume_token(Tok.KW_EXCEPT)
+            ex_type = self.consume(ast.Expr)
+            if self.match_token(Tok.KW_AS):
+                name = self.consume(ast.Name)
+            body = self.consume(ast.SubNodeList)
+            return ast.Except(
+                ex_type=ex_type,
+                name=name,
+                body=body,
+                kid=self.cur_nodes,
+            )
 
-        def finally_stmt(self, kid: list[ast.AstNode]) -> ast.FinallyStmt:
+        def finally_stmt(self, _: None) -> ast.FinallyStmt:
             """Grammar rule.
 
             finally_stmt: KW_FINALLY code_block
             """
-            if isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.FinallyStmt(
-                        body=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_FINALLY)
+            body = self.consume(ast.SubNodeList)
+            return ast.FinallyStmt(
+                body=body,
+                kid=self.cur_nodes,
+            )
 
-        def for_stmt(self, kid: list[ast.AstNode]) -> ast.IterForStmt | ast.InForStmt:
+        def for_stmt(self, _: None) -> ast.IterForStmt | ast.InForStmt:
             """Grammar rule.
 
             for_stmt: KW_ASYNC? KW_FOR assignment KW_TO expression KW_BY
                         expression code_block else_stmt?
                     | KW_ASYNC? KW_FOR expression KW_IN expression code_block else_stmt?
             """
-            chomp = [*kid]
-            is_async = bool(
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_ASYNC
+            is_async = bool(self.match_token(Tok.KW_ASYNC))
+            self.consume_token(Tok.KW_FOR)
+            if iter := self.match(ast.Assignment):
+                self.consume_token(Tok.KW_TO)
+                condition = self.consume(ast.Expr)
+                self.consume_token(Tok.KW_BY)
+                count_by = self.consume(ast.Assignment)
+                body = self.consume(ast.SubNodeList)
+                else_body = self.match(ast.ElseStmt)
+                return ast.IterForStmt(
+                    is_async=is_async,
+                    iter=iter,
+                    condition=condition,
+                    count_by=count_by,
+                    body=body,
+                    else_body=else_body,
+                    kid=self.cur_nodes,
+                )
+            target = self.consume(ast.Expr)
+            self.consume_token(Tok.KW_IN)
+            collection = self.consume(ast.Expr)
+            body = self.consume(ast.SubNodeList)
+            else_body = self.match(ast.ElseStmt)
+            return ast.InForStmt(
+                is_async=is_async,
+                target=target,
+                collection=collection,
+                body=body,
+                else_body=else_body,
+                kid=self.cur_nodes,
             )
-            chomp = chomp[1:] if is_async else chomp
-            if isinstance(chomp[1], ast.Assignment):
-                if (
-                    isinstance(chomp[3], ast.Expr)
-                    and isinstance(chomp[5], ast.Assignment)
-                    and isinstance(chomp[6], ast.SubNodeList)
-                ):
-                    return self.nu(
-                        ast.IterForStmt(
-                            is_async=is_async,
-                            iter=chomp[1],
-                            condition=chomp[3],
-                            count_by=chomp[5],
-                            body=chomp[6],
-                            else_body=(
-                                chomp[-1]
-                                if isinstance(chomp[-1], ast.ElseStmt)
-                                else None
-                            ),
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(chomp[1], ast.Expr):
-                if isinstance(chomp[3], ast.Expr) and isinstance(
-                    chomp[4], ast.SubNodeList
-                ):
-                    return self.nu(
-                        ast.InForStmt(
-                            is_async=is_async,
-                            target=chomp[1],
-                            collection=chomp[3],
-                            body=chomp[4],
-                            else_body=(
-                                chomp[-1]
-                                if isinstance(chomp[-1], ast.ElseStmt)
-                                else None
-                            ),
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            else:
-                raise self.ice()
 
-        def while_stmt(self, kid: list[ast.AstNode]) -> ast.WhileStmt:
+        def while_stmt(self, _: None) -> ast.WhileStmt:
             """Grammar rule.
 
             while_stmt: KW_WHILE expression code_block
             """
-            if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.WhileStmt(
-                        condition=kid[1],
-                        body=kid[2],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_WHILE)
+            condition = self.consume(ast.Expr)
+            body = self.consume(ast.SubNodeList)
+            return ast.WhileStmt(
+                condition=condition,
+                body=body,
+                kid=self.cur_nodes,
+            )
 
-        def with_stmt(self, kid: list[ast.AstNode]) -> ast.WithStmt:
+        def with_stmt(self, _: None) -> ast.WithStmt:
             """Grammar rule.
 
-            with_stmt: KW_ASYNC? KW_WITH expr_as_list code_block
-            """
-            chomp = [*kid]
-            is_async = bool(
-                isinstance(chomp[0], ast.Token) and chomp[0].name == Tok.KW_ASYNC
-            )
-            chomp = chomp[1:] if is_async else chomp
-            if isinstance(chomp[1], ast.SubNodeList) and isinstance(
-                chomp[2], ast.SubNodeList
-            ):
-                return self.nu(
-                    ast.WithStmt(
-                        is_async=is_async,
-                        exprs=chomp[1],
-                        body=chomp[2],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            with_stmt: KW_ASYNC? KW_WITH expr_as_list code_block
+            """
+            is_async = bool(self.match_token(Tok.KW_ASYNC))
+            self.consume_token(Tok.KW_WITH)
+            exprs = self.consume(ast.SubNodeList)
+            body = self.consume(ast.SubNodeList)
+            return ast.WithStmt(
+                is_async=is_async,
+                exprs=exprs,
+                body=body,
+                kid=self.cur_nodes,
+            )
 
-        def expr_as_list(
-            self, kid: list[ast.AstNode]
-        ) -> ast.SubNodeList[ast.ExprAsItem]:
+        def expr_as_list(self, _: None) -> ast.SubNodeList[ast.ExprAsItem]:
             """Grammar rule.
 
             expr_as_list: (expr_as COMMA)* expr_as
             """
-            ret = ast.SubNodeList[ast.ExprAsItem](
-                items=[i for i in kid if isinstance(i, ast.ExprAsItem)],
+            items = [self.consume(ast.ExprAsItem)]
+            while self.match_token(Tok.COMMA):
+                items.append(self.consume(ast.ExprAsItem))
+            return ast.SubNodeList[ast.ExprAsItem](
+                items=items,
                 delim=Tok.COMMA,
-                kid=kid,
+                kid=self.cur_nodes,
             )
-            return self.nu(ret)
 
-        def expr_as(self, kid: list[ast.AstNode]) -> ast.ExprAsItem:
+        def expr_as(self, _: None) -> ast.ExprAsItem:
             """Grammar rule.
 
             expr_as: expression (KW_AS expression)?
             """
-            expr = kid[0]
-            alias = kid[2] if len(kid) > 1 else None
-            if isinstance(expr, ast.Expr) and (
-                alias is None or isinstance(alias, ast.Expr)
-            ):
-                return self.nu(
-                    ast.ExprAsItem(
-                        expr=expr,
-                        alias=alias,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            expr = self.consume(ast.Expr)
+            alias = self.consume(ast.Expr) if self.match_token(Tok.KW_AS) else None
+            return ast.ExprAsItem(
+                expr=expr,
+                alias=alias,
+                kid=self.cur_nodes,
+            )
 
         def raise_stmt(self, kid: list[ast.AstNode]) -> ast.RaiseStmt:
             """Grammar rule.
@@ -1639,113 +1460,90 @@ class JacParser(Pass):
             )
             chomp = chomp[2:] if e_type and len(chomp) > 1 else chomp[1:]
             e = chomp[0] if len(chomp) > 0 and isinstance(chomp[0], ast.Expr) else None
-            return self.nu(
-                ast.RaiseStmt(
-                    cause=e_type,
-                    from_target=e,
-                    kid=kid,
-                )
+            return ast.RaiseStmt(
+                cause=e_type,
+                from_target=e,
+                kid=kid,
             )
 
-        def assert_stmt(self, kid: list[ast.AstNode]) -> ast.AssertStmt:
+        def assert_stmt(self, _: None) -> ast.AssertStmt:
             """Grammar rule.
 
             assert_stmt: KW_ASSERT expression (COMMA expression)?
             """
-            condition = kid[1]
-            error_msg = kid[3] if len(kid) > 3 else None
-            if isinstance(condition, ast.Expr):
-                return self.nu(
-                    ast.AssertStmt(
-                        condition=condition,
-                        error_msg=(
-                            error_msg if isinstance(error_msg, ast.Expr) else None
-                        ),
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            error_msg: ast.Expr | None = None
+            self.consume_token(Tok.KW_ASSERT)
+            condition = self.consume(ast.Expr)
+            if self.match_token(Tok.COMMA):
+                error_msg = self.consume(ast.Expr)
+            return ast.AssertStmt(
+                condition=condition,
+                error_msg=error_msg,
+                kid=self.cur_nodes,
+            )
 
-        def check_stmt(self, kid: list[ast.AstNode]) -> ast.CheckStmt:
+        def check_stmt(self, _: None) -> ast.CheckStmt:
             """Grammar rule.
 
             check_stmt: KW_CHECK expression
             """
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.CheckStmt(
-                        target=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_CHECK)
+            target = self.consume(ast.Expr)
+            return ast.CheckStmt(
+                target=target,
+                kid=self.cur_nodes,
+            )
 
-        def ctrl_stmt(self, kid: list[ast.AstNode]) -> ast.CtrlStmt:
+        def ctrl_stmt(self, _: None) -> ast.CtrlStmt:
             """Grammar rule.
 
             ctrl_stmt: KW_SKIP | KW_BREAK | KW_CONTINUE
             """
-            if isinstance(kid[0], ast.Token):
-                return self.nu(
-                    ast.CtrlStmt(
-                        ctrl=kid[0],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            tok = (
+                self.match_token(Tok.KW_SKIP)
+                or self.match_token(Tok.KW_BREAK)
+                or self.consume_token(Tok.KW_CONTINUE)
+            )
+            return ast.CtrlStmt(
+                ctrl=tok,
+                kid=self.cur_nodes,
+            )
 
-        def delete_stmt(self, kid: list[ast.AstNode]) -> ast.DeleteStmt:
+        def delete_stmt(self, _: None) -> ast.DeleteStmt:
             """Grammar rule.
 
             delete_stmt: KW_DELETE expression
             """
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.DeleteStmt(
-                        target=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_DELETE)
+            target = self.consume(ast.Expr)
+            return ast.DeleteStmt(
+                target=target,
+                kid=self.cur_nodes,
+            )
 
-        def report_stmt(self, kid: list[ast.AstNode]) -> ast.ReportStmt:
+        def report_stmt(self, _: None) -> ast.ReportStmt:
             """Grammar rule.
 
             report_stmt: KW_REPORT expression
             """
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.ReportStmt(
-                        expr=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_REPORT)
+            target = self.consume(ast.Expr)
+            return ast.ReportStmt(
+                expr=target,
+                kid=self.cur_nodes,
+            )
 
-        def return_stmt(self, kid: list[ast.AstNode]) -> ast.ReturnStmt:
+        def return_stmt(self, _: None) -> ast.ReturnStmt:
             """Grammar rule.
 
             return_stmt: KW_RETURN expression?
             """
-            if len(kid) > 1:
-                return self.nu(
-                    ast.ReturnStmt(
-                        expr=kid[1] if isinstance(kid[1], ast.Expr) else None,
-                        kid=kid,
-                    )
-                )
-            else:
-                return self.nu(
-                    ast.ReturnStmt(
-                        expr=None,
-                        kid=kid,
-                    )
-                )
+            self.consume_token(Tok.KW_RETURN)
+            expr = self.match(ast.Expr)
+            return ast.ReturnStmt(
+                expr=expr,
+                kid=self.cur_nodes,
+            )
 
         def walker_stmt(self, kid: list[ast.AstNode]) -> ast.CodeBlockStmt:
             """Grammar rule.
@@ -1753,90 +1551,91 @@ class JacParser(Pass):
             walker_stmt: disengage_stmt | revisit_stmt | visit_stmt | ignore_stmt
             """
             if isinstance(kid[0], ast.CodeBlockStmt):
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
-        def ignore_stmt(self, kid: list[ast.AstNode]) -> ast.IgnoreStmt:
+        def ignore_stmt(self, _: None) -> ast.IgnoreStmt:
             """Grammar rule.
 
             ignore_stmt: KW_IGNORE expression SEMI
             """
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.IgnoreStmt(
-                        target=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_IGNORE)
+            target = self.consume(ast.Expr)
+            self.consume_token(Tok.SEMI)
+            return ast.IgnoreStmt(
+                target=target,
+                kid=self.cur_nodes,
+            )
 
-        def visit_stmt(self, kid: list[ast.AstNode]) -> ast.VisitStmt:
+        def visit_stmt(self, _: None) -> ast.VisitStmt:
             """Grammar rule.
 
             visit_stmt: KW_VISIT (inherited_archs)? expression (else_stmt | SEMI)
             """
-            sub_name = kid[1] if isinstance(kid[1], ast.SubNodeList) else None
-            target = kid[2] if sub_name else kid[1]
-            else_body = kid[-1] if isinstance(kid[-1], ast.ElseStmt) else None
-            if isinstance(target, ast.Expr):
-                return self.nu(
-                    ast.VisitStmt(
-                        vis_type=sub_name,
-                        target=target,
-                        else_body=else_body,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_VISIT)
+            sub_name = self.match(ast.SubNodeList)
+            target = self.consume(ast.Expr)
+            else_body = self.match(ast.ElseStmt)
+            if else_body is None:
+                self.consume_token(Tok.SEMI)
+            return ast.VisitStmt(
+                vis_type=sub_name,
+                target=target,
+                else_body=else_body,
+                kid=self.cur_nodes,
+            )
 
-        def revisit_stmt(self, kid: list[ast.AstNode]) -> ast.RevisitStmt:
+        def revisit_stmt(self, _: None) -> ast.RevisitStmt:
             """Grammar rule.
 
             revisit_stmt: KW_REVISIT expression? (else_stmt | SEMI)
             """
-            target = kid[1] if isinstance(kid[1], ast.Expr) else None
-            else_body = kid[-1] if isinstance(kid[-1], ast.ElseStmt) else None
-            return self.nu(
-                ast.RevisitStmt(
-                    hops=target,
-                    else_body=else_body,
-                    kid=kid,
-                )
+            self.consume_token(Tok.KW_REVISIT)
+            target = self.match(ast.Expr)
+            else_body = self.match(ast.ElseStmt)
+            if else_body is None:
+                self.consume_token(Tok.SEMI)
+            return ast.RevisitStmt(
+                hops=target,
+                else_body=else_body,
+                kid=self.cur_nodes,
             )
 
-        def disengage_stmt(self, kid: list[ast.AstNode]) -> ast.DisengageStmt:
+        def disengage_stmt(self, _: None) -> ast.DisengageStmt:
             """Grammar rule.
 
             disengage_stmt: KW_DISENGAGE SEMI
             """
-            return self.nu(
-                ast.DisengageStmt(
-                    kid=kid,
-                )
+            kw = self.consume_token(Tok.KW_DISENGAGE)
+            semi = self.consume_token(Tok.SEMI)
+            return ast.DisengageStmt(
+                kid=[kw, semi],
             )
 
-        def global_ref(self, kid: list[ast.AstNode]) -> ast.GlobalStmt:
+        def global_ref(self, _: None) -> ast.GlobalStmt:
             """Grammar rule.
 
             global_ref: GLOBAL_OP name_list
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.SubNodeList):
-                return self.nu(ast.GlobalStmt(target=kid[1], kid=kid))
-            else:
-                raise self.ice()
+            self.consume_token(Tok.GLOBAL_OP)
+            target = self.consume(ast.SubNodeList)
+            return ast.GlobalStmt(
+                target=target,
+                kid=self.cur_nodes,
+            )
 
-        def nonlocal_ref(self, kid: list[ast.AstNode]) -> ast.NonLocalStmt:
+        def nonlocal_ref(self, _: None) -> ast.NonLocalStmt:
             """Grammar rule.
 
             nonlocal_ref: NONLOCAL_OP name_list
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.SubNodeList):
-                return self.nu(ast.NonLocalStmt(target=kid[1], kid=kid))
-            else:
-                raise self.ice()
+            self.consume_token(Tok.NONLOCAL_OP)
+            target = self.consume(ast.SubNodeList)
+            return ast.NonLocalStmt(
+                target=target,
+                kid=self.cur_nodes,
+            )
 
         def assignment(self, kid: list[ast.AstNode]) -> ast.Assignment:
             """Grammar rule.
@@ -1899,88 +1698,49 @@ class JacParser(Pass):
             kid = [x for x in kid if x not in assignees]
             kid.insert(1, new_targ) if is_frozen else kid.insert(0, new_targ)
             if is_aug:
-                return self.nu(
-                    ast.Assignment(
-                        target=new_targ,
-                        type_tag=type_tag if isinstance(type_tag, ast.SubTag) else None,
-                        value=value,
-                        mutable=is_frozen,
-                        aug_op=is_aug,
-                        kid=kid,
-                    )
-                )
-            return self.nu(
-                ast.Assignment(
+                return ast.Assignment(
                     target=new_targ,
                     type_tag=type_tag if isinstance(type_tag, ast.SubTag) else None,
                     value=value,
                     mutable=is_frozen,
+                    aug_op=is_aug,
                     kid=kid,
-                    semstr=semstr if isinstance(semstr, ast.String) else None,
                 )
+            return ast.Assignment(
+                target=new_targ,
+                type_tag=type_tag if isinstance(type_tag, ast.SubTag) else None,
+                value=value,
+                mutable=is_frozen,
+                kid=kid,
+                semstr=semstr if isinstance(semstr, ast.String) else None,
             )
 
-        def expression(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def expression(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             expression: walrus_assign
                     | pipe (KW_IF expression KW_ELSE expression)?
                     | lambda_expr
             """
-            if len(kid) > 1:
-                if (
-                    isinstance(kid[0], ast.Expr)
-                    and isinstance(kid[2], ast.Expr)
-                    and isinstance(kid[4], ast.Expr)
-                ):
-                    return self.nu(
-                        ast.IfElseExpr(
-                            value=kid[0],
-                            condition=kid[2],
-                            else_value=kid[4],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            value = self.consume(ast.Expr)
+            if self.match_token(Tok.KW_IF):
+                condition = self.consume(ast.Expr)
+                self.consume_token(Tok.KW_ELSE)
+                else_value = self.consume(ast.Expr)
+                return ast.IfElseExpr(
+                    value=value,
+                    condition=condition,
+                    else_value=else_value,
+                    kid=self.cur_nodes,
+                )
+            return value
 
-        def walrus_assign(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def walrus_assign(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             walrus_assign: (walrus_assign WALRUS_EQ)? pipe
             """
-            return self.binary_expr_unwind(kid)
-
-        def binary_expr_unwind(self, kid: list[ast.AstNode]) -> ast.Expr:
-            """Binary expression helper."""
-            if len(kid) > 1:
-                if (
-                    isinstance(kid[0], ast.Expr)
-                    and isinstance(
-                        kid[1],
-                        (ast.Token, ast.DisconnectOp, ast.ConnectOp),
-                    )
-                    and isinstance(kid[2], ast.Expr)
-                ):
-                    return self.nu(
-                        ast.BinaryExpr(
-                            left=kid[0],
-                            op=kid[1],
-                            right=kid[2],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-
-                raise self.ice()
+            return self._binary_expr_unwind(self.cur_nodes)
 
         def lambda_expr(self, kid: list[ast.AstNode]) -> ast.LambdaExpr:
             """Grammar rule.
@@ -2016,156 +1776,134 @@ class JacParser(Pass):
             new_kid = [i for i in kid if i != params and i != return_type]
             new_kid.insert(1, signature) if signature else None
             if isinstance(chomp[0], ast.Expr):
-                return self.nu(
-                    ast.LambdaExpr(
-                        signature=signature,
-                        body=chomp[0],
-                        kid=new_kid,
-                    )
+                return ast.LambdaExpr(
+                    signature=signature,
+                    body=chomp[0],
+                    kid=new_kid,
                 )
             else:
                 raise self.ice()
 
-        def pipe(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def pipe(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             pipe: pipe_back PIPE_FWD pipe
                 | pipe_back
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def pipe_back(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             pipe_back: bitwise_or PIPE_BKWD pipe_back
                      | bitwise_or
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def bitwise_or(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def bitwise_or(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             bitwise_or: bitwise_xor BW_OR bitwise_or
                       | bitwise_xor
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def bitwise_xor(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def bitwise_xor(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             bitwise_xor: bitwise_and BW_XOR bitwise_xor
                        | bitwise_and
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def bitwise_and(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def bitwise_and(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             bitwise_and: shift BW_AND bitwise_and
                        | shift
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def shift(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def shift(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             shift: (shift (RSHIFT | LSHIFT))? logical_or
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def logical_or(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def logical_or(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             logical_or: logical_and (KW_OR logical_and)*
             """
-            if len(kid) > 1:
-                values = [i for i in kid if isinstance(i, ast.Expr)]
-                ops = kid[1] if isinstance(kid[1], ast.Token) else None
-                if not ops:
-                    raise self.ice()
-                return self.nu(
-                    ast.BoolExpr(
-                        op=ops,
-                        values=values,
-                        kid=kid,
-                    )
-                )
-            elif isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-
-                raise self.ice()
+            value = self.consume(ast.Expr)
+            if not (ops := self.match_token(Tok.KW_OR)):
+                return value
+            values: list = [value]
+            while value := self.consume(ast.Expr):
+                values.append(value)
+                if not self.match_token(Tok.KW_OR):
+                    break
+            return ast.BoolExpr(
+                op=ops,
+                values=values,
+                kid=self.cur_nodes,
+            )
 
-        def logical_and(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def logical_and(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             logical_and: logical_not (KW_AND logical_not)*
             """
-            if len(kid) > 1:
-                values = [i for i in kid if isinstance(i, ast.Expr)]
-                ops = kid[1] if isinstance(kid[1], ast.Token) else None
-                if not ops:
-                    raise self.ice()
-                return self.nu(
-                    ast.BoolExpr(
-                        op=ops,
-                        values=values,
-                        kid=kid,
-                    )
-                )
-            elif isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-
-                raise self.ice()
+            value = self.consume(ast.Expr)
+            if not (ops := self.match_token(Tok.KW_AND)):
+                return value
+            values: list = [value]
+            while value := self.consume(ast.Expr):
+                values.append(value)
+                if not self.match_token(Tok.KW_AND):
+                    break
+            return ast.BoolExpr(
+                op=ops,
+                values=values,
+                kid=self.cur_nodes,
+            )
 
-        def logical_not(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def logical_not(self, _: None) -> ast.Expr:
             """Grammar rule.
 
-            logical_or: (logical_or KW_OR)? logical_and
+            logical_not: NOT logical_not | compare
             """
-            if len(kid) == 2:
-                if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
-                    return self.nu(
-                        ast.UnaryExpr(
-                            op=kid[0],
-                            operand=kid[1],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            if isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            if op := self.match_token(Tok.NOT):
+                operand = self.consume(ast.Expr)
+                return ast.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
+            return self.consume(ast.Expr)
 
-        def compare(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def compare(self, _: list[ast.AstNode]) -> ast.Expr:
             """Grammar rule.
 
             compare: (arithmetic cmp_op)* arithmetic
             """
-            if len(kid) > 1:
-                ops = [i for i in kid[1::2] if isinstance(i, ast.Token)]
-                left = kid[0]
-                rights = [i for i in kid[1:][1::2] if isinstance(i, ast.Expr)]
-                if isinstance(left, ast.Expr) and len(ops) == len(rights):
-                    return self.nu(
-                        ast.CompareExpr(
-                            left=left,
-                            ops=ops,
-                            rights=rights,
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            elif isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            ops: list = []
+            rights: list = []
+            left = self.consume(ast.Expr)
+            while op := self.match(ast.Token):
+                ops.append(op)
+                rights.append(self.consume(ast.Expr))
+            if not ops:
+                return left
+            return ast.CompareExpr(
+                left=left,
+                ops=ops,
+                rights=rights,
+                kid=self.cur_nodes,
+            )
 
-        def cmp_op(self, kid: list[ast.AstNode]) -> ast.Token:
+        def cmp_op(self, _: None) -> ast.Token:
             """Grammar rule.
 
             cmp_op: KW_ISN
@@ -2179,116 +1917,105 @@ class JacParser(Pass):
                   | LT
                   | EE
             """
-            if isinstance(kid[0], ast.Token):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.Token)
 
-        def arithmetic(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def arithmetic(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             arithmetic: (arithmetic (MINUS | PLUS))? term
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def term(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def term(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             term: (term (MOD | DIV | FLOOR_DIV | STAR_MUL | DECOR_OP))? power
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def factor(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def factor(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             factor: (BW_NOT | MINUS | PLUS) factor | connect
             """
-            if len(kid) == 2:
-                if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
-                    return self.nu(
-                        ast.UnaryExpr(
-                            op=kid[0],
-                            operand=kid[1],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            return self.binary_expr_unwind(kid)
+            if (
+                op := self.match_token(Tok.BW_NOT)
+                or self.match_token(Tok.MINUS)
+                or self.match_token(Tok.PLUS)
+            ):
+                operand = self.consume(ast.Expr)
+                return ast.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def power(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def power(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             power: (power STAR_POW)? factor
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def connect(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def connect(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             connect: (connect (connect_op | disconnect_op))? atomic_pipe
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def atomic_pipe(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def atomic_pipe(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             atomic_pipe: (atomic_pipe A_PIPE_FWD)? atomic_pipe_back
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def atomic_pipe_back(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def atomic_pipe_back(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             atomic_pipe_back: (atomic_pipe_back A_PIPE_BKWD)? ds_spawn
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def ds_spawn(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def ds_spawn(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             ds_spawn: (ds_spawn KW_SPAWN)? unpack
             """
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def unpack(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def unpack(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             unpack: STAR_MUL? ref
             """
-            if len(kid) == 2:
-                if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
-                    return self.nu(
-                        ast.UnaryExpr(
-                            op=kid[0],
-                            operand=kid[1],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            return self.binary_expr_unwind(kid)
+            if op := self.match_token(Tok.STAR_MUL):
+                operand = self.consume(ast.Expr)
+                return ast.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def ref(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def ref(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             ref: walrus_assign
                | BW_AND walrus_assign
             """
-            if len(kid) == 2:
-                if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
-                    return self.nu(
-                        ast.UnaryExpr(
-                            op=kid[0],
-                            operand=kid[1],
-                            kid=kid,
-                        )
-                    )
-                else:
-                    raise self.ice()
-            return self.binary_expr_unwind(kid)
+            if op := self.match_token(Tok.BW_AND):
+                operand = self.consume(ast.Expr)
+                return ast.UnaryExpr(
+                    op=op,
+                    operand=operand,
+                    kid=self.cur_nodes,
+                )
+            return self._binary_expr_unwind(self.cur_nodes)
 
-        def pipe_call(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def pipe_call(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             pipe_call: atomic_chain
@@ -2297,29 +2024,21 @@ class JacParser(Pass):
                 | KW_SPAWN atomic_chain
                 | KW_AWAIT atomic_chain
             """
-            if len(kid) == 2:
-                if (
-                    isinstance(kid[0], ast.Token)
-                    and kid[0].name == Tok.KW_AWAIT
-                    and isinstance(kid[1], ast.Expr)
-                ):
-                    return self.nu(
-                        ast.AwaitExpr(
-                            target=kid[1],
-                            kid=kid,
-                        )
+            if len(self.cur_nodes) == 2:
+                if self.match_token(Tok.KW_AWAIT):
+                    target = self.consume(ast.Expr)
+                    return ast.AwaitExpr(
+                        target=target,
+                        kid=self.cur_nodes,
                     )
-                elif isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.Expr):
-                    return self.nu(
-                        ast.UnaryExpr(
-                            op=kid[0],
-                            operand=kid[1],
-                            kid=kid,
-                        )
+                elif op := self.match(ast.Token):
+                    operand = self.consume(ast.Expr)
+                    return ast.UnaryExpr(
+                        op=op,
+                        operand=operand,
+                        kid=self.cur_nodes,
                     )
-                else:
-                    raise self.ice()
-            return self.binary_expr_unwind(kid)
+            return self._binary_expr_unwind(self.cur_nodes)
 
         def aug_op(self, kid: list[ast.AstNode]) -> ast.Token:
             """Grammar rule.
@@ -2339,7 +2058,7 @@ class JacParser(Pass):
                      | WALRUS_EQ
             """
             if isinstance(kid[0], ast.Token):
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
@@ -2351,7 +2070,7 @@ class JacParser(Pass):
                         | (atomic_call | atom | edge_ref_chain)
             """
             if len(kid) < 2 and isinstance(kid[0], ast.Expr):
-                return self.nu(kid[0])
+                return kid[0]
             chomp = [*kid]
             target = chomp[0]
             chomp = chomp[1:]
@@ -2364,14 +2083,12 @@ class JacParser(Pass):
                 and isinstance(chomp[0], ast.AtomExpr)
                 and isinstance(target, ast.Expr)
             ):
-                return self.nu(
-                    ast.AtomTrailer(
-                        target=target,
-                        right=chomp[0],
-                        is_null_ok=is_null_ok,
-                        is_attr=False,
-                        kid=kid,
-                    )
+                return ast.AtomTrailer(
+                    target=target,
+                    right=chomp[0],
+                    is_null_ok=is_null_ok,
+                    is_attr=False,
+                    kid=kid,
                 )
             elif (
                 len(chomp) > 1
@@ -2379,14 +2096,12 @@ class JacParser(Pass):
                 and isinstance(chomp[1], (ast.AtomExpr, ast.AtomTrailer))
                 and isinstance(target, ast.Expr)
             ):
-                return self.nu(
-                    ast.AtomTrailer(
-                        target=(target if chomp[0].name != Tok.DOT_BKWD else chomp[1]),
-                        right=(chomp[1] if chomp[0].name != Tok.DOT_BKWD else target),
-                        is_null_ok=is_null_ok,
-                        is_attr=True,
-                        kid=kid,
-                    )
+                return ast.AtomTrailer(
+                    target=(target if chomp[0].name != Tok.DOT_BKWD else chomp[1]),
+                    right=(chomp[1] if chomp[0].name != Tok.DOT_BKWD else target),
+                    is_null_ok=is_null_ok,
+                    is_attr=True,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2402,25 +2117,23 @@ class JacParser(Pass):
                 and kid[-2]
                 and isinstance(kid[-2], ast.FuncCall)
             ):
-                return self.nu(
-                    ast.FuncCall(
-                        target=kid[0],
-                        params=kid[2] if isinstance(kid[2], ast.SubNodeList) else None,
-                        genai_call=kid[-2],
-                        kid=kid,
-                    )
+                return ast.FuncCall(
+                    target=kid[0],
+                    params=kid[2] if isinstance(kid[2], ast.SubNodeList) else None,
+                    genai_call=kid[-2],
+                    kid=kid,
                 )
             if (
                 len(kid) == 4
                 and isinstance(kid[0], ast.Expr)
                 and isinstance(kid[2], ast.SubNodeList)
             ):
-                return self.nu(
-                    ast.FuncCall(target=kid[0], params=kid[2], genai_call=None, kid=kid)
+                return ast.FuncCall(
+                    target=kid[0], params=kid[2], genai_call=None, kid=kid
                 )
             elif len(kid) == 3 and isinstance(kid[0], ast.Expr):
-                return self.nu(
-                    ast.FuncCall(target=kid[0], params=None, genai_call=None, kid=kid)
+                return ast.FuncCall(
+                    target=kid[0], params=None, genai_call=None, kid=kid
                 )
             else:
                 raise self.ice()
@@ -2447,14 +2160,10 @@ class JacParser(Pass):
                         )
                         expr = ast.TupleVal(values=sublist, kid=[sublist])
                         kid = [expr]
-                    return self.nu(
-                        ast.IndexSlice(
-                            slices=[
-                                ast.IndexSlice.Slice(start=expr, stop=None, step=None)
-                            ],
-                            is_range=False,
-                            kid=kid,
-                        )
+                    return ast.IndexSlice(
+                        slices=[ast.IndexSlice.Slice(start=expr, stop=None, step=None)],
+                        is_range=False,
+                        kid=kid,
                     )
                 else:
                     raise self.ice()
@@ -2489,15 +2198,13 @@ class JacParser(Pass):
                         ast.IndexSlice.Slice(start=expr1, stop=expr2, step=expr3)
                     )
 
-                return self.nu(
-                    ast.IndexSlice(
-                        slices=slices,
-                        is_range=True,
-                        kid=kid,
-                    )
+                return ast.IndexSlice(
+                    slices=slices,
+                    is_range=True,
+                    kid=kid,
                 )
 
-        def atom(self, kid: list[ast.AstNode]) -> ast.Expr:
+        def atom(self, _: None) -> ast.Expr:
             """Grammar rule.
 
             atom: named_ref
@@ -2506,41 +2213,27 @@ class JacParser(Pass):
                  | atom_literal
                  | type_ref
             """
-            if len(kid) == 1:
-                if isinstance(kid[0], ast.AtomExpr):
-                    return self.nu(kid[0])
-                else:
-                    raise self.ice()
-            elif len(kid) == 3:
-                if (
-                    isinstance(kid[0], ast.Token)
-                    and isinstance(kid[1], (ast.Expr, ast.YieldExpr))
-                    and isinstance(kid[2], ast.Token)
-                ):
-                    ret = ast.AtomUnit(value=kid[1], kid=kid)
-                    return self.nu(ret)
-                else:
-                    raise self.ice()
-            else:
-                raise self.ice()
+            if self.match_token(Tok.LPAREN):
+                value = self.match(ast.Expr) or self.consume(ast.YieldExpr)
+                self.consume_token(Tok.RPAREN)
+                return ast.AtomUnit(value=value, kid=self.cur_nodes)
+            return self.consume(ast.AtomExpr)
 
-        def yield_expr(self, kid: list[ast.AstNode]) -> ast.YieldExpr:
+        def yield_expr(self, _: None) -> ast.YieldExpr:
             """Grammar rule.
 
             yield_expr: KW_YIELD KW_FROM? expression
             """
-            if isinstance(kid[-1], ast.Expr):
-                return self.nu(
-                    ast.YieldExpr(
-                        expr=kid[-1],
-                        with_from=len(kid) > 2,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_YIELD)
+            is_with_from = bool(self.match_token(Tok.KW_FROM))
+            expr = self.consume(ast.Expr)
+            return ast.YieldExpr(
+                expr=expr,
+                with_from=is_with_from,
+                kid=self.cur_nodes,
+            )
 
-        def atom_literal(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
+        def atom_literal(self, _: None) -> ast.AtomExpr:
             """Grammar rule.
 
             atom_literal: builtin_type
@@ -2553,10 +2246,7 @@ class JacParser(Pass):
                         | HEX
                         | INT
             """
-            if isinstance(kid[0], ast.AtomExpr):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.AtomExpr)
 
         def atom_collection(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
             """Grammar rule.
@@ -2570,23 +2260,18 @@ class JacParser(Pass):
                            | tuple_val
                            | list_val
             """
-            if isinstance(kid[0], ast.AtomExpr):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.AtomExpr)
 
         def multistring(self, kid: list[ast.AstNode]) -> ast.AtomExpr:
             """Grammar rule.
 
-            multistring: (fstring | STRING | DOC_STRING)+
+            multistring: (fstring | STRING)+
             """
             valid_strs = [i for i in kid if isinstance(i, (ast.String, ast.FString))]
             if len(valid_strs) == len(kid):
-                return self.nu(
-                    ast.MultiString(
-                        strings=valid_strs,
-                        kid=kid,
-                    )
+                return ast.MultiString(
+                    strings=valid_strs,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2598,18 +2283,14 @@ class JacParser(Pass):
                 | FSTR_SQ_START fstr_sq_parts FSTR_SQ_END
             """
             if len(kid) == 2:
-                return self.nu(
-                    ast.FString(
-                        parts=None,
-                        kid=kid,
-                    )
+                return ast.FString(
+                    parts=None,
+                    kid=kid,
                 )
             elif isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.FString(
-                        parts=kid[1],
-                        kid=kid,
-                    )
+                return ast.FString(
+                    parts=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2630,12 +2311,10 @@ class JacParser(Pass):
                 for i in kid
                 if isinstance(i, ast.Expr)
             ]
-            return self.nu(
-                ast.SubNodeList[ast.String | ast.ExprStmt](
-                    items=valid_parts,
-                    delim=None,
-                    kid=valid_parts,
-                )
+            return ast.SubNodeList[ast.String | ast.ExprStmt](
+                items=valid_parts,
+                delim=None,
+                kid=valid_parts,
             )
 
         def fstr_sq_parts(
@@ -2654,12 +2333,10 @@ class JacParser(Pass):
                 for i in kid
                 if isinstance(i, ast.Expr)
             ]
-            return self.nu(
-                ast.SubNodeList[ast.String | ast.ExprStmt](
-                    items=valid_parts,
-                    delim=None,
-                    kid=valid_parts,
-                )
+            return ast.SubNodeList[ast.String | ast.ExprStmt](
+                items=valid_parts,
+                delim=None,
+                kid=valid_parts,
             )
 
         def list_val(self, kid: list[ast.AstNode]) -> ast.ListVal:
@@ -2668,18 +2345,14 @@ class JacParser(Pass):
             list_val: LSQUARE (expr_list COMMA?)? RSQUARE
             """
             if len(kid) == 2:
-                return self.nu(
-                    ast.ListVal(
-                        values=None,
-                        kid=kid,
-                    )
+                return ast.ListVal(
+                    values=None,
+                    kid=kid,
                 )
-            elif isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.ListVal(
-                        values=kid[1],
-                        kid=kid,
-                    )
+            elif isinstance(kid[1], ast.SubNodeList):
+                return ast.ListVal(
+                    values=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2690,18 +2363,14 @@ class JacParser(Pass):
             tuple_val: LPAREN tuple_list? RPAREN
             """
             if len(kid) == 2:
-                return self.nu(
-                    ast.TupleVal(
-                        values=None,
-                        kid=kid,
-                    )
+                return ast.TupleVal(
+                    values=None,
+                    kid=kid,
                 )
             elif isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.TupleVal(
-                        values=kid[1],
-                        kid=kid,
-                    )
+                return ast.TupleVal(
+                    values=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2712,18 +2381,14 @@ class JacParser(Pass):
             set_val: LBRACE expr_list COMMA? RBRACE
             """
             if len(kid) == 2:
-                return self.nu(
-                    ast.SetVal(
-                        values=None,
-                        kid=kid,
-                    )
+                return ast.SetVal(
+                    values=None,
+                    kid=kid,
                 )
             elif isinstance(kid[1], ast.SubNodeList):
-                return self.nu(
-                    ast.SetVal(
-                        values=kid[1],
-                        kid=kid,
-                    )
+                return ast.SetVal(
+                    values=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2745,12 +2410,10 @@ class JacParser(Pass):
                 expr = kid[0]
                 new_kid = [expr]
             valid_kid = [i for i in new_kid if isinstance(i, ast.Expr)]
-            return self.nu(
-                ast.SubNodeList[ast.Expr](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=new_kid,
-                )
+            return ast.SubNodeList[ast.Expr](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=new_kid,
             )
 
         def kw_expr_list(self, kid: list[ast.AstNode]) -> ast.SubNodeList[ast.KWPair]:
@@ -2770,12 +2433,10 @@ class JacParser(Pass):
                 expr = kid[0]
                 new_kid = [expr]
             valid_kid = [i for i in new_kid if isinstance(i, ast.KWPair)]
-            return self.nu(
-                ast.SubNodeList[ast.KWPair](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=new_kid,
-                )
+            return ast.SubNodeList[ast.KWPair](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=new_kid,
             )
 
         def kw_expr(self, kid: list[ast.AstNode]) -> ast.KWPair:
@@ -2788,20 +2449,16 @@ class JacParser(Pass):
                 and isinstance(kid[0], ast.NameAtom)
                 and isinstance(kid[2], ast.Expr)
             ):
-                return self.nu(
-                    ast.KWPair(
-                        key=kid[0],
-                        value=kid[2],
-                        kid=kid,
-                    )
+                return ast.KWPair(
+                    key=kid[0],
+                    value=kid[2],
+                    kid=kid,
                 )
             elif len(kid) == 2 and isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.KWPair(
-                        key=None,
-                        value=kid[1],
-                        kid=kid,
-                    )
+                return ast.KWPair(
+                    key=None,
+                    value=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2812,12 +2469,10 @@ class JacParser(Pass):
             name_list: (named_ref COMMA)* named_ref
             """
             valid_kid = [i for i in kid if isinstance(i, ast.Name)]
-            return self.nu(
-                ast.SubNodeList[ast.Name](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=kid,
-                )
+            return ast.SubNodeList[ast.Name](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=kid,
             )
 
         def tuple_list(
@@ -2840,7 +2495,7 @@ class JacParser(Pass):
                     # Add the comma to the subnode list if it exists, otherwise the last comma will not be a part of
                     # the ast, we need it for formatting.
                     chomp[0].kid.append(chomp[1])
-                return self.nu(chomp[0])
+                return chomp[0]
             else:
                 # The chomp will be like this:
                 #     expression, COMMA, [subnode_list, [COMMA, [kw_expr_list, [COMMA]]]]
@@ -2859,12 +2514,10 @@ class JacParser(Pass):
                     expr_list = [*expr_list, *chomp[0].kid]
             expr_list = [first_expr, *expr_list]
             valid_kid = [i for i in expr_list if isinstance(i, (ast.Expr, ast.KWPair))]
-            return self.nu(
-                ast.SubNodeList[ast.Expr | ast.KWPair](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=kid,
-                )
+            return ast.SubNodeList[ast.Expr | ast.KWPair](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=kid,
             )
 
         def dict_val(self, kid: list[ast.AstNode]) -> ast.DictVal:
@@ -2877,7 +2530,7 @@ class JacParser(Pass):
                 kid=kid,
             )
             ret.kv_pairs = [i for i in kid if isinstance(i, ast.KVPair)]
-            return self.nu(ret)
+            return ret
 
         def kv_pair(self, kid: list[ast.AstNode]) -> ast.KVPair:
             """Grammar rule.
@@ -2889,20 +2542,16 @@ class JacParser(Pass):
                 and isinstance(kid[0], ast.Expr)
                 and isinstance(kid[2], ast.Expr)
             ):
-                return self.nu(
-                    ast.KVPair(
-                        key=kid[0],
-                        value=kid[2],
-                        kid=kid,
-                    )
+                return ast.KVPair(
+                    key=kid[0],
+                    value=kid[2],
+                    kid=kid,
                 )
             elif len(kid) == 2 and isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.KVPair(
-                        key=None,
-                        value=kid[1],
-                        kid=kid,
-                    )
+                return ast.KVPair(
+                    key=None,
+                    value=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2914,12 +2563,10 @@ class JacParser(Pass):
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.ListCompr(
-                        out_expr=kid[1],
-                        compr=comprs,
-                        kid=kid,
-                    )
+                return ast.ListCompr(
+                    out_expr=kid[1],
+                    compr=comprs,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2931,12 +2578,10 @@ class JacParser(Pass):
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.GenCompr(
-                        out_expr=kid[1],
-                        compr=comprs,
-                        kid=kid,
-                    )
+                return ast.GenCompr(
+                    out_expr=kid[1],
+                    compr=comprs,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2948,12 +2593,10 @@ class JacParser(Pass):
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.Expr) and isinstance(kid[2], ast.InnerCompr):
-                return self.nu(
-                    ast.SetCompr(
-                        out_expr=kid[1],
-                        compr=comprs,
-                        kid=kid,
-                    )
+                return ast.SetCompr(
+                    out_expr=kid[1],
+                    compr=comprs,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2965,12 +2608,10 @@ class JacParser(Pass):
             """
             comprs = [i for i in kid if isinstance(i, ast.InnerCompr)]
             if isinstance(kid[1], ast.KVPair) and isinstance(kid[2], ast.InnerCompr):
-                return self.nu(
-                    ast.DictCompr(
-                        kv_pair=kid[1],
-                        compr=comprs,
-                        kid=kid,
-                    )
+                return ast.DictCompr(
+                    kv_pair=kid[1],
+                    compr=comprs,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -2987,18 +2628,16 @@ class JacParser(Pass):
             chomp = chomp[1:] if is_async else chomp
             chomp = chomp[1:]
             if isinstance(chomp[0], ast.Expr) and isinstance(chomp[2], ast.Expr):
-                return self.nu(
-                    ast.InnerCompr(
-                        is_async=is_async,
-                        target=chomp[0],
-                        collection=chomp[2],
-                        conditional=(
-                            [i for i in chomp[4:] if isinstance(i, ast.Expr)]
-                            if len(chomp) > 4 and isinstance(chomp[4], ast.Expr)
-                            else None
-                        ),
-                        kid=chomp,
-                    )
+                return ast.InnerCompr(
+                    is_async=is_async,
+                    target=chomp[0],
+                    collection=chomp[2],
+                    conditional=(
+                        [i for i in chomp[4:] if isinstance(i, ast.Expr)]
+                        if len(chomp) > 4 and isinstance(chomp[4], ast.Expr)
+                        else None
+                    ),
+                    kid=chomp,
                 )
             else:
                 raise self.ice()
@@ -3023,7 +2662,7 @@ class JacParser(Pass):
                         ends_with_comma
                     ):  # Append the trailing comma to the subnode list.
                         kid[0].kid.append(kid[1])
-                    return self.nu(kid[0])
+                    return kid[0]
                 else:
                     raise self.ice()
             elif isinstance(kid[0], ast.SubNodeList) and isinstance(
@@ -3035,12 +2674,10 @@ class JacParser(Pass):
                     if isinstance(i, (ast.Expr, ast.KWPair))
                 ]
                 if len(valid_kid) == len(kid[0].items) + len(kid[2].items):
-                    return self.nu(
-                        ast.SubNodeList[ast.Expr | ast.KWPair](
-                            items=valid_kid,
-                            delim=Tok.COMMA,
-                            kid=kid,
-                        )
+                    return ast.SubNodeList[ast.Expr | ast.KWPair](
+                        items=valid_kid,
+                        delim=Tok.COMMA,
+                        kid=kid,
                     )
                 else:
                     raise self.ice()
@@ -3065,12 +2702,10 @@ class JacParser(Pass):
                 assign = kid[0]
                 new_kid = [assign]
             valid_kid = [i for i in new_kid if isinstance(i, ast.Assignment)]
-            return self.nu(
-                ast.SubNodeList[ast.Assignment](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=new_kid,
-                )
+            return ast.SubNodeList[ast.Assignment](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=new_kid,
             )
 
         def arch_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
@@ -3082,159 +2717,125 @@ class JacParser(Pass):
                     | node_ref
                     | type_ref
             """
-            if isinstance(kid[0], ast.ArchRef):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.ArchRef)
 
         def node_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             node_ref: NODE_OP NAME
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def edge_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             edge_ref: EDGE_OP NAME
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def walker_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             walker_ref: WALKER_OP NAME
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def class_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             class_ref: CLASS_OP name_ref
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def object_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             object_ref: OBJECT_OP name_ref
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def type_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             type_ref: TYPE_OP (named_ref | builtin_type)
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def enum_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
             """Grammar rule.
 
             enum_ref: ENUM_OP NAME
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume(ast.Token)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
-        def ability_ref(self, kid: list[ast.AstNode]) -> ast.ArchRef:
+        def ability_ref(self, _: None) -> ast.ArchRef:
             """Grammar rule.
 
             ability_ref: ABILITY_OP (special_ref | name_ref)
             """
-            if isinstance(kid[0], ast.Token) and isinstance(kid[1], ast.NameAtom):
-                return self.nu(
-                    ast.ArchRef(
-                        arch_type=kid[0],
-                        arch_name=kid[1],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            arch_type = self.consume_token(Tok.ABILITY_OP)
+            arch_name = self.consume(ast.NameAtom)
+            return ast.ArchRef(
+                arch_type=arch_type,
+                arch_name=arch_name,
+                kid=self.cur_nodes,
+            )
 
         def arch_or_ability_chain(self, kid: list[ast.AstNode]) -> ast.ArchRefChain:
             """Grammar rule.
 
             arch_or_ability_chain: arch_or_ability_chain? (ability_ref | arch_ref)
             """
-            consume = None
-            name = None
-            if isinstance(kid[0], ast.SubNodeList):
-                consume = kid[0]
-                name = kid[1]
-            else:
-                name = kid[0]
+            consume = self.match(ast.ArchRefChain)
+            name = self.consume(ast.ArchRef)
             new_kid = [*consume.kid, name] if consume else [name]
             valid_kid = [i for i in new_kid if isinstance(i, ast.ArchRef)]
             if len(valid_kid) == len(new_kid):
-                return self.nu(
-                    ast.ArchRefChain(
-                        archs=valid_kid,
-                        kid=new_kid,
-                    )
+                return ast.ArchRefChain(
+                    archs=valid_kid,
+                    kid=new_kid,
                 )
             else:
                 raise self.ice()
@@ -3248,20 +2849,16 @@ class JacParser(Pass):
                 if isinstance(kid[1], ast.ArchRef) and isinstance(
                     kid[0], ast.ArchRefChain
                 ):
-                    return self.nu(
-                        ast.ArchRefChain(
-                            archs=[*(kid[0].archs), kid[1]],
-                            kid=[*(kid[0].kid), kid[1]],
-                        )
+                    return ast.ArchRefChain(
+                        archs=[*(kid[0].archs), kid[1]],
+                        kid=[*(kid[0].kid), kid[1]],
                     )
                 else:
                     raise self.ice()
             elif isinstance(kid[0], ast.ArchRef):
-                return self.nu(
-                    ast.ArchRefChain(
-                        archs=[kid[0]],
-                        kid=kid,
-                    )
+                return ast.ArchRefChain(
+                    archs=[kid[0]],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3275,20 +2872,16 @@ class JacParser(Pass):
                 if isinstance(kid[1], ast.ArchRef) and isinstance(
                     kid[0], ast.ArchRefChain
                 ):
-                    return self.nu(
-                        ast.ArchRefChain(
-                            archs=[*(kid[0].archs), kid[1]],
-                            kid=[*(kid[0].kid), kid[1]],
-                        )
+                    return ast.ArchRefChain(
+                        archs=[*(kid[0].archs), kid[1]],
+                        kid=[*(kid[0].kid), kid[1]],
                     )
                 else:
                     raise self.ice()
             elif isinstance(kid[0], ast.ArchRef):
-                return self.nu(
-                    ast.ArchRefChain(
-                        archs=[kid[0]],
-                        kid=kid,
-                    )
+                return ast.ArchRefChain(
+                    archs=[kid[0]],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3302,20 +2895,16 @@ class JacParser(Pass):
                 if isinstance(kid[1], ast.ArchRef) and isinstance(
                     kid[0], ast.ArchRefChain
                 ):
-                    return self.nu(
-                        ast.ArchRefChain(
-                            archs=[*(kid[0].archs), kid[1]],
-                            kid=[*(kid[0].kid), kid[1]],
-                        )
+                    return ast.ArchRefChain(
+                        archs=[*(kid[0].archs), kid[1]],
+                        kid=[*(kid[0].kid), kid[1]],
                     )
                 else:
                     raise self.ice()
             elif isinstance(kid[0], ast.ArchRef):
-                return self.nu(
-                    ast.ArchRefChain(
-                        archs=[kid[0]],
-                        kid=kid,
-                    )
+                return ast.ArchRefChain(
+                    archs=[kid[0]],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3326,13 +2915,10 @@ class JacParser(Pass):
             (EDGE_OP|NODE_OP)? LSQUARE expression? (edge_op_ref (filter_compr | expression)?)+ RSQUARE
             """
             valid_chain = [i for i in kid if isinstance(i, (ast.Expr, ast.FilterCompr))]
-            return self.nu(
-                ast.EdgeRefTrailer(
-                    chain=valid_chain,
-                    edges_only=isinstance(kid[0], ast.Token)
-                    and kid[0].name == Tok.EDGE_OP,
-                    kid=kid,
-                )
+            return ast.EdgeRefTrailer(
+                chain=valid_chain,
+                edges_only=isinstance(kid[0], ast.Token) and kid[0].name == Tok.EDGE_OP,
+                kid=kid,
             )
 
         def edge_op_ref(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
@@ -3340,10 +2926,7 @@ class JacParser(Pass):
 
             edge_op_ref: (edge_any | edge_from | edge_to)
             """
-            if isinstance(kid[0], ast.EdgeOpRef):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.EdgeOpRef)
 
         def edge_to(self, kid: list[ast.AstNode]) -> ast.EdgeOpRef:
             """Grammar rule.
@@ -3353,9 +2936,7 @@ class JacParser(Pass):
             """
             fcond = kid[1] if len(kid) > 1 else None
             if isinstance(fcond, ast.FilterCompr) or fcond is None:
-                return self.nu(
-                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.OUT, kid=kid)
-                )
+                return ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.OUT, kid=kid)
             else:
                 raise self.ice()
 
@@ -3367,9 +2948,7 @@ class JacParser(Pass):
             """
             fcond = kid[1] if len(kid) > 1 else None
             if isinstance(fcond, ast.FilterCompr) or fcond is None:
-                return self.nu(
-                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.IN, kid=kid)
-                )
+                return ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.IN, kid=kid)
             else:
                 raise self.ice()
 
@@ -3381,9 +2960,7 @@ class JacParser(Pass):
             """
             fcond = kid[1] if len(kid) > 1 else None
             if isinstance(fcond, ast.FilterCompr) or fcond is None:
-                return self.nu(
-                    ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.ANY, kid=kid)
-                )
+                return ast.EdgeOpRef(filter_cond=fcond, edge_dir=EdgeDir.ANY, kid=kid)
             else:
                 raise self.ice()
 
@@ -3393,7 +2970,7 @@ class JacParser(Pass):
             connect_op: connect_from | connect_to | connect_any
             """
             if len(kid) < 2 and isinstance(kid[0], ast.ConnectOp):
-                return self.nu(kid[0])
+                return kid[0]
             else:
                 raise self.ice()
 
@@ -3403,11 +2980,9 @@ class JacParser(Pass):
             disconnect_op: NOT edge_op_ref
             """
             if isinstance(kid[1], ast.EdgeOpRef):
-                return self.nu(
-                    ast.DisconnectOp(
-                        edge_spec=kid[1],
-                        kid=kid,
-                    )
+                return ast.DisconnectOp(
+                    edge_spec=kid[1],
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3430,13 +3005,11 @@ class JacParser(Pass):
                 )
                 if conn_assign:
                     kid[3] = conn_assign
-                return self.nu(
-                    ast.ConnectOp(
-                        conn_type=conn_type,
-                        conn_assign=conn_assign,
-                        edge_dir=EdgeDir.OUT,
-                        kid=kid,
-                    )
+                return ast.ConnectOp(
+                    conn_type=conn_type,
+                    conn_assign=conn_assign,
+                    edge_dir=EdgeDir.OUT,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3459,13 +3032,11 @@ class JacParser(Pass):
                 )
                 if conn_assign:
                     kid[3] = conn_assign
-                return self.nu(
-                    ast.ConnectOp(
-                        conn_type=conn_type,
-                        conn_assign=conn_assign,
-                        edge_dir=EdgeDir.IN,
-                        kid=kid,
-                    )
+                return ast.ConnectOp(
+                    conn_type=conn_type,
+                    conn_assign=conn_assign,
+                    edge_dir=EdgeDir.IN,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3487,13 +3058,11 @@ class JacParser(Pass):
                 )
                 if conn_assign:
                     kid[3] = conn_assign
-                return self.nu(
-                    ast.ConnectOp(
-                        conn_type=conn_type,
-                        conn_assign=conn_assign,
-                        edge_dir=EdgeDir.ANY,
-                        kid=kid,
-                    )
+                return ast.ConnectOp(
+                    conn_type=conn_type,
+                    conn_assign=conn_assign,
+                    edge_dir=EdgeDir.ANY,
+                    kid=kid,
                 )
             else:
                 raise self.ice()
@@ -3505,11 +3074,11 @@ class JacParser(Pass):
                         | LPAREN TYPE_OP NULL_OK typed_filter_compare_list RPAREN
             """
             if isinstance(kid[2], ast.SubNodeList):
-                return self.nu(ast.FilterCompr(compares=kid[2], f_type=None, kid=kid))
+                return ast.FilterCompr(compares=kid[2], f_type=None, kid=kid)
             elif isinstance(kid[3], ast.FilterCompr):
                 kid[3].add_kids_left(kid[:3])
                 kid[3].add_kids_right(kid[4:])
-                return self.nu(kid[3])
+                return kid[3]
             else:
                 raise self.ice()
 
@@ -3532,12 +3101,10 @@ class JacParser(Pass):
                 expr = kid[0]
                 new_kid = [expr]
             valid_kid = [i for i in new_kid if isinstance(i, ast.CompareExpr)]
-            return self.nu(
-                ast.SubNodeList[ast.CompareExpr](
-                    items=valid_kid,
-                    delim=Tok.COMMA,
-                    kid=new_kid,
-                )
+            return ast.SubNodeList[ast.CompareExpr](
+                items=valid_kid,
+                delim=Tok.COMMA,
+                kid=new_kid,
             )
 
         def typed_filter_compare_list(self, kid: list[ast.AstNode]) -> ast.FilterCompr:
@@ -3558,7 +3125,7 @@ class JacParser(Pass):
             if isinstance(expr, ast.Expr) and (
                 (isinstance(compares, ast.SubNodeList)) or compares is None
             ):
-                return self.nu(ast.FilterCompr(compares=compares, f_type=expr, kid=kid))
+                return ast.FilterCompr(compares=compares, f_type=expr, kid=kid)
             else:
                 raise self.ice()
 
@@ -3569,110 +3136,95 @@ class JacParser(Pass):
             """
             ret = self.compare(kid)
             if isinstance(ret, ast.CompareExpr):
-                return self.nu(ret)
+                return ret
             else:
                 raise self.ice()
 
-        def assign_compr(self, kid: list[ast.AstNode]) -> ast.AssignCompr:
+        def assign_compr(self, _: None) -> ast.AssignCompr:
             """Grammar rule.
 
             filter_compr: LPAREN EQ kw_expr_list RPAREN
             """
-            if isinstance(kid[2], ast.SubNodeList):
-                return self.nu(
-                    ast.AssignCompr(
-                        assigns=kid[2],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.LPAREN)
+            self.consume_token(Tok.EQ)
+            assigns = self.consume(ast.SubNodeList)
+            self.consume_token(Tok.RPAREN)
+            return ast.AssignCompr(assigns=assigns, kid=self.cur_nodes)
 
-        def match_stmt(self, kid: list[ast.AstNode]) -> ast.MatchStmt:
+        def match_stmt(self, _: None) -> ast.MatchStmt:
             """Grammar rule.
 
             match_stmt: KW_MATCH expr_list LBRACE match_case_block+ RBRACE
             """
-            cases = [i for i in kid if isinstance(i, ast.MatchCase)]
-            if isinstance(kid[1], ast.Expr):
-                return self.nu(
-                    ast.MatchStmt(
-                        target=kid[1],
-                        cases=cases,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            self.consume_token(Tok.KW_MATCH)
+            target = self.consume(ast.Expr)
+            self.consume_token(Tok.LBRACE)
+            cases = [self.consume(ast.MatchCase)]
+            while case := self.match(ast.MatchCase):
+                cases.append(case)
+            self.consume_token(Tok.RBRACE)
+            return ast.MatchStmt(
+                target=target,
+                cases=cases,
+                kid=self.cur_nodes,
+            )
 
-        def match_case_block(self, kid: list[ast.AstNode]) -> ast.MatchCase:
+        def match_case_block(self, _: None) -> ast.MatchCase:
             """Grammar rule.
 
             match_case_block: KW_CASE pattern_seq (KW_IF expression)? COLON statement_list
             """
-            pattern = kid[1]
-            guard = kid[3] if isinstance(kid[3], ast.Expr) else None
-            stmts = [i for i in kid if isinstance(i, ast.CodeBlockStmt)]
-            if isinstance(pattern, ast.MatchPattern) and isinstance(
-                guard, (ast.Expr, type(None))
-            ):
-                return self.nu(
-                    ast.MatchCase(
-                        pattern=pattern,
-                        guard=guard,
-                        body=stmts,
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            guard: ast.Expr | None = None
+            self.consume_token(Tok.KW_CASE)
+            pattern = self.consume(ast.MatchPattern)
+            if self.match_token(Tok.KW_IF):
+                guard = self.consume(ast.Expr)
+            self.consume_token(Tok.COLON)
+            stmts = [self.consume(ast.CodeBlockStmt)]
+            while stmt := self.match(ast.CodeBlockStmt):
+                stmts.append(stmt)
+            return ast.MatchCase(
+                pattern=pattern,
+                guard=guard,
+                body=stmts,
+                kid=self.cur_nodes,
+            )
 
-        def pattern_seq(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def pattern_seq(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             pattern_seq: (or_pattern | as_pattern)
             """
-            if isinstance(kid[0], ast.MatchPattern):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.MatchPattern)
 
-        def or_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def or_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             or_pattern: (pattern BW_OR)* pattern
             """
-            if len(kid) == 1:
-                if isinstance(kid[0], ast.MatchPattern):
-                    return self.nu(kid[0])
-                else:
-                    raise self.ice()
-            else:
-                patterns = [i for i in kid if isinstance(i, ast.MatchPattern)]
-                return self.nu(
-                    ast.MatchOr(
-                        patterns=patterns,
-                        kid=kid,
-                    )
-                )
+            patterns: list = [self.consume(ast.MatchPattern)]
+            while self.match_token(Tok.BW_OR):
+                patterns.append(self.consume(ast.MatchPattern))
+            if len(patterns) == 1:
+                return patterns[0]
+            return ast.MatchOr(
+                patterns=patterns,
+                kid=self.cur_nodes,
+            )
 
-        def as_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def as_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             as_pattern: pattern KW_AS NAME
             """
-            if isinstance(kid[0], ast.MatchPattern) and isinstance(
-                kid[2], ast.NameAtom
-            ):
-                return self.nu(
-                    ast.MatchAs(
-                        pattern=kid[0],
-                        name=kid[2],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            pattern = self.consume(ast.MatchPattern)
+            self.consume_token(Tok.KW_AS)
+            name = self.consume(ast.NameAtom)
+            return ast.MatchAs(
+                pattern=pattern,
+                name=name,
+                kid=self.cur_nodes,
+            )
 
         def pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
             """Grammar rule.
@@ -3683,141 +3235,109 @@ class JacParser(Pass):
                 | mapping_pattern
                 | class_pattern
             """
-            if isinstance(kid[0], ast.MatchPattern):
-                return self.nu(kid[0])
-            else:
-                raise self.ice()
+            return self.consume(ast.MatchPattern)
 
-        def literal_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def literal_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             literal_pattern: (INT | FLOAT | multistring)
             """
-            if isinstance(kid[0], ast.Expr):
-                return self.nu(
-                    ast.MatchValue(
-                        value=kid[0],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            value = self.consume(ast.Expr)
+            return ast.MatchValue(
+                value=value,
+                kid=self.cur_nodes,
+            )
 
-        def singleton_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def singleton_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             singleton_pattern: (NULL | BOOL)
             """
-            if isinstance(kid[0], (ast.Bool, ast.Null)):
-                return self.nu(
-                    ast.MatchSingleton(
-                        value=kid[0],
-                        kid=kid,
-                    )
-                )
-            else:
-                raise self.ice()
+            value = self.match(ast.Null) or self.consume(ast.Bool)
+            return ast.MatchSingleton(
+                value=value,
+                kid=self.cur_nodes,
+            )
 
-        def capture_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def capture_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             capture_pattern: NAME
             """
-            if (
-                len(kid) == 1
-                and isinstance(kid[0], ast.Name)
-                and kid[0].sym_name == "_"
-            ):
-                return self.nu(
-                    ast.MatchWild(
-                        kid=kid,
-                    )
-                )
-            if isinstance(kid[0], ast.NameAtom):
-                return self.nu(
-                    ast.MatchAs(
-                        name=kid[0],
-                        pattern=None,
-                        kid=kid,
-                    )
+            name = self.consume(ast.Name)
+            if name.sym_name == "_":
+                return ast.MatchWild(
+                    kid=self.cur_nodes,
                 )
-            else:
-                raise self.ice()
+            return ast.MatchAs(
+                name=name,
+                pattern=None,
+                kid=self.cur_nodes,
+            )
 
-        def sequence_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def sequence_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             sequence_pattern: LSQUARE list_inner_pattern (COMMA list_inner_pattern)* RSQUARE
                             | LPAREN list_inner_pattern (COMMA list_inner_pattern)* RPAREN
             """
-            patterns = [i for i in kid if isinstance(i, ast.MatchPattern)]
-            return self.nu(
-                ast.MatchSequence(
-                    values=patterns,
-                    kid=kid,
-                )
+            self.consume_token(Tok.LSQUARE) or self.consume_token(Tok.LPAREN)
+            patterns = [self.consume(ast.MatchPattern)]
+            while self.match_token(Tok.COMMA):
+                patterns.append(self.consume(ast.MatchPattern))
+            self.consume_token(Tok.RSQUARE) or self.consume_token(Tok.RPAREN)
+            return ast.MatchSequence(
+                values=patterns,
+                kid=self.cur_nodes,
             )
 
-        def mapping_pattern(self, kid: list[ast.AstNode]) -> ast.MatchMapping:
+        def mapping_pattern(self, _: None) -> ast.MatchMapping:
             """Grammar rule.
 
             mapping_pattern: LBRACE (dict_inner_pattern (COMMA dict_inner_pattern)*)? RBRACE
             """
-            patterns = [
-                i for i in kid if isinstance(i, (ast.MatchKVPair, ast.MatchStar))
-            ]
-            return self.nu(
-                ast.MatchMapping(
-                    values=patterns,
-                    kid=kid,
+            self.consume_token(Tok.LBRACE)
+            patterns = [self.match(ast.MatchKVPair) or self.consume(ast.MatchStar)]
+            while self.match_token(Tok.COMMA):
+                patterns.append(
+                    self.match(ast.MatchKVPair) or self.consume(ast.MatchStar)
                 )
+            self.consume_token(Tok.RBRACE)
+            return ast.MatchMapping(
+                values=patterns,
+                kid=self.cur_nodes,
             )
 
-        def list_inner_pattern(self, kid: list[ast.AstNode]) -> ast.MatchPattern:
+        def list_inner_pattern(self, _: None) -> ast.MatchPattern:
             """Grammar rule.
 
             list_inner_pattern: (pattern_seq | STAR_MUL NAME)
             """
-            if isinstance(kid[0], ast.MatchPattern):
-                return self.nu(kid[0])
-            elif isinstance(kid[-1], ast.Name):
-                return self.nu(
-                    ast.MatchStar(
-                        is_list=True,
-                        name=kid[-1],
-                        kid=kid,
-                    )
+            if self.match_token(Tok.STAR_MUL):
+                name = self.consume(ast.Name)
+                return ast.MatchStar(
+                    is_list=True,
+                    name=name,
+                    kid=self.cur_nodes,
                 )
-            else:
-                raise self.ice()
+            return self.consume(ast.MatchPattern)
 
-        def dict_inner_pattern(
-            self, kid: list[ast.AstNode]
-        ) -> ast.MatchKVPair | ast.MatchStar:
+        def dict_inner_pattern(self, _: None) -> ast.MatchKVPair | ast.MatchStar:
             """Grammar rule.
 
             dict_inner_pattern: (pattern_seq COLON pattern_seq | STAR_POW NAME)
             """
-            if isinstance(kid[0], ast.MatchPattern) and isinstance(
-                kid[2], ast.MatchPattern
-            ):
-                return self.nu(
-                    ast.MatchKVPair(
-                        key=kid[0],
-                        value=kid[2],
-                        kid=kid,
-                    )
-                )
-            elif isinstance(kid[-1], ast.Name):
-                return self.nu(
-                    ast.MatchStar(
-                        is_list=False,
-                        name=kid[-1],
-                        kid=kid,
-                    )
+            if self.match_token(Tok.STAR_POW):
+                name = self.consume(ast.Name)
+                return ast.MatchStar(
+                    is_list=False,
+                    name=name,
+                    kid=self.cur_nodes,
                 )
-            else:
-                raise self.ice()
+            pattern = self.consume(ast.MatchPattern)
+            self.consume_token(Tok.COLON)
+            value = self.consume(ast.MatchPattern)
+            return ast.MatchKVPair(key=pattern, value=value, kid=self.cur_nodes)
 
         def class_pattern(self, kid: list[ast.AstNode]) -> ast.MatchArch:
             """Grammar rule.
@@ -3886,13 +3406,11 @@ class JacParser(Pass):
                     kid_nodes.append(kw)
                 kid_nodes.append(rapren)
 
-                return self.nu(
-                    ast.MatchArch(
-                        name=name,
-                        arg_patterns=arg,
-                        kw_patterns=kw,
-                        kid=kid_nodes,
-                    )
+                return ast.MatchArch(
+                    name=name,
+                    arg_patterns=arg,
+                    kw_patterns=kw,
+                    kid=kid_nodes,
                 )
             else:
                 raise self.ice()
@@ -3998,7 +3516,6 @@ class JacParser(Pass):
                 Tok.FSTR_BESC,
                 Tok.FSTR_PIECE,
                 Tok.FSTR_SQ_PIECE,
-                Tok.DOC_STRING,
             ]:
                 ret_type = ast.String
                 if token.type == Tok.FSTR_BESC:
@@ -4027,4 +3544,4 @@ class JacParser(Pass):
                     err.column = ret.loc.col_start
                     raise err
             self.terminals.append(ret)
-            return self.nu(ret)
+            return ret