jaclang 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -31,6 +31,63 @@ from jaclang.settings import settings
 
 T = TypeVar("T", bound=ast3.AST)
 
+# Mapping of Jac tokens to corresponding Python AST operator classes. This
+# helps keep the implementation of ``exit_token`` concise and easier to
+# maintain.
+TOKEN_AST_MAP: dict[Tok, type[ast3.AST]] = {
+    Tok.KW_AND: ast3.And,
+    Tok.KW_OR: ast3.Or,
+    Tok.PLUS: ast3.Add,
+    Tok.ADD_EQ: ast3.Add,
+    Tok.BW_AND: ast3.BitAnd,
+    Tok.BW_AND_EQ: ast3.BitAnd,
+    Tok.BW_OR: ast3.BitOr,
+    Tok.BW_OR_EQ: ast3.BitOr,
+    Tok.BW_XOR: ast3.BitXor,
+    Tok.BW_XOR_EQ: ast3.BitXor,
+    Tok.DIV: ast3.Div,
+    Tok.DIV_EQ: ast3.Div,
+    Tok.FLOOR_DIV: ast3.FloorDiv,
+    Tok.FLOOR_DIV_EQ: ast3.FloorDiv,
+    Tok.LSHIFT: ast3.LShift,
+    Tok.LSHIFT_EQ: ast3.LShift,
+    Tok.MOD: ast3.Mod,
+    Tok.MOD_EQ: ast3.Mod,
+    Tok.STAR_MUL: ast3.Mult,
+    Tok.MUL_EQ: ast3.Mult,
+    Tok.DECOR_OP: ast3.MatMult,
+    Tok.MATMUL_EQ: ast3.MatMult,
+    Tok.STAR_POW: ast3.Pow,
+    Tok.STAR_POW_EQ: ast3.Pow,
+    Tok.RSHIFT: ast3.RShift,
+    Tok.RSHIFT_EQ: ast3.RShift,
+    Tok.MINUS: ast3.Sub,
+    Tok.SUB_EQ: ast3.Sub,
+    Tok.BW_NOT: ast3.Invert,
+    Tok.BW_NOT_EQ: ast3.Invert,
+    Tok.NOT: ast3.Not,
+    Tok.EQ: ast3.NotEq,
+    Tok.EE: ast3.Eq,
+    Tok.GT: ast3.Gt,
+    Tok.GTE: ast3.GtE,
+    Tok.KW_IN: ast3.In,
+    Tok.KW_IS: ast3.Is,
+    Tok.KW_ISN: ast3.IsNot,
+    Tok.LT: ast3.Lt,
+    Tok.LTE: ast3.LtE,
+    Tok.NE: ast3.NotEq,
+    Tok.KW_NIN: ast3.NotIn,
+}
+
+# Mapping of unary operator tokens to their Python AST counterparts used in
+# ``exit_unary_expr``.
+UNARY_OP_MAP: dict[Tok, type[ast3.unaryop]] = {
+    Tok.NOT: ast3.Not,
+    Tok.BW_NOT: ast3.Invert,
+    Tok.PLUS: ast3.UAdd,
+    Tok.MINUS: ast3.USub,
+}
+
 
 class PyastGenPass(UniPass):
     """Jac blue transpilation to python pass."""
@@ -114,69 +171,55 @@ class PyastGenPass(UniPass):
             )
         )
 
-    def needs_typing(self) -> None:
-        """Check if enum is needed."""
-        if self.needs_typing.__name__ in self.already_added:
+    def _add_preamble_once(self, key: str, node: ast3.AST) -> None:
+        """Append an import statement to the preamble once."""
+        if key in self.already_added:
             return
