Send completion request to multiple sessions

plugin/completion.py

@@ -3,7 +3,7 @@
 import webbrowser
 from .core.logging import debug
 from .core.edit import parse_text_edit
-from .core.protocol import Request, InsertTextFormat, Range
+from .core.protocol import Request, InsertTextFormat, Range, CompletionItem
 from .core.registry import LspTextCommand
 from .core.typing import Any, List, Dict, Optional, Generator, Union
 from .core.views import FORMAT_STRING, FORMAT_MARKUP_CONTENT, minihtml
@@ -14,9 +14,9 @@
 
 class LspResolveDocsCommand(LspTextCommand):
 
-    completions = []  # type: List[Dict[str, Any]]
+    completions = []  # type: List[CompletionItem]
 
-    def run(self, edit: sublime.Edit, index: int, event: Optional[dict] = None) -> None:
+    def run(self, edit: sublime.Edit, index: int, session_name: str, event: Optional[dict] = None) -> None:
         item = self.completions[index]
         detail = self.format_documentation(item.get('detail') or "")
         documentation = self.format_documentation(item.get("documentation") or "")
@@ -25,8 +25,8 @@ def run(self, edit: sublime.Edit, index: int, event: Optional[dict] = None) -> N
         if not detail or not documentation:
             # To make sure that the detail or documentation fields doesn't exist we need to resove the completion item.
             # If those fields appear after the item is resolved we show them in the popup.
-            session = self.best_session('completionProvider.resolveProvider')
-            if session:
+            session = self.session_by_name(session_name)
+            if session and session.has_capability('completionProvider.resolveProvider'):
                 session.send_request(Request.resolveCompletionItem(item, self.view), self.handle_resolve_response)
                 return
         minihtml_content = self.get_content(documentation, detail)

plugin/core/protocol.py

@@ -151,13 +151,11 @@ class SignatureHelpTriggerKind:
     'targetSelectionRange': Dict[str, Any]
 }, total=False)
 
-
 DiagnosticRelatedInformation = TypedDict('DiagnosticRelatedInformation', {
     'location': Location,
     'message': str
 }, total=False)
 
-
 Diagnostic = TypedDict('Diagnostic', {
     'range': RangeLsp,
     'severity': int,
@@ -169,6 +167,13 @@ class SignatureHelpTriggerKind:
     'relatedInformation': List[DiagnosticRelatedInformation]
 }, total=False)
 
+CompletionItem = Dict[str, Any]
+
+CompletionList = TypedDict('CompletionList', {
+    'isIncomplete': bool,
+    'items': List[CompletionItem],
+}, total=True)
+
 
 class Request:
 

plugin/core/views.py

@@ -1,4 +1,5 @@
 from .css import css as lsp_css
+from .protocol import CompletionItem
 from .protocol import CompletionItemTag
 from .protocol import Diagnostic
 from .protocol import DiagnosticRelatedInformation
