jaclang 0.7.13__py3-none-any.whl → 0.7.16__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.sem_manager import SemTokManager
+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 = SemTokManager.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

@@ -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()
@@ -146,7 +170,7 @@ class TestJacLangServer(TestCase):
         lsp.lsp._workspace = workspace
         circle_file = uris.from_fs_path(self.fixture_abs_path("circle_pure.test.jac"))
         lsp.deep_check(circle_file)
-        pos = lspt.Position(13, 29)
+        pos = lspt.Position(13, 21)
         self.assertIn(
             "shape_type: circle_pure.ShapeType",
             lsp.get_hover_info(circle_file, pos).contents.value,
@@ -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"),
@@ -198,7 +222,7 @@ class TestJacLangServer(TestCase):
             ),
             (
                 "<JacSemTokenType.FUNCTION: 12>, <JacSemTokenModifier.DECLARATION: 1>,",
-                9,
+                6,
             ),
             ("<JacSemTokenType.METHOD: 13>, <JacSemTokenModifier.DECLARATION: 1>", 6),
             ("<JacSemTokenType.ENUM: 3>, <JacSemTokenModifier.DECLARATION: 1>,", 4),
@@ -208,6 +232,7 @@ 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)
 
@@ -222,32 +247,87 @@ class TestJacLangServer(TestCase):
         )
         lsp.deep_check(base_module_file)
         test_cases = [
-            (lspt.Position(37, 16), ["get_color1", "color1", "point1"], 3),
+            (lspt.Position(38, 16), ["get_color1", "color1", "point1"], 3),
+            (lspt.Position(42, 22), ["RED", "GREEN", "BLUE"], 3),
+            (lspt.Position(42, 33), ["RED", "GREEN", "BLUE"], 3),
+            (lspt.Position(42, 45), ["RED", "GREEN", "BLUE"], 3),
+            (lspt.Position(46, 20), ["RED22", "GREEN22", "BLUE22"], 3),
+            (lspt.Position(46, 30), ["RED22", "GREEN22", "BLUE22"], 3),
+            (lspt.Position(46, 41), ["RED22", "GREEN22", "BLUE22"], 3),
+            (
+                lspt.Position(51, 32),
+                ["RED22", "GREEN22", "BLUE22"],
+                3,
+            ),
             (
-                lspt.Position(51, 12),
+                lspt.Position(65, 13),
                 [
                     "get_color1",
                     "color1",
                     "point1",
                     "base_colorred",
                     "pointred",
-                    "color2",
+                    "inner_red",
+                    "doubleinner",
+                    "apply_red",
                 ],
-                6,
+                8,
+            ),
+            (
+                lspt.Position(65, 23),
+                ["color22", "doublepoint22", "point22", "apply_inner_red", "enum_red"],
+                5,
+            ),
+            (
+                lspt.Position(65, 31),
+                ["RED22", "GREEN22", "BLUE22"],
+                3,
+            ),
+            (
+                lspt.Position(35, 28),
+                [],
+                0,
+            ),
+            (
+                lspt.Position(72, 12),
+                [
+                    "get_color1",
+                    "color1",
+                    "point1",
+                    "base_colorred",
+                    "pointred",
+                    "inner_red",
+                    "doubleinner",
+                    "apply_red",
+                ],
+                8,
+            ),
+            (
+                lspt.Position(73, 22),
+                ["color22", "doublepoint22", "apply_inner_red", "point22", "enum_red"],
+                5,
+            ),
+            (
+                lspt.Position(37, 12),
+                ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
+                8,
+                None,
             ),
-            (lspt.Position(52, 19), ["color22", "point22"], 2),
         ]
-        for position, expected_completions, expected_length in test_cases:
+        default_trigger = "."
+        for case in test_cases:
+            position, expected_completions, expected_length = case[:3]
+            completion_trigger = case[3] if len(case) > 3 else default_trigger
             completions = lsp.get_completion(
-                base_module_file, position, completion_trigger="."
+                base_module_file, position, completion_trigger=completion_trigger
             ).items
             for completion in expected_completions:
                 self.assertIn(completion, str(completions))
             self.assertEqual(expected_length, len(completions))
 
-            if position == lspt.Position(47, 12):
+            if position == lspt.Position(73, 12):
                 self.assertEqual(
-                    1, str(completions).count("kind=<CompletionItemKind.Function: 3>")
+                    2, str(completions).count("kind=<CompletionItemKind.Function: 3>")
                 )
                 self.assertEqual(
                     4, str(completions).count("kind=<CompletionItemKind.Field: 5>")
@@ -264,8 +344,8 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_file)
         test_cases = [
             (47, 12, ["circle.jac:47:8-47:14", "69:8-69:14", "74:8-74:14"]),
-            (54, 66, ["54:62-54:76", "65:28-65:42"]),
-            (62, 14, ["65:49-65:62", "70:38-70:51"]),
+            (54, 66, ["54:62-54:76", "65:22-65:36"]),
+            (62, 14, ["65:43-65:56", "70:32-70:45"]),
         ]
         for line, char, expected_refs in test_cases:
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))