Improve type annotations (#2162)

Co-authored-by: Rafal Chlodnicki <rchl2k@gmail.com>

plugin/code_actions.py

@@ -16,7 +16,8 @@
 from .core.views import first_selection_region
 from .core.views import format_code_actions_for_quick_panel
 from .core.views import text_document_code_action_params
-from .save_command import LspSaveCommand, SaveTask
+from .save_command import LspSaveCommand
+from .save_command import SaveTask
 from abc import ABCMeta
 from abc import abstractmethod
 from functools import partial

plugin/code_lens.py

@@ -1,4 +1,6 @@
-from .core.protocol import CodeLens, CodeLensExtended, Error
+from .core.protocol import CodeLens
+from .core.protocol import CodeLensExtended
+from .core.protocol import Error
 from .core.typing import List, Tuple, Dict, Iterable, Generator, Union, cast
 from .core.registry import LspTextCommand
 from .core.registry import windows

plugin/core/edit.py

@@ -1,7 +1,10 @@
 from .logging import debug
 from .open import open_file
 from .promise import Promise
-from .protocol import UINT_MAX, TextEdit as LspTextEdit, Position, WorkspaceEdit
+from .protocol import Position
+from .protocol import TextEdit
+from .protocol import UINT_MAX
+from .protocol import WorkspaceEdit
 from .typing import List, Dict, Optional, Tuple
 from functools import partial
 import sublime
@@ -37,7 +40,7 @@ def parse_range(range: Position) -> Tuple[int, int]:
     return range['line'], min(UINT_MAX, range['character'])
 
 
-def parse_text_edit(text_edit: LspTextEdit, version: Optional[int] = None) -> TextEditTuple:
+def parse_text_edit(text_edit: TextEdit, version: Optional[int] = None) -> TextEditTuple:
     return (
         parse_range(text_edit['range']['start']),
         parse_range(text_edit['range']['end']),

plugin/core/protocol.py

@@ -5861,55 +5861,55 @@ def __init__(
         self.progress = progress  # type: Union[bool, str]
 
     @classmethod
-    def initialize(cls, params: Mapping[str, Any]) -> 'Request':
+    def initialize(cls, params: InitializeParams) -> 'Request':
         return Request("initialize", params)
 
     @classmethod
-    def complete(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def complete(cls, params: CompletionParams, view: sublime.View) -> 'Request':
         return Request("textDocument/completion", params, view)
 
     @classmethod
-    def signatureHelp(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def signatureHelp(cls, params: SignatureHelpParams, view: sublime.View) -> 'Request':
         return Request("textDocument/signatureHelp", params, view)
 
     @classmethod
     def codeAction(cls, params: CodeActionParams, view: sublime.View) -> 'Request':
         return Request("textDocument/codeAction", params, view)
 
     @classmethod
-    def documentColor(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def documentColor(cls, params: DocumentColorParams, view: sublime.View) -> 'Request':
         return Request('textDocument/documentColor', params, view)
 
     @classmethod
     def colorPresentation(cls, params: ColorPresentationParams, view: sublime.View) -> 'Request':
         return Request('textDocument/colorPresentation', params, view)
 
     @classmethod
-    def willSaveWaitUntil(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def willSaveWaitUntil(cls, params: WillSaveTextDocumentParams, view: sublime.View) -> 'Request':
         return Request("textDocument/willSaveWaitUntil", params, view)
 
     @classmethod
     def documentSymbols(cls, params: DocumentSymbolParams, view: sublime.View) -> 'Request':
         return Request("textDocument/documentSymbol", params, view, progress=True)
 
     @classmethod
-    def documentHighlight(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def documentHighlight(cls, params: DocumentHighlightParams, view: sublime.View) -> 'Request':
         return Request("textDocument/documentHighlight", params, view)
 
     @classmethod
-    def documentLink(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def documentLink(cls, params: DocumentLinkParams, view: sublime.View) -> 'Request':
         return Request("textDocument/documentLink", params, view)
 
     @classmethod
-    def semanticTokensFull(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def semanticTokensFull(cls, params: SemanticTokensParams, view: sublime.View) -> 'Request':
         return Request("textDocument/semanticTokens/full", params, view)
 
     @classmethod
-    def semanticTokensFullDelta(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def semanticTokensFullDelta(cls, params: SemanticTokensDeltaParams, view: sublime.View) -> 'Request':
         return Request("textDocument/semanticTokens/full/delta", params, view)
 
     @classmethod
-    def semanticTokensRange(cls, params: Mapping[str, Any], view: sublime.View) -> 'Request':
+    def semanticTokensRange(cls, params: SemanticTokensRangeParams, view: sublime.View) -> 'Request':
         return Request("textDocument/semanticTokens/range", params, view)
 
     @classmethod
@@ -5928,6 +5928,18 @@ def inlayHint(cls, params: InlayHintParams, view: sublime.View) -> 'Request':
     def resolveInlayHint(cls, params: InlayHint, view: sublime.View) -> 'Request':
         return Request('inlayHint/resolve', params, view)
 
+    @classmethod
+    def rename(cls, params: RenameParams, view: sublime.View, progress: bool = False) -> 'Request':
+        return Request('textDocument/rename', params, view, progress)
+
+    @classmethod
+    def prepareRename(cls, params: PrepareRenameParams, view: sublime.View, progress: bool = False) -> 'Request':
+        return Request('textDocument/prepareRename', params, view, progress)
+
+    @classmethod
+    def selectionRange(cls, params: SelectionRangeParams) -> 'Request':
+        return Request('textDocument/selectionRange', params)
+
     @classmethod
     def workspaceSymbol(cls, params: WorkspaceSymbolParams) -> 'Request':
         return Request("workspace/symbol", params, None, progress=True)
@@ -6003,35 +6015,35 @@ def initialized(cls) -> 'Notification':
         return Notification("initialized", {})
 
     @classmethod
-    def didOpen(cls, params: dict) -> 'Notification':
+    def didOpen(cls, params: DidOpenTextDocumentParams) -> 'Notification':
         return Notification("textDocument/didOpen", params)
 
     @classmethod
-    def didChange(cls, params: dict) -> 'Notification':
+    def didChange(cls, params: DidChangeTextDocumentParams) -> 'Notification':
         return Notification("textDocument/didChange", params)
 
     @classmethod
-    def willSave(cls, params: dict) -> 'Notification':
+    def willSave(cls, params: WillSaveTextDocumentParams) -> 'Notification':
         return Notification("textDocument/willSave", params)
 
     @classmethod
-    def didSave(cls, params: dict) -> 'Notification':
+    def didSave(cls, params: DidSaveTextDocumentParams) -> 'Notification':
         return Notification("textDocument/didSave", params)
 
     @classmethod
-    def didClose(cls, params: dict) -> 'Notification':
+    def didClose(cls, params: DidCloseTextDocumentParams) -> 'Notification':
         return Notification("textDocument/didClose", params)
 
     @classmethod
-    def didChangeConfiguration(cls, params: dict) -> 'Notification':
+    def didChangeConfiguration(cls, params: DidChangeConfigurationParams) -> 'Notification':
         return Notification("workspace/didChangeConfiguration", params)
 
     @classmethod
-    def didChangeWatchedFiles(cls, params: dict) -> 'Notification':
+    def didChangeWatchedFiles(cls, params: DidChangeWatchedFilesParams) -> 'Notification':
         return Notification("workspace/didChangeWatchedFiles", params)
 
     @classmethod
-    def didChangeWorkspaceFolders(cls, params: dict) -> 'Notification':
+    def didChangeWorkspaceFolders(cls, params: DidChangeWorkspaceFoldersParams) -> 'Notification':
         return Notification("workspace/didChangeWorkspaceFolders", params)
 
     @classmethod

plugin/core/sessions.py

@@ -27,6 +27,7 @@
 from .protocol import DiagnosticSeverity
 from .protocol import DiagnosticTag
 from .protocol import DidChangeWatchedFilesRegistrationOptions
+from .protocol import DidChangeWorkspaceFoldersParams
 from .protocol import DocumentLink
 from .protocol import DocumentUri
 from .protocol import Error
@@ -35,9 +36,11 @@
 from .protocol import FailureHandlingKind
 from .protocol import FileEvent
 from .protocol import GeneralClientCapabilities
+from .protocol import InitializeParams
 from .protocol import InsertTextMode
 from .protocol import Location
 from .protocol import LocationLink
+from .protocol import LSPAny
 from .protocol import LSPObject
 from .protocol import MarkupKind
 from .protocol import Notification
@@ -205,7 +208,7 @@ def _enum_like_class_to_list(c: Type[object]) -> List[Union[int, str]]:
 
 
 def get_initialize_params(variables: Dict[str, str], workspace_folders: List[WorkspaceFolder],
-                          config: ClientConfig) -> dict:
+                          config: ClientConfig) -> InitializeParams:
     completion_kinds = cast(List[CompletionItemKind], _enum_like_class_to_list(CompletionItemKind))
     symbol_kinds = cast(List[SymbolKind], _enum_like_class_to_list(SymbolKind))
     diagnostic_tag_value_set = cast(List[DiagnosticTag], _enum_like_class_to_list(DiagnosticTag))
@@ -452,7 +455,7 @@ def get_initialize_params(variables: Dict[str, str], workspace_folders: List[Wor
         "rootPath": first_folder.path if first_folder else None,
         "workspaceFolders": [folder.to_lsp() for folder in workspace_folders] if workspace_folders else None,
         "capabilities": capabilities,
-        "initializationOptions": config.init_options.get_resolved(variables)
+        "initializationOptions": cast(LSPAny, config.init_options.get_resolved(variables))
     }
 
 
@@ -1348,7 +1351,7 @@ def update_folders(self, folders: List[WorkspaceFolder]) -> None:
                         "added": [a.to_lsp() for a in added],
                         "removed": [r.to_lsp() for r in removed]
                     }
-                }
+                }  # type: DidChangeWorkspaceFoldersParams
                 self.send_notification(Notification.didChangeWorkspaceFolders(params))
         if self._supports_workspace_folders():
             self._workspace_folders = folders

plugin/core/views.py

@@ -13,6 +13,11 @@
 from .protocol import Diagnostic
 from .protocol import DiagnosticRelatedInformation
 from .protocol import DiagnosticSeverity
+from .protocol import DidChangeTextDocumentParams
+from .protocol import DidCloseTextDocumentParams
+from .protocol import DidOpenTextDocumentParams
+from .protocol import DidSaveTextDocumentParams
+from .protocol import DocumentColorParams
 from .protocol import DocumentHighlightKind
 from .protocol import DocumentUri
 from .protocol import ExperimentalTextDocumentRangeParams
@@ -25,9 +30,15 @@
 from .protocol import Position
 from .protocol import Range
 from .protocol import Request
+from .protocol import SelectionRangeParams
 from .protocol import SymbolKind
+from .protocol import TextDocumentContentChangeEvent
 from .protocol import TextDocumentIdentifier
+from .protocol import TextDocumentItem
 from .protocol import TextDocumentPositionParams
+from .protocol import TextDocumentSaveReason
+from .protocol import VersionedTextDocumentIdentifier
+from .protocol import WillSaveTextDocumentParams
 from .settings import userprefs
 from .types import ClientConfig
 from .typing import Callable, Optional, Dict, Any, Iterable, List, Union, Tuple, cast
@@ -448,7 +459,7 @@ def entire_content_range(view: sublime.View) -> Range:
     return region_to_range(view, entire_content_region(view))
 
 
-def text_document_item(view: sublime.View, language_id: str) -> Dict[str, Any]:
+def text_document_item(view: sublime.View, language_id: str) -> TextDocumentItem:
     return {
         "uri": uri_from_view(view),
         "languageId": language_id,
@@ -457,7 +468,7 @@ def text_document_item(view: sublime.View, language_id: str) -> Dict[str, Any]:
     }
 
 
-def versioned_text_document_identifier(view: sublime.View, version: int) -> Dict[str, Any]:
+def versioned_text_document_identifier(view: sublime.View, version: int) -> VersionedTextDocumentIdentifier:
     return {"uri": uri_from_view(view), "version": version}
 
 
@@ -474,11 +485,11 @@ def text_document_range_params(view: sublime.View, location: int,
     }
 
 
-def did_open_text_document_params(view: sublime.View, language_id: str) -> Dict[str, Any]:
+def did_open_text_document_params(view: sublime.View, language_id: str) -> DidOpenTextDocumentParams:
     return {"textDocument": text_document_item(view, language_id)}
 
 
-def render_text_change(change: sublime.TextChange) -> Dict[str, Any]:
+def render_text_change(change: sublime.TextChange) -> TextDocumentContentChangeEvent:
     # Note: cannot use protocol.Range because these are "historic" points.
     return {
         "range": {
@@ -489,10 +500,14 @@ def render_text_change(change: sublime.TextChange) -> Dict[str, Any]:
     }
 
 
-def did_change_text_document_params(view: sublime.View, version: int,
-                                    changes: Optional[Iterable[sublime.TextChange]] = None) -> Dict[str, Any]:
-    content_changes = []  # type: List[Dict[str, Any]]
-    result = {"textDocument": versioned_text_document_identifier(view, version), "contentChanges": content_changes}
+def did_change_text_document_params(
+    view: sublime.View, version: int, changes: Optional[Iterable[sublime.TextChange]] = None
+) -> DidChangeTextDocumentParams:
+    content_changes = []  # type: List[TextDocumentContentChangeEvent]
+    result = {
+        "textDocument": versioned_text_document_identifier(view, version),
+        "contentChanges": content_changes
+    }  # type: DidChangeTextDocumentParams
     if changes is None:
         # TextDocumentSyncKind.Full
         content_changes.append({"text": entire_content(view)})
@@ -503,21 +518,24 @@ def did_change_text_document_params(view: sublime.View, version: int,
     return result
 
 
-def will_save_text_document_params(view_or_uri: Union[DocumentUri, sublime.View], reason: int) -> Dict[str, Any]:
+def will_save_text_document_params(
+    view_or_uri: Union[DocumentUri, sublime.View], reason: TextDocumentSaveReason
+) -> WillSaveTextDocumentParams:
     return {"textDocument": text_document_identifier(view_or_uri), "reason": reason}
 
 
 def did_save_text_document_params(
     view: sublime.View, include_text: bool, uri: Optional[DocumentUri] = None
-) -> Dict[str, Any]:
-    identifier = text_document_identifier(uri if uri is not None else view)
-    result = {"textDocument": identifier}  # type: Dict[str, Any]
+) -> DidSaveTextDocumentParams:
+    result = {
+        "textDocument": text_document_identifier(uri if uri is not None else view)
+    }  # type: DidSaveTextDocumentParams
     if include_text:
         result["text"] = entire_content(view)
     return result
 
 
-def did_close_text_document_params(uri: DocumentUri) -> Dict[str, Any]:
+def did_close_text_document_params(uri: DocumentUri) -> DidCloseTextDocumentParams:
     return {"textDocument": text_document_identifier(uri)}
 
 
@@ -530,11 +548,11 @@ def did_change(view: sublime.View, version: int,
     return Notification.didChange(did_change_text_document_params(view, version, changes))
 
 
-def will_save(uri: DocumentUri, reason: int) -> Notification:
+def will_save(uri: DocumentUri, reason: TextDocumentSaveReason) -> Notification:
     return Notification.willSave(will_save_text_document_params(uri, reason))
 
 
-def will_save_wait_until(view: sublime.View, reason: int) -> Request:
+def will_save_wait_until(view: sublime.View, reason: TextDocumentSaveReason) -> Request:
     return Request.willSaveWaitUntil(will_save_text_document_params(view, reason), view)
 
 
@@ -579,7 +597,7 @@ def text_document_range_formatting(view: sublime.View, region: sublime.Region) -
     }, view, progress=True)
 
 
-def selection_range_params(view: sublime.View) -> Dict[str, Any]:
+def selection_range_params(view: sublime.View) -> SelectionRangeParams:
     return {
         "textDocument": text_document_identifier(view),
         "positions": [position(view, r.b) for r in view.sel()]
@@ -839,7 +857,7 @@ def lsp_color_to_phantom(view: sublime.View, color_info: ColorInformation) -> su
     return sublime.Phantom(region, lsp_color_to_html(color_info), sublime.LAYOUT_INLINE)
 
 
-def document_color_params(view: sublime.View) -> Dict[str, Any]:
+def document_color_params(view: sublime.View) -> DocumentColorParams:
     return {"textDocument": text_document_identifier(view)}
 
 

plugin/core/workspace.py

@@ -1,5 +1,6 @@
+from .protocol import WorkspaceFolder as LspWorkspaceFolder
 from .types import diff
-from .typing import Any, Dict, List, Union
+from .typing import Any, List, Union
 from .url import filename_to_uri
 import sublime
 import os
@@ -40,7 +41,7 @@ def __eq__(self, other: Any) -> bool:
             return self.name == other.name and self.path == other.path
         return False
 
-    def to_lsp(self) -> Dict[str, str]:
+    def to_lsp(self) -> LspWorkspaceFolder:
         return {"name": self.name, "uri": self.uri()}
 
     def uri(self) -> str:

plugin/document_link.py

@@ -1,7 +1,9 @@
 from .core.logging import debug
 from .core.open import open_file_uri
 from .core.open import open_in_browser
-from .core.protocol import DocumentLink, Request
+from .core.protocol import DocumentLink
+from .core.protocol import Request
+from .core.protocol import URI
 from .core.registry import get_position
 from .core.registry import LspTextCommand
 from .core.typing import Optional
@@ -54,7 +56,7 @@ def _on_resolved_async(self, response: DocumentLink) -> None:
         if target is not None:
             self.open_target(target)
 
-    def open_target(self, target: str) -> None:
+    def open_target(self, target: URI) -> None:
         if target.startswith("file:"):
             window = self.view.window()
             if window: