jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -1,47 +1,43 @@
-"""Jac Blue pass for Jaseci Ast.
+"""Python AST Generation Pass for the Jac compiler.
 
-At the end of this pass a meta['py_code'] is present with pure python code
-in each node. Module nodes contain the entire module code.
+This pass transforms the Jac AST into equivalent Python AST by:
+
+1. Traversing the Jac AST and generating corresponding Python AST nodes
+2. Handling all Jac language constructs and translating them to Python equivalents:
+   - Classes, functions, and methods
+   - Control flow statements (if/else, loops, try/except)
+   - Data structures (lists, dictionaries, sets)
+   - Special Jac features (walkers, abilities, archetypes)
+   - Data spatial operations (node/edge connections)
+
+3. Managing imports and dependencies between modules
+4. Preserving source location information for error reporting
+5. Generating appropriate Python code for Jac-specific constructs
+
+The output of this pass is a complete Python AST representation that can be
+compiled to Python bytecode or serialized to Python source code.
 """
 
 import ast as ast3
+import copy
 import textwrap
 from dataclasses import dataclass
-from typing import Optional, Sequence, TypeVar, cast
+from typing import List, Optional, Sequence, TypeVar, Union, cast
 
-import jaclang.compiler.absyntree as ast
+import jaclang.compiler.unitree as uni
 from jaclang.compiler.constant import Constants as Con, EdgeDir, Tokens as Tok
-from jaclang.compiler.passes import Pass
+from jaclang.compiler.passes import UniPass
 from jaclang.settings import settings
 
 T = TypeVar("T", bound=ast3.AST)
 
 
-class PyastGenPass(Pass):
+class PyastGenPass(UniPass):
     """Jac blue transpilation to python pass."""
 
-    # TODO: This should live in utils and perhaps a test added using it
-    # @staticmethod
-    # def node_compilable_test(node: ast3.AST) -> None:
-    #     """Convert any AST node to a compilable module node."""
-    #     if isinstance(node, ast3.Module):
-    #         pass
-    #     elif isinstance(node, (ast3.Expr, ast3.stmt)):
-    #         node = ast3.Module(body=[node], type_ignores=[])
-    #     elif isinstance(node, list) and all(isinstance(n, ast3.stmt) for n in node):
-    #         node = ast3.Module(body=node, type_ignores=[])
-    #     else:
-    #         node = ast3.Module(body=[], type_ignores=[])
-    #     try:
-    #         compile(node, "<ast>", "exec")
-    #     except TypeError as e:
-    #         print(ast3.dump(node, indent=2))
-    #         raise e
-    #     except Exception:
-    #         pass
-
     def before_pass(self) -> None:
-        """Initialize pass."""
+        for i in self.ir_in.impl_mod + self.ir_in.test_mod:
+            PyastGenPass(ir_in=i, prog=self.prog)
         self.debuginfo: dict[str, list[str]] = {"jac_mods": []}
         self.already_added: list[str] = []
         self.preamble: list[ast3.AST] = [
@@ -51,57 +47,52 @@ class PyastGenPass(Pass):
                     names=[self.sync(ast3.alias(name="annotations", asname=None))],
                     level=0,
                 ),
-                jac_node=self.ir,
+                jac_node=self.ir_out,
             ),
             (
                 self.sync(
                     ast3.ImportFrom(
-                        module="jaclang",
-                        names=[self.sync(ast3.alias(name="*", asname=None))],
-                        level=0,
-                    ),
-                    jac_node=self.ir,
-                )
-                if settings.pyout_jaclib_import_all
-                else self.sync(
-                    ast3.Import(
+                        module="jaclang.runtimelib.builtin",
                         names=[
                             self.sync(
                                 ast3.alias(
-                                    name="jaclang", asname=settings.pyout_jaclib_alias
+                                    name="*",
+                                    asname=None,
                                 )
                             )
-                        ]
+                        ],
+                        level=0,
                     ),
-                    jac_node=self.ir,
+                    jac_node=self.ir_out,
                 )
             ),
-        ]
-
-        from jaclang.plugin.builtin import __all__ as jac_builtin_funcs
-
-        if not settings.pyout_jaclib_import_all:
-            self.preamble += [
+            (
                 self.sync(
                     ast3.ImportFrom(
                         module="jaclang",
                         names=[
-                            self.sync(ast3.alias(name=func_name))
-                            for func_name in jac_builtin_funcs
+                            self.sync(
+                                ast3.alias(
+                                    name="JacMachineInterface",
+                                    asname=settings.pyout_jaclib_alias,
+                                )
+                            ),
                         ],
                         level=0,
-                    )
+                    ),
+                    jac_node=self.ir_out,
                 )
-            ]
+            ),
+        ]
 
-    def enter_node(self, node: ast.AstNode) -> None:
+    def enter_node(self, node: uni.UniNode) -> None:
         """Enter node."""
         if node.gen.py_ast:
             self.prune()
             return
         super().enter_node(node)
 
-    def exit_node(self, node: ast.AstNode) -> None:
+    def exit_node(self, node: uni.UniNode) -> None:
         """Exit node."""
         super().exit_node(node)
         # for i in node.gen.py_ast:  # Internal validation
@@ -113,8 +104,6 @@ class PyastGenPass(Pass):
 
     def jaclib_obj(self, obj_name: str) -> ast3.Name | ast3.Attribute:
         """Return the object from jaclib as ast node based on the import config."""
-        if settings.pyout_jaclib_import_all:
-            return self.sync(ast3.Name(id=obj_name, ctx=ast3.Load()))
         return self.sync(
             ast3.Attribute(
                 value=self.sync(
@@ -135,11 +124,11 @@ class PyastGenPass(Pass):
                     names=[
                         self.sync(
                             ast3.alias(name="typing"),
-                            jac_node=self.ir,
+                            jac_node=self.ir_out,
                         ),
                     ]
                 ),
-                jac_node=self.ir,
+                jac_node=self.ir_out,
             )
         )
         self.already_added.append(self.needs_typing.__name__)
@@ -158,13 +147,30 @@ class PyastGenPass(Pass):
                     ],
                     level=0,
                 ),
-                jac_node=self.ir,
+                jac_node=self.ir_out,
             )
         )
         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,
+            )
+        )
+        self.already_added.append(self.needs_future.__name__)
+
     def flatten(self, body: list[T | list[T] | None]) -> list[T]:
-        """Flatten ast list."""
         new_body = []
         for i in body:
             if isinstance(i, list):
@@ -174,22 +180,25 @@ class PyastGenPass(Pass):
         return new_body
 
     def sync(
-        self, py_node: T, jac_node: Optional[ast.AstNode] = None, deep: bool = False
+        self, py_node: T, jac_node: Optional[uni.UniNode] = None, deep: bool = False
     ) -> T:
         """Sync ast locations."""
         if not jac_node:
             jac_node = self.cur_node
         for i in ast3.walk(py_node) if deep else [py_node]:
+            # TODO:here we are type ignore to hack the mypy bcz
+            # python AST dosen't have lineno, col_offset, end_lineno, end_col_offset attributes.
+            # we need to discuss with @marsninja
             if isinstance(i, ast3.AST):
-                i.lineno = jac_node.loc.first_line
-                i.col_offset = jac_node.loc.col_start
-                i.end_lineno = (
+                i.lineno = jac_node.loc.first_line  # type:ignore[attr-defined]
+                i.col_offset = jac_node.loc.col_start  # type:ignore[attr-defined]
+                i.end_lineno = (  # type:ignore[attr-defined]
                     jac_node.loc.last_line
                     if jac_node.loc.last_line
                     and (jac_node.loc.last_line > jac_node.loc.first_line)
                     else jac_node.loc.first_line
                 )
-                i.end_col_offset = (
+                i.end_col_offset = (  # type:ignore[attr-defined]
                     jac_node.loc.col_end
                     if jac_node.loc.col_end
                     and (jac_node.loc.col_end > jac_node.loc.col_start)
@@ -215,45 +224,44 @@ class PyastGenPass(Pass):
 
     def resolve_stmt_block(
         self,
-        node: (
-            ast.SubNodeList[ast.CodeBlockStmt]
-            | ast.SubNodeList[ast.ArchBlockStmt]
-            | ast.SubNodeList[ast.EnumBlockStmt]
-            | None
-        ),
-        doc: Optional[ast.String] = 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, ast.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, ast.SubNodeList) and not valid_stmts
+            [self.sync(ast3.Pass())]
+            if isinstance(node, Sequence) and not valid_stmts
             else (
                 self.flatten(
                     [
                         x.gen.py_ast
                         for x in valid_stmts
-                        if not isinstance(x, ast.AstImplOnlyNode)
+                        if not isinstance(x, uni.ImplDef)
                     ]
                 )
-                if node and isinstance(node.gen.py_ast, list)
+                if node is not None
                 else []
             )
         )
         if doc:
-            ret = [self.sync(ast3.Expr(value=doc.gen.py_ast[0]), jac_node=doc), *ret]
+            ret = [
+                self.sync(
+                    ast3.Expr(value=cast(ast3.expr, doc.gen.py_ast[0])), jac_node=doc
+                ),
+                *ret,
+            ]
         return ret
 
-    def sync_many(self, py_nodes: list[T], jac_node: ast.AstNode) -> list[T]:
+    def sync_many(self, py_nodes: list[T], jac_node: uni.UniNode) -> list[T]:
         """Sync ast locations."""
         for py_node in py_nodes:
             self.sync(py_node, jac_node)
         return py_nodes
 
     def list_to_attrib(
-        self, attribute_list: list[str], sync_node_list: Sequence[ast.AstNode]
+        self, attribute_list: list[str], sync_node_list: Sequence[uni.UniNode]
     ) -> ast3.AST:
         """Convert list to attribute."""
         attr_node: ast3.Name | ast3.Attribute = self.sync(
@@ -270,31 +278,12 @@ class PyastGenPass(Pass):
             )
         return attr_node
 
-    def exit_sub_tag(self, node: ast.SubTag[ast.T]) -> None:
-        """Sub objects.
-
-        tag: T,
-        """
+    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: ast.SubNodeList[ast.T]) -> None:
-        """Sub objects.
-
-        items: Sequence[T],
-        """
-        node.gen.py_ast = self.flatten([i.gen.py_ast for i in node.items])
-
-    def exit_module(self, node: ast.Module) -> None:
-        """Sub objects.
-
-        name: str,
-        source: JacSource,
-        doc: Optional[String],
-        body: Sequence[ElementStmt],
-        is_imported: bool,
-        """
-        clean_body = [i for i in node.body if not isinstance(i, ast.AstImplOnlyNode)]
-        pre_body: list[ast.AstNode] = []
+    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] = []
         for pbody in node.impl_mod:
             pre_body = [*pre_body, *pbody.body]
         pre_body = [*pre_body, *clean_body]
@@ -302,7 +291,10 @@ class PyastGenPass(Pass):
             pre_body = [*pre_body, *pbody.body]
         body = (
             [
-                self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc),
+                self.sync(
+                    ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                    jac_node=node.doc,
+                ),
                 *self.preamble,
                 *[x.gen.py_ast for x in pre_body],
             ]
@@ -325,32 +317,23 @@ class PyastGenPass(Pass):
         ]
         node.gen.py = ast3.unparse(node.gen.py_ast[0])
 
-    def exit_global_vars(self, node: ast.GlobalVars) -> None:
-        """Sub objects.
-
-        access: Optional[SubTag[Token]],
-        assignments: SubNodeList[Assignment],
-        is_frozen: bool,
-        doc: Optional[String],
-        """
+    def exit_global_vars(self, node: uni.GlobalVars) -> None:
         if node.doc:
-            doc = self.sync(ast3.Expr(value=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
+            doc = self.sync(
+                ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                jac_node=node.doc,
+            )
+            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
-
-    def exit_test(self, node: ast.Test) -> None:
-        """Sub objects.
+            node.gen.py_ast = self.flatten([a.gen.py_ast for a in node.assignments])
 
