jaclang 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

jaclang/compiler/absyntree.py

@@ -6,10 +6,18 @@ import ast as ast3
 from types import EllipsisType
 from typing import Any, Callable, Generic, Optional, Sequence, Type, TypeVar
 
+from jaclang.compiler import TOKEN_MAP
 from jaclang.compiler.codeloc import CodeGenTarget, CodeLocInfo
 from jaclang.compiler.constant import Constants as Con, EdgeDir
-from jaclang.compiler.constant import Tokens as Tok
-from jaclang.compiler.symtable import Symbol, SymbolAccess, SymbolTable, SymbolType
+from jaclang.compiler.constant import DELIM_MAP, Tokens as Tok
+from jaclang.compiler.symtable import (
+    Symbol,
+    SymbolAccess,
+    SymbolInfo,
+    SymbolTable,
+    SymbolType,
+)
+from jaclang.core.registry import SemRegistry
 from jaclang.utils.treeprinter import dotgen_ast_tree, print_ast_tree
 
 
@@ -74,12 +82,46 @@ class AstNode:
         else:
             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
+            else (
+                DELIM_MAP[name]
+                if name in DELIM_MAP
+                else TOKEN_MAP[name.value] if name.value in TOKEN_MAP else name.value
+            )
+        )
+        return Token(
+            name=name,
+            value=value,
+            file_path=self.loc.mod_path,
+            col_start=self.loc.col_start,
+            col_end=0,
+            line=self.loc.first_line,
+            pos_start=0,
+            pos_end=0,
+        )
+
     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
 
         return Pass.get_all_sub_nodes(node=self, typ=typ, brute_force=brute_force)
 
+    def has_parent_of_type(self, typ: Type[T]) -> Optional[T]:
+        """Get parent of type."""
+        from jaclang.compiler.passes import Pass
+
+        return Pass.has_parent_of_type(node=self, typ=typ)
+
+    def format(self) -> str:
+        """Get all sub nodes of type."""
+        from jaclang.compiler.passes.tool import JacFormatPass
+
+        return JacFormatPass(self, None).ir.gen.jac
+
     def to_dict(self) -> dict[str, str]:
         """Return dict representation of node."""
         ret = {
@@ -108,6 +150,18 @@ class AstNode:
             ret += k.flatten()
         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:
+            raise NotImplementedError(f"Node {type(self).__name__} is not valid.")
+        return res
+
 
 class AstSymbolNode(AstNode):
     """Nodes that have link to a symbol in symbol table."""
@@ -120,6 +174,7 @@ class AstSymbolNode(AstNode):
         self.sym_name: str = sym_name
         self.sym_name_node = sym_name_node
         self.sym_type: SymbolType = sym_type
+        self.sym_info: SymbolInfo = SymbolInfo()
         self.py_ctx_func: Type[ast3.AST] = ast3.Load
 
 
@@ -144,6 +199,9 @@ class AstAccessNode(AstNode):
         )
 
 
+T = TypeVar("T", bound=AstNode)
+
+
 class AstDocNode(AstNode):
     """Nodes that have access."""
 
@@ -195,11 +253,25 @@ class WalkerStmtOnlyNode(AstNode):
 class AstImplOnlyNode(AstNode):
     """ImplOnly node type for Jac Ast."""
 
-    def __init__(self, decl_link: Optional[AstNode]) -> None:
+    def __init__(self, body: SubNodeList, decl_link: Optional[AstNode]) -> None:
         """Initialize impl only node."""
+        self.body = body
         self.decl_link = decl_link
 
 
+class AstImplNeedingNode(AstSymbolNode, Generic[T]):
+    """Impl needing 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 Expr(AstNode):
     """Expr node type for Jac Ast."""
 
@@ -240,9 +312,6 @@ class MatchPattern(AstNode):
     """MatchPattern node type for Jac Ast."""
 
 
-T = TypeVar("T", bound=AstNode)
-
-
 class SubTag(AstNode, Generic[T]):
     """SubTag node type for Jac Ast."""
 
@@ -255,22 +324,54 @@ class SubTag(AstNode, Generic[T]):
         self.tag = tag
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize sub tag node."""
+        res = self.tag.normalize() if deep else True
+        AstNode.set_kids(self, nodes=[self.gen_token(Tok.COLON), self.tag])
+        return res
+
 
 # SubNodeList were created to simplify the type safety of the
 # parser's implementation. We basically need to maintain tokens
-# in the kid list as well as separating out items of interest in
-# the ast node class body.
+# 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]):
     """SubNodeList node type for Jac Ast."""
 
     def __init__(
         self,
         items: list[T],
+        delim: Optional[Tok],
         kid: Sequence[AstNode],
+        left_enc: Optional[Token] = None,
+        right_enc: Optional[Token] = None,
     ) -> None:
         """Initialize sub node list node."""
         self.items = items
-        AstNode.__init__(self, kid=kid)
+        self.delim = delim
+        self.left_enc = left_enc
+        self.right_enc = right_enc
+        AstNode.__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] = []
+        if self.left_enc:
+            new_kid.append(self.left_enc)
+        for i in self.items:
+            new_kid.append(i)
+            if self.delim:
+                new_kid.append(self.gen_token(self.delim))
+        if self.delim and self.items:
+            new_kid.pop()
+        if self.right_enc:
+            new_kid.append(self.right_enc)
+        AstNode.set_kids(self, nodes=new_kid if len(new_kid) else [EmptyToken()])
+        return res
 
 
 # AST Mid Level Node Types
@@ -288,6 +389,7 @@ class Module(AstDocNode):
         kid: Sequence[AstNode],
         impl_mod: Optional[Module] = None,
         test_mod: Optional[Module] = None,
+        registry: Optional[SemRegistry] = None,
     ) -> None:
         """Initialize whole program node."""
         self.name = name
@@ -297,9 +399,29 @@ class Module(AstDocNode):
         self.impl_mod = impl_mod
         self.test_mod = test_mod
         self.mod_deps: dict[str, Module] = {}
+        self.registry = registry
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    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] = []
+        if self.doc:
+            new_kid.append(self.doc)
+        new_kid.extend(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
+    def unparse(self) -> str:
+        """Unparse module node."""
+        super().unparse()
+        return self.format()
+
 
 class GlobalVars(ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
@@ -319,6 +441,26 @@ class GlobalVars(ElementStmt, AstAccessNode):
         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] = []
+        if self.doc:
+            new_kid.append(self.doc)
+        if self.is_frozen:
+            new_kid.append(self.gen_token(Tok.KW_LET))
+        else:
+            new_kid.append(self.gen_token(Tok.KW_GLOBAL))
+        if self.access:
+            new_kid.append(self.access)
+        new_kid.append(self.assignments)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class Test(AstSymbolNode, ElementStmt):
     """Test node type for Jac Ast."""
@@ -346,7 +488,6 @@ class Test(AstSymbolNode, ElementStmt):
                 line=name.loc.first_line,
                 pos_start=name.pos_start,
                 pos_end=name.pos_end,
-                kid=name.kid,
             )
         )
         self.name.parent = self
