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

jaclang/compiler/symtable.py

@@ -137,7 +137,7 @@ class SymbolTable:
                 return k
         return None
 
-    def push_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable:
+    def push_kid_scope(self, name: str, key_node: ast.AstNode) -> SymbolTable:
         """Push a new scope onto the symbol table."""
         self.kid.append(SymbolTable(name, key_node, self))
         return self.kid[-1]
@@ -205,16 +205,21 @@ class SymbolTable:
         for i in node_list:
             if cur_sym_tab is None:
                 break
-            cur_sym_tab = (
-                lookup.decl.sym_tab
-                if (
-                    lookup := self.use_lookup(
-                        i,
-                        sym_table=cur_sym_tab,
-                    )
-                )
-                else None
-            )
+            lookup = self.use_lookup(i, sym_table=cur_sym_tab)
+            if lookup:
+                cur_sym_tab = lookup.decl.sym_tab
+
+                # check if the symbol table name is not the same as symbol name
+                # then try to find a child scope with the same name
+                # This is used to get the scope in case of
+                #      import:py math;
+                #      b = math.floor(1.7);
+                if cur_sym_tab.name != i.sym_name:
+                    t = cur_sym_tab.find_scope(i.sym_name)
+                    if t:
+                        cur_sym_tab = t
+            else:
+                cur_sym_tab = None
 
     def update_py_ctx_for_def(self, node: ast.AstSymbolNode) -> None:
         """Update python context for definition."""

jaclang/compiler/tests/test_importer.py

@@ -5,29 +5,37 @@ import sys
 
 from jaclang import jac_import
 from jaclang.cli import cli
-from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.machine import JacMachine, JacProgram
 from jaclang.utils.test import TestCase
 
 
 class TestLoader(TestCase):
     """Test Jac self.prse."""
 
-    def setUp(self) -> None:
-        """Set up test."""
-        return super().setUp()
-
     def test_import_basic_python(self) -> None:
         """Test basic self loading."""
-        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
+        JacMachine(self.fixture_abs_path(__file__)).attach_program(
+            JacProgram(mod_bundle=None, bytecode=None)
+        )
         (h,) = jac_import("fixtures.hello_world", base_path=__file__)
         self.assertEqual(h.hello(), "Hello World!")  # type: ignore
+        JacMachine.detach()
 
     def test_modules_correct(self) -> None:
         """Test basic self loading."""
-        Jac.context().init_memory(base_path=self.fixture_abs_path(__file__))
+        JacMachine(self.fixture_abs_path(__file__)).attach_program(
+            JacProgram(mod_bundle=None, bytecode=None)
+        )
         jac_import("fixtures.hello_world", base_path=__file__)
-        self.assertIn("module 'fixtures.hello_world'", str(sys.modules))
-        self.assertIn("/tests/fixtures/hello_world.jac", str(sys.modules))
+        self.assertIn(
+            "module 'fixtures.hello_world'",
+            str(JacMachine.get().loaded_modules),
+        )
+        self.assertIn(
+            "/tests/fixtures/hello_world.jac",
+            str(JacMachine.get().loaded_modules),
+        )
+        JacMachine.detach()
 
     def test_jac_py_import(self) -> None:
         """Basic test for pass."""

jaclang/langserve/engine.py

@@ -16,6 +16,7 @@ from jaclang.compiler.passes.main.schedules import py_code_gen_typed
 from jaclang.compiler.passes.tool import FuseCommentsPass, JacFormatPass
 from jaclang.langserve.sem_manager import SemTokManager
 from jaclang.langserve.utils import (
+    add_unique_text_edit,
     collect_all_symbols_in_scope,
     create_range,
     find_deepest_symbol_node_at_pos,
@@ -127,6 +128,15 @@ class JacLangServer(LanguageServer):
                     build.warnings_had,
                 ),
             )
+            if annex_view:
+                self.publish_diagnostics(
+                    file_path,
+                    gen_diagnostics(
+                        file_path,
+                        build.errors_had,
+                        build.warnings_had,
+                    ),
+                )
             self.log_py(f"PROFILE: Deep check took {time.time() - start_time} seconds.")
             return len(build.errors_had) == 0
         except Exception as e:
@@ -404,6 +414,35 @@ class JacLangServer(LanguageServer):
             return list_of_references
         return []
 
+    def rename_symbol(
+        self, file_path: str, position: lspt.Position, new_name: str
+    ) -> Optional[lspt.WorkspaceEdit]:
+        """Rename a symbol in a file."""
+        if file_path not in self.modules:
+            return None
+        index1 = find_index(
+            self.modules[file_path].sem_manager.sem_tokens,
+            position.line,
+            position.character,
+        )
+        if index1 is None:
+            return None
+        node_selected = self.modules[file_path].sem_manager.static_sem_tokens[index1][3]
+        if node_selected and node_selected.sym:
+            changes: dict[str, list[lspt.TextEdit]] = {}
+            for node in [
+                *node_selected.sym.uses,
+                node_selected.sym.defn[0],
+            ]:
+                key = uris.from_fs_path(node.loc.mod_path)
+                new_edit = lspt.TextEdit(
+                    range=create_range(node.loc),
+                    new_text=new_name,
+                )
+                add_unique_text_edit(changes, key, new_edit)
+            return lspt.WorkspaceEdit(changes=changes)
+        return None
+
     def get_semantic_tokens(self, file_path: str) -> lspt.SemanticTokens:
         """Return semantic tokens for a file."""
         if file_path not in self.modules:

jaclang/langserve/server.py

@@ -17,8 +17,14 @@ server = JacLangServer()
 
 
 @server.feature(lspt.TEXT_DOCUMENT_DID_OPEN)