-        name: Name | Token,
-        body: SubNodeList[CodeBlockStmt],
-        doc: Optional[String],
-        """
+    def exit_test(self, node: uni.Test) -> None:
         test_name = node.name.sym_name
         func = self.sync(
             ast3.FunctionDef(
@@ -365,36 +348,33 @@ class PyastGenPass(Pass):
                         ],
                         kwonlyargs=[],
                         vararg=None,
-                        kwargs=None,
+                        kwarg=None,
                         kw_defaults=[],
                         defaults=[],
                     )
                 ),
-                body=self.resolve_stmt_block(node.body, doc=node.doc),
+                body=[
+                    cast(ast3.stmt, stmt)
+                    for stmt in self.resolve_stmt_block(node.body, doc=node.doc)
+                ],
                 decorator_list=[self.jaclib_obj("jac_test")],
                 returns=self.sync(ast3.Constant(value=None)),
                 type_comment=None,
                 type_params=[],
             ),
         )
-        if node.loc.mod_path != self.ir.loc.mod_path:
+        if node.loc.mod_path.endswith(".test.jac"):
             func.decorator_list.append(
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=self.jaclib_obj("Jac"),
-                                attr="impl_patch_filename",
-                                ctx=ast3.Load(),
-                            )
-                        ),
+                        func=self.jaclib_obj("impl_patch_filename"),
                         args=[],
                         keywords=[
                             self.sync(
                                 ast3.keyword(
                                     arg="file_loc",
                                     value=self.sync(
-                                        ast3.Constant(value=node.body.loc.mod_path)
+                                        ast3.Constant(value=node.loc.mod_path)
                                     ),
                                 )
                             ),
@@ -404,13 +384,7 @@ class PyastGenPass(Pass):
             )
         node.gen.py_ast = [func]
 
-    def exit_module_code(self, node: ast.ModuleCode) -> None:
-        """Sub objects.
-
-        name: Optional[SubTag[Name]],
-        body: SubNodeList[CodeBlockStmt],
-        doc: Optional[String],
-        """
+    def exit_module_code(self, node: uni.ModuleCode) -> None:
         node.gen.py_ast = self.resolve_stmt_block(node.body, doc=node.doc)
         if node.name:
             node.gen.py_ast = [
@@ -423,26 +397,22 @@ class PyastGenPass(Pass):
                                 ),
                                 ops=[self.sync(ast3.Eq())],
                                 comparators=[
-                                    self.sync(
-                                        ast3.Constant(value=node.name.tag.sym_name)
-                                    )
+                                    self.sync(ast3.Constant(value=node.name.sym_name))
                                 ],
                             )
                         ),
-                        body=node.gen.py_ast,
+                        body=[cast(ast3.stmt, i) for i in node.gen.py_ast],
                         orelse=[],
                     )
                 )
             ]
 
-    def exit_py_inline_code(self, node: ast.PyInlineCode) -> None:
-        """Sub objects.
-
-        code: Token,
-        doc: Optional[String],
-        """
+    def exit_py_inline_code(self, node: uni.PyInlineCode) -> None:
         if node.doc:
-            doc = self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=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):
                 node.gen.py_ast = self.pyinline_sync(
                     [doc, *ast3.parse(node.code.value).body]
@@ -455,37 +425,36 @@ class PyastGenPass(Pass):
                 [*ast3.parse(textwrap.dedent(node.code.value)).body]
             )
 
-    def exit_import(self, node: ast.Import) -> None:
-        """Sub objects.
-
-        hint: SubTag[Name],
-        paths: list[ModulePath],
-        alias: Optional[Name],
-        items: Optional[SubNodeList[ModuleItem]],
-        is_absorb: bool,
-        doc: Optional[String],
-        sub_module: Optional[Module],
-        """
+    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, ast.ModuleItem):
+            for item in node.items:
+                if isinstance(item, uni.ModuleItem):
                     imp_from[item.name.sym_name] = (
                         item.alias.sym_name if item.alias else None
                     )
-                elif isinstance(item, ast.ModulePath):
+                elif isinstance(item, uni.ModulePath):
                     path_alias[item.dot_path_str] = (
                         item.alias.sym_name if item.alias else None
                     )
 
-        item_keys = []
-        item_values = []
+        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
         py_nodes: list[ast3.AST] = []
         typecheck_nodes: list[ast3.AST] = []
@@ -493,7 +462,10 @@ class PyastGenPass(Pass):
 
         if node.doc:
             py_nodes.append(
-                self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
+                self.sync(
+                    ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                    jac_node=node.doc,
+                )
             )
 
         for path, alias in path_alias.items():
@@ -505,6 +477,50 @@ class PyastGenPass(Pass):
             #     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(
@@ -513,7 +529,8 @@ class PyastGenPass(Pass):
                                 self.sync(
                                     ast3.Tuple(
                                         elts=(
-                                            [
+                                            item_names
+                                            or [
                                                 self.sync(
                                                     ast3.Name(
                                                         id=path_named_value,
@@ -521,21 +538,6 @@ class PyastGenPass(Pass):
                                                     )
                                                 )
                                             ]
-                                            if not len(item_keys)
-                                            else []
-                                            + [
-                                                self.sync(
-                                                    ast3.Name(
-                                                        id=(
-                                                            v.value
-                                                            if v.value
-                                                            else k.value
-                                                        ),
-                                                        ctx=ast3.Store(),
-                                                    )
-                                                )
-                                                for k, v in zip(item_keys, item_values)
-                                            ]
                                         ),
                                         ctx=ast3.Store(),
                                     )
@@ -544,65 +546,9 @@ class PyastGenPass(Pass):
                         ),
                         value=self.sync(
                             ast3.Call(
-                                func=self.jaclib_obj("jac_import"),
-                                args=[
-                                    self.sync(ast3.Constant(value=path)),
-                                ]
-                                + (
-                                    [
-                                        self.sync(
-                                            ast3.Constant(value="py"),
-                                            node.hint,
-                                        )
-                                    ]
-                                    if node.is_py
-                                    else []
-                                ),
-                                keywords=(
-                                    [
-                                        self.sync(
-                                            ast3.keyword(
-                                                arg="absorb",
-                                                value=self.sync(
-                                                    ast3.Constant(value=node.is_absorb),
-                                                ),
-                                            )
-                                        ),
-                                    ]
-                                    if node.is_absorb
-                                    else []
-                                )
-                                + (
-                                    [
-                                        self.sync(
-                                            ast3.keyword(
-                                                arg="alias",
-                                                value=self.sync(
-                                                    ast3.Constant(value=alias),
-                                                ),
-                                            )
-                                        ),
-                                    ]
-                                    if alias
-                                    else []
-                                )
-                                + (
-                                    [
-                                        self.sync(
-                                            ast3.keyword(
-                                                arg="items",
-                                                value=self.sync(
-                                                    ast3.Dict(
-                                                        keys=item_keys,
-                                                        values=item_values,
-                                                    ),
-                                                ),
-                                            )
-                                        ),
-                                    ]
-                                    if len(item_keys)
-                                    else []
-                                ),
+                                func=self.jaclib_obj("py_jac_import"),
+                                args=args,
+                                keywords=keywords,
                             )
                         ),
                     ),
@@ -756,8 +702,8 @@ class PyastGenPass(Pass):
                 )
             )
         if node.is_absorb:
-            source = node.items.items[0]
-            if not isinstance(source, ast.ModulePath):
+            source = node.items[0]
+            if not isinstance(source, uni.ModulePath):
                 raise self.ice()
             typecheck_nodes.append(
                 self.sync(
@@ -770,7 +716,17 @@ class PyastGenPass(Pass):
                 )
             )
         elif not node.from_loc:
-            typecheck_nodes.append(self.sync(ast3.Import(names=node.items.gen.py_ast)))
+            typecheck_nodes.append(
+                self.sync(
+                    ast3.Import(
+                        names=[
+                            cast(ast3.alias, x)
+                            for item in node.items
+                            for x in item.gen.py_ast
+                        ]
+                    )
+                )
+            )
         else:
             typecheck_nodes.append(
                 self.sync(
@@ -780,36 +736,27 @@ class PyastGenPass(Pass):
                             if node.from_loc
                             else None
                         ),
-                        names=node.items.gen.py_ast,
+                        names=[
+                            cast(ast3.alias, i)
+                            for item in node.items
+                            for i in item.gen.py_ast
+                        ],
                         level=0,
                     )
                 )
             )
-        self.needs_typing()
         py_nodes.append(
             self.sync(
                 ast3.If(
-                    test=self.sync(
-                        ast3.Attribute(
-                            value=self.sync(ast3.Name(id="typing", ctx=ast3.Load())),
-                            attr="TYPE_CHECKING",
-                            ctx=ast3.Load(),
-                        )
-                    ),
-                    body=typecheck_nodes,
-                    orelse=runtime_nodes,
+                    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: ast.ModulePath) -> None:
-        """Sub objects.
-
-        path: Sequence[Token],
-        alias: Optional[Name],
-        path_str: str,
-        """
+    def exit_module_path(self, node: uni.ModulePath) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.alias(
@@ -819,12 +766,7 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_module_item(self, node: ast.ModuleItem) -> None:
-        """Sub objects.
-
-        name: Name,
-        alias: Optional[Name],
-        """
+    def exit_module_item(self, node: uni.ModuleItem) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.alias(
@@ -834,172 +776,127 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def enter_architype(self, node: ast.Architype) -> None:
-        """Sub objects.
-
-        name: Name,
-        arch_type: Token,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[SubNodeList[AtomType]],
-        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-        if isinstance(node.body, ast.AstImplOnlyNode):
+    def enter_archetype(self, node: uni.Archetype) -> None:
+        if isinstance(node.body, uni.ImplDef):
             self.traverse(node.body)
 
-    def exit_architype(self, node: ast.Architype) -> None:
-        """Sub objects.
+    def exit_archetype(self, node: uni.Archetype) -> None:
+        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,
+                self.sync(
+                    ast3.Assign(
+                        targets=[
+                            self.sync(ast3.Name(id="__jac_async__", ctx=ast3.Store()))
+                        ],
+                        value=self.sync(ast3.Constant(value=node.is_async)),
+                    )
+                ),
+            )
 
-        name: Name,
-        arch_type: Token,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[SubNodeList[AtomType]],
-        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-        body = self.resolve_stmt_block(
-            node.body.body if isinstance(node.body, ast.ArchDef) else node.body,
-            doc=node.doc,
-        )
         decorators = (
-            node.decorators.gen.py_ast
-            if isinstance(node.decorators, ast.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()))
+
         node.gen.py_ast = [
             self.sync(
                 ast3.ClassDef(
                     name=node.name.sym_name,
-                    bases=base_classes,
+                    bases=[cast(ast3.expr, i) for i in base_classes],
                     keywords=[],
-                    body=body,
-                    decorator_list=decorators,
+                    body=[cast(ast3.stmt, i) for i in body],
+                    decorator_list=[cast(ast3.expr, i) for i in decorators],
                     type_params=[],
                 )
             )
         ]
 
-    def exit_arch_def(self, node: ast.ArchDef) -> None:
-        """Sub objects.
-
-        target: ArchRefChain,
-        body: SubNodeList[ArchBlockStmt],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-
-    def enter_enum(self, node: ast.Enum) -> None:
-        """Sub objects.
-
-        name: Name,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[SubNodeList[AtomType]],
-        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-        if isinstance(node.body, ast.AstImplOnlyNode):
+    def enter_enum(self, node: uni.Enum) -> None:
+        if isinstance(node.body, uni.ImplDef):
             self.traverse(node.body)
 
-    def exit_enum(self, node: ast.Enum) -> None:
-        """Sub objects.
-
-        name: Name,
-        access: Optional[SubTag[Token]],
-        base_classes: Optional[Optional[SubNodeList[AtomType]]],
-        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
+    def exit_enum(self, node: uni.Enum) -> None:
         self.needs_enum()
-        body = self.resolve_stmt_block(
-            node.body.body if isinstance(node.body, ast.EnumDef) else node.body,
-            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, ast.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(
                     name=node.name.sym_name,
-                    bases=base_classes,
+                    bases=[cast(ast3.expr, i) for i in base_classes],
                     keywords=[],
-                    body=body,
-                    decorator_list=decorators,
+                    body=[cast(ast3.stmt, i) for i in body],
+                    decorator_list=[cast(ast3.expr, i) for i in decorators],
                     type_params=[],
                 )
             )
         ]
 
-    def exit_enum_def(self, node: ast.EnumDef) -> None:
-        """Sub objects.
-
-        target: ArchRefChain,
-        body: SubNodeList[EnumBlockStmt],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-
-    def enter_ability(self, node: ast.Ability) -> None:
-        """Sub objects.
-
-        name_ref: NameType,
-        is_func: bool,
-        is_async: bool,
-        is_static: bool,
-        is_abstract: bool,
-        access: Optional[SubTag[Token]],
-        signature: Optional[FuncSignature | ExprType | EventSignature],
-        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-        if isinstance(node.body, ast.AstImplOnlyNode):
+    def enter_ability(self, node: uni.Ability) -> None:
+        if isinstance(node.body, uni.ImplDef):
             self.traverse(node.body)
 
-    def gen_llm_body(self, node: ast.Ability) -> list[ast3.AST]:
+    def gen_llm_body(self, node: uni.Ability) -> list[ast3.AST]:
         """Generate the by LLM body."""
         # to Avoid circular import
-        from jaclang.plugin.feature import JacFeature
-
-        return JacFeature.gen_llm_body(self, node)
+        from jaclang.runtimelib.machine import JacMachineInterface
 
-    def exit_ability(self, node: ast.Ability) -> None:
-        """Sub objects.
+        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
 
-        name_ref: NameType,
-        is_func: bool,
-        is_async: bool,
-        is_static: bool,
-        is_abstract: bool,
-        access: Optional[SubTag[Token]],
-        signature: Optional[FuncSignature | ExprType | EventSignature],
-        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
+    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, ast.FuncCall)
+            if isinstance(node.body, uni.FuncCall)
+            or (
+                isinstance(node.body, uni.ImplDef)
+                and isinstance(node.body.body, uni.FuncCall)
+            )
             else (
                 [
                     self.sync(
-                        ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc
+                        ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                        jac_node=node.doc,
                     ),
                     self.sync(ast3.Pass(), node.body),
                 ]
@@ -1010,8 +907,13 @@ class PyastGenPass(Pass):
                     else self.resolve_stmt_block(
                         (
                             node.body.body
-                            if isinstance(node.body, ast.AbilityDef)
-                            else node.body
+                            if isinstance(node.body, uni.ImplDef)
+                            and not isinstance(node.body.body, uni.FuncCall)
+                            else (
+                                node.body
+                                if not isinstance(node.body, uni.FuncCall)
+                                else None
+                            )
                         ),
                         doc=node.doc,
                     )
@@ -1019,57 +921,75 @@ class PyastGenPass(Pass):
             )
         )
         if node.is_abstract and node.body:
-            self.error(
+            self.log_error(
                 f"Abstract ability {node.sym_name} should not have a body.",
                 node,
             )
-        decorator_list = node.decorators.gen.py_ast if node.decorators else []
-        if isinstance(node.signature, ast.EventSignature):
+        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(
-                    "with_entry"
-                    if node.signature.event.name == Tok.KW_ENTRY
-                    else "with_exit"
+                    "entry" if node.signature.event.name == Tok.KW_ENTRY else "exit"
                 )
             )
 
-        if isinstance(node.body, ast.AstImplOnlyNode):
+        if isinstance(node.body, uni.ImplDef):
             decorator_list.append(
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                self.jaclib_obj("Jac"),
-                                attr="impl_patch_filename",
-                                ctx=ast3.Load(),
-                            ),
-                        ),
+                        func=self.jaclib_obj("impl_patch_filename"),
                         args=[self.sync(ast3.Constant(value=node.body.loc.mod_path))],
                         keywords=[],
                     )
                 )
             )
         if node.is_abstract:
-            decorator_list.append(self.jaclib_obj("abstract"))
+            decorator_list.append(
+                self.sync(ast3.Name(id="abstractmethod", ctx=ast3.Load()))
+            )
         if node.is_override:
-            decorator_list.append(self.jaclib_obj("override"))
+            decorator_list.append(self.sync(ast3.Name(id="override", ctx=ast3.Load())))
         if node.is_static:
             decorator_list.insert(
                 0, self.sync(ast3.Name(id="staticmethod", ctx=ast3.Load()))
             )
-        if not body and not isinstance(node.body, ast.FuncCall):
-            self.error("Ability has no body. Perhaps an impl must be imported.", node)
+        if not body and not isinstance(node.body, uni.FuncCall):
+            self.log_error(
+                "Ability has no body. Perhaps an impl must be imported.", node
+            )
             body = [self.sync(ast3.Pass(), node)]
 
         node.gen.py_ast = [
             self.sync(
                 func_type(
                     name=node.name_ref.sym_name,
-                    args=node.signature.gen.py_ast[0] if node.signature else [],
-                    body=body,
-                    decorator_list=decorator_list,
+                    args=(
+                        cast(ast3.arguments, node.signature.gen.py_ast[0])
+                        if node.signature
+                        else self.sync(
+                            ast3.arguments(
+                                posonlyargs=[],
+                                args=(
+                                    [self.sync(ast3.arg(arg="self", annotation=None))]
+                                    if node.is_method
+                                    else []
+                                ),
+                                vararg=None,
+                                kwonlyargs=[],
+                                kw_defaults=[],
+                                kwarg=None,
+                                defaults=[],
+                            )
+                        )
+                    ),
+                    body=[cast(ast3.stmt, i) for i in body],
+                    decorator_list=[cast(ast3.expr, i) for i in decorator_list],
                     returns=(
-                        node.signature.return_type.gen.py_ast[0]
+                        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))
                     ),
@@ -1078,72 +998,55 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_ability_def(self, node: ast.AbilityDef) -> None:
-        """Sub objects.
-
-        target: ArchRefChain,
-        signature: FuncSignature | EventSignature,
-        body: SubNodeList[CodeBlockStmt],
-        doc: Optional[String],
-        decorators: Optional[SubNodeList[ExprType]],
-        """
-
-    def exit_func_signature(self, node: ast.FuncSignature) -> None:
-        """Sub objects.
+    def exit_impl_def(self, node: uni.ImplDef) -> None:
+        pass
 