@@ -363,8 +504,24 @@ class Test(AstSymbolNode, ElementStmt):
         )
         AstDocNode.__init__(self, doc=doc)
 
-
-class ModuleCode(ElementStmt):
+    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] = []
+        if self.doc:
+            new_kid.append(self.doc)
+        new_kid.append(self.gen_token(Tok.KW_TEST))
+        new_kid.append(self.name)
+        new_kid.append(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
+
+class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
     """Free mod code for Jac Ast."""
 
     def __init__(
@@ -380,6 +537,24 @@ class ModuleCode(ElementStmt):
         AstNode.__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] = []
+        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.name)
+        new_kid.append(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class PyInlineCode(ElementStmt, ArchBlockStmt, EnumBlockStmt, CodeBlockStmt):
     """Inline Python code node type for Jac Ast."""
@@ -395,6 +570,21 @@ class PyInlineCode(ElementStmt, ArchBlockStmt, EnumBlockStmt, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    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] = []
+        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))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class Import(ElementStmt, CodeBlockStmt):
     """Import node type for Jac Ast."""
@@ -416,6 +606,36 @@ class Import(ElementStmt, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize import node."""
+        res = True
+        if deep:
+            res = self.lang.normalize(deep)
+            for p in self.paths:
+                res = res and p.normalize(deep)
+            res = res and self.items.normalize(deep) if self.items else res
+            res = res and self.doc.normalize(deep) if self.doc else res
+        new_kid: list[AstNode] = []
+        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))
+        new_kid.append(self.lang)
+        if self.items:
+            new_kid.append(self.gen_token(Tok.KW_FROM))
+        for p in self.paths:
+            new_kid.append(p)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        new_kid.pop()
+        if self.items:
+            new_kid.append(self.gen_token(Tok.COMMA))
+            new_kid.append(self.items)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ModulePath(AstSymbolNode):
     """ModulePath node type for Jac Ast."""
@@ -442,6 +662,29 @@ class ModulePath(AstSymbolNode):
             sym_type=SymbolType.MODULE,
         )
 
+    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 = res and self.alias.normalize(deep) if self.alias else res
+        new_kid: list[AstNode] = []
+        # 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()
+        if self.alias:
+            res = res and self.alias.normalize(deep)
+            new_kid.append(self.alias)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     @property
     def path_str(self) -> str:
         """Get path string."""
@@ -470,8 +713,21 @@ class ModuleItem(AstSymbolNode):
             sym_type=SymbolType.MOD_VAR,
         )
 
-
-class Architype(ArchSpec, AstAccessNode, ArchBlockStmt):
+    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]
+        if self.alias:
+            new_kid.append(self.gen_token(Tok.KW_AS))
+            new_kid.append(self.alias)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
+
+class Architype(ArchSpec, AstAccessNode, ArchBlockStmt, AstImplNeedingNode):
     """ObjectArch node type for Jac Ast."""
 
     def __init__(
@@ -490,7 +746,6 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt):
         self.name = name
         self.arch_type = arch_type
         self.base_classes = base_classes
-        self.body = body
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -514,6 +769,7 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt):
                 )
             ),
         )
+        AstImplNeedingNode.__init__(self, body=body)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
         AstSemStrNode.__init__(self, semstr=semstr)
@@ -529,6 +785,46 @@ class Architype(ArchSpec, AstAccessNode, ArchBlockStmt):
         )
         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)
+            res = res and self.arch_type.normalize(deep)
+            res = res and self.access.normalize(deep) if self.access else res
+            res = (
+                res and self.base_classes.normalize(deep) if self.base_classes else res
+            )
+            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] = []
+        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.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.base_classes)
+            new_kid.append(self.gen_token(Tok.COLON))
+        if self.body:
+            if isinstance(self.body, AstImplOnlyNode):
+                new_kid.append(self.gen_token(Tok.SEMI))
+            else:
+                new_kid.append(self.body)
+        else:
+            new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ArchDef(ArchSpec, AstImplOnlyNode):
     """ArchDef node type for Jac Ast."""
@@ -544,7 +840,6 @@ class ArchDef(ArchSpec, AstImplOnlyNode):
     ) -> None:
         """Initialize arch def node."""
         self.target = target
-        self.body = body
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -554,10 +849,26 @@ class ArchDef(ArchSpec, AstImplOnlyNode):
         )
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
-        AstImplOnlyNode.__init__(self, decl_link=decl_link)
-
-
-class Enum(ArchSpec, AstAccessNode):
+        AstImplOnlyNode.__init__(self, body=body, decl_link=decl_link)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize arch 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
+            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.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
+
+class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
     """Enum node type for Jac Ast."""
 
     def __init__(
@@ -574,7 +885,6 @@ class Enum(ArchSpec, AstAccessNode):
         """Initialize object arch node."""
         self.name = name
         self.base_classes = base_classes
-        self.body = body
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -582,11 +892,50 @@ class Enum(ArchSpec, AstAccessNode):
             sym_name_node=name,
             sym_type=SymbolType.ENUM_ARCH,
         )
+        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)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize enum node."""
+        res = True
+        if deep:
+            res = self.name.normalize(deep)
+            res = res and self.access.normalize(deep) if self.access else res
+            res = (
+                res and self.base_classes.normalize(deep) if self.base_classes else res
+            )
+            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] = []
+        if self.doc:
+            new_kid.append(self.doc)
+        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):
+                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))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class EnumDef(ArchSpec, AstImplOnlyNode):
     """EnumDef node type for Jac Ast."""
@@ -602,7 +951,6 @@ class EnumDef(ArchSpec, AstImplOnlyNode):
     ) -> None:
         """Initialize arch def node."""
         self.target = target
-        self.body = body
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
             self,
