jaclang 0.7.13__tar.gz → 0.7.14__tar.gz

{jaclang-0.7.13 → jaclang-0.7.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.13
+Version: 0.7.14
 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

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/absyntree.py

@@ -621,6 +621,7 @@ class Module(AstDocNode):
         doc: Optional[String],
         body: Sequence[ElementStmt | String | EmptyToken],
         is_imported: bool,
+        terminals: list[Token],
         kid: Sequence[AstNode],
         stub_only: bool = False,
         registry: Optional[SemRegistry] = None,
@@ -635,6 +636,7 @@ class Module(AstDocNode):
         self.test_mod: list[Module] = []
         self.mod_deps: dict[str, Module] = {}
         self.registry = registry
+        self.terminals: list[Token] = terminals
         AstNode.__init__(self, kid=kid)
         AstDocNode.__init__(self, doc=doc)
 
@@ -642,15 +644,15 @@ class Module(AstDocNode):
     def annexable_by(self) -> Optional[str]:
         """Get annexable by."""
         if not self.stub_only and (
-            self.loc.mod_path.endswith("impl.jac")
-            or self.loc.mod_path.endswith("test.jac")
+            self.loc.mod_path.endswith(".impl.jac")
+            or self.loc.mod_path.endswith(".test.jac")
         ):
             head_mod_name = self.name.split(".")[0]
             potential_path = os.path.join(
                 os.path.dirname(self.loc.mod_path),
                 f"{head_mod_name}.jac",
             )
-            if os.path.exists(potential_path):
+            if os.path.exists(potential_path) and potential_path != self.loc.mod_path:
                 return potential_path
             annex_dir = os.path.split(os.path.dirname(self.loc.mod_path))[-1]
             if annex_dir.endswith(".impl") or annex_dir.endswith(".test"):
@@ -661,7 +663,10 @@ class Module(AstDocNode):
                     os.path.dirname(os.path.dirname(self.loc.mod_path)),
                     f"{head_mod_name}.jac",
                 )
-                if os.path.exists(potential_path):
+                if (
+                    os.path.exists(potential_path)
+                    and potential_path != self.loc.mod_path
+                ):
                     return potential_path
         return None
 

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/parser.py

@@ -56,6 +56,7 @@ class JacParser(Pass):
             source=self.source,
             doc=None,
             body=[],
+            terminals=[],
             is_imported=False,
             kid=[ast.EmptyToken()],
         )
@@ -120,6 +121,7 @@ class JacParser(Pass):
             """Initialize transformer."""
             super().__init__(*args, **kwargs)
             self.parse_ref = parser
+            self.terminals: list[ast.Token] = []
 
         def ice(self) -> Exception:
             """Raise internal compiler error."""
@@ -160,6 +162,7 @@ class JacParser(Pass):
                 doc=doc,
                 body=body,
                 is_imported=False,
+                terminals=self.terminals,
                 kid=kid if len(kid) else [ast.EmptyToken()],
             )
             return self.nu(mod)
@@ -3983,4 +3986,5 @@ class JacParser(Pass):
                     err.line = ret.loc.first_line
                     err.column = ret.loc.col_start
                     raise err
+            self.terminals.append(ret)
             return self.nu(ret)

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/main/import_pass.py

@@ -182,6 +182,7 @@ class JacImportPass(Pass):
                 source=ast.JacSource("", mod_path=target),
                 doc=None,
                 body=[],
+                terminals=[],
                 is_imported=False,
                 stub_only=True,
                 kid=[ast.EmptyToken()],

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/main/pyast_gen_pass.py

