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

jaclang/compiler/{absyntree.py → unitree.py}

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast as ast3
 import builtins
 import os
+from copy import copy
 from dataclasses import dataclass
 from hashlib import md5
 from types import EllipsisType
@@ -14,14 +15,13 @@ from typing import (
     Generic,
     Optional,
     Sequence,
-    TYPE_CHECKING,
     Type,
     TypeVar,
 )
 
 
 from jaclang.compiler import TOKEN_MAP
-from jaclang.compiler.codeloc import CodeGenTarget, CodeLocInfo
+from jaclang.compiler.codeinfo import CodeGenTarget, CodeLocInfo
 from jaclang.compiler.constant import (
     Constants as Con,
     EdgeDir,
@@ -30,70 +30,89 @@ from jaclang.compiler.constant import (
     SymbolType,
 )
 from jaclang.compiler.constant import DELIM_MAP, SymbolAccess, Tokens as Tok
-from jaclang.compiler.py_info import PyInfo
-from jaclang.compiler.semtable import SemRegistry
-from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
-
-if TYPE_CHECKING:
-    from jaclang.compiler.symtable import Symbol, SymbolTable
+from jaclang.utils import resolve_relative_path
+from jaclang.utils.treeprinter import (
+    dotgen_ast_tree,
+    dotgen_symtab_tree,
+    print_ast_tree,
+    print_symtab_tree,
+)
 
 
-class AstNode:
+class UniNode:
     """Abstract syntax tree node for Jac."""
 
-    def __init__(self, kid: Sequence[AstNode]) -> None:
+    def __init__(self, kid: Sequence[UniNode]) -> None:
         """Initialize ast."""
-        self.parent: Optional[AstNode] = None
-        self.kid: list[AstNode] = [x.set_parent(self) for x in kid]
-        self._sym_tab: Optional[SymbolTable] = None
-        self._sub_node_tab: dict[type, list[AstNode]] = {}
-        self._in_mod_nodes: list[AstNode] = []
+        self.parent: Optional[UniNode] = None
+        self.kid: list[UniNode] = [x.set_parent(self) for x in kid]
+        self._sub_node_tab: dict[type, list[UniNode]] = {}
+        self.construct_sub_node_tab()
+        self._in_mod_nodes: list[UniNode] = []
         self.gen: CodeGenTarget = CodeGenTarget()
-        self.meta: dict[str, str] = {}
         self.loc: CodeLocInfo = CodeLocInfo(*self.resolve_tok_range())
 
+    def construct_sub_node_tab(self) -> None:
+        """Construct sub node table."""
+        for i in self.kid:
+            if not i:
+                continue
+            for k, v in i._sub_node_tab.items():
+                if k in self._sub_node_tab:
+                    self._sub_node_tab[k].extend(v)
+                else:
+                    self._sub_node_tab[k] = copy(v)
+            if type(i) in self._sub_node_tab:
+                self._sub_node_tab[type(i)].append(i)
+            else:
+                self._sub_node_tab[type(i)] = [i]
+
     @property
-    def sym_tab(self) -> SymbolTable:
+    def sym_tab(self) -> UniScopeNode:
         """Get symbol table."""
-        # sym_tab should never be accessed without being set in codebase
-        if not self._sym_tab:
-            raise ValueError(
-                f"Symbol table not set for {type(self).__name__}. Impossible.\n"
-                f"Node: {self.pp()}\n"
-                f"Parent: {self.parent.pp() if self.parent else None}\n"
-            )
-        return self._sym_tab
-
-    @sym_tab.setter
-    def sym_tab(self, sym_tab: SymbolTable) -> None:
-        """Set symbol table."""
-        self._sym_tab = sym_tab
+        return (
+            self
+            if isinstance(self, UniScopeNode)
+            else self.parent_of_type(UniScopeNode)
+        )
 
     def add_kids_left(
-        self, nodes: Sequence[AstNode], pos_update: bool = True
-    ) -> AstNode:
+        self,
+        nodes: Sequence[UniNode],
+        pos_update: bool = True,
+        parent_update: bool = False,
+    ) -> UniNode:
         """Add kid left."""
         self.kid = [*nodes, *self.kid]
         if pos_update:
             for i in nodes:
                 i.parent = self
             self.loc.update_first_token(self.kid[0].loc.first_tok)
+        elif parent_update:
+            for i in nodes:
+                i.parent = self
         return self
 
     def add_kids_right(
-        self, nodes: Sequence[AstNode], pos_update: bool = True
-    ) -> AstNode:
+        self,
+        nodes: Sequence[UniNode],
+        pos_update: bool = True,
+        parent_update: bool = False,
+    ) -> UniNode:
         """Add kid right."""
         self.kid = [*self.kid, *nodes]
         if pos_update:
             for i in nodes:
                 i.parent = self
             self.loc.update_last_token(self.kid[-1].loc.last_tok)
+        elif parent_update:
+            for i in nodes:
+                i.parent = self
         return self
 
     def insert_kids_at_pos(
-        self, nodes: Sequence[AstNode], pos: int, pos_update: bool = True
-    ) -> AstNode:
+        self, nodes: Sequence[UniNode], pos: int, pos_update: bool = True
+    ) -> UniNode:
         """Insert kids at position."""
         self.kid = [*self.kid[:pos], *nodes, *self.kid[pos:]]
         if pos_update:
@@ -102,7 +121,7 @@ class AstNode:
             self.loc.update_token_range(*self.resolve_tok_range())
         return self
 
-    def set_kids(self, nodes: Sequence[AstNode]) -> AstNode:
+    def set_kids(self, nodes: Sequence[UniNode]) -> UniNode:
         """Set kids."""
         self.kid = [*nodes]
         for i in nodes:
@@ -110,13 +129,12 @@ class AstNode:
         self.loc.update_token_range(*self.resolve_tok_range())
         return self
 
-    def set_parent(self, parent: AstNode) -> AstNode:
+    def set_parent(self, parent: UniNode) -> UniNode:
         """Set parent."""
         self.parent = parent
         return self
 
     def resolve_tok_range(self) -> tuple[Token, Token]:
