jaclang 0.8.6__py3-none-any.whl → 0.8.8__py3-none-any.whl

jaclang/langserve/tests/server_test/utils.py

@@ -2,21 +2,19 @@
 
 import os
 import tempfile
-
+from typing import Optional
+from dataclasses import dataclass
+
+from lsprotocol.types import (
+    DidOpenTextDocumentParams,
+    TextDocumentItem,
+    DidSaveTextDocumentParams,
+    DidChangeTextDocumentParams,
+    VersionedTextDocumentIdentifier,
+)
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 
-from textwrap import dedent
-
-
-def get_jac_file_path():
-    """Return the absolute path to the sample Jac file used for testing."""
-    return os.path.abspath(
-        os.path.join(
-            os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac"
-        )
-    )
-
 
 def create_temp_jac_file(initial_content: str = "") -> str:
     """Create a temporary Jac file with optional initial content and return its path."""
@@ -28,110 +26,11 @@ def create_temp_jac_file(initial_content: str = "") -> str:
     return temp.name
 
 
-def get_code(code: str) -> str:
-    """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(
-        f'''
-    """
-    This module demonstrates a simple circle class and a function to calculate
-    the area of a circle in all of Jac's glory.
-    """
-
-    import math;
-
-    # Module-level global variable
-    glob RAD = 5;
-
-    """Function to calculate the area of a circle."""
-    def calculate_area(radius: float) -> float {{
-        return math.pi * radius * radius;
-    }}
-
-    #* (This is a multiline comment in Jac)
-    Above we have the demonstration of a function to calculate the area of a circle.
-    Below we have the demonstration of a class to calculate the area of a circle.
-    *#
-
-    """Enum for shape types"""
-    enum ShapeType {{
-        CIRCLE = "Circle",
-        UNKNOWN = "Unknown"
-    }}
-
-    """Base class for a shape."""
-    obj Shape {{
-        has shape_type: ShapeType;
-
-        """Abstract method to calculate the area of a shape."""
-        def area -> float abs;
-    }}
-
-    """Circle class inherits from Shape."""
-    obj Circle(Shape) {{
-        def init(radius: float) {{
-            super.init(ShapeType.CIRCLE);
-            self.radius = radius;
-        }}
-
-        """Overridden method to calculate the area of the circle."""
-        override def area -> float {{
-            return math.pi * self.radius * self.radius;
-        }}
-    }}
-
-    with entry {{
-        c = Circle(RAD);
-    }}
-
-    # Global also works here
-
-    with entry:__main__ {{
-        # To run the program functionality
-        print(
-            f"Area of a circle with radius {{RAD}} using function: {{calculate_area(RAD)}}"
-        );
-        print(
-            f"Area of a {{c.shape_type.value}} with radius {{RAD}} using class: {{c.area()}}"
-        );
-    }}
-
-    # Unit Tests!
-    glob expected_area = 78.53981633974483;
-    {code}
-
-    test calc_area {{
-        check almostEqual(calculate_area(RAD), expected_area);
-    }}
-
-    test circle_area {{
-        c = Circle(RAD);
-        check almostEqual(c.area(), expected_area);
-    }}
-
-    test circle_type {{
-        c = Circle(RAD);
-        check c.shape_type == ShapeType.CIRCLE;
-    }}
-'''
-    )
-    return jac_code
-
-
-def get_simple_code(code: str) -> str:
-    """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(
-        f"""
-    
-    # Unit Tests!
-    glob expected_area0 = 78.53981633974483;
-    glob expected_area1 = 78.53981633974483;
-    {code}
-    glob expected_area2 = 78.53981633974483;
-
-
-"""
-    )
-    return jac_code
+def load_jac_template(template_file: str, code: str = "") -> str:
+    """Load a Jac template file and inject code into placeholder."""
+    with open(template_file, "r") as f:
+        jac_template = f.read()
+    return jac_template.replace("#{{INJECT_CODE}}", code)
 
 
 def create_ls_with_workspace(file_path: str):
@@ -142,3 +41,141 @@ def create_ls_with_workspace(file_path: str):
     uri = from_fs_path(file_path)
     ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
     return uri, ls
