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

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -3,7 +3,8 @@
 This is a pass for formatting Jac code.
 """
 
-from typing import Optional
+from collections import deque
+from typing import Deque, Optional, Tuple
 
 import jaclang.compiler.passes.tool.doc_ir as doc
 import jaclang.compiler.unitree as uni
@@ -19,6 +20,83 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
         self.indent_size = 4
         self.MAX_LINE_LENGTH = settings.max_line_length
 
+    def _probe_fits(
+        self,
+        node: doc.DocType,
+        indent_level: int,
+        width_remaining: int,
+        *,
+        max_steps: int = 2000,
+    ) -> bool:
+        """
+        Check if flat can be used early.
+
+        returns True if `node` could be printed *flat* on the current line within
+        `width_remaining` columns at `indent_level`.
+        Stops early on overflow or hard/literal lines.
+        """
+        # Worklist holds (node, indent_level). We only ever push FLAT in a probe.
+        work: Deque[Tuple[object, int]] = deque()
+        work.append((node, indent_level))
+        steps = 0
+        remaining = width_remaining
+
+        while work:
+            if steps >= max_steps:
+                # Safety cutoff: if it's *that* complex, assume it doesn't fit.
+                return False
+            steps += 1
+
+            cur, lvl = work.pop()
+
+            if isinstance(cur, doc.Text):
+                remaining -= len(cur.text)
+                if remaining <= 0:
+                    return False
+
+            elif isinstance(cur, doc.Line):
+                if cur.hard or cur.literal:
+                    # Any *real* newline (hard or literal) in FLAT means "doesn't fit"
+                    return False
+                if cur.tight:
+                    # tight softline disappears in flat mode
+                    continue
+                # regular soft line becomes a single space in flat mode
+                remaining -= 1
+                if remaining <= 0:
+                    return False
+
+            # --- Structural nodes (walk children in LIFO) ---
+            elif isinstance(cur, doc.Concat):
+                # push reversed so we process left-to-right as work is a stack
+                for p in reversed(cur.parts):
+                    work.append((p, lvl))
+
+            elif isinstance(cur, doc.Group):
+                # Probe is always FLAT for groups.
+                work.append((cur.contents, lvl))
+
+            elif isinstance(cur, doc.Indent):
+                # In flat mode, indentation has no effect until a newline; keep lvl in case
+                # children contain Lines (which would have already returned False).
+                work.append((cur.contents, lvl + 1))
+
+            elif isinstance(cur, doc.Align):
+                # In flat mode, alignment doesn’t change width immediately (no newline),
+                # but we carry its virtual indent so nested (illegal) Line would be caught.
+                align_spaces = cur.n if cur.n is not None else self.indent_size
+                extra_levels = align_spaces // self.indent_size
+                work.append((cur.contents, lvl + extra_levels))
+
+            elif isinstance(cur, doc.IfBreak):
+                # Flat branch while probing
+                work.append((cur.flat_contents, lvl))
+
+            else:
+                raise ValueError(f"Unknown DocType in probe: {type(cur)}")
+
+        return True
+
     def transform(self, ir_in: uni.Module) -> uni.Module:
         """After pass."""
         ir_in.gen.jac = self.format_doc_ir()
@@ -52,106 +130,78 @@ class JacFormatPass(Transform[uni.Module, uni.Module]):
                 return " "
 
         elif isinstance(doc_node, doc.Group):
-            # Try to print flat first. For this attempt, the group itself isn't forced to break.
-            flat_contents_str = self.format_doc_ir(
-                doc_node.contents, indent_level, width_remaining, is_broken=False
+            fits_flat = self._probe_fits(
+                doc_node.contents,
+                indent_level=indent_level,
+                width_remaining=width_remaining,
+            )
+            return self.format_doc_ir(
+                doc_node.contents,
+                indent_level,
+                width_remaining,
+                is_broken=not fits_flat,
             )
-            if (
-                "\n" not in flat_contents_str
-                and len(flat_contents_str) <= width_remaining
-            ):
-                return flat_contents_str
-            else:
-                full_width_for_broken_content = self.MAX_LINE_LENGTH - (
-                    indent_level * self.indent_size
-                )
-                return self.format_doc_ir(
-                    doc_node.contents,
-                    indent_level,
-                    full_width_for_broken_content,
-                    is_broken=True,
-                )
 
         elif isinstance(doc_node, doc.Indent):
             new_indent_level = indent_level + 1
-
-            width_for_indented_content = self.MAX_LINE_LENGTH - (
-                new_indent_level * self.indent_size
-            )
             return self.format_doc_ir(
                 doc_node.contents,
                 new_indent_level,
-                width_for_indented_content,  # Budget for lines within indent
+                width_remaining,  # width_for_indented_content  # Budget for lines within indent
                 is_broken,  # is_broken state propagates
             )
 
         elif isinstance(doc_node, doc.Concat):
-            result = ""
-            # current_line_budget is the space left on the current line for the current part.
+            result: list[str] = []
             current_line_budget = width_remaining
 
             for part in doc_node.parts:
                 part_str = self.format_doc_ir(
                     part, indent_level, current_line_budget, is_broken
                 )
-                if part_str.startswith("\n"):
-                    result = result.rstrip(" ")
-                result += part_str
+
+                # Trim trailing spaces when a newline begins next
+                if part_str.startswith("\n") and result and result[-1].endswith(" "):
+                    result[-1] = result[-1].rstrip(" ")
+
+                result.append(part_str)
 
                 if "\n" in part_str:
-                    # part_str created a newline. The next part starts on a new line.
-                    # Its budget is the full width available at this indent level.
-                    current_line_budget = self.MAX_LINE_LENGTH - (
-                        indent_level * self.indent_size
+                    # After a newline, reset budget to full width at this indent.
+                    last_line = part_str.splitlines()[-1]
+                    full_budget = max(
+                        0, self.MAX_LINE_LENGTH - indent_level * self.indent_size
                     )
-                    # Subtract what the *last line* of part_str consumed from this budget.
-                    # The characters on the last line after the indent string.
-                    indent_str_len = indent_level * self.indent_size
-                    last_line_of_part = part_str.splitlines()[-1]
-
-                    content_on_last_line = 0
-                    if last_line_of_part.startswith(" " * indent_str_len):
-                        content_on_last_line = len(last_line_of_part) - indent_str_len
-                    else:  # It was a line not starting with the full indent (e.g. literal \n)
-                        content_on_last_line = len(last_line_of_part)
-
-                    current_line_budget -= content_on_last_line
+                    # Compute how many chars are already on the last line (after indent).
+                    indent_spaces = " " * (indent_level * self.indent_size)
+                    if last_line.startswith(indent_spaces):
+                        used = len(last_line) - len(indent_spaces)
+                    else:
+                        used = len(last_line)
+                    current_line_budget = max(0, full_budget - used)
                 else:
-                    # part_str stayed on the same line. Reduce budget for next part on this line.
-                    current_line_budget -= len(part_str)
+                    current_line_budget = max(0, current_line_budget - len(part_str))
 
-                if current_line_budget < 0:  # Ensure budget isn't negative
-                    current_line_budget = 0
-            return result
+            return "".join(result)
 
         elif isinstance(doc_node, doc.IfBreak):
-            if is_broken:
-                return self.format_doc_ir(
-                    doc_node.break_contents, indent_level, width_remaining, is_broken
-                )
-            else:
-                return self.format_doc_ir(
-                    doc_node.flat_contents, indent_level, width_remaining, is_broken
-                )
+            branch = doc_node.break_contents if is_broken else doc_node.flat_contents
+            return self.format_doc_ir(branch, indent_level, width_remaining, is_broken)
 
         elif isinstance(doc_node, doc.Align):
             align_spaces = doc_node.n if doc_node.n is not None else self.indent_size
-            # effective_total_indent_spaces_for_children = (
-            #     indent_level * self.indent_size
-            # ) + align_spaces
-            child_indent_level_for_align = indent_level + (
-                align_spaces // self.indent_size
-            )
+            extra_levels = align_spaces // self.indent_size
+            child_indent_level = indent_level + extra_levels
 
-            child_width_budget = width_remaining - align_spaces
-            if child_width_budget < 0:
-                child_width_budget = 0
+            # On the same line, alignment "consumes" part of the current budget.
+            child_width_budget = max(0, width_remaining - align_spaces)
 
             return self.format_doc_ir(
                 doc_node.contents,
-                child_indent_level_for_align,  # Approximated level for Lines inside
-                child_width_budget,  # Budget for content on first line
+                child_indent_level,
+                child_width_budget,
                 is_broken,
             )
+
         else:
             raise ValueError(f"Unknown DocType: {type(doc_node)}")

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

@@ -474,15 +474,15 @@ impl JacPlugin.visit_node
 glob expected_area = 78.53981633974483;
 
 test a1 {
-    check assertAlmostEqual(calculate_area(RAD), expected_area);
+    assert assertAlmostEqual(calculate_area(RAD), expected_area);
 }
 
 test a2 {
     c = Circle(RAD);
-    check assertAlmostEqual(c.area(), expected_area);
+    assert assertAlmostEqual(c.area(), expected_area);
 }
 
 test a3 {
     c = Circle(RAD);
-    check assertEqual(c.shape_type, ShapeType.CIRCLE);
+    assert assertEqual(c.shape_type, ShapeType.CIRCLE);
 }

jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/triple_quoted_string.jac

@@ -1,7 +1,6 @@
 with entry {
-    triple_quoted_string =
-        """This is a triple quoted string.
-        It can span multiple lines.
-        It can contain any number of quotes or apostrophes.
-        """;
+    triple_quoted_string = """This is a triple quoted string.
+    It can span multiple lines.
+    It can contain any number of quotes or apostrophes.
+    """;
 }

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;

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

@@ -1,18 +1,284 @@
+#this file is part of formatter tests and is not meant to be run
 class SemTokManager {
     """Initialize semantic token manager."""
     def init(self: SemTokManager, ir: uni.Module) -> None {
-        self.sem_tokens: List[int] = self.gen_sem_tokens(ir);
         self.aaaaastatic_sem_tokens:
-            List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] =
-            self.gen_sem_tok_node(ir);
+            List[Tuple[lspt.Position, int, int, uni.AstSymbolNode]] = self.gen_sem_tok_node(
+            ir
+        );
     }
 }
 
 
-def init(
-    self: ModuleManager,
-    program: JacProgram,
-    sem_managers: <>dict,
-    program2: JacProgram,
-    sem_managers2: <>dict
-) -> None { }
+def walrus_example() {
+    if ((x := 10) > 5) {
+        print(x);
+        b = a(
+            11111111111111111111111111111111111111111111111111111111111111111111111111
+        );
+    }
+}
+
+
+with entry {
+    c = (
+        a()
+        if 1
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
+        and isinstance(a, int)
+        else (
+            999
+            if isinstance(a, int)
+            and isinstance(a, int)
+            and isinstance(a, int)
+            and isinstance(4, bool)
+            else 7
+        )
+    );
+    print("""This is a long
+        line of code.""");
+}
+
+
+class ModuleManager {
+    def clear_alerts_for_file(self: ModuleManager, file_path_fs: str) -> None {
+        #list comprehension example
+        self.warnings_had = [
+            w
+            for w in self.program
+            if w.loc.mod_path != file_path_fs
+        ];
+        self.program.errors_had = [
+            e
+            for e in self.program.errors_haddddddddd
+            if e.loc.mod_path != file_path_fs
+        ];
+        self.program.errors_had = [
+            e
+            for e in self.program.errors_haddddddddddddddddddddddddddddddddddddddddd
+            if e.loc.mod_path != file_path_fs
+        ];
+        # dict comprehension example
+        squares_dict = {x : x ** 2 for x in numbers};
+        squares_dict = {
+            x : x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        squares_dict = {
+            x : x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        # set comprehension example
+        squares_set = {x ** 2 for x in numbers};
+        squares_set = {
+            x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        squares_set = {
+            x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        };
+        # generator comprehension example
+        squares_gen = (x ** 2 for x in numbers);
+        squares_gen = (
+            x ** 2 for x in numberssssssssssssssssssssssssssssssssssssssssssssssssssss
+        );
+        squares_gen = (
+            x ** 2
+            for x in numbersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
+        );
+    }
+}
+
+
+## expr as item extra space issue
+with entry {
+    with open(f"Apple{apple}.txt") as f {
+        # Fix syntax highlighting
+        print(
+            f.read()
+        );
+    }
+}
+
+
+def func_with_very_long_params(
+    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: int,
+    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
+) -> None {
+    print(
+        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
+        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,
+    );
+}
+
+
+def func_with_long_params(
+    aaaaaaaaaaaaaaaaaaaaaa: int, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb: int,
+) -> None {
+    print(
+        aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, 1111111111111
+    );
+}
+
+
+def func_with_short_params(a: int, b: int) -> None {
+    print(a + b + c[5:]);
+}
+
+
+with entry {
+    if (
+        node_selected
+        and node_selected.find_parent_of_type(uni.Archetype)
+        or node_selected.find_parent_of_type(uni.ImplDef)
+    ) {
+        self_symbol = [
+            lspt.CompletionItem(label='self', kind=lspt.CompletionItemKind.Variable)
+        ];
+    } else {
+        self_symbol = [];
+    }
+    x = (
+        1222222222
+        and 2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222
+    );
+    a = 4 if True else 4;
+}
+
+
+import from typing { Any, Awaitable, Callable, Coroutine, Optional, ParamSpec, TypeVar }
+
+import from jaclang.compiler.constant {
+    JacSemTokenModifier as SemTokMod,
+    JacSemTokenType as SemTokType,
+}
+
+
+"""Return diagnostics."""
+def gen_diagnostics(
+    from_path: str, errors: list[Alert], warnings: list[Alert]
+) -> list[lspt.Diagnostic] {
+    if (
+        isinstance(node_selected, uni.Name)
+        and node_selected.parent
+        and isinstance(node_selected.parent, uni.ModulePath)
+    ) {
+        node_selected = node_selected.name_of;
+    } elif (
+        isinstance(node_selected, uni.Name)
+        and node_selected.parent
+        and isinstance(node_selected.parent, uni.ModulePath)
+    ) {
+        spec = node_selected.parent.parent.abs_path;
+    }
+}
+
+
+@decorator
+def x() {
+    assert gg == 7;
+}
+
+
+@decorator()
+class KK {}
+
+
+# kkk
+import pygame, random, math;
+
+
+# fff
+with entry {
+    # gg
+    a = 9;
+}
+
+
+# kkk
+class X {}
+
+
+# comment
+@decorator
+def xxx() { }
+
+
+# ddd
+glob a = 7;
+def get_node_info(self: JacLangServer, sym_node: uni.AstSymbolNode) -> Optional[str] {
+    try {
+        if isinstance(sym_node, uni.NameAtom) {
+            sym_node = sym_node.name_of;
+        }
+        access = (sym_node.sym.access.value + ' ') if sym_node.sym else None;
+        node_info = f"'('{(access if access else '')}{sym_node.sym_category.value}') '{sym_node.sym_name}";
+        if sym_node.name_spec.clean_type {
+            node_info += f"': '{sym_node.name_spec.clean_type}";
+        }
+        if (
+            isinstance(sym_node, uni.AstSymbolNode)
+            and isinstance(sym_node.name_spec.type, ClassType)
+        ) {
+            node_info += f"': '{sym_node.name_spec.type.shared.class_name}";
+        }
+        if (isinstance(sym_node, uni.AstDocNode) and sym_node.doc) {
+            node_info += f"'\n'{sym_node.doc.value}";
+        }
+        if (isinstance(sym_node, uni.Ability) and sym_node.signature) {
+            node_info += f"'\n'{sym_node.signature.unparse()}";
+        }
+    } except AttributeError as e {
+        self.log_warning(f"'Attribute error when accessing node attributes: '{e}");
+    }
+    return node_info.strip();
+}
+
+
+class foo {
+    """Get information about a node."""
+    def get_node_info(
+        self: JacLangServer, sym_node: uni.AstSymbolNode
+    ) -> Optional[str] {
+        if isinstance(sym_node, uni.AstVarNode) {
+            var_name = sym_node.name;
+            var_type = sym_node.var_type if sym_node.var_type else 'unknown';
+            return f" 'Variable: ' {var_name} ', Type: ' {var_type} ";
+        } elif isinstance(sym_node, uni.AstFuncNode) {
+            func_name = sym_node.name;
+            params = ', '.join(
+                [f" {p.name} ': ' {p.param_type} " for p in sym_node.params]
+            );
+            return f" 'Function: ' {func_name} '(' {params} ')' ";
+        }
+    }
+}
+
+
+def x3() {
+    if dest_type.is_class_instance() and src_type.is_class_instance() {
+        print("x");
+    }
+    if (
+        dest_type.is_class_instance()
+        and src_type.is_class_instance()
+        and src_type.is_class_instance()
+    ) {
+        print("x");
+    }
+    if (dest_type.is_class_instance() and src_type.is_class_instance()) {
+        print("x");
+    }
+}
+
+
+class HH {
+    def test()  -> Optional[str] {
+        a = """!
+hello
+hru
+""";
+    }
+}

jaclang/compiler/passes/transform.py

@@ -9,7 +9,7 @@ from typing import Generic, Optional, TYPE_CHECKING, Type, TypeVar
 from jaclang.compiler.codeinfo import CodeLocInfo
 from jaclang.compiler.unitree import UniNode
 from jaclang.settings import settings
-from jaclang.utils.helpers import pretty_print_source_location
+from jaclang.utils.helpers import ANSIColors, pretty_print_source_location
 from jaclang.utils.log import logging
 
 if TYPE_CHECKING:
@@ -39,7 +39,7 @@ class Alert:
         """Return string representation of alert."""
         return self.as_log()
 
-    def as_log(self) -> str:
+    def as_log(self, *, colors: bool = False) -> str:
         """Return the alert as a single line log as opposed to the pretty print."""
         file_path: str = self.loc.mod_path
         if file_path == "":
@@ -47,20 +47,24 @@ class Alert:
 
         line: int = self.loc.first_line
         column: int = self.loc.col_start
-        return f"{file_path}:{line}:{column} {self.msg}"
 
-    def pretty_print(self) -> str:
-        """Pretty pritns the Alert to show the alert with source location."""
+        # TODO: Set if the alert is error or warning and color accordingly.
+        msg = self.msg if not colors else f"{ANSIColors.RED}{self.msg}{ANSIColors.END}"
+        return f"{file_path}:{line}:{column} {msg}"
+
+    def pretty_print(self, *, colors: bool = False) -> str:
+        """Pretty prints the Alert to show the alert with source location."""
         pretty_dump = pretty_print_source_location(
             self.loc.mod_path,
             self.loc.orig_src.code,
             self.loc.first_line,
             self.loc.pos_start,
             self.loc.pos_end,
+            colors=colors,
         )
         if pretty_dump != "":
             pretty_dump = "\n" + pretty_dump
-        return self.as_log() + pretty_dump
+        return self.as_log(colors=colors) + pretty_dump
 
 
 class Transform(ABC, Generic[T, R]):
@@ -115,7 +119,7 @@ class Transform(ABC, Generic[T, R]):
         )
         self.errors_had.append(alrt)
         self.prog.errors_had.append(alrt)
-        self.logger.error(alrt.as_log())
+        # self.logger.error(alrt.as_log())
 
     def log_warning(self, msg: str, node_override: Optional[UniNode] = None) -> None:
         """Pass Error."""
@@ -126,7 +130,7 @@ class Transform(ABC, Generic[T, R]):
         )
         self.warnings_had.append(alrt)
         self.prog.warnings_had.append(alrt)
-        self.logger.warning(alrt.as_log())
+        # self.logger.warning(alrt.as_log())
 
     def log_info(self, msg: str) -> None:
         """Log info."""