jaclang 0.7.14__py3-none-any.whl → 0.7.16__py3-none-any.whl

jaclang/compiler/passes/main/pyast_load_pass.py

@@ -144,12 +144,15 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             if sys.version_info >= (3, 12):
             type_params: list[type_param]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
+        value = node.name if node.name not in reserved_keywords else f"<>{node.name}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=(
-                node.name if node.name != "root" else "root_"
-            ),  # root is a reserved keyword
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1875,10 +1878,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         id: _Identifier
         ctx: expr_context
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            for _, v in TOKEN_MAP.items()
+            if v not in ["float", "int", "str", "bool", "self"]
+        ]
+
+        value = node.id if node.id not in reserved_keywords else f"<>{node.id}"
         ret = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.id if node.id != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,
@@ -1913,13 +1925,18 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
         class Nonlocal(stmt):
             names: list[_Identifier]
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [v for _, v in TOKEN_MAP.items()]
+
         names: list[ast.NameAtom] = []
         for name in node.names:
+            value = name if name not in reserved_keywords else f"<>{name}"
             names.append(
                 ast.Name(
                     file_path=self.mod_path,
                     name=Tok.NAME,
-                    value=name if name != "root" else "root_",
+                    value=value,
                     line=node.lineno,
                     end_line=node.end_lineno if node.end_lineno else node.lineno,
                     col_start=node.col_offset,
@@ -2238,10 +2255,19 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             arg: _Identifier
             annotation: expr | None
         """
+        from jaclang.compiler import TOKEN_MAP
+
+        reserved_keywords = [
+            v
+            for _, v in TOKEN_MAP.items()
+            if v not in ["float", "int", "str", "bool", "self"]
+        ]
+
+        value = node.arg if node.arg not in reserved_keywords else f"<>{node.arg}"
         name = ast.Name(
             file_path=self.mod_path,
             name=Tok.NAME,
-            value=node.arg if node.arg != "root" else "root_",  # reserved word
+            value=value,
             line=node.lineno,
             end_line=node.end_lineno if node.end_lineno else node.lineno,
             col_start=node.col_offset,

jaclang/compiler/passes/main/registry_pass.py

@@ -13,7 +13,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
-from jaclang.core.utils import get_sem_scope
+from jaclang.runtimelib.utils import get_sem_scope
 
 
 class RegistryPass(Pass):
@@ -46,6 +46,7 @@ class RegistryPass(Pass):
         """Save architype information."""
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
             node.name.value,
             node.arch_type.value,
             node.semstr.lit_value if node.semstr else "",
@@ -61,7 +62,7 @@ class RegistryPass(Pass):
         """Save enum information."""
         scope = get_sem_scope(node)
         seminfo = SemInfo(
-            node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
+            node, node.name.value, "Enum", node.semstr.lit_value if node.semstr else ""
         )
         if (
             len(self.modules_visited)
@@ -77,6 +78,38 @@ class RegistryPass(Pass):
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
+            node.name.value,
+            extracted_type,
+            node.semstr.lit_value if node.semstr else "",
+        )
+        if len(self.modules_visited) and self.modules_visited[-1].registry:
+            self.modules_visited[-1].registry.add(scope, seminfo)
+
+    def exit_ability(self, node: ast.Ability) -> None:
+        """Save ability information."""
+        scope = get_sem_scope(node)
+        seminfo = SemInfo(
+            node,
+            node.name_ref.sym_name,
+            "Ability",
+            node.semstr.lit_value if node.semstr else "",
+        )
+        if len(self.modules_visited) and self.modules_visited[-1].registry:
+            (
+                self.modules_visited[-1].registry.add(scope.parent, seminfo)
+                if scope.parent
+                else None
+            )
+
+    def exit_param_var(self, node: ast.ParamVar) -> None:
+        """Save param information."""
+        scope = get_sem_scope(node)
+        extracted_type = (
+            "".join(self.extract_type(node.type_tag.tag)) if node.type_tag else None
+        )
+        seminfo = SemInfo(
+            node,
             node.name.value,
             extracted_type,
             node.semstr.lit_value if node.semstr else "",
@@ -94,6 +127,7 @@ class RegistryPass(Pass):
         )
         scope = get_sem_scope(node)
         seminfo = SemInfo(
+            node,
             (
                 node.target.items[0].value
                 if isinstance(node.target.items[0], ast.Name)
@@ -113,7 +147,7 @@ class RegistryPass(Pass):
             and node.parent.parent.__class__.__name__ == "Enum"
         ):
             scope = get_sem_scope(node)
-            seminfo = SemInfo(node.value, None, "")
+            seminfo = SemInfo(node, node.value, None, "")
             if len(self.modules_visited) and self.modules_visited[-1].registry:
                 self.modules_visited[-1].registry.add(scope, seminfo)
 

jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -193,7 +193,7 @@ class SymTabBuildPass(Pass):
         if not node.is_absorb:
             for i in node.items.items:
                 i.sym_tab.def_insert(i, single_decl="import item")
-        elif node.is_absorb and node.hint.tag.value == "jac":
+        elif node.is_absorb and node.is_jac:
             source = node.items.items[0]
             if not isinstance(source, ast.ModulePath) or not source.sub_module:
                 self.error(

jaclang/compiler/passes/main/tests/__init__.py

@@ -1 +1 @@
-"""Tests for Jac passes."""
+"""Various tests for Jac passes."""

jaclang/compiler/passes/main/type_check_pass.py

@@ -49,7 +49,14 @@ class JacTypeCheckPass(Pass):
         """Call mypy APIs to implement type checking in Jac."""
         # Creating mypy api objects
         options = myab.myb.Options()
+        options.ignore_missing_imports = True
         options.cache_dir = Con.JAC_MYPY_CACHE
+        options.mypy_path = [
+            str(
+                pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+                / "stubs"
+            )
+        ]
         errors = myab.Errors(self, options)
         fs_cache = myab.FileSystemCache()
         search_paths = myab.compute_search_paths([], options, str(self.__path))

jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -10,6 +10,7 @@ import jaclang.compiler.absyntree as ast
 from jaclang.compiler.absyntree import AstNode
 from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
+from jaclang.settings import settings
 
 
 class JacFormatPass(Pass):
@@ -20,7 +21,7 @@ class JacFormatPass(Pass):
         self.comments: list[ast.CommentToken] = []
         self.indent_size = 4
         self.indent_level = 0
-        self.MAX_LINE_LENGTH = 44
+        self.MAX_LINE_LENGTH = int(float(settings.max_line_length) / 2)
 
     def enter_node(self, node: ast.AstNode) -> None:
         """Enter node."""
@@ -49,7 +50,8 @@ class JacFormatPass(Pass):
 
     def emit(self, node: ast.AstNode, s: str, strip_mode: bool = True) -> None:
         """Emit code to node."""
-        node.gen.jac += self.indent_str() + s.replace("\n", "\n" + self.indent_str())
+        indented_str = re.sub(r"\n(?!\n)", f"\n{self.indent_str()}", s)
+        node.gen.jac += self.indent_str() + indented_str
         if "\n" in node.gen.jac:
             if strip_mode:
                 node.gen.jac = node.gen.jac.rstrip(" ")
@@ -129,9 +131,15 @@ class JacFormatPass(Pass):
             else:
                 if isinstance(last_element, ast.Import):
                     self.emit_ln(node, "")
-                self.emit_ln(node, i.gen.jac)
-                if not node.gen.jac.endswith("\n"):
+                if last_element and (
+                    isinstance(i, ast.Architype)
+                    and isinstance(last_element, ast.Architype)
+                    and i.loc.first_line - last_element.loc.last_line == 2
+                    and not node.gen.jac.endswith("\n\n")
+                ):
                     self.emit_ln(node, "")
+                self.emit_ln(node, i.gen.jac)
+
                 if counter <= len(node.body) - 1:
                     if (
                         isinstance(i, ast.Ability)
@@ -142,6 +150,7 @@ class JacFormatPass(Pass):
                             and len(node.body[counter].kid[-1].kid) == 2
                             and len(node.body[counter - 1].kid[-1].kid) == 2
                         )
+                        and node.gen.jac.endswith("\n")
                     ):
                         self.emit(node, "")
                     else:
@@ -212,7 +221,7 @@ class JacFormatPass(Pass):
         items: list[T],
         """
         prev_token = None
-        for i, stmt in enumerate(node.kid):
+        for stmt in node.kid:
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -238,42 +247,18 @@ class JacFormatPass(Pass):
                 if stmt.name == Tok.LBRACE:
                     self.emit(node, f" {stmt.value}")
                 elif stmt.name == Tok.RBRACE:
-                    if self.indent_level > 0:
-                        self.indent_level -= 1
-                    if (stmt.parent and stmt.parent.gen.jac.strip() == "{") or (
-                        stmt.parent
-                        and stmt.parent.parent
-                        and isinstance(
-                            stmt.parent.parent,
-                            (ast.ElseIf, ast.IfStmt, ast.IterForStmt, ast.TryStmt),
-                        )
-                    ):
+                    self.indent_level = max(0, self.indent_level - 1)
+                    if stmt.parent and stmt.parent.gen.jac.strip() == "{":
                         self.emit(node, f"{stmt.value}")
                     else:
-                        next_kid = (
-                            node.kid[i + 1]
-                            if i < (len(node.kid) - 1)
-                            else ast.EmptyToken()
-                        )
-                        if (
-                            isinstance(next_kid, ast.CommentToken)
-                            and next_kid.is_inline
-                        ):
-                            self.emit(node, f" {stmt.value}")
-                        elif not (node.gen.jac).endswith("\n"):
+                        if not node.gen.jac.endswith("\n"):
                             self.emit_ln(node, "")
-                            self.emit(node, f"{stmt.value}")
-                        else:
-                            self.emit(node, f"{stmt.value}")
+                        self.emit(node, f"{stmt.value}")
                 elif isinstance(stmt, ast.CommentToken):
                     if stmt.is_inline:
                         if isinstance(prev_token, ast.Semi) or (
                             isinstance(prev_token, ast.Token)
-                            and prev_token.name
-                            in [
-                                Tok.LBRACE,
-                                Tok.RBRACE,
-                            ]
+                            and prev_token.name in [Tok.LBRACE, Tok.RBRACE]
                         ):
                             self.indent_level -= 1
                             self.emit(node, f" {stmt.gen.jac}")
@@ -297,48 +282,33 @@ class JacFormatPass(Pass):
                             self.emit(node, stmt.gen.jac)
                             if not stmt.gen.jac.endswith("postinit;"):
                                 self.indent_level -= 1
+                                self.emit_ln(stmt, "")
                                 self.emit_ln(node, "")
                                 self.indent_level += 1
                 elif stmt.gen.jac == ",":
                     self.emit(node, f"{stmt.value} ")
                 elif stmt.value == "=":
                     self.emit(node, f" {stmt.value} ")
+                elif prev_token and prev_token.gen.jac.strip() == "@":
+                    self.emit_ln(node, stmt.value)
                 else:
-                    self.emit(node, f"{stmt.value}")
+                    self.emit(node, f"{stmt.gen.jac}")
                 prev_token = stmt
                 continue
             elif isinstance(stmt, ast.Semi):
                 self.emit(node, stmt.gen.jac)
-            elif isinstance(prev_token, (ast.HasVar, ast.ArchHas)) and not isinstance(
-                stmt, (ast.HasVar, ast.ArchHas)
+            elif (
+                isinstance(prev_token, (ast.HasVar, ast.ArchHas))
+                and not isinstance(stmt, (ast.HasVar, ast.ArchHas))
+            ) or (
+                isinstance(prev_token, ast.Ability)
+                and isinstance(stmt, (ast.Ability, ast.AbilityDef))
             ):
                 if not isinstance(prev_token.kid[-1], ast.CommentToken):
                     self.indent_level -= 1
                     self.emit_ln(node, "")
                     self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
-            elif isinstance(prev_token, ast.Ability) and isinstance(
-                stmt, (ast.Ability, ast.AbilityDef)
-            ):
-                if not isinstance(prev_token.kid[-1], ast.CommentToken) and (
-                    stmt.body and not isinstance(stmt.body, ast.FuncCall)
-                ):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, f"{stmt.gen.jac}")
-                elif stmt.body and isinstance(
-                    stmt.body, (ast.FuncCall, ast.EventSignature)
-                ):
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, stmt.gen.jac)
-                else:
-                    self.indent_level -= 1
-                    self.emit_ln(node, "")
-                    self.indent_level += 1
-                    self.emit(node, f"{stmt.gen.jac}")
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
                     self.emit_ln(node, "")
@@ -763,7 +733,7 @@ class JacFormatPass(Pass):
                             self.indent_level += indent_val
                             indented = True
                     else:
-                        self.emit(node, f"{j.gen.jac.strip()}")
+                        self.emit(node, j.gen.jac.lstrip())
                 if indented:
                     self.indent_level -= indent_val
             else:
@@ -929,6 +899,8 @@ class JacFormatPass(Pass):
         """Check if the length of the current generated code exceeds the max line length."""
         if max_line_length == 0:
             max_line_length = self.MAX_LINE_LENGTH
+        # print(content)
+        # print(len(content))
         return len(content) > max_line_length
 
     def exit_binary_expr(self, node: ast.BinaryExpr) -> None:
@@ -978,6 +950,7 @@ class JacFormatPass(Pass):
                 self.error(
                     f"Binary operator {node.op.value} not supported in bootstrap Jac"
                 )
+        # print(node.gen)
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -1110,6 +1083,9 @@ class JacFormatPass(Pass):
             if isinstance(i, ast.CommentToken):
                 if i.is_inline:
                     self.emit(node, f" {i.gen.jac}")
+                elif (tok := self.token_before(i)) and (i.line_no - tok.line_no == 1):
+                    self.emit_ln(node, "")
+                    self.emit(node, i.gen.jac)
                 else:
                     self.emit_ln(node, "")
                     self.emit_ln(node, "")
@@ -1340,38 +1316,96 @@ class JacFormatPass(Pass):
         if isinstance(node.kid[-1], (ast.Semi, ast.CommentToken)):
             self.emit_ln(node, "")
 
+    def handle_long_assignment(self, node: ast.Assignment, kid: ast.AstNode) -> None:
+        """Handle long assignment lines."""
+        parts = re.split(r"(=)", kid.gen.jac)
+        first_part = parts.pop(0).strip()
+        self.emit_ln(
+            node, f"{first_part} {parts.pop(0).strip()} {parts.pop(0).strip()}"
+        )
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if var:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, op)
+                self.indent_level -= 1
+
+    def handle_long_expression(self, node: ast.AstNode, kid: ast.AstNode) -> None:
+        """Handle long expressions with multiple operators."""
+        parts = re.split(r"(\+|\-|\*|\/)", kid.gen.jac)
+        self.emit_ln(node, f"{parts.pop(0).strip()}")
+        for j in range(0, len(parts) - 1, 2):
+            op = parts[j]
+            var = parts[j + 1].strip() if j + 1 < len(parts) else ""
+            if j < len(parts) - 2:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+                self.emit_ln(node, "")
+            else:
+                self.indent_level += 1
+                self.emit(node, f"{op} {var}")
+                self.indent_level -= 1
+
     def exit_assignment(self, node: ast.Assignment) -> None:
         """Sub objects.
 
-        target: SubNodeList[AtomType],
-        value: Optional[ExprType | YieldStmt],
-        type_tag: Optional[SubTag[ExprType]],
+        target: SubNodeList[Expr],
+        value: Optional[Expr | YieldExpr],
+        type_tag: Optional[SubTag[Expr]],
         mutable: bool = True,
-        aug_op: Optional[Token] = None
+        aug_op: Optional[Token] = None,
+        semstr: Optional[String] = None,
+        is_enum_stmt: bool = False,
         """