@@ -434,14 +434,7 @@ class PyastGenPass(Pass):
         body: SubNodeList[CodeBlockStmt],
         doc: Optional[String],
         """
-        if node.doc:
-            doc = self.sync(ast3.Expr(value=node.doc.gen.py_ast[0]), jac_node=node.doc)
-            if isinstance(node.body.gen.py_ast, list):
-                node.gen.py_ast = [doc] + node.body.gen.py_ast
-            else:
-                raise self.ice()
-        else:
-            node.gen.py_ast = node.body.gen.py_ast
+        node.gen.py_ast = self.resolve_stmt_block(node.body, doc=node.doc)
         if node.name:
             node.gen.py_ast = [
                 self.sync(

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/main/pyast_load_pass.py

@@ -124,6 +124,7 @@ class PyastBuildPass(Pass[ast.PythonModuleAst]):
             source=ast.JacSource("", mod_path=self.mod_path),
             doc=doc_str,
             body=valid[1:] if valid and isinstance(valid[0], ast.String) else valid,
+            terminals=[],
             is_imported=False,
             kid=valid,
         )

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/main/tests/test_import_pass.py

@@ -47,8 +47,12 @@ class ImportPassPassTests(TestCase):
         state = jac_file_to_pass(
             self.fixture_abs_path("incautoimpl.jac"), JacImportPass
         )
+        count = 0
         for i in state.ir.get_all_sub_nodes(ast.Module):
-            self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+            if i.name != "autoimpl":
+                count += 1
+                self.assertEqual(i.annexable_by, self.fixture_abs_path("autoimpl.jac"))
+        self.assertEqual(count, 3)
 
     def test_py_resolve_list(self) -> None:
         """Basic test for pass."""

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/tool/fuse_comments_pass.py

@@ -27,7 +27,12 @@ class FuseCommentsPass(Pass):
         """Insert comment tokens into all_tokens."""
         comment_stream = iter(self.comments)  # Iterator for comments
         code_stream = iter(self.all_tokens)  # Iterator for code tokens
-        new_stream: list[ast.AstNode] = []  # New stream to hold ordered tokens
+        new_stream: list[ast.Token] = []  # New stream to hold ordered tokens
+
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice(
+                f"FuseCommentsPass can only be run on a Module, not a {type(self.ir)}"
+            )
 
         try:
             next_comment = next(comment_stream)  # Get the first comment
@@ -39,12 +44,20 @@ class FuseCommentsPass(Pass):
         except StopIteration:
             next_code = None
 
+        if next_comment and (not next_code or is_comment_next(next_comment, next_code)):
+            self.ir.terminals.insert(0, next_comment)
+
         while next_comment or next_code:
             if next_comment and (
                 not next_code or is_comment_next(next_comment, next_code)
             ):
                 # Add the comment to the new stream
+                last_tok = new_stream[-1] if len(new_stream) else None
                 new_stream.append(next_comment)
+                if last_tok:
+                    self.ir.terminals.insert(
+                        self.ir.terminals.index(last_tok) + 1, next_comment
+                    )
                 try:
                     next_comment = next(comment_stream)
                 except StopIteration:
@@ -70,7 +83,6 @@ class FuseCommentsPass(Pass):
                         parent_kids.insert(insert_index, token)
                         prev_token.parent.set_kids(parent_kids)
                     else:
-                        prev_token.pp()
                         raise self.ice(
                             "Token without parent in AST should be impossible"
                         )

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/compiler/passes/tool/jac_formatter_pass.py

@@ -27,6 +27,22 @@ class JacFormatPass(Pass):
         node.gen.jac = ""
         super().enter_node(node)
 
+    def token_before(self, node: ast.Token) -> Optional[ast.Token]:
+        """Token before."""
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("IR must be module. Impossible")
+        if self.ir.terminals.index(node) == 0:
+            return None
+        return self.ir.terminals[self.ir.terminals.index(node) - 1]
+
+    def token_after(self, node: ast.Token) -> Optional[ast.Token]:
+        """Token after."""
+        if not isinstance(self.ir, ast.Module):
+            raise self.ice("IR must be module. Impossible")
+        if self.ir.terminals.index(node) == len(self.ir.terminals) - 1:
+            return None
+        return self.ir.terminals[self.ir.terminals.index(node) + 1]
+
     def indent_str(self) -> str:
         """Return string for indent."""
         return " " * self.indent_size * self.indent_level
@@ -220,17 +236,11 @@ class JacFormatPass(Pass):
                     self.emit_ln(node, "")
                     self.indent_level += 1
                 if stmt.name == Tok.LBRACE:
-                    next_kid = node.kid[i + 1]
-                    if isinstance(next_kid, ast.CommentToken) and next_kid.is_inline:
-                        self.emit(node, f" {stmt.value}")
-                    else:
-                        self.emit(node, f" {stmt.value}")
+                    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() == "{":
-                        self.emit_ln(node, stmt.gen.jac.strip())
-                    elif (
+                    if (stmt.parent and stmt.parent.gen.jac.strip() == "{") or (
                         stmt.parent
                         and stmt.parent.parent
                         and isinstance(
@@ -251,9 +261,7 @@ class JacFormatPass(Pass):
                         ):
                             self.emit(node, f" {stmt.value}")
                         elif not (node.gen.jac).endswith("\n"):
-                            self.indent_level -= 1
                             self.emit_ln(node, "")
-                            self.indent_level += 1
                             self.emit(node, f"{stmt.value}")
                         else:
                             self.emit(node, f"{stmt.value}")
@@ -1392,8 +1400,12 @@ class JacFormatPass(Pass):
                     self.emit(node, i.gen.jac)
                     if isinstance(prev_token, ast.Semi):
                         self.emit_ln(node, "")
+                elif (tok := self.token_before(i)) and (i.line_no - tok.line_no > 1):
+                    self.emit_ln(node, "")
+                    self.emit_ln(node, i.gen.jac)
                 else:
                     self.emit_ln(node, i.gen.jac)
+                    self.emit_ln(node, "")
             elif isinstance(i, ast.Semi):
                 self.emit(node, f"{i.gen.jac} ")
             elif isinstance(i, ast.SubNodeList) and i.gen.jac.startswith("@"):

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/langserve/engine.py

@@ -14,7 +14,6 @@ from jaclang.compiler.parser import JacParser
 from jaclang.compiler.passes import Pass
 from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
-from jaclang.compiler.passes.transform import Alert
 from jaclang.langserve.utils import (
     collect_all_symbols_in_scope,
     collect_symbols,
@@ -39,13 +38,11 @@ class ModuleInfo:
     def __init__(
         self,
         ir: ast.Module,
-        errors: list[Alert],
-        warnings: list[Alert],
-        parent: Optional[ModuleInfo] = None,
+        impl_parent: Optional[ModuleInfo] = None,
     ) -> None:
         """Initialize module info."""
         self.ir = ir
-        self.parent: Optional[ModuleInfo] = parent
+        self.impl_parent: Optional[ModuleInfo] = impl_parent
         self.sem_tokens: list[int] = self.gen_sem_tokens()
 
     @property
@@ -162,29 +159,17 @@ class JacLangServer(LanguageServer):
         if not isinstance(build.ir, ast.Module):
             self.log_error("Error with module build.")
             return
-        self.modules[file_path] = ModuleInfo(
-            ir=build.ir,
-            errors=[
-                i
-                for i in build.errors_had
-                if i.loc.mod_path == uris.to_fs_path(file_path)
-            ],
-            warnings=[
-                i
-                for i in build.warnings_had
-                if i.loc.mod_path == uris.to_fs_path(file_path)
-            ],
+        keep_parent = (
+            self.modules[file_path].impl_parent if file_path in self.modules else None
         )
+        self.modules[file_path] = ModuleInfo(ir=build.ir, impl_parent=keep_parent)
         for p in build.ir.mod_deps.keys():
             uri = uris.from_fs_path(p)
-            self.modules[uri] = ModuleInfo(
-                ir=build.ir.mod_deps[p],
-                errors=[i for i in build.errors_had if i.loc.mod_path == p],
-                warnings=[i for i in build.warnings_had if i.loc.mod_path == p],
-            )
-            self.modules[uri].parent = (
-                self.modules[file_path] if file_path != uri else None
-            )
+            if file_path != uri:
+                self.modules[uri] = ModuleInfo(
+                    ir=build.ir.mod_deps[p],
+                    impl_parent=self.modules[file_path],
+                )
 
     def quick_check(self, file_path: str) -> bool:
         """Rebuild a file."""
@@ -206,6 +191,12 @@ class JacLangServer(LanguageServer):
         """Rebuild a file and its dependencies."""
         try:
             document = self.workspace.get_text_document(file_path)
+            if file_path in self.modules and (
+                parent := self.modules[file_path].impl_parent
+            ):
+                return self.deep_check(
+                    uris.from_fs_path(parent.ir.loc.mod_path), annex_view=file_path
+                )
             build = jac_str_to_pass(
                 jac_str=document.source,
                 file_path=document.path,
@@ -216,6 +207,7 @@ class JacLangServer(LanguageServer):
                 return self.deep_check(
                     uris.from_fs_path(discover), annex_view=file_path
                 )
+
             self.publish_diagnostics(
                 file_path,
                 gen_diagnostics(

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/langserve/tests/test_server.py

@@ -137,6 +137,30 @@ class TestJacLangServer(TestCase):
             str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
         )
 
+    def test_go_to_definition_method_manual_impl(self) -> None:
+        """Test that the go to definition is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        decldef_file = uris.from_fs_path(
+            self.examples_abs_path("micro/decl_defs_impl.jac")
+        )
+        lsp.deep_check(decldef_file)
+        self.assertNotIn(
+            "decl_defs_main.jac:8:8-8:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+        )
+        decldef_main_file = uris.from_fs_path(
+            self.examples_abs_path("micro/decl_defs_main.jac")
+        )
+        lsp.deep_check(decldef_main_file)
+        lsp.deep_check(decldef_file)
+        self.assertIn(
+            "decl_defs_main.jac:8:8-8:17",
+            str(lsp.get_definition(decldef_file, lspt.Position(2, 24))),
+        )
+
     def test_test_annex(self) -> None:
         """Test that the server doesn't run if there is a syntax error."""
         lsp = JacLangServer()

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/plugin/default.py

@@ -260,6 +260,8 @@ class JacFeatureDefaults:
                 base, mod_name = os.path.split(filepath)
                 base = base if base else "./"
                 mod_name = mod_name[:-4]
+                if mod_name.endswith(".test"):
+                    mod_name = mod_name[:-5]
                 JacTestCheck.reset()
                 Jac.jac_import(target=mod_name, base_path=base)
                 JacTestCheck.run_test(xit, maxfail, verbose)

jaclang-0.7.14/jaclang/tests/fixtures/blankwithentry.jac

@@ -0,0 +1,3 @@
+with entry:__main__ {}
+
+with entry {print("i work");}

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/tests/test_language.py

@@ -840,3 +840,12 @@ class JacLanguageTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertIn("[x()]", stdout_value)
+
+    def test_blank_with_entry(self) -> None:
+        """Test importing python."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("blankwithentry", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertIn("i work", stdout_value)

{jaclang-0.7.13 → jaclang-0.7.14}/jaclang/tests/test_man_code.py

@@ -124,6 +124,23 @@ class JacCliTests(TestCase):
         # Assertions or verifications
         self.assertIn("Ran 3 tests", stderr_value)
 
+    def test_pure_circle_jac_test(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        stdio_block = io.StringIO()
+        sys.stderr = captured_output
+        sys.stdout = stdio_block
+
+        # Execute the function
+        with suppress(SystemExit):
+            cli.test(self.examples_abs_path("manual_code/circle_pure.test.jac"))
+
+        sys.stderr = sys.__stderr__
+        sys.stdout = sys.__stdout__
+        stderr_value = captured_output.getvalue()
+        # Assertions or verifications
+        self.assertIn("Ran 3 tests", stderr_value)
+
     def test_jac_name_in_sys_mods(self) -> None:
         """Basic test for pass."""
         captured_output = io.StringIO()

{jaclang-0.7.13 → jaclang-0.7.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jaclang"
-version = "0.7.13"
+version = "0.7.14"
 description = "Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding."
 authors = ["Jason Mars <jason@jaseci.org>"]
 license = "MIT"