+
+
+@dataclass
+class TestFile:
+    """Encapsulates test file information and operations."""
+    
+    path: str
+    uri: str
+    code: str
+    version: int = 1
+    
+    @classmethod
+    def from_template(cls, template_name: str, content: str = "") -> "TestFile":
+        """Create a test file from a template."""
+        code = load_jac_template(cls._get_template_path(template_name), content)
+        temp_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_path)
+        return cls(
+            path=temp_path,
+            uri=uri or "",
+            code=code,
+        )
+    
+    @staticmethod
+    def _get_template_path(file_name: str) -> str:
+        """Get absolute path to test template file."""
+        return os.path.abspath(
+            os.path.join(os.path.dirname(__file__), file_name)
+        )
+    
+    def cleanup(self):
+        """Remove temporary test file."""
+        if os.path.exists(self.path):
+            os.remove(self.path)
+    
+    def increment_version(self) -> int:
+        """Increment and return the version number."""
+        self.version += 1
+        return self.version
+
+
+class LanguageServerTestHelper:
+    """Helper class for language server testing operations."""
+    
+    def __init__(self, ls, test_file: TestFile):
+        self.ls = ls
+        self.test_file = test_file
+    
+    async def open_document(self) -> None:
+        """Open a document in the language server."""
+        from jaclang.langserve.server import did_open
+        
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=self.test_file.version,
+                text=self.test_file.code,
+            )
+        )
+        await did_open(self.ls, params)
+    
+    async def save_document(self, code: Optional[str] = None) -> None:
+        """Save a document in the language server."""
+        from jaclang.langserve.server import did_save
+        
+        content = code if code is not None else self.test_file.code
+        version = self.test_file.increment_version()
+        
+        if code:
+            self._update_workspace(code, version)
+        
+        from lsprotocol.types import TextDocumentIdentifier
+        
+        params = DidSaveTextDocumentParams(
+            text_document=TextDocumentIdentifier(uri=self.test_file.uri),
+            text=content
+        )
+        await did_save(self.ls, params)
+    
+    async def change_document(self, code: str) -> None:
+        """Change document content in the language server."""
+        from jaclang.langserve.server import did_change
+        
+        version = self.test_file.increment_version()
+        self._update_workspace(code, version)
+        
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(
+                uri=self.test_file.uri,
+                version=version
+            ),
+            content_changes=[{"text": code}],  # type: ignore
+        )
+        await did_change(self.ls, params)
+    
+    def _update_workspace(self, code: str, version: int) -> None:
+        """Update workspace with new document content."""
+        self.ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=version,
+                text=code,
+            )
+        )
+    
+    def get_diagnostics(self) -> list:
+        """Get diagnostics for the current document."""
+        return self.ls.diagnostics.get(self.test_file.uri, [])
+    
+    def get_semantic_tokens(self):
+        """Get semantic tokens for the current document."""
+        return self.ls.get_semantic_tokens(self.test_file.uri)
+    
+    def assert_no_diagnostics(self) -> None:
+        """Assert that there are no diagnostics."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0, f"Expected no diagnostics, found {len(diagnostics)}"
+    
+    def assert_has_diagnostics(self, count: int = 1, message_contains: Optional[str] = None) -> None:
+        """Assert that diagnostics exist with optional message validation."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == count, f"Expected {count} diagnostic(s), found {len(diagnostics)}"
+        
+        if message_contains:
+            assert message_contains in diagnostics[0].message, \
+                f"Expected '{message_contains}' in diagnostic message"
+    
+    def assert_semantic_tokens_count(self, expected_count: int) -> None:
+        """Assert semantic tokens data has expected count."""
+        tokens = self.get_semantic_tokens()
+        assert hasattr(tokens, "data")
+        assert isinstance(tokens.data, list)
+        assert len(tokens.data) == expected_count, \
+            f"Expected {expected_count} tokens, found {len(tokens.data)}"

jaclang/langserve/tests/test_dev_server.py

@@ -3,7 +3,7 @@ from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
 
 import lsprotocol.types as lspt
-from jaclang.langserve.dev_engine import JacLangServer
+from jaclang.langserve.engine import JacLangServer
 
 
 class TestJacLangServer(TestCase):