-        params: Optional[SubNodeList[ParamVar]],
-        return_type: Optional[SubTag[ExprType]],
-        """
+    def exit_func_signature(self, node: uni.FuncSignature) -> None:
         params = (
             [self.sync(ast3.arg(arg="self", annotation=None))]
-            if node.is_method and not node.is_static and not node.is_in_py_class
+            if (abl := node.find_parent_of_type(uni.Ability))
+            and abl.is_method
+            and not node.is_static
+            and not node.is_in_py_class
             else []
         )
         vararg = None
         kwarg = None
-        if isinstance(node.params, ast.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(
                     posonlyargs=[],
-                    args=params,
+                    args=[cast(ast3.arg, param) for param in params],
                     kwonlyargs=[],
-                    vararg=vararg,
-                    kwarg=kwarg,
+                    vararg=cast(ast3.arg, vararg) if vararg else None,
+                    kwarg=cast(ast3.arg, kwarg) if kwarg else None,
                     kw_defaults=[],
-                    defaults=defaults,
+                    defaults=[cast(ast3.expr, default) for default in defaults],
                 )
             )
         ]
 
-    def exit_event_signature(self, node: ast.EventSignature) -> None:
-        """Sub objects.
-
-        event: Token,
-        arch_tag_info: Optional[ExprType],
-        return_type: Optional[SubTag[ExprType]],
-        """
-        here = self.sync(
+    def exit_event_signature(self, node: uni.EventSignature) -> None:
+        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=(
-                    node.arch_tag_info.gen.py_ast[0] if node.arch_tag_info else None
+                    cast(ast3.expr, node.arch_tag_info.gen.py_ast[0])
+                    if node.arch_tag_info
+                    else None
                 ),
             ),
             jac_node=node.arch_tag_info if node.arch_tag_info else node,
@@ -1153,287 +1056,208 @@ class PyastGenPass(Pass):
                 ast3.arguments(
                     posonlyargs=[],
                     args=(
-                        [self.sync(ast3.arg(arg="self", annotation=None)), here]
-                        if node.is_method
-                        else [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 [arch_arg]
                     ),
                     kwonlyargs=[],
                     vararg=None,
-                    kwargs=None,
+                    kwarg=None,
                     kw_defaults=[],
                     defaults=[],
                 )
             )
         ]
 
-    def exit_arch_ref(self, node: ast.ArchRef) -> None:
-        """Sub objects.
-
-        name_ref: NameType,
-        arch: Token,
-        """
-        if node.arch_type.name == Tok.TYPE_OP:
-            if (
-                isinstance(node.arch_name, ast.SpecialVarRef)
-                and node.arch_name.orig.name == Tok.KW_ROOT
-            ):
-                node.gen.py_ast = [self.jaclib_obj("Root")]
-            else:
-                self.needs_typing()
-                node.gen.py_ast = [
-                    self.sync(
-                        ast3.Attribute(
-                            value=self.sync(ast3.Name(id="typing", ctx=ast3.Load())),
-                            attr=node.arch_name.sym_name,
-                            ctx=ast3.Load(),
-                        )
-                    )
-                ]
+    def exit_type_ref(self, node: uni.TypeRef) -> None:
+        if (
+            isinstance(node.target, uni.SpecialVarRef)
+            and node.target.orig.name == Tok.KW_ROOT
+        ):
+            node.gen.py_ast = [self.jaclib_obj("Root")]
         else:
-            node.gen.py_ast = node.arch_name.gen.py_ast
-
-    def exit_arch_ref_chain(self, node: ast.ArchRefChain) -> None:
-        """Sub objects.
-
-        archs: Sequence[ArchRef],
-        """
-
-        def make_attr_chain(arch: list[ast.ArchRef]) -> list[ast3.AST]:
-            """Make attr chain."""
-            if len(arch) == 0:
-                return []
-            if len(arch) == 1 and isinstance(arch[0].gen.py_ast, ast3.AST):
-                return arch[0].gen.py_ast
-            cur = arch[-1]
-            attr = self.sync(
-                ast3.Attribute(
-                    value=make_attr_chain(arch[:-1]),
-                    attr=cur.arch_name.sym_name,
-                    ctx=ast3.Load(),
-                ),
-                jac_node=cur,
-            )
-            return [attr]
-
-        node.gen.py_ast = make_attr_chain(node.archs)
-
-    def exit_param_var(self, node: ast.ParamVar) -> None:
-        """Sub objects.
+            self.needs_typing()
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Attribute(
+                        value=self.sync(ast3.Name(id="typing", ctx=ast3.Load())),
+                        attr=node.target.sym_name,
+                        ctx=ast3.Load(),
+                    )
+                )
+            ]
 
-        name: Name,
-        unpack: Optional[Token],
-        type_tag: SubTag[ExprType],
-        value: Optional[ExprType],
-        """
+    def exit_param_var(self, node: uni.ParamVar) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.arg(
                     arg=node.name.sym_name,
-                    annotation=node.type_tag.gen.py_ast[0] if node.type_tag else None,
+                    annotation=(
+                        cast(ast3.expr, node.type_tag.gen.py_ast[0])
+                        if node.type_tag
+                        else None
+                    ),
                 )
             )
         ]
 
-    def exit_arch_has(self, node: ast.ArchHas) -> None:
-        """Sub objects.
-
-        is_static: bool,
-        access: Optional[SubTag[Token]],
-        vars: SubNodeList[HasVar],
-        is_frozen: bool,
-        doc: Optional[String],
-        """
+    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=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
+            doc = self.sync(
+                ast3.Expr(value=cast(ast3.expr, node.doc.gen.py_ast[0])),
+                jac_node=node.doc,
+            )
+            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: ast.HasVar) -> None:
-        """Sub objects.
-
-        name: Name,
-        type_tag: SubTag[Expr],
-        value: Optional[Expr],
-        semstr: Optional[String] = None,
-        """
+    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, ast.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, ast.Architype)
-                    and node.parent.parent.parent.arch_type.name == Tok.KW_CLASS
-                )
-                or (
-                    node.parent.parent.parent.parent
-                    and isinstance(node.parent.parent.parent.parent, ast.Architype)
-                    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
         )
-        if is_static_var:
+
+        value = None
+
+        if is_in_class:
+            value = cast(ast3.expr, node.value.gen.py_ast[0]) if node.value else None
+        elif is_static_var:
             annotation = self.sync(
                 ast3.Subscript(
-                    value=self.jaclib_obj("static"),
-                    slice=annotation,
+                    value=self.sync(ast3.Name(id="ClassVar", ctx=ast3.Load())),
+                    slice=cast(ast3.expr, annotation),
                     ctx=ast3.Load(),
                 )
             )
-
-        default_field_fn_name = "field"
-        node.gen.py_ast = [
-            (
-                self.sync(
-                    ast3.AnnAssign(
-                        target=node.name.gen.py_ast[0],
-                        annotation=annotation,
-                        value=(
+            value = cast(ast3.expr, node.value.gen.py_ast[0]) if node.value else None
+        elif node.defer:
+            value = self.sync(
+                ast3.Call(
+                    func=self.jaclib_obj("field"),
+                    args=[],
+                    keywords=[
+                        self.sync(
+                            ast3.keyword(
+                                arg="init",
+                                value=self.sync(ast3.Constant(value=False)),
+                            )
+                        )
+                    ],
+                ),
+            )
+        elif node.value:
+            if isinstance(node.value.gen.py_ast[0], ast3.Constant):
+                value = cast(ast3.expr, node.value.gen.py_ast[0])
+            else:
+                value = self.sync(
+                    ast3.Call(
+                        func=self.jaclib_obj("field"),
+                        args=[],
+                        keywords=[
                             self.sync(
-                                ast3.Call(
-                                    func=self.jaclib_obj(default_field_fn_name),
-                                    args=(
-                                        [node.value.gen.py_ast[0]]
-                                        if isinstance(
-                                            node.value.gen.py_ast[0], ast3.Constant
-                                        )
-                                        else []
-                                    ),
-                                    keywords=(
-                                        [
-                                            self.sync(
-                                                ast3.keyword(
-                                                    arg="gen",
-                                                    value=self.sync(
-                                                        ast3.Lambda(
-                                                            args=self.sync(
-                                                                ast3.arguments(
-                                                                    posonlyargs=[],
-                                                                    args=[],
-                                                                    kwonlyargs=[],
-                                                                    vararg=None,
-                                                                    kwargs=None,
-                                                                    kw_defaults=[],
-                                                                    defaults=[],
-                                                                )
-                                                            ),
-                                                            body=node.value.gen.py_ast[
-                                                                0
-                                                            ],
-                                                        )
-                                                    ),
+                                ast3.keyword(
+                                    arg="factory",
+                                    value=self.sync(
+                                        ast3.Lambda(
+                                            args=self.sync(
+                                                ast3.arguments(
+                                                    posonlyargs=[],
+                                                    args=[],
+                                                    kwonlyargs=[],
+                                                    vararg=None,
+                                                    kwarg=None,
+                                                    kw_defaults=[],
+                                                    defaults=[],
                                                 )
-                                            )
-                                        ]
-                                        if not isinstance(
-                                            node.value.gen.py_ast[0], ast3.Constant
+                                            ),
+                                            body=cast(
+                                                ast3.expr,
+                                                node.value.gen.py_ast[0],
+                                            ),
                                         )
-                                        else []
                                     ),
-                                )
-                            )
-                            if node.value
-                            and not (is_static_var or is_in_class or node.defer)
-                            else (
-                                self.sync(
-                                    ast3.Call(
-                                        func=self.jaclib_obj(default_field_fn_name),
-                                        args=[],
-                                        keywords=[
-                                            self.sync(
-                                                ast3.keyword(
-                                                    arg="postinit",
-                                                    value=self.sync(
-                                                        ast3.Constant(value=True)
-                                                    ),
-                                                )
-                                            )
-                                        ],
-                                    )
-                                )
-                                if node.defer and not (is_static_var or is_in_class)
-                                else node.value.gen.py_ast[0] if node.value else None
+                                ),
                             )
-                        ),
-                        simple=int(isinstance(node.name, ast.Name)),
-                    )
+                        ],
+                    ),
+                )
+
+        node.gen.py_ast = [
+            self.sync(
+                ast3.AnnAssign(
+                    target=cast(
+                        ast3.Name | ast3.Attribute | ast3.Subscript,
+                        node.name.gen.py_ast[0],
+                    ),
+                    annotation=(
+                        cast(ast3.expr, annotation)
+                        if annotation
+                        else ast3.Constant(value=None)
+                    ),
+                    value=value,
+                    simple=int(isinstance(node.name, uni.Name)),
                 )
             )
         ]
 
-    def exit_typed_ctx_block(self, node: ast.TypedCtxBlock) -> None:
-        """Sub objects.
-
-        type_ctx: ExprType,
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_typed_ctx_block(self, node: uni.TypedCtxBlock) -> None:
         # TODO: Come back
+        pass
 
-    def exit_if_stmt(self, node: ast.IfStmt) -> None:
-        """Sub objects.
-
-        condition: ExprType,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: Optional[ElseStmt | ElseIf],
-        """
+    def exit_if_stmt(self, node: uni.IfStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.If(
-                    test=node.condition.gen.py_ast[0],
-                    body=self.resolve_stmt_block(node.body),
-                    orelse=node.else_body.gen.py_ast if node.else_body else [],
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    body=cast(list[ast3.stmt], self.resolve_stmt_block(node.body)),
+                    orelse=(
+                        cast(list[ast3.stmt], node.else_body.gen.py_ast)
+                        if node.else_body
+                        else []
+                    ),
                 )
             )
         ]
 
-    def exit_else_if(self, node: ast.ElseIf) -> None:
-        """Sub objects.
-
-        condition: ExprType,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: Optional[ElseStmt | ElseIf],
-        """
+    def exit_else_if(self, node: uni.ElseIf) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.If(
-                    test=node.condition.gen.py_ast[0],
-                    body=self.resolve_stmt_block(node.body),
-                    orelse=node.else_body.gen.py_ast if node.else_body else [],
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    body=cast(list[ast3.stmt], self.resolve_stmt_block(node.body)),
+                    orelse=(
+                        cast(list[ast3.stmt], node.else_body.gen.py_ast)
+                        if node.else_body
+                        else []
+                    ),
                 )
             )
         ]
 
-    def exit_else_stmt(self, node: ast.ElseStmt) -> None:
-        """Sub objects.
-
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_else_stmt(self, node: uni.ElseStmt) -> None:
         node.gen.py_ast = self.resolve_stmt_block(node.body)
 
-    def exit_expr_stmt(self, node: ast.ExprStmt) -> None:
-        """Sub objects.
-
-        expr: ExprType,
-        in_fstring: bool,
-        """
+    def exit_expr_stmt(self, node: uni.ExprStmt) -> None:
         node.gen.py_ast = [
             (
-                self.sync(ast3.Expr(value=node.expr.gen.py_ast[0]))
+                self.sync(ast3.Expr(value=cast(ast3.expr, node.expr.gen.py_ast[0])))
                 if not node.in_fstring
                 else self.sync(
                     ast3.FormattedValue(
-                        value=node.expr.gen.py_ast[0],
+                        value=cast(ast3.expr, node.expr.gen.py_ast[0]),
                         conversion=-1,
                         format_spec=None,
                     )
@@ -1441,61 +1265,96 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_try_stmt(self, node: ast.TryStmt) -> None:
-        """Sub objects.
+    def exit_concurrent_expr(self, node: uni.ConcurrentExpr) -> None:
+        func = ""
+        if node.tok:
+            match node.tok.value:
+                case "flow":
+                    func = "thread_run"
+                case "wait":
+                    func = "thread_wait"
+        if func:
+            lambda_ex = [
+                self.sync(
+                    ast3.Lambda(
+                        args=(
+                            self.sync(
+                                ast3.arguments(
+                                    posonlyargs=[],
+                                    args=[],
+                                    kwonlyargs=[],
+                                    kw_defaults=[],
+                                    defaults=[],
+                                )
+                            )
+                        ),
+                        body=cast(ast3.expr, node.target.gen.py_ast[0]),
+                    )
+                )
+            ]
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Call(
+                        func=self.jaclib_obj(func),
+                        args=cast(
+                            list[ast3.expr],
+                            (
+                                lambda_ex
+                                if func == "thread_run"
+                                else [node.target.gen.py_ast[0]]  # type: ignore
+                            ),
+                        ),
+                        keywords=[],
+                    )
+                )
+            ]
 