@@ -612,24 +960,41 @@ class EnumDef(ArchSpec, AstImplOnlyNode):
         )
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
-        AstImplOnlyNode.__init__(self, decl_link=decl_link)
+        AstImplOnlyNode.__init__(self, 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
+            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.gen_token(Tok.LBRACE))
+        new_kid.append(self.body)
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
 
 
 class Ability(
-    AstSymbolNode,
     AstAccessNode,
     ElementStmt,
     AstAsyncNode,
     ArchBlockStmt,
     CodeBlockStmt,
     AstSemStrNode,
+    AstImplNeedingNode,
 ):
     """Ability node type for Jac Ast."""
 
     def __init__(
         self,
         name_ref: NameSpec,
-        is_func: bool,
         is_async: bool,
         is_override: bool,
         is_static: bool,
@@ -644,14 +1009,13 @@ class Ability(
     ) -> None:
         """Initialize func arch node."""
         self.name_ref = name_ref
-        self.is_func = is_func
         self.is_override = is_override
         self.is_static = is_static
         self.is_abstract = is_abstract
         self.decorators = decorators
         self.signature = signature
-        self.body = body
         AstNode.__init__(self, kid=kid)
+        AstImplNeedingNode.__init__(self, body=body)
         AstSemStrNode.__init__(self, semstr=semstr)
         AstSymbolNode.__init__(
             self,
@@ -673,6 +1037,11 @@ class Ability(
             self.sym_type = SymbolType.METHOD
         return check
 
+    @property
+    def is_func(self) -> bool:
+        """Check if is func."""
+        return isinstance(self.body, FuncSignature)
+
     @property
     def is_genai_ability(self) -> bool:
         """Check if is genai_ability."""
@@ -687,6 +1056,54 @@ class Ability(
         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] = []
+        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.WS))
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
+        if self.is_override:
+            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))
+        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)
+        if self.is_genai_ability:
+            new_kid.append(self.gen_token(Tok.KW_BY))
+        if self.is_abstract:
+            new_kid.append(self.gen_token(Tok.KW_ABSTRACT))
+        if self.body:
+            if isinstance(self.body, AstImplOnlyNode):
+                new_kid.append(self.gen_token(Tok.SEMI))
+            else:
+                new_kid.append(self.body)
+                if self.is_genai_ability:
+                    new_kid.append(self.gen_token(Tok.SEMI))
+        else:
+            new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
     """AbilityDef node type for Jac Ast."""
@@ -704,7 +1121,6 @@ class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
         """Initialize ability def node."""
         self.target = target
         self.signature = signature
-        self.body = body
         self.decorators = decorators
         AstNode.__init__(self, kid=kid)
         AstSymbolNode.__init__(
@@ -714,7 +1130,27 @@ class AbilityDef(AstSymbolNode, ElementStmt, AstImplOnlyNode, CodeBlockStmt):
             sym_type=SymbolType.IMPL,
         )
         AstDocNode.__init__(self, doc=doc)
-        AstImplOnlyNode.__init__(self, decl_link=decl_link)
+        AstImplOnlyNode.__init__(self, 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)
+
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
 
     @property
     def is_method(self) -> bool:
@@ -741,6 +1177,26 @@ class FuncSignature(AstSemStrNode):
         AstNode.__init__(self, kid=kid)
         AstSemStrNode.__init__(self, semstr=semstr)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        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)]
+        if self.params:
+            new_kid.append(self.params)
+        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)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     @property
     def is_method(self) -> bool:
         """Check if is method."""
@@ -776,6 +1232,30 @@ class EventSignature(AstSemStrNode):
         AstNode.__init__(self, kid=kid)
         AstSemStrNode.__init__(self, semstr=semstr)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.event.normalize(deep)
+            res = (
+                res and self.arch_tag_info.normalize(deep)
+                if self.arch_tag_info
+                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)]
+        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)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     @property
     def is_method(self) -> bool:
         """Check if is method."""
@@ -800,6 +1280,18 @@ class ArchRefChain(AstNode):
         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)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     def py_resolve_name(self) -> str:
         """Resolve name."""
 
@@ -845,6 +1337,30 @@ class ParamVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         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] = []
+        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:
+            new_kid.append(self.gen_token(Tok.EQ))
+            new_kid.append(self.value)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
     """HasStmt node type for Jac Ast."""
@@ -866,6 +1382,30 @@ class ArchHas(AstAccessNode, AstDocNode, ArchBlockStmt):
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
 
+    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] = []
+        if self.doc:
+            new_kid.append(self.doc)
+        if self.is_static:
+            new_kid.append(self.gen_token(Tok.KW_STATIC))
+        (
+            new_kid.append(self.gen_token(Tok.KW_LET))
+            if self.is_frozen
+            else new_kid.append(self.gen_token(Tok.KW_HAS))
+        )
+        if self.access:
+            new_kid.append(self.access)
+        new_kid.append(self.vars)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
     """HasVar node type for Jac Ast."""
@@ -893,6 +1433,29 @@ class HasVar(AstSymbolNode, AstTypedVarNode, AstSemStrNode):
         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)
+        if self.type_tag:
+            new_kid.append(self.type_tag)
+        if self.value:
+            new_kid.append(self.gen_token(Tok.EQ))
+            new_kid.append(self.value)
+        if self.defer:
+            new_kid.append(self.gen_token(Tok.KW_BY))
+            new_kid.append(self.gen_token(Tok.KW_POST_INIT))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class TypedCtxBlock(CodeBlockStmt):
     """TypedCtxBlock node type for Jac Ast."""
@@ -908,6 +1471,20 @@ class TypedCtxBlock(CodeBlockStmt):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.RETURN_HINT),
+            self.type_ctx,
+            self.body,
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class IfStmt(CodeBlockStmt, AstElseBodyNode):
     """IfStmt node type for Jac Ast."""
@@ -925,10 +1502,44 @@ class IfStmt(CodeBlockStmt, AstElseBodyNode):
         AstNode.__init__(self, kid=kid)
         AstElseBodyNode.__init__(self, else_body=else_body)
 
+    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] = [
+            self.gen_token(Tok.KW_IF),
+            self.condition,
+            self.body,
+        ]
+        if self.else_body:
+            new_kid.append(self.else_body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ElseIf(IfStmt):
     """ElseIfs 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] = [
+            self.gen_token(Tok.KW_ELIF),
+            self.condition,
+            self.body,
+        ]
+        if self.else_body:
+            new_kid.append(self.else_body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ElseStmt(AstNode):
     """Else node type for Jac Ast."""
@@ -942,6 +1553,18 @@ class ElseStmt(AstNode):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize else statement node."""
+        res = True
+        if deep:
+            res = self.body.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_ELSE),
+            self.body,
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ExprStmt(CodeBlockStmt):
     """ExprStmt node type for Jac Ast."""
@@ -957,6 +1580,19 @@ class ExprStmt(CodeBlockStmt):
         self.in_fstring = in_fstring
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = True) -> bool:
+        """Normalize ast node."""
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[AstNode] = []
+        if self.in_fstring:
+            new_kid.append(self.expr)
+        else:
+            new_kid.append(self.expr)
+            new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res and self.expr is not None
+
 
 class TryStmt(AstElseBodyNode, CodeBlockStmt):
     """TryStmt node type for Jac Ast."""