-        """Get token range."""
         if len(self.kid):
             return (
                 self.kid[0].loc.first_tok,
@@ -128,7 +146,6 @@ class AstNode:
             raise ValueError(f"Empty kid for Token {type(self).__name__}")
 
     def gen_token(self, name: Tok, value: Optional[str] = None) -> Token:
-        """Generate token."""
         value = (
             value
             if value
@@ -152,29 +169,22 @@ class AstNode:
 
     def get_all_sub_nodes(self, typ: Type[T], brute_force: bool = True) -> list[T]:
         """Get all sub nodes of type."""
-        from jaclang.compiler.passes import Pass
+        from jaclang.compiler.passes import UniPass
 
-        return Pass.get_all_sub_nodes(node=self, typ=typ, brute_force=brute_force)
+        return UniPass.get_all_sub_nodes(node=self, typ=typ, brute_force=brute_force)
 
     def find_parent_of_type(self, typ: Type[T]) -> Optional[T]:
         """Get parent of type."""
-        from jaclang.compiler.passes import Pass
+        from jaclang.compiler.passes import UniPass
 
-        return Pass.find_parent_of_type(node=self, typ=typ)
+        return UniPass.find_parent_of_type(node=self, typ=typ)
 
     def parent_of_type(self, typ: Type[T]) -> T:
-        """Get parent of type."""
         ret = self.find_parent_of_type(typ)
         if isinstance(ret, typ):
             return ret
         else:
-            raise ValueError(f"Parent of type {typ} not found.")
-
-    def format(self) -> str:
-        """Get all sub nodes of type."""
-        from jaclang.compiler.passes.tool import JacFormatPass
-
-        return JacFormatPass(self, None).ir.gen.jac
+            raise ValueError(f"Parent of type {typ} not found from {type(self)}.")
 
     def to_dict(self) -> dict[str, str]:
         """Return dict representation of node."""
@@ -197,7 +207,7 @@ class AstNode:
         """Print ast."""
         return dotgen_ast_tree(self)
 
-    def flatten(self) -> list[AstNode]:
+    def flatten(self) -> list[UniNode]:
         """Flatten ast."""
         ret = [self]
         for k in self.kid:
@@ -205,11 +215,9 @@ class AstNode:
         return ret
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         return False
 
     def unparse(self) -> str:
-        """Unparse ast node."""
         valid = self.normalize()
         res = " ".join([i.unparse() for i in self.kid])
         if not valid:
@@ -217,13 +225,325 @@ class AstNode:
         return res
 
 
-class AstSymbolNode(AstNode):
+# Symbols can have mulitple definitions but resolves decl to be the
+# first such definition in a given scope.
+class Symbol:
+    """Symbol."""
+
+    def __init__(
+        self,
+        defn: NameAtom,
+        access: SymbolAccess,
+        parent_tab: UniScopeNode,
+    ) -> None:
+        """Initialize."""
+        self.defn: list[NameAtom] = [defn]
+        self.uses: list[NameAtom] = []
+        defn.sym = self
+        self.access: SymbolAccess = access
+        self.parent_tab = parent_tab
+
+    @property
+    def decl(self) -> NameAtom:
+        """Get decl."""
+        return self.defn[0]
+
+    @property
+    def sym_name(self) -> str:
+        """Get name."""
+        return self.decl.sym_name
+
+    @property
+    def sym_type(self) -> SymbolType:
+        """Get sym_type."""
+        return self.decl.sym_category
+
+    @property
+    def sym_dotted_name(self) -> str:
+        """Return a full path of the symbol."""
+        out = [self.defn[0].sym_name]
+        current_tab: UniScopeNode | None = self.parent_tab
+        while current_tab is not None:
+            out.append(current_tab.scope_name)
+            current_tab = current_tab.parent_scope
+        out.reverse()
+        return ".".join(out)
+
+    @property
+    def fetch_sym_tab(self) -> Optional[UniScopeNode]:
+        """Get symbol table."""
+        return self.parent_tab.find_scope(self.sym_name)
+
+    def add_defn(self, node: NameAtom) -> None:
+        """Add defn."""
+        self.defn.append(node)
+        node.sym = self
+
+    def add_use(self, node: NameAtom) -> None:
+        """Add use."""
+        self.uses.append(node)
+        node.sym = self
+
+    def __repr__(self) -> str:
+        """Repr."""
+        return f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, {self.defn})"
+
+
+class UniScopeNode(UniNode):
+    """Symbol Table."""
+
+    def __init__(
+        self,
+        name: str,
+        parent_scope: Optional[UniScopeNode] = None,
+    ) -> None:
+        """Initialize."""
+        self.scope_name = name
+        self.parent_scope = parent_scope
+        self.kid_scope: list[UniScopeNode] = []
+        self.names_in_scope: dict[str, Symbol] = {}
+        self.inherited_scope: list[InheritedSymbolTable] = []
+
+    def get_type(self) -> SymbolType:
+        """Get type."""
+        if isinstance(self, AstSymbolNode):
+            return self.sym_category
+        return SymbolType.VAR
+
+    def get_parent(self) -> Optional[UniScopeNode]:
+        """Get parent."""
+        return self.parent_scope
+
+    def lookup(self, name: str, deep: bool = True) -> Optional[Symbol]:
+        """Lookup a variable in the symbol table."""
+        if name in self.names_in_scope:
+            return self.names_in_scope[name]
+        for i in self.inherited_scope:
+            found = i.lookup(name, deep=False)
+            if found:
+                return found
+        if deep and self.parent_scope:
+            return self.parent_scope.lookup(name, deep)
+        return None
+
+    def insert(
+        self,
+        node: AstSymbolNode,
+        access_spec: Optional[AstAccessNode] | SymbolAccess = None,
+        single: bool = False,
+        force_overwrite: bool = False,
+    ) -> Optional[UniNode]:
+        """Set a variable in the symbol table.
+
+        Returns original symbol as collision if single check fails, none otherwise.
+        Also updates node.sym to create pointer to symbol.
+        """
+        collision = (
+            self.names_in_scope[node.sym_name].defn[-1]
+            if single and node.sym_name in self.names_in_scope
+            else None
+        )
+        if force_overwrite or node.sym_name not in self.names_in_scope:
+            self.names_in_scope[node.sym_name] = Symbol(
+                defn=node.name_spec,
+                access=(
+                    access_spec
+                    if isinstance(access_spec, SymbolAccess)
+                    else access_spec.access_type if access_spec else SymbolAccess.PUBLIC
+                ),
+                parent_tab=self,
+            )
+        else:
+            self.names_in_scope[node.sym_name].add_defn(node.name_spec)
+        node.name_spec.sym = self.names_in_scope[node.sym_name]
+        return collision
+
+    def find_scope(self, name: str) -> Optional[UniScopeNode]:
+        """Find a scope in the symbol table."""
+        for k in self.kid_scope:
+            if k.scope_name == name:
+                return k
+        for k2 in self.inherited_scope:
+            if k2.base_symbol_table.scope_name == name:
+                return k2.base_symbol_table
+        return None
+
+    def link_kid_scope(self, key_node: UniScopeNode) -> UniScopeNode:
+        """Push a new scope onto the symbol table."""
+        key_node.parent_scope = self
+        self.kid_scope.append(key_node)
+        return self.kid_scope[-1]
+
+    def inherit_sym_tab(self, target_sym_tab: UniScopeNode) -> None:
+        """Inherit symbol table."""
+        for i in target_sym_tab.names_in_scope.values():
+            self.def_insert(i.decl, access_spec=i.access)
+
+    def def_insert(
+        self,
+        node: AstSymbolNode,
+        access_spec: Optional[AstAccessNode] | SymbolAccess = None,
+        single_decl: Optional[str] = None,
+        force_overwrite: bool = False,
+    ) -> Optional[Symbol]:
+        """Insert into symbol table."""
+        if node.sym and self == node.sym.parent_tab:
+            return node.sym
+        self.insert(
+            node=node,
+            single=single_decl is not None,
+            access_spec=access_spec,
+            force_overwrite=force_overwrite,
+        )
+        self.update_py_ctx_for_def(node)
+        return node.sym
+
+    def chain_def_insert(self, node_list: list[AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: UniScopeNode | None = node_list[0].sym_tab
+        node_list[-1].name_spec.py_ctx_func = ast3.Store
+        if isinstance(node_list[-1].name_spec, AstSymbolNode):
+            node_list[-1].name_spec.py_ctx_func = ast3.Store
+
+        node_list = node_list[:-1]  # Just performs lookup mappings of pre assign chain
+        for i in node_list:
+            cur_sym_tab = (
+                lookup.decl.sym_tab
+                if (
+                    lookup := self.use_lookup(
+                        i,
+                        sym_table=cur_sym_tab,
+                    )
+                )
+                else None
+            )
+
+    def use_lookup(
+        self,
+        node: AstSymbolNode,
+        sym_table: Optional[UniScopeNode] = None,
+    ) -> Optional[Symbol]:
+        """Link to symbol."""
+        if node.sym:
+            return node.sym
+        if not sym_table:
+            sym_table = node.sym_tab
+        if sym_table:
+            lookup = sym_table.lookup(name=node.sym_name, deep=True)
+            lookup.add_use(node.name_spec) if lookup else None
+        return node.sym
+
+    def chain_use_lookup(self, node_list: Sequence[AstSymbolNode]) -> None:
+        """Link chain of containing names to symbol."""
+        if not node_list:
+            return
+        cur_sym_tab: UniScopeNode | None = node_list[0].sym_tab
+        for i in node_list:
+            if cur_sym_tab is None:
+                break
+            lookup = self.use_lookup(i, sym_table=cur_sym_tab)
+            if lookup:
+                cur_sym_tab = lookup.decl.sym_tab
+
+                # check if the symbol table name is not the same as symbol name
+                # then try to find a child scope with the same name
+                # This is used to get the scope in case of
+                #      import math;
+                #      b = math.floor(1.7);
+                if cur_sym_tab.scope_name != i.sym_name:
+                    t = cur_sym_tab.find_scope(i.sym_name)
+                    if t:
+                        cur_sym_tab = t
+            else:
+                cur_sym_tab = None
+
+    def update_py_ctx_for_def(self, node: AstSymbolNode) -> None:
+        """Update python context for definition."""
+        node.name_spec.py_ctx_func = ast3.Store
+        if isinstance(node, (TupleVal, ListVal)) and node.values:
+            # Handling of UnaryExpr case for item is only necessary for
+            # the generation of Starred nodes in the AST for examples
+            # like `(a, *b) = (1, 2, 3, 4)`.
+            def fix(item: TupleVal | ListVal | UnaryExpr) -> None:
+                if isinstance(item, UnaryExpr):
+                    if isinstance(item.operand, AstSymbolNode):
+                        item.operand.name_spec.py_ctx_func = ast3.Store
+                elif isinstance(item, (TupleVal, ListVal)):
+                    for i in item.values.items if item.values else []:
+                        if isinstance(i, AstSymbolNode):
+                            i.name_spec.py_ctx_func = ast3.Store
+                        elif isinstance(i, AtomTrailer):
+                            self.chain_def_insert(i.as_attr_list)
+                        if isinstance(i, (TupleVal, ListVal, UnaryExpr)):
+                            fix(i)
+
+            fix(node)
+
+    def inherit_baseclasses_sym(self, node: Archetype | Enum) -> None:
+        """Inherit base classes symbol tables."""
+        if node.base_classes:
+            for base_cls in node.base_classes.items:
+                if (
+                    isinstance(base_cls, AstSymbolNode)
+                    and (found := self.use_lookup(base_cls))
+                    and found
+                ):
+                    found_tab = found.decl.sym_tab
+                    inher_sym_tab = InheritedSymbolTable(
+                        base_symbol_table=found_tab, load_all_symbols=True, symbols=[]
+                    )
+                    self.inherited_scope.append(inher_sym_tab)
+                    base_cls.name_spec.name_of = found.decl.name_of
+
+    def sym_pp(self, depth: Optional[int] = None) -> str:
+        """Pretty print."""
+        return print_symtab_tree(root=self, depth=depth)
+
+    def sym_dotgen(self) -> str:
+        """Generate dot graph for sym table."""
+        return dotgen_symtab_tree(self)
+
+    def __repr__(self) -> str:
+        """Repr."""
+        out = f"{self.scope_name} {super().__repr__()}:\n"
+        for k, v in self.names_in_scope.items():
+            out += f"    {k}: {v}\n"
+        return out
+
+
+class InheritedSymbolTable:
+    """Inherited symbol table."""
+
+    def __init__(
+        self,
+        base_symbol_table: UniScopeNode,
+        load_all_symbols: bool = False,  # This is needed for python imports
+        symbols: Optional[list[str]] = None,
+    ) -> None:
+        """Initialize."""
+        self.base_symbol_table: UniScopeNode = base_symbol_table
+        self.load_all_symbols: bool = load_all_symbols
+        self.symbols: list[str] = symbols if symbols else []
+
+    def lookup(self, name: str, deep: bool = False) -> Optional[Symbol]:
+        """Lookup a variable in the symbol table."""
+        if self.load_all_symbols:
+            return self.base_symbol_table.lookup(name, deep)
+        else:
+            if name in self.symbols:
+                return self.base_symbol_table.lookup(name, deep)
+            else:
+                return None
+
+
+class AstSymbolNode(UniNode):
     """Nodes that have link to a symbol in symbol table."""
 
     def __init__(
         self, sym_name: str, name_spec: NameAtom, sym_category: SymbolType
     ) -> None:
-        """Initialize ast."""
         self.name_spec = name_spec
         self.name_spec.name_of = self
         self.name_spec._sym_name = sym_name
@@ -231,31 +551,26 @@ class AstSymbolNode(AstNode):
 
     @property
     def sym(self) -> Optional[Symbol]:
-        """Get symbol."""
         return self.name_spec.sym
 
     @property
     def sym_name(self) -> str:
-        """Get symbol name."""
         return self.name_spec.sym_name
 
     @property
     def sym_category(self) -> SymbolType:
-        """Get symbol category."""
         return self.name_spec.sym_category
 
     @property
     def py_ctx_func(self) -> Type[ast3.AST]:
-        """Get python context function."""
         return self.name_spec.py_ctx_func
 
     @property
     def expr_type(self) -> str:
-        """Get symbol type."""
         return self.name_spec.expr_type
 
     @property
-    def type_sym_tab(self) -> Optional[SymbolTable]:
+    def type_sym_tab(self) -> Optional[UniScopeNode]:
         """Get type symbol table."""
         return self.name_spec.type_sym_tab
 
@@ -264,7 +579,6 @@ class AstSymbolStubNode(AstSymbolNode):
     """Nodes that have link to a symbol in symbol table."""
 
     def __init__(self, sym_type: SymbolType) -> None:
-        """Initialize ast."""
         AstSymbolNode.__init__(
             self,
             sym_name=f"[{self.__class__.__name__}]",
@@ -273,16 +587,14 @@ class AstSymbolStubNode(AstSymbolNode):
         )
 
 
-class AstAccessNode(AstNode):
+class AstAccessNode(UniNode):
     """Nodes that have access."""
 
     def __init__(self, access: Optional[SubTag[Token]]) -> None:
-        """Initialize ast."""
         self.access: Optional[SubTag[Token]] = access
 
     @property
     def access_type(self) -> SymbolAccess:
-        """Get access spec."""
         return (
             SymbolAccess.PRIVATE
             if self.access and self.access.tag.name == Tok.KW_PRIV
@@ -294,85 +606,130 @@ class AstAccessNode(AstNode):
         )
 
 
-T = TypeVar("T", bound=AstNode)
+T = TypeVar("T", bound=UniNode)
 
 
-class AstDocNode(AstNode):
+class AstDocNode(UniNode):
     """Nodes that have access."""
 
     def __init__(self, doc: Optional[String]) -> None:
-        """Initialize ast."""
         self.doc: Optional[String] = doc
 
 
-class AstSemStrNode(AstNode):
-    """Nodes that have access."""
-
-    def __init__(self, semstr: Optional[String]) -> None:
-        """Initialize ast."""
-        self.semstr: Optional[String] = semstr
-
-
-class AstAsyncNode(AstNode):
+class AstAsyncNode(UniNode):
     """Nodes that have access."""
 
     def __init__(self, is_async: bool) -> None:
-        """Initialize ast."""
         self.is_async: bool = is_async
 
 
-class AstElseBodyNode(AstNode):
+class AstElseBodyNode(UniNode):
     """Nodes that have access."""
 
     def __init__(self, else_body: Optional[ElseStmt | ElseIf]) -> None:
-        """Initialize ast."""
         self.else_body: Optional[ElseStmt | ElseIf] = else_body
 
 
-class AstTypedVarNode(AstNode):
+class AstTypedVarNode(UniNode):
     """Nodes that have access."""
 
     def __init__(self, type_tag: Optional[SubTag[Expr]]) -> None:
-        """Initialize ast."""
         self.type_tag: Optional[SubTag[Expr]] = type_tag
 
 
-class WalkerStmtOnlyNode(AstNode):
+class WalkerStmtOnlyNode(UniNode):
     """WalkerStmtOnlyNode node type for Jac Ast."""
 
     def __init__(self) -> None:
-        """Initialize walker statement only node."""
         self.from_walker: bool = False
 
 
-class Expr(AstNode):
-    """Expr node type for Jac Ast."""
+class UniCFGNode(UniNode):
+    """BasicBlockStmt node type for Jac Uniir."""
+
+    def __init__(self) -> None:
+        """Initialize basic block statement node."""
+        self.bb_in: list[UniCFGNode] = []
+        self.bb_out: list[UniCFGNode] = []
+
+    def get_head(self) -> UniCFGNode:
+        """Get head by walking up the CFG iteratively."""
+        node = self
+        while (
+            node.bb_in
+            and len(node.bb_in) == 1
+            and not isinstance(node.bb_in[0], (InForStmt, IterForStmt, WhileStmt))
+            and node.bb_in[0].bb_out
+            and len(node.bb_in[0].bb_out) == 1
+        ):
+            node = node.bb_in[0]
+        return node
+
+    def get_tail(self) -> UniCFGNode:
+        """Get tail by walking down the CFG iteratively."""
+        node = self
+        while (
+            node.bb_out
+            and len(node.bb_out) == 1
+            and not isinstance(node.bb_out[0], (InForStmt, IterForStmt, WhileStmt))
+            and node.bb_out[0].bb_in
+            and len(node.bb_out[0].bb_in) == 1
+        ):
+            node = node.bb_out[0]
+        return node
+
+
+class Expr(UniNode):
+    """Expression is a combination of values, variables operators and fuctions that are evaluated to produce a value.
+
+    1. Literal Expressions.
+    2. Binary Operations.
+    3. Unary Operations.
+    4. Ternary Operations.
+    5. Attribute Access.
+    6. Subscript.
+    7. Call Expression.
+    8. List Value.
+    9. Dictionary Value.
+    10. Set Value.
+    11. Generator Expression.
+    12. Lambda Expression.
+    13. Conditional Expression.
+    14. Yield Expression.
+    etc.
+
+    An expression can be assigned to a variable, passed to a function, or
+    retuurend from a function.
+
+    Examples:
+        "hello world"         # literal.
+        <expr>(<expr>, ...);  # call.
+        <expr>.NAME           # attribute.
+        <expr>[<expr>]        # subscript.
+        <expr> if <expr> else <expr>  # ternary.
+    """
 
-    def __init__(self, type_src: Optional[Expr] = None) -> None:
-        """Initialize expression node."""
-        self.type_src = type_src or self  # Only used for ArchRef
+    def __init__(self) -> None:
         self._sym_type: str = "NoType"
-        self._type_sym_tab: Optional[SymbolTable] = None
+        self._type_sym_tab: Optional[UniScopeNode] = None
 
     @property
     def expr_type(self) -> str:
-        """Get symbol type."""
-        return self.type_src._sym_type
+        return self._sym_type
 
     @expr_type.setter
     def expr_type(self, sym_type: str) -> None:
-        """Set symbol type."""
-        self.type_src._sym_type = sym_type
+        self._sym_type = sym_type
 
     @property
-    def type_sym_tab(self) -> Optional[SymbolTable]:
+    def type_sym_tab(self) -> Optional[UniScopeNode]:
         """Get type symbol table."""
-        return self.type_src._type_sym_tab
+        return self._type_sym_tab
 
     @type_sym_tab.setter
-    def type_sym_tab(self, type_sym_tab: SymbolTable) -> None:
+    def type_sym_tab(self, type_sym_tab: UniScopeNode) -> None:
         """Set type symbol table."""
-        self.type_src._type_sym_tab = type_sym_tab
+        self._type_sym_tab = type_sym_tab
 
 
 class AtomExpr(Expr, AstSymbolStubNode):
@@ -383,81 +740,37 @@ class ElementStmt(AstDocNode):
     """ElementStmt node type for Jac Ast."""
 
 
-class ArchBlockStmt(AstNode):
+class ArchBlockStmt(UniNode):
     """ArchBlockStmt node type for Jac Ast."""
 
 
-class EnumBlockStmt(AstNode):
+class EnumBlockStmt(UniNode):
     """EnumBlockStmt node type for Jac Ast."""
 
 
-class CodeBlockStmt(AstNode):
+class CodeBlockStmt(UniCFGNode):
     """CodeBlockStmt node type for Jac Ast."""
 
-
-class AstImplOnlyNode(CodeBlockStmt, ElementStmt, AstSymbolNode):
-    """ImplOnly node type for Jac Ast."""
-
-    def __init__(
-        self, target: ArchRefChain, body: SubNodeList, decl_link: Optional[AstNode]
-    ) -> None:
-        """Initialize impl only node."""
-        self.target = target
-        self.body = body
-        self.decl_link = decl_link
-        AstSymbolNode.__init__(
-            self,
-            sym_name=self.target.py_resolve_name(),
-            name_spec=self.create_impl_name_node(),
-            sym_category=SymbolType.IMPL,
-        )
-
-    @property
-    def sym_tab(self) -> SymbolTable:
-        """Get symbol table."""
-        return super().sym_tab
-
-    @sym_tab.setter
-    def sym_tab(self, sym_tab: SymbolTable) -> None:
-        """Set symbol table."""
-        self._sym_tab = sym_tab
-        self.name_spec._sym_tab = sym_tab
-
-    def create_impl_name_node(self) -> Name:
-        """Create impl name."""
-        ret = Name(
-            orig_src=self.target.archs[-1].loc.orig_src,
-            name=Tok.NAME.value,
-            value=self.target.py_resolve_name(),
-            col_start=self.target.archs[0].loc.col_start,
-            col_end=self.target.archs[-1].loc.col_end,
-            line=self.target.archs[0].loc.first_line,
-            end_line=self.target.archs[-1].loc.last_line,
-            pos_start=self.target.archs[0].loc.pos_start,
-            pos_end=self.target.archs[-1].loc.pos_end,
-        )
-        ret.name_of = self
-        return ret
+    def __init__(self) -> None:
+        """Initialize code block statement node."""
+        UniCFGNode.__init__(self)
 
 
 class AstImplNeedingNode(AstSymbolNode, Generic[T]):
-    """Impl needing node type for Jac Ast."""
+    """AstImplNeedingNode node type for Jac Ast."""
 
     def __init__(self, body: Optional[T]) -> None:
-        """Initialize impl needing node."""
         self.body = body
 
     @property
     def needs_impl(self) -> bool:
-        """Need impl."""
         return self.body is None
 
 
 class NameAtom(AtomExpr, EnumBlockStmt):
-    """NameSpec node type for Jac Ast."""
+    """NameAtom node type for Jac Ast."""
 
     def __init__(self) -> None:
-        """Initialize name spec node."""
         self.name_of: AstSymbolNode = self
         self._sym: Optional[Symbol] = None
         self._sym_name: str = ""
@@ -467,27 +780,22 @@ class NameAtom(AtomExpr, EnumBlockStmt):
 
     @property
     def sym(self) -> Optional[Symbol]:
-        """Get symbol."""
         return self._sym
 
     @sym.setter
     def sym(self, sym: Symbol) -> None:
-        """Set symbol."""
         self._sym = sym
 
     @property
     def sym_name(self) -> str:
-        """Get symbol name."""
         return self._sym_name
 
     @property
     def sym_category(self) -> SymbolType:
-        """Get symbol category."""
         return self._sym_category
 
     @property
     def clean_type(self) -> str:
-        """Get clean type."""
         ret_type = self.expr_type.replace("builtins.", "").replace("NoType", "")
         return ret_type
 
@@ -513,7 +821,7 @@ class NameAtom(AtomExpr, EnumBlockStmt):
         )
         if isinstance(name_of, ModulePath):
             return SemTokType.NAMESPACE, SemTokMod.DEFINITION
-        if isinstance(name_of, Architype):
+        if isinstance(name_of, Archetype):
             return SemTokType.CLASS, SemTokMod.DECLARATION
         if isinstance(name_of, Enum):
             return SemTokType.ENUM, SemTokMod.DECLARATION
@@ -537,32 +845,33 @@ class NameAtom(AtomExpr, EnumBlockStmt):
         return None
 
 
-class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode, AstSemStrNode):
+class ArchSpec(ElementStmt, CodeBlockStmt, AstSymbolNode, AstDocNode):
     """ArchSpec node type for Jac Ast."""
 
-    def __init__(self, decorators: Optional[SubNodeList[Expr]] = None) -> None:
-        """Initialize walker statement only node."""
+    def __init__(
+        self, decorators: Optional[SubNodeList[Expr]] = None, is_async: bool = False
+    ) -> None:
         self.decorators = decorators
+        self.is_async = is_async
+        CodeBlockStmt.__init__(self)
 
 
-class MatchPattern(AstNode):
+class MatchPattern(UniNode):
     """MatchPattern node type for Jac Ast."""
 
 
-class SubTag(AstNode, Generic[T]):
+class SubTag(UniNode, Generic[T]):
     """SubTag node type for Jac Ast."""
 
     def __init__(
         self,
         tag: T,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize tag node."""
-        self.tag = tag
-        AstNode.__init__(self, kid=kid)
+        self.tag: T = tag
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize sub tag node."""
         res = self.tag.normalize() if deep else True
         self.set_kids(nodes=[self.gen_token(Tok.COLON), self.tag])
         return res
@@ -572,31 +881,29 @@ class SubTag(AstNode, Generic[T]):
 # parser's implementation. We basically need to maintain tokens
 # of mixed type in the kid list of the subnodelist as well as
 # separating out typed items of interest in the ast node class body.
-class SubNodeList(AstNode, Generic[T]):
+class SubNodeList(UniNode, Generic[T]):
     """SubNodeList node type for Jac Ast."""
 
     def __init__(
         self,
         items: list[T],
         delim: Optional[Tok],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         left_enc: Optional[Token] = None,
         right_enc: Optional[Token] = None,
     ) -> None:
-        """Initialize sub node list node."""
-        self.items = items
+        self.items: list[T] = items
         self.delim = delim
         self.left_enc = left_enc
         self.right_enc = right_enc
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize sub node list node."""
         res = True
         if deep:
             for i in self.items:
                 res = res and i.normalize()
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.left_enc:
             new_kid.append(self.left_enc)
         for i in self.items:
@@ -613,36 +920,31 @@ class SubNodeList(AstNode, Generic[T]):
 
 # AST Mid Level Node Types
 # --------------------------
-class Module(AstDocNode):
+class Module(AstDocNode, UniScopeNode):
     """Whole Program node type for Jac Ast."""
 
     def __init__(
         self,
         name: str,
-        source: JacSource,
+        source: Source,
         doc: Optional[String],
         body: Sequence[ElementStmt | String | EmptyToken],
-        is_imported: bool,
         terminals: list[Token],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         stub_only: bool = False,
-        registry: Optional[SemRegistry] = None,
     ) -> None:
-        """Initialize whole program node."""
         self.name = name
         self.source = source
         self.body = body
-        self.is_imported = is_imported
         self.stub_only = stub_only
         self.impl_mod: list[Module] = []
         self.test_mod: list[Module] = []
-        self.mod_deps: dict[str, Module] = {}
-        self.registry = registry
-        self.terminals: list[Token] = terminals
-        self.py_info: PyInfo = PyInfo()
+        self.src_terminals: list[Token] = terminals
+        self.is_raised_from_py: bool = False
 
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
+        UniScopeNode.__init__(self, name=self.name)
 
     @property
     def annexable_by(self) -> Optional[str]:
@@ -675,30 +977,56 @@ class Module(AstDocNode):
         return None
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize module node."""
         res = True
         if deep:
             res = self.doc.normalize() if self.doc else True
             for i in self.body:
                 res = res and i.normalize()
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         new_kid.extend(self.body)
         self.set_kids(nodes=new_kid if len(new_kid) else [EmptyToken()])
         return res
 
+    def format(self) -> str:
+        """Get all sub nodes of type."""
+        from jaclang.compiler.passes.tool import DocIRGenPass, JacFormatPass
+        from jaclang.compiler.program import JacProgram
+
+        return JacFormatPass(
+            ir_in=DocIRGenPass(
+                ir_in=self,
+                prog=JacProgram(),
+            ).ir_out,
+            prog=JacProgram(),
+        ).ir_out.gen.jac
+
     def unparse(self) -> str:
-        """Unparse module node."""
         super().unparse()
         return self.format()
 
     @staticmethod
-    def get_href_path(node: AstNode) -> str:
+    def make_stub(
+        inject_name: Optional[str] = None, inject_src: Optional[Source] = None
+    ) -> Module:
+        """Create a stub module."""
+        return Module(
+            name=inject_name or "",
+            source=inject_src or Source("", ""),
+            doc=None,
+            body=[],
+            terminals=[],
+            stub_only=True,
+            kid=[EmptyToken()],
+        )
+
+    @staticmethod
+    def get_href_path(node: UniNode) -> str:
         """Return the full path of the module that contains this node."""
         parent = node.find_parent_of_type(Module)
-        mod_list: list[Module | Architype] = []
-        if isinstance(node, (Module, Architype)):
+        mod_list: list[Module | Archetype] = []
+        if isinstance(node, (Module, Archetype)):
             mod_list.append(node)
         while parent is not None:
             mod_list.append(parent)
@@ -709,6 +1037,16 @@ class Module(AstDocNode):
         )
 
 
+class ProgramModule(UniNode):
+    """Whole Program node type for Jac Ast."""
+
+    def __init__(self, main_mod: Optional[Module] = None) -> None:
+        """Initialize whole program node."""
+        self.main = main_mod if main_mod else Module.make_stub()
+        UniNode.__init__(self, kid=[self.main])
+        self.hub: dict[str, Module] = {self.loc.mod_path: main_mod} if main_mod else {}
+
+
 class GlobalVars(ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
 
@@ -717,24 +1055,22 @@ class GlobalVars(ElementStmt, AstAccessNode):
         access: Optional[SubTag[Token]],
         assignments: SubNodeList[Assignment],
         is_frozen: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize global var node."""
         self.assignments = assignments
         self.is_frozen = is_frozen
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize global var node."""
         res = True
         if deep:
             res = self.access.normalize(deep) if self.access else True
             res = res and self.assignments.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         if self.is_frozen:
@@ -748,7 +1084,7 @@ class GlobalVars(ElementStmt, AstAccessNode):
         return res
 
 
-class Test(AstSymbolNode, ElementStmt):
+class Test(AstSymbolNode, ElementStmt, UniScopeNode):
     """Test node type for Jac Ast."""
 
     TEST_COUNT = 0
@@ -757,10 +1093,9 @@ class Test(AstSymbolNode, ElementStmt):
         self,
         name: Name | Token,
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize test node."""
         Test.TEST_COUNT += 1 if isinstance(name, Token) else 0
         self.name: Name = (  # for auto generated test names
             name
@@ -784,7 +1119,7 @@ class Test(AstSymbolNode, ElementStmt):
             else self.name.value
         )
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         if self.name not in self.kid:
             self.insert_kids_at_pos([self.name], pos=1, pos_update=False)
         AstSymbolNode.__init__(
@@ -794,15 +1129,15 @@ class Test(AstSymbolNode, ElementStmt):
             sym_category=SymbolType.TEST,
         )
         AstDocNode.__init__(self, doc=doc)
+        UniScopeNode.__init__(self, name=self.sym_name)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize test node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
             res = res and self.body.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         new_kid.append(self.gen_token(Tok.KW_TEST))
@@ -813,34 +1148,33 @@ class Test(AstSymbolNode, ElementStmt):
 
 
 class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
-    """Free mod code for Jac Ast."""
+    """ModuleCode node type for Jac Ast."""
 
     def __init__(
         self,
-        name: Optional[SubTag[Name]],
+        name: Optional[Name],
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize test node."""
         self.name = name
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize module code node."""
         res = True
         if deep:
             res = self.name.normalize(deep) if self.name else res
             res = res and self.body.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         new_kid.append(self.gen_token(Tok.KW_WITH))
         new_kid.append(self.gen_token(Tok.KW_ENTRY))
         if self.name:
+            new_kid.append(self.gen_token(Tok.COLON))
             new_kid.append(self.name)
         new_kid.append(self.body)
         self.set_kids(nodes=new_kid)
@@ -848,31 +1182,28 @@ class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
 
 
 class PyInlineCode(ElementStmt, ArchBlockStmt, EnumBlockStmt, CodeBlockStmt):
-    """Inline Python code node type for Jac Ast."""
+    """PyInlineCode node type for Jac Ast."""
 
     def __init__(
         self,
         code: Token,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize inline python code node."""
         self.code = code
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize inline python code node."""
         res = True
         if deep:
             res = self.code.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
-        new_kid.append(self.gen_token(Tok.PYNLINE))
         new_kid.append(self.code)
-        new_kid.append(self.gen_token(Tok.PYNLINE))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -882,20 +1213,19 @@ class Import(ElementStmt, CodeBlockStmt):
 
     def __init__(
         self,
-        hint: Optional[SubTag[Name]],
         from_loc: Optional[ModulePath],
         items: SubNodeList[ModuleItem] | SubNodeList[ModulePath],
         is_absorb: bool,  # For includes
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize import node."""
-        self.hint = hint
+        self.hint = None
         self.from_loc = from_loc
         self.items = items
         self.is_absorb = is_absorb
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
+        CodeBlockStmt.__init__(self)
 
     @property
     def is_py(self) -> bool:
@@ -939,28 +1269,28 @@ class Import(ElementStmt, CodeBlockStmt):
         )
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize import node."""
         res = True
         if deep:
             res = self.hint.normalize(deep) if self.hint else res
             res = res and self.from_loc.normalize(deep) if self.from_loc else res
             res = res and self.items.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         if self.is_absorb:
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
             new_kid.append(self.gen_token(Tok.KW_IMPORT))
-        if self.hint:
-            new_kid.append(self.hint)
         if self.from_loc:
             new_kid.append(self.gen_token(Tok.KW_FROM))
             new_kid.append(self.from_loc)
-            new_kid.append(self.gen_token(Tok.COMMA))
+            new_kid.append(self.gen_token(Tok.LBRACE))
         new_kid.append(self.items)
-        new_kid.append(self.gen_token(Tok.SEMI))
+        if self.from_loc:
+            new_kid.append(self.gen_token(Tok.RBRACE))
+        else:
+            new_kid.append(self.gen_token(Tok.SEMI))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -970,21 +1300,19 @@ class ModulePath(AstSymbolNode):
 
     def __init__(
         self,
-        path: Optional[list[Name]],
+        path: Optional[SubNodeList[Name]],
         level: int,
         alias: Optional[Name],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize module path node."""
         self.path = path
         self.level = level
         self.alias = alias
-        self.sub_module: Optional[Module] = None
         self.abs_path: Optional[str] = None
 
-        name_spec = alias if alias else path[0] if path else None
+        name_spec = alias if alias else path.items[0] if path else None
 
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         if not name_spec:
             pkg_name = self.loc.mod_path
             for _ in range(self.level):
@@ -1005,63 +1333,32 @@ class ModulePath(AstSymbolNode):
     def dot_path_str(self) -> str:
         """Get path string."""
         return ("." * self.level) + ".".join(
-            [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
-        )
-
-    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
-        """Convert an import target string into a relative file path."""
-        target = self.dot_path_str
-        if target_item:
-            target += f".{target_item}"
-        base_path = (
-            os.getenv("JACPATH") or os.path.dirname(self.loc.mod_path) or os.getcwd()
-        )
-        parts = target.split(".")
-        traversal_levels = self.level - 1 if self.level > 0 else 0
-        actual_parts = parts[traversal_levels:]
-        for _ in range(traversal_levels):
-            base_path = os.path.dirname(base_path)
-        relative_path = os.path.join(base_path, *actual_parts)
-        relative_path = (
-            relative_path + ".jac"
-            if os.path.exists(relative_path + ".jac")
-            else relative_path
+            [p.value for p in self.path.items]
+            if self.path
+            else [self.name_spec.sym_name]
         )
-        jacpath = os.getenv("JACPATH")
-        if not os.path.exists(relative_path) and jacpath:
-            name_to_find = actual_parts[-1] + ".jac"
-
-            # Walk through the single path in JACPATH
-            for root, _, files in os.walk(jacpath):
-                if name_to_find in files:
-                    relative_path = os.path.join(root, name_to_find)
-                    break
-        return relative_path
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize module path node."""
         res = True
         if deep:
-            if self.path:
-                for p in self.path:
-                    res = res and p.normalize(deep)
+            res = self.path.normalize(deep) if self.path else res
             res = res and self.alias.normalize(deep) if self.alias else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         for _ in range(self.level):
             new_kid.append(self.gen_token(Tok.DOT))
         if self.path:
-            for p in self.path:
-                res = res and p.normalize(deep)
-                new_kid.append(p)
-                new_kid.append(self.gen_token(Tok.DOT))
-            new_kid.pop()
+            new_kid.append(self.path)
         if self.alias:
-            res = res and self.alias.normalize(deep)
             new_kid.append(self.gen_token(Tok.KW_AS))
             new_kid.append(self.alias)
         self.set_kids(nodes=new_kid)
         return res
 
+    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
+        """Convert an import target string into a relative file path."""
+        target = self.dot_path_str + (f".{target_item}" if target_item else "")
+        return resolve_relative_path(target, self.loc.mod_path)
+
 
 class ModuleItem(AstSymbolNode):
     """ModuleItem node type for Jac Ast."""
@@ -1070,13 +1367,11 @@ class ModuleItem(AstSymbolNode):
         self,
         name: Name,
         alias: Optional[Name],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize module item node."""
         self.name = name
         self.alias = alias
-        self.sub_module: Optional[Module] = None
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=alias.sym_name if alias else name.sym_name,
@@ -1104,12 +1399,11 @@ class ModuleItem(AstSymbolNode):
         return self.from_parent.from_loc
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize module item node."""
         res = True
         if deep:
             res = res and self.name.normalize(deep)
             res = res and self.alias.normalize(deep) if self.alias else res
-        new_kid: list[AstNode] = [self.name]
+        new_kid: list[UniNode] = [self.name]
         if self.alias:
             new_kid.append(self.gen_token(Tok.KW_AS))
             new_kid.append(self.alias)
@@ -1117,7 +1411,14 @@ class ModuleItem(AstSymbolNode):
         return res
 
 
-class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
+class Archetype(
+    ArchSpec,
+    AstAccessNode,
+    ArchBlockStmt,
+    AstImplNeedingNode,
+    UniScopeNode,
+    UniCFGNode,
+):
     """ObjectArch node type for Jac Ast."""
 
     def __init__(
@@ -1126,17 +1427,15 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
         arch_type: Token,
         access: Optional[SubTag[Token]],
         base_classes: Optional[SubNodeList[Expr]],
-        body: Optional[SubNodeList[ArchBlockStmt] | ArchDef],
-        kid: Sequence[AstNode],
+        body: Optional[SubNodeList[ArchBlockStmt] | ImplDef],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
-        semstr: Optional[String] = None,
         decorators: Optional[SubNodeList[Expr]] = None,
     ) -> None:
-        """Initialize object arch node."""
         self.name = name
         self.arch_type = arch_type
         self.base_classes = base_classes
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=name.value,
@@ -1162,21 +1461,25 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
         AstImplNeedingNode.__init__(self, body=body)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
-        AstSemStrNode.__init__(self, semstr=semstr)
         ArchSpec.__init__(self, decorators=decorators)
+        UniScopeNode.__init__(self, name=self.sym_name)
+        CodeBlockStmt.__init__(self)
 
     @property
     def is_abstract(self) -> bool:
-        """Check if has an abstract method."""
         body = (
             self.body.items
             if isinstance(self.body, SubNodeList)
-            else self.body.body.items if isinstance(self.body, ArchDef) else []
+            else (
+                self.body.body.items
+                if isinstance(self.body, ImplDef)
+                and isinstance(self.body.body, SubNodeList)
+                else []
+            )
         )
         return any(isinstance(i, Ability) and i.is_abstract for i in body)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize architype node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
@@ -1187,26 +1490,25 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
             )
             res = res and self.body.normalize(deep) if self.body else res
             res = res and self.doc.normalize(deep) if self.doc else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
             res = res and self.decorators.normalize(deep) if self.decorators else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             new_kid.append(self.decorators)
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
         new_kid.append(self.arch_type)
         if self.access:
             new_kid.append(self.access)
-        if self.semstr:
-            new_kid.append(self.semstr)
         new_kid.append(self.name)
         if self.base_classes:
-            new_kid.append(self.gen_token(Tok.COLON))
+            new_kid.append(self.gen_token(Tok.LPAREN))
             new_kid.append(self.base_classes)
-            new_kid.append(self.gen_token(Tok.COLON))
+            new_kid.append(self.gen_token(Tok.RPAREN))
         if self.body:
-            if isinstance(self.body, AstImplOnlyNode):
+            if isinstance(self.body, ImplDef):
                 new_kid.append(self.gen_token(Tok.SEMI))
             else:
                 new_kid.append(self.body)
@@ -1216,39 +1518,74 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
         return res
 
 
-class ArchDef(AstImplOnlyNode):
-    """ArchDef node type for Jac Ast."""
+class ImplDef(CodeBlockStmt, ElementStmt, ArchBlockStmt, AstSymbolNode, UniScopeNode):
+    """AstImplOnlyNode node type for Jac Ast."""
 
     def __init__(
         self,
-        target: ArchRefChain,
-        body: SubNodeList[ArchBlockStmt],
-        kid: Sequence[AstNode],
+        decorators: Optional[SubNodeList[Expr]],
+        target: SubNodeList[NameAtom],
+        spec: SubNodeList[Expr] | FuncSignature | EventSignature | None,
+        body: SubNodeList[CodeBlockStmt] | FuncCall,
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
-        decl_link: Optional[Architype] = None,
+        decl_link: Optional[UniNode] = None,
     ) -> None:
-        """Initialize arch def node."""
-        AstNode.__init__(self, kid=kid)
-        AstDocNode.__init__(self, doc=doc)
-        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
+        self.decorators = decorators
+        self.target = target
+        self.spec = spec
+        self.body = body
+        self.doc = doc
+        self.decl_link = decl_link
+        UniNode.__init__(self, kid=kid)
+        AstSymbolNode.__init__(
+            self,
+            sym_name="impl." + ".".join([x.sym_name for x in self.target.items]),
+            name_spec=self.create_impl_name_node(),
+            sym_category=SymbolType.IMPL,
+        )
+        CodeBlockStmt.__init__(self)
+        UniScopeNode.__init__(self, name=self.sym_name)
+
+    def create_impl_name_node(self) -> Name:
+        ret = Name(
+            orig_src=self.target.items[-1].loc.orig_src,
+            name=Tok.NAME.value,
+            value="impl." + ".".join([x.sym_name for x in self.target.items]),
+            col_start=self.target.items[0].loc.col_start,
+            col_end=self.target.items[-1].loc.col_end,
+            line=self.target.items[0].loc.first_line,
+            end_line=self.target.items[-1].loc.last_line,
+            pos_start=self.target.items[0].loc.pos_start,
+            pos_end=self.target.items[-1].loc.pos_end,
+        )
+        ret.parent = self
+        return ret
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize arch def node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
+            res = res and self.spec.normalize(deep) if self.spec else res
             res = res and self.body.normalize(deep)
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+            res = res and self.decorators.normalize(deep) if self.decorators else res
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.decorators:
+            new_kid.append(self.gen_token(Tok.DECOR_OP))
+            new_kid.append(self.decorators)
+        new_kid.append(self.gen_token(Tok.KW_IMPL))
         new_kid.append(self.target)
+        if self.spec:
+            new_kid.append(self.spec)
         new_kid.append(self.body)
         self.set_kids(nodes=new_kid)
         return res
 
 
-class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
+class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeNode):
     """Enum node type for Jac Ast."""
 
     def __init__(
@@ -1256,16 +1593,14 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
         name: Name,
         access: Optional[SubTag[Token]],
         base_classes: Optional[SubNodeList[Expr]],
-        body: Optional[SubNodeList[EnumBlockStmt] | EnumDef],
-        kid: Sequence[AstNode],
+        body: Optional[SubNodeList[Assignment] | ImplDef],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
-        semstr: Optional[String] = None,
         decorators: Optional[SubNodeList[Expr]] = None,
     ) -> None:
-        """Initialize object arch node."""
         self.name = name
         self.base_classes = base_classes
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=name.value,
@@ -1275,11 +1610,10 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
         AstImplNeedingNode.__init__(self, body=body)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
-        AstSemStrNode.__init__(self, semstr=semstr)
         ArchSpec.__init__(self, decorators=decorators)
+        UniScopeNode.__init__(self, name=self.sym_name)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize enum node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
@@ -1289,9 +1623,8 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
             )
             res = res and self.body.normalize(deep) if self.body else res
             res = res and self.doc.normalize(deep) if self.doc else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
             res = res and self.decorators.normalize(deep) if self.decorators else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             new_kid.append(self.decorators)
@@ -1300,70 +1633,30 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
         new_kid.append(self.gen_token(Tok.KW_ENUM))
         if self.access:
             new_kid.append(self.access)
-        if self.semstr:
-            new_kid.append(self.semstr)
         new_kid.append(self.name)
         if self.base_classes:
             new_kid.append(self.gen_token(Tok.COLON))
             new_kid.append(self.base_classes)
             new_kid.append(self.gen_token(Tok.COLON))
         if self.body:
-            if isinstance(self.body, AstImplOnlyNode):
+            if isinstance(self.body, ImplDef):
                 new_kid.append(self.gen_token(Tok.SEMI))
             else:
-                new_kid.append(self.gen_token(Tok.LBRACE))
                 new_kid.append(self.body)
-                new_kid.append(self.gen_token(Tok.RBRACE))
         else:
             new_kid.append(self.gen_token(Tok.SEMI))
         self.set_kids(nodes=new_kid)
         return res
 
 
-class EnumDef(AstImplOnlyNode):
-    """EnumDef node type for Jac Ast."""
-
-    def __init__(
-        self,
-        target: ArchRefChain,
-        body: SubNodeList[EnumBlockStmt],
-        kid: Sequence[AstNode],
-        doc: Optional[String] = None,
-        decorators: Optional[SubNodeList[Expr]] = None,
-        decl_link: Optional[Enum] = None,
-    ) -> None:
-        """Initialize arch def node."""
-        AstNode.__init__(self, kid=kid)
-        AstDocNode.__init__(self, doc=doc)
-        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
-
-    def normalize(self, deep: bool = False) -> bool:
-        """Normalize enum def node."""
-        res = True
-        if deep:
-            res = self.target.normalize(deep)
-            res = res and self.body.normalize(deep)
-            res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
-        if self.doc:
-            new_kid.append(self.doc)
-        new_kid.append(self.target)
-        new_kid.append(self.gen_token(Tok.LBRACE))
-        new_kid.append(self.body)
-        new_kid.append(self.gen_token(Tok.RBRACE))
-        self.set_kids(nodes=new_kid)
-        return res
-
-
 class Ability(
     AstAccessNode,
     ElementStmt,
     AstAsyncNode,
     ArchBlockStmt,
-    EnumBlockStmt,
     CodeBlockStmt,
-    AstSemStrNode,
     AstImplNeedingNode,
+    UniScopeNode,
 ):
     """Ability node type for Jac Ast."""
 
@@ -1375,23 +1668,21 @@ class Ability(
         is_static: bool,
         is_abstract: bool,
         access: Optional[SubTag[Token]],
-        signature: FuncSignature | EventSignature,
-        body: Optional[SubNodeList[CodeBlockStmt] | AbilityDef | FuncCall],
-        kid: Sequence[AstNode],
-        semstr: Optional[String] = None,
+        signature: FuncSignature | EventSignature | None,
+        body: Optional[SubNodeList[CodeBlockStmt] | ImplDef | FuncCall],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
         decorators: Optional[SubNodeList[Expr]] = None,
     ) -> None:
-        """Initialize func arch node."""
         self.name_ref = name_ref
         self.is_override = is_override
         self.is_static = is_static
         self.is_abstract = is_abstract
         self.decorators = decorators
         self.signature = signature
-        AstNode.__init__(self, kid=kid)
+
+        UniNode.__init__(self, kid=kid)
         AstImplNeedingNode.__init__(self, body=body)
-        AstSemStrNode.__init__(self, semstr=semstr)
         AstSymbolNode.__init__(
             self,
             sym_name=self.py_resolve_name(),
@@ -1401,49 +1692,57 @@ class Ability(
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
         AstAsyncNode.__init__(self, is_async=is_async)
+        UniScopeNode.__init__(self, name=self.sym_name)
+        CodeBlockStmt.__init__(self)
 
     @property
     def is_method(self) -> bool:
-        """Check if is func."""
-        return self.signature.is_method
+        return self.method_owner is not None
 
     @property
-    def owner_method(self) -> Optional[Architype | Enum]:
-        """Check if is owner method."""
-        return (
+    def is_def(self) -> bool:
+        return not self.signature or isinstance(self.signature, FuncSignature)
+
+    @property
+    def method_owner(self) -> Optional[Archetype | Enum]:
+        found = (
             self.parent.parent
             if self.parent
             and self.parent.parent
-            and isinstance(self.parent.parent, (Architype, Enum))
+            and isinstance(self.parent.parent, (Archetype, Enum))
+            else None
+        ) or (
+            self.parent.parent.decl_link
+            if self.parent
+            and self.parent.parent
+            and isinstance(self.parent.parent, ImplDef)
+            and isinstance(self.parent.parent.decl_link, Archetype)
             else None
         )
+        return found
 
     @property
     def is_genai_ability(self) -> bool:
-        """Check if is genai_ability."""
         return isinstance(self.body, FuncCall)
 
     def py_resolve_name(self) -> str:
-        """Resolve name."""
         if isinstance(self.name_ref, Name):
             return self.name_ref.value
-        elif isinstance(self.name_ref, (SpecialVarRef, ArchRef)):
+        elif isinstance(self.name_ref, SpecialVarRef):
             return self.name_ref.py_resolve_name()
         else:
             raise NotImplementedError
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.name_ref.normalize(deep)
             res = res and self.access.normalize(deep) if self.access else res
             res = res and self.signature.normalize(deep) if self.signature else res
             res = res and self.body.normalize(deep) if self.body else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
             res = res and self.decorators.normalize(deep) if self.decorators else res
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         if self.decorators:
@@ -1456,11 +1755,13 @@ class Ability(
             new_kid.append(self.gen_token(Tok.KW_OVERRIDE))
         if self.is_static:
             new_kid.append(self.gen_token(Tok.KW_STATIC))
-        new_kid.append(self.gen_token(Tok.KW_CAN))
+        new_kid.append(
+            self.gen_token(Tok.KW_CAN)
+            if not self.is_def
+            else self.gen_token(Tok.KW_DEF)
+        )
         if self.access:
             new_kid.append(self.access)
-        if self.semstr:
-            new_kid.append(self.semstr)
         new_kid.append(self.name_ref)
         if self.signature:
             new_kid.append(self.signature)
@@ -1469,7 +1770,7 @@ class Ability(
         if self.is_abstract:
             new_kid.append(self.gen_token(Tok.KW_ABSTRACT))
         if self.body:
-            if isinstance(self.body, AstImplOnlyNode):
+            if isinstance(self.body, ImplDef):
                 new_kid.append(self.gen_token(Tok.SEMI))
             else:
                 new_kid.append(self.body)
@@ -1481,97 +1782,47 @@ class Ability(
         return res
 
 
-class AbilityDef(AstImplOnlyNode):
-    """AbilityDef node type for Jac Ast."""
-
-    def __init__(
-        self,
-        target: ArchRefChain,
-        signature: FuncSignature | EventSignature,
-        body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
-        doc: Optional[String] = None,
-        decorators: Optional[SubNodeList[Expr]] = None,
-        decl_link: Optional[Ability] = None,
-    ) -> None:
-        """Initialize ability def node."""
-        self.signature = signature
-        self.decorators = decorators
-        AstNode.__init__(self, kid=kid)
-        AstDocNode.__init__(self, doc=doc)
-        AstImplOnlyNode.__init__(self, target=target, body=body, decl_link=decl_link)
-
-    def normalize(self, deep: bool = False) -> bool:
-        """Normalize ability def node."""
-        res = True
-        if deep:
-            res = self.target.normalize(deep)
-            res = res and self.signature.normalize(deep)
-            res = res and self.body.normalize(deep)
-            res = res and self.doc.normalize(deep) if self.doc else res
-            res = res and self.decorators.normalize(deep) if self.decorators else res
-        new_kid: list[AstNode] = []
-        if self.doc:
-            new_kid.append(self.doc)
-        new_kid.append(self.target)
-        new_kid.append(self.signature)
-
-        new_kid.append(self.body)
-
-        self.set_kids(nodes=new_kid)
-        return res
-
-
-class FuncSignature(AstSemStrNode):
+class FuncSignature(UniNode):
     """FuncSignature node type for Jac Ast."""
 
     def __init__(
         self,
         params: Optional[SubNodeList[ParamVar]],
         return_type: Optional[Expr],
-        kid: Sequence[AstNode],
-        semstr: Optional[String] = None,
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize method signature node."""
         self.params = params
         self.return_type = return_type
-        self.is_method = False
-        AstNode.__init__(self, kid=kid)
-        AstSemStrNode.__init__(self, semstr=semstr)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
+        is_lambda = self.parent and isinstance(self.parent, LambdaExpr)
         if deep:
             res = self.params.normalize(deep) if self.params else res
             res = res and self.return_type.normalize(deep) if self.return_type else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
-        new_kid: list[AstNode] = [self.gen_token(Tok.LPAREN)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.LPAREN)] if not is_lambda else []
         if self.params:
             new_kid.append(self.params)
-        new_kid.append(self.gen_token(Tok.RPAREN))
+        if not is_lambda:
+            new_kid.append(self.gen_token(Tok.RPAREN))
         if self.return_type:
             new_kid.append(self.gen_token(Tok.RETURN_HINT))
-            if self.semstr:
-                new_kid.append(self.semstr)
-                new_kid.append(self.gen_token(Tok.COLON))
             new_kid.append(self.return_type)
         self.set_kids(nodes=new_kid)
         return res
 
     @property
     def is_static(self) -> bool:
-        """Check if is static."""
         return (isinstance(self.parent, Ability) and self.parent.is_static) or (
-            isinstance(self.parent, AbilityDef)
+            isinstance(self.parent, ImplDef)
             and isinstance(self.parent.decl_link, Ability)
             and self.parent.decl_link.is_static
         )
 
     @property
     def is_in_py_class(self) -> bool:
-        """Check if the ability belongs to a class."""
-        is_archi = self.find_parent_of_type(Architype)
+        is_archi = self.find_parent_of_type(Archetype)
         is_class = is_archi is not None and is_archi.arch_type.name == Tok.KW_CLASS
 
         return (
@@ -1579,14 +1830,14 @@ class FuncSignature(AstSemStrNode):
             and self.parent.is_method is not None
             and is_class
         ) or (
-            isinstance(self.parent, AbilityDef)
+            isinstance(self.parent, ImplDef)
             and isinstance(self.parent.decl_link, Ability)
             and self.parent.decl_link.is_method
             and is_class
         )
 
 
-class EventSignature(AstSemStrNode):
+class EventSignature(UniNode):
     """EventSignature node type for Jac Ast."""
 
     def __init__(
@@ -1594,19 +1845,14 @@ class EventSignature(AstSemStrNode):
         event: Token,
         arch_tag_info: Optional[Expr],
         return_type: Optional[Expr],
-        kid: Sequence[AstNode],
-        semstr: Optional[String] = None,
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize event signature node."""
         self.event = event
         self.arch_tag_info = arch_tag_info
         self.return_type = return_type
-        self.is_method = False
-        AstNode.__init__(self, kid=kid)
-        AstSemStrNode.__init__(self, semstr=semstr)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.event.normalize(deep)
@@ -1616,64 +1862,18 @@ class EventSignature(AstSemStrNode):
                 else res
             )
             res = res and self.return_type.normalize(deep) if self.return_type else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_WITH)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_WITH)]
         if self.arch_tag_info:
             new_kid.append(self.arch_tag_info)
         new_kid.append(self.event)
         if self.return_type:
-            if self.semstr:
-                new_kid.append(self.semstr)
             new_kid.append(self.gen_token(Tok.RETURN_HINT))
             new_kid.append(self.return_type)
         self.set_kids(nodes=new_kid)
         return res
 
 
-class ArchRefChain(AstNode):
-    """Arch ref list node type for Jac Ast."""
-
-    def __init__(
-        self,
-        archs: list[ArchRef],
-        kid: Sequence[AstNode],
-    ) -> None:
-        """Initialize name list ."""
-        self.archs = archs
-        AstNode.__init__(self, kid=kid)
-
-    def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
-        res = True
-        if deep:
-            for a in self.archs:
-                res = res and a.normalize(deep)
-        new_kid: list[AstNode] = []
-        for a in self.archs:
-            new_kid.append(a)
-        self.set_kids(nodes=new_kid)
-        return res
-
-    def py_resolve_name(self) -> str:
-        """Resolve name."""
-
-        def get_tag(x: ArchRef) -> str:
-            return (
-                "en"
-                if x.arch_type.value == "enum"
-                else "cls" if x.arch_type.value == "class" else x.arch_type.value[1]
-            )
-
-        return ".".join([f"({get_tag(x)}){x.sym_name}" for x in self.archs])
-
-    def flat_name(self) -> str:
-        """Resolve name for python gen."""
-        return (
-            self.py_resolve_name().replace(".", "_").replace("(", "").replace(")", "_")
-        )
-
-
-class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
+class ParamVar(AstSymbolNode, AstTypedVarNode):
     """ParamVar node type for Jac Ast."""
 
     def __init__(
@@ -1682,14 +1882,12 @@ class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         unpack: Optional[Token],
         type_tag: SubTag[Expr],
         value: Optional[Expr],
-        kid: Sequence[AstNode],
-        semstr: Optional[String] = None,
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize param var node."""
         self.name = name
         self.unpack = unpack
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=name.value,
@@ -1697,24 +1895,18 @@ class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
             sym_category=SymbolType.VAR,
         )
         AstTypedVarNode.__init__(self, type_tag=type_tag)
-        AstSemStrNode.__init__(self, semstr=semstr)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
             res = res and self.unpack.normalize(deep) if self.unpack else res
             res = res and self.type_tag.normalize(deep) if self.type_tag else res
             res = res and self.value.normalize(deep) if self.value else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.unpack:
             new_kid.append(self.unpack)
         new_kid.append(self.name)
-        if self.semstr:
-            new_kid.append(self.gen_token(Tok.COLON))
-            new_kid.append(self.semstr)
         if self.type_tag:
             new_kid.append(self.type_tag)
         if self.value:
@@ -1724,8 +1916,11 @@ class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         return res
 
 
-class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
-    """HasStmt node type for Jac Ast."""
+# TODO: Must deal with codeblockstmt here, should only be in ArchBocks
+# but had to do this for impls to work, probably should do checks in the
+# static analysis phase
+class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt, CodeBlockStmt):
+    """ArchHas node type for Jac Ast."""
 
     def __init__(
         self,
@@ -1733,25 +1928,24 @@ class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
         access: Optional[SubTag[Token]],
         vars: SubNodeList[HasVar],
         is_frozen: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         doc: Optional[String] = None,
     ) -> None:
-        """Initialize has statement node."""
         self.is_static = is_static
         self.vars = vars
         self.is_frozen = is_frozen
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize has statement node."""
         res = True
         if deep:
             res = self.access.normalize(deep) if self.access else res
             res = res and self.vars.normalize(deep) if self.vars else res
             res = res and self.doc.normalize(deep) if self.doc else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
         if self.is_static:
@@ -1769,7 +1963,7 @@ class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
         return res
 
 
-class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
+class HasVar(AstSymbolNode, AstTypedVarNode):
     """HasVar node type for Jac Ast."""
 
     def __init__(
@@ -1778,14 +1972,12 @@ class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         type_tag: SubTag[Expr],
         value: Optional[Expr],
         defer: bool,
-        kid: Sequence[AstNode],
-        semstr: Optional[String] = None,
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize has var node."""
         self.name = name
         self.value = value
         self.defer = defer
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
             sym_name=name.value,
@@ -1793,20 +1985,14 @@ class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
             sym_category=SymbolType.HAS_VAR,
         )
         AstTypedVarNode.__init__(self, type_tag=type_tag)
-        AstSemStrNode.__init__(self, semstr=semstr)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize has var node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
             res = res and self.type_tag.normalize(deep) if self.type_tag else res
             res = res and self.value.normalize(deep) if self.value else res