-        body: SubNodeList[CodeBlockStmt],
-        excepts: Optional[SubNodeList[Except]],
-        else_body: Optional[ElseStmt],
-        finally_body: Optional[FinallyStmt],
-        """
+    def exit_try_stmt(self, node: uni.TryStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Try(
-                    body=self.resolve_stmt_block(node.body),
-                    handlers=node.excepts.gen.py_ast if node.excepts else [],
-                    orelse=node.else_body.gen.py_ast if node.else_body else [],
-                    finalbody=node.finally_body.gen.py_ast if node.finally_body else [],
+                    body=cast(list[ast3.stmt], self.resolve_stmt_block(node.body)),
+                    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
+                        else []
+                    ),
+                    finalbody=(
+                        [cast(ast3.stmt, i) for i in node.finally_body.gen.py_ast]
+                        if node.finally_body
+                        else []
+                    ),
                 )
             )
         ]
 
-    def exit_except(self, node: ast.Except) -> None:
-        """Sub objects.
-
-        ex_type: ExprType,
-        name: Optional[Name],
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_except(self, node: uni.Except) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.ExceptHandler(
-                    type=node.ex_type.gen.py_ast[0],
+                    type=(
+                        cast(ast3.expr, node.ex_type.gen.py_ast[0])
+                        if node.ex_type
+                        else None
+                    ),
                     name=node.name.sym_name if node.name else None,
-                    body=self.resolve_stmt_block(node.body),
+                    body=[
+                        cast(ast3.stmt, stmt)
+                        for stmt in self.resolve_stmt_block(node.body)
+                    ],
                 )
             )
         ]
 
-    def exit_finally_stmt(self, node: ast.FinallyStmt) -> None:
-        """Sub objects.
-
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_finally_stmt(self, node: uni.FinallyStmt) -> None:
         node.gen.py_ast = self.resolve_stmt_block(node.body)
 
-    def exit_iter_for_stmt(self, node: ast.IterForStmt) -> None:
-        """Sub objects.
-
-        iter: Assignment,
-        is_async: bool,
-        condition: ExprType,
-        count_by: ExprType,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: Optional[ElseStmt],
-        """
+    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)
@@ -1508,113 +1367,115 @@ class PyastGenPass(Pass):
         py_nodes.append(
             self.sync(
                 ast3.While(
-                    test=node.condition.gen.py_ast[0],
-                    body=body,
-                    orelse=node.else_body.gen.py_ast if node.else_body else [],
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    body=[cast(ast3.stmt, stmt) for stmt in body],
+                    orelse=(
+                        [cast(ast3.stmt, stmt) for stmt in node.else_body.gen.py_ast]
+                        if node.else_body
+                        else []
+                    ),
                 )
             )
         )
         node.gen.py_ast = py_nodes
 
-    def exit_in_for_stmt(self, node: ast.InForStmt) -> None:
-        """Sub objects.
-
-        target: Expr,
-        is_async: bool,
-        collection: Expr,
-        body: SubNodeList[CodeBlockStmt],
-        else_body: Optional[ElseStmt],
-        """
+    def exit_in_for_stmt(self, node: uni.InForStmt) -> None:
         for_node = ast3.AsyncFor if node.is_async else ast3.For
         node.gen.py_ast = [
             self.sync(
                 for_node(
-                    target=node.target.gen.py_ast[0],
-                    iter=node.collection.gen.py_ast[0],
-                    body=self.resolve_stmt_block(node.body),
-                    orelse=node.else_body.gen.py_ast if node.else_body else [],
+                    target=cast(ast3.expr, node.target.gen.py_ast[0]),
+                    iter=cast(ast3.expr, node.collection.gen.py_ast[0]),
+                    body=[
+                        cast(ast3.stmt, stmt)
+                        for stmt in self.resolve_stmt_block(node.body)
+                    ],
+                    orelse=(
+                        [cast(ast3.stmt, stmt) for stmt in node.else_body.gen.py_ast]
+                        if node.else_body
+                        else []
+                    ),
                 )
             )
         ]
 
-    def exit_while_stmt(self, node: ast.WhileStmt) -> None:
-        """Sub objects.
-
-        condition: ExprType,
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_while_stmt(self, node: uni.WhileStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.While(
-                    test=node.condition.gen.py_ast[0],
-                    body=self.resolve_stmt_block(node.body),
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    body=[
+                        cast(ast3.stmt, stmt)
+                        for stmt in self.resolve_stmt_block(node.body)
+                    ],
                     orelse=[],
                 )
             )
         ]
 
-    def exit_with_stmt(self, node: ast.WithStmt) -> None:
-        """Sub objects.
-
-        is_async: bool,
-        exprs: SubNodeList[ExprAsItem],
-        body: SubNodeList[CodeBlockStmt],
-        """
+    def exit_with_stmt(self, node: uni.WithStmt) -> None:
         with_node = ast3.AsyncWith if node.is_async else ast3.With
         node.gen.py_ast = [
             self.sync(
                 with_node(
-                    items=node.exprs.gen.py_ast, body=self.resolve_stmt_block(node.body)
+                    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)
+                    ],
                 )
             )
         ]
 
-    def exit_expr_as_item(self, node: ast.ExprAsItem) -> None:
-        """Sub objects.
-
-        expr: ExprType,
-        alias: Optional[ExprType],
-        """
+    def exit_expr_as_item(self, node: uni.ExprAsItem) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.withitem(
-                    context_expr=node.expr.gen.py_ast[0],
-                    optional_vars=node.alias.gen.py_ast[0] if node.alias else None,
+                    context_expr=cast(ast3.expr, node.expr.gen.py_ast[0]),
+                    optional_vars=(
+                        cast(ast3.expr, node.alias.gen.py_ast[0])
+                        if node.alias
+                        else None
+                    ),
                 )
             )
         ]
 
-    def exit_raise_stmt(self, node: ast.RaiseStmt) -> None:
-        """Sub objects.
-
-        cause: Optional[ExprType],
-        from_target: Optional[ExprType],
-        """
+    def exit_raise_stmt(self, node: uni.RaiseStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Raise(
-                    exc=node.cause.gen.py_ast[0] if node.cause else None,
-                    cause=node.from_target.gen.py_ast[0] if node.from_target else None,
+                    exc=(
+                        cast(ast3.expr, node.cause.gen.py_ast[0])
+                        if node.cause
+                        else None
+                    ),
+                    cause=(
+                        cast(ast3.expr, node.from_target.gen.py_ast[0])
+                        if node.from_target
+                        else None
+                    ),
                 )
             )
         ]
 
-    def exit_assert_stmt(self, node: ast.AssertStmt) -> None:
-        """Sub objects.
-
-        condition: ExprType,
-        error_msg: Optional[ExprType],
-        """
+    def exit_assert_stmt(self, node: uni.AssertStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Assert(
-                    test=node.condition.gen.py_ast[0],
-                    msg=node.error_msg.gen.py_ast[0] if node.error_msg else None,
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    msg=(
+                        cast(ast3.expr, node.error_msg.gen.py_ast[0])
+                        if node.error_msg
+                        else None
+                    ),
                 )
             )
         ]
 
-    def exit_check_stmt(self, node: ast.CheckStmt) -> None:
+    def exit_check_stmt(self, node: uni.CheckStmt) -> None:
         """Sub objects.
 
         target: ExprType,
@@ -1647,16 +1508,14 @@ class PyastGenPass(Pass):
         # This will check if a node is `isinstance(<expr>, <expr>)`, we're
         # using a function because it's reusable to check not isinstance(<expr>, <expr>).
         def check_node_isinstance_call(
-            node: ast.FuncCall,
+            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], ast.Expr)
-                and isinstance(node.params.items[1], ast.Expr)
+                len(node.params) == 2
+                and isinstance(node.params[0], uni.Expr)
+                and isinstance(node.params[1], uni.Expr)
             ):
                 return CheckNodeIsinstanceCallResult()
 
@@ -1666,8 +1525,8 @@ class PyastGenPass(Pass):
 
             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.
@@ -1677,12 +1536,12 @@ class PyastGenPass(Pass):
         # Compare operations. Note that We're only considering the compare
         # operation with a single operation ie. a < b < c is  ignored here.
         if (
-            isinstance(node.target, ast.CompareExpr)
+            isinstance(node.target, uni.CompareExpr)
             and isinstance(node.target.gen.py_ast[0], ast3.Compare)
             and len(node.target.ops) == 1
         ):
-            expr: ast.CompareExpr = node.target
-            opty: ast.Token = expr.ops[0]
+            expr: uni.CompareExpr = node.target
+            opty: uni.Token = expr.ops[0]
 
             optype2fn = {
                 Tok.EE.name: "assertEqual",
@@ -1705,17 +1564,17 @@ class PyastGenPass(Pass):
                 ]
 
                 # Override for <expr> is None.
-                if opty.name == Tok.KW_IS and isinstance(expr.rights[0], ast.Null):
+                if opty.name == Tok.KW_IS and isinstance(expr.rights[0], uni.Null):
                     assert_func_name = "assertIsNone"
                     assert_args_list.pop()
 
                 # Override for <expr> is not None.
-                elif opty.name == Tok.KW_ISN and isinstance(expr.rights[0], ast.Null):
+                elif opty.name == Tok.KW_ISN and isinstance(expr.rights[0], uni.Null):
                     assert_func_name = "assertIsNotNone"
                     assert_args_list.pop()
 
         # Check if 'isinstance' is called.
-        elif isinstance(node.target, ast.FuncCall) and isinstance(
+        elif isinstance(node.target, uni.FuncCall) and isinstance(
             node.target.gen.py_ast[0], ast3.Call
         ):
             res = check_node_isinstance_call(node.target)
@@ -1728,10 +1587,10 @@ class PyastGenPass(Pass):
 
         # Check if 'not isinstance(<expr>, <expr>)' is called.
         elif (
-            isinstance(node.target, ast.UnaryExpr)
-            and isinstance(node.target, ast.UnaryExpr)
-            and isinstance(node.target.operand, ast.FuncCall)
-            and isinstance(node.target.operand, ast.UnaryExpr)
+            isinstance(node.target, uni.UnaryExpr)
+            and isinstance(node.target, uni.UnaryExpr)
+            and isinstance(node.target.operand, uni.FuncCall)
+            and isinstance(node.target.operand, uni.UnaryExpr)
         ):
             res = check_node_isinstance_call(node.target.operand)
             if res.isit:
@@ -1746,16 +1605,15 @@ class PyastGenPass(Pass):
         # the almost equal functionality (snice there is no almost equal operator in jac and never needed ig.).
 
         # Check if 'almostEqual' is called.
-        if isinstance(node.target, ast.FuncCall) and isinstance(
+        if isinstance(node.target, uni.FuncCall) and isinstance(
             node.target.gen.py_ast[0], ast3.Call
         ):
             func = node.target.target
-            if isinstance(func, ast.Name) and func.value == "almostEqual":
+            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(
@@ -1768,16 +1626,16 @@ class PyastGenPass(Pass):
 
         # assert_call_expr = "(Con.JAC_CHECK.value.assertXXX)(args)"
         assert_call_expr: ast3.Call = self.sync(
-            ast3.Call(func=assert_func_expr, args=assert_args_list, keywords=[])
+            ast3.Call(
+                func=assert_func_expr,
+                args=[cast(ast3.expr, arg) for arg in assert_args_list],
+                keywords=[],
+            )
         )
 
         node.gen.py_ast = [self.sync(ast3.Expr(assert_call_expr))]
 
-    def exit_ctrl_stmt(self, node: ast.CtrlStmt) -> None:
-        """Sub objects.
-
-        ctrl: Token,
-        """
+    def exit_ctrl_stmt(self, node: uni.CtrlStmt) -> None:
         if node.ctrl.name == Tok.KW_BREAK:
             node.gen.py_ast = [self.sync(ast3.Break())]
         elif node.ctrl.name == Tok.KW_CONTINUE:
@@ -1785,42 +1643,58 @@ class PyastGenPass(Pass):
         elif node.ctrl.name == Tok.KW_SKIP:
             node.gen.py_ast = [self.sync(ast3.Return(value=None))]
 
-    def exit_delete_stmt(self, node: ast.DeleteStmt) -> None:
-        """Sub objects.
-
-        target: SubNodeList[AtomType],
-        """
-        node.gen.py_ast = [
-            self.sync(
-                ast3.Delete(
-                    targets=(
-                        node.target.values.gen.py_ast
-                        if isinstance(node.target, ast.TupleVal) and node.target.values
-                        else node.target.gen.py_ast
-                    )
+    def exit_delete_stmt(self, node: uni.DeleteStmt) -> None:
+        def set_ctx(
+            targets: Union[ast3.AST, List[ast3.AST]], ctx: type
+        ) -> List[ast3.AST]:
+            """Set the given ctx (Load, Del) to AST node(s)."""
+            if not isinstance(targets, list):
+                targets = [targets]
+            elif isinstance(targets[0], (ast3.List, ast3.Tuple)):
+                targets = [i for i in targets[0].elts if isinstance(i, ast3.AST)]
+            result = []
+            for target in targets:
+                if hasattr(target, "ctx"):
+                    target = copy.copy(target)
+                    target.ctx = ctx()
+                result.append(target)
+            return result
+
+        destroy_expr = ast3.Expr(
+            value=self.sync(
+                ast3.Call(
+                    func=self.jaclib_obj("destroy"),
+                    args=[
+                        self.sync(
+                            ast3.List(
+                                elts=cast(
+                                    list[ast3.expr],
+                                    set_ctx(node.py_ast_targets, ast3.Load),
+                                ),
+                                ctx=ast3.Load(),
+                            )
+                        )
+                    ],
+                    keywords=[],
                 )
             )
-        ]
-
-    def exit_report_stmt(self, node: ast.ReportStmt) -> None:
-        """Sub objects.
+        )
+        delete_stmt = self.sync(
+            ast3.Delete(
+                targets=cast(list[ast3.expr], set_ctx(node.py_ast_targets, ast3.Del))
+            )
+        )
+        node.gen.py_ast = [self.sync(destroy_expr), self.sync(delete_stmt)]
 