@@ -976,6 +1612,29 @@ class TryStmt(AstElseBodyNode, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstElseBodyNode.__init__(self, else_body=else_body)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize try statement node."""
+        res = True
+        if deep:
+            res = self.body.normalize(deep)
+            res = res and self.excepts.normalize(deep) if self.excepts else res
+            res = res and self.else_body.normalize(deep) if self.else_body else res
+            res = (
+                res and self.finally_body.normalize(deep) if self.finally_body else res
+            )
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_TRY),
+        ]
+        new_kid.append(self.body)
+        if self.excepts:
+            new_kid.append(self.excepts)
+        if self.else_body:
+            new_kid.append(self.else_body)
+        if self.finally_body:
+            new_kid.append(self.finally_body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class Except(CodeBlockStmt):
     """Except node type for Jac Ast."""
@@ -993,6 +1652,24 @@ class Except(CodeBlockStmt):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.KW_EXCEPT),
+            self.ex_type,
+        ]
+        if self.name:
+            new_kid.append(self.gen_token(Tok.KW_AS))
+            new_kid.append(self.name)
+        new_kid.append(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class FinallyStmt(CodeBlockStmt):
     """FinallyStmt node type for Jac Ast."""
@@ -1006,6 +1683,18 @@ class FinallyStmt(CodeBlockStmt):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize finally statement node."""
+        res = True
+        if deep:
+            res = self.body.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_FINALLY),
+        ]
+        new_kid.append(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
     """IterFor node type for Jac Ast."""
@@ -1029,6 +1718,30 @@ class IterForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         AstAsyncNode.__init__(self, is_async=is_async)
         AstElseBodyNode.__init__(self, else_body=else_body)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize iter for node."""
+        res = True
+        if deep:
+            res = self.iter.normalize(deep)
+            res = self.condition.normalize(deep)
+            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] = []
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
+        new_kid.append(self.gen_token(Tok.KW_FOR))
+        new_kid.append(self.iter)
+        new_kid.append(self.gen_token(Tok.KW_TO))
+        new_kid.append(self.condition)
+        new_kid.append(self.gen_token(Tok.KW_BY))
+        new_kid.append(self.count_by)
+        new_kid.append(self.body)
+        if self.else_body:
+            new_kid.append(self.else_body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
     """InFor node type for Jac Ast."""
@@ -1050,6 +1763,29 @@ class InForStmt(AstAsyncNode, AstElseBodyNode, CodeBlockStmt):
         AstAsyncNode.__init__(self, is_async=is_async)
         AstElseBodyNode.__init__(self, else_body=else_body)
 
+    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] = []
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
+        new_kid.append(self.gen_token(Tok.KW_FOR))
+        new_kid.append(self.target)
+        new_kid.append(self.gen_token(Tok.KW_IN))
+        new_kid.append(self.collection)
+
+        if self.body:
+            new_kid.append(self.body)
+        if self.else_body:
+            new_kid.append(self.else_body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class WhileStmt(CodeBlockStmt):
     """WhileStmt node type for Jac Ast."""
@@ -1065,6 +1801,21 @@ class WhileStmt(CodeBlockStmt):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.KW_WHILE),
+            self.condition,
+        ]
+        if self.body:
+            new_kid.append(self.body)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class WithStmt(AstAsyncNode, CodeBlockStmt):
     """WithStmt node type for Jac Ast."""
@@ -1082,6 +1833,24 @@ class WithStmt(AstAsyncNode, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
 
+    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] = []
+        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))
+
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ExprAsItem(AstNode):
     """ExprAsItem node type for Jac Ast."""
@@ -1097,6 +1866,19 @@ class ExprAsItem(AstNode):
         self.alias = alias
         AstNode.__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]
+        if self.alias:
+            new_kid.append(self.gen_token(Tok.KW_AS))
+            new_kid.append(self.alias)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class RaiseStmt(CodeBlockStmt):
     """RaiseStmt node type for Jac Ast."""
@@ -1112,6 +1894,22 @@ class RaiseStmt(CodeBlockStmt):
         self.from_target = from_target
         AstNode.__init__(self, kid=kid)
 
+    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)]
+        if self.cause:
+            new_kid.append(self.cause)
+        if self.from_target:
+            new_kid.append(self.gen_token(Tok.KW_FROM))
+            new_kid.append(self.from_target)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class AssertStmt(CodeBlockStmt):
     """AssertStmt node type for Jac Ast."""
@@ -1127,6 +1925,23 @@ class AssertStmt(CodeBlockStmt):
         self.error_msg = error_msg
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.KW_ASSERT),
+            self.condition,
+        ]
+        if self.error_msg:
+            new_kid.append(self.gen_token(Tok.COMMA))
+            new_kid.append(self.error_msg)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class CtrlStmt(CodeBlockStmt):
     """CtrlStmt node type for Jac Ast."""
@@ -1140,6 +1955,15 @@ class CtrlStmt(CodeBlockStmt):
         self.ctrl = ctrl
         AstNode.__init__(self, kid=kid)
 
+    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)]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class DeleteStmt(CodeBlockStmt):
     """DeleteStmt node type for Jac Ast."""
@@ -1153,6 +1977,19 @@ class DeleteStmt(CodeBlockStmt):
         self.target = target
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize delete statement node."""
+        res = True
+        if deep:
+            res = self.target.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_DELETE),
+            self.target,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ReportStmt(CodeBlockStmt):
     """ReportStmt node type for Jac Ast."""
@@ -1166,6 +2003,19 @@ class ReportStmt(CodeBlockStmt):
         self.expr = expr
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize report statement node."""
+        res = True
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_REPORT),
+            self.expr,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ReturnStmt(CodeBlockStmt):
     """ReturnStmt node type for Jac Ast."""
@@ -1179,6 +2029,20 @@ class ReturnStmt(CodeBlockStmt):
         self.expr = expr
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.KW_RETURN),
+        ]
+        if self.expr:
+            new_kid.append(self.expr)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class IgnoreStmt(WalkerStmtOnlyNode, CodeBlockStmt):
     """IgnoreStmt node type for Jac Ast."""
@@ -1193,6 +2057,19 @@ class IgnoreStmt(WalkerStmtOnlyNode, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__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] = [
+            self.gen_token(Tok.KW_IGNORE),
+            self.target,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class VisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
     """VisitStmt node type for Jac Ast."""
@@ -1211,6 +2088,27 @@ class VisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
         WalkerStmtOnlyNode.__init__(self)
         AstElseBodyNode.__init__(self, else_body=else_body)
 
+    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.target.normalize(deep)
+            res = res and self.else_body.normalize(deep) if self.else_body else res
+        new_kid: list[AstNode] = []
+        new_kid.append(self.gen_token(Tok.KW_VISIT))
+        if self.vis_type:
+            new_kid.append(self.gen_token(Tok.COLON))
+            new_kid.append(self.vis_type)
+            new_kid.append(self.gen_token(Tok.COLON))
+        new_kid.append(self.target)
+        if self.else_body:
+            new_kid.append(self.else_body)
+        else:
+            new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class RevisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
     """ReVisitStmt node type for Jac Ast."""
@@ -1227,6 +2125,21 @@ class RevisitStmt(WalkerStmtOnlyNode, AstElseBodyNode, CodeBlockStmt):
         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))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class DisengageStmt(WalkerStmtOnlyNode, CodeBlockStmt):
     """DisengageStmt node type for Jac Ast."""
@@ -1239,6 +2152,15 @@ class DisengageStmt(WalkerStmtOnlyNode, CodeBlockStmt):
         AstNode.__init__(self, kid=kid)
         WalkerStmtOnlyNode.__init__(self)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize disengage statement node."""
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_DISENGAGE),
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return True
+
 
 class AwaitExpr(Expr):
     """AwaitStmt node type for Jac Ast."""