-            res = res and self.semstr.normalize(deep) if self.semstr else res
-        new_kid: list[AstNode] = [self.name]
-        if self.semstr:
-            new_kid.append(self.gen_token(Tok.COLON))
-            new_kid.append(self.semstr)
+        new_kid: list[UniNode] = [self.name]
         if self.type_tag:
             new_kid.append(self.type_tag)
         if self.value:
@@ -1819,27 +2005,27 @@ class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         return res
 
 
-class TypedCtxBlock(CodeBlockStmt):
+class TypedCtxBlock(CodeBlockStmt, UniScopeNode):
     """TypedCtxBlock node type for Jac Ast."""
 
     def __init__(
         self,
         type_ctx: Expr,
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize typed context block node."""
         self.type_ctx = type_ctx
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize typed context block node."""
         res = True
         if deep:
             res = self.type_ctx.normalize(deep)
             res = res and self.body.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.RETURN_HINT),
             self.type_ctx,
             self.body,
@@ -1848,7 +2034,7 @@ class TypedCtxBlock(CodeBlockStmt):
         return res
 
 
-class IfStmt(CodeBlockStmt, AstElseBodyNode):
+class IfStmt(CodeBlockStmt, AstElseBodyNode, UniScopeNode):
     """IfStmt node type for Jac Ast."""
 
     def __init__(
@@ -1856,22 +2042,22 @@ class IfStmt(CodeBlockStmt, AstElseBodyNode):
         condition: Expr,
         body: SubNodeList[CodeBlockStmt],
         else_body: Optional[ElseStmt | ElseIf],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize if statement node."""
         self.condition = condition
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstElseBodyNode.__init__(self, else_body=else_body)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize if statement node."""
         res = True
         if deep:
             res = self.condition.normalize(deep)
             res = res and self.body.normalize(deep)
             res = res and self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_IF),
             self.condition,
             self.body,
