jaclang 0.7.13__py3-none-any.whl → 0.7.15__py3-none-any.whl

jaclang/langserve/tests/test_sem_tokens.py

@@ -0,0 +1,277 @@
+"""Test Semantic Tokens Update."""
+
+import copy
+import lsprotocol.types as lspt
+
+from jaclang.langserve.engine import ModuleInfo
+from jaclang.utils.test import TestCase
+
+from typing import Tuple
+
+
+class TestUpdateSemTokens(TestCase):
+    """Test update semantic tokens"""
+
+    def setUp(self) -> None:
+        """Set up test."""
+        # fmt: off
+        self.initial_sem_tokens = [
+            1, 10, 4, 0, 2, 3, 4, 14, 12, 1, 0, 15, 6, 7, 1, 0, 8, 5, 2, 1,
+            0, 10, 5, 2, 1, 1, 11, 4, 0, 2, 0, 10, 6, 7, 1, 0, 9, 6, 7, 1
+        ]
+        # fmt: on
+
+        self.document_lines = [
+            "",
+            "import:py math;",
+            "",
+            '"""Function to calculate the area of a circle."""',
+            "can calculate_area(radius: float) -> float {",
+            "    return math.pi * radius * radius;",
+            "}",
+            " ",
+        ]
+
+    def check_semantic_token_update(self, case: Tuple, expected_output: str) -> None:
+        """Check semantic token update."""
+        doc_lines = copy.deepcopy(self.document_lines)
+
+        updated_semtokens = ModuleInfo.update_sem_tokens(
+            "circle_ir",
+            lspt.DidChangeTextDocumentParams(
+                text_document=lspt.VersionedTextDocumentIdentifier(
+                    version=32,
+                    uri="...jaclang/examples/manual_code/circle.jac",
+                ),
+                content_changes=[
+                    lspt.TextDocumentContentChangeEvent_Type1(
+                        range=lspt.Range(start=case[0], end=case[1]),
+                        text=case[2],
+                        range_length=case[3],
+                    )
+                ],
+            ),
+            sem_tokens=copy.deepcopy(self.initial_sem_tokens),
+            document_lines=doc_lines,
+        )
+        self.assertIn(
+            expected_output, str(updated_semtokens), f"\nFailed for case: {case[4]}"
+        )
+
+    def test_multiline_before_first_token(self) -> None:
+        """Test multiline before first token."""
+        case = (
+            lspt.Position(line=0, character=0),
+            lspt.Position(line=0, character=0),
+            "\n",
+            0,
+            "Multiline before first token (Basic)",
+        )
+        self.document_lines.insert(1, "")
+        self.check_semantic_token_update(case, "2, 10, 4, 0, 2, 3, 4, 14,")
+
+    def test_multiline_between_tokens(self) -> None:
+        """Test multiline between tokens."""
+        case = (
+            lspt.Position(line=5, character=19),
+            lspt.Position(line=5, character=19),
+            "\n    ",
+            0,
+            "Multiline between tokens (Basic)",
+        )
+        self.document_lines[5] = "    return math.pi "
+        self.document_lines.insert(6, "    * radius * radius;")
+        self.check_semantic_token_update(case, "2, 1, 6, 6, 7, 1, ")
+
+    def test_multiline_at_end_of_line(self) -> None:
+        """Test multiline at end of line."""
+        case = (
+            lspt.Position(line=4, character=37),
+            lspt.Position(line=4, character=37),
+            "\n",
+            0,
+            "Multiline at end of line",
+        )
+        self.document_lines[4] = "can calculate_area(radius: float) -> "
+        self.document_lines.insert(5, "float {")
+        self.check_semantic_token_update(case, " 2, 1, 1, 0, 5, 2, 1, ")
+
+    def test_sameline_space_between_tokens(self) -> None:
+        """Test sameline space between tokens."""
+        case = (
+            lspt.Position(line=5, character=20),
+            lspt.Position(line=5, character=20),
+            " ",
+            0,
+            "Sameline space between tokens (Basic)",
+        )
+        self.check_semantic_token_update(case, "0, 11, 6, 7, 1,")
+
+    def test_sameline_tab_between_tokens(self) -> None:
+        """Test sameline tab between tokens."""
+        case = (
+            lspt.Position(line=5, character=20),
+            lspt.Position(line=5, character=20),
+            "    ",
+            0,
+            "Sameline tab between tokens (Basic)",
+        )
+        self.check_semantic_token_update(case, "0, 14, 6, 7, 1")
+
+    def test_tab_at_start_of_token(self) -> None:
+        """Test tab at start of token."""
+        case = (
+            lspt.Position(line=5, character=21),
+            lspt.Position(line=5, character=21),
+            "   ",
+            0,
+            "Tab at start of a token",
+        )
+        self.check_semantic_token_update(case, "0, 13, 6, 7, 1,")
+
+    def test_insert_inside_token(self) -> None:
+        """Test insert inside token."""
+        case = (
+            lspt.Position(line=5, character=13),
+            lspt.Position(line=5, character=13),
+            "calculate",
+            0,
+            "insert inside a token",
+        )
+        self.check_semantic_token_update(case, "1, 11, 13, 0, 2, 0, 19, 6, 7, 1")
+
+    def test_insert_inside_token_selected_range(self) -> None:
+        """Test insert inside token selected range."""
+        case = (
+            lspt.Position(line=5, character=12),
+            lspt.Position(line=5, character=14),
+            "calculate",
+            2,
+            "insert inside a token in a selected range",
+        )
+        self.check_semantic_token_update(case, "1, 11, 11, 0, 2, 0, 17, 6, 7, 1,")
+
+    def test_newline_at_start_of_token(self) -> None:
+        """Test newline at start of token."""
+        case = (
+            lspt.Position(line=5, character=21),
+            lspt.Position(line=5, character=21),
+            "\n    ",
+            0,
+            "Newline at start of a token",
+        )
+        self.document_lines[5] = "    return math.pi * "
+        self.document_lines.insert(6, "    radius * radius;")
+        self.check_semantic_token_update(case, "0, 2, 1, 4, 6, 7, 1, 0")
+
+    def test_newline_after_parenthesis(self) -> None:
+        """Test newline after parenthesis."""
+        case = (
+            lspt.Position(line=4, character=19),
+            lspt.Position(line=4, character=19),
+            "\n    ",
+            0,
+            "Newline after parenthesis",
+        )
+        self.document_lines[4] = "can calculate_area("
+        self.document_lines.insert(5, "    radius: float) -> float {")
+        self.check_semantic_token_update(case, "12, 1, 1, 4, 6, 7, 1, 0, 8")
+
+    def test_insert_newline_at_end_of_token(self) -> None:
+        """Test insert newline at end of token."""
+        case = (
+            lspt.Position(line=5, character=27),
+            lspt.Position(line=5, character=27),
+            "\n    ",
+            0,
+            "Insert Newline at end of a token",
+        )
+        self.document_lines[5] = "    return math.pi * radius"
+        self.document_lines.insert(6, "     * radius;")
+        self.check_semantic_token_update(case, "7, 1, 1, 7, 6, 7")
+
+    def test_deletion_basic(self) -> None:
+        """Test deletion basic."""
+        case = (
+            lspt.Position(line=5, character=4),
+            lspt.Position(line=5, character=4),
+            "",
+            4,
+            "Deletion Basic",
+        )
+        self.check_semantic_token_update(case, "0, 10, 5, 2, 1, 1, 7, 4, 0, 2, 0")
+
+    def test_multiline_deletion(self) -> None:
+        """Test multiline deletion."""
+        case = (
+            lspt.Position(line=3, character=49),
+            lspt.Position(line=4, character=0),
+            "",
+            4,
+            "Multiline Deletion",
+        )
+        self.document_lines[3] = (
+            '"""Function to calculate the area of a circle."""can calculate_area(radius: float) -> float {'
+        )
+        del self.document_lines[4]
+        self.check_semantic_token_update(case, "2, 2, 53, 14, 12, 1, 0")
+
+    def test_single_deletion_inside_token(self) -> None:
+        """Test single deletion inside token."""
+        case = (
+            lspt.Position(line=5, character=12),
+            lspt.Position(line=5, character=13),
+            "",
+            1,
+            "single Deletion inside token",
+        )
+        self.check_semantic_token_update(case, "1, 1, 11, 3, 0, 2, 0, 9, 6")
+
+    def test_deletion_inside_token_selected_range(self) -> None:
+        """Test deletion inside token selected range."""
+        case = (
+            lspt.Position(line=4, character=10),
+            lspt.Position(line=4, character=15),
+            "",
+            5,
+            "Deletion inside token- selected range",
+        )
+        self.check_semantic_token_update(case, "4, 9, 12, 1, 0, 10, 6")
+
+    def test_selected_multiline_deletion(self) -> None:
+        """Test selected multiline deletion."""
+        case = (
+            lspt.Position(line=4, character=44),
+            lspt.Position(line=5, character=4),
+            "",
+            5,
+            "selected Multi line Deletion",
+        )
+        self.document_lines[3] = (
+            "can calculate_area(radius: float) -> float {return math.pi * radius * radius;"
+        )
+        del self.document_lines[4]
+        self.check_semantic_token_update(case, "4, 0, 2, 3, 4, 14, 12, 1, 0, 15")
+
+    def test_multi_line_insert_on_selected_region(self) -> None:
+        """Test multi line insert on selected region."""
+        case = (
+            lspt.Position(line=4, character=26),
+            lspt.Position(line=4, character=27),
+            ':= a + a // 2) > 5 {\n        print("b is grater than 5");\n    }',
+            1,
+            "multi line insert on selected region ",
+        )
+        self.document_lines = [
+            "",
+            "import:py math;",
+            "",
+            '"""Function to calculate the area of a circle."""',
+            "can calculate_area(radius::= a + a // 2) > 5 {",
+            '        print("b is grater than 5");',
+            "    }float) -> float {",
+            "    return math.pi * radius * radius;",
+            "}",
+            " ",
+        ]
+        self.check_semantic_token_update(case, " 2, 1, 2, 14, 5, 2, 1, 1, ")