-        expr: ExprType,
-        """
+    def exit_report_stmt(self, node: uni.ReportStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Expr(
                     value=self.sync(
                         self.sync(
                             ast3.Call(
-                                func=self.sync(
-                                    ast3.Attribute(
-                                        value=self.jaclib_obj(Con.JAC_FEATURE.value),
-                                        attr="report",
-                                        ctx=ast3.Load(),
-                                    )
-                                ),
-                                args=node.expr.gen.py_ast,
+                                func=self.jaclib_obj("report"),
+                                args=cast(list[ast3.expr], node.expr.gen.py_ast),
                                 keywords=[],
                             )
                         )
@@ -1829,42 +1703,48 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_return_stmt(self, node: ast.ReturnStmt) -> None:
-        """Sub objects.
-
-        expr: Optional[ExprType],
-        """
+    def exit_return_stmt(self, node: uni.ReturnStmt) -> None:
         node.gen.py_ast = [
-            self.sync(ast3.Return(value=node.expr.gen.py_ast[0] if node.expr else None))
+            self.sync(
+                ast3.Return(
+                    value=(
+                        cast(ast3.expr, node.expr.gen.py_ast[0]) if node.expr else None
+                    )
+                )
+            )
         ]
 
-    def exit_yield_expr(self, node: ast.YieldExpr) -> None:
-        """Sub objects.
-
-        expr: Optional[ExprType],
-        """
+    def exit_yield_expr(self, node: uni.YieldExpr) -> None:
         if not node.with_from:
             node.gen.py_ast = [
                 self.sync(
-                    ast3.Yield(value=node.expr.gen.py_ast[0] if node.expr else None)
+                    ast3.Yield(
+                        value=(
+                            cast(ast3.expr, node.expr.gen.py_ast[0])
+                            if node.expr
+                            else None
+                        )
+                    )
                 )
             ]
         else:
             node.gen.py_ast = [
                 self.sync(
-                    ast3.YieldFrom(value=node.expr.gen.py_ast[0] if node.expr else None)
+                    ast3.YieldFrom(
+                        value=(
+                            cast(ast3.expr, node.expr.gen.py_ast[0])
+                            if node.expr
+                            else self.sync(ast3.Constant(value=None))
+                        )
+                    )
                 )
             ]
 
-    def exit_ignore_stmt(self, node: ast.IgnoreStmt) -> None:
-        """Sub objects.
-
-        target: ExprType,
-        """
+    def exit_ignore_stmt(self, node: uni.IgnoreStmt) -> None:
         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 = [
@@ -1872,14 +1752,10 @@ class PyastGenPass(Pass):
                 ast3.Expr(
                     value=self.sync(
                         ast3.Call(
-                            func=self.sync(
-                                ast3.Attribute(
-                                    value=walker,
-                                    attr="ignore",
-                                    ctx=ast3.Load(),
-                                )
+                            func=self.jaclib_obj("ignore"),
+                            args=cast(
+                                list[ast3.expr], [walker, node.target.gen.py_ast[0]]
                             ),
-                            args=[node.target.gen.py_ast[0]],
                             keywords=[],
                         )
                     )
@@ -1887,33 +1763,31 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_visit_stmt(self, node: ast.VisitStmt) -> None:
-        """Sub objects.
-
-        vis_type: Optional[SubNodeList[AtomType]],
-        target: ExprType,
-        else_body: Optional[ElseStmt],
-        """
+    def exit_visit_stmt(self, node: uni.VisitStmt) -> None:
         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(
             ast3.Call(
-                func=self.sync(
-                    ast3.Attribute(
-                        value=loc,
-                        attr="visit",
-                        ctx=ast3.Load(),
-                    )
-                ),
-                args=[node.target.gen.py_ast[0]],
+                func=self.jaclib_obj("visit"),
+                args=cast(list[ast3.expr], [loc, node.target.gen.py_ast[0]]),
                 keywords=[],
             )
         )
 
+        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(
@@ -1924,7 +1798,7 @@ class PyastGenPass(Pass):
                                 operand=visit_call,
                             )
                         ),
-                        body=node.else_body.gen.py_ast,
+                        body=cast(list[ast3.stmt], node.else_body.gen.py_ast),
                         orelse=[],
                     )
                 )
@@ -1933,60 +1807,51 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_revisit_stmt(self, node: ast.RevisitStmt) -> None:
-        """Sub objects.
-
-        hops: Optional[ExprType],
-        else_body: Optional[ElseStmt],
-        """
-        self.warning("Revisit not used in Jac", node)
-        node.gen.py_ast = [
-            self.sync(ast3.Expr(value=self.sync(ast3.Constant(value=None))))
-        ]
-
-    def exit_disengage_stmt(self, node: ast.DisengageStmt) -> None:
-        """Sub objects."""
+    def exit_disengage_stmt(self, node: uni.DisengageStmt) -> None:
         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(
-                ast3.Return(
+                ast3.Expr(
                     self.sync(
-                        self.sync(
-                            ast3.Call(
-                                func=self.sync(
-                                    ast3.Attribute(
-                                        value=loc,
-                                        attr="disengage",
-                                        ctx=ast3.Load(),
-                                    )
-                                ),
-                                args=[],
-                                keywords=[],
-                            )
+                        ast3.Call(
+                            func=self.jaclib_obj("disengage"),
+                            args=[loc],
+                            keywords=[],
                         )
                     )
                 )
             ),
+            self.sync(ast3.Return()),
         ]
 
-    def exit_await_expr(self, node: ast.AwaitExpr) -> None:
-        """Sub objects.
-
-        target: ExprType,
-        """
-        node.gen.py_ast = [self.sync(ast3.Await(value=node.target.gen.py_ast[0]))]
-
-    def exit_global_stmt(self, node: ast.GlobalStmt) -> None:
-        """Sub objects.
+    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=[],
+                    )
+                )
+            ]
 
-        target: SubNodeList[NameType],
-        """
+    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]),
@@ -1995,13 +1860,9 @@ class PyastGenPass(Pass):
             )
         node.gen.py_ast = [*py_nodes]
 
-    def exit_non_local_stmt(self, node: ast.NonLocalStmt) -> None:
-        """Sub objects.
-
-        target: SubNodeList[NameType],
-        """
+    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]),
@@ -2010,14 +1871,7 @@ class PyastGenPass(Pass):
             )
         node.gen.py_ast = [*py_nodes]
 
-    def exit_assignment(self, node: ast.Assignment) -> None:
-        """Sub objects.
-
-        target: SubNodeList[AtomType],
-        value: Optional[ExprType | YieldStmt],
-        type_tag: Optional[SubTag[ExprType]],
-        mutable: bool =True,
-        """
+    def exit_assignment(self, node: uni.Assignment) -> None:
         value = (
             node.value.gen.py_ast[0]
             if node.value
@@ -2033,14 +1887,20 @@ class PyastGenPass(Pass):
                 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=node.target.items[0].gen.py_ast[0],
-                        annotation=node.type_tag.gen.py_ast[0],
-                        value=node.value.gen.py_ast[0] if node.value else None,
-                        simple=int(isinstance(node.target.gen.py_ast[0], ast3.Name)),
+                        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(targets_ast[0], ast3.Name)),
                     )
                 )
             ]
@@ -2048,26 +1908,32 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.AugAssign(
-                        target=node.target.items[0].gen.py_ast[0],
-                        op=node.aug_op.gen.py_ast[0],
-                        value=value,
+                        target=cast(ast3.Name, targets_ast[0]),
+                        op=cast(ast3.operator, node.aug_op.gen.py_ast[0]),
+                        value=(
+                            cast(ast3.expr, value)
+                            if isinstance(value, ast3.expr)
+                            else ast3.Constant(value=None)
+                        ),
                     )
                 )
             ]
         else:
             node.gen.py_ast = [
-                self.sync(ast3.Assign(targets=node.target.gen.py_ast, value=value))
+                self.sync(
+                    ast3.Assign(
+                        targets=cast(list[ast3.expr], targets_ast),
+                        value=(
+                            cast(ast3.expr, value)
+                            if isinstance(value, ast3.expr)
+                            else ast3.Constant(value=None)
+                        ),
+                    )
+                )
             ]
 
-    def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
-        """Sub objects.
-
-        left: ExprType,
-        right: ExprType,
-        op: Token | DisconnectOp | ConnectOp,
-        """
-        if isinstance(node.op, ast.ConnectOp):
-
+    def exit_binary_expr(self, node: uni.BinaryExpr) -> None:
+        if isinstance(node.op, uni.ConnectOp):
             left = (
                 node.right.gen.py_ast[0]
                 if node.op.edge_dir == EdgeDir.IN
@@ -2078,46 +1944,37 @@ class PyastGenPass(Pass):
                 if node.op.edge_dir == EdgeDir.IN
                 else node.right.gen.py_ast[0]
             )
-            conn_type = (
-                node.op.conn_type.gen.py_ast[0]
-                if node.op.conn_type
-                else self.sync(ast3.Constant(value=None))
-            )
-            undir = self.sync(ast3.Constant(value=node.op.edge_dir == EdgeDir.ANY))
-            conn_assign = (
-                node.op.conn_assign.gen.py_ast[0]
-                if node.op.conn_assign
-                else self.sync(ast3.Constant(value=None))
-            )
 
-            keywords = []
-            if not isinstance(conn_type, ast3.Constant) or conn_type.value is not None:
+            keywords = [
+                self.sync(ast3.keyword(arg="left", value=cast(ast3.expr, left))),
+                self.sync(ast3.keyword(arg="right", value=cast(ast3.expr, right))),
+            ]
+
+            if node.op.conn_type:
                 keywords.append(
                     self.sync(
                         ast3.keyword(
                             arg="edge",
-                            value=conn_type,
+                            value=cast(ast3.expr, node.op.conn_type.gen.py_ast[0]),
                         )
                     )
                 )
-            if undir.value:  # default is Fault.
+
+            if node.op.edge_dir == EdgeDir.ANY:
                 keywords.append(
                     self.sync(
                         ast3.keyword(
-                            arg="undir",
-                            value=undir,
+                            arg="undir", value=self.sync(ast3.Constant(value=True))
                         )
                     )
                 )
-            if (
-                not isinstance(conn_assign, ast3.Constant)
-                or conn_assign.value is not None
-            ):
+
+            if node.op.conn_assign:
                 keywords.append(
                     self.sync(
                         ast3.keyword(
                             arg="conn_assign",
-                            value=conn_assign,
+                            value=cast(ast3.expr, node.op.conn_assign.gen.py_ast[0]),
                         )
                     )
                 )
@@ -2125,39 +1982,32 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=left,
-                                attr="connect",
-                                ctx=ast3.Load(),
-                            ),
-                        ),
-                        args=[right],
+                        func=self.jaclib_obj("connect"),
+                        args=[],
                         keywords=keywords,
                     )
                 )
             ]
 
-        elif isinstance(node.op, ast.DisconnectOp):
-            keywords = []
-
-            if node.op.edge_spec.filter_cond and node.op.edge_spec.filter_cond.f_type:
-                keywords.append(
-                    self.sync(
-                        ast3.keyword(
-                            arg="edge",
-                            value=self.sync(
-                                node.op.edge_spec.filter_cond.f_type.gen.py_ast[0]
-                            ),
-                        )
+        elif isinstance(node.op, uni.DisconnectOp):
+            keywords = [
+                self.sync(
+                    ast3.keyword(
+                        arg="left", value=cast(ast3.expr, node.left.gen.py_ast[0])
                     )
-                )
+                ),
+                self.sync(
+                    ast3.keyword(
+                        arg="right", value=cast(ast3.expr, node.right.gen.py_ast[0])
+                    )
+                ),
+            ]
 
             if node.op.edge_spec.edge_dir != EdgeDir.OUT:
                 keywords.append(
                     self.sync(
                         ast3.keyword(
-                            arg="dir",
+                            arg="EdgeDir",
                             value=self.sync(
                                 ast3.Attribute(
                                     value=self.jaclib_obj("EdgeDir"),
@@ -2169,17 +2019,24 @@ class PyastGenPass(Pass):
                     )
                 )
 
+            if node.op.edge_spec.filter_cond:
+                keywords.append(
+                    self.sync(
+                        ast3.keyword(
+                            arg="filter",
+                            value=cast(
+                                ast3.expr,
+                                node.op.edge_spec.filter_cond.gen.py_ast[0],
+                            ),
+                        ),
+                    )
+                )
+
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=node.left.gen.py_ast[0],
-                                attr="disconnect",
-                                ctx=ast3.Load(),
-                            )
-                        ),
-                        args=[node.right.gen.py_ast[0]],
+                        func=self.jaclib_obj("disconnect"),
+                        args=[],
                         keywords=keywords,
                     )
                 )
@@ -2188,8 +2045,11 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.BoolOp(
-                        op=node.op.gen.py_ast[0],
-                        values=[node.left.gen.py_ast[0], node.right.gen.py_ast[0]],
+                        op=cast(ast3.boolop, node.op.gen.py_ast[0]),
+                        values=[
+                            cast(ast3.expr, node.left.gen.py_ast[0]),
+                            cast(ast3.expr, node.right.gen.py_ast[0]),
+                        ],
                     )
                 )
             ]
@@ -2200,8 +2060,8 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.NamedExpr(
-                        target=node.left.gen.py_ast[0],
-                        value=node.right.gen.py_ast[0],
+                        target=cast(ast3.Name, node.left.gen.py_ast[0]),
+                        value=cast(ast3.expr, node.right.gen.py_ast[0]),
                     )
                 )
             ]
@@ -2209,49 +2069,44 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.BinOp(
-                        left=node.left.gen.py_ast[0],
-                        right=node.right.gen.py_ast[0],
-                        op=node.op.gen.py_ast[0],
+                        left=cast(ast3.expr, node.left.gen.py_ast[0]),
+                        right=cast(ast3.expr, node.right.gen.py_ast[0]),
+                        op=cast(ast3.operator, node.op.gen.py_ast[0]),
                     )
                 )
             ]
         else:
             node.gen.py_ast = self.translate_jac_bin_op(node)
 
-    def translate_jac_bin_op(self, node: ast.BinaryExpr) -> list[ast3.AST]:
-        """Translate jac binary op."""
-        if isinstance(node.op, (ast.DisconnectOp, ast.ConnectOp)):
+    def translate_jac_bin_op(self, node: uni.BinaryExpr) -> list[ast3.AST]:
+        if isinstance(node.op, (uni.DisconnectOp, uni.ConnectOp)):
             raise self.ice()
         elif node.op.name in [
             Tok.PIPE_FWD,
             Tok.A_PIPE_FWD,
         ]:
-            func_node = ast.FuncCall(
+            func_node = uni.FuncCall(
                 target=node.right,
                 params=(
-                    node.left.values
-                    if isinstance(node.left, ast.TupleVal)
-                    else ast.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,
             )
+            func_node.parent = node.parent
             self.exit_func_call(func_node)
             return func_node.gen.py_ast
         elif node.op.name in [Tok.KW_SPAWN]:
             return [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=node.left.gen.py_ast[0],
-                                attr="spawn",
-                                ctx=ast3.Load(),
-                            )
+                        func=self.jaclib_obj("spawn"),
+                        args=cast(
+                            list[ast3.expr],
+                            [node.left.gen.py_ast[0], node.right.gen.py_ast[0]],
                         ),
-                        args=[node.right.gen.py_ast[0]],
                         keywords=[],
                     )
                 )
@@ -2260,71 +2115,54 @@ class PyastGenPass(Pass):
             Tok.PIPE_BKWD,
             Tok.A_PIPE_BKWD,
         ]:
-            func_node = ast.FuncCall(
+            func_node = uni.FuncCall(
                 target=node.left,
                 params=(
-                    node.right.values
-                    if isinstance(node.right, ast.TupleVal)
-                    else ast.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,
             )
+            func_node.parent = node.parent
             self.exit_func_call(func_node)
             return func_node.gen.py_ast
-        elif node.op.name == Tok.PIPE_FWD and isinstance(node.right, ast.TupleVal):
-            self.error("Invalid pipe target.")
+        elif node.op.name == Tok.PIPE_FWD and isinstance(node.right, uni.TupleVal):
+            self.log_error("Invalid pipe target.")
         else:
-            self.error(
+            self.log_error(
                 f"Binary operator {node.op.value} not supported in bootstrap Jac"
             )
         return []
 
-    def exit_compare_expr(self, node: ast.CompareExpr) -> None:
-        """Sub objects.
-
-        left: Expr,
-        rights: list[Expr],
-        ops: list[Token],
-        """
+    def exit_compare_expr(self, node: uni.CompareExpr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Compare(
-                    left=node.left.gen.py_ast[0],
-                    comparators=[i.gen.py_ast[0] for i in node.rights],
-                    ops=[i.gen.py_ast[0] for i in node.ops],
+                    left=cast(ast3.expr, node.left.gen.py_ast[0]),
+                    comparators=[cast(ast3.expr, i.gen.py_ast[0]) for i in node.rights],
+                    ops=[cast(ast3.cmpop, i.gen.py_ast[0]) for i in node.ops],
                 )
             )
         ]
 
-    def exit_bool_expr(self, node: ast.BoolExpr) -> None:
-        """Sub objects.
-
-        op: Token,
-        values: list[Expr],
-        """
+    def exit_bool_expr(self, node: uni.BoolExpr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.BoolOp(
-                    op=node.op.gen.py_ast[0],
-                    values=[i.gen.py_ast[0] for i in node.values],
+                    op=cast(ast3.boolop, node.op.gen.py_ast[0]),
+                    values=[cast(ast3.expr, i.gen.py_ast[0]) for i in node.values],
                 )
             )
         ]
 
-    def exit_lambda_expr(self, node: ast.LambdaExpr) -> None:
-        """Sub objects.
-
-        signature: FuncSignature,
-        body: ExprType,
-        """
+    def exit_lambda_expr(self, node: uni.LambdaExpr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Lambda(
                     args=(
-                        node.signature.gen.py_ast[0]
+                        cast(ast3.arguments, node.signature.gen.py_ast[0])
                         if node.signature
                         else self.sync(
                             ast3.arguments(
@@ -2336,23 +2174,18 @@ class PyastGenPass(Pass):
                             )
                         )
                     ),
-                    body=node.body.gen.py_ast[0],
+                    body=cast(ast3.expr, node.body.gen.py_ast[0]),
                 )
             )
         ]
 
-    def exit_unary_expr(self, node: ast.UnaryExpr) -> None:
-        """Sub objects.
-
-        operand: ExprType,
-        op: Token,
-        """
+    def exit_unary_expr(self, node: uni.UnaryExpr) -> None:
         if node.op.name == Tok.NOT:
             node.gen.py_ast = [
                 self.sync(
                     ast3.UnaryOp(
                         op=self.sync(ast3.Not()),
-                        operand=node.operand.gen.py_ast[0],
+                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
                     )
                 )
             ]
@@ -2361,7 +2194,7 @@ class PyastGenPass(Pass):
                 self.sync(
                     ast3.UnaryOp(
                         op=self.sync(ast3.Invert()),
-                        operand=node.operand.gen.py_ast[0],
+                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
                     )
                 )
             ]
@@ -2370,7 +2203,7 @@ class PyastGenPass(Pass):
                 self.sync(
                     ast3.UnaryOp(
                         op=self.sync(ast3.UAdd()),
-                        operand=node.operand.gen.py_ast[0],
+                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
                     )
                 )
             ]
@@ -2379,7 +2212,7 @@ class PyastGenPass(Pass):
                 self.sync(
                     ast3.UnaryOp(
                         op=self.sync(ast3.USub()),
-                        operand=node.operand.gen.py_ast[0],
+                        operand=cast(ast3.expr, node.operand.gen.py_ast[0]),
                     )
                 )
             ]
@@ -2387,7 +2220,7 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=node.operand.gen.py_ast[0],
+                        func=cast(ast3.expr, node.operand.gen.py_ast[0]),
                         args=[],
                         keywords=[],
                     )
@@ -2396,14 +2229,14 @@ class PyastGenPass(Pass):
         elif node.op.name in [Tok.STAR_MUL]:
             ctx_val = (
                 node.operand.py_ctx_func()
-                if isinstance(node.operand, ast.AstSymbolNode)
+                if isinstance(node.operand, uni.AstSymbolNode)
                 else ast3.Load()
             )
             node.gen.py_ast = [
                 self.sync(
                     ast3.Starred(
-                        value=node.operand.gen.py_ast[0],
-                        ctx=ctx_val,
+                        value=cast(ast3.expr, node.operand.gen.py_ast[0]),
+                        ctx=cast(ast3.expr_context, ctx_val),
                     )
                 )
             ]
@@ -2413,13 +2246,13 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.jaclib_obj("jobj"),
+                        func=self.sync(ast3.Name(id="jobj", ctx=ast3.Load())),
                         args=[],
                         keywords=[
                             self.sync(
                                 ast3.keyword(
                                     arg="id",
-                                    value=node.operand.gen.py_ast[0],
+                                    value=cast(ast3.expr, node.operand.gen.py_ast[0]),
                                 )
                             ),
                         ],
@@ -2429,39 +2262,29 @@ class PyastGenPass(Pass):
         else:
             self.ice(f"Unknown Unary operator {node.op.value}")
 
-    def exit_if_else_expr(self, node: ast.IfElseExpr) -> None:
-        """Sub objects.
-
-        condition: ExprType,
-        value: ExprType,
-        else_value: ExprType,
-        """
+    def exit_if_else_expr(self, node: uni.IfElseExpr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.IfExp(
-                    test=node.condition.gen.py_ast[0],
-                    body=node.value.gen.py_ast[0],
-                    orelse=node.else_value.gen.py_ast[0],
+                    test=cast(ast3.expr, node.condition.gen.py_ast[0]),
+                    body=cast(ast3.expr, node.value.gen.py_ast[0]),
+                    orelse=cast(ast3.expr, node.else_value.gen.py_ast[0]),
                 )
             )
         ]
 
-    def exit_multi_string(self, node: ast.MultiString) -> None:
-        """Sub objects.
-
-        strings: Sequence[String | FString],
-        """
-
+    def exit_multi_string(self, node: uni.MultiString) -> None:
         def get_pieces(str_seq: Sequence) -> list[str | ast3.AST]:
-            """Pieces."""
             pieces: list[str | ast3.AST] = []
             for i in str_seq:
-                if isinstance(i, ast.String):
+                if isinstance(i, uni.String):
                     pieces.append(i.lit_value)
-                elif isinstance(i, ast.FString):
-                    pieces.extend(get_pieces(i.parts.items)) if i.parts else None
-                elif isinstance(i, ast.ExprStmt):
+                elif isinstance(i, uni.FString):
+                    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
@@ -2490,138 +2313,79 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.JoinedStr(
-                        values=combined_multi,
+                        values=[cast(ast3.expr, node) for node in combined_multi],
                     )
                 )
             ]
         else:
             node.gen.py_ast = [combined_multi[0]]
 
-    def exit_f_string(self, node: ast.FString) -> None:
-        """Sub objects.
-
-        parts: Optional[SubNodeList[String | ExprType]],
-        """
-        node.gen.py_ast = (
-            node.parts.gen.py_ast
-            if node.parts
-            else [self.sync(ast3.Constant(value=""))]
-        )
-
-    def exit_list_val(self, node: ast.ListVal) -> None:
-        """Sub objects.
-
-        values: Optional[SubNodeList[ExprType]],
-        """
-        if isinstance(node.py_ctx_func(), ast3.Load):
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.Call(
-                        func=self.jaclib_obj("JacList"),
-                        args=[
-                            self.sync(
-                                ast3.List(
-                                    elts=node.values.gen.py_ast if node.values else [],
-                                    ctx=ast3.Load(),
-                                )
-                            )
-                        ],
-                        keywords=[],
-                    )
-                )
-            ]
-        else:
-            node.gen.py_ast = [
-                self.sync(
-                    ast3.List(
-                        elts=node.values.gen.py_ast if node.values else [],
-                        ctx=node.py_ctx_func(),
-                    )
-                )
-            ]
-
-    def exit_set_val(self, node: ast.SetVal) -> None:
-        """Sub objects.
-
-        values: Optional[SubNodeList[ExprType]],
-        """
-        node.gen.py_ast = [
-            self.sync(
-                ast3.Set(
-                    elts=node.values.gen.py_ast if node.values else [],
-                    ctx=node.py_ctx_func(),
-                )
-            )
+    def exit_f_string(self, node: uni.FString) -> None:
+        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:
+        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_tuple_val(self, node: ast.TupleVal) -> None:
-        """Sub objects.
+    def exit_set_val(self, node: uni.SetVal) -> None:
+        elts = [cast(ast3.expr, i.gen.py_ast[0]) for i in node.values]
+        node.gen.py_ast = [self.sync(ast3.Set(elts=elts))]
 
