jaclang 0.7.18__tar.gz → 0.7.20__tar.gz

{jaclang-0.7.18 → jaclang-0.7.20}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.18
+Version: 0.7.20
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
 Author-email: jason@jaseci.org
+Maintainer: Jason Mars
+Maintainer-email: jason@jaseci.org
 Requires-Python: >=3.11.0,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -42,7 +44,7 @@ This is the main source code repository for the [Jac] programming language. It c
 [Documentation]: https://www.jac-lang.org//learn/guide/
 [Contributing]: .github/CONTRIBUTING.md
 
-## What and Why Jac?
+## What and Why is Jac?
 
 - **Native Superset of Python** - Jac is a native superset of python, meaning the entire python ecosystem is directly interoperable with Jac without any trickery (no interop interface needed). Like Typescript is to Javascript, or C++ is to C, Jac is to Python. (every Jac program can be ejected to pure python, and every python program can be transpiled to a Jac program)
 

{jaclang-0.7.18 → jaclang-0.7.20}/README.md

@@ -21,7 +21,7 @@ This is the main source code repository for the [Jac] programming language. It c
 [Documentation]: https://www.jac-lang.org//learn/guide/
 [Contributing]: .github/CONTRIBUTING.md
 
-## What and Why Jac?
+## What and Why is Jac?
 
 - **Native Superset of Python** - Jac is a native superset of python, meaning the entire python ecosystem is directly interoperable with Jac without any trickery (no interop interface needed). Like Typescript is to Javascript, or C++ is to C, Jac is to Python. (every Jac program can be ejected to pure python, and every python program can be transpiled to a Jac program)
 

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/cli/cli.py

@@ -429,8 +429,8 @@ def dot(
 
     if filename.endswith(".jac"):
         jac_machine = JacMachine(base)
-        jac_import(target=mod, base_path=base)
-        module = jac_machine.loaded_modules.get(mod)
+        jac_import(target=mod, base_path=base, override_name="__main__")
+        module = jac_machine.loaded_modules.get("__main__")
         globals().update(vars(module))
         try:
             node = globals().get(initial, eval(initial)) if initial else None

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/absyntree.py

@@ -4212,7 +4212,7 @@ class Literal(Token, AtomExpr):
         raise NotImplementedError
 
 
-class BuiltinType(Name, Literal, NameAtom):
+class BuiltinType(Name, Literal):
     """Type node type for Jac Ast."""
 
     SYMBOL_TYPE = SymbolType.VAR

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/parser.py

@@ -3587,7 +3587,7 @@ class JacParser(Pass):
             match_case_block: KW_CASE pattern_seq (KW_IF expression)? COLON statement_list
             """
             pattern = kid[1]
-            guard = kid[3] if len(kid) > 4 else None
+            guard = kid[3] if isinstance(kid[3], ast.Expr) else None
             stmts = [i for i in kid if isinstance(i, ast.CodeBlockStmt)]
             if isinstance(pattern, ast.MatchPattern) and isinstance(
                 guard, (ast.Expr, type(None))

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/ir_pass.py

@@ -133,6 +133,8 @@ class Pass(Transform[T]):
         else:
             self.prune_signal = False
         self.cur_node = node
+        if self.term_signal:
+            return node
         self.exit_node(node)
         return node
 

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/__init__.py

@@ -13,7 +13,7 @@ from .type_check_pass import JacTypeCheckPass  # noqa: I100
 from .registry_pass import RegistryPass  # noqa: I100
 
 
-pass_schedule = py_code_gen
+pass_schedule = py_code_gen  # type: ignore[has-type]
 
 __all__ = [
     "SubNodeTabPass",

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/fuse_typeinfo_pass.py

@@ -6,6 +6,7 @@ mypy apis into Jac and use jac py ast in it.
 
 from __future__ import annotations
 
+import re
 from typing import Callable, Optional, TypeVar
 
 import jaclang.compiler.absyntree as ast
@@ -46,24 +47,24 @@ class FuseTypeInfoPass(Pass):
             )
 
     def __set_sym_table_link(self, node: ast.AstSymbolNode) -> None:
-        typ = node.sym_type.split(".")
         typ_sym_table = self.ir.sym_tab
+        assert isinstance(self.ir, ast.Module)
 
-        if typ[0] == "builtins":
-            return
+        sym_type = node.sym_type
+        if re.match(r"builtins.(list|dict|tuple)", sym_type):
+            sym_type = re.sub(r"\[.*\]", "", sym_type)
+
+        typ = sym_type.split(".")
 
         if node.sym_type == "types.ModuleType" and node.sym:
             node.name_spec.type_sym_tab = node.sym.parent_tab.find_scope(node.sym_name)
 
-        assert isinstance(self.ir, ast.Module)
-
-        if typ_sym_table:
-            for i in typ:
-                if i == self.ir.name:
-                    continue
-                f = typ_sym_table.find_scope(i)
-                if f:
-                    typ_sym_table = f
+        for i in typ:
+            if i == self.ir.name:
+                continue
+            f = typ_sym_table.find_scope(i)
+            if f:
+                typ_sym_table = f
 
         if typ_sym_table != self.ir.sym_tab:
             node.name_spec.type_sym_tab = typ_sym_table
@@ -144,6 +145,11 @@ class FuseTypeInfoPass(Pass):
                         self.__set_sym_table_link(node)
                         self.__collect_python_dependencies(node)
 
+                # Special handing for BuiltinType
+                elif isinstance(node, ast.BuiltinType):
+                    func(self, node)  # type: ignore
+                    self.__set_sym_table_link(node)
+
                 # Jac node doesn't have mypy nodes linked to it
                 else:
                     self.__debug_print(
@@ -209,10 +215,21 @@ class FuseTypeInfoPass(Pass):
                     f"{type(mypy_node)}"
                 )
 
+    def __check_builltin_symbol(self, node: ast.NameAtom) -> None:
+        if isinstance(node.parent, ast.AtomTrailer) and node is node.parent.right:
+            return
+        builtins_sym_tab = self.ir.sym_tab.find_scope("builtins")
+        assert builtins_sym_tab is not None
+        builtins_sym = builtins_sym_tab.lookup(node.sym_name)
+        if builtins_sym:
+            node.name_spec._sym = builtins_sym
+
     @__handle_node
     def enter_name(self, node: ast.NameAtom) -> None:
         """Pass handler for name nodes."""
         self.__collect_type_from_symbol(node)
+        if node.sym is None:
+            self.__check_builltin_symbol(node)
 
     @__handle_node
     def enter_module_path(self, node: ast.ModulePath) -> None:
@@ -423,7 +440,8 @@ class FuseTypeInfoPass(Pass):
     @__handle_node
     def enter_builtin_type(self, node: ast.BuiltinType) -> None:
         """Pass handler for BuiltinType nodes."""
-        self.__collect_type_from_symbol(node)
+        self.__check_builltin_symbol(node)
+        node.name_spec.sym_type = f"builtins.{node.sym_name}"
 
     def get_type_from_instance(
         self, node: ast.AstSymbolNode, mypy_type: MypyTypes.Instance
@@ -483,6 +501,21 @@ class FuseTypeInfoPass(Pass):
                 if self_obj.type_sym_tab and isinstance(right_obj, ast.AstSymbolNode):
                     self_obj.type_sym_tab.def_insert(right_obj)
 
+        # Support adding the correct type symbol table in case of ModuleType
+        # This will only work for target=Val & target1=target2=val and
+        #   target is a moduleType
+        # it won't work in case of
+        #   - target1, target2 = Val1, Val2  <-- tuples need more attention
+        #   - target = a.b.c                 <-- will be fixed after thakee's PR
+        #   - a.b.c = val                    <-- will be fixed after thakee's PR
+        for target in node.target.items:
+            if (
+                isinstance(target, ast.Name)
+                and target.sym_type == "types.ModuleType"
+                and isinstance(node.value, ast.Name)
+            ):
+                target.type_sym_tab = node.value.type_sym_tab
+
     def expand_atom_trailer(self, node_list: list[ast.AstNode]) -> list[ast.AstNode]:
         """Expand the atom trailer object in a list of AstNode."""
         out: list[ast.AstNode] = []
@@ -552,6 +585,10 @@ class FuseTypeInfoPass(Pass):
                 type_symtab: Optional[SymbolTable] = self.ir.sym_tab
                 assert isinstance(self.ir, ast.Module)
                 assert isinstance(type_symtab, SymbolTable)
+
+                if re.match(r"builtins.(list|dict|tuple)", node_type):
+                    node_type = re.sub(r"\[.*\]", "", node_type)
+
                 for j in node_type.split("."):
                     if j == self.ir.name:
                         continue

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/import_pass.py

@@ -7,12 +7,14 @@ symbols are available for matching.
 
 import ast as py_ast
 import os
+import pathlib
 from typing import Optional
 
 
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main import SubNodeTabPass, SymTabBuildPass
+from jaclang.settings import settings
 from jaclang.utils.log import logging
 
 
@@ -105,7 +107,7 @@ class JacImportPass(Pass):
                 or test_folder == os.path.dirname(cur_file)
             ) and cur_file.endswith(".test.jac"):
                 mod = self.import_jac_mod_from_file(cur_file)
-                if mod:
+                if mod and not settings.ignore_test_annex:
                     node.test_mod.append(mod)
                     node.add_kids_right([mod], pos_update=False)
                     mod.parent = node
@@ -199,6 +201,7 @@ class PyImportPass(JacImportPass):
     def before_pass(self) -> None:
         """Only run pass if settings are set to raise python."""
         super().before_pass()
+        self.__load_builtins()
 
     def __get_current_module(self, node: ast.AstNode) -> str:
         parent = node.find_parent_of_type(ast.Module)
@@ -295,6 +298,31 @@ class PyImportPass(JacImportPass):
             raise e
         return None
 
+    def __load_builtins(self) -> None:
+        """Pyraise builtins to help with builtins auto complete."""
+        from jaclang.compiler.passes.main import PyastBuildPass
+
+        assert isinstance(self.ir, ast.Module)
+
+        file_to_raise = str(
+            pathlib.Path(os.path.dirname(__file__)).parent.parent.parent
+            / "vendor"
+            / "mypy"
+            / "typeshed"
+            / "stdlib"
+            / "builtins.pyi"
+        )
+        with open(file_to_raise, "r", encoding="utf-8") as f:
+            mod = PyastBuildPass(
+                input_ir=ast.PythonModuleAst(
+                    py_ast.parse(f.read()), mod_path=file_to_raise
+                ),
+            ).ir
+            mod.parent = self.ir
+            SubNodeTabPass(input_ir=mod, prior=self)
+            SymTabBuildPass(input_ir=mod, prior=self)
+            mod.parent = None
+
     def annex_impl(self, node: ast.Module) -> None:
         """Annex impl and test modules."""
         return None

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/py_collect_dep_pass.py

@@ -7,6 +7,8 @@ that are only relevant to actual references source from Jac code.
 from __future__ import annotations
 
 
+import os
+
 import jaclang.compiler.absyntree as ast
 from jaclang.compiler.passes import Pass
 from jaclang.settings import settings
@@ -28,11 +30,15 @@ class PyCollectDepsPass(Pass):
         if not isinstance(node, ast.AstSymbolNode):
             return
 
+        # Adding the path of the file related to the py import
         path: str = ""
         if isinstance(node, ast.ModulePath):
             if node.path:
                 path = ".".join([i.value for i in node.path])
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
+
         elif isinstance(node, ast.ModuleItem):
             imp = node.parent_of_type(ast.Import)
             mod_path_node = imp.get_all_sub_nodes(ast.ModulePath)[0]
@@ -40,6 +46,8 @@ class PyCollectDepsPass(Pass):
                 path = ".".join([i.value for i in mod_path_node.path])
             path += f".{node.name.value}"
             node.abs_path = self.ir.py_mod_dep_map.get(path)
+            if node.abs_path and os.path.isfile(node.abs_path.replace(".pyi", ".py")):
+                node.abs_path = node.abs_path.replace(".pyi", ".py")
 
         if len(node.gen.mypy_ast) == 0:
             return

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/registry_pass.py

@@ -14,6 +14,7 @@ from jaclang.compiler.constant import Constants as Con
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.semtable import SemInfo, SemRegistry
 from jaclang.runtimelib.utils import get_sem_scope
+from jaclang.settings import settings
 
 
 class RegistryPass(Pass):
@@ -23,6 +24,9 @@ class RegistryPass(Pass):
 
     def enter_module(self, node: ast.Module) -> None:
         """Create registry for each module."""
+        if settings.disable_mtllm:
+            self.terminate()
+            return None
         node.registry = SemRegistry()
         self.modules_visited.append(node)
 

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/sym_tab_build_pass.py

@@ -4,10 +4,7 @@ This pass builds the symbol table tree for the Jaseci Ast. It also adds symbols
 for globals, imports, architypes, and abilities declarations and definitions.
 """
 
-import builtins
-
 import jaclang.compiler.absyntree as ast
-from jaclang.compiler.constant import Tokens as Tok
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.symtable import SymbolTable
 
@@ -54,21 +51,6 @@ class SymTabBuildPass(Pass):
         """
         self.push_scope(node.name, node)
         self.sync_node_to_scope(node)
-        for obj in dir(builtins):
-            builtin = ast.Name(
-                file_path=node.loc.mod_path,
-                name=Tok.NAME,
-                value=str(obj),
-                line=0,
-                end_line=0,
-                col_start=0,
-                col_end=0,
-                pos_start=0,
-                pos_end=0,
-            )
-            self.sync_node_to_scope(builtin)
-            builtin.sym_tab.def_insert(builtin)
-        # self.def_insert(ast.Name.gen_stub_from_node(node.name, "root"))
 
     def exit_module(self, node: ast.Module) -> None:
         """Sub objects.

jaclang-0.7.20/jaclang/compiler/passes/main/tests/fixtures/mod_type_assign.jac

@@ -0,0 +1,7 @@
+import:jac blip;
+
+
+with entry{
+    kl = blip;
+    l1 = l2 = blip;
+}

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -70,19 +70,19 @@ class ImportPassPassTests(TestCase):
         )
         assert isinstance(build.ir, ast.Module)
         p = {
-            "math": "jaclang/jaclang/vendor/mypy/typeshed/stdlib/math.pyi",
-            "pygame_mock": "pygame_mock/__init__.py",
-            "pygame_mock.color": "pygame_mock/color.py",
-            "pygame_mock.constants": "pygame_mock/constants.py",
-            "argparse": "jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi",
-            "builtins": "jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi",
-            "pygame_mock.display": "pygame_mock/display.py",
-            "os": "jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi",
-            "genericpath": "jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi",
+            "math": r"jaclang/vendor/mypy/typeshed/stdlib/math.pyi$",
+            "pygame_mock": r"pygame_mock/__init__.pyi$",
+            "pygame_mock.color": r"pygame_mock/color.py$",
+            "pygame_mock.constants": r"pygame_mock/constants.py$",
+            "argparse": r"jaclang/vendor/mypy/typeshed/stdlib/argparse.pyi$",
+            "builtins": r"jaclang/vendor/mypy/typeshed/stdlib/builtins.pyi$",
+            "pygame_mock.display": r"pygame_mock/display.py$",
+            "os": r"jaclang/vendor/mypy/typeshed/stdlib/os/__init__.pyi$",
+            "genericpath": r"jaclang/vendor/mypy/typeshed/stdlib/genericpath.pyi$",
         }
         for i in p:
             self.assertIn(i, build.ir.py_raise_map)
-            self.assertIn(p[i], re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]))
+            self.assertRegex(re.sub(r".*fixtures/", "", build.ir.py_raise_map[i]), p[i])
 
     def test_py_raised_mods(self) -> None:
         """Basic test for pass."""

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/tests/test_type_check_pass.py

@@ -59,6 +59,6 @@ class MypyTypeCheckPassTests(TestCase):
         self.assertIn("HasVar - species - Type: builtins.str", out)
         self.assertIn("myDog - Type: type_info.Dog", out)
         self.assertIn("Body - Type: type_info.Dog.Body", out)
-        self.assertEqual(out.count("Type: builtins.str"), 28)
+        self.assertEqual(out.count("Type: builtins.str"), 34)
         for i in lis:
             self.assertNotIn(i, out)

jaclang-0.7.20/jaclang/compiler/passes/main/tests/test_typeinfo_pass.py

@@ -0,0 +1,29 @@
+"""Test pass module."""
+
+from jaclang.compiler.compile import jac_file_to_pass
+from jaclang.compiler.passes.main.fuse_typeinfo_pass import FuseTypeInfoPass
+from jaclang.compiler.passes.main.schedules import py_code_gen_typed
+from jaclang.utils.test import TestCase
+
+
+class TestFuseTypeInfo(TestCase):
+    """Test FuseTypeInfoPass module."""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        return super().setUp()
+
+    def test_mod_type_assign(self) -> None:
+        """Test module type assignment."""
+        gen_ast = jac_file_to_pass(
+            self.fixture_abs_path("mod_type_assign.jac"),
+            FuseTypeInfoPass,
+            schedule=py_code_gen_typed,
+        ).ir.pp()
+        type_info_list = [
+            "kl - Type: types.ModuleType,  SymbolTable: blip",
+            "l1 - Type: types.ModuleType,  SymbolTable: blip",
+            "l2 - Type: types.ModuleType,  SymbolTable: blip",
+        ]
+        for type_info in type_info_list:
+            self.assertIn(type_info, str(gen_ast))

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/main/type_check_pass.py