@@ -1252,6 +2174,18 @@ class AwaitExpr(Expr):
         self.target = target
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize sync statement node."""
+        res = True
+        if deep:
+            res = self.target.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_AWAIT),
+            self.target,
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class GlobalStmt(CodeBlockStmt):
     """GlobalStmt node type for Jac Ast."""
@@ -1265,12 +2199,38 @@ class GlobalStmt(CodeBlockStmt):
         self.target = target
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize global statement node."""
+        res = True
+        if deep:
+            res = self.target.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.GLOBAL_OP),
+            self.target,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class NonLocalStmt(GlobalStmt):
     """NonlocalStmt node type for Jac Ast."""
 
-
-class Assignment(AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize nonlocal statement node."""
+        res = True
+        if deep:
+            res = self.target.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.NONLOCAL_OP),
+            self.target,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
+
+class Assignment(AstSemStrNode, AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
     """Assignment node type for Jac Ast."""
 
     def __init__(
@@ -1281,15 +2241,50 @@ class Assignment(AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
         kid: Sequence[AstNode],
         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)
         AstTypedVarNode.__init__(self, type_tag=type_tag)
 
+    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.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:
+            new_kid.append(self.aug_op)
+        if self.value:
+            if not self.aug_op:
+                new_kid.append(self.gen_token(Tok.EQ))
+            new_kid.append(self.value)
+        if isinstance(self.parent, SubNodeList) and isinstance(
+            self.parent.parent, GlobalVars
+        ):
+            if self.parent.kid.index(self) == len(self.parent.kid) - 1:
+                new_kid.append(self.gen_token(Tok.SEMI))
+        elif (not self.is_enum_stmt) and not isinstance(self.parent, IterForStmt):
+            new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class BinaryExpr(Expr):
     """ExprBinary node type for Jac Ast."""
@@ -1307,6 +2302,23 @@ class BinaryExpr(Expr):
         self.op = op
         AstNode.__init__(self, kid=kid)
 
+    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),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class CompareExpr(Expr):
     """CompareExpr node type for Jac Ast."""
@@ -1324,6 +2336,22 @@ class CompareExpr(Expr):
         self.ops = ops
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.left.normalize(deep)
+            for right in self.rights:
+                res = res and right.normalize(deep)
+            for op in self.ops:
+                res = res and op.normalize(deep)
+        new_kid: list[AstNode] = [self.left]
+        for i, right in enumerate(self.rights):
+            new_kid.append(self.ops[i])
+            new_kid.append(right)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class BoolExpr(Expr):
     """BoolExpr node type for Jac Ast."""
@@ -1339,6 +2367,21 @@ class BoolExpr(Expr):
         self.op = op
         AstNode.__init__(self, kid=kid)
 
+    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] = []
+        for i, value in enumerate(self.values):
+            if i > 0:
+                new_kid.append(self.op)
+            new_kid.append(value)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class LambdaExpr(Expr):
     """ExprLambda node type for Jac Ast."""
@@ -1354,6 +2397,22 @@ class LambdaExpr(Expr):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.signature.normalize(deep)
+            res = res and self.body.normalize(deep)
+        new_kid: list[AstNode] = [
+            self.gen_token(Tok.KW_WITH),
+            self.signature,
+            self.gen_token(Tok.KW_CAN),
+            self.body,
+            self.gen_token(Tok.SEMI),
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class UnaryExpr(Expr):
     """ExprUnary node type for Jac Ast."""
@@ -1369,6 +2428,16 @@ class UnaryExpr(Expr):
         self.op = op
         AstNode.__init__(self, kid=kid)
 
+    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]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class IfElseExpr(Expr):
     """ExprIfElse node type for Jac Ast."""
@@ -1386,6 +2455,23 @@ class IfElseExpr(Expr):
         self.else_value = else_value
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.value,
+            self.gen_token(Tok.KW_IF),
+            self.condition,
+            self.gen_token(Tok.KW_ELSE),
+            self.else_value,
+        ]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MultiString(AtomExpr):
     """ExprMultiString node type for Jac Ast."""
@@ -1405,8 +2491,20 @@ class MultiString(AtomExpr):
             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] = []
+        for string in self.strings:
+            new_kid.append(string)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
 
-class FString(AstSymbolNode):
+
+class FString(AtomExpr):
     """FString node type for Jac Ast."""
 
     def __init__(
@@ -1424,18 +2522,21 @@ class FString(AstSymbolNode):
             sym_type=SymbolType.STRING,
         )
 
-
-class ExprList(AstNode):
-    """ExprList node type for Jac Ast."""
-
-    def __init__(
-        self,
-        values: Optional[SubNodeList[Expr]],
-        kid: Sequence[AstNode],
-    ) -> None:
-        """Initialize expr value node."""
-        self.values = values
-        AstNode.__init__(self, kid=kid)
+    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] = []
+        if self.parts:
+            for i in self.parts.items:
+                if isinstance(i, String):
+                    i.value = (
+                        "{{" if i.value == "{" else "}}" if i.value == "}" else i.value
+                    )
+            new_kid.append(self.parts)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
 
 
 class ListVal(AtomExpr):
@@ -1456,6 +2557,20 @@ class ListVal(AtomExpr):
             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] = [
+            self.gen_token(Tok.LSQUARE),
+        ]
+        if self.values:
+            new_kid.append(self.values)
+        new_kid.append(self.gen_token(Tok.RSQUARE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class SetVal(AtomExpr):
     """SetVal node type for Jac Ast."""
@@ -1475,6 +2590,20 @@ class SetVal(AtomExpr):
             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] = [
+            self.gen_token(Tok.LBRACE),
+        ]
+        if self.values:
+            new_kid.append(self.values)
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class TupleVal(AtomExpr):
     """TupleVal node type for Jac Ast."""
@@ -1494,6 +2623,35 @@ class TupleVal(AtomExpr):
             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
+        in_ret_type = (
+            self.parent
+            and isinstance(self.parent, IndexSlice)
+            and self.parent
+            and isinstance(self.parent.parent, AtomTrailer)
+            and self.parent.parent
+            and isinstance(self.parent.parent.parent, FuncSignature)
+        )
+        new_kid: list[AstNode] = (
+            [
+                self.gen_token(Tok.LPAREN),
+            ]
+            if not in_ret_type
+            else []
+        )
+        if self.values:
+            new_kid.append(self.values)
+            if len(self.values.items) < 2:
+                new_kid.append(self.gen_token(Tok.COMMA))
+        if not in_ret_type:
+            new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class DictVal(AtomExpr):
     """ExprDict node type for Jac Ast."""
@@ -1513,6 +2671,23 @@ class DictVal(AtomExpr):
             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] = [
+            self.gen_token(Tok.LBRACE),
+        ]
+        for i, kv_pair in enumerate(self.kv_pairs):
+            new_kid.append(kv_pair)
+            if i < len(self.kv_pairs) - 1:
+                new_kid.append(self.gen_token(Tok.COMMA))
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class KVPair(AstNode):
     """ExprKVPair node type for Jac Ast."""
@@ -1528,6 +2703,22 @@ class KVPair(AstNode):
         self.value = value
         AstNode.__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] = []
+        if self.key:
+            new_kid.append(self.key)
+            new_kid.append(self.gen_token(Tok.COLON))
+        else:
+            new_kid.append(self.gen_token(Tok.STAR_POW))
+        new_kid.append(self.value)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class KWPair(AstNode):
     """ExprKWPair node type for Jac Ast."""
@@ -1543,6 +2734,20 @@ class KWPair(AstNode):
         self.value = value
         AstNode.__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] = []
+        if self.key:
+            new_kid.append(self.key)
+            new_kid.append(self.gen_token(Tok.EQ))
+        new_kid.append(self.value)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class InnerCompr(AstAsyncNode):
     """ListCompr node type for Jac Ast."""
@@ -1552,7 +2757,7 @@ class InnerCompr(AstAsyncNode):
         is_async: bool,
         target: Expr,
         collection: Expr,
-        conditional: Optional[Expr],
+        conditional: Optional[list[Expr]],
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize comprehension expression node."""
@@ -1562,6 +2767,27 @@ class InnerCompr(AstAsyncNode):
         AstNode.__init__(self, kid=kid)
         AstAsyncNode.__init__(self, is_async=is_async)
 
+    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] = []
+        if self.is_async:
+            new_kid.append(self.gen_token(Tok.KW_ASYNC))
+        new_kid.append(self.gen_token(Tok.KW_FOR))
+        new_kid.append(self.target)
+        new_kid.append(self.gen_token(Tok.KW_IN))
+        new_kid.append(self.collection)
+        for cond in self.conditional if self.conditional else []:
+            new_kid.append(self.gen_token(Tok.KW_IF))
+            new_kid.append(cond)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ListCompr(AtomExpr):
     """ListCompr node type for Jac Ast."""
@@ -1583,14 +2809,65 @@ class ListCompr(AtomExpr):
             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] = [
+            self.gen_token(Tok.LSQUARE),
+            self.out_expr,
+        ]
+        for comp in self.compr:
+            new_kid.append(comp)
+        new_kid.append(self.gen_token(Tok.RSQUARE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 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] = [
+            self.gen_token(Tok.LPAREN),
+            self.out_expr,
+        ]
+        for comp in self.compr:
+            new_kid.append(comp)
+        new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 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] = [
+            self.gen_token(Tok.LBRACE),
+            self.out_expr,
+        ]
+        for comp in self.compr:
+            new_kid.append(comp)
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class DictCompr(AtomExpr):
     """DictCompr node type for Jac Ast."""
@@ -1612,6 +2889,22 @@ class DictCompr(AtomExpr):
             sym_type=SymbolType.SEQUENCE,
         )
 
+    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] = [
+            self.gen_token(Tok.LBRACE),
+            self.kv_pair,
+        ]
+        for comp in self.compr:
+            new_kid.append(comp)
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class AtomTrailer(Expr):
     """AtomTrailer node type for Jac Ast."""
@@ -1620,7 +2913,7 @@ class AtomTrailer(Expr):
         self,
         target: Expr,
         right: AtomExpr | Expr,
-        is_attr: Optional[Token],
+        is_attr: bool,
         is_null_ok: bool,
         kid: Sequence[AstNode],
     ) -> None:
@@ -1631,6 +2924,22 @@ class AtomTrailer(Expr):
         self.is_null_ok = is_null_ok
         AstNode.__init__(self, kid=kid)
 
+    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]
+        if self.is_null_ok:
+            new_kid.append(self.gen_token(Tok.NULL_OK))
+        if self.is_attr:
+            new_kid.append(self.gen_token(Tok.DOT))
+        if self.right:
+            new_kid.append(self.right)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class AtomUnit(Expr):
     """AtomUnit node type for Jac Ast."""
@@ -1638,14 +2947,24 @@ class AtomUnit(Expr):
     def __init__(
         self,
         value: Expr | YieldExpr,
-        is_paren: bool,
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize atom unit expression node."""
         self.value = value
-        self.is_paren = is_paren
         AstNode.__init__(self, kid=kid)
 
+    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.append(self.gen_token(Tok.LPAREN))
+        new_kid.append(self.value)
+        new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class YieldExpr(Expr):
     """YieldStmt node type for Jac Ast."""
@@ -1661,6 +2980,20 @@ class YieldExpr(Expr):
         self.with_from = with_from
         AstNode.__init__(self, kid=kid)
 
+    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)]
+        if self.with_from:
+            new_kid.append(self.gen_token(Tok.KW_FROM))
+        if self.expr:
+            new_kid.append(self.expr)
+        new_kid.append(self.gen_token(Tok.SEMI))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class FuncCall(Expr):
     """FuncCall node type for Jac Ast."""
@@ -1676,6 +3009,17 @@ class FuncCall(Expr):
         self.params = params
         AstNode.__init__(self, kid=kid)
 
+    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))
+        AstNode.__init__(self, kid=[self.target, self.gen_token(Tok.LPAREN, "(")])
+        if self.params:  # TODO: Fix
+            self.kid.append(self.params)
+        self.kid.append(self.gen_token(Tok.RPAREN, ")"))
+        return res
+
 
 class IndexSlice(AtomExpr):
     """IndexSlice node type for Jac Ast."""
@@ -1701,6 +3045,32 @@ class IndexSlice(AtomExpr):
             sym_name_node=self,
         )
 
+    def normalize(self, deep: bool = True) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.start.normalize(deep) if self.start else res
+            res = res and self.stop.normalize(deep) if self.stop else res
+            res = res and self.step.normalize(deep) if self.step else res
+        new_kid: list[AstNode] = []
+        new_kid.append(self.gen_token(Tok.LSQUARE))
+        if self.is_range:
+            if self.start:
+                new_kid.append(self.start)
+            if self.stop:
+                new_kid.append(self.gen_token(Tok.COLON))
+                new_kid.append(self.stop)
+            if self.step:
+                new_kid.append(self.gen_token(Tok.COLON))
+                new_kid.append(self.step)
+        elif self.start:
+            new_kid.append(self.start)
+        else:
+            res = False
+        new_kid.append(self.gen_token(Tok.RSQUARE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ArchRef(NameSpec):
     """ArchRef node type for Jac Ast."""
@@ -1722,6 +3092,15 @@ class ArchRef(NameSpec):
             sym_type=SymbolType.TYPE,
         )
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.name_ref.normalize(deep)
+        new_kid: list[AstNode] = [self.arch, self.name_ref]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     def py_resolve_name(self) -> str:
         """Resolve name."""
         if isinstance(self.name_ref, Name):
@@ -1750,6 +3129,15 @@ class SpecialVarRef(NameSpec):
             sym_type=SymbolType.VAR,
         )
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize ast node."""
+        res = True
+        if deep:
+            res = self.var.normalize(deep)
+        new_kid: list[AstNode] = [self.var]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
     def py_resolve_name(self) -> str:
         """Resolve name."""
         if self.var.name == Tok.KW_SELF:
@@ -1782,6 +3170,20 @@ class EdgeRefTrailer(Expr):
         self.edges_only = edges_only
         AstNode.__init__(self, kid=kid)
 
+    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.append(self.gen_token(Tok.LSQUARE))
+        new_kid.extend(self.chain)
+        new_kid.append(self.gen_token(Tok.RSQUARE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
     """EdgeOpRef node type for Jac Ast."""
@@ -1804,6 +3206,36 @@ class EdgeOpRef(WalkerStmtOnlyNode, AtomExpr):
             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] = []
+        if self.edge_dir == EdgeDir.IN:
+            if not self.filter_cond:
+                new_kid.append(self.gen_token(Tok.ARROW_L))
+            else:
+                new_kid.append(self.gen_token(Tok.ARROW_L_P1))
+                new_kid.append(self.filter_cond)
+                new_kid.append(self.gen_token(Tok.ARROW_L_P2))
+        elif self.edge_dir == EdgeDir.OUT:
+            if not self.filter_cond:
+                new_kid.append(self.gen_token(Tok.ARROW_R))
+            else:
+                new_kid.append(self.gen_token(Tok.ARROW_R_P1))
+                new_kid.append(self.filter_cond)
+                new_kid.append(self.gen_token(Tok.ARROW_R_P2))
+        else:
+            if not self.filter_cond:
+                new_kid.append(self.gen_token(Tok.ARROW_BI))
+            else:
+                new_kid.append(self.gen_token(Tok.ARROW_L_P1))
+                new_kid.append(self.filter_cond)
+                new_kid.append(self.gen_token(Tok.ARROW_R_P2))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class DisconnectOp(WalkerStmtOnlyNode):
     """DisconnectOpRef node type for Jac Ast."""
@@ -1818,6 +3250,15 @@ class DisconnectOp(WalkerStmtOnlyNode):
         AstNode.__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]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class ConnectOp(AstNode):
     """ConnectOpRef node type for Jac Ast."""
@@ -1835,6 +3276,49 @@ class ConnectOp(AstNode):
         self.edge_dir = edge_dir
         AstNode.__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] = []