-        values: Optional[SubNodeList[ExprType | Assignment]],
-        """
+    def exit_tuple_val(self, node: uni.TupleVal) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Tuple(
-                    elts=node.values.gen.py_ast if node.values else [],
-                    ctx=node.py_ctx_func(),
+                    elts=[cast(ast3.expr, i.gen.py_ast[0]) for i in node.values],
+                    ctx=cast(ast3.expr_context, node.py_ctx_func()),
                 )
             )
         ]
 
-    def exit_dict_val(self, node: ast.DictVal) -> None:
-        """Sub objects.
-
-        kv_pairs: Sequence[KVPair],
-        """
+    def exit_dict_val(self, node: uni.DictVal) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Dict(
                     keys=[
-                        (x.key.gen.py_ast[0] if x.key else None) for x in node.kv_pairs
+                        cast(ast3.expr, x.key.gen.py_ast[0]) if x.key else None
+                        for x in node.kv_pairs
+                    ],
+                    values=[
+                        cast(ast3.expr, x.value.gen.py_ast[0]) for x in node.kv_pairs
                     ],
-                    values=[x.value.gen.py_ast[0] for x in node.kv_pairs],
                 )
             )
         ]
 
-    def exit_k_v_pair(self, node: ast.KVPair) -> None:
-        """Sub objects.
-
-        key: ExprType,
-        value: ExprType,
-        """
-        # Processed elsewhere
-
-    def exit_k_w_pair(self, node: ast.KWPair) -> None:
-        """Sub objects.
+    def exit_k_v_pair(self, node: uni.KVPair) -> None:
+        pass
 