jaclang/langserve/tests/test_server.py

@@ -1,7 +1,7 @@
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
-from jaclang.langserve.engine import JacLangServer
+from jaclang.langserve.engine import JacLangServer, ModuleInfo
 from .session import LspSession
 
 import lsprotocol.types as lspt
@@ -103,7 +103,7 @@ class TestJacLangServer(TestCase):
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.jac"))
         lsp.deep_check(circle_file)
-        self.assertEqual(8, len(lsp.get_document_symbols(circle_file)))
+        self.assertEqual(8, len(lsp.get_outline(circle_file)))
 
     def test_go_to_definition(self) -> None:
         """Test that the go to definition is correct."""
@@ -119,7 +119,7 @@ class TestJacLangServer(TestCase):
         )
         self.assertIn(
             "fixtures/circle_pure.jac:13:11-13:16",
-            str(lsp.get_definition(circle_file, lspt.Position(20, 17))),
+            str(lsp.get_definition(circle_file, lspt.Position(20, 16))),
         )
 
     def test_go_to_definition_method(self) -> None:
@@ -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()
@@ -163,7 +187,7 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(import_file)
         positions = [
-            (2, 16, "datetime.py:0:0-0:0"),
+            (2, 24, "datetime.py:0:0-0:0"),
             (3, 17, "base_module_structure.jac:0:0-0:0"),
             (3, 87, "base_module_structure.jac:23:0-23:5"),
             (5, 65, "py_import.py:12:0-20:5"),

jaclang/langserve/utils.py

@@ -89,53 +89,38 @@ def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]:
     return sym_tabs
 
 