jaclang/langserve/tests/test_server.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
@@ -127,6 +128,9 @@ class TestJacLangServer(TestCase):
             str(lsp.get_definition(circle_file, lspt.Position(20, 16))),
         )
 
+    @pytest.mark.xfail(
+        reason="Incorrect handling of 'self' in DefUsePass.TODO: Fix chain_use_lookup."
+    )
     def test_go_to_definition_method(self) -> None:
         """Test that the go to definition is correct."""
         lsp = JacLangServer()
@@ -307,7 +311,6 @@ class TestJacLangServer(TestCase):
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_completion(self) -> None:
         """Test that the completions are correct."""
         lsp = JacLangServer()
@@ -315,95 +318,28 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         base_module_file = uris.from_fs_path(
-            self.fixture_abs_path("base_module_structure.jac")
+            self.fixture_abs_path("completion_test_err.jac")
         )
         lsp.deep_check(base_module_file)
-        test_cases = [
-            (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(65, 13),
-                [
-                    "get_color1",
-                    "color1",
-                    "point1",
-                    "base_colorred",
-                    "pointred",
-                    "inner_red",
-                    "doubleinner",
-                    "apply_red",
-                ],
-                11,
-            ),
-            (
-                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",
-                ],
-                11,
-            ),
-            (
-                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"],
-                153,
-                None,
+
+        @dataclass
+        class Case:
+            pos: lspt.Position
+            expected: list[str]
+            trigger: str = "."
+
+        test_cases: list[Case] = [
+            Case(
+                lspt.Position(8, 8),
+                ["bar", "baz"],
             ),
         ]
-        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=completion_trigger
+                base_module_file, case.pos, completion_trigger=case.trigger
             ).items
-            for completion in expected_completions:
+            for completion in case.expected:
                 self.assertIn(completion, str(completions))
-            self.assertEqual(expected_length, len(completions))
-
-            if position == lspt.Position(73, 12):
-                self.assertEqual(
-                    2, str(completions).count("kind=<CompletionItemKind.Function: 3>")
-                )
-                self.assertEqual(
-                    4, str(completions).count("kind=<CompletionItemKind.Field: 5>")
-                )
 
     def test_go_to_reference(self) -> None:
         """Test that the go to reference is correct."""
@@ -416,8 +352,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:22-65:36"]),
-            (62, 14, ["65:43-65:56", "70:32-70:45"]),
+            (54, 66, ["54:62-54:76", "65:23-65:37"]),
+            (62, 14, ["65:44-65:57", "70:33-70:46"]),
         ]
         for line, char, expected_refs in test_cases:
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
@@ -595,9 +531,17 @@ class TestJacLangServer(TestCase):
         workspace_path = self.fixture_abs_path("")
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
-        guess_game_file = uris.from_fs_path(self.fixture_abs_path('../../../compiler/passes/main/tests/fixtures/sym_binder.jac'))
+        guess_game_file = uris.from_fs_path(
+            self.fixture_abs_path(
+                "../../../compiler/passes/main/tests/fixtures/sym_binder.jac"
+            )
+        )
         lsp.deep_check(guess_game_file)
         self.assertIn(
             "/tests/fixtures/M1.jac:0:0-0:0",
             str(lsp.get_definition(guess_game_file, lspt.Position(29, 9))),
-        )
+        )
+
+
+
+TestJacLangServer().test_completion()

jaclang/langserve/utils.jac

@@ -1,5 +1,6 @@
 """Utility functions for the language server."""
 
+
 import asyncio;
 import builtins;
 import re;
@@ -31,18 +32,18 @@ glob T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
 """Return diagnostics."""
 def gen_diagnostics(
     from_path: str,
-    errors: <>list[Alert],
-    warnings: <>list[Alert]
-) -> <>list[lspt.Diagnostic] {
+    errors: list[Alert],
+    warnings: list[Alert]
+) -> list[lspt.Diagnostic] {
     return [ lspt.Diagnostic(
         range=create_range(error.loc),
         message=error.msg,
         severity=lspt.DiagnosticSeverity.Error
-    ) for error in errors if error.loc.mod_path == uris.to_fs_path(from_path) ] + [ lspt.Diagnostic(
+    ) for error in errors if error.loc.mod_path == from_path ] + [ lspt.Diagnostic(
         range=create_range(warning.loc),
         message=warning.msg,
         severity=lspt.DiagnosticSeverity.Warning
-    ) for warning in warnings if warning.loc.mod_path == uris.to_fs_path(from_path) ];
+    ) for warning in warnings if warning.loc.mod_path == from_path ];
 }
 
 