+        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))
+            else:
+                new_kid.append(self.gen_token(Tok.CARROW_L_P1))
+                if self.conn_type:
+                    new_kid.append(self.conn_type)
+                if self.conn_assign:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(self.conn_assign)
+                new_kid.append(self.gen_token(Tok.CARROW_L_P2))
+        elif self.edge_dir == EdgeDir.OUT:
+            if not self.conn_assign and not self.conn_type:
+                new_kid.append(self.gen_token(Tok.CARROW_R))
+            else:
+                new_kid.append(self.gen_token(Tok.CARROW_R_P1))
+                if self.conn_type:
+                    new_kid.append(self.conn_type)
+                if self.conn_assign:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(self.conn_assign)
+                new_kid.append(self.gen_token(Tok.CARROW_R_P2))
+        else:
+            if not self.conn_assign and not self.conn_type:
+                new_kid.append(self.gen_token(Tok.CARROW_BI))
+            else:
+                new_kid.append(self.gen_token(Tok.CARROW_L_P1))
+                if self.conn_type:
+                    new_kid.append(self.conn_type)
+                if self.conn_assign:
+                    new_kid.append(self.gen_token(Tok.COLON))
+                    new_kid.append(self.conn_assign)
+                new_kid.append(self.gen_token(Tok.CARROW_R_P2))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class FilterCompr(AtomExpr):
     """FilterCtx node type for Jac Ast."""
@@ -1856,6 +3340,29 @@ class FilterCompr(AtomExpr):
             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] = []
+        if not isinstance(self.parent, EdgeOpRef):
+            new_kid.append(self.gen_token(Tok.LPAREN))
+            if self.f_type:
+                new_kid.append(self.gen_token(Tok.TYPE_OP))
+            new_kid.append(self.gen_token(Tok.NULL_OK))
+        if self.f_type:
+            new_kid.append(self.f_type)
+        if self.compares:
+            if self.f_type:
+                new_kid.append(self.gen_token(Tok.COLON))
+            new_kid.append(self.compares)
+        if not isinstance(self.parent, EdgeOpRef):
+            new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class AssignCompr(AtomExpr):
     """AssignCtx node type for Jac Ast."""
@@ -1875,6 +3382,22 @@ class AssignCompr(AtomExpr):
             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] = []
+        if isinstance(self.parent, ConnectOp):
+            new_kid.append(self.assigns)
+        else:
+            new_kid.append(self.gen_token(Tok.LPAREN))
+            new_kid.append(self.gen_token(Tok.EQ))
+            new_kid.append(self.assigns)
+            new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 # Match Nodes
 # ------------
@@ -1894,6 +3417,25 @@ class MatchStmt(CodeBlockStmt):
         self.cases = cases
         AstNode.__init__(self, kid=kid)
 
+    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] = [
+            self.gen_token(Tok.KW_MATCH),
+            self.target,
+        ]
+        new_kid.append(self.gen_token(Tok.LBRACE))
+        for case in self.cases:
+            new_kid.append(case)
+        new_kid.append(self.gen_token(Tok.RBRACE))
+
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchCase(AstNode):
     """MatchCase node type for Jac Ast."""
@@ -1902,7 +3444,7 @@ class MatchCase(AstNode):
         self,
         pattern: MatchPattern,
         guard: Optional[Expr],
-        body: SubNodeList[CodeBlockStmt],
+        body: list[CodeBlockStmt],
         kid: Sequence[AstNode],
     ) -> None:
         """Initialize match case node."""
@@ -1911,6 +3453,24 @@ class MatchCase(AstNode):
         self.body = body
         AstNode.__init__(self, kid=kid)
 
+    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]
+        if self.guard:
+            new_kid.append(self.gen_token(Tok.KW_IF))
+            new_kid.append(self.guard)
+        new_kid.append(self.gen_token(Tok.COLON))
+        if self.body:
+            new_kid.extend([*self.body])
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchOr(MatchPattern):
     """MatchOr node type for Jac Ast."""
@@ -1924,6 +3484,20 @@ class MatchOr(MatchPattern):
         self.patterns = patterns
         AstNode.__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] = []
+        for pattern in self.patterns:
+            new_kid.append(pattern)
+            new_kid.append(self.gen_token(Tok.KW_OR))
+        new_kid.pop()
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchAs(MatchPattern):
     """MatchAs node type for Jac Ast."""
@@ -1939,10 +3513,43 @@ class MatchAs(MatchPattern):
         self.pattern = pattern
         AstNode.__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] = []
