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

jaclang/compiler/passes/tool/doc_ir_gen_pass.py

@@ -135,20 +135,53 @@ class DocIRGenPass(UniPass):
     def exit_import(self, node: uni.Import) -> None:
         """Exit import node."""
         parts: list[doc.DocType] = []
+        mod_items: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
+        is_in_items: bool = False
         for i in node.kid:
             if isinstance(i, uni.Token) and i.name == Tok.COMMA:
-                parts.pop()
-                parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+                if is_in_items:
+                    mod_items.pop()
+                    mod_items.append(i.gen.doc_ir)
+                    mod_items.append(self.line())
+                else:
+                    parts.pop()
+                    parts.append(i.gen.doc_ir)
+                    parts.append(self.line())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(i, uni.Token) and i.name == Tok.SEMI:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
             elif isinstance(i, uni.Token) and i.name == Tok.RBRACE:
+                is_in_items = False
+                mod_items.pop()
+                parts.append(
+                    self.group(
+                        self.concat(
+                            [
+                                self.indent(self.concat([self.line(), *mod_items])),
+                                self.line(),
+                            ]
+                        )
+                    )
+                )
                 parts.append(i.gen.doc_ir)
-            else:
+            elif isinstance(i, uni.Token) and i.name == Tok.LBRACE:
+                is_in_items = True
                 parts.append(i.gen.doc_ir)
-                parts.append(self.space())
+            else:
+                if is_in_items:
+                    mod_items.append(i.gen.doc_ir)
+                    mod_items.append(self.space())
+                else:
+                    parts.append(i.gen.doc_ir)
+                    parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_module_item(self, node: uni.ModuleItem) -> None:
         """Generate DocIR for module items."""
@@ -178,6 +211,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for archetypes."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         prev_item = None
         in_body = False
         for i in node.kid:
@@ -198,6 +232,10 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(node.body, Sequence) and i in node.body:
                 if not in_body:
                     body_parts.append(self.hard_line())
@@ -225,13 +263,15 @@ class DocIRGenPass(UniPass):
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
-
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_ability(self, node: uni.Ability) -> None:
         """Generate DocIR for abilities."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if i == node.doc or (node.decorators and i in node.decorators):
@@ -259,12 +299,18 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif not in_body and isinstance(i, uni.Token) and i.name == Tok.DECOR_OP:
                 parts.append(i.gen.doc_ir)
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_func_signature(self, node: uni.FuncSignature) -> None:
         """Generate DocIR for function signatures."""
@@ -401,7 +447,7 @@ class DocIRGenPass(UniPass):
                         ]
                     )
                 )
-                parts.append(self.if_break(broken, flat))
+                parts.append(self.group(self.if_break(broken, flat)))
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
@@ -846,6 +892,13 @@ class DocIRGenPass(UniPass):
             parts.append(i.gen.doc_ir)
         node.gen.doc_ir = self.group(self.concat(parts))
 
+    def exit_formatted_value(self, node: uni.FormattedValue) -> None:
+        """Generate DocIR for formatted value expressions."""
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.group(self.concat(parts))
+
     def exit_if_else_expr(self, node: uni.IfElseExpr) -> None:
         """Generate DocIR for conditional expressions."""
         parts: list[doc.DocType] = []
@@ -901,16 +954,16 @@ class DocIRGenPass(UniPass):
                 return [expr]
 
         exprs = __flatten_bool_expr(node)
-        for i in range(0, len(exprs) - 1, 2):
+        parts += [exprs[0].gen.doc_ir, self.line()]
+        for i in range(1, len(exprs), 2):
             (
-                expr,
                 op,
+                expr,
             ) = (
-                exprs[i],
                 exprs[i + 1],
+                exprs[i],
             )
             parts += [expr.gen.doc_ir, self.space(), op.gen.doc_ir, self.line()]
-        parts += [exprs[-1].gen.doc_ir, self.line()]
         parts.pop()
         flat = self.concat(parts)
         node.gen.doc_ir = self.group(flat)
@@ -1108,6 +1161,8 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for assert statements."""
         parts: list[doc.DocType] = []
         for i in node.kid:
+            if isinstance(i, uni.Token) and i.name == Tok.SEMI and len(parts):
+                parts.pop()
             parts.append(i.gen.doc_ir)
             parts.append(self.space())
         parts.pop()
@@ -1125,6 +1180,7 @@ class DocIRGenPass(UniPass):
     def exit_global_vars(self, node: uni.GlobalVars) -> None:
         """Generate DocIR for global variables."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1133,15 +1189,22 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_module_code(self, node: uni.ModuleCode) -> None:
         """Generate DocIR for module code."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if node.doc and i is node.doc:
@@ -1153,6 +1216,10 @@ class DocIRGenPass(UniPass):
             elif isinstance(i, uni.Token) and i.name == Tok.COLON:
                 parts.pop()
                 parts.append(i.gen.doc_ir)
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif isinstance(node.body, Sequence) and i in node.body:
                 if not in_body:
                     parts.pop()
@@ -1175,6 +1242,8 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_global_stmt(self, node: uni.GlobalStmt) -> None:
         """Generate DocIR for global statements."""
@@ -1264,7 +1333,9 @@ class DocIRGenPass(UniPass):
                 ]
             )
         )
-        if isinstance(node.parent, uni.Assignment):
+        if isinstance(node.parent, (uni.Assignment)) or (
+            isinstance(node.parent, uni.IfStmt) and isinstance(node.value, uni.BoolExpr)
+        ):
             node.gen.doc_ir = self.if_break(
                 flat_contents=self.group(self.concat(parts[1:-1])),
                 break_contents=broken,
@@ -1300,6 +1371,7 @@ class DocIRGenPass(UniPass):
     def exit_py_inline_code(self, node: uni.PyInlineCode) -> None:
         """Generate DocIR for Python inline code blocks."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1309,14 +1381,21 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.text("::py::"))
                 parts.append(self.hard_line())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_test(self, node: uni.Test) -> None:
         """Generate DocIR for test nodes."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i == node.doc:
                 parts.append(i.gen.doc_ir)
@@ -1325,10 +1404,16 @@ class DocIRGenPass(UniPass):
                 if not i.value.startswith("_jac_gen_"):
                     parts.append(i.gen.doc_ir)
                     parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_match_stmt(self, node: uni.MatchStmt) -> None:
         """Generate DocIR for match statements."""
@@ -1512,6 +1597,7 @@ class DocIRGenPass(UniPass):
         """Generate DocIR for implementation definitions."""
         parts: list[doc.DocType] = []
         body_parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         in_body = False
         for i in node.kid:
             if i == node.doc or (node.decorators and i in node.decorators):
@@ -1519,6 +1605,10 @@ class DocIRGenPass(UniPass):
                 parts.append(self.hard_line())
             elif self.is_within(i, node.target):
                 parts.append(i.gen.doc_ir)
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             elif (
                 in_body
                 or isinstance(node.body, Sequence)
@@ -1546,10 +1636,13 @@ class DocIRGenPass(UniPass):
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_sem_def(self, node: uni.SemDef) -> None:
         """Generate DocIR for semantic definitions."""
         parts: list[doc.DocType] = []
+        has_comment: Optional[doc.DocType] = None
         for i in node.kid:
             if i in node.target:
                 parts.append(i.gen.doc_ir)
@@ -1557,10 +1650,16 @@ class DocIRGenPass(UniPass):
                 parts.pop()
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
+            elif (
+                i == node.kid[0] and isinstance(i, uni.Token) and i.name == Tok.COMMENT
+            ):
+                has_comment = i.gen.doc_ir
             else:
                 parts.append(i.gen.doc_ir)
                 parts.append(self.space())
         node.gen.doc_ir = self.group(self.concat(parts))
+        if has_comment:
+            node.gen.doc_ir = self.concat([has_comment, node.gen.doc_ir])
 
     def exit_event_signature(self, node: uni.EventSignature) -> None:
         """Generate DocIR for event signatures."""
@@ -1614,14 +1713,6 @@ class DocIRGenPass(UniPass):
             and isinstance(node.parent, uni.FString)
         )
 
-        if "\n" in node.value:
-            lines = node.value.split("\n")
-            parts: list[doc.DocType] = [self.text(lines[0])]
-            for line in lines[1:]:
-                parts.append(self.hard_line())
-                parts.append(self.text(line.lstrip()))
-            node.gen.doc_ir = self.group(self.concat(parts))
-            return
         if is_escaped_curly:
             node.gen.doc_ir = self.concat(
                 [self.text(node.value), self.text(node.value)]
@@ -1663,3 +1754,111 @@ class DocIRGenPass(UniPass):
             node.gen.doc_ir = self.group(
                 self.concat([self.text(node.value), self.hard_line()])
             )
+
+    def exit_jsx_element(self, node: uni.JsxElement) -> None:
+        """Generate DocIR for JSX elements - kid-centric beautiful formatting!"""
+        parts: list[doc.DocType] = []
+        prev = None
+
+        # Check if we have any JSX element children
+        # Use node.children instead of node.kid to avoid counting opening/closing tags
+        has_jsx_elem_children = any(
+            isinstance(k, uni.JsxElement) for k in node.children
+        )
+
+        # Only break/indent if we have JSX element children
+        # (simple text/expression children stay inline)
+        should_format_children = has_jsx_elem_children
+
+        for i in node.kid:
+            # Add line break between attributes (allows them to wrap nicely)
+            if (
+                prev
+                and isinstance(prev, (uni.JsxElementName, uni.JsxAttribute))
+                and isinstance(i, uni.JsxAttribute)
+            ):
+                parts.append(self.line())
+            # Add hard line between JSX element children, or before first child
+            elif (
+                prev
+                and (
+                    (
+                        isinstance(prev, (uni.JsxChild, uni.JsxElement))
+                        and isinstance(i, (uni.JsxChild, uni.JsxElement))
+                    )
+                    or (
+                        isinstance(prev, (uni.JsxElementName, uni.JsxAttribute))
+                        and isinstance(i, (uni.JsxChild, uni.JsxElement))
+                    )
+                )
+                and should_format_children
+            ):
+                parts.append(self.hard_line())
+
+            # Indent JSX element children, but not text/expression children
+            if isinstance(i, uni.JsxElement) and should_format_children:
+                parts.append(self.indent(i.gen.doc_ir))
+            else:
+                parts.append(i.gen.doc_ir)
+
+            prev = i
+
+        node.gen.doc_ir = self.group(self.concat(parts))
+
+    def exit_jsx_element_name(self, node: uni.JsxElementName) -> None:
+        """Generate DocIR for JSX element names."""
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_spread_attribute(self, node: uni.JsxSpreadAttribute) -> None:
+        """Generate DocIR for JSX spread attributes."""
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_normal_attribute(self, node: uni.JsxNormalAttribute) -> None:
+        """Generate DocIR for JSX normal attributes."""
+        # Normalize to ensure LBRACE/RBRACE tokens are added for expression values
+        node.normalize()
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            # Tokens created by normalize() have empty doc_ir, so regenerate it
+            if (
+                isinstance(i, uni.Token)
+                and isinstance(i.gen.doc_ir, doc.Text)
+                and not i.gen.doc_ir.text
+            ):
+                i.gen.doc_ir = self.text(i.value)
+            elif not isinstance(
+                i.gen.doc_ir,
+                (
+                    doc.Text,
+                    doc.Concat,
+                    doc.Group,
+                    doc.Indent,
+                    doc.Line,
+                    doc.Align,
+                    doc.IfBreak,
+                ),
+            ):
+                # For nodes with invalid doc_ir, generate it by visiting
+                self.enter_exit(i)
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_text(self, node: uni.JsxText) -> None:
+        """Generate DocIR for JSX text."""
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.concat(parts)
+
+    def exit_jsx_expression(self, node: uni.JsxExpression) -> None:
+        """Generate DocIR for JSX expressions."""
+        parts: list[doc.DocType] = []
+        for i in node.kid:
+            parts.append(i.gen.doc_ir)
+        node.gen.doc_ir = self.concat(parts)

jaclang/compiler/passes/tool/fuse_comments_pass.py

@@ -41,19 +41,9 @@ class FuseCommentsPass(UniPass):
         except StopIteration:
             next_comment = None
 
-        # Handle possible leading comments
-        if next_comment and (not next_code or _is_before(next_comment, next_code)):
-            self.ir_out.src_terminals.insert(0, next_comment)
-
         # Merge streams in order
         while next_comment or next_code:
             if next_comment and (not next_code or _is_before(next_comment, next_code)):
-                # Add comment token
-                if merged and (last_token := merged[-1]):
-                    self.ir_out.src_terminals.insert(
-                        self.ir_out.src_terminals.index(last_token) + 1,
-                        next_comment,
-                    )
                 merged.append(next_comment)
                 try:
                     next_comment = next(comments)
@@ -66,6 +56,7 @@ class FuseCommentsPass(UniPass):
                     next_code = next(code_tokens)
                 except StopIteration:
                     next_code = None
+        self.ir_out.src_terminals[:] = merged
 
         return merged
 

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -51,7 +51,7 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
 
             if isinstance(cur, doc.Text):
                 remaining -= len(cur.text)
-                if remaining < 0:
+                if remaining <= 0:
                     return False
 
             elif isinstance(cur, doc.Line):
@@ -63,7 +63,7 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                     continue
                 # regular soft line becomes a single space in flat mode
                 remaining -= 1
-                if remaining < 0:
+                if remaining <= 0:
                     return False
 
             # --- Structural nodes (walk children in LIFO) ---

jaclang/compiler/passes/tool/tests/fixtures/import_fmt.jac

@@ -1,6 +1,12 @@
 import from datetime { datetime }
 import from uuid { UUID, uuid4 }
 import from jaclang.compiler.constant { EdgeDir }
-import from jaclang.plugin { Archetype, ArchetypeProtocol, DSFunc, AbsRootHook, hookimpl }
+import from jaclang.plugin {
+    Archetype,
+    ArchetypeProtocol,
+    DSFunc,
+    AbsRootHook,
+    hookimpl
+}
 import math;
 import numpy as np;