@@ -672,7 +673,7 @@ def format_diagnostic_for_html(view: sublime.View, diagnostic: Diagnostic, base_
     return "".join(formatted)
 
 
-def _is_completion_item_deprecated(item: dict) -> bool:
+def _is_completion_item_deprecated(item: CompletionItem) -> bool:
     if item.get("deprecated", False):
         return True
     tags = item.get("tags")
@@ -682,7 +683,7 @@ def _is_completion_item_deprecated(item: dict) -> bool:
 
 
 def format_completion(
-    item: dict, index: int, can_resolve_completion_items: bool, session_name: str
+    item: CompletionItem, index: int, can_resolve_completion_items: bool, session_name: str
 ) -> sublime.CompletionItem:
     # This is a hot function. Don't do heavy computations or IO in this function.
     item_kind = item.get("kind")
@@ -707,7 +708,7 @@ def format_completion(
 
     st_details = ""
     if can_resolve_completion_items or item.get("documentation"):
-        st_details += make_command_link("lsp_resolve_docs", "More", {"index": index})
+        st_details += make_command_link("lsp_resolve_docs", "More", {"index": index, "session_name": session_name})
         st_details += " | " if lsp_detail else ""
 
     st_details += "<p>{}</p>".format(lsp_detail)

plugin/documents.py

@@ -2,10 +2,14 @@
 from .code_actions import CodeActionsByConfigName
 from .completion import LspResolveDocsCommand
 from .core.logging import debug
+from .core.promise import Promise
 from .core.protocol import CodeLens
 from .core.protocol import Command
+from .core.protocol import CompletionItem
+from .core.protocol import CompletionList
 from .core.protocol import Diagnostic
 from .core.protocol import DocumentHighlightKind
+from .core.protocol import Error
 from .core.protocol import Notification
 from .core.protocol import Range
 from .core.protocol import Request
@@ -52,7 +56,12 @@
     DocumentHighlightKind.Write: "write"
 }
 
-ResolveCompletionsFn = Callable[[List[sublime.CompletionItem], int], None]
+Flags = int
+ResolveCompletionsFn = Callable[[List[sublime.CompletionItem], Flags], None]
+
+SessionName = str
+CompletionResponse = Union[List[CompletionItem], CompletionList, None]
+ResolvedCompletions = Tuple[Union[CompletionResponse, Error], SessionName]
 
 
 def is_regular_view(v: sublime.View) -> bool:
@@ -606,46 +615,64 @@ def render_highlights_on_main_thread() -> None:
 
     # --- textDocument/complete ----------------------------------------------------------------------------------------
 
-    def _on_query_completions_async(self, resolve: ResolveCompletionsFn, location: int) -> None:
-        session = self.session('completionProvider', location)
-        if not session:
-            resolve([], 0)
+    def _on_query_completions_async(self, resolve_completion_list: ResolveCompletionsFn, location: int) -> None:
+        sessions = self.sessions('completionProvider')
+        if not sessions:
+            resolve_completion_list([], 0)
             return
         self.purge_changes_async()
-        can_resolve_completion_items = bool(session.get_capability('completionProvider.resolveProvider'))
-        config_name = session.config.name
-        session.send_request_async(
-            Request.complete(text_document_position_params(self.view, location), self.view),
-            lambda res: self._on_complete_result(res, resolve, can_resolve_completion_items, config_name),
-            lambda res: self._on_complete_error(res, resolve))
-
-    def _on_complete_result(self, response: Optional[Union[dict, List]], resolve: ResolveCompletionsFn,
-                            can_resolve_completion_items: bool, session_name: str) -> None:
-        response_items = []  # type: List[Dict]
-        flags = 0
+        completion_promises = []  # type: List[Promise[ResolvedCompletions]]
+        for session in sessions:
+
+            def completion_request() -> Promise[ResolvedCompletions]:
+                return session.send_request_task(
+                    Request.complete(text_document_position_params(self.view, location), self.view)
+                ).then(lambda response: (response, session.config.name))
+
+            completion_promises.append(completion_request())
+        LspResolveDocsCommand.completions = []
+        Promise.all(completion_promises).then(
+            lambda responses: self._on_all_settled(responses, resolve_completion_list))
+
+    def _on_all_settled(
+        self,
+        responses: List[ResolvedCompletions],
+        resolve_completion_list: ResolveCompletionsFn
+    ) -> None:
+        items = []  # type: List[sublime.CompletionItem]
+        errors = []  # type: List[Error]
+        flags = 0  # int
         prefs = userprefs()
         if prefs.inhibit_snippet_completions:
             flags |= sublime.INHIBIT_EXPLICIT_COMPLETIONS
         if prefs.inhibit_word_completions:
             flags |= sublime.INHIBIT_WORD_COMPLETIONS
-        if isinstance(response, dict):
-            response_items = response["items"] or []
-            if response.get("isIncomplete", False):
-                flags |= sublime.DYNAMIC_COMPLETIONS
-        elif isinstance(response, list):
-            response_items = response
-        response_items = sorted(response_items, key=lambda item: item.get("sortText") or item["label"])
-        LspResolveDocsCommand.completions = response_items
-        items = [format_completion(response_item, index, can_resolve_completion_items, session_name)
-                 for index, response_item in enumerate(response_items)]
+        for response, session_name in responses:
+            if isinstance(response, Error):
+                errors.append(response)
+                continue
+            session = self.session_by_name(session_name)
+            if not session:
+                continue
+            response_items = []  # type: List[CompletionItem]
+            if isinstance(response, dict):
+                response_items = response["items"] or []
+                if response.get("isIncomplete", False):
+                    flags |= sublime.DYNAMIC_COMPLETIONS
+            elif isinstance(response, list):
+                response_items = response
+            response_items = sorted(response_items, key=lambda item: item.get("sortText") or item["label"])
+            LspResolveDocsCommand.completions.extend(response_items)
+            can_resolve_completion_items = session.has_capability('completionProvider.resolveProvider')
+            items.extend(
+                format_completion(response_item, len(items) + index, can_resolve_completion_items, session.config.name)
+                for index, response_item in enumerate(response_items))
         if items:
             flags |= sublime.INHIBIT_REORDER
-        resolve(items, flags)
-
-    def _on_complete_error(self, error: dict, resolve: ResolveCompletionsFn) -> None:
-        resolve([], 0)
-        LspResolveDocsCommand.completions = []
-        sublime.status_message('Completion error: ' + str(error.get('message')))
+        if errors:
+            error_messages = ", ".join(str(error) for error in errors)
+            sublime.status_message('Completion error: {}'.format(error_messages))
+        resolve_completion_list(items, flags)
 
     # --- Public utility methods ---------------------------------------------------------------------------------------
 
@@ -665,6 +692,12 @@ def sessions(self, capability: Optional[str]) -> Generator[Session, None, None]:
     def session(self, capability: str, point: Optional[int] = None) -> Optional[Session]:
         return best_session(self.view, self.sessions(capability), point)
 
+    def session_by_name(self, name: Optional[str] = None) -> Optional[Session]:
+        for sb in self.session_buffers_async():
+            if sb.session.config.name == name:
+                return sb.session
+        return None
+
     def get_capability_async(self, session: Session, capability_path: str) -> Optional[Any]:
         for sv in self.session_views_async():
             if sv.session == session:

tests/test_completion.py

@@ -78,7 +78,7 @@ def verify(self, *, completion_items: List[Dict[str, Any]], insert_text: str, ex
     def test_none(self) -> 'Generator':
         self.set_response("textDocument/completion", None)
         self.view.run_command('auto_complete')
-        yield lambda: self.view.is_auto_complete_visible()
+        yield lambda: self.view.is_auto_complete_visible() is False
 
     def test_simple_label(self) -> 'Generator':
         yield from self.verify(