-@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
 async def did_open(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
+    """Check syntax on change."""
+    ls.deep_check(params.text_document.uri)
+    ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
+
+
+@server.feature(lspt.TEXT_DOCUMENT_DID_SAVE)
+async def did_save(ls: JacLangServer, params: lspt.DidOpenTextDocumentParams) -> None:
     """Check syntax on change."""
     await ls.launch_deep_check(params.text_document.uri)
     ls.lsp.send_request(lspt.WORKSPACE_SEMANTIC_TOKENS_REFRESH)
@@ -132,6 +138,15 @@ def references(ls: JacLangServer, params: lspt.ReferenceParams) -> list[lspt.Loc
     return ls.get_references(params.text_document.uri, params.position)
 
 
+@server.feature(lspt.TEXT_DOCUMENT_RENAME)
+def rename(
+    ls: JacLangServer, params: lspt.RenameParams
+) -> Optional[lspt.WorkspaceEdit]:
+    """Rename symbol."""
+    ls.log_warning("Auto Rename is Experimental, Please use with caution.")
+    return ls.rename_symbol(params.text_document.uri, params.position, params.new_name)
+
+
 @server.feature(
     lspt.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
     lspt.SemanticTokensLegend(

jaclang/langserve/tests/fixtures/rename.jac

@@ -0,0 +1,30 @@
+can foo;
+
+
+
+:can:foo{
+    print("foo");
+}
+
+
+obj out{
+    has cnt :int;
+    can bar;
+    can baz;
+}
+
+
+:obj:out:can:bar{
+    print("bar");
+}
+
+:obj:out:can:baz{
+    print("baz");
+}
+
+with entry{
+    foo();
+    new = out();
+    new.cnt;
+    out(1).bar();
+}

jaclang/langserve/tests/test_server.py

@@ -201,6 +201,62 @@ class TestJacLangServer(TestCase):
                     str(lsp.get_definition(import_file, lspt.Position(line, char))),
                 )
 
+    def test_go_to_definition_foolme(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
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (6, 39, "/pygame_mock/__init__.py:2:0-2:0"),
+            (6, 45, "/pygame_mock/constants.py:3:0-4:1"),
+            (7, 31, "/pygame_mock/__init__.py:2:0-2:0"),
+            (7, 35, "/pygame_mock/constants.py:3:0-4:1"),
+            (20, 51, "/py_imp_test.jac:6:4-6:11"),
+            (20, 64, "/pygame_mock/constants.py:4:3-4:15"),
+            (21, 48, "/py_imp_test.jac:10:4-10:6"),
+            (21, 58, "/py_imp_test.jac:11:8-11:15"),
+            (21, 68, "/pygame_mock/constants.py:4:3-4:15"),
+            (23, 58, "/pygame_mock/constants.py:4:3-4:15"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
+    def test_go_to_definition_index_expr(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
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path("../../../../jaclang/tests/fixtures/index_slice.jac")
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (23, 20, "index_slice.jac:2:8-2:13"),
+            (24, 24, "index_slice.jac:2:8-2:13"),
+            (27, 33, "index_slice.jac:2:8-2:13"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                print(str(lsp.get_definition(import_file, lspt.Position(line, char))))
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
     def test_sem_tokens(self) -> None:
         """Test that the Semantic Tokens are generated correctly."""
         lsp = JacLangServer()
@@ -214,7 +270,7 @@ class TestJacLangServer(TestCase):
             ("<JacSemTokenType.VARIABLE: 8>, <JacSemTokenModifier.READONLY: 4>", 12),
             (
                 "<JacSemTokenType.PROPERTY: 9>, <JacSemTokenModifier.DEFINITION: 2>,",
-                19,
+                21,
             ),
             (
                 "<JacSemTokenType.PARAMETER: 7>, <JacSemTokenModifier.DECLARATION: 1>,",
@@ -232,7 +288,6 @@ class TestJacLangServer(TestCase):
                 3,
             ),
         ]
-        print(str(sem_list))
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
@@ -351,3 +406,162 @@ class TestJacLangServer(TestCase):
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
             for expected in expected_refs:
                 self.assertIn(expected, references)
+
+    def test_py_type__definition(self) -> None:
+        """Test that the go to definition is correct for pythoon imports."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+        import_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(import_file)
+        positions = [
+            (19, 29, "pygame_mock/color.py:0:0-2:4"),
+            (3, 17, "/pygame_mock/__init__.py:0:0-0:0"),
+            (20, 45, "pygame_mock/color.py:0:0-2:4"),
+            (19, 77, "mock/constants.py:4:3-4:15"),
+            (26, 28, "mock/display.py:0:0-1:7"),
+            (24, 22, "/argparse.pyi:124:0-249:13"),
+            (19, 74, "pygame_mock/constants.py:4:3-4:15"),
+            (27, 17, "/stdlib/os/__init__.pyi:50:0-50:3"),
+        ]
+
+        for line, char, expected in positions:
+            with self.subTest(line=line, char=char):
+                self.assertIn(
+                    expected,
+                    str(lsp.get_definition(import_file, lspt.Position(line, char))),
+                )
+
+    def test_py_type__references(self) -> None:
+        """Test that the go to definition is correct for pythoon imports."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../../jaclang/compiler/passes/main/tests/fixtures/py_imp_test.jac"
+            )
+        )
+        lsp.deep_check(circle_file)
+        test_cases = [
+            (
+                2,
+                21,
+                [
+                    ":6:21-6:32",
+                    ":7:11-7:22",
+                    ":11:25-11:36",
+                    ":12:15-12:26",
+                    ":18:33-18:44",
+                    "19:46-19:57",
+                    ":19:8-19:19",
+                    ":19:46-19:57",
+                    ":20:8-20:19",
+                    "21:8-21:19,",
+                    "23:8-23:19",
+                    ":26:4-26:15",
+                ],
+            ),
+            (
+                19,
+                63,
+                [
+                    "6:33-6:42",
+                    "7:23-7:32",
+                    "18:45-18:54",
+                    "19:58-19:67",
+                    "11:37-11:46",
+                    "12:27-12:36",
+                ],
+            ),
+            (
+                24,
+                53,
+                [
+                    "24:42-24:56",
+                    "24:16-24:30",
+                    "argparse.pyi:334:21-334:35",
+                    "argparse.pyi:163:29-163:43",
+                    "argparse.pyi:32:52-32:66",
+                ],
+            ),
+        ]
+        for line, char, expected_refs in test_cases:
+            references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
+            for expected in expected_refs:
+                self.assertIn(expected, references)
+
+    def test_rename_symbol(self) -> None:
+        """Test that the rename is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(self.fixture_abs_path("circle.jac"))
+        lsp.deep_check(circle_file)
+        test_cases = [
+            (
+                20,
+                14,
+                "ShapeKind",
+                "27:20-27:29,",
+                "36:19-36:28",
+                "75:26-75:35",
+                "20:5-20:14",
+            ),
+            (12, 34, "circleRadius", "12:21-12:27", "12:30-12:36", "11:19-11:25"),
+            (62, 14, "target_area", "65:43-65:56", "70:32-70:45", "62:5-62:18"),
+            (57, 33, "type_of_shape", "75:12-75:22", "27:8-27:18,", "57:23-57:33"),
+        ]
+        for tup in test_cases:
+            line, char, new_name, *expected_refs = tup
+            references = str(
+                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
+            )
+            for expected in expected_refs:
+                self.assertIn(expected, references)
+
+    def test_rename_uses(self) -> None:
+        """Test that the rename is correct."""
+        lsp = JacLangServer()
+        workspace_path = self.fixture_abs_path("")
+        workspace = Workspace(workspace_path, lsp)
+        lsp.lsp._workspace = workspace
+
+        circle_file = uris.from_fs_path(self.fixture_abs_path("rename.jac"))
+        lsp.deep_check(circle_file)
+        # fmt: off
+        test_cases = [
+            (0, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (4, 6, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (25, 7, "func", "25:4-25:7", "0:4-0:7", "4:5-4:8",),
+            (10, 10, "canBar", "27:8-27:11", "10:8-10:11"),
+            (27, 9, "canBar", "27:8-27:11", "10:8-10:11"),
+            (9, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (26, 11, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (16, 7, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (28, 6, "canBar", "26:10-26:13", "28:4-28:7", "16:5-16:8", "9:4-9:7"),
+            (11, 10, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (16, 14, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (28, 13, "canBar", "11:8-11:11", "16:13-16:16", "28:11-28:14"),
+            (12, 10, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (20, 14, "canBaz", "12:8-12:11", "20:13-20:16"),
+            (26, 6, "count", "27:4-27:7", "26:4-26:7"),
+            (27, 5, "count", "27:4-27:7", "26:4-26:7"),
+        ]
+        # fmt: on
+        for tup in test_cases:
+            line, char, new_name, *expected_refs = tup
+            references = str(
+                lsp.rename_symbol(circle_file, lspt.Position(line, char), new_name)
+            )
+            for expected in expected_refs:
+                self.assertIn(expected, references)

jaclang/langserve/utils.py

@@ -273,7 +273,9 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind:
     )
 
 
-def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
+def get_mod_path(
+    mod_path: ast.ModulePath, name_node: ast.Name
+) -> str | None:  # TODO: This should go away
     """Get path for a module import name."""
     ret_target = None
     if mod_path.parent and (
@@ -294,7 +296,7 @@ def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None:
                 else ""
             )
         else:
-            temporary_path_str = mod_path.path_str
+            temporary_path_str = mod_path.dot_path_str
         sys.path.append(os.path.dirname(mod_path.loc.mod_path))
         spec = importlib.util.find_spec(temporary_path_str)
         sys.path.remove(os.path.dirname(mod_path.loc.mod_path))
@@ -625,3 +627,20 @@ def get_line_of_code(line_number: int, lines: list[str]) -> Optional[tuple[str,
             else first_non_space
         )
     return None
+
+
+def add_unique_text_edit(
+    changes: dict[str, list[lspt.TextEdit]], key: str, new_edit: lspt.TextEdit
+) -> None:
+    """Add a new text edit to the changes dictionary if it is unique."""
+    if key not in changes:
+        changes[key] = [new_edit]
+    else:
+        for existing_edit in changes[key]:
+            if (
+                existing_edit.range.start == new_edit.range.start
+                and existing_edit.range.end == new_edit.range.end
+                and existing_edit.new_text == new_edit.new_text
+            ):
+                return
+        changes[key].append(new_edit)