-        self.preamble.append(
-            self.sync(
-                ast3.Import(
-                    names=[
-                        self.sync(
-                            ast3.alias(name="typing"),
-                            jac_node=self.ir_out,
-                        ),
-                    ]
-                ),
-                jac_node=self.ir_out,
-            )
+        self.preamble.append(self.sync(node, jac_node=self.ir_out))
+        self.already_added.append(key)
+
+    def needs_typing(self) -> None:
+        """Ensure typing is imported only once."""
+        self._add_preamble_once(
+            self.needs_typing.__name__,
+            ast3.Import(
+                names=[self.sync(ast3.alias(name="typing"), jac_node=self.ir_out)]
+            ),
         )
-        self.already_added.append(self.needs_typing.__name__)
 
     def needs_enum(self) -> None:
-        """Check if enum is needed."""
-        if self.needs_enum.__name__ in self.already_added:
-            return
-        self.preamble.append(
-            self.sync(
-                ast3.ImportFrom(
-                    module="enum",
-                    names=[
-                        self.sync(ast3.alias(name="Enum", asname=None)),
-                        self.sync(ast3.alias(name="auto", asname=None)),
-                    ],
-                    level=0,
-                ),
-                jac_node=self.ir_out,
-            )
+        """Ensure Enum utilities are imported only once."""
+        self._add_preamble_once(
+            self.needs_enum.__name__,
+            ast3.ImportFrom(
+                module="enum",
+                names=[
+                    self.sync(ast3.alias(name="Enum", asname=None)),
+                    self.sync(ast3.alias(name="auto", asname=None)),
+                ],
+                level=0,
+            ),
         )
-        self.already_added.append(self.needs_enum.__name__)
 
     def needs_future(self) -> None:
-        """Check if enum is needed."""
-        if self.needs_future.__name__ in self.already_added:
-            return
-        self.preamble.append(
-            self.sync(
-                ast3.ImportFrom(
-                    module="concurrent.futures",
-                    names=[
-                        self.sync(ast3.alias(name="Future", asname=None)),
-                    ],
-                    level=0,
-                ),
-                jac_node=self.ir_out,
-            )
+        """Ensure concurrent Future is imported only once."""
+        self._add_preamble_once(
+            self.needs_future.__name__,
+            ast3.ImportFrom(
+                module="concurrent.futures",
+                names=[self.sync(ast3.alias(name="Future", asname=None))],
+                level=0,
+            ),
         )
-        self.already_added.append(self.needs_future.__name__)
 
     def flatten(self, body: list[T | list[T] | None]) -> list[T]:
-        new_body = []
-        for i in body:
-            if isinstance(i, list):
-                new_body += i
-            elif i is not None:
-                new_body.append(i) if i else None
+        """Flatten a list of items or lists into a single list."""
+        new_body: list[T] = []
+        for item in body:
+            if isinstance(item, list):
+                new_body.extend(item)
+            elif item is not None:
+                new_body.append(item)
         return new_body
 
     def sync(
@@ -224,21 +267,15 @@ class PyastGenPass(UniPass):
 
     def resolve_stmt_block(
         self,
-        node: (
-            uni.SubNodeList[uni.CodeBlockStmt]
-            | uni.SubNodeList[uni.ArchBlockStmt]
-            | uni.SubNodeList[uni.EnumBlockStmt]
-            | None
-        ),
+        node: Sequence[uni.CodeBlockStmt] | Sequence[uni.EnumBlockStmt] | None,
         doc: Optional[uni.String] = None,
     ) -> list[ast3.AST]:
         """Unwind codeblock."""
-        valid_stmts = (
-            [i for i in node.items if not isinstance(i, uni.Semi)] if node else []
-        )
+        items = list(node) if node else []
+        valid_stmts = [i for i in items if not isinstance(i, uni.Semi)]
         ret: list[ast3.AST] = (
-            [self.sync(ast3.Pass(), node)]
-            if isinstance(node, uni.SubNodeList) and not valid_stmts
+            [self.sync(ast3.Pass())]
+            if isinstance(node, Sequence) and not valid_stmts
             else (
                 self.flatten(
                     [
@@ -247,7 +284,7 @@ class PyastGenPass(UniPass):
                         if not isinstance(x, uni.ImplDef)
                     ]
                 )
-                if node
+                if node is not None
                 else []
             )
         )
@@ -273,23 +310,16 @@ class PyastGenPass(UniPass):
         attr_node: ast3.Name | ast3.Attribute = self.sync(
             ast3.Name(id=attribute_list[0], ctx=ast3.Load()), sync_node_list[0]
         )
-        for i in range(len(attribute_list)):
-            if i == 0:
-                continue
+        for attr, sync_node in zip(attribute_list[1:], sync_node_list[1:]):
             attr_node = self.sync(
-                ast3.Attribute(
-                    value=attr_node, attr=attribute_list[i], ctx=ast3.Load()
-                ),
-                sync_node_list[i],
+                ast3.Attribute(value=attr_node, attr=attr, ctx=ast3.Load()),
+                sync_node,
             )
         return attr_node
 
     def exit_sub_tag(self, node: uni.SubTag[uni.T]) -> None:
         node.gen.py_ast = node.tag.gen.py_ast
 
-    def exit_sub_node_list(self, node: uni.SubNodeList[uni.T]) -> None:
-        node.gen.py_ast = self.flatten([i.gen.py_ast for i in node.items])
-
     def exit_module(self, node: uni.Module) -> None:
         clean_body = [i for i in node.body if not isinstance(i, uni.ImplDef)]
         pre_body: list[uni.UniNode] = []
@@ -332,14 +362,15 @@ class PyastGenPass(UniPass):
                 ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
                 jac_node=node.doc,
             )
-            if isinstance(doc, ast3.AST) and isinstance(
-                node.assignments.gen.py_ast, list
-            ):
-                node.gen.py_ast = [doc] + node.assignments.gen.py_ast
+            assigns_ast: list[ast3.AST] = self.flatten(
+                [a.gen.py_ast for a in node.assignments]
+            )
+            if isinstance(doc, ast3.AST):
+                node.gen.py_ast = [doc] + assigns_ast
             else:
                 raise self.ice()
         else:
-            node.gen.py_ast = node.assignments.gen.py_ast
+            node.gen.py_ast = self.flatten([a.gen.py_ast for a in node.assignments])
 
     def exit_test(self, node: uni.Test) -> None:
         test_name = node.name.sym_name
@@ -382,7 +413,7 @@ class PyastGenPass(UniPass):
                                 ast3.keyword(
                                     arg="file_loc",
                                     value=self.sync(
-                                        ast3.Constant(value=node.body.loc.mod_path)
+                                        ast3.Constant(value=node.loc.mod_path)
                                     ),
                                 )
                             ),
@@ -434,40 +465,8 @@ class PyastGenPass(UniPass):
             )
 
     def exit_import(self, node: uni.Import) -> None:
-        path_alias: dict[str, Optional[str]] = (
-            {node.from_loc.dot_path_str: None} if node.from_loc else {}
-        )
-        imp_from = {}
-        if node.items:
-            for item in node.items.items:
-                if isinstance(item, uni.ModuleItem):
-                    imp_from[item.name.sym_name] = (
-                        item.alias.sym_name if item.alias else None
-                    )
-                elif isinstance(item, uni.ModulePath):
-                    path_alias[item.dot_path_str] = (
-                        item.alias.sym_name if item.alias else None
-                    )
-
-        item_names: list[ast3.expr] = []
-        item_keys: list[ast3.Constant] = []
-        item_values: list[ast3.Constant] = []
-        for k, v in imp_from.items():
-            item_keys.append(self.sync(ast3.Constant(value=k)))
-            item_values.append(self.sync(ast3.Constant(value=v)))
-            item_names.append(
-                self.sync(
-                    ast3.Name(
-                        id=v or k,
-                        ctx=ast3.Store(),
-                    )
-                )
-            )
-        path_named_value: str
+        """Exit import node."""
         py_nodes: list[ast3.AST] = []
-        typecheck_nodes: list[ast3.AST] = []
-        runtime_nodes: list[ast3.AST] = []
-
         if node.doc:
             py_nodes.append(
                 self.sync(
@@ -476,284 +475,58 @@ class PyastGenPass(UniPass):
                 )
             )
 
-        for path, alias in path_alias.items():
-            path_named_value = ("_jac_inc_" if node.is_absorb else "") + (
-                alias if alias else path
-            ).lstrip(".").split(".")[0]
-            # target_named_value = ""
-            # for i in path.split("."):
-            #     target_named_value += i if i else "."
-            #     if i:
-            #         break
-
-            args = [
-                self.sync(
-                    ast3.Constant(value=path),
-                ),
-                self.sync(
-                    ast3.Name(
-                        id="__file__",
-                        ctx=ast3.Load(),
-                    )
-                ),
-            ]
-            keywords = []
-
-            if node.is_absorb:
-                args.append(self.sync(ast3.Constant(value=node.is_absorb)))
-
-            if alias is not None:
-                keywords.append(
-                    self.sync(
-                        ast3.keyword(
-                            arg="mdl_alias",
-                            value=self.sync(
-                                ast3.Constant(value=alias),
-                            ),
-                        )
-                    )
-                )
-
-            if item_keys and item_values:
-                keywords.append(
-                    self.sync(
-                        ast3.keyword(
-                            arg="items",
-                            value=self.sync(
-                                ast3.Dict(
-                                    keys=cast(list[ast3.expr | None], item_keys),
-                                    values=cast(list[ast3.expr], item_values),
-                                ),
-                            ),
-                        )
-                    )
-                )
-
-            runtime_nodes.append(
-                self.sync(
-                    ast3.Assign(
-                        targets=(
-                            [
-                                self.sync(
-                                    ast3.Tuple(
-                                        elts=(
-                                            item_names
-                                            or [
-                                                self.sync(
-                                                    ast3.Name(
-                                                        id=path_named_value,
-                                                        ctx=ast3.Store(),
-                                                    )
-                                                )
-                                            ]
-                                        ),
-                                        ctx=ast3.Store(),
-                                    )
-                                )
-                            ]
-                        ),
-                        value=self.sync(
-                            ast3.Call(
-                                func=self.jaclib_obj("py_jac_import"),
-                                args=args,
-                                keywords=keywords,
-                            )
-                        ),
-                    ),
-                ),
-            )
         if node.is_absorb:
-            absorb_exec = f"={path_named_value}.__dict__['"
-            runtime_nodes.append(
-                self.sync(
-                    ast3.For(
-                        target=self.sync(ast3.Name(id="i", ctx=ast3.Store())),
-                        iter=self.sync(
-                            ast3.IfExp(
-                                test=self.sync(
-                                    ast3.Compare(
-                                        left=self.sync(ast3.Constant(value="__all__")),
-                                        ops=[self.sync(ast3.In())],
-                                        comparators=[
-                                            self.sync(
-                                                ast3.Attribute(
-                                                    value=self.sync(
-                                                        ast3.Name(
-                                                            id=path_named_value,
-                                                            ctx=ast3.Load(),
-                                                        )
-                                                    ),
-                                                    attr="__dict__",
-                                                    ctx=ast3.Load(),
-                                                )
-                                            )
-                                        ],
-                                    )
-                                ),
-                                body=self.sync(
-                                    ast3.Attribute(
-                                        value=self.sync(
-                                            ast3.Name(
-                                                id=path_named_value, ctx=ast3.Load()
-                                            )
-                                        ),
-                                        attr="__all__",
-                                        ctx=ast3.Load(),
-                                    )
-                                ),
-                                orelse=self.sync(
-                                    ast3.Attribute(
-                                        value=self.sync(
-                                            ast3.Name(
-                                                id=path_named_value, ctx=ast3.Load()
-                                            )
-                                        ),
-                                        attr="__dict__",
-                                        ctx=ast3.Load(),
-                                    )
-                                ),
-                            )
-                        ),
-                        body=[
-                            self.sync(
-                                ast3.If(
-                                    test=self.sync(
-                                        ast3.UnaryOp(
-                                            op=self.sync(ast3.Not()),
-                                            operand=self.sync(
-                                                ast3.Call(
-                                                    func=self.sync(
-                                                        ast3.Attribute(
-                                                            value=self.sync(
-                                                                ast3.Name(
-                                                                    id="i",
-                                                                    ctx=ast3.Load(),
-                                                                )
-                                                            ),
-                                                            attr="startswith",
-                                                            ctx=ast3.Load(),
-                                                        )
-                                                    ),
-                                                    args=[
-                                                        self.sync(
-                                                            ast3.Constant(value="_")
-                                                        )
-                                                    ],
-                                                    keywords=[],
-                                                )
-                                            ),
-                                        )
-                                    ),
-                                    body=[
-                                        self.sync(
-                                            ast3.Expr(
-                                                value=self.sync(
-                                                    ast3.Call(
-                                                        func=self.sync(
-                                                            ast3.Name(
-                                                                id="exec",
-                                                                ctx=ast3.Load(),
-                                                            )
-                                                        ),
-                                                        args=[
-                                                            self.sync(
-                                                                ast3.JoinedStr(
-                                                                    values=[
-                                                                        self.sync(
-                                                                            ast3.FormattedValue(
-                                                                                value=self.sync(
-                                                                                    ast3.Name(
-                                                                                        id="i",
-                                                                                        ctx=ast3.Load(),
-                                                                                    )
-                                                                                ),
-                                                                                conversion=-1,
-                                                                            )
-                                                                        ),
-                                                                        self.sync(
-                                                                            ast3.Constant(
-                                                                                value=absorb_exec
-                                                                            )
-                                                                        ),
-                                                                        self.sync(
-                                                                            ast3.FormattedValue(
-                                                                                value=self.sync(
-                                                                                    ast3.Name(
-                                                                                        id="i",
-                                                                                        ctx=ast3.Load(),
-                                                                                    )
-                                                                                ),
-                                                                                conversion=-1,
-                                                                            )
-                                                                        ),
-                                                                        self.sync(
-                                                                            ast3.Constant(
-                                                                                value="']"
-                                                                            )
-                                                                        ),
-                                                                    ]
-                                                                )
-                                                            )
-                                                        ],
-                                                        keywords=[],
-                                                    )
-                                                )
-                                            )
-                                        )
-                                    ],
-                                    orelse=[],
-                                )
-                            )
-                        ],
-                        orelse=[],
-                    )
-                )
-            )
-        if node.is_absorb:
-            source = node.items.items[0]
+            # This is `include "module_name";` which becomes `from module_name import *`
+            source = node.items[0]
             if not isinstance(source, uni.ModulePath):
                 raise self.ice()
-            typecheck_nodes.append(
+
+            module_name_parts = [p.value for p in source.path] if source.path else []
+            module_name = ".".join(module_name_parts) if module_name_parts else None
+
+            py_nodes.append(
                 self.sync(
                     py_node=ast3.ImportFrom(
-                        module=(source.dot_path_str.lstrip(".") if source else None),
+                        module=module_name,
                         names=[self.sync(ast3.alias(name="*"), node)],
-                        level=0,
+                        level=source.level,
                     ),
                     jac_node=node,
                 )
             )
         elif not node.from_loc:
-            typecheck_nodes.append(
+            # This is `import module1, module2 as alias;`
+            py_nodes.append(
                 self.sync(
                     ast3.Import(
-                        names=[cast(ast3.alias, x) for x in node.items.gen.py_ast]
+                        names=[
+                            cast(ast3.alias, x)
+                            for item in node.items
+                            for x in item.gen.py_ast
+                        ]
                     )
                 )
             )
         else:
-            typecheck_nodes.append(
+            # This is `from module import item1, item2 as alias;`
+            module_name_parts = (
+                [p.value for p in node.from_loc.path] if node.from_loc.path else []
+            )
+            module_name = ".".join(module_name_parts) if module_name_parts else None
+
+            py_nodes.append(
                 self.sync(
                     ast3.ImportFrom(
-                        module=(
-                            node.from_loc.dot_path_str.lstrip(".")
-                            if node.from_loc
-                            else None
-                        ),
-                        names=[cast(ast3.alias, i) for i in node.items.gen.py_ast],
-                        level=0,
+                        module=module_name,
+                        names=[
+                            cast(ast3.alias, i)
+                            for item in node.items
+                            for i in item.gen.py_ast
+                        ],
+                        level=node.from_loc.level,
                     )
                 )
             )
-        py_nodes.append(
-            self.sync(
-                ast3.If(
-                    test=self.jaclib_obj("TYPE_CHECKING"),
-                    body=[cast(ast3.stmt, node) for node in typecheck_nodes],
-                    orelse=[cast(ast3.stmt, node) for node in runtime_nodes],
-                )
-            )
-        )
         node.gen.py_ast = py_nodes
 
     def exit_module_path(self, node: uni.ModulePath) -> None:
@@ -781,16 +554,19 @@ class PyastGenPass(UniPass):
             self.traverse(node.body)
 
     def exit_archetype(self, node: uni.Archetype) -> None:
-        body = self.resolve_stmt_block(
-            (
-                node.body.body
-                if isinstance(node.body, uni.ImplDef)
-                and isinstance(node.body.body, uni.SubNodeList)
-                else node.body if isinstance(node.body, uni.SubNodeList) else None
-            ),
-            doc=node.doc,
-        )
-
+        inner = None
+        if isinstance(node.body, uni.ImplDef):
+            inner = (
+                node.body.body if not isinstance(node.body.body, uni.FuncCall) else None
+            )
+        elif not isinstance(node.body, uni.FuncCall):
+            inner = node.body
+        body = self.resolve_stmt_block(inner, doc=node.doc)
+        if not body and not isinstance(node.body, uni.FuncCall):
+            self.log_error(
+                "Archetype has no body. Perhaps an impl must be imported.", node
+            )
+            body = [self.sync(ast3.Pass(), node)]
         if node.is_async:
             body.insert(
                 0,
@@ -805,12 +581,11 @@ class PyastGenPass(UniPass):
             )
 
         decorators = (
-            node.decorators.gen.py_ast
-            if isinstance(node.decorators, uni.SubNodeList)
+            [cast(ast3.expr, i.gen.py_ast[0]) for i in node.decorators]
+            if node.decorators
             else []
         )
-
-        base_classes = node.base_classes.gen.py_ast if node.base_classes else []
+        base_classes = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.base_classes]
         if node.arch_type.name != Tok.KW_CLASS:
             base_classes.append(self.jaclib_obj(node.arch_type.value.capitalize()))
 
@@ -833,25 +608,21 @@ class PyastGenPass(UniPass):
 
     def exit_enum(self, node: uni.Enum) -> None:
         self.needs_enum()
-        body = self.resolve_stmt_block(
-            (
-                node.body.body
-                if isinstance(node.body, uni.ImplDef)
-                and isinstance(node.body.body, uni.SubNodeList)
-                else node.body if isinstance(node.body, uni.SubNodeList) else None
-            ),
-            doc=node.doc,
-        )
+        inner = None
+        if isinstance(node.body, uni.ImplDef):
+            inner = (
+                node.body.body if not isinstance(node.body.body, uni.FuncCall) else None
+            )
+        elif not isinstance(node.body, uni.FuncCall):
+            inner = node.body
+        body = self.resolve_stmt_block(inner, doc=node.doc)
         decorators = (
-            node.decorators.gen.py_ast
-            if isinstance(node.decorators, uni.SubNodeList)
+            [cast(ast3.expr, i.gen.py_ast[0]) for i in node.decorators]
+            if node.decorators
             else []
         )
-        base_classes = node.base_classes.gen.py_ast if node.base_classes else []
-        if isinstance(base_classes, list):
-            base_classes.append(self.sync(ast3.Name(id="Enum", ctx=ast3.Load())))
-        else:
-            raise self.ice()
+        base_classes = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.base_classes]
+        base_classes.append(self.sync(ast3.Name(id="Enum", ctx=ast3.Load())))
         node.gen.py_ast = [
             self.sync(
                 ast3.ClassDef(
@@ -869,20 +640,42 @@ class PyastGenPass(UniPass):
         if isinstance(node.body, uni.ImplDef):
             self.traverse(node.body)
 
+    def gen_llm_call_override(self, node: uni.FuncCall) -> list[ast3.AST]:
+        """Generate python ast nodes for llm function body override syntax.
+
+        example:
+            foo() by llm();
+        """
+        # to Avoid circular import
+        from jaclang.runtimelib.machine import JacMachineInterface
+
+        return JacMachineInterface.gen_llm_call_override(self, node)
+
     def gen_llm_body(self, node: uni.Ability) -> list[ast3.AST]:
         """Generate the by LLM body."""
         # to Avoid circular import
         from jaclang.runtimelib.machine import JacMachineInterface
 
-        return JacMachineInterface.gen_llm_body(self, node)
+        body: list[ast3.AST] = JacMachineInterface.gen_llm_body(self, node)
+        if node.doc:
+            body.insert(
+                0,
+                self.sync(
+                    ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                    jac_node=node.doc,
+                ),
+            )
+        return body
 
     def exit_ability(self, node: uni.Ability) -> None:
         func_type = ast3.AsyncFunctionDef if node.is_async else ast3.FunctionDef
         body = (
             self.gen_llm_body(node)
             if isinstance(node.body, uni.FuncCall)
-            or isinstance(node.body, uni.ImplDef)
-            and isinstance(node.body.body, uni.FuncCall)
+            or (
+                isinstance(node.body, uni.ImplDef)
+                and isinstance(node.body.body, uni.FuncCall)
+            )
             else (
                 [
                     self.sync(
@@ -899,8 +692,12 @@ class PyastGenPass(UniPass):
                         (
                             node.body.body
                             if isinstance(node.body, uni.ImplDef)
-                            and isinstance(node.body.body, uni.SubNodeList)
-                            else node.body
+                            and not isinstance(node.body.body, uni.FuncCall)
+                            else (
+                                node.body
+                                if not isinstance(node.body, uni.FuncCall)
+                                else None
+                            )
                         ),
                         doc=node.doc,
                     )
@@ -912,7 +709,11 @@ class PyastGenPass(UniPass):
                 f"Abstract ability {node.sym_name} should not have a body.",
                 node,
             )
-        decorator_list = node.decorators.gen.py_ast if node.decorators else []
+        decorator_list = (
+            [cast(ast3.expr, i.gen.py_ast[0]) for i in node.decorators]
+            if node.decorators
+            else []
+        )
         if isinstance(node.signature, uni.EventSignature):
             decorator_list.append(
                 self.jaclib_obj(
@@ -971,11 +772,7 @@ class PyastGenPass(UniPass):
                     ),
                     body=[cast(ast3.stmt, i) for i in body],
                     decorator_list=[cast(ast3.expr, i) for i in decorator_list],
-                    returns=(
-                        cast(ast3.expr, node.signature.return_type.gen.py_ast[0])
-                        if node.signature and node.signature.return_type
-                        else self.sync(ast3.Constant(value=None))
-                    ),
+                    returns=self.sync(ast3.Constant(value=None)),
                     type_params=[],
                 )
             )
@@ -995,23 +792,18 @@ class PyastGenPass(UniPass):
         )
         vararg = None
         kwarg = None
-        if isinstance(node.params, uni.SubNodeList):
-            for i in node.params.items:
-                if i.unpack and i.unpack.value == "*":
-                    vararg = i.gen.py_ast[0]
-                elif i.unpack and i.unpack.value == "**":
-                    kwarg = i.gen.py_ast[0]
-                else:
-                    (
-                        params.append(i.gen.py_ast[0])
-                        if isinstance(i.gen.py_ast[0], ast3.arg)
-                        else self.ice("This list should only be Args")
-                    )
-        defaults = (
-            [x.value.gen.py_ast[0] for x in node.params.items if x.value]
-            if node.params
-            else []
-        )
+        for i in node.params:
+            if i.unpack and i.unpack.value == "*":
+                vararg = i.gen.py_ast[0]
+            elif i.unpack and i.unpack.value == "**":
+                kwarg = i.gen.py_ast[0]
+            else:
+                (
+                    params.append(i.gen.py_ast[0])
+                    if isinstance(i.gen.py_ast[0], ast3.arg)
+                    else self.ice("This list should only be Args")
+                )
+        defaults = [x.value.gen.py_ast[0] for x in node.params if x.value]
         node.gen.py_ast = [
             self.sync(
                 ast3.arguments(
@@ -1027,9 +819,10 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_event_signature(self, node: uni.EventSignature) -> None:
-        here = self.sync(
+        arch_kw = Con.HERE.value if node.from_walker else Con.VISITOR.value
+        arch_arg = self.sync(
             ast3.arg(
-                arg=f"{Con.HERE.value}",
+                arg=f"{arch_kw}",
                 annotation=(
                     cast(ast3.expr, node.arch_tag_info.gen.py_ast[0])
                     if node.arch_tag_info
@@ -1043,10 +836,10 @@ class PyastGenPass(UniPass):
                 ast3.arguments(
                     posonlyargs=[],
                     args=(
-                        [self.sync(ast3.arg(arg="self", annotation=None)), here]
+                        [self.sync(ast3.arg(arg="self", annotation=None)), arch_arg]
                         if (abl := node.find_parent_of_type(uni.Ability))
                         and abl.is_method
-                        else [here]
+                        else [arch_arg]
                     ),
                     kwonlyargs=[],
                     vararg=None,
@@ -1090,43 +883,31 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_arch_has(self, node: uni.ArchHas) -> None:
+        vars_py: list[ast3.AST] = self.flatten([v.gen.py_ast for v in node.vars])
         if node.doc:
             doc = self.sync(
                 ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
                 jac_node=node.doc,
             )
-            if isinstance(doc, ast3.AST) and isinstance(node.vars.gen.py_ast, list):
-                node.gen.py_ast = [doc] + node.vars.gen.py_ast
+            if isinstance(doc, ast3.AST):
+                node.gen.py_ast = [doc] + vars_py
             else:
                 raise self.ice()
         else:
-            node.gen.py_ast = node.vars.gen.py_ast  # TODO: This is a list
+            node.gen.py_ast = vars_py
 
     def exit_has_var(self, node: uni.HasVar) -> None:
         annotation = node.type_tag.gen.py_ast[0] if node.type_tag else None
 
         is_static_var = (
-            node.parent
-            and node.parent.parent
-            and isinstance(node.parent.parent, uni.ArchHas)
-            and node.parent.parent.is_static
+            (haspar := node.find_parent_of_type(uni.ArchHas))
+            and haspar
+            and haspar.is_static
         )
-
         is_in_class = (
-            node.parent
-            and node.parent.parent
-            and node.parent.parent.parent
-            and (
-                (
-                    isinstance(node.parent.parent.parent, uni.Archetype)
-                    and node.parent.parent.parent.arch_type.name == Tok.KW_CLASS
-                )
-                or (
-                    node.parent.parent.parent.parent
-                    and isinstance(node.parent.parent.parent.parent, uni.Archetype)
-                    and node.parent.parent.parent.parent.arch_type.name == Tok.KW_CLASS
-                )
-            )
+            (archpar := node.find_parent_of_type(uni.Archetype))
+            and archpar
+            and archpar.arch_type.name == Tok.KW_CLASS
         )
 
         value = None
@@ -1313,11 +1094,9 @@ class PyastGenPass(UniPass):
             self.sync(
                 ast3.Try(
                     body=cast(list[ast3.stmt], self.resolve_stmt_block(node.body)),
-                    handlers=(
-                        [cast(ast3.ExceptHandler, i) for i in node.excepts.gen.py_ast]
-                        if node.excepts
-                        else []
-                    ),
+                    handlers=[
+                        cast(ast3.ExceptHandler, i.gen.py_ast[0]) for i in node.excepts
+                    ],
                     orelse=(
                         [cast(ast3.stmt, i) for i in node.else_body.gen.py_ast]
                         if node.else_body
@@ -1355,7 +1134,7 @@ class PyastGenPass(UniPass):
 
     def exit_iter_for_stmt(self, node: uni.IterForStmt) -> None:
         py_nodes: list[ast3.AST] = []
-        body = node.body.gen.py_ast
+        body = self.resolve_stmt_block(node.body)
         if (
             isinstance(body, list)
             and isinstance(node.count_by.gen.py_ast[0], ast3.AST)
@@ -1419,7 +1198,9 @@ class PyastGenPass(UniPass):
         node.gen.py_ast = [
             self.sync(
                 with_node(
-                    items=[cast(ast3.withitem, item) for item in node.exprs.gen.py_ast],
+                    items=[
+                        cast(ast3.withitem, item.gen.py_ast[0]) for item in node.exprs
+                    ],
                     body=[
                         cast(ast3.stmt, stmt)
                         for stmt in self.resolve_stmt_block(node.body)
@@ -1510,13 +1291,11 @@ class PyastGenPass(UniPass):
             node: uni.FuncCall,
         ) -> CheckNodeIsinstanceCallResult:
 
-            # Ensure the type of the FuncCall node is SubNodeList[Expr]
-            # since the type can be: Optional[SubNodeList[Expr | KWPair]].
+            # Ensure the func call has exactly two expression parameters
             if not (
-                node.params is not None
-                and len(node.params.items) == 2
-                and isinstance(node.params.items[0], uni.Expr)
-                and isinstance(node.params.items[1], uni.Expr)
+                len(node.params) == 2
+                and isinstance(node.params[0], uni.Expr)
+                and isinstance(node.params[1], uni.Expr)
             ):
                 return CheckNodeIsinstanceCallResult()
 
@@ -1526,8 +1305,8 @@ class PyastGenPass(UniPass):
 
             return CheckNodeIsinstanceCallResult(
                 True,
-                node.params.items[0].gen.py_ast[0],
-                node.params.items[1].gen.py_ast[0],
+                node.params[0].gen.py_ast[0],
+                node.params[1].gen.py_ast[0],
             )
 
         # By default the check expression will become assertTrue(<expr>), unless any pattern detected.
@@ -1613,9 +1392,8 @@ class PyastGenPass(UniPass):
             if isinstance(func, uni.Name) and func.value == "almostEqual":
                 assert_func_name = "assertAlmostEqual"
                 assert_args_list = []
-                if node.target.params is not None:
-                    for param in node.target.params.items:
-                        assert_args_list.append(param.gen.py_ast[0])
+                for param in node.target.params:
+                    assert_args_list.append(param.gen.py_ast[0])
 
         # assert_func_expr = "Con.JAC_CHECK.value.assertXXX"
         assert_func_expr: ast3.Attribute = self.sync(
@@ -1746,7 +1524,7 @@ class PyastGenPass(UniPass):
         walker = self.sync(
             ast3.Name(id="self", ctx=ast3.Load())
             if node.from_walker
-            else ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
+            else ast3.Name(id=Con.VISITOR.value, ctx=ast3.Load())
         )
 
         node.gen.py_ast = [
@@ -1769,7 +1547,7 @@ class PyastGenPass(UniPass):
         loc = self.sync(
             ast3.Name(id="self", ctx=ast3.Load())
             if node.from_walker
-            else ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
+            else ast3.Name(id=Con.VISITOR.value, ctx=ast3.Load())
         )
 
         visit_call = self.sync(
@@ -1780,6 +1558,16 @@ class PyastGenPass(UniPass):
             )
         )
 
+        if node.insert_loc is not None:
+            visit_call.keywords.append(
+                self.sync(
+                    ast3.keyword(
+                        arg="insert_loc",
+                        value=cast(ast3.expr, node.insert_loc.gen.py_ast[0]),
+                    )
+                )
+            )
+
         node.gen.py_ast = [
             (
                 self.sync(
@@ -1803,7 +1591,7 @@ class PyastGenPass(UniPass):
         loc = self.sync(
             ast3.Name(id="self", ctx=ast3.Load())
             if node.from_walker
-            else ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
+            else ast3.Name(id=Con.VISITOR.value, ctx=ast3.Load())
         )
         node.gen.py_ast = [
             self.sync(
@@ -1821,29 +1609,13 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_await_expr(self, node: uni.AwaitExpr) -> None:
-        parent_node = node.parent
-        while parent_node and (parent_node := parent_node.parent):
-            if hasattr(parent_node, "is_async") and parent_node.is_async:
-                node.gen.py_ast = [
-                    self.sync(
-                        ast3.Await(value=cast(ast3.expr, node.target.gen.py_ast[0]))
-                    )
-                ]
-                break
-        else:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Call(
-                        func=self.jaclib_obj("await_obj"),
-                        args=[cast(ast3.expr, node.target.gen.py_ast[0])],
-                        keywords=[],
-                    )
-                )
-            ]
+        node.gen.py_ast = [
+            self.sync(ast3.Await(value=cast(ast3.expr, node.target.gen.py_ast[0])))
+        ]
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
         py_nodes = []
-        for x in node.target.items:
+        for x in node.target:
             py_nodes.append(
                 self.sync(
                     ast3.Global(names=[x.sym_name]),
@@ -1854,7 +1626,7 @@ class PyastGenPass(UniPass):
 
     def exit_non_local_stmt(self, node: uni.NonLocalStmt) -> None:
         py_nodes = []
-        for x in node.target.items:
+        for x in node.target:
             py_nodes.append(
                 self.sync(
                     ast3.Nonlocal(names=[x.sym_name]),
@@ -1879,18 +1651,20 @@ class PyastGenPass(UniPass):
                 else None if node.type_tag else self.ice()
             )
         )
+        targets_ast = [cast(ast3.expr, t.gen.py_ast[0]) for t in node.target]
+
         if node.type_tag:
             node.gen.py_ast = [
                 self.sync(
                     ast3.AnnAssign(
-                        target=cast(ast3.Name, node.target.items[0].gen.py_ast[0]),
+                        target=cast(ast3.Name, targets_ast[0]),
                         annotation=cast(ast3.expr, node.type_tag.gen.py_ast[0]),
                         value=(
                             cast(ast3.expr, node.value.gen.py_ast[0])
                             if node.value
                             else None
                         ),
-                        simple=int(isinstance(node.target.gen.py_ast[0], ast3.Name)),
+                        simple=int(isinstance(targets_ast[0], ast3.Name)),
                     )
                 )
             ]
@@ -1898,7 +1672,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.AugAssign(
-                        target=cast(ast3.Name, node.target.items[0].gen.py_ast[0]),
+                        target=cast(ast3.Name, targets_ast[0]),
                         op=cast(ast3.operator, node.aug_op.gen.py_ast[0]),
                         value=(
                             cast(ast3.expr, value)
@@ -1912,7 +1686,7 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Assign(
-                        targets=cast(list[ast3.expr], node.target.gen.py_ast),
+                        targets=cast(list[ast3.expr], targets_ast),
                         value=(
                             cast(ast3.expr, value)
                             if isinstance(value, ast3.expr)
@@ -2078,11 +1852,9 @@ class PyastGenPass(UniPass):
             func_node = uni.FuncCall(
                 target=node.right,
                 params=(
-                    node.left.values
-                    if isinstance(node.left, uni.TupleVal)
-                    else uni.SubNodeList(
-                        items=[node.left], delim=Tok.COMMA, kid=[node.left]
-                    )
+                    list(node.left.values)
+                    if isinstance(node.left, uni.TupleVal) and node.left.values
+                    else [node.left]
                 ),
                 genai_call=None,
                 kid=node.kid,
@@ -2110,11 +1882,9 @@ class PyastGenPass(UniPass):
             func_node = uni.FuncCall(
                 target=node.left,
                 params=(
-                    node.right.values
-                    if isinstance(node.right, uni.TupleVal)
-                    else uni.SubNodeList(
-                        items=[node.right], delim=Tok.COMMA, kid=[node.right]
-                    )
+                    list(node.right.values)
+                    if isinstance(node.right, uni.TupleVal) and node.right.values
+                    else [node.right]
                 ),
                 genai_call=None,
                 kid=node.kid,
@@ -2174,42 +1944,17 @@ class PyastGenPass(UniPass):
         ]
 
     def exit_unary_expr(self, node: uni.UnaryExpr) -> None:
-        if node.op.name == Tok.NOT:
+        op_cls = UNARY_OP_MAP.get(node.op.name)
+        if op_cls:
             node.gen.py_ast = [
                 self.sync(
                     ast3.UnaryOp(
-                        op=self.sync(ast3.Not()),
-                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
-                    )
-                )
-            ]
-        elif node.op.name == Tok.BW_NOT:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.UnaryOp(
-                        op=self.sync(ast3.Invert()),
-                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
-                    )
-                )
-            ]
-        elif node.op.name == Tok.PLUS:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.UnaryOp(
-                        op=self.sync(ast3.UAdd()),
-                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
-                    )
-                )
-            ]
-        elif node.op.name == Tok.MINUS:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.UnaryOp(
-                        op=self.sync(ast3.USub()),
+                        op=self.sync(op_cls()),
                         operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
                     )
                 )
             ]
+            return
         elif node.op.name in [Tok.PIPE_FWD, Tok.KW_SPAWN, Tok.A_PIPE_FWD]:
             node.gen.py_ast = [
                 self.sync(
@@ -2274,9 +2019,11 @@ class PyastGenPass(UniPass):
                 if isinstance(i, uni.String):
                     pieces.append(i.lit_value)
                 elif isinstance(i, uni.FString):
-                    pieces.extend(get_pieces(i.parts.items)) if i.parts else None
+                    pieces.extend(get_pieces(i.parts)) if i.parts else None
                 elif isinstance(i, uni.ExprStmt):
                     pieces.append(i.gen.py_ast[0])
+                elif isinstance(i, uni.Token) and i.name in [Tok.LBRACE, Tok.RBRACE]:
+                    continue
                 else:
                     raise self.ice("Multi string made of something weird.")
             return pieces
@@ -2313,62 +2060,30 @@ class PyastGenPass(UniPass):
             node.gen.py_ast = [combined_multi[0]]
 
     def exit_f_string(self, node: uni.FString) -> None:
-        node.gen.py_ast = (
-            node.parts.gen.py_ast
-            if node.parts
-            else [self.sync(ast3.Constant(value=""))]
-        )
+        py_parts: list[list[ast3.AST]] = [
+            cast(list[ast3.AST], p.gen.py_ast) for p in node.parts
+        ]
+        parts = self.flatten(cast(list[list[ast3.AST] | ast3.AST | None], py_parts))
+        node.gen.py_ast = parts if parts else [self.sync(ast3.Constant(value=""))]
 
     def exit_list_val(self, node: uni.ListVal) -> None:
-        if isinstance(node.py_ctx_func(), ast3.Load):
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.List(
-                        elts=(
-                            cast(list[ast3.expr], node.values.gen.py_ast)
-                            if node.values
-                            else []
-                        ),
-                        ctx=ast3.Load(),
-                    )
-                )
-            ]
-        else:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.List(
-                        elts=(
-                            [cast(ast3.expr, item) for item in node.values.gen.py_ast]
-                            if node.values and node.values.gen.py_ast
-                            else []
-                        ),
-                        ctx=cast(ast3.expr_context, node.py_ctx_func()),
-                    )
-                )
-            ]
+        elts = [cast(ast3.expr, v.gen.py_ast[0]) for v in node.values]
+        ctx = (
+            ast3.Load()
+            if isinstance(node.py_ctx_func(), ast3.Load)
+            else cast(ast3.expr_context, node.py_ctx_func())
+        )
+        node.gen.py_ast = [self.sync(ast3.List(elts=elts, ctx=ctx))]
 
     def exit_set_val(self, node: uni.SetVal) -> None:
-        node.gen.py_ast = [
-            self.sync(
-                ast3.Set(
-                    elts=(
-                        [cast(ast3.expr, i) for i in node.values.gen.py_ast]
-                        if node.values
-                        else []
-                    ),
-                )
-            )
-        ]
+        elts = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.values]
+        node.gen.py_ast = [self.sync(ast3.Set(elts=elts))]
 
     def exit_tuple_val(self, node: uni.TupleVal) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Tuple(
-                    elts=(
-                        cast(list[ast3.expr], node.values.gen.py_ast)
-                        if node.values
-                        else []
-                    ),
+                    elts=[cast(ast3.expr, i.gen.py_ast[0]) for i in node.values],
                     ctx=cast(ast3.expr_context, node.py_ctx_func()),
                 )
             )
@@ -2597,12 +2312,14 @@ class PyastGenPass(UniPass):
 
         return JacMachineInterface.get_by_llm_call_args(self, node)
 
-    def exit_func_call(self, node: uni.FuncCall) -> None:
-        func = node.target.gen.py_ast[0]
+    def gen_call_args(
+        self, node: uni.FuncCall
+    ) -> tuple[list[ast3.expr], list[ast3.keyword]]:
+        """Generate the arguments for a function call."""
         args = []
         keywords = []
-        if node.params and len(node.params.items) > 0:
-            for x in node.params.items:
+        if node.params:
+            for x in node.params:
                 if isinstance(x, uni.UnaryExpr) and x.op.name == Tok.STAR_POW:
                     keywords.append(
                         self.sync(
@@ -2620,10 +2337,21 @@ class PyastGenPass(UniPass):
                     keywords.append(x.gen.py_ast[0])
                 else:
                     self.ice("Invalid Parameter")
-        if node.genai_call:
+        return args, keywords
+
+    def exit_func_call(self, node: uni.FuncCall) -> None:
+        if node.body_genai_call:
+            node.gen.py_ast = self.gen_llm_call_override(node)
+
+        # TODO: This needs to be changed to only generate parameters no the body.
+        elif node.genai_call:
             by_llm_call_args = self.get_by_llm_call_args(node)
             node.gen.py_ast = [self.sync(self.by_llm_call(**by_llm_call_args))]
+
         else:
+            func = node.target.gen.py_ast[0]
+            args, keywords = self.gen_call_args(node)
+
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
@@ -2723,135 +2451,115 @@ class PyastGenPass(UniPass):
             ]
 
     def exit_edge_ref_trailer(self, node: uni.EdgeRefTrailer) -> None:
-        pynode = node.chain[0].gen.py_ast[0]
-        chomp = [*node.chain]
-        last_edge = None
-        if node.edges_only:
-            for i in node.chain:
-                if isinstance(i, uni.EdgeOpRef):
-                    last_edge = i
-        while len(chomp):
-            cur = chomp[0]
-            chomp = chomp[1:]
-            if len(chomp) == len(node.chain) - 1 and not isinstance(cur, uni.EdgeOpRef):
-                continue
-            next_i = chomp[0] if chomp else None
-            if isinstance(cur, uni.EdgeOpRef) and (
-                not next_i or not isinstance(next_i, uni.EdgeOpRef)
-            ):
-                pynode = self.translate_edge_op_ref(
-                    loc=pynode,
-                    node=cur,
-                    targ=(
-                        next_i.gen.py_ast[0]
-                        if next_i and not isinstance(next_i, uni.FilterCompr)
-                        else None
-                    ),
-                    edges_only=node.edges_only and cur == last_edge,
-                )
-                if next_i and isinstance(next_i, uni.FilterCompr):
-                    pynode = self.sync(
-                        ast3.Call(
-                            func=self.jaclib_obj("filter"),
-                            args=[],
-                            keywords=[
-                                self.sync(
-                                    ast3.keyword(
-                                        arg="items",
-                                        value=cast(ast3.expr, pynode),
-                                    )
-                                ),
-                                self.sync(
-                                    ast3.keyword(
-                                        arg="func",
-                                        value=cast(ast3.expr, next_i.gen.py_ast[0]),
-                                    )
-                                ),
-                            ],
-                        )
-                    )
-                chomp = chomp[1:] if next_i else chomp
-            elif isinstance(cur, uni.EdgeOpRef) and isinstance(next_i, uni.EdgeOpRef):
-                pynode = self.translate_edge_op_ref(
-                    pynode,
-                    cur,
-                    targ=None,
-                    edges_only=node.edges_only and cur == last_edge,
-                )
-            else:
-                raise self.ice("Invalid edge ref trailer")
+        origin = None
+        cur = node.chain[0]
+        chomp = [*node.chain[1:]]
+        from_visit = bool(isinstance(node.parent, uni.VisitStmt))
 
-        node.gen.py_ast = [pynode]
+        if not isinstance(cur, uni.EdgeOpRef):
+            origin = cur.gen.py_ast[0]
+            cur = cast(uni.EdgeOpRef, chomp.pop(0))
 
-    def exit_edge_op_ref(self, node: uni.EdgeOpRef) -> None:
-        loc = self.sync(
-            ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
-            if node.from_walker
-            else ast3.Name(id="self", ctx=ast3.Load())
+        pynode = self.sync(
+            ast3.Call(
+                func=self.jaclib_obj("Path"),
+                args=[cast(ast3.expr, origin or cur.gen.py_ast[0])],
+                keywords=[],
+            )
         )
-        node.gen.py_ast = [loc]
 
-    def translate_edge_op_ref(
-        self,
-        loc: ast3.AST,
-        node: uni.EdgeOpRef,
-        targ: ast3.AST | None,
-        edges_only: bool,
-    ) -> ast3.AST:
-        """Generate ast for edge op ref call."""
-        keywords = [self.sync(ast3.keyword(arg="sources", value=cast(ast3.expr, loc)))]
-
-        if targ:
-            keywords.append(
-                self.sync(ast3.keyword(arg="targets", value=cast(ast3.expr, targ)))
-            )
+        while True:
+            keywords = []
+            if cur.filter_cond:
+                keywords.append(
+                    self.sync(
+                        ast3.keyword(
+                            arg="edge",
+                            value=cast(
+                                ast3.expr, self.sync(cur.filter_cond.gen.py_ast[0])
+                            ),
+                        )
+                    )
+                )
 
-        if node.edge_dir != EdgeDir.OUT:
-            keywords.append(
-                self.sync(
-                    ast3.keyword(
-                        arg="dir",
-                        value=self.sync(
-                            ast3.Attribute(
-                                value=self.jaclib_obj("EdgeDir"),
-                                attr=node.edge_dir.name,
-                                ctx=ast3.Load(),
-                            )
-                        ),
+            if chomp and not isinstance(chomp[0], uni.EdgeOpRef):
+                filt = chomp.pop(0)
+                keywords.append(
+                    self.sync(
+                        ast3.keyword(
+                            arg="node",
+                            value=cast(ast3.expr, self.sync(filt.gen.py_ast[0])),
+                        )
                     )
                 )
+
+            pynode = self.sync(
+                ast3.Call(
+                    func=self.sync(
+                        ast3.Attribute(
+                            value=pynode,
+                            attr=f"_{cur.edge_dir.name.lower()}",
+                            ctx=ast3.Load(),
+                        )
+                    ),
+                    args=[],
+                    keywords=keywords,
+                )
             )
 
-        if node.filter_cond:
-            keywords.append(
-                self.sync(
-                    ast3.keyword(
-                        arg="filter",
-                        value=cast(
-                            ast3.expr, self.sync(node.filter_cond.gen.py_ast[0])
-                        ),
-                    )
+            if chomp:
+                cur = cast(uni.EdgeOpRef, chomp.pop(0))
+            else:
+                break
+
+        if node.edges_only:
+            pynode = self.sync(
+                ast3.Call(
+                    func=self.sync(
+                        ast3.Attribute(
+                            value=pynode,
+                            attr="edge",
+                            ctx=ast3.Load(),
+                        )
+                    ),
+                    args=[],
+                    keywords=[],
                 )
             )
 
-        if edges_only:
-            keywords.append(
-                self.sync(
-                    ast3.keyword(
-                        arg="edges_only",
-                        value=self.sync(ast3.Constant(value=edges_only)),
-                    )
+        if from_visit:
+            pynode = self.sync(
+                ast3.Call(
+                    func=self.sync(
+                        ast3.Attribute(
+                            value=pynode,
+                            attr="visit",
+                            ctx=ast3.Load(),
+                        )
+                    ),
+                    args=[],
+                    keywords=[],
                 )
             )
 
-        return self.sync(
+        pynode = self.sync(
             ast3.Call(
                 func=self.jaclib_obj("refs"),
-                args=[],
-                keywords=keywords,
+                args=[pynode],
+                keywords=[],
             )
         )
 
+        node.gen.py_ast = [pynode]
+
+    def exit_edge_op_ref(self, node: uni.EdgeOpRef) -> None:
+        loc = self.sync(
+            ast3.Name(id=Con.HERE.value, ctx=ast3.Load())
+            if node.from_walker
+            else ast3.Name(id="self", ctx=ast3.Load())
+        )
+        node.gen.py_ast = [loc]
+
     def exit_disconnect_op(self, node: uni.DisconnectOp) -> None:
         node.gen.py_ast = node.edge_spec.gen.py_ast
 
@@ -2949,7 +2657,7 @@ class PyastGenPass(UniPass):
                 ),
                 jac_node=x,
             )
-            for x in (node.compares.items if node.compares else [])
+            for x in node.compares
             if isinstance(x.gen.py_ast[0], ast3.Compare)
             and isinstance(x.gen.py_ast[0].left, ast3.Name)
         )
@@ -2984,7 +2692,7 @@ class PyastGenPass(UniPass):
     def exit_assign_compr(self, node: uni.AssignCompr) -> None:
         keys = []
         values = []
-        for i in node.assigns.items:
+        for i in node.assigns:
             if i.key:  # TODO: add support for **kwargs in assign_compr
                 keys.append(self.sync(ast3.Constant(i.key.sym_name)))
                 values.append(i.value.gen.py_ast[0])
@@ -3099,92 +2807,27 @@ class PyastGenPass(UniPass):
             self.sync(
                 ast3.MatchClass(
                     cls=cast(ast3.expr, node.name.gen.py_ast[0]),
-                    patterns=(
-                        [
-                            cast(ast3.pattern, x.gen.py_ast[0])
-                            for x in node.arg_patterns.items
-                        ]
-                        if node.arg_patterns
-                        else []
-                    ),
-                    kwd_attrs=(
-                        [
-                            x.key.sym_name
-                            for x in node.kw_patterns.items
-                            if isinstance(x.key, uni.NameAtom)
-                        ]
-                        if node.kw_patterns
-                        else []
-                    ),
-                    kwd_patterns=(
-                        [
-                            cast(ast3.pattern, x.value.gen.py_ast[0])
-                            for x in node.kw_patterns.items
-                        ]
-                        if node.kw_patterns
-                        else []
-                    ),
+                    patterns=[
+                        cast(ast3.pattern, x.gen.py_ast[0])
+                        for x in (node.arg_patterns or [])
+                    ],
+                    kwd_attrs=[
+                        x.key.sym_name
+                        for x in (node.kw_patterns or [])
+                        if isinstance(x.key, uni.NameAtom)
+                    ],
+                    kwd_patterns=[
+                        cast(ast3.pattern, x.value.gen.py_ast[0])
+                        for x in (node.kw_patterns or [])
+                    ],
                 )
             )
         ]
 
     def exit_token(self, node: uni.Token) -> None:
-        if node.name == Tok.KW_AND:
-            node.gen.py_ast = [self.sync(ast3.And())]
-        elif node.name == Tok.KW_OR:
-            node.gen.py_ast = [self.sync(ast3.Or())]
-        elif node.name in [Tok.PLUS, Tok.ADD_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Add())]
-        elif node.name in [Tok.BW_AND, Tok.BW_AND_EQ]:
-            node.gen.py_ast = [self.sync(ast3.BitAnd())]
-        elif node.name in [Tok.BW_OR, Tok.BW_OR_EQ]:
-            node.gen.py_ast = [self.sync(ast3.BitOr())]
-        elif node.name in [Tok.BW_XOR, Tok.BW_XOR_EQ]:
-            node.gen.py_ast = [self.sync(ast3.BitXor())]
-        elif node.name in [Tok.DIV, Tok.DIV_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Div())]
-        elif node.name in [Tok.FLOOR_DIV, Tok.FLOOR_DIV_EQ]:
-            node.gen.py_ast = [self.sync(ast3.FloorDiv())]
-        elif node.name in [Tok.LSHIFT, Tok.LSHIFT_EQ]:
-            node.gen.py_ast = [self.sync(ast3.LShift())]
-        elif node.name in [Tok.MOD, Tok.MOD_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Mod())]
-        elif node.name in [Tok.STAR_MUL, Tok.MUL_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Mult())]
-        elif node.name in [Tok.DECOR_OP, Tok.MATMUL_EQ]:
-            node.gen.py_ast = [self.sync(ast3.MatMult())]
-        elif node.name in [Tok.STAR_POW, Tok.STAR_POW_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Pow())]
-        elif node.name in [Tok.RSHIFT, Tok.RSHIFT_EQ]:
-            node.gen.py_ast = [self.sync(ast3.RShift())]
-        elif node.name in [Tok.MINUS, Tok.SUB_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Sub())]
-        elif node.name in [Tok.BW_NOT, Tok.BW_NOT_EQ]:
-            node.gen.py_ast = [self.sync(ast3.Invert())]
-        elif node.name in [Tok.NOT]:
-            node.gen.py_ast = [self.sync(ast3.Not())]
-        elif node.name in [Tok.EQ]:
-            node.gen.py_ast = [self.sync(ast3.NotEq())]
-        elif node.name == Tok.EE:
-            node.gen.py_ast = [self.sync(ast3.Eq())]
-        elif node.name == Tok.GT:
-            node.gen.py_ast = [self.sync(ast3.Gt())]
-        elif node.name == Tok.GTE:
-            node.gen.py_ast = [self.sync(ast3.GtE())]
-        elif node.name == Tok.KW_IN:
-            node.gen.py_ast = [self.sync(ast3.In())]
-        elif node.name == Tok.KW_IS:
-            node.gen.py_ast = [self.sync(ast3.Is())]
-        elif node.name == Tok.KW_ISN:
-            node.gen.py_ast = [self.sync(ast3.IsNot())]
-        elif node.name == Tok.LT:
-            node.gen.py_ast = [self.sync(ast3.Lt())]
-        elif node.name == Tok.LTE:
-            node.gen.py_ast = [self.sync(ast3.LtE())]
-        elif node.name == Tok.NE:
-            node.gen.py_ast = [self.sync(ast3.NotEq())]
-        elif node.name == Tok.KW_NIN:
-            node.gen.py_ast = [self.sync(ast3.NotIn())]
+        op_cls = TOKEN_AST_MAP.get(node.name)
+        if op_cls:
+            node.gen.py_ast = [self.sync(op_cls())]
 
     def exit_name(self, node: uni.Name) -> None:
         node.gen.py_ast = [
@@ -3195,21 +2838,7 @@ class PyastGenPass(UniPass):
         node.gen.py_ast = [self.sync(ast3.Constant(value=float(node.value)))]
 
     def exit_int(self, node: uni.Int) -> None:
-        def handle_node_value(value: str) -> int:
-            if value.startswith(("0x", "0X")):
-                return int(value, 16)
-            elif value.startswith(("0b", "0B")):
-                return int(value, 2)
-            elif value.startswith(("0o", "0O")):
-                return int(value, 8)
-            else:
-                return int(value)
-
-        node.gen.py_ast = [
-            self.sync(
-                ast3.Constant(value=handle_node_value(str(node.value)), kind=None)
-            )
-        ]
+        node.gen.py_ast = [self.sync(ast3.Constant(value=int(node.value, 0)))]
 
     def exit_string(self, node: uni.String) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=node.lit_value))]