@@ -1883,16 +2069,15 @@ class IfStmt(CodeBlockStmt, AstElseBodyNode):
 
 
 class ElseIf(IfStmt):
-    """ElseIfs node type for Jac Ast."""
+    """ElseIf node type for Jac Ast."""
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize else if statement node."""
         res = True
         if deep:
             res = self.condition.normalize(deep)
             res = res and self.body.normalize(deep)
             res = res and self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_ELIF),
             self.condition,
             self.body,
@@ -1903,24 +2088,23 @@ class ElseIf(IfStmt):
         return res
 
 
-class ElseStmt(AstNode):
-    """Else node type for Jac Ast."""
+class ElseStmt(UniScopeNode):
+    """ElseStmt node type for Jac Ast."""
 
     def __init__(
         self,
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize else node."""
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize else statement node."""
         res = True
         if deep:
             res = self.body.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_ELSE),
             self.body,
         ]
@@ -1935,18 +2119,17 @@ class ExprStmt(CodeBlockStmt):
         self,
         expr: Expr,
         in_fstring: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize expr statement node."""
         self.expr = expr
         self.in_fstring = in_fstring
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         if deep:
             res = self.expr.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.in_fstring:
             new_kid.append(self.expr)
         else:
@@ -1956,7 +2139,7 @@ class ExprStmt(CodeBlockStmt):
         return res and self.expr is not None
 
 
-class TryStmt(AstElseBodyNode, CodeBlockStmt):
+class TryStmt(AstElseBodyNode, CodeBlockStmt, UniScopeNode):
     """TryStmt node type for Jac Ast."""
 
     def __init__(
@@ -1965,17 +2148,17 @@ class TryStmt(AstElseBodyNode, CodeBlockStmt):
         excepts: Optional[SubNodeList[Except]],
         else_body: Optional[ElseStmt],
         finally_body: Optional[FinallyStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize try statement node."""
         self.body = body
         self.excepts = excepts
         self.finally_body = finally_body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstElseBodyNode.__init__(self, else_body=else_body)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize try statement node."""
         res = True
         if deep:
             res = self.body.normalize(deep)
@@ -1984,7 +2167,7 @@ class TryStmt(AstElseBodyNode, CodeBlockStmt):
             res = (
                 res and self.finally_body.normalize(deep) if self.finally_body else res
             )
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_TRY),
         ]
         new_kid.append(self.body)
@@ -1998,7 +2181,7 @@ class TryStmt(AstElseBodyNode, CodeBlockStmt):
         return res
 
 
-class Except(CodeBlockStmt):
+class Except(CodeBlockStmt, UniScopeNode):
     """Except node type for Jac Ast."""
 
     def __init__(
@@ -2006,22 +2189,22 @@ class Except(CodeBlockStmt):
         ex_type: Expr,
         name: Optional[Name],
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize except node."""
         self.ex_type = ex_type
         self.name = name
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize except node."""
         res = True
         if deep:
             res = self.ex_type.normalize(deep)
             res = res and self.name.normalize(deep) if self.name else res
             res = res and self.body.normalize(deep) if self.body else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_EXCEPT),
             self.ex_type,
         ]
@@ -2033,24 +2216,24 @@ class Except(CodeBlockStmt):
         return res
 
 
-class FinallyStmt(CodeBlockStmt):
+class FinallyStmt(CodeBlockStmt, UniScopeNode):
     """FinallyStmt node type for Jac Ast."""
 
     def __init__(
         self,
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize finally statement node."""
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize finally statement node."""
         res = True
         if deep:
             res = self.body.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_FINALLY),
         ]
         new_kid.append(self.body)
@@ -2058,8 +2241,8 @@ class FinallyStmt(CodeBlockStmt):
         return res
 
 