-        key: NameType,
-        value: ExprType,
-        """
+    def exit_k_w_pair(self, node: uni.KWPair) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.keyword(
                     arg=node.key.sym_name if node.key else None,
-                    value=node.value.gen.py_ast[0],
+                    value=cast(ast3.expr, node.value.gen.py_ast[0]),
                 )
             )
         ]
 
-    def exit_inner_compr(self, node: ast.InnerCompr) -> None:
-        """Sub objects.
-
-        out_expr: ExprType,
-        target: ExprType,
-        collection: ExprType,
-        conditional: Optional[ExprType],
-        """
+    def exit_inner_compr(self, node: uni.InnerCompr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.comprehension(
-                    target=node.target.gen.py_ast[0],
-                    iter=node.collection.gen.py_ast[0],
+                    target=cast(ast3.expr, node.target.gen.py_ast[0]),
+                    iter=cast(ast3.expr, node.collection.gen.py_ast[0]),
                     ifs=(
-                        [x.gen.py_ast[0] for x in node.conditional]
+                        [cast(ast3.expr, x.gen.py_ast[0]) for x in node.conditional]
                         if node.conditional
                         else []
                     ),
@@ -2630,129 +2394,107 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_list_compr(self, node: ast.ListCompr) -> None:
-        """Sub objects.
-
-        out_expr: ExprType,
-        compr: list[InnerCompr]
-        """
+    def exit_list_compr(self, node: uni.ListCompr) -> None:
         node.gen.py_ast = [
             self.sync(
-                ast3.Call(
-                    func=self.jaclib_obj("JacList"),
-                    args=[
-                        self.sync(
-                            ast3.ListComp(
-                                elt=node.out_expr.gen.py_ast[0],
-                                generators=[i.gen.py_ast[0] for i in node.compr],
-                            )
-                        )
-                    ],
-                    keywords=[],
+                ast3.ListComp(
+                    elt=cast(ast3.expr, node.out_expr.gen.py_ast[0]),
+                    generators=cast(
+                        list[ast3.comprehension], [i.gen.py_ast[0] for i in node.compr]
+                    ),
                 )
             )
         ]
 
-    def exit_gen_compr(self, node: ast.GenCompr) -> None:
-        """Sub objects.
-
-        out_expr: ExprType,
-        compr: list[InnerCompr]
-        """
+    def exit_gen_compr(self, node: uni.GenCompr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.GeneratorExp(
-                    elt=node.out_expr.gen.py_ast[0],
-                    generators=[i.gen.py_ast[0] for i in node.compr],
+                    elt=cast(ast3.expr, node.out_expr.gen.py_ast[0]),
+                    generators=[
+                        cast(ast3.comprehension, i.gen.py_ast[0]) for i in node.compr
+                    ],
                 )
             )
         ]
 
-    def exit_set_compr(self, node: ast.SetCompr) -> None:
-        """Sub objects.
-
-        out_expr: ExprType,
-        compr: list[InnerCompr]
-        """
+    def exit_set_compr(self, node: uni.SetCompr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.SetComp(
-                    elt=node.out_expr.gen.py_ast[0],
-                    generators=[i.gen.py_ast[0] for i in node.compr],
+                    elt=cast(ast3.expr, node.out_expr.gen.py_ast[0]),
+                    generators=[
+                        cast(ast3.comprehension, i.gen.py_ast[0]) for i in node.compr
+                    ],
                 )
             )
         ]
 
-    def exit_dict_compr(self, node: ast.DictCompr) -> None:
-        """Sub objects.
-
-        kv_pair: KVPair,
-        names: SubNodeList[AtomType],
-        collection: ExprType,
-        conditional: Optional[ExprType],
-        """
+    def exit_dict_compr(self, node: uni.DictCompr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.DictComp(
-                    key=node.kv_pair.key.gen.py_ast[0] if node.kv_pair.key else None,
-                    value=node.kv_pair.value.gen.py_ast[0],
-                    generators=[i.gen.py_ast[0] for i in node.compr],
+                    key=(
+                        cast(ast3.expr, node.kv_pair.key.gen.py_ast[0])
+                        if node.kv_pair.key
+                        else cast(ast3.expr, ast3.Constant(value=None))
+                    ),
+                    value=cast(ast3.expr, node.kv_pair.value.gen.py_ast[0]),
+                    generators=[
+                        cast(ast3.comprehension, i.gen.py_ast[0]) for i in node.compr
+                    ],
                 )
             )
         ]
 
-    def exit_atom_trailer(self, node: ast.AtomTrailer) -> None:
-        """Sub objects.
-
-        target: Expr,
-        right: AtomExpr | Expr,
-        is_attr: bool,
-        is_null_ok: bool,
-        is_genai: bool = False,
-        """
+    def exit_atom_trailer(self, node: uni.AtomTrailer) -> None:
         if node.is_genai:
             node.gen.py_ast = []
         if node.is_attr:
-            if isinstance(node.right, ast.AstSymbolNode):
+            if isinstance(node.right, uni.AstSymbolNode):
                 node.gen.py_ast = [
                     self.sync(
                         ast3.Attribute(
-                            value=node.target.gen.py_ast[0],
+                            value=cast(ast3.expr, node.target.gen.py_ast[0]),
                             attr=(node.right.sym_name),
-                            ctx=(node.right.py_ctx_func()),
+                            ctx=cast(ast3.expr_context, node.right.py_ctx_func()),
                         )
                     )
                 ]
             else:
-                self.error("Invalid attribute access")
-        elif isinstance(node.right, ast.FilterCompr):
+                self.log_error("Invalid attribute access")
+        elif isinstance(node.right, uni.FilterCompr):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=node.target.gen.py_ast[0],
-                                attr="filter",
-                                ctx=ast3.Load(),
-                            )
-                        ),
-                        args=cast(ast3.Tuple, node.right.gen.py_ast[0]).elts,
-                        keywords=[],
+                        func=self.jaclib_obj("filter"),
+                        args=[],
+                        keywords=[
+                            self.sync(
+                                ast3.keyword(
+                                    arg="items",
+                                    value=cast(ast3.expr, node.target.gen.py_ast[0]),
+                                )
+                            ),
+                            self.sync(
+                                ast3.keyword(
+                                    arg="func",
+                                    value=cast(ast3.expr, node.right.gen.py_ast[0]),
+                                )
+                            ),
+                        ],
                     )
                 )
             ]
-        elif isinstance(node.right, ast.AssignCompr):
+        elif isinstance(node.right, uni.AssignCompr):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Call(
-                        func=self.sync(
-                            ast3.Attribute(
-                                value=node.target.gen.py_ast[0],
-                                attr="assign",
-                                ctx=ast3.Load(),
-                            )
+                        func=self.jaclib_obj("assign"),
+                        args=cast(
+                            list[ast3.expr],
+                            [node.target.gen.py_ast[0], node.right.gen.py_ast[0]],
                         ),
-                        args=cast(ast3.Tuple, node.right.gen.py_ast[0]).elts,
                         keywords=[],
                     )
                 )
@@ -2761,11 +2503,11 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [
                 self.sync(
                     ast3.Subscript(
-                        value=node.target.gen.py_ast[0],
-                        slice=node.right.gen.py_ast[0],
+                        value=cast(ast3.expr, node.target.gen.py_ast[0]),
+                        slice=cast(ast3.expr, node.right.gen.py_ast[0]),
                         ctx=(
-                            node.right.py_ctx_func()
-                            if isinstance(node.right, ast.AstSymbolNode)
+                            cast(ast3.expr_context, node.right.py_ctx_func())
+                            if isinstance(node.right, uni.AstSymbolNode)
                             else ast3.Load()
                         ),
                     )
@@ -2785,27 +2527,22 @@ class PyastGenPass(Pass):
                                 target=self.sync(
                                     ast3.Name(id="__jac_tmp", ctx=ast3.Store())
                                 ),
-                                value=node.target.gen.py_ast[0],
+                                value=cast(ast3.expr, node.target.gen.py_ast[0]),
                             )
                         ),
-                        body=node.gen.py_ast[0],
+                        body=cast(ast3.expr, node.gen.py_ast[0]),
                         orelse=self.sync(ast3.Constant(value=None)),
                     )
                 )
             ]
 
-    def exit_atom_unit(self, node: ast.AtomUnit) -> None:
-        """Sub objects.
-
-        value: AtomType | ExprType,
-        is_paren: bool,
-        """
+    def exit_atom_unit(self, node: uni.AtomUnit) -> None:
         node.gen.py_ast = node.value.gen.py_ast
 
     def by_llm_call(
         self,
         model: ast3.AST,
-        model_params: dict[str, ast.Expr],
+        model_params: dict[str, uni.Expr],
         scope: ast3.AST,
         inputs: Sequence[Optional[ast3.AST]],
         outputs: Sequence[Optional[ast3.AST]] | ast3.Call,
@@ -2815,9 +2552,9 @@ class PyastGenPass(Pass):
     ) -> ast3.Call:
         """Return the LLM Call, e.g. _Jac.with_llm()."""
         # to avoid circular import
-        from jaclang.plugin.feature import JacFeature
+        from jaclang.runtimelib.machine import JacMachineInterface
 
-        return JacFeature.by_llm_call(
+        return JacMachineInterface.by_llm_call(
             self,
             model,
             model_params,
@@ -2829,31 +2566,31 @@ class PyastGenPass(Pass):
             exclude_info,
         )
 
-    def get_by_llm_call_args(self, node: ast.FuncCall) -> dict:
+    def get_by_llm_call_args(self, node: uni.FuncCall) -> dict:
         """Get the arguments for the by_llm_call."""
         # to avoid circular import
-        from jaclang.plugin.feature import JacFeature
-
-        return JacFeature.get_by_llm_call_args(self, node)
+        from jaclang.runtimelib.machine import JacMachineInterface
 
-    def exit_func_call(self, node: ast.FuncCall) -> None:
-        """Sub objects.
+        return JacMachineInterface.get_by_llm_call_args(self, node)
 
-        target: Expr,
-        params: Optional[SubNodeList[Expr | KWPair]],
-        """
+    def exit_func_call(self, node: uni.FuncCall) -> None:
         func = node.target.gen.py_ast[0]
         args = []
         keywords = []
-        if node.params and len(node.params.items) > 0:
-            for x in node.params.items:
-                if isinstance(x, ast.UnaryExpr) and x.op.name == Tok.STAR_POW:
+        if node.params:
+            for x in node.params:
+                if isinstance(x, uni.UnaryExpr) and x.op.name == Tok.STAR_POW:
                     keywords.append(
-                        self.sync(ast3.keyword(value=x.operand.gen.py_ast[0]), x)
+                        self.sync(
+                            ast3.keyword(
+                                value=cast(ast3.expr, x.operand.gen.py_ast[0])
+                            ),
+                            x,
+                        )
                     )
-                elif isinstance(x, ast.Expr):
+                elif isinstance(x, uni.Expr):
                     args.append(x.gen.py_ast[0])
-                elif isinstance(x, ast.KWPair) and isinstance(
+                elif isinstance(x, uni.KWPair) and isinstance(
                     x.gen.py_ast[0], ast3.keyword
                 ):
                     keywords.append(x.gen.py_ast[0])
@@ -2864,15 +2601,16 @@ class PyastGenPass(Pass):
             node.gen.py_ast = [self.sync(self.by_llm_call(**by_llm_call_args))]
         else:
             node.gen.py_ast = [
-                self.sync(ast3.Call(func=func, args=args, keywords=keywords))
+                self.sync(
+                    ast3.Call(
+                        func=cast(ast3.expr, func),
+                        args=[cast(ast3.expr, arg) for arg in args],
+                        keywords=keywords,
+                    )
+                )
             ]
 
-    def exit_index_slice(self, node: ast.IndexSlice) -> None:
-        """Sub objects.
-
-        slices: list[IndexSlice.Slice],
-        is_range: bool,
-        """
+    def exit_index_slice(self, node: uni.IndexSlice) -> None:
         if node.is_range:
             if len(node.slices) > 1:  # Multiple slices. Example arr[a:b, c:d]
                 node.gen.py_ast = [
@@ -2882,17 +2620,17 @@ class PyastGenPass(Pass):
                                 self.sync(
                                     ast3.Slice(
                                         lower=(
-                                            slice.start.gen.py_ast[0]
+                                            cast(ast3.expr, slice.start.gen.py_ast[0])
                                             if slice.start
                                             else None
                                         ),
                                         upper=(
-                                            slice.stop.gen.py_ast[0]
+                                            cast(ast3.expr, slice.stop.gen.py_ast[0])
                                             if slice.stop
                                             else None
                                         ),
                                         step=(
-                                            slice.step.gen.py_ast[0]
+                                            cast(ast3.expr, slice.step.gen.py_ast[0])
                                             if slice.step
                                             else None
                                         ),
@@ -2909,9 +2647,21 @@ class PyastGenPass(Pass):
                 node.gen.py_ast = [
                     self.sync(
                         ast3.Slice(
-                            lower=slice.start.gen.py_ast[0] if slice.start else None,
-                            upper=slice.stop.gen.py_ast[0] if slice.stop else None,
-                            step=slice.step.gen.py_ast[0] if slice.step else None,
+                            lower=(
+                                cast(ast3.expr, slice.start.gen.py_ast[0])
+                                if slice.start
+                                else None
+                            ),
+                            upper=(
+                                cast(ast3.expr, slice.stop.gen.py_ast[0])
+                                if slice.stop
+                                else None
+                            ),
+                            step=(
+                                cast(ast3.expr, slice.step.gen.py_ast[0])
+                                if slice.step
+                                else None
+                            ),
                         )
                     )
                 ]
@@ -2921,11 +2671,7 @@ class PyastGenPass(Pass):
             else:
                 node.gen.py_ast = []
 
-    def exit_special_var_ref(self, node: ast.SpecialVarRef) -> None:
-        """Sub objects.
-
-        var: Token,
-        """
+    def exit_special_var_ref(self, node: uni.SpecialVarRef) -> None:
         if node.name == Tok.KW_SUPER:
             node.gen.py_ast = [
                 self.sync(
@@ -2952,72 +2698,71 @@ class PyastGenPass(Pass):
                 self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
             ]
 
-    def exit_edge_ref_trailer(self, node: ast.EdgeRefTrailer) -> None:
-        """Sub objects.
-
-        chain: list[Expr|FilterCompr],
-        edges_only: bool,
-        """
+    def exit_edge_ref_trailer(self, node: uni.EdgeRefTrailer) -> None:
         pynode = node.chain[0].gen.py_ast[0]
         chomp = [*node.chain]
         last_edge = None
+        from_visit = bool(isinstance(node.parent, uni.VisitStmt))
         if node.edges_only:
             for i in node.chain:
-                if isinstance(i, ast.EdgeOpRef):
+                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, ast.EdgeOpRef):
+            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, ast.EdgeOpRef) and (
-                not next_i or not isinstance(next_i, ast.EdgeOpRef)
+            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, ast.FilterCompr)
+                        if next_i and not isinstance(next_i, uni.FilterCompr)
                         else None
                     ),
                     edges_only=node.edges_only and cur == last_edge,
+                    from_visit=from_visit,
                 )
-                if next_i and isinstance(next_i, ast.FilterCompr):
+                if next_i and isinstance(next_i, uni.FilterCompr):
                     pynode = self.sync(
                         ast3.Call(
-                            func=self.sync(
-                                ast3.Attribute(
-                                    value=pynode,
-                                    attr="filter",
-                                    ctx=ast3.Load(),
-                                )
-                            ),
-                            args=cast(ast3.Tuple, next_i.gen.py_ast[0]).elts,
-                            keywords=[],
+                            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, ast.EdgeOpRef) and isinstance(next_i, ast.EdgeOpRef):
+            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,
+                    from_visit=from_visit,
                 )
             else:
                 raise self.ice("Invalid edge ref trailer")
 
         node.gen.py_ast = [pynode]
 
-    def exit_edge_op_ref(self, node: ast.EdgeOpRef) -> None:
-        """Sub objects.
-
-        filter_type: Optional[ExprType],
-        filter_cond: Optional[FilterCompr],
-        edge_dir: EdgeDir,
-        """
+    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
@@ -3028,107 +2773,17 @@ class PyastGenPass(Pass):
     def translate_edge_op_ref(
         self,
         loc: ast3.AST,
-        node: ast.EdgeOpRef,
+        node: uni.EdgeOpRef,
         targ: ast3.AST | None,
         edges_only: bool,
+        from_visit: bool,
     ) -> ast3.AST:
         """Generate ast for edge op ref call."""
-        args = []
-        keywords = []
-
-        if node.filter_cond and node.filter_cond.f_type:
-            args.append(self.sync(node.filter_cond.f_type.gen.py_ast[0]))
-
-            edge_iter_name = "edge"
-            if node.filter_cond.compares:
-
-                expr: ast3.expr | None = None
-                comp = node.filter_cond.compares.items[0]
-                if (
-                    len(node.filter_cond.compares.items) == 1
-                    and isinstance(comp.gen.py_ast[0], ast3.Compare)
-                    and isinstance(comp.gen.py_ast[0].left, ast3.Name)
-                ):
-                    expr = self.sync(
-                        ast3.Compare(
-                            left=self.sync(
-                                ast3.Attribute(
-                                    value=self.sync(
-                                        ast3.Name(
-                                            id=edge_iter_name,
-                                            ctx=ast3.Load(),
-                                        ),
-                                        jac_node=comp,
-                                    ),
-                                    attr=comp.gen.py_ast[0].left.id,
-                                    ctx=ast3.Load(),
-                                ),
-                                jac_node=comp,
-                            ),
-                            ops=comp.gen.py_ast[0].ops,
-                            comparators=comp.gen.py_ast[0].comparators,
-                        ),
-                        jac_node=comp,
-                    )
-                else:
-                    expr = self.sync(
-                        ast3.BoolOp(
-                            op=self.sync(ast3.And()),
-                            values=[
-                                self.sync(
-                                    ast3.Compare(
-                                        left=self.sync(
-                                            ast3.Attribute(
-                                                value=self.sync(
-                                                    ast3.Name(
-                                                        id=edge_iter_name,
-                                                        ctx=ast3.Load(),
-                                                    ),
-                                                    jac_node=comp,
-                                                ),
-                                                attr=comp.gen.py_ast[0].left.id,
-                                                ctx=ast3.Load(),
-                                            ),
-                                            jac_node=comp,
-                                        ),
-                                        ops=comp.gen.py_ast[0].ops,
-                                        comparators=comp.gen.py_ast[0].comparators,
-                                    ),
-                                    jac_node=comp,
-                                )
-                                for comp in node.filter_cond.compares.items
-                                if isinstance(comp.gen.py_ast[0], ast3.Compare)
-                                and isinstance(comp.gen.py_ast[0].left, ast3.Name)
-                            ],
-                        ),
-                    )
-                assert expr is not None
-
-                args.append(
-                    self.sync(
-                        ast3.Lambda(
-                            args=self.sync(
-                                ast3.arguments(
-                                    posonlyargs=[],
-                                    args=[self.sync(ast3.arg(arg=edge_iter_name))],
-                                    kwonlyargs=[],
-                                    kw_defaults=[],
-                                    defaults=[],
-                                )
-                            ),
-                            body=expr,
-                        )
-                    )
-                )
+        keywords = [self.sync(ast3.keyword(arg="sources", value=cast(ast3.expr, loc)))]
 
-        if targ is not None:
+        if targ:
             keywords.append(
-                self.sync(
-                    ast3.keyword(
-                        arg="target",
-                        value=targ,
-                    )
-                )
+                self.sync(ast3.keyword(arg="targets", value=cast(ast3.expr, targ)))
             )
 
         if node.edge_dir != EdgeDir.OUT:
@@ -3147,6 +2802,18 @@ class PyastGenPass(Pass):
                 )
             )
 
+        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 edges_only:
             keywords.append(
                 self.sync(
@@ -3157,44 +2824,32 @@ class PyastGenPass(Pass):
                 )
             )
 
+        if from_visit:
+            keywords.append(
+                self.sync(
+                    ast3.keyword(
+                        arg="from_visit",
+                        value=self.sync(ast3.Constant(value=from_visit)),
+                    )
+                )
+            )
+
         return self.sync(
             ast3.Call(
-                func=self.sync(
-                    ast3.Attribute(
-                        value=loc,
-                        attr="refs",
-                        ctx=ast3.Load(),
-                    )
-                ),
-                args=args,
+                func=self.jaclib_obj("refs"),
+                args=[],
                 keywords=keywords,
             )
         )
 
-    def exit_disconnect_op(self, node: ast.DisconnectOp) -> None:
-        """Sub objects.
-
-        edge_spec: EdgeOpRef,
-        """
+    def exit_disconnect_op(self, node: uni.DisconnectOp) -> None:
         node.gen.py_ast = node.edge_spec.gen.py_ast
 
-    def exit_connect_op(self, node: ast.ConnectOp) -> None:
-        """Sub objects.
-
-        conn_type: Optional[ExprType],
-        conn_assign: Optional[AssignCompr],
-        edge_dir: EdgeDir,
-        """
+    def exit_connect_op(self, node: uni.ConnectOp) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Call(
-                    func=self.sync(
-                        ast3.Attribute(
-                            value=self.jaclib_obj(Con.JAC_FEATURE.value),
-                            attr="build_edge",
-                            ctx=ast3.Load(),
-                        )
-                    ),
+                    func=self.jaclib_obj("build_edge"),
                     args=[],
                     keywords=[
                         self.sync(
@@ -3209,7 +2864,7 @@ class PyastGenPass(Pass):
                             ast3.keyword(
                                 arg="conn_type",
                                 value=(
-                                    node.conn_type.gen.py_ast[0]
+                                    cast(ast3.expr, node.conn_type.gen.py_ast[0])
                                     if node.conn_type
                                     else self.sync(ast3.Constant(value=None))
                                 ),
@@ -3219,7 +2874,7 @@ class PyastGenPass(Pass):
                             ast3.keyword(
                                 arg="conn_assign",
                                 value=(
-                                    node.conn_assign.gen.py_ast[0]
+                                    cast(ast3.expr, node.conn_assign.gen.py_ast[0])
                                     if node.conn_assign
                                     else self.sync(ast3.Constant(value=None))
                                 ),
@@ -3230,13 +2885,39 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_filter_compr(self, node: ast.FilterCompr) -> None:
-        """Sub objects.
+    def exit_filter_compr(self, node: uni.FilterCompr) -> None:
+        iter_name = "i"
 