@@ -51,10 +51,10 @@ class JacTypeCheckPass(Pass):
         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"
-            )
+            # str( # TODO: Remove me, this was the wrong way to point to stubs
+            #     pathlib.Path(os.path.dirname(__file__)).parent.parent.parent.parent
+            #     / "stubs"
+            # )
         ]
         if top_module_path != "":
             options.mypy_path.append(top_module_path)

{jaclang-0.7.18 → jaclang-0.7.20}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -126,11 +126,14 @@ class JacFormatPass(Pass):
         last_element = None
         for counter, i in enumerate(node.body):
             counter += 1
+            if last_element and (
+                i.loc.first_line - last_element.loc.last_line > 1
+                and not last_element.gen.jac.endswith("\n\n")
+            ):
+                self.emit_ln(node, "")
             if isinstance(i, ast.Import):
                 self.emit_ln(node, i.gen.jac)
             else:
-                if isinstance(last_element, ast.Import):
-                    self.emit_ln(node, "")
                 if last_element and (
                     isinstance(i, ast.Architype)
                     and isinstance(last_element, ast.Architype)
@@ -140,21 +143,6 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                 self.emit_ln(node, i.gen.jac)
 
-                if counter <= len(node.body) - 1:
-                    if (
-                        isinstance(i, ast.Ability)
-                        and isinstance(node.body[counter], ast.Ability)
-                        and i.gen.jac.endswith(";")
-                        or (
-                            isinstance(i, ast.Architype)
-                            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:
-                        self.emit_ln(node, "")
             last_element = i
 
     def exit_global_vars(self, node: ast.GlobalVars) -> None:
@@ -222,6 +210,20 @@ class JacFormatPass(Pass):
         """
         prev_token = None
         for stmt in node.kid:
+            line_emiited = False
+            if prev_token and stmt.loc.first_line - prev_token.loc.last_line > 1:
+                if (
+                    stmt.kid
+                    and isinstance(stmt.kid[-1], ast.SubNodeList)
+                    and not isinstance(stmt.kid[-1].kid[-1], ast.CommentToken)
+                ):
+                    self.emit(node, "")
+
+                else:
+                    line_emiited = True
+                    self.indent_level -= 1
+                    self.emit_ln(node, "")
+                    self.indent_level += 1
             if isinstance(node.parent, (ast.EnumDef, ast.Enum)) and stmt.gen.jac == ",":
                 self.indent_level -= 1
                 self.emit_ln(node, f"{stmt.gen.jac}")
@@ -266,9 +268,10 @@ class JacFormatPass(Pass):
                             self.indent_level += 1
                         else:
                             self.emit(node, f" {stmt.gen.jac}")
-                        self.indent_level -= 1
-                        self.emit_ln(node, "")
-                        self.indent_level += 1
+                        if not line_emiited:
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
                     else:
                         if not node.gen.jac.endswith("\n"):
                             self.indent_level -= 1
@@ -279,12 +282,21 @@ class JacFormatPass(Pass):
                         if prev_token and isinstance(prev_token, ast.Ability):
                             self.emit(node, f"{stmt.gen.jac}")
                         else:
-                            self.emit(node, stmt.gen.jac)
-                            if not stmt.gen.jac.endswith("postinit;"):
+                            token_before = self.token_before(stmt)
+                            if (
+                                token_before is not None
+                                and isinstance(token_before, ast.Token)
+                                and token_before.name == Tok.LBRACE
+                                and stmt.loc.first_line - token_before.loc.last_line > 1
+                            ):
                                 self.indent_level -= 1
-                                self.emit_ln(stmt, "")
                                 self.emit_ln(node, "")
                                 self.indent_level += 1
+                            self.emit(node, stmt.gen.jac)
+                            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 == "=":
@@ -304,10 +316,29 @@ class JacFormatPass(Pass):
                 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
+                if (
+                    not isinstance(prev_token.kid[-1], ast.CommentToken)
+                    and not line_emiited
+                ):
+                    if (
+                        prev_token.kid
+                        and isinstance(prev_token.kid[-1], ast.SubNodeList)
+                        and isinstance(prev_token.kid[-1].kid[-1], ast.CommentToken)
+                    ):
+                        if (
+                            prev_token
+                            and stmt.loc.first_line - prev_token.kid[-1].kid[-1].line_no
+                            > 1
+                        ):
+                            self.indent_level -= 1
+                            self.emit_ln(node, "")
+                            self.indent_level += 1
+                        else:
+                            self.emit(node, "")
+                    else:
+                        self.indent_level -= 1
+                        self.emit_ln(node, "")
+                        self.indent_level += 1
                 self.emit(node, stmt.gen.jac)
             else:
                 if prev_token and prev_token.gen.jac.strip() == "{":
@@ -907,8 +938,6 @@ 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:
@@ -958,7 +987,6 @@ 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"):

jaclang-0.7.20/jaclang/compiler/passes/tool/tests/fixtures/general_format_checks/line_spacing.jac

@@ -0,0 +1,57 @@
+import:py math;
+
+glob RAD = 5;
+
+glob DIA = 10;
+
+# this comment is for walker
+
+walker decorator_walk {
+    can hash(func: Any) {
+        can inner(a: Any) {
+            print(("#" * 20));
+            func(a);
+            print(("#" * 20));
+        }
+        return inner;
+    }
+
+    can exclaim(func: Any) {
+        can inner(b: Any) {
+            print(("!" * 20));
+            func(b);
+            print(("!" * 20));
+        }
+        return inner;
+    }
+
+    can tilde(func: Any) {
+        can inner(c: Any) {
+            print(("~" * 20));
+            func(c);
+            print(("~" * 20));
+        }
+        return inner;
+    }
+
+    can greeter(name: Any) {
+        print("Hello, " + name + "!");
+    }
+
+    # Entry point for the walker
+
+    can start with entry {
+
+        # Apply decorators to greeter
+        decorated_greeter = hash(exclaim(tilde(greeter)));
+
+        # Call the decorated greeter function
+        decorated_greeter("World");
+
+        # this is another comment
+    }
+}
+
+with entry {
+    root spawn decorator_walk();
+}