jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/compiler/unitree.py

@@ -18,6 +18,8 @@ from typing import (
     Sequence,
     Type,
     TypeVar,
+    Union,
+    cast,
 )
 
 
@@ -227,8 +229,12 @@ class UniNode:
         return res
 
 
-# Symbols can have mulitple definitions but resolves decl to be the
+# Symbols can have multiple definitions but resolves decl to be the
 # first such definition in a given scope.
+# Symbols may exist without a parent symbol table (parent_tab=None),
+# such as imports like 'from a.b.c {...}' or with alias.
+# These symbols(a,b,c) are not inserted into symbol tables
+# but are still used for go-to-def, find references, and rename.
 class Symbol:
     """Symbol."""
 
@@ -236,7 +242,7 @@ class Symbol:
         self,
         defn: NameAtom,
         access: SymbolAccess,
-        parent_tab: UniScopeNode,
+        parent_tab: Optional[UniScopeNode] = None,
         imported: bool = False,
     ) -> None:
         """Initialize."""
@@ -277,7 +283,9 @@ class Symbol:
     @property
     def symbol_table(self) -> Optional[UniScopeNode]:
         """Get symbol table."""
-        return self.parent_tab.find_scope(self.sym_name)
+        if self.parent_tab:
+            return self.parent_tab.find_scope(self.sym_name)
+        return None
 
     def add_defn(self, node: NameAtom) -> None:
         """Add defn."""
@@ -345,8 +353,7 @@ class UniScopeNode(UniNode):
             else None
         )
         if force_overwrite or node.sym_name not in self.names_in_scope:
-            self.names_in_scope[node.sym_name] = Symbol(
-                defn=node.name_spec,
+            self.names_in_scope[node.sym_name] = node.name_spec.create_symbol(
                 access=(
                     access_spec
                     if isinstance(access_spec, SymbolAccess)
@@ -570,6 +577,13 @@ class AstAccessNode(UniNode):
 T = TypeVar("T", bound=UniNode)
 
 
+class ClientFacingNode:
+    """Mixin for nodes that can be marked as client-facing declarations."""
+
+    def __init__(self, is_client_decl: bool = False) -> None:
+        self.is_client_decl = is_client_decl
+
+
 class AstDocNode(UniNode):
     """Nodes that have access."""
 
@@ -767,6 +781,16 @@ class NameAtom(AtomExpr, EnumBlockStmt):
     def sym_category(self) -> SymbolType:
         return self._sym_category
 
+    def create_symbol(
+        self,
+        access: SymbolAccess,
+        parent_tab: Optional[UniScopeNode] = None,
+        imported: bool = False,
+    ) -> Symbol:
+        """Create symbol."""
+        sym = Symbol(defn=self, access=access, parent_tab=parent_tab, imported=imported)
+        return sym
+
     @property
     def clean_type(self) -> str:
         ret_type = self.expr_type.replace("builtins.", "").replace("NoType", "")
@@ -890,6 +914,7 @@ class Module(AstDocNode, UniScopeNode):
         if not self.stub_only and (
             self.loc.mod_path.endswith(".impl.jac")
             or self.loc.mod_path.endswith(".test.jac")
+            or self.loc.mod_path.endswith(".cl.jac")
         ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
@@ -899,7 +924,11 @@ class Module(AstDocNode, UniScopeNode):
             if os.path.exists(potential_path) and potential_path != self.loc.mod_path:
                 return potential_path
             annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
-            if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
+            if (
+                annex_dir.endswith(".impl")
+                or annex_dir.endswith(".test")
+                or annex_dir.endswith(".cl")
+            ):
                 head_mod_name = os.path.split(os.path.dirname(self.loc.mod_path))[
                     -1
                 ].split(".")[0]
@@ -987,7 +1016,7 @@ class ProgramModule(UniNode):
         self.hub: dict[str, Module] = {self.loc.mod_path: main_mod} if main_mod else {}
 
 
-class GlobalVars(ElementStmt, AstAccessNode):
+class GlobalVars(ClientFacingNode, ElementStmt, AstAccessNode):
     """GlobalVars node type for Jac Ast."""
 
     def __init__(
@@ -1003,6 +1032,7 @@ class GlobalVars(ElementStmt, AstAccessNode):
         UniNode.__init__(self, kid=kid)
         AstAccessNode.__init__(self, access=access)
         AstDocNode.__init__(self, doc=doc)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1014,6 +1044,8 @@ class GlobalVars(ElementStmt, AstAccessNode):
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.is_frozen:
             new_kid.append(self.gen_token(Tok.KW_LET))
         else:
@@ -1028,7 +1060,7 @@ class GlobalVars(ElementStmt, AstAccessNode):
         return res
 
 
-class Test(AstSymbolNode, ElementStmt, UniScopeNode):
+class Test(ClientFacingNode, AstSymbolNode, ElementStmt, UniScopeNode):
     """Test node type for Jac Ast."""
 
     TEST_COUNT = 0
@@ -1074,6 +1106,7 @@ class Test(AstSymbolNode, ElementStmt, UniScopeNode):
         )
         AstDocNode.__init__(self, doc=doc)
         UniScopeNode.__init__(self, name=self.sym_name)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1085,6 +1118,8 @@ class Test(AstSymbolNode, ElementStmt, UniScopeNode):
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_TEST))
         new_kid.append(self.name)
         new_kid.append(self.gen_token(Tok.LBRACE))
@@ -1095,7 +1130,7 @@ class Test(AstSymbolNode, ElementStmt, UniScopeNode):
         return res
 
 
-class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
+class ModuleCode(ClientFacingNode, ElementStmt, ArchBlockStmt, EnumBlockStmt):
     """ModuleCode node type for Jac Ast."""
 
     def __init__(
@@ -1111,6 +1146,7 @@ class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
         UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
         EnumBlockStmt.__init__(self, is_enum_stmt=is_enum_stmt)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1122,6 +1158,8 @@ class ModuleCode(ElementStmt, ArchBlockStmt, EnumBlockStmt):
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_WITH))
         new_kid.append(self.gen_token(Tok.KW_ENTRY))
         if self.name:
@@ -1164,7 +1202,7 @@ class PyInlineCode(ElementStmt, ArchBlockStmt, EnumBlockStmt, CodeBlockStmt):
         return res
 
 
-class Import(ElementStmt, CodeBlockStmt):
+class Import(ClientFacingNode, ElementStmt, CodeBlockStmt):
     """Import node type for Jac Ast."""
 
     def __init__(
@@ -1182,6 +1220,7 @@ class Import(ElementStmt, CodeBlockStmt):
         UniNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
     @property
     def is_py(self) -> bool:
@@ -1235,6 +1274,8 @@ class Import(ElementStmt, CodeBlockStmt):
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.is_absorb:
             new_kid.append(self.gen_token(Tok.KW_INCLUDE))
         else:
@@ -1255,7 +1296,7 @@ class Import(ElementStmt, CodeBlockStmt):
         return res
 
 
-class ModulePath(AstSymbolNode):
+class ModulePath(UniNode):
     """ModulePath node type for Jac Ast."""
 
     def __init__(
@@ -1269,33 +1310,36 @@ class ModulePath(AstSymbolNode):
         self.level = level
         self.alias = alias
         self.abs_path: Optional[str] = None
-
-        name_spec = alias if alias else path[0] if path else None
-
         UniNode.__init__(self, kid=kid)
-        if not name_spec:
-            pkg_name = self.loc.mod_path
-            for _ in range(self.level):
-                pkg_name = os.path.dirname(pkg_name)
-            pkg_name = pkg_name.split(os.sep)[-1]
-            name_spec = Name.gen_stub_from_node(self, pkg_name)
-            self.level += 1
-        if not isinstance(name_spec, Name):
-            raise ValueError("ModulePath should have a name spec. Impossible.")
-        AstSymbolNode.__init__(
-            self,
-            sym_name=name_spec.sym_name,
-            name_spec=name_spec,
-            sym_category=SymbolType.MODULE,
-        )
+
+    @property
+    def is_import_from(self) -> bool:
+        """Check if this modulepath is from import."""
+        if self.parent and isinstance(self.parent, Import):
+            return self.parent.from_loc == self
+        return False
 
     @property
     def dot_path_str(self) -> str:
         """Get path string."""
         return ("." * self.level) + ".".join(
-            [p.value for p in self.path] if self.path else [self.name_spec.sym_name]
+            [p.value for p in self.path] if self.path else []
         )
 
+    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
+        """Convert an import target string into a relative file path."""
+        target = self.dot_path_str + (f".{target_item}" if target_item else "")
+        return resolve_relative_path(target, self.loc.mod_path)
+
+    def resolve_relative_path_list(self) -> list[str]:
+        """Convert an import target string into a relative file path."""
+        parts = self.dot_path_str.split(".")
+        paths = []
+        for i in range(len(parts)):
+            sub_path = ".".join(parts[: i + 1])
+            paths.append(resolve_relative_path(sub_path, self.loc.mod_path))
+        return paths
+
     def normalize(self, deep: bool = False) -> bool:
         res = True
         if deep:
@@ -1317,13 +1361,8 @@ class ModulePath(AstSymbolNode):
         self.set_kids(nodes=new_kid)
         return res
 
-    def resolve_relative_path(self, target_item: Optional[str] = None) -> str:
-        """Convert an import target string into a relative file path."""
-        target = self.dot_path_str + (f".{target_item}" if target_item else "")
-        return resolve_relative_path(target, self.loc.mod_path)
-
 
-class ModuleItem(AstSymbolNode):
+class ModuleItem(UniNode):
     """ModuleItem node type for Jac Ast."""
 
     def __init__(
@@ -1335,12 +1374,6 @@ class ModuleItem(AstSymbolNode):
         self.name = name
         self.alias = alias
         UniNode.__init__(self, kid=kid)
-        AstSymbolNode.__init__(
-            self,
-            sym_name=alias.sym_name if alias else name.sym_name,
-            name_spec=alias or name,
-            sym_category=SymbolType.MOD_VAR,
-        )
         self.abs_path: Optional[str] = None
 
     @property
@@ -1371,6 +1404,7 @@ class ModuleItem(AstSymbolNode):
 
 
 class Archetype(
+    ClientFacingNode,
     ArchSpec,
     AstAccessNode,
     ArchBlockStmt,
@@ -1412,10 +1446,10 @@ class Archetype(
         ArchSpec.__init__(self, decorators=decorators)
         UniScopeNode.__init__(self, name=self.sym_name)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
-    @property
-    def is_abstract(self) -> bool:
-        body = (
+    def _get_impl_resolved_body(self) -> list:
+        return (
             list(self.body)
             if isinstance(self.body, Sequence)
             else (
@@ -1425,8 +1459,23 @@ class Archetype(
                 else []
             )
         )
+
+    @property
+    def is_abstract(self) -> bool:
+        body = self._get_impl_resolved_body()
         return any(isinstance(i, Ability) and i.is_abstract for i in body)
 
+    def get_has_vars(self) -> list[HasVar]:
+        body = self._get_impl_resolved_body()
+        has_vars: list[HasVar] = []
+        for node in body:
+            if not isinstance(node, ArchHas):
+                continue
+            for has_ in node.vars:
+                if isinstance(has_, HasVar):
+                    has_vars.append(has_)
+        return has_vars
+
     def normalize(self, deep: bool = False) -> bool:
         res = True
         if deep:
@@ -1448,6 +1497,8 @@ class Archetype(
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             for idx, dec in enumerate(self.decorators):
@@ -1639,7 +1690,14 @@ class SemDef(ElementStmt, AstSymbolNode, UniScopeNode):
         return res
 
 
-class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeNode):
+class Enum(
+    ClientFacingNode,
+    ArchSpec,
+    AstAccessNode,
+    AstImplNeedingNode,
+    ArchBlockStmt,
+    UniScopeNode,
+):
     """Enum node type for Jac Ast."""
 
     def __init__(
@@ -1666,6 +1724,7 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeN
         AstDocNode.__init__(self, doc=doc)
         ArchSpec.__init__(self, decorators=decorators)
         UniScopeNode.__init__(self, name=self.sym_name)
+        ClientFacingNode.__init__(self)
 
     def normalize(self, deep: bool = False) -> bool:
         res = True
@@ -1693,6 +1752,8 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeN
                     new_kid.append(self.gen_token(Tok.DECOR_OP))
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         new_kid.append(self.gen_token(Tok.KW_ENUM))
         if self.access:
             new_kid.append(self.access)
@@ -1723,6 +1784,7 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt, UniScopeN
 
 
 class Ability(
+    ClientFacingNode,
     AstAccessNode,
     ElementStmt,
     AstAsyncNode,
@@ -1735,7 +1797,7 @@ class Ability(
 
     def __init__(
         self,
-        name_ref: NameAtom,
+        name_ref: Optional[NameAtom],
         is_async: bool,
         is_override: bool,
         is_static: bool,
@@ -1756,10 +1818,36 @@ class Ability(
 
         UniNode.__init__(self, kid=kid)
         AstImplNeedingNode.__init__(self, body=body)
+
+        # Create a synthetic name_ref if none provided
+        if name_ref is None:
+            # Extract location info from kid for positioning
+            # Note: kid should always contain at least KW_CAN token from parser
+            first_tok = kid[0] if kid and isinstance(kid[0], Token) else None
+            if first_tok is None:
+                raise ValueError(
+                    "Cannot create synthetic name_ref without location info."
+                )
+            synthetic_name_ref = Name(
+                orig_src=first_tok.orig_src,
+                name=Tok.NAME,
+                value=self.py_resolve_name(),
+                line=first_tok.line_no,
+                end_line=first_tok.end_line,
+                col_start=first_tok.c_start,
+                col_end=first_tok.c_end,
+                pos_start=first_tok.pos_start,
+                pos_end=first_tok.pos_end,
+                is_enum_stmt=False,
+            )
+            name_spec_for_init: Name | NameAtom = synthetic_name_ref
+        else:
+            name_spec_for_init = name_ref
+
         AstSymbolNode.__init__(
             self,
             sym_name=self.py_resolve_name(),
-            name_spec=name_ref,
+            name_spec=name_spec_for_init,
             sym_category=SymbolType.ABILITY,
         )
         AstAccessNode.__init__(self, access=access)
@@ -1767,6 +1855,7 @@ class Ability(
         AstAsyncNode.__init__(self, is_async=is_async)
         UniScopeNode.__init__(self, name=self.sym_name)
         CodeBlockStmt.__init__(self)
+        ClientFacingNode.__init__(self)
 
     @property
     def is_method(self) -> bool:
@@ -1812,7 +1901,18 @@ class Ability(
         return mn, mx
 
     def py_resolve_name(self) -> str:
-        if isinstance(self.name_ref, Name):
+        if self.name_ref is None:
+            # Generate anonymous name based on event type and location
+            event_type = (
+                "entry"
+                if isinstance(self.signature, EventSignature)
+                and self.signature.event.name == Tok.KW_ENTRY
+                else "exit"
+            )
+            return (
+                f"__ability_{event_type}_{self.loc.first_line}_{self.loc.col_start}__"
+            )
+        elif isinstance(self.name_ref, Name):
             return self.name_ref.value
         elif isinstance(self.name_ref, SpecialVarRef):
             return self.name_ref.py_resolve_name()
@@ -1822,7 +1922,7 @@ class Ability(
     def normalize(self, deep: bool = False) -> bool:
         res = True
         if deep:
-            res = self.name_ref.normalize(deep)
+            res = self.name_ref.normalize(deep) if self.name_ref else res
             res = res and self.access.normalize(deep) if self.access else res
             res = res and self.signature.normalize(deep) if self.signature else res
             if isinstance(self.body, ImplDef):
@@ -1838,6 +1938,8 @@ class Ability(
         new_kid: list[UniNode] = []
         if self.doc:
             new_kid.append(self.doc)
+        if self.is_client_decl:
+            new_kid.append(self.gen_token(Tok.KW_CLIENT))
         if self.decorators:
             new_kid.append(self.gen_token(Tok.DECOR_OP))
             for idx, dec in enumerate(self.decorators):
@@ -1858,7 +1960,8 @@ class Ability(
         )
         if self.access:
             new_kid.append(self.access)
-        new_kid.append(self.name_ref)
+        if self.name_ref:
+            new_kid.append(self.name_ref)
         if self.signature:
             new_kid.append(self.signature)
         if self.is_genai_ability:
@@ -1940,6 +2043,8 @@ class FuncSignature(UniNode):
             new_kid = new_kid[:-1]
         if not is_lambda:
             new_kid.append(self.gen_token(Tok.RPAREN))
+        elif not new_kid:
+            new_kid.extend([self.gen_token(Tok.LPAREN), self.gen_token(Tok.RPAREN)])
         if self.return_type:
             new_kid.append(self.gen_token(Tok.RETURN_HINT))
             new_kid.append(self.return_type)
@@ -2960,6 +3065,8 @@ class Assignment(AstTypedVarNode, EnumBlockStmt, CodeBlockStmt):
             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[UniNode] = []
+        if self.mutable and not self.is_enum_stmt:
+            new_kid.append(self.gen_token(Tok.KW_LET))
         for idx, targ in enumerate(self.target):
             new_kid.append(targ)
             if idx < len(self.target) - 1:
@@ -3106,12 +3213,15 @@ class LambdaExpr(Expr, UniScopeNode):
 
     def __init__(
         self,
-        body: Expr,
+        body: Union[Expr, Sequence[CodeBlockStmt]],
         kid: Sequence[UniNode],
         signature: Optional[FuncSignature] = None,
     ) -> None:
         self.signature = signature
-        self.body = body
+        if isinstance(body, Sequence) and not isinstance(body, Expr):
+            self.body: Expr | Sequence[CodeBlockStmt] = list(body)
+        else:
+            self.body = cast(Expr, body)
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         UniScopeNode.__init__(self, name=f"{self.__class__.__name__}")
@@ -3120,11 +3230,21 @@ class LambdaExpr(Expr, UniScopeNode):
         res = True
         if deep:
             res = self.signature.normalize(deep) if self.signature else res
-            res = res and self.body.normalize(deep)
+            if isinstance(self.body, list):
+                for stmt in self.body:
+                    res = res and stmt.normalize(deep)
+            elif isinstance(self.body, Expr):
+                res = res and self.body.normalize(deep)
         new_kid: list[UniNode] = [self.gen_token(Tok.KW_LAMBDA)]
         if self.signature:
             new_kid.append(self.signature)
-        new_kid += [self.gen_token(Tok.COLON), self.body]
+        # For code block lambdas, we add LBRACE, statements, RBRACE
+        if isinstance(self.body, list):
+            new_kid.append(self.gen_token(Tok.LBRACE))
+            new_kid.extend(self.body)
+            new_kid.append(self.gen_token(Tok.RBRACE))
+        elif isinstance(self.body, Expr):
+            new_kid += [self.gen_token(Tok.COLON), self.body]
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3216,10 +3336,14 @@ class FString(AtomExpr):
 
     def __init__(
         self,
-        parts: Sequence[String | ExprStmt],
+        start: Optional[Token],
+        parts: Sequence[String | FormattedValue],
+        end: Optional[Token],
         kid: Sequence[UniNode],
     ) -> None:
-        self.parts: list[String | ExprStmt] = list(parts)
+        self.start = start
+        self.parts: list[String | FormattedValue] = list(parts)
+        self.end = end
         UniNode.__init__(self, kid=kid)
         Expr.__init__(self)
         AstSymbolStubNode.__init__(self, sym_type=SymbolType.STRING)
@@ -3229,33 +3353,53 @@ class FString(AtomExpr):
         if deep:
             for part in self.parts:
                 res = res and part.normalize(deep)
-        new_kid: list[UniNode] = []
-        # Determine quote type from first token
-        start_token = self.kid[0] if isinstance(self.kid[0], Token) else None
-        if start_token:
-            if start_token.name == Tok.FSTR_SQ_TRIPLE_START:
-                start_tok, end_tok = Tok.FSTR_SQ_TRIPLE_START, Tok.FSTR_SQ_TRIPLE_END
-            elif start_token.name == Tok.FSTR_TRIPLE_START:
-                start_tok, end_tok = Tok.FSTR_TRIPLE_START, Tok.FSTR_TRIPLE_END
-            elif start_token.name == Tok.FSTR_SQ_START:
-                start_tok, end_tok = Tok.FSTR_SQ_START, Tok.FSTR_SQ_END
-            else:
-                start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
-        else:
-            start_tok, end_tok = Tok.FSTR_START, Tok.FSTR_END
+        new_kid: list[UniNode] = (
+            [self.gen_token(self.start)] if self.start is not None else []
+        )
+        for part in self.parts:
+            new_kid.append(part)
+        if self.end is not None:
+            new_kid.append(self.gen_token(self.end))
+        self.set_kids(nodes=new_kid)
+        return res
 
-        new_kid.append(self.gen_token(start_tok))
-        for i in self.parts:
-            if isinstance(i, String):
-                i.value = (
-                    "{{" if i.value == "{" else "}}" if i.value == "}" else i.value
-                )
-                new_kid.append(i)
-            else:
-                new_kid.append(self.gen_token(Tok.LBRACE))
-                new_kid.append(i)
-                new_kid.append(self.gen_token(Tok.RBRACE))
-        new_kid.append(self.gen_token(end_tok))
+    def unparse(self) -> str:
+        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 FormattedValue(Expr):
+    """FormattedValue node type for Jac Ast."""
+
+    def __init__(
+        self,
+        format_part: Expr,
+        conversion: int,
+        format_spec: Expr | None,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.format_part: Expr = format_part
+        self.conversion: int = conversion
+        self.format_spec: Expr | None = format_spec
+        UniNode.__init__(self, kid=kid)
+        Expr.__init__(self)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.format_part.normalize(deep)
+            res = res and self.format_spec.normalize(deep) if self.format_spec else res
+        new_kid: list[UniNode] = [self.gen_token(Tok.LBRACE)]
+        new_kid.append(self.format_part)
+        if self.conversion != -1:
+            new_kid.append(self.gen_token(Tok.CONV, value="!" + chr(self.conversion)))
+        if self.format_spec:
+            new_kid.append(self.gen_token(Tok.COLON))
+            new_kid.append(self.format_spec)
+        new_kid.append(self.gen_token(Tok.RBRACE))
         self.set_kids(nodes=new_kid)
         return res
 
@@ -3649,7 +3793,7 @@ class AtomUnit(Expr):
 
     def __init__(
         self,
-        value: Expr | YieldExpr,
+        value: Expr | YieldExpr | Ability,
         kid: Sequence[UniNode],
     ) -> None:
         self.value = value
@@ -4050,6 +4194,206 @@ class AssignCompr(AtomExpr):
         return res
 
 
+# JSX Nodes
+# ---------
+
+
+class JsxElement(AtomExpr):
+    """JsxElement node type for Jac Ast."""
+
+    def __init__(
+        self,
+        name: Optional["JsxElementName"],
+        attributes: Optional[Sequence["JsxAttribute"]],
+        children: Optional[Sequence["JsxChild"]],
+        is_self_closing: bool,
+        is_fragment: bool,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.name = name
+        self.attributes = list(attributes) if attributes else []
+        self.children = list(children) if children else []
+        self.is_self_closing = is_self_closing
+        self.is_fragment = is_fragment
+        UniNode.__init__(self, kid=kid)
+        Expr.__init__(self)
+        AstSymbolStubNode.__init__(self, sym_type=SymbolType.OBJECT_ARCH)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize JSX element by recursively normalizing children.
+
+        Unlike most normalize methods, JSX elements don't need to rebuild
+        their kid structure since the parser already creates it correctly.
+        We just need to normalize child nodes if deep=True.
+        """
+        res = True
+        if deep:
+            if self.name:
+                res = res and self.name.normalize(deep)
+            if self.attributes:
+                for attr in self.attributes:
+                    res = res and attr.normalize(deep)
+            if self.children:
+                for child in self.children:
+                    res = res and child.normalize(deep)
+        return res
+
+
+class JsxElementName(UniNode):
+    """JsxElementName node type for Jac Ast."""
+
+    def __init__(
+        self,
+        parts: Sequence[Name],
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.parts = list(parts)
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            for part in self.parts:
+                res = res and part.normalize(deep)
+        new_kid: list[UniNode] = []
+        for i, part in enumerate(self.parts):
+            new_kid.append(part)
+            if i < len(self.parts) - 1:
+                new_kid.append(self.gen_token(Tok.DOT))
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxAttribute(UniNode):
+    """JsxAttribute node type for Jac Ast (base class)."""
+
+    def __init__(self, kid: Sequence[UniNode]) -> None:
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize the node (base implementation)."""
+        # Base class normalize - subclasses should override if needed
+        return True
+
+
+class JsxSpreadAttribute(JsxAttribute):
+    """JsxSpreadAttribute node type for Jac Ast."""
+
+    def __init__(
+        self,
+        expr: Expr,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.expr = expr
+        JsxAttribute.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[UniNode] = [
+            self.gen_token(Tok.LBRACE),
+            self.gen_token(Tok.ELLIPSIS),
+            self.expr,
+            self.gen_token(Tok.RBRACE),
+        ]
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxNormalAttribute(JsxAttribute):
+    """JsxNormalAttribute node type for Jac Ast."""
+
+    def __init__(
+        self,
+        name: Name,
+        value: Optional[Union[String, Expr]],
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.name = name
+        self.value = value
+        JsxAttribute.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.name.normalize(deep)
+            if self.value:
+                res = res and self.value.normalize(deep)
+        new_kid: list[UniNode] = [self.name]
+        if self.value:
+            new_kid.append(self.gen_token(Tok.EQ))
+            if isinstance(self.value, String):
+                new_kid.append(self.value)
+            else:  # Expression in braces
+                new_kid.extend(
+                    [
+                        self.gen_token(Tok.LBRACE),
+                        self.value,
+                        self.gen_token(Tok.RBRACE),
+                    ]
+                )
+        self.set_kids(nodes=new_kid)
+        return res
+
+
+class JsxChild(UniNode):
+    """JsxChild node type for Jac Ast (base class)."""
+
+    def __init__(self, kid: Sequence[UniNode]) -> None:
+        UniNode.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        """Normalize the node (base implementation)."""
+        # Base class normalize - subclasses should override if needed
+        return True
+
+
+class JsxText(JsxChild):
+    """JsxText node type for Jac Ast."""
+
+    def __init__(
+        self,
+        value: str,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.value = value
+        JsxChild.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        # JSX text is represented as a token
+        if isinstance(self.value, Token):
+            new_kid: list[UniNode] = [self.value]
+        else:
+            new_kid = [self.gen_token(Tok.JSX_TEXT, value=str(self.value))]
+        self.set_kids(nodes=new_kid)
+        return True
+
+
+class JsxExpression(JsxChild):
+    """JsxExpression node type for Jac Ast."""
+
+    def __init__(
+        self,
+        expr: Expr,
+        kid: Sequence[UniNode],
+    ) -> None:
+        self.expr = expr
+        JsxChild.__init__(self, kid=kid)
+
+    def normalize(self, deep: bool = False) -> bool:
+        res = True
+        if deep:
+            res = self.expr.normalize(deep)
+        new_kid: list[UniNode] = [
+            self.gen_token(Tok.LBRACE),
+            self.expr,
+            self.gen_token(Tok.RBRACE),
+        ]
+        self.set_kids(nodes=new_kid)
+        return res
+
+
 # Match Nodes
 # ------------
 
@@ -4656,6 +5000,8 @@ class String(Literal):
 
     def unparse(self) -> str:
         super().unparse()
+        if self.parent and isinstance(self.parent, FString):
+            return self.lit_value
         return self.value