-        compares: SubNodeList[BinaryExpr],
-        """
-        iter_name = "item"
-        comprs = [
+        comprs: list[ast3.Compare | ast3.Call] = (
+            [
+                self.sync(
+                    ast3.Call(
+                        func=self.sync(
+                            ast3.Name(
+                                id="isinstance",
+                                ctx=ast3.Load(),
+                            )
+                        ),
+                        args=cast(
+                            list[ast3.expr],
+                            [
+                                self.sync(
+                                    ast3.Name(
+                                        id=iter_name,
+                                        ctx=ast3.Load(),
+                                    )
+                                ),
+                                self.sync(node.f_type.gen.py_ast[0]),
+                            ],
+                        ),
+                        keywords=[],
+                    )
+                )
+            ]
+            if node.f_type
+            else []
+        )
+        comprs.extend(
             self.sync(
                 ast3.Compare(
                     left=self.sync(
@@ -3258,249 +2939,174 @@ class PyastGenPass(Pass):
                 ),
                 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)
-        ]
+        )
 
-        body = (
+        if body := (
             self.sync(
                 ast3.BoolOp(
                     op=self.sync(ast3.And()),
-                    values=comprs,
+                    values=[cast(ast3.expr, item) for item in comprs],
                 )
             )
             if len(comprs) > 1
             else (comprs[0] if comprs else None)
-        )
-
-        node.gen.py_ast = [
-            self.sync(
-                ast3.Tuple(
-                    elts=[
-                        (
-                            self.sync(node.f_type.gen.py_ast[0])
-                            if node.f_type
-                            else self.sync(ast3.Constant(value=None))
-                        ),
-                        (
-                            self.sync(
-                                ast3.Lambda(
-                                    args=self.sync(
-                                        ast3.arguments(
-                                            posonlyargs=[],
-                                            args=[self.sync(ast3.arg(arg=iter_name))],
-                                            kwonlyargs=[],
-                                            kw_defaults=[],
-                                            defaults=[],
-                                        )
-                                    ),
-                                    body=body,
-                                )
+        ):
+            node.gen.py_ast = [
+                self.sync(
+                    ast3.Lambda(
+                        args=self.sync(
+                            ast3.arguments(
+                                posonlyargs=[],
+                                args=[self.sync(ast3.arg(arg=iter_name))],
+                                kwonlyargs=[],
+                                kw_defaults=[],
+                                defaults=[],
                             )
-                            if body
-                            else self.sync(ast3.Constant(value=None))
                         ),
-                    ],
-                    ctx=ast3.Load(),
+                        body=body,
+                    )
                 )
-            )
-        ]
-
-    def exit_assign_compr(self, node: ast.AssignCompr) -> None:
-        """Sub objects.
+            ]
 
-        assigns: SubNodeList[KWPair],
-        """
+    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])
-        key_tup = self.sync(ast3.Tuple(elts=keys, ctx=ast3.Load()))
-        val_tup = self.sync(ast3.Tuple(elts=values, ctx=ast3.Load()))
+        key_tup = self.sync(
+            ast3.Tuple(
+                elts=[key for key in keys if isinstance(key, ast3.expr)],
+                ctx=ast3.Load(),
+            )
+        )
+        val_tup = self.sync(
+            ast3.Tuple(
+                elts=[v for v in values if isinstance(v, ast3.expr)], ctx=ast3.Load()
+            )
+        )
         node.gen.py_ast = [
             self.sync(ast3.Tuple(elts=[key_tup, val_tup], ctx=ast3.Load()))
         ]
 
-    def exit_match_stmt(self, node: ast.MatchStmt) -> None:
-        """Sub objects.
-
-        target: Expr,
-        cases: list[MatchCase],
-        """
+    def exit_match_stmt(self, node: uni.MatchStmt) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.Match(
-                    subject=node.target.gen.py_ast[0],
-                    cases=[x.gen.py_ast[0] for x in node.cases],
+                    subject=cast(ast3.expr, node.target.gen.py_ast[0]),
+                    cases=[cast(ast3.match_case, x.gen.py_ast[0]) for x in node.cases],
                 )
             )
         ]
 
-    def exit_match_case(self, node: ast.MatchCase) -> None:
-        """Sub objects.
-
-        pattern: MatchPattern,
-        guard: Optional[ExprType],
-        body: list[CodeBlockStmt],
-        """
+    def exit_match_case(self, node: uni.MatchCase) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.match_case(
-                    pattern=node.pattern.gen.py_ast[0],
-                    guard=node.guard.gen.py_ast[0] if node.guard else None,
-                    body=[x.gen.py_ast[0] for x in node.body],
+                    pattern=cast(ast3.pattern, node.pattern.gen.py_ast[0]),
+                    guard=(
+                        cast(ast3.expr, node.guard.gen.py_ast[0])
+                        if node.guard
+                        else None
+                    ),
+                    body=[cast(ast3.stmt, x.gen.py_ast[0]) for x in node.body],
                 )
             )
         ]
 
-    def exit_match_or(self, node: ast.MatchOr) -> None:
-        """Sub objects.
-
-        patterns: list[MatchPattern],
-        """
+    def exit_match_or(self, node: uni.MatchOr) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.MatchOr(
-                    patterns=[x.gen.py_ast[0] for x in node.patterns],
+                    patterns=[
+                        cast(ast3.pattern, x.gen.py_ast[0]) for x in node.patterns
+                    ],
                 )
             )
         ]
 
-    def exit_match_as(self, node: ast.MatchAs) -> None:
-        """Sub objects.
-
-        name: NameType,
-        pattern: MatchPattern,
-        """
+    def exit_match_as(self, node: uni.MatchAs) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.MatchAs(
                     name=node.name.sym_name,
-                    pattern=node.pattern.gen.py_ast[0] if node.pattern else None,
+                    pattern=(
+                        cast(ast3.pattern, node.pattern.gen.py_ast[0])
+                        if node.pattern
+                        else None
+                    ),
                 )
             )
         ]
 
-    def exit_match_wild(self, node: ast.MatchWild) -> None:
-        """Sub objects."""
+    def exit_match_wild(self, node: uni.MatchWild) -> None:
         node.gen.py_ast = [self.sync(ast3.MatchAs())]
 
-    def exit_match_value(self, node: ast.MatchValue) -> None:
-        """Sub objects.
-
-        value: ExprType,
-        """
-        node.gen.py_ast = [self.sync(ast3.MatchValue(value=node.value.gen.py_ast[0]))]
-
-    def exit_match_singleton(self, node: ast.MatchSingleton) -> None:
-        """Sub objects.
+    def exit_match_value(self, node: uni.MatchValue) -> None:
+        node.gen.py_ast = [
+            self.sync(ast3.MatchValue(value=cast(ast3.expr, node.value.gen.py_ast[0])))
+        ]
 
-        value: Bool | Null,
-        """
+    def exit_match_singleton(self, node: uni.MatchSingleton) -> None:
         node.gen.py_ast = [self.sync(ast3.MatchSingleton(value=node.value.lit_value))]
 
-    def exit_match_sequence(self, node: ast.MatchSequence) -> None:
-        """Sub objects.
-
-        values: list[MatchPattern],
-        """
+    def exit_match_sequence(self, node: uni.MatchSequence) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.MatchSequence(
-                    patterns=[x.gen.py_ast[0] for x in node.values],
+                    patterns=[cast(ast3.pattern, x.gen.py_ast[0]) for x in node.values],
                 )
             )
         ]
 
-    def exit_match_mapping(self, node: ast.MatchMapping) -> None:
-        """Sub objects.
-
-        values: list[MatchKVPair | MatchStar],
-        """
+    def exit_match_mapping(self, node: uni.MatchMapping) -> None:
         mapping = self.sync(ast3.MatchMapping(keys=[], patterns=[], rest=None))
         for i in node.values:
             if (
-                isinstance(i, ast.MatchKVPair)
-                and isinstance(i.key, ast.MatchValue)
+                isinstance(i, uni.MatchKVPair)
+                and isinstance(i.key, uni.MatchValue)
                 and isinstance(i.key.value.gen.py_ast[0], ast3.expr)
                 and isinstance(i.value.gen.py_ast[0], ast3.pattern)
             ):
                 mapping.keys.append(i.key.value.gen.py_ast[0])
                 mapping.patterns.append(i.value.gen.py_ast[0])
-            elif isinstance(i, ast.MatchStar):
+            elif isinstance(i, uni.MatchStar):
                 mapping.rest = i.name.sym_name
         node.gen.py_ast = [mapping]
 
-    def exit_match_k_v_pair(self, node: ast.MatchKVPair) -> None:
-        """Sub objects.
-
-        key: MatchPattern | NameType,
-        value: MatchPattern,
-        """
-        node.gen.py_ast = [
-            self.sync(
-                ast3.MatchMapping(
-                    patterns=[node.key.gen.py_ast[0], node.value.gen.py_ast[0]],
-                )
-            )
-        ]
-
-    def exit_match_star(self, node: ast.MatchStar) -> None:
-        """Sub objects.
+    def exit_match_k_v_pair(self, node: uni.MatchKVPair) -> None:
+        pass
 
-        name: NameType,
-        is_list: bool,
-        """
+    def exit_match_star(self, node: uni.MatchStar) -> None:
         node.gen.py_ast = [self.sync(ast3.MatchStar(name=node.name.sym_name))]
 
-    def exit_match_arch(self, node: ast.MatchArch) -> None:
-        """Sub objects.
-
-        name: NameType,
-        arg_patterns: Optional[SubNodeList[MatchPattern]],
-        kw_patterns: Optional[SubNodeList[MatchKVPair]],
-        """
+    def exit_match_arch(self, node: uni.MatchArch) -> None:
         node.gen.py_ast = [
             self.sync(
                 ast3.MatchClass(
-                    cls=node.name.gen.py_ast[0],
-                    patterns=(
-                        [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, ast.NameAtom)
-                        ]
-                        if node.kw_patterns
-                        else []
-                    ),
-                    kwd_patterns=(
-                        [x.value.gen.py_ast[0] for x in node.kw_patterns.items]
-                        if node.kw_patterns
-                        else []
-                    ),
+                    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 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: ast.Token) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    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:
@@ -3558,46 +3164,15 @@ class PyastGenPass(Pass):
         elif node.name == Tok.KW_NIN:
             node.gen.py_ast = [self.sync(ast3.NotIn())]
 
-    def exit_name(self, node: ast.Name) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_name(self, node: uni.Name) -> None:
         node.gen.py_ast = [
             self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
         ]
 
-    def exit_float(self, node: ast.Float) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_float(self, node: uni.Float) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=float(node.value)))]
 
-    def exit_int(self, node: ast.Int) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
-
+    def exit_int(self, node: uni.Int) -> None:
         def handle_node_value(value: str) -> int:
             if value.startswith(("0x", "0X")):
                 return int(value, 16)
@@ -3614,93 +3189,25 @@ class PyastGenPass(Pass):
             )
         ]
 
-    def exit_string(self, node: ast.String) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_string(self, node: uni.String) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=node.lit_value))]
 
-    def exit_bool(self, node: ast.Bool) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_bool(self, node: uni.Bool) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=node.value == "True"))]
 
-    def exit_builtin_type(self, node: ast.BuiltinType) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_builtin_type(self, node: uni.BuiltinType) -> None:
         node.gen.py_ast = [
             self.sync(ast3.Name(id=node.sym_name, ctx=node.py_ctx_func()))
         ]
 
-    def exit_null(self, node: ast.Null) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_null(self, node: uni.Null) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=None))]
 
-    def exit_ellipsis(self, node: ast.Ellipsis) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_ellipsis(self, node: uni.Ellipsis) -> None:
         node.gen.py_ast = [self.sync(ast3.Constant(value=...))]
 
-    def exit_semi(self, node: ast.Semi) -> None:
-        """Sub objects.
-
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
-
-    def exit_comment_token(self, node: ast.CommentToken) -> None:
-        """Sub objects.
+    def exit_semi(self, node: uni.Semi) -> None:
+        pass
 
-        file_path: str,
-        name: str,
-        value: str,
-        col_start: int,
-        col_end: int,
-        pos_start: int,
-        pos_end: int,
-        """
+    def exit_comment_token(self, node: uni.CommentToken) -> None:
+        pass