-def find_deepest_symbol_node_at_pos(
-    node: ast.AstNode, line: int, character: int
+def find_node_by_position(
+    tokens: list[tuple[lspt.Position, int, int, ast.AstSymbolNode]],
+    line: int,
+    position: int,
 ) -> Optional[ast.AstSymbolNode]:
     """Return the deepest symbol node that contains the given position."""
-    last_symbol_node = None
-
-    if position_within_node(node, line, character):
-        if isinstance(node, ast.AstSymbolNode):
-            last_symbol_node = node
-
-        for child in [i for i in node.kid if i.loc.mod_path == node.loc.mod_path]:
-            if position_within_node(child, line, character):
-                deeper_node = find_deepest_symbol_node_at_pos(child, line, character)
-                if deeper_node is not None:
-                    last_symbol_node = deeper_node
-
-    return last_symbol_node
+    for token in tokens:
+        pos, token_end, length, node = token
+        if pos.line == line and pos.character <= position < token_end:
+            return node
+    return None
 
 
-def position_within_node(node: ast.AstNode, line: int, character: int) -> bool:
-    """Check if the position falls within the node's location."""
-    if node.loc.first_line < line + 1 < node.loc.last_line:
-        return True
-    if (
-        node.loc.first_line == line + 1
-        and node.loc.col_start <= character + 1
-        and (
-            node.loc.last_line == line + 1
-            and node.loc.col_end >= character + 1
-            or node.loc.last_line > line + 1
-        )
-    ):
-        return True
-    if (
-        node.loc.last_line == line + 1
-        and node.loc.col_start <= character + 1 <= node.loc.col_end
+def find_index(
+    sem_tokens: list[int],
+    line: int,
+    char: int,
+) -> Optional[int]:
+    """Find index."""
+    index = None
+    for i, j in enumerate(
+        [get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5)]
     ):
-        return True
-    return False
+        if j[0] == line and j[1] <= char <= j[2]:
+            return i
 
+    return index
 
-def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
+
+def get_symbols_for_outline(node: SymbolTable) -> list[lspt.DocumentSymbol]:
     """Recursively collect symbols from the AST."""
     symbols = []
-    if node is None:
-        return symbols
-
     for key, item in node.tab.items():
         if (
             key in dir(builtins)
@@ -143,23 +128,20 @@ def collect_symbols(node: SymbolTable) -> list[lspt.DocumentSymbol]:
             or item.decl.loc.mod_path != node.owner.loc.mod_path
         ):
             continue
-        else:
-
-            pos = create_range(item.decl.loc)
-            symbol = lspt.DocumentSymbol(
-                name=key,
-                kind=kind_map(item.decl),
-                range=pos,
-                selection_range=pos,
-                children=[],
-            )
-            symbols.append(symbol)
+        pos = create_range(item.decl.loc)
+        symbol = lspt.DocumentSymbol(
+            name=key,
+            kind=kind_map(item.decl),
+            range=pos,
+            selection_range=pos,
+            children=[],
+        )
+        symbols.append(symbol)
 
     for sub_tab in [
         i for i in node.kid if i.owner.loc.mod_path == node.owner.loc.mod_path
     ]:
-        sub_symbols = collect_symbols(sub_tab)
-
+        sub_symbols = get_symbols_for_outline(sub_tab)
         if isinstance(
             sub_tab.owner,
             (ast.IfStmt, ast.ElseStmt, ast.WhileStmt, ast.IterForStmt, ast.InForStmt),
@@ -364,50 +346,6 @@ def get_definition_range(
     return None
 
 
-def locate_affected_token(
-    tokens: list[int],
-    change_start_line: int,
-    change_start_char: int,
-    change_end_line: int,
-    change_end_char: int,
-) -> Optional[int]:
-    """Find in which token change is occurring."""
-    token_index = 0
-    current_line = 0
-    line_char_offset = 0
-
-    while token_index < len(tokens):
-        token_line_delta = tokens[token_index]
-        token_start_char = tokens[token_index + 1]
-        token_length = tokens[token_index + 2]
-
-        if token_line_delta > 0:
-            current_line += token_line_delta
-            line_char_offset = 0
-        token_abs_start_char = line_char_offset + token_start_char
-        token_abs_end_char = token_abs_start_char + token_length
-        if (
-            current_line == change_start_line == change_end_line
-            and token_abs_start_char <= change_start_char
-            and change_end_char <= token_abs_end_char
-        ):
-            return token_index
-        if (
-            current_line == change_start_line
-            and token_abs_start_char <= change_start_char < token_abs_end_char
-        ):
-            return token_index
-        if (
-            current_line == change_end_line
-            and token_abs_start_char < change_end_char <= token_abs_end_char
-        ):
-            return token_index
-
-        line_char_offset += token_start_char
-        token_index += 5
-    return None
-
-
 def collect_all_symbols_in_scope(
     sym_tab: SymbolTable, up_tree: bool = True
 ) -> list[lspt.CompletionItem]:
@@ -558,3 +496,98 @@ def resolve_completion_symbol_table(
         collect_all_symbols_in_scope(current_symbol_table, up_tree=False)
     )
     return completion_items
+
+
+def get_token_start(
+    token_index: int | None, sem_tokens: list[int]
+) -> tuple[int, int, int]:
+    """Return the starting position of a token."""
+    if token_index is None or token_index >= len(sem_tokens):
+        return 0, 0, 0
+
+    current_line = 0
+    current_char = 0
+    current_tok_index = 0
+
+    while current_tok_index < len(sem_tokens):
+        token_line_delta = sem_tokens[current_tok_index]
+        token_start_char = sem_tokens[current_tok_index + 1]
+
+        if token_line_delta > 0:
+            current_line += token_line_delta
+            current_char = 0
+        if current_tok_index == token_index:
+            if token_line_delta > 0:
+                return (
+                    current_line,
+                    token_start_char,
+                    token_start_char + sem_tokens[current_tok_index + 2],
+                )
+            return (
+                current_line,
+                current_char + token_start_char,
+                current_char + token_start_char + sem_tokens[current_tok_index + 2],
+            )
+
+        current_char += token_start_char
+        current_tok_index += 5
+
+    return (
+        current_line,
+        current_char,
+        current_char + sem_tokens[current_tok_index + 2],
+    )
+
+
+def find_surrounding_tokens(
+    change_start_line: int,
+    change_start_char: int,
+    change_end_line: int,
+    change_end_char: int,
+    sem_tokens: list[int],
+) -> tuple[int | None, int | None, bool]:
+    """Find the indices of the previous and next tokens surrounding the change."""
+    prev_token_index = None
+    next_token_index = None
+    inside_tok = False
+    for i, tok in enumerate(
+        [get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5)][0:]
+    ):
+        if (not (prev_token_index is None or next_token_index is None)) and (
+            tok[0] > change_end_line
+            or (tok[0] == change_end_line and tok[1] > change_end_char)
+        ):
+            prev_token_index = i * 5
+            break
+        elif (
+            change_start_line == tok[0] == change_end_line
+            and tok[1] <= change_start_char
+            and tok[2] >= change_end_char
+        ):
+            prev_token_index = i * 5
+            inside_tok = True
+            break
+        elif (tok[0] < change_start_line) or (
+            tok[0] == change_start_line and tok[1] < change_start_char
+        ):
+            prev_token_index = i * 5
+        elif (tok[0] > change_end_line) or (
+            tok[0] == change_end_line and tok[1] > change_end_char
+        ):
+            next_token_index = i * 5
+            break
+
+    return prev_token_index, next_token_index, inside_tok
+
+
+def get_line_of_code(line_number: int, lines: list[str]) -> Optional[tuple[str, int]]:
+    """Get the line of code, and the first non-space character index."""
+    if 0 <= line_number < len(lines):
+        line = lines[line_number].rstrip("\n")
+        first_non_space = len(line) - len(line.lstrip())
+        return line, (
+            first_non_space + 4
+            if line.strip().endswith(("(", "{", "["))
+            else first_non_space
+        )
+    return None

jaclang/plugin/builtin.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional
-    from jaclang.core.constructs import NodeArchitype
+    from jaclang.runtimelib.constructs import NodeArchitype
 
 
 def dotgen(

jaclang/plugin/default.py

@@ -15,7 +15,7 @@ from typing import Any, Callable, Optional, Type, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.constant import EdgeDir, colors
 from jaclang.compiler.semtable import SemInfo, SemRegistry, SemScope
-from jaclang.core.constructs import (
+from jaclang.runtimelib.constructs import (
     Architype,
     DSFunc,
     EdgeAnchor,
@@ -32,9 +32,9 @@ from jaclang.core.constructs import (
     WalkerArchitype,
     exec_context,
 )
-from jaclang.core.importer import jac_importer
-from jaclang.core.utils import traverse_graph
-from jaclang.plugin.feature import JacFeature as Jac
+from jaclang.runtimelib.importer import ImportPathSpec, JacImporter, PythonImporter
+from jaclang.runtimelib.utils import traverse_graph
+from jaclang.plugin.feature import JacFeature as Jac  # noqa: I100
 from jaclang.plugin.spec import T
 
 
@@ -54,7 +54,6 @@ __all__ = [
     "WalkerArchitype",
     "Architype",
     "DSFunc",
-    "jac_importer",
     "T",
 ]
 
@@ -216,18 +215,26 @@ class JacFeatureDefaults:
         items: Optional[dict[str, Union[str, Optional[str]]]],
     ) -> tuple[types.ModuleType, ...]:
         """Core Import Process."""
-        result = jac_importer(
-            target=target,
-            base_path=base_path,
-            absorb=absorb,
-            cachable=cachable,
-            mdl_alias=mdl_alias,
-            override_name=override_name,
-            mod_bundle=mod_bundle,
-            lng=lng,
-            items=items,
+        spec = ImportPathSpec(
+            target,
+            base_path,
+            absorb,
+            cachable,
+            mdl_alias,
+            override_name,
+            mod_bundle,
+            lng,
+            items,
+        )
+        if lng == "py":
+            import_result = PythonImporter(Jac.context().jac_machine).run_import(spec)
+        else:
+            import_result = JacImporter(Jac.context().jac_machine).run_import(spec)
+        return (
+            (import_result.ret_mod,)
+            if absorb or not items
+            else tuple(import_result.ret_items)
         )
-        return result
 
     @staticmethod
     @hookimpl
@@ -260,6 +267,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)