-class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
-    """IterFor node type for Jac Ast."""
+class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt, UniScopeNode):
+    """IterForStmt node type for Jac Ast."""
 
     def __init__(
         self,
@@ -2069,19 +2252,19 @@ class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         count_by: Assignment,
         body: SubNodeList[CodeBlockStmt],
         else_body: Optional[ElseStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize iter for node."""
         self.iter = iter
         self.condition = condition
         self.count_by = count_by
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
         AstElseBodyNode.__init__(self, else_body=else_body)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize iter for node."""
         res = True
         if deep:
             res = self.iter.normalize(deep)
@@ -2089,7 +2272,7 @@ class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
             res = self.count_by.normalize(deep)
             res = self.body.normalize(deep)
             res = self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.is_async:
             new_kid.append(self.gen_token(Tok.KW_ASYNC))
         new_kid.append(self.gen_token(Tok.KW_FOR))
@@ -2105,8 +2288,8 @@ class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         return res
 
 
-class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
-    """InFor node type for Jac Ast."""
+class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt, UniScopeNode):
+    """InForStmt node type for Jac Ast."""
 
     def __init__(
         self,
@@ -2115,25 +2298,25 @@ class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         collection: Expr,
         body: SubNodeList[CodeBlockStmt],
         else_body: Optional[ElseStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize in for node."""
         self.target = target
         self.collection = collection
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
         AstElseBodyNode.__init__(self, else_body=else_body)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize in for node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
             res = res and self.collection.normalize(deep)
             res = res and self.body.normalize(deep)
             res = res and self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.is_async:
             new_kid.append(self.gen_token(Tok.KW_ASYNC))
         new_kid.append(self.gen_token(Tok.KW_FOR))
@@ -2149,27 +2332,27 @@ class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         return res
 
 
-class WhileStmt(CodeBlockStmt):
+class WhileStmt(CodeBlockStmt, UniScopeNode):
     """WhileStmt node type for Jac Ast."""
 
     def __init__(
         self,
         condition: Expr,
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize while statement node."""
         self.condition = condition
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize while statement node."""
         res = True
         if deep:
             res = self.condition.normalize(deep)
             res = res and self.body.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_WHILE),
             self.condition,
         ]
@@ -2179,7 +2362,7 @@ class WhileStmt(CodeBlockStmt):
         return res
 
 
-class WithStmt(AstAsyncNode, CodeBlockStmt):
+class WithStmt(AstAsyncNode, CodeBlockStmt, UniScopeNode):
     """WithStmt node type for Jac Ast."""
 
     def __init__(
@@ -2187,54 +2370,49 @@ class WithStmt(AstAsyncNode, CodeBlockStmt):
         is_async: bool,
         exprs: SubNodeList[ExprAsItem],
         body: SubNodeList[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize with statement node."""
         self.exprs = exprs
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize with statement node."""
         res = True
         if deep:
             res = self.exprs.normalize(deep)
             res = res and self.body.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.is_async:
             new_kid.append(self.gen_token(Tok.KW_ASYNC))
         new_kid.append(self.gen_token(Tok.KW_WITH))
         new_kid.append(self.exprs)
-        new_kid.append(self.gen_token(Tok.LBRACE))
         new_kid.append(self.body)
-        new_kid.append(self.gen_token(Tok.RBRACE))
-
         self.set_kids(nodes=new_kid)
         return res
 
 
-class ExprAsItem(AstNode):
+class ExprAsItem(UniNode):
     """ExprAsItem node type for Jac Ast."""
 
     def __init__(
         self,
         expr: Expr,
         alias: Optional[Expr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize module item node."""
         self.expr = expr
         self.alias = alias
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.expr.normalize(deep)
             res = res and self.alias.normalize(deep) if self.alias else res
-        new_kid: list[AstNode] = [self.expr]
+        new_kid: list[UniNode] = [self.expr]
         if self.alias:
             new_kid.append(self.gen_token(Tok.KW_AS))
             new_kid.append(self.alias)
@@ -2249,20 +2427,19 @@ class RaiseStmt(CodeBlockStmt):
         self,
         cause: Optional[Expr],
         from_target: Optional[Expr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize raise statement node."""
         self.cause = cause
         self.from_target = from_target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize raise statement node."""
         res = True
         if deep:
             res = res and self.cause.normalize(deep) if self.cause else res
             res = res and self.from_target.normalize(deep) if self.from_target else res
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_RAISE)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_RAISE)]
         if self.cause:
             new_kid.append(self.cause)
         if self.from_target:
@@ -2280,20 +2457,19 @@ class AssertStmt(CodeBlockStmt):
         self,
         condition: Expr,
         error_msg: Optional[Expr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize assert statement node."""
         self.condition = condition
         self.error_msg = error_msg
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize assert statement node."""
         res = True
         if deep:
             res = self.condition.normalize(deep)
             res = res and self.error_msg.normalize(deep) if self.error_msg else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_ASSERT),
             self.condition,
         ]
@@ -2306,23 +2482,22 @@ class AssertStmt(CodeBlockStmt):
 
 
 class CheckStmt(CodeBlockStmt):
-    """DeleteStmt node type for Jac Ast."""
+    """CheckStmt node type for Jac Ast."""
 
     def __init__(
         self,
         target: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize delete statement node."""
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize delete statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_CHECK),
             self.target,
             self.gen_token(Tok.SEMI),
@@ -2337,18 +2512,17 @@ class CtrlStmt(CodeBlockStmt):
     def __init__(
         self,
         ctrl: Token,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize control statement node."""
         self.ctrl = ctrl
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize control statement node."""
         res = True
         if deep:
             res = self.ctrl.normalize(deep)
-        new_kid: list[AstNode] = [self.ctrl, self.gen_token(Tok.SEMI)]
+        new_kid: list[UniNode] = [self.ctrl, self.gen_token(Tok.SEMI)]
         self.set_kids(nodes=new_kid)
         return res
 
@@ -2359,18 +2533,26 @@ class DeleteStmt(CodeBlockStmt):
     def __init__(
         self,
         target: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize delete statement node."""
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
+
+    @property
+    def py_ast_targets(self) -> list[ast3.AST]:
+        """Get Python AST targets (without setting ctx)."""
+        return (
+            self.target.values.gen.py_ast
+            if isinstance(self.target, TupleVal) and self.target.values
+            else self.target.gen.py_ast
+        )
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize delete statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_DELETE),
             self.target,
             self.gen_token(Tok.SEMI),
@@ -2385,18 +2567,17 @@ class ReportStmt(CodeBlockStmt):
     def __init__(
         self,
         expr: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize report statement node."""
         self.expr = expr
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize report statement node."""
         res = True
         if deep:
             res = self.expr.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_REPORT),
             self.expr,
             self.gen_token(Tok.SEMI),
@@ -2411,18 +2592,17 @@ class ReturnStmt(CodeBlockStmt):
     def __init__(
         self,
         expr: Optional[Expr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize return statement node."""
         self.expr = expr
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize return statement node."""
         res = True
         if deep:
             res = self.expr.normalize(deep) if self.expr else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_RETURN),
         ]
         if self.expr:
@@ -2438,19 +2618,18 @@ class IgnoreStmt(WalkerStmtOnlyNode, CodeBlockStmt):
     def __init__(
         self,
         target: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize ignore statement node."""
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ignore statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_IGNORE),
             self.target,
             self.gen_token(Tok.SEMI),
@@ -2464,30 +2643,29 @@ class VisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
 
     def __init__(
         self,
-        vis_type: Optional[SubNodeList[Expr]],
+        insert_loc: Optional[Expr],
         target: Expr,
         else_body: Optional[ElseStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize visit statement node."""
-        self.vis_type = vis_type
+        self.insert_loc = insert_loc
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
         AstElseBodyNode.__init__(self, else_body=else_body)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize visit statement node."""
         res = True
         if deep:
-            res = self.vis_type.normalize(deep) if self.vis_type else res
+            res = self.insert_loc.normalize(deep) if self.insert_loc else res
             res = self.target.normalize(deep)
             res = res and self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         new_kid.append(self.gen_token(Tok.KW_VISIT))
-        if self.vis_type:
+        if self.insert_loc:
             new_kid.append(self.gen_token(Tok.COLON))
-            new_kid.append(self.vis_type)
+            new_kid.append(self.insert_loc)
             new_kid.append(self.gen_token(Tok.COLON))
         new_kid.append(self.target)
         if self.else_body:
@@ -2498,51 +2676,21 @@ class VisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
         return res
 
 
-class RevisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
-    """ReVisitStmt node type for Jac Ast."""
-
-    def __init__(
-        self,
-        hops: Optional[Expr],
-        else_body: Optional[ElseStmt],
-        kid: Sequence[AstNode],
-    ) -> None:
-        """Initialize revisit statement node."""
-        self.hops = hops
-        AstNode.__init__(self, kid=kid)
-        WalkerStmtOnlyNode.__init__(self)
-        AstElseBodyNode.__init__(self, else_body=else_body)
-
-    def normalize(self, deep: bool = False) -> bool:
-        """Normalize revisit statement node."""
-        res = True
-        if deep:
-            res = self.hops.normalize(deep) if self.hops else res
-            res = res and self.else_body.normalize(deep) if self.else_body else res
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_REVISIT)]
-        if self.hops:
-            new_kid.append(self.hops)
-        if self.else_body:
-            new_kid.append(self.else_body)
-        new_kid.append(self.gen_token(Tok.SEMI))
-        self.set_kids(nodes=new_kid)
-        return res
-
-
 class DisengageStmt(WalkerStmtOnlyNode, CodeBlockStmt):
     """DisengageStmt node type for Jac Ast."""
 
     def __init__(
         self,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
         """Initialize disengage statement node."""
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize disengage statement node."""
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_DISENGAGE),
             self.gen_token(Tok.SEMI),
         ]
@@ -2551,24 +2699,22 @@ class DisengageStmt(WalkerStmtOnlyNode, CodeBlockStmt):
 
 
 class AwaitExpr(Expr):
-    """AwaitStmt node type for Jac Ast."""
+    """AwaitExpr node type for Jac Ast."""
 
     def __init__(
         self,
         target: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize sync statement node."""
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize sync statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_AWAIT),
             self.target,
         ]
@@ -2582,18 +2728,17 @@ class GlobalStmt(CodeBlockStmt):
     def __init__(
         self,
         target: SubNodeList[NameAtom],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize global statement node."""
         self.target = target
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize global statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.GLOBAL_OP),
             self.target,
             self.gen_token(Tok.SEMI),
@@ -2603,14 +2748,13 @@ class GlobalStmt(CodeBlockStmt):
 
 
 class NonLocalStmt(GlobalStmt):
-    """NonlocalStmt node type for Jac Ast."""
+    """NonLocalStmt node type for Jac Ast."""
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize nonlocal statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.NONLOCAL_OP),
             self.target,
             self.gen_token(Tok.SEMI),
@@ -2619,7 +2763,7 @@ class NonLocalStmt(GlobalStmt):
         return res
 
 