+        if self.pattern:
+            new_kid.append(self.pattern)
+            new_kid.append(self.gen_token(Tok.KW_AS))
+        new_kid.append(self.name)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchWild(MatchPattern):
     """Match wild card node type for Jac Ast."""
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize match wild card node."""
+        AstNode.set_kids(
+            self,
+            nodes=[
+                Name(
+                    file_path=self.loc.mod_path,
+                    name=Tok.NAME,
+                    value="_",
+                    col_start=self.loc.col_start,
+                    col_end=self.loc.col_end,
+                    line=self.loc.first_line,
+                    pos_start=self.loc.pos_start,
+                    pos_end=self.loc.pos_end,
+                )
+            ],
+        )
+        return True
+
 
 class MatchValue(MatchPattern):
     """MatchValue node type for Jac Ast."""
@@ -1956,6 +3563,14 @@ class MatchValue(MatchPattern):
         self.value = value
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize match value node."""
+        res = True
+        if deep:
+            res = self.value.normalize(deep)
+        AstNode.set_kids(self, nodes=[self.value])
+        return res
+
 
 class MatchSingleton(MatchPattern):
     """MatchSingleton node type for Jac Ast."""
@@ -1969,6 +3584,12 @@ class MatchSingleton(MatchPattern):
         self.value = value
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize match singleton node."""
+        res = True
+        AstNode.set_kids(self, nodes=[self.value])
+        return res
+
 
 class MatchSequence(MatchPattern):
     """MatchSequence node type for Jac Ast."""
@@ -1982,6 +3603,21 @@ class MatchSequence(MatchPattern):
         self.values = values
         AstNode.__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)]
+        for value in self.values:
+            new_kid.append(value)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        new_kid.pop()
+        new_kid.append(self.gen_token(Tok.RSQUARE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchMapping(MatchPattern):
     """MatchMapping node type for Jac Ast."""
@@ -1995,6 +3631,21 @@ class MatchMapping(MatchPattern):
         self.values = values
         AstNode.__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)]
+        for value in self.values:
+            new_kid.append(value)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        new_kid.pop()
+        new_kid.append(self.gen_token(Tok.RBRACE))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchKVPair(MatchPattern):
     """MatchKVPair node type for Jac Ast."""
@@ -2010,6 +3661,19 @@ class MatchKVPair(MatchPattern):
         self.value = value
         AstNode.__init__(self, kid=kid)
 
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize match key value pair node."""
+        res = True
+        if deep:
+            res = (
+                self.key.normalize(deep) if isinstance(self.key, MatchPattern) else True
+            )
+            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]
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchStar(MatchPattern):
     """MatchStar node type for Jac Ast."""
@@ -2025,6 +3689,18 @@ class MatchStar(MatchPattern):
         self.is_list = is_list
         AstNode.__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] = [
+            self.gen_token(Tok.STAR_MUL if self.is_list else Tok.STAR_POW)
+        ]
+        new_kid.append(self.name)
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 class MatchArch(MatchPattern):
     """MatchClass node type for Jac Ast."""
@@ -2042,6 +3718,26 @@ class MatchArch(MatchPattern):
         self.kw_patterns = kw_patterns
         AstNode.__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.append(self.gen_token(Tok.LPAREN))
+        if self.arg_patterns:
+            new_kid.append(self.arg_patterns)
+            new_kid.append(self.gen_token(Tok.COMMA))
+        if self.kw_patterns:
+            new_kid.append(self.kw_patterns)
+        else:
+            new_kid.pop()
+        new_kid.append(self.gen_token(Tok.RPAREN))
+        AstNode.set_kids(self, nodes=new_kid)
+        return res
+
 
 # AST Terminal Node Types
 # --------------------------
@@ -2058,7 +3754,6 @@ class Token(AstNode):
         col_end: int,
         pos_start: int,
         pos_end: int,
-        kid: Sequence[AstNode],
     ) -> None:
         """Initialize token."""
         self.file_path = file_path
@@ -2069,7 +3764,15 @@ class Token(AstNode):
         self.c_end = col_end
         self.pos_start = pos_start
         self.pos_end = pos_end
-        AstNode.__init__(self, kid=kid)
+        AstNode.__init__(self, kid=[])
+
+    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
 
 
 class Name(Token, NameSpec):
@@ -2085,7 +3788,6 @@ class Name(Token, NameSpec):
         col_end: int,
         pos_start: int,
         pos_end: int,
-        kid: Sequence[AstNode],
         is_enum_singleton: bool = False,
         is_kwesc: bool = False,
     ) -> None:
@@ -2102,7 +3804,6 @@ class Name(Token, NameSpec):
             col_end=col_end,
             pos_start=pos_start,
             pos_end=pos_end,
-            kid=kid,
         )
         AstSymbolNode.__init__(
             self,
@@ -2111,6 +3812,13 @@ class Name(Token, NameSpec):
             sym_type=SymbolType.VAR,
         )
 
+    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 ""
+        )
+
 
 class Literal(Token, AtomExpr):
     """Literal node type for Jac Ast."""
@@ -2140,7 +3848,6 @@ class Literal(Token, AtomExpr):
         col_end: int,
         pos_start: int,
         pos_end: int,
-        kid: Sequence[AstNode],
     ) -> None:
         """Initialize token."""
         Token.__init__(
@@ -2153,7 +3860,6 @@ class Literal(Token, AtomExpr):
             col_end=col_end,
             pos_start=pos_start,
             pos_end=pos_end,
-            kid=kid,
         )
         AstSymbolNode.__init__(
             self,
@@ -2185,7 +3891,6 @@ class TokenSymbol(Token, AstSymbolNode):
         col_end: int,
         pos_start: int,
         pos_end: int,
-        kid: Sequence[AstNode],
     ) -> None:
         """Initialize token."""
         Token.__init__(
@@ -2198,7 +3903,6 @@ class TokenSymbol(Token, AstSymbolNode):
             col_end=col_end,
             pos_start=pos_start,
             pos_end=pos_end,
-            kid=kid,
         )
         AstSymbolNode.__init__(
             self,
@@ -2251,6 +3955,8 @@ class String(Literal):
     @property
     def lit_value(self) -> str:
         """Return literal value in its python type."""
+        if isinstance(self.value, bytes):
+            return self.value
         prefix_len = 3 if self.value.startswith(("'''", '"""')) else 1
         if any(
             self.value.startswith(prefix)
@@ -2261,10 +3967,19 @@ class String(Literal):
 
         elif self.value.startswith(("'", '"')):
             ret_str = self.value[prefix_len:-prefix_len]
+            return ret_str.encode().decode("unicode_escape", errors="backslashreplace")
         else:
-            ret_str = self.value
-        ret_str = ret_str.encode().decode("unicode_escape")
-        return ret_str
+            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)
 
 
 class Bool(Literal):
@@ -2314,7 +4029,6 @@ class EmptyToken(Token):
             col_end=0,
             pos_start=0,
             pos_end=0,
-            kid=[],
         )