-        for i in node.kid:
-            if isinstance(i, ast.CommentToken):
-                if i.is_inline:
-                    self.emit(node, i.gen.jac)
+        prev_token = None
+        for kid in node.kid:
+            if isinstance(kid, ast.CommentToken):
+                if kid.is_inline:
+                    self.emit(node, kid.gen.jac)
                 else:
-                    if i.gen.jac not in [
+                    if kid.gen.jac not in [
                         "# Update any new user level buddy schedule",
                         "# Construct prompt here",
                     ]:
                         self.emit_ln(node, "")
                         self.emit_ln(node, "")
-                        self.emit_ln(node, i.gen.jac)
+                        self.emit_ln(node, kid.gen.jac)
                     else:
                         self.emit_ln(node, "")
-                        self.emit(node, i.gen.jac)
-            elif isinstance(i, ast.Token) and (
-                i.name == Tok.KW_LET or i.gen.jac == ":"
+                        self.emit(node, kid.gen.jac)
+            elif isinstance(kid, ast.Token) and (
+                kid.name == Tok.KW_LET or kid.gen.jac == ":"
             ):
-                self.emit(node, f"{i.gen.jac} ")
-            elif isinstance(i, ast.Token) and "=" in i.gen.jac:
-                self.emit(node, f" {i.gen.jac} ")
+                self.emit(node, f"{kid.gen.jac} ")
+            elif isinstance(kid, ast.Token) and "=" in kid.gen.jac:
+                self.emit(node, f" {kid.gen.jac} ")
+            elif (
+                "=" in kid.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_assignment(node, kid)
+            elif (
+                prev_token
+                and "=" in prev_token.gen.jac
+                and self.is_line_break_needed(
+                    kid.gen.jac, max_line_length=self.MAX_LINE_LENGTH * 2
+                )
+                and "\n" not in kid.gen.jac
+            ):
+                self.handle_long_expression(node, kid)
             else:
-                self.emit(node, i.gen.jac)
+                self.emit(node, kid.gen.jac)
+            prev_token = kid
         if isinstance(
             node.kid[-1], (ast.Semi, ast.CommentToken)
         ) and not node.gen.jac.endswith("\n"):
@@ -2386,7 +2420,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, f"<>{node.value}" if node.is_kwesc else node.value)
 
-    def enter_float(self, node: ast.Float) -> None:
+    def exit_float(self, node: ast.Float) -> None:
         """Sub objects.
 
         name: str,
@@ -2399,7 +2433,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_int(self, node: ast.Int) -> None:
+    def exit_int(self, node: ast.Int) -> None:
         """Sub objects.
 
         name: str,
@@ -2412,7 +2446,7 @@ class JacFormatPass(Pass):
         """
         self.emit(node, node.value)
 
-    def enter_string(self, node: ast.String) -> None:
+    def exit_string(self, node: ast.String) -> None:
         """Sub objects.
 
         name: str,
@@ -2424,7 +2458,11 @@ class JacFormatPass(Pass):
         pos_end: int,
         """
         # if string is in docstring format and spans multiple lines turn into the multiple single quoted strings
-        if "\n" in node.value and node.parent and isinstance(node.parent, ast.Expr):
+        if "\n" in node.value and (
+            node.parent
+            and isinstance(node.parent, ast.Expr)
+            and not isinstance(node.parent, ast.MultiString)
+        ):
             string_type = node.value[0:3]
             pure_string = node.value[3:-3]
             lines = pure_string.split("\n")
@@ -2442,14 +2480,14 @@ class JacFormatPass(Pass):
             string_type = node.value[0:3]
             pure_string = node.value[3:-3]
             lines = pure_string.split("\n")
-            self.emit(node, string_type)
-            for line in lines[:-1]:
-                self.emit_ln(node, line)
-            self.emit_ln(node, f"{lines[-1]}{string_type}")
+            self.emit_ln(node, f"{string_type}{lines[0].lstrip()}")
+            for line in lines[1:-1]:
+                self.emit_ln(node, line.lstrip())
+            self.emit(node, f"{lines[-1].lstrip()}{string_type}")
         else:
             self.emit(node, node.value)
 
-    def enter_bool(self, node: ast.Bool) -> None:
+    def exit_bool(self, node: ast.Bool) -> None:
         """Sub objects.
 
         name: str,

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

@@ -16,7 +16,6 @@ obj Memory {
     can save_obj(caller_id: UUID, item: Element);
     can del_obj(caller_id: UUID, item: Element);
     #* Utility Functions *#
-
     can get_object_distribution -> dict;
     can get_mem_size -> float;
 }

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

@@ -0,0 +1,13 @@
+class Animal {}
+
+obj Domesticated {}
+
+@print_base_classes
+node Pet :Animal, Domesticated: {}
+
+walker Person :Animal: {}
+
+walker Feeder :Person: {}
+
+@print_base_classes
+walker Zoologist :Feeder: {}

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

@@ -0,0 +1,11 @@
+obj inner_red {
+    has color22: string = 'red',
+        # self
+        doublepoint11: int = 2,
+        doublepoint22: float = 2.0,
+        # self
+        doublepoint33: int = 2,
+        # Comments explaining each attribute
+        # color22: represents the color, set to 'red'
+        point22: int = 20;
+}

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

@@ -0,0 +1,13 @@
+with entry:__main__ {
+    app = App();
+    app.run();
+    # ray.init_window(800, 450, "Hello");
+    # while not ray.window_should_close() {
+    #     ray.begin_drawing();
+    #     ray.clear_background(ray.WHITE);
+    #     ray.draw_text("Hello world", 190, 200, 20, ray.VIOLET);
+    #     ray.end_drawing();
+    # }
+
+    # ray.close_window();
+}

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

@@ -0,0 +1,37 @@
+can star(func: Any) {
+    can inner(x: Any) {
+        print(("*" * 30));
+        func(x);
+        print(("*" * 30));
+    }
+    return inner;
+}
+
+can percent(func: Any) {
+    can inner(y: Any) {
+        print(("%" * 30));
+        func(y);
+        print(("%" * 30));
+    }
+    return inner;
+}
+
+can percent2(func: Any) {
+    can inner(y: Any) {
+        print(("-" * 30));
+        func(y);
+        print(("+" * 30));
+    }
+    return inner;
+}
+
+@star
+@percent
+@percent2
+can printer(msg: Any) {
+    print(msg);
+}
+
+with entry {
+    printer("Hello");
+}

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

@@ -0,0 +1,5 @@
+with entry {
+    <>self = 5;
+    <>self += <>self;
+    print(<>self);
+}