-class Assignment(AstSemStrNode, AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
+class Assignment(AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
     """Assignment node type for Jac Ast."""
 
     def __init__(
@@ -2627,35 +2771,29 @@ class Assignment(AstSemStrNode, AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
         target: SubNodeList[Expr],
         value: Optional[Expr | YieldExpr],
         type_tag: Optional[SubTag[Expr]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         mutable: bool = True,
         aug_op: Optional[Token] = None,
-        semstr: Optional[String] = None,
         is_enum_stmt: bool = False,
     ) -> None:
-        """Initialize assignment node."""
         self.target = target
         self.value = value
         self.mutable = mutable
         self.aug_op = aug_op
         self.is_enum_stmt = is_enum_stmt
-        AstNode.__init__(self, kid=kid)
-        AstSemStrNode.__init__(self, semstr=semstr)
+        UniNode.__init__(self, kid=kid)
         AstTypedVarNode.__init__(self, type_tag=type_tag)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
             res = res and self.value.normalize(deep) if self.value else res
             res = res and self.type_tag.normalize(deep) if self.type_tag else res
             res = res and self.aug_op.normalize(deep) if self.aug_op else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         new_kid.append(self.target)
-        if self.semstr:
-            new_kid.append(self.gen_token(Tok.COLON))
-            new_kid.append(self.semstr)
         if self.type_tag:
             new_kid.append(self.type_tag)
         if self.aug_op:
@@ -2675,37 +2813,58 @@ class Assignment(AstSemStrNode, AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
         return res
 
 
+class ConcurrentExpr(Expr):
+    """ConcurrentExpr node type for Jac Ast."""
+
+    def __init__(
+        self,
+        tok: Optional[Token],
+        target: Expr,
+        kid: Sequence[UniNode],
+    ) -> None:
+        UniNode.__init__(self, kid=kid)
+        Expr.__init__(self)
+        self.tok = tok
+        self.target = target
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.target.normalize(deep)
+            res = res and self.target.normalize(deep) if self.target else res
+        new_kid: list[UniNode] = []
+        if isinstance(self.tok, Token) and self.tok.value == "flow":
+            new_kid.append(self.gen_token(Tok.KW_FLOW))
+        elif isinstance(self.tok, Token) and self.tok.value == "wait":
+            new_kid.append(self.gen_token(Tok.KW_WAIT))
+        new_kid.append(self.target)
+        self.set_kids(nodes=new_kid)
+        return res
+
+
 class BinaryExpr(Expr):
-    """ExprBinary node type for Jac Ast."""
+    """BinaryExpr node type for Jac Ast."""
 
     def __init__(
         self,
         left: Expr,
         right: Expr,
         op: Token | DisconnectOp | ConnectOp,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize binary expression node."""
         self.left = left
         self.right = right
         self.op = op
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.left.normalize(deep)
             res = res and self.right.normalize(deep) if self.right else res
             res = res and self.op.normalize(deep) if self.op else res
-        new_kid: list[AstNode] = [
-            self.gen_token(Tok.LPAREN),
-            self.left,
-            self.op,
-            self.right,
-            self.gen_token(Tok.RPAREN),
-        ]
+        new_kid: list[UniNode] = [self.left, self.op, self.right]
         self.set_kids(nodes=new_kid)
         return res
 
@@ -2718,17 +2877,15 @@ class CompareExpr(Expr):
         left: Expr,
         rights: list[Expr],
         ops: list[Token],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize binary expression node."""
         self.left = left
         self.rights = rights
         self.ops = ops
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.left.normalize(deep)
@@ -2736,7 +2893,7 @@ class CompareExpr(Expr):
                 res = res and right.normalize(deep)
             for op in self.ops:
                 res = res and op.normalize(deep)
-        new_kid: list[AstNode] = [self.left]
+        new_kid: list[UniNode] = [self.left]
         for i, right in enumerate(self.rights):
             new_kid.append(self.ops[i])
             new_kid.append(right)
@@ -2751,22 +2908,20 @@ class BoolExpr(Expr):
         self,
         op: Token,
         values: list[Expr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize binary expression node."""
         self.values = values
         self.op = op
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             for value in self.values:
                 res = res and value.normalize(deep)
             res = res and self.op.normalize(deep) if self.op else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         for i, value in enumerate(self.values):
             if i > 0:
                 new_kid.append(self.op)
@@ -2775,90 +2930,81 @@ class BoolExpr(Expr):
         return res
 
 
-class LambdaExpr(Expr):
-    """ExprLambda node type for Jac Ast."""
+class LambdaExpr(Expr, UniScopeNode):
+    """LambdaExpr node type for Jac Ast."""
 
     def __init__(
         self,
         body: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         signature: Optional[FuncSignature] = None,
     ) -> None:
-        """Initialize lambda expression node."""
         self.signature = signature
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.signature.normalize(deep) if self.signature else res
             res = res and self.body.normalize(deep)
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_WITH)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_LAMBDA)]
         if self.signature:
             new_kid.append(self.signature)
-        new_kid += [
-            self.gen_token(Tok.KW_CAN),
-            self.body,
-            self.gen_token(Tok.SEMI),
-        ]
+        new_kid += [self.gen_token(Tok.COLON), self.body]
         self.set_kids(nodes=new_kid)
         return res
 
 
 class UnaryExpr(Expr):
-    """ExprUnary node type for Jac Ast."""
+    """UnaryExpr node type for Jac Ast."""
 
     def __init__(
         self,
         operand: Expr,
         op: Token,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize unary expression node."""
         self.operand = operand
         self.op = op
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.operand.normalize(deep)
             res = res and self.op.normalize(deep) if self.op else res
-        new_kid: list[AstNode] = [self.op, self.operand]
+        new_kid: list[UniNode] = [self.op, self.operand]
         self.set_kids(nodes=new_kid)
         return res
 
 
 class IfElseExpr(Expr):
-    """ExprIfElse node type for Jac Ast."""
+    """IfElseExpr node type for Jac Ast."""
 
     def __init__(
         self,
         condition: Expr,
         value: Expr,
         else_value: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize if else expression node."""
         self.condition = condition
         self.value = value
         self.else_value = else_value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.condition.normalize(deep)
             res = res and self.value.normalize(deep)
             res = res and self.else_value.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.value,
             self.gen_token(Tok.KW_IF),
             self.condition,
@@ -2870,26 +3016,24 @@ class IfElseExpr(Expr):
 
 
 class MultiString(AtomExpr):
-    """ExprMultiString node type for Jac Ast."""
+    """MultiString node type for Jac Ast."""
 
     def __init__(
         self,
         strings: Sequence[String | FString],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize multi string expression node."""
         self.strings = strings
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.STRING)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             for string in self.strings:
                 res = res and string.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         for string in self.strings:
             new_kid.append(string)
         self.set_kids(nodes=new_kid)
@@ -2902,20 +3046,18 @@ class FString(AtomExpr):
     def __init__(
         self,
         parts: Optional[SubNodeList[String | ExprStmt]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize fstring expression node."""
         self.parts = parts
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.STRING)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.parts.normalize(deep) if self.parts else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         is_single_quote = (
             isinstance(self.kid[0], Token) and self.kid[0].name == Tok.FSTR_SQ_START
         )
@@ -2944,20 +3086,18 @@ class ListVal(AtomExpr):
     def __init__(
         self,
         values: Optional[SubNodeList[Expr]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize value node."""
         self.values = values
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.values.normalize(deep) if self.values else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LSQUARE),
         ]
         if self.values:
@@ -2973,20 +3113,18 @@ class SetVal(AtomExpr):
     def __init__(
         self,
         values: Optional[SubNodeList[Expr]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize value node."""
         self.values = values
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.values.normalize(deep) if self.values else res
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LBRACE),
         ]
         if self.values:
@@ -3002,16 +3140,14 @@ class TupleVal(AtomExpr):
     def __init__(
         self,
         values: Optional[SubNodeList[Expr | KWPair]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize tuple value node."""
         self.values = values
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.values.normalize(deep) if self.values else res
@@ -3023,7 +3159,7 @@ class TupleVal(AtomExpr):
             and self.parent.parent
             and isinstance(self.parent.parent.parent, FuncSignature)
         )
-        new_kid: list[AstNode] = (
+        new_kid: list[UniNode] = (
             [
                 self.gen_token(Tok.LPAREN),
             ]
@@ -3041,26 +3177,24 @@ class TupleVal(AtomExpr):
 
 
 class DictVal(AtomExpr):
-    """ExprDict node type for Jac Ast."""
+    """DictVal node type for Jac Ast."""
 
     def __init__(
         self,
         kv_pairs: Sequence[KVPair],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize dict expression node."""
         self.kv_pairs = kv_pairs
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             for kv_pair in self.kv_pairs:
                 res = res and kv_pair.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LBRACE),
         ]
         for i, kv_pair in enumerate(self.kv_pairs):
@@ -3072,27 +3206,25 @@ class DictVal(AtomExpr):
         return res
 
 
-class KVPair(AstNode):
-    """ExprKVPair node type for Jac Ast."""
+class KVPair(UniNode):
+    """KVPair node type for Jac Ast."""
 
     def __init__(
         self,
         key: Optional[Expr],  # is **key if blank
         value: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize key value pair expression node."""
         self.key = key
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.key.normalize(deep) if self.key else res
             res = res and self.value.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.key:
             new_kid.append(self.key)
             new_kid.append(self.gen_token(Tok.COLON))
@@ -3103,37 +3235,37 @@ class KVPair(AstNode):
         return res
 
 
-class KWPair(AstNode):
-    """ExprKWPair node type for Jac Ast."""
+class KWPair(UniNode):
+    """KWPair node type for Jac Ast."""
 
     def __init__(
         self,
         key: Optional[NameAtom],  # is **value if blank
         value: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize keyword pair expression node."""
         self.key = key
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.key.normalize(deep) if self.key else res
             res = res and self.value.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.key:
             new_kid.append(self.key)
             new_kid.append(self.gen_token(Tok.EQ))
+        else:
+            new_kid.append(self.gen_token(Tok.STAR_POW))
         new_kid.append(self.value)
         self.set_kids(nodes=new_kid)
         return res
 
 
-class InnerCompr(AstAsyncNode):
-    """ListCompr node type for Jac Ast."""
+class InnerCompr(AstAsyncNode, UniScopeNode):
+    """InnerCompr node type for Jac Ast."""
 
     def __init__(
         self,
@@ -3141,24 +3273,23 @@ class InnerCompr(AstAsyncNode):
         target: Expr,
         collection: Expr,
         conditional: Optional[list[Expr]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize comprehension expression node."""
         self.target = target
         self.collection = collection
         self.conditional = conditional
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
             res = res and self.collection.normalize(deep)
             for cond in self.conditional if self.conditional else []:
                 res = res and cond.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.is_async:
             new_kid.append(self.gen_token(Tok.KW_ASYNC))
         new_kid.append(self.gen_token(Tok.KW_FOR))
@@ -3179,23 +3310,21 @@ class ListCompr(AtomExpr):
         self,
         out_expr: Expr,
         compr: list[InnerCompr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize comprehension expression node."""
         self.out_expr = out_expr
         self.compr = compr
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.out_expr.normalize(deep)
             for comp in self.compr:
                 res = res and comp.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LSQUARE),
             self.out_expr,
         ]
@@ -3210,13 +3339,12 @@ class GenCompr(ListCompr):
     """GenCompr node type for Jac Ast."""
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.out_expr.normalize(deep)
             for comp in self.compr:
                 res = res and comp.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LPAREN),
             self.out_expr,
         ]
@@ -3231,13 +3359,12 @@ class SetCompr(ListCompr):
     """SetCompr node type for Jac Ast."""
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.out_expr.normalize(deep)
             for comp in self.compr:
                 res = res and comp.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LBRACE),
             self.out_expr,
         ]
@@ -3248,29 +3375,28 @@ class SetCompr(ListCompr):
         return res
 
 
-class DictCompr(AtomExpr):
+class DictCompr(AtomExpr, UniScopeNode):
     """DictCompr node type for Jac Ast."""
 
     def __init__(
         self,
         kv_pair: KVPair,
         compr: list[InnerCompr],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize comprehension expression node."""
         self.kv_pair = kv_pair
         self.compr = compr
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         res = self.kv_pair.normalize(deep)
         for comp in self.compr:
             res = res and comp.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.LBRACE),
             self.kv_pair,
         ]
@@ -3290,25 +3416,23 @@ class AtomTrailer(Expr):
         right: AtomExpr | Expr,
         is_attr: bool,
         is_null_ok: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         is_genai: bool = False,
     ) -> None:
-        """Initialize atom trailer expression node."""
         self.target = target
         self.right = right
         self.is_attr = is_attr
         self.is_null_ok = is_null_ok
         self.is_genai = is_genai
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
             res = res and self.right.normalize(deep) if self.right else res
-        new_kid: list[AstNode] = [self.target]
+        new_kid: list[UniNode] = [self.target]
         if self.is_null_ok:
             new_kid.append(self.gen_token(Tok.NULL_OK))
         if self.is_attr:
@@ -3320,7 +3444,6 @@ class AtomTrailer(Expr):
 
     @property
     def as_attr_list(self) -> list[AstSymbolNode]:
-        """Unwind trailer into list of ast symbol nodes."""
         left = self.right if isinstance(self.right, AtomTrailer) else self.target
         right = self.target if isinstance(self.right, AtomTrailer) else self.right
         trag_list: list[AstSymbolNode] = (
@@ -3341,19 +3464,17 @@ class AtomUnit(Expr):
     def __init__(
         self,
         value: Expr | YieldExpr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize atom unit expression node."""
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.value.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         new_kid.append(self.gen_token(Tok.LPAREN))
         new_kid.append(self.value)
         new_kid.append(self.gen_token(Tok.RPAREN))
@@ -3362,26 +3483,24 @@ class AtomUnit(Expr):
 
 
 class YieldExpr(Expr):
-    """YieldStmt node type for Jac Ast."""
+    """YieldExpr node type for Jac Ast."""
 
     def __init__(
         self,
         expr: Optional[Expr],
         with_from: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize yeild statement node."""
         self.expr = expr
         self.with_from = with_from
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize yield statement node."""
         res = True
         if deep:
             res = self.expr.normalize(deep) if self.expr else res
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_YIELD)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_YIELD)]
         if self.with_from:
             new_kid.append(self.gen_token(Tok.KW_FROM))
         if self.expr:
@@ -3399,17 +3518,15 @@ class FuncCall(Expr):
         target: Expr,
         params: Optional[SubNodeList[Expr | KWPair]],
         genai_call: Optional[FuncCall],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize function call expression node."""
         self.target = target
         self.params = params
         self.genai_call = genai_call
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         if deep:
             res = self.target.normalize(deep)
             res = res and (not self.params or self.params.normalize(deep))
@@ -3429,7 +3546,7 @@ class IndexSlice(AtomExpr):
 
     @dataclass
     class Slice:
-        """Slice node for index slice."""
+        """Slice node type for Jac Ast."""
 
         start: Optional[Expr]
         stop: Optional[Expr]
@@ -3439,24 +3556,22 @@ class IndexSlice(AtomExpr):
         self,
         slices: list[Slice],
         is_range: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize index slice expression node."""
         self.slices = slices
         self.is_range = is_range
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             for slice in self.slices:
                 res = slice.start.normalize(deep) if slice.start else res
                 res = res and slice.stop.normalize(deep) if slice.stop else res
                 res = res and slice.step.normalize(deep) if slice.step else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
         if self.is_range:
             for i, slice in enumerate(self.slices):
@@ -3479,33 +3594,29 @@ class IndexSlice(AtomExpr):
         return res
 
 
-class ArchRef(AtomExpr):
+class TypeRef(AtomExpr):
     """ArchRef node type for Jac Ast."""
 
     def __init__(
         self,
-        arch_name: NameAtom,
-        arch_type: Token,
-        kid: Sequence[AstNode],
+        target: NameAtom,
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize architype reference expression node."""
-        self.arch_name = arch_name
-        self.arch_type = arch_type
-        AstNode.__init__(self, kid=kid)
-        Expr.__init__(self, type_src=arch_name)
+        self.target = target
+        UniNode.__init__(self, kid=kid)
+        Expr.__init__(self)
         AstSymbolNode.__init__(
             self,
-            sym_name=arch_name.sym_name,
-            name_spec=arch_name,
+            sym_name=target.sym_name,
+            name_spec=target,
             sym_category=SymbolType.TYPE,
         )
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
-            res = self.arch_name.normalize(deep)
-        new_kid: list[AstNode] = [self.arch_type, self.arch_name]
+            res = self.target.normalize(deep)
+        new_kid: list[UniNode] = [self.gen_token(Tok.TYPE_OP), self.target]
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3517,23 +3628,21 @@ class EdgeRefTrailer(Expr):
         self,
         chain: list[Expr | FilterCompr],
         edges_only: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize edge reference trailer expression node."""
         self.chain = chain
         self.edges_only = edges_only
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize ast node."""
         res = True
         for expr in self.chain:
             res = res and expr.normalize(deep)
-        new_kid: list[AstNode] = []
-        if self.edges_only:
-            new_kid.append(self.gen_token(Tok.EDGE_OP))
+        new_kid: list[UniNode] = []
         new_kid.append(self.gen_token(Tok.LSQUARE))
+        if self.edges_only:
+            new_kid.append(self.gen_token(Tok.KW_EDGE))
         new_kid.extend(self.chain)
         new_kid.append(self.gen_token(Tok.RSQUARE))
         self.set_kids(nodes=new_kid)
@@ -3547,22 +3656,20 @@ class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
         self,
         filter_cond: Optional[FilterCompr],
         edge_dir: EdgeDir,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize edge op reference expression node."""
         self.filter_cond = filter_cond
         self.edge_dir = edge_dir
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         WalkerStmtOnlyNode.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.filter_cond.normalize(deep) if self.filter_cond else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.edge_dir == EdgeDir.IN:
             if not self.filter_cond:
                 new_kid.append(self.gen_token(Tok.ARROW_L))
@@ -3589,29 +3696,27 @@ class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
 
 
 class DisconnectOp(WalkerStmtOnlyNode):
-    """DisconnectOpRef node type for Jac Ast."""
+    """DisconnectOp node type for Jac Ast."""
 
     def __init__(
         self,
         edge_spec: EdgeOpRef,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize disconnect op reference expression node."""
         self.edge_spec = edge_spec
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.edge_spec.normalize(deep)
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_DELETE), self.edge_spec]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_DELETE), self.edge_spec]
         self.set_kids(nodes=new_kid)
         return res
 
 
-class ConnectOp(AstNode):
+class ConnectOp(UniNode):
     """ConnectOpRef node type for Jac Ast."""
 
     def __init__(
@@ -3619,21 +3724,19 @@ class ConnectOp(AstNode):
         conn_type: Optional[Expr],
         conn_assign: Optional[AssignCompr],
         edge_dir: EdgeDir,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize connect op reference expression node."""
         self.conn_type = conn_type
         self.conn_assign = conn_assign
         self.edge_dir = edge_dir
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.conn_type.normalize(deep) if self.conn_type else res
             res = res and self.conn_assign.normalize(deep) if self.conn_assign else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.edge_dir == EdgeDir.IN:
             if not self.conn_assign and not self.conn_type:
                 new_kid.append(self.gen_token(Tok.CARROW_L))
@@ -3672,28 +3775,26 @@ class ConnectOp(AstNode):
 
 
 class FilterCompr(AtomExpr):
-    """FilterCtx node type for Jac Ast."""
+    """FilterCompr node type for Jac Ast."""
 
     def __init__(
         self,
         f_type: Optional[Expr],
         compares: Optional[SubNodeList[CompareExpr]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize filter_cond context expression node."""
         self.f_type = f_type
         self.compares = compares
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.f_type.normalize(deep) if self.f_type else res
             res = res and self.compares.normalize(deep) if self.compares else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if not isinstance(self.parent, EdgeOpRef):
             new_kid.append(self.gen_token(Tok.LPAREN))
             if self.f_type:
@@ -3712,25 +3813,23 @@ class FilterCompr(AtomExpr):
 
 
 class AssignCompr(AtomExpr):
-    """AssignCtx node type for Jac Ast."""
+    """AssignCompr node type for Jac Ast."""
 
     def __init__(
         self,
         assigns: SubNodeList[KWPair],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize assign compr expression node."""
         self.assigns = assigns
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.SEQUENCE)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize ast node."""
         res = True
         if deep:
             res = self.assigns.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if isinstance(self.parent, ConnectOp):
             new_kid.append(self.assigns)
         else:
@@ -3753,21 +3852,20 @@ class MatchStmt(CodeBlockStmt):
         self,
         target: Expr,
         cases: list[MatchCase],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match statement node."""
         self.target = target
         self.cases = cases
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        CodeBlockStmt.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match statement node."""
         res = True
         if deep:
             res = self.target.normalize(deep)
             for case in self.cases:
                 res = res and case.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.KW_MATCH),
             self.target,
         ]
@@ -3780,7 +3878,7 @@ class MatchStmt(CodeBlockStmt):
         return res
 
 
-class MatchCase(AstNode):
+class MatchCase(UniScopeNode):
     """MatchCase node type for Jac Ast."""
 
     def __init__(
@@ -3788,23 +3886,22 @@ class MatchCase(AstNode):
         pattern: MatchPattern,
         guard: Optional[Expr],
         body: list[CodeBlockStmt],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match case node."""
         self.pattern = pattern
         self.guard = guard
         self.body = body
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+        UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match case node."""
         res = True
         if deep:
             res = self.pattern.normalize(deep)
             res = res and self.guard.normalize(deep) if self.guard else res
             for stmt in self.body:
                 res = res and stmt.normalize(deep)
-        new_kid: list[AstNode] = [self.gen_token(Tok.KW_CASE), self.pattern]
+        new_kid: list[UniNode] = [self.gen_token(Tok.KW_CASE), self.pattern]
         if self.guard:
             new_kid.append(self.gen_token(Tok.KW_IF))
             new_kid.append(self.guard)
@@ -3821,19 +3918,17 @@ class MatchOr(MatchPattern):
     def __init__(
         self,
         patterns: list[MatchPattern],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match or node."""
         self.patterns = patterns
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match or node."""
         res = True
         if deep:
             for pattern in self.patterns:
                 res = res and pattern.normalize(deep)
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         for pattern in self.patterns:
             new_kid.append(pattern)
             new_kid.append(self.gen_token(Tok.KW_OR))
@@ -3849,20 +3944,18 @@ class MatchAs(MatchPattern):
         self,
         name: NameAtom,
         pattern: Optional[MatchPattern],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match as node."""
         self.name = name
         self.pattern = pattern
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match as node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
             res = res and self.pattern.normalize(deep) if self.pattern else res
-        new_kid: list[AstNode] = []
+        new_kid: list[UniNode] = []
         if self.pattern:
             new_kid.append(self.pattern)
             new_kid.append(self.gen_token(Tok.KW_AS))
@@ -3872,11 +3965,11 @@ class MatchAs(MatchPattern):
 
 
 class MatchWild(MatchPattern):
-    """Match wild card node type for Jac Ast."""
+    """MatchWild node type for Jac Ast."""
 
     def normalize(self, deep: bool = False) -> bool:
         """Normalize match wild card node."""
-        AstNode.set_kids(
+        UniNode.set_kids(
             self,
             nodes=[
                 Name(
@@ -3901,14 +3994,12 @@ class MatchValue(MatchPattern):
     def __init__(
         self,
         value: Expr,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match value node."""
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match value node."""
         res = True
         if deep:
             res = self.value.normalize(deep)
@@ -3922,14 +4013,12 @@ class MatchSingleton(MatchPattern):
     def __init__(
         self,
         value: Bool | Null,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match singleton node."""
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match singleton node."""
         res = True
         self.set_kids(nodes=[self.value])
         return res
@@ -3941,19 +4030,17 @@ class MatchSequence(MatchPattern):
     def __init__(
         self,
         values: list[MatchPattern],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match sequence node."""
         self.values = values
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match sequence node."""
         res = True
         if deep:
             for value in self.values:
                 res = res and value.normalize(deep)
-        new_kid: list[AstNode] = [self.gen_token(Tok.LSQUARE)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.LSQUARE)]
         for value in self.values:
             new_kid.append(value)
             new_kid.append(self.gen_token(Tok.COMMA))
@@ -3969,19 +4056,17 @@ class MatchMapping(MatchPattern):
     def __init__(
         self,
         values: list[MatchKVPair | MatchStar],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match mapping node."""
         self.values = values
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match mapping node."""
         res = True
         if deep:
             for value in self.values:
                 res = res and value.normalize(deep)
-        new_kid: list[AstNode] = [self.gen_token(Tok.LBRACE)]
+        new_kid: list[UniNode] = [self.gen_token(Tok.LBRACE)]
         for value in self.values:
             new_kid.append(value)
             new_kid.append(self.gen_token(Tok.COMMA))
@@ -3996,17 +4081,15 @@ class MatchKVPair(MatchPattern):
 
     def __init__(
         self,
-        key: MatchPattern | NameAtom,
+        key: MatchPattern | NameAtom | AtomExpr,
         value: MatchPattern,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match key value pair node."""
         self.key = key
         self.value = value
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match key value pair node."""
         res = True
         if deep:
             res = (
@@ -4014,7 +4097,7 @@ class MatchKVPair(MatchPattern):
             )
             res = res and self.value.normalize(deep)
         op = Tok.EQ if isinstance(self.key, Name) else Tok.COLON
-        new_kid: list[AstNode] = [self.key, self.gen_token(op), self.value]
+        new_kid: list[UniNode] = [self.key, self.gen_token(op), self.value]
         self.set_kids(nodes=new_kid)
         return res
 
@@ -4026,19 +4109,17 @@ class MatchStar(MatchPattern):
         self,
         name: NameAtom,
         is_list: bool,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match star node."""
         self.name = name
         self.is_list = is_list
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match star node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
-        new_kid: list[AstNode] = [
+        new_kid: list[UniNode] = [
             self.gen_token(Tok.STAR_MUL if self.is_list else Tok.STAR_POW)
         ]
         new_kid.append(self.name)
@@ -4047,29 +4128,27 @@ class MatchStar(MatchPattern):
 
 
 class MatchArch(MatchPattern):
-    """MatchClass node type for Jac Ast."""
+    """MatchArch node type for Jac Ast."""
 
     def __init__(
         self,
         name: AtomTrailer | NameAtom,
         arg_patterns: Optional[SubNodeList[MatchPattern]],
         kw_patterns: Optional[SubNodeList[MatchKVPair]],
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
     ) -> None:
-        """Initialize match class node."""
         self.name = name
         self.arg_patterns = arg_patterns
         self.kw_patterns = kw_patterns
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
 
     def normalize(self, deep: bool = False) -> bool:
-        """Normalize match class node."""
         res = True
         if deep:
             res = self.name.normalize(deep)
             res = res and (not self.arg_patterns or self.arg_patterns.normalize(deep))
             res = res and (not self.kw_patterns or self.kw_patterns.normalize(deep))
-        new_kid: list[AstNode] = [self.name]
+        new_kid: list[UniNode] = [self.name]
         new_kid.append(self.gen_token(Tok.LPAREN))
         if self.arg_patterns:
             new_kid.append(self.arg_patterns)
@@ -4085,12 +4164,12 @@ class MatchArch(MatchPattern):
 
 # AST Terminal Node Types
 # --------------------------
-class Token(AstNode):
+class Token(UniNode):
     """Token node type for Jac Ast."""
 
     def __init__(
         self,
-        orig_src: JacSource,
+        orig_src: Source,
         name: str,
         value: str,
         line: int,
@@ -4100,7 +4179,6 @@ class Token(AstNode):
         pos_start: int,
         pos_end: int,
     ) -> None:
-        """Initialize token."""
         self.orig_src = orig_src
         self.name = name
         self.value = value
@@ -4110,14 +4188,15 @@ class Token(AstNode):
         self.c_end = col_end
         self.pos_start = pos_start
         self.pos_end = pos_end
-        AstNode.__init__(self, kid=[])
+        UniNode.__init__(self, kid=[])
+
+    def __repr__(self) -> str:
+        return f"Token({self.name}, {self.value}, {self.loc})"
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize token."""
         return bool(self.value and self.name)
 
     def unparse(self) -> str:
-        """Unparse token."""
         return self.value
 
 
@@ -4126,7 +4205,7 @@ class Name(Token, NameAtom):
 
     def __init__(
         self,
-        orig_src: JacSource,
+        orig_src: Source,
         name: str,
         value: str,
         line: int,
@@ -4138,7 +4217,6 @@ class Name(Token, NameAtom):
         is_enum_singleton: bool = False,
         is_kwesc: bool = False,
     ) -> None:
-        """Initialize token."""
         self.is_enum_singleton = is_enum_singleton
         self.is_kwesc = is_kwesc
         Token.__init__(
@@ -4162,7 +4240,6 @@ class Name(Token, NameAtom):
         )
 
     def unparse(self) -> str:
-        """Unparse name."""
         super().unparse()
         return (f"<>{self.value}" if self.is_kwesc else self.value) + (
             ",\n" if self.is_enum_singleton else ""
@@ -4184,20 +4261,18 @@ class Name(Token, NameAtom):
             pos_start=node.loc.pos_start,
             pos_end=node.loc.pos_end,
         )
+        ret.parent = node.parent
         ret.name_of = set_name_of if set_name_of else ret
-        if node._sym_tab:
-            ret.sym_tab = node.sym_tab
         return ret
 
 
 class SpecialVarRef(Name):
-    """HereRef node type for Jac Ast."""
+    """SpecialVarRef node type for Jac Ast."""
 
     def __init__(
         self,
         var: Name,
     ) -> None:
-        """Initialize special var reference expression node."""
         self.orig = var
         Name.__init__(
             self,
@@ -4220,7 +4295,6 @@ class SpecialVarRef(Name):
         )
 
     def py_resolve_name(self) -> str:
-        """Resolve name."""
         if self.orig.name == Tok.KW_SELF:
             return "self"
         elif self.orig.name == Tok.KW_SUPER:
@@ -4229,6 +4303,8 @@ class SpecialVarRef(Name):
             return Con.ROOT.value
         elif self.orig.name == Tok.KW_HERE:
             return Con.HERE.value
+        elif self.orig.name == Tok.KW_VISITOR:
+            return Con.VISITOR.value
         elif self.orig.name == Tok.KW_INIT:
             return "__init__"
         elif self.orig.name == Tok.KW_POST_INIT:
@@ -4257,7 +4333,7 @@ class Literal(Token, AtomExpr):
 
     def __init__(
         self,
-        orig_src: JacSource,
+        orig_src: Source,
         name: str,
         value: str,
         line: int,
@@ -4267,7 +4343,6 @@ class Literal(Token, AtomExpr):
         pos_start: int,
         pos_end: int,
     ) -> None:
-        """Initialize token."""
         Token.__init__(
             self,
             orig_src=orig_src,
@@ -4292,7 +4367,7 @@ class Literal(Token, AtomExpr):
 
 
 class BuiltinType(Name, Literal):
-    """Type node type for Jac Ast."""
+    """BuiltinType node type for Jac Ast."""
 
     SYMBOL_TYPE = SymbolType.VAR
 
@@ -4311,7 +4386,6 @@ class Float(Literal):
 
     @property
     def lit_value(self) -> float:
-        """Return literal value in its python type."""
         return float(self.value)
 
 
@@ -4322,7 +4396,6 @@ class Int(Literal):
 
     @property
     def lit_value(self) -> int:
-        """Return literal value in its python type."""
         return int(self.value)
 
 
@@ -4333,7 +4406,6 @@ class String(Literal):
 
     @property
     def lit_value(self) -> str:
-        """Return literal value in its python type."""
         if isinstance(self.value, bytes):
             return self.value
         if any(
@@ -4364,12 +4436,10 @@ class String(Literal):
             return self.value
 
     def normalize(self, deep: bool = True) -> bool:
-        """Normalize string."""
         self.value = r"%s" % self.value
         return True
 
     def unparse(self) -> str:
-        """Unparse string."""
         super().unparse()
         return repr(self.value)
 
@@ -4381,18 +4451,16 @@ class Bool(Literal):
 
     @property
     def lit_value(self) -> bool:
-        """Return literal value in its python type."""
         return self.value == "True"
 
 
 class Null(Literal):
-    """Semicolon node type for Jac Ast."""
+    """Null node type for Jac Ast."""
 
     SYMBOL_TYPE = SymbolType.NULL
 
     @property
     def lit_value(self) -> None:
-        """Return literal value in its python type."""
         return None
 
 
@@ -4403,18 +4471,16 @@ class Ellipsis(Literal):
 
     @property
     def lit_value(self) -> EllipsisType:
-        """Return literal value in its python type."""
         return ...
 
 
 class EmptyToken(Token):
     """EmptyToken node type for Jac Ast."""
 
-    def __init__(self, orig_src: JacSource | None = None) -> None:
-        """Initialize empty token."""
+    def __init__(self, orig_src: Source | None = None) -> None:
         super().__init__(
             name="EmptyToken",
-            orig_src=orig_src or JacSource("", ""),
+            orig_src=orig_src or Source("", ""),
             value="",
             line=0,
             end_line=0,
@@ -4425,16 +4491,46 @@ class EmptyToken(Token):
         )
 
 
-class Semi(Token, CodeBlockStmt):
+class Semi(
+    Token,
+    CodeBlockStmt,
+):
     """Semicolon node type for Jac Ast."""
 
+    def __init__(
+        self,
+        orig_src: Source,
+        name: str,
+        value: str,
+        line: int,
+        end_line: int,
+        col_start: int,
+        col_end: int,
+        pos_start: int,
+        pos_end: int,
+    ) -> None:
+        """Initialize token."""
+        Token.__init__(
+            self,
+            orig_src=orig_src,
+            name=name,
+            value=value,
+            line=line,
+            end_line=end_line,
+            col_start=col_start,
+            col_end=col_end,
+            pos_start=pos_start,
+            pos_end=pos_end,
+        )
+        CodeBlockStmt.__init__(self)
+
 
 class CommentToken(Token):
     """CommentToken node type for Jac Ast."""
 
     def __init__(
         self,
-        orig_src: JacSource,
+        orig_src: Source,
         name: str,
         value: str,
         line: int,
@@ -4443,10 +4539,9 @@ class CommentToken(Token):
         col_end: int,
         pos_start: int,
         pos_end: int,
-        kid: Sequence[AstNode],
+        kid: Sequence[UniNode],
         is_inline: bool = False,
     ) -> None:
-        """Initialize token."""
         self.is_inline = is_inline
 
         Token.__init__(
@@ -4462,15 +4557,29 @@ class CommentToken(Token):
             pos_end=pos_end,
         )
 
-        AstNode.__init__(self, kid=kid)
+        UniNode.__init__(self, kid=kid)
+
+    @property
+    def left_node(self) -> Optional[UniNode]:
+        if self.parent and (idx := self.parent.kid.index(self)) > 0:
+            return self.parent.kid[idx - 1]
+        return None
+
+    @property
+    def right_node(self) -> Optional[UniNode]:
+        if (
+            self.parent
+            and (idx := self.parent.kid.index(self)) < len(self.parent.kid) - 1
+        ):
+            return self.parent.kid[idx + 1]
+        return None
 
 
 # ----------------
-class JacSource(EmptyToken):
+class Source(EmptyToken):
     """SourceString node type for Jac Ast."""
 
     def __init__(self, source: str, mod_path: str) -> None:
-        """Initialize source string."""
         super().__init__(self)
         self.value = source
         self.hash = md5(source.encode()).hexdigest()
@@ -4479,15 +4588,14 @@ class JacSource(EmptyToken):
 
     @property
     def code(self) -> str:
-        """Return code."""
+        """Return the source code as string."""
         return self.value
 
 
 class PythonModuleAst(EmptyToken):
     """SourceString node type for Jac Ast."""
 
-    def __init__(self, ast: ast3.Module, orig_src: JacSource) -> None:
-        """Initialize source string."""
+    def __init__(self, ast: ast3.Module, orig_src: Source) -> None:
         super().__init__()
         self.ast = ast
         self.orig_src = orig_src