jaclang 0.7.14__py3-none-any.whl → 0.7.17__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:
@@ -170,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,
@@ -187,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"),
@@ -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>,",
@@ -222,7 +278,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),
@@ -246,32 +302,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, 12),
+                lspt.Position(51, 32),
+                ["RED22", "GREEN22", "BLUE22"],
+                3,
+            ),
+            (
+                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>")
@@ -288,10 +399,169 @@ 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)))
+            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)