@@ -75,7 +76,7 @@ def debounce(<>wait: float) -> Callable[[T], Callable[(..., Awaitable[None])]] {
 
 
 """Iterate through symbol table."""
-def sym_tab_list(sym_tab: UniScopeNode, file_path: str) -> <>list[UniScopeNode] {
+def sym_tab_list(sym_tab: UniScopeNode, file_path: str) -> list[UniScopeNode] {
     sym_tabs = [sym_tab]
     if not (isinstance(sym_tab, uni.Module) and sym_tab.loc.mod_path != file_path )
     else []
@@ -112,30 +113,26 @@ def find_deepest_symbol_node_at_pos(
 
 
 """Check if the position falls within the node's location."""
-def position_within_node(<>node: uni.UniNode, line: int, character: int) -> bool {
-    if <>node.loc.first_line < (line + 1) < <>node.loc.last_line {
+# All lines and columns are 1-Based
+def position_within_node(n: uni.UniNode, line: int, character: int) -> bool {
+    if n.loc.first_line < line < n.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 line < n.loc.first_line or line > n.loc.last_line {
+        return False;
     }
-    if <>node.loc.last_line == (line + 1)
-    and <>node.loc.col_start <= (character + 1) <= <>node.loc.col_end
-     {
-        return True;
+    if line == n.loc.first_line and character < n.loc.col_start {
+        return False;
     }
-    return False;
+    if line == n.loc.last_line and character >= n.loc.col_end {
+        return False;
+    }
+    return True;
 }
 
 
 """Find index."""
-def find_index(sem_tokens: <>list[int], line: int, char: int) -> Optional[int] {
+def find_index(sem_tokens: list[int], line: int, char: int) -> Optional[int] {
     index = None;
     token_start_list = [ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ];
     for (i, j) in enumerate(token_start_list) {
@@ -148,7 +145,7 @@ def find_index(sem_tokens: <>list[int], line: int, char: int) -> Optional[int] {
 
 
 """Recursively collect symbols from the AST."""
-def get_symbols_for_outline(<>node: UniScopeNode) -> <>list[lspt.DocumentSymbol] {
+def get_symbols_for_outline(<>node: UniScopeNode) -> list[lspt.DocumentSymbol] {
     symbols = [];
     for (key, item) in <>node.names_in_scope.items() {
         if key in dir(builtins)
@@ -234,34 +231,30 @@ def kind_map(sub_tab: uni.UniNode) -> lspt.SymbolKind {
 
 """Map the symbol node to an lspt.CompletionItemKind."""
 def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind {
-    return lspt.CompletionItemKind.Function
-    if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
-    else lspt.CompletionItemKind.Class
-    if sub_tab in [SymbolType.OBJECT_ARCH,
-    SymbolType.NODE_ARCH,
-    SymbolType.EDGE_ARCH,
-    SymbolType.WALKER_ARCH]
-    else lspt.CompletionItemKind.Module
-    if sub_tab == SymbolType.MODULE
-    else lspt.CompletionItemKind.Enum
-    if sub_tab == SymbolType.ENUM_ARCH
-    else lspt.CompletionItemKind.Field
-    if sub_tab == SymbolType.HAS_VAR
-    else lspt.CompletionItemKind.Method
-    if sub_tab == SymbolType.METHOD
-    else lspt.CompletionItemKind.EnumMember
-    if sub_tab == SymbolType.ENUM_MEMBER
-    else lspt.CompletionItemKind.Interface
-    if sub_tab == SymbolType.IMPL
-    else lspt.CompletionItemKind.Variable
-
-
-
-
-
-
-
-    ;
+    return (
+        lspt.CompletionItemKind.Function
+        if sub_tab in [SymbolType.ABILITY, SymbolType.TEST]
+        else lspt.CompletionItemKind.Class
+        if sub_tab in [
+            SymbolType.OBJECT_ARCH,
+            SymbolType.NODE_ARCH,
+            SymbolType.EDGE_ARCH,
+            SymbolType.WALKER_ARCH
+        ]
+        else lspt.CompletionItemKind.Module
+        if sub_tab == SymbolType.MODULE
+        else lspt.CompletionItemKind.Enum
+        if sub_tab == SymbolType.ENUM_ARCH
+        else lspt.CompletionItemKind.Field
+        if sub_tab == SymbolType.HAS_VAR
+        else lspt.CompletionItemKind.Method
+        if sub_tab == SymbolType.METHOD
+        else lspt.CompletionItemKind.EnumMember
+        if sub_tab == SymbolType.ENUM_MEMBER
+        else lspt.CompletionItemKind.Interface
+        if sub_tab == SymbolType.IMPL
+        else lspt.CompletionItemKind.Variable
+    );
 }
 
 
@@ -269,9 +262,9 @@ def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind {
 def collect_all_symbols_in_scope(
     sym_tab: UniScopeNode,
     up_tree: bool = True
-) -> <>list[lspt.CompletionItem] {
+) -> list[lspt.CompletionItem] {
     symbols = [];
-    visited = <>set();
+    visited = set();
     current_tab : Optional[UniScopeNode] = sym_tab;
     while current_tab is not None and current_tab not in visited  {
         visited.add(current_tab);
@@ -295,8 +288,8 @@ def collect_all_symbols_in_scope(
 
 
 """Return all child tab's as completion items."""
-def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
-    symbols : <>list[lspt.CompletionItem] = [];
+def collect_child_tabs(sym_tab: UniScopeNode) -> list[lspt.CompletionItem] {
+    symbols : list[lspt.CompletionItem] = [];
     for tab in sym_tab.kid_scope {
         if tab.scope_name not in [ i.label for i in symbols ] {
             symbols.append(
@@ -312,7 +305,7 @@ def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
 
 
 """Parse text and return a list of symbols."""
-def parse_symbol_path(text: str, dot_position: int) -> <>list[str] {
+def parse_symbol_path(text: str, dot_position: int) -> list[str] {
     text = text[ : dot_position ][ : -1 ].strip();
     valid_character_pattern = re.compile('[a-zA-Z0-9_]');
     reversed_text = text[ : : -1 ];
@@ -342,8 +335,8 @@ def parse_symbol_path(text: str, dot_position: int) -> <>list[str] {
 """Return the starting position of a token."""
 def get_token_start(
     token_index: (int | None),
-    sem_tokens: <>list[int]
-) -> <>tuple[int, int, int] {
+    sem_tokens: list[int]
+) -> tuple[int, int, int] {
     if token_index is None or token_index >= len(sem_tokens)  {
         return (0, 0, 0);
     }
@@ -382,8 +375,8 @@ def find_surrounding_tokens(
     change_start_char: int,
     change_end_line: int,
     change_end_char: int,
-    sem_tokens: <>list[int]
-) -> <>tuple[(int | None), (int | None), bool] {
+    sem_tokens: list[int]
+) -> tuple[(int | None), (int | None), bool] {
     prev_token_index = None;
     next_token_index = None;
     inside_tok = False;
@@ -422,8 +415,8 @@ def find_surrounding_tokens(
 """Get the line of code, and the first non-space character index."""
 def get_line_of_code(
     line_number: int,
-    lines: <>list[str]
-) -> Optional[<>tuple[(str, int)]] {
+    lines: list[str]
+) -> Optional[tuple[(str, int)]] {
     if 0 <= line_number < len(lines) {
         line = lines[line_number].rstrip('\n');
         first_non_space = (len(line) - len(line.lstrip()));
@@ -439,7 +432,7 @@ def get_line_of_code(
 
 """Add a new text edit to the changes dictionary if it is unique."""
 def add_unique_text_edit(
-    changes: <>dict[(str, <>list[lspt.TextEdit])],
+    changes: dict[(str, list[lspt.TextEdit])],
     key: str,
     new_edit: lspt.TextEdit
 ) -> None {