feat: use pygls for json-rpc language client and add support for lsprotocol 2025.0.0

Author: hlouzada

spyder/plugins/completion/providers/languageserver/client.py

@@ -4,63 +4,89 @@
 # Licensed under the terms of the MIT License
 # (see spyder/__init__.py for details)
 
-"""Spyder Language Server Protocol Client auxiliar decorators."""
+"""
+Spyder Language Server Protocol Client auxiliary decorators.
+
+send_request / send_notification / send_response are now *marker* decorators:
+they tag a method with the LSP method name it corresponds to and its kind
+('request', 'notification', 'response').  The actual sending is done by
+LSPClient.perform_request(), which inspects these attributes via the
+sender_registry built by @class_register.
+
+Each tagged method is expected to:
+  - Accept Spyder's internal params dict.
+  - Return a lsprotocol typed object (the LSP params to send), or None to
+    cancel the operation.
+
+@handles(method_name) marks a method as the handler for an LSP response or
+server-initiated notification carrying that method name.
+
+@class_register scans a class at definition time and builds:
+  - handler_registry  : {method_name: handler_method_name}
+  - sender_registry   : {method_name: sender_method_name}
+  - notification_registry : {method_name}; subset of sender methods that are
+                            notifications (no response expected).
+"""
 
 import functools
-from spyder.plugins.completion.providers.languageserver.transport import (
-    MessageKind)
 
 
 def send_request(req=None, method=None):
-    """Send message as a proper JSON-RPC request."""
+    """Mark *req* as a method that builds params for an LSP request."""
     if req is None:
         return functools.partial(send_request, method=method)
-
-    return send_message(req, method, kind=MessageKind.REQUEST)
+    req._sends = method
+    req._kind = 'request'
+    return req
 
 
 def send_notification(req=None, method=None):
-    """Send message as a proper JSON-RPC notification."""
+    """Mark *req* as a method that builds params for an LSP notification."""
     if req is None:
         return functools.partial(send_notification, method=method)
-
-    return send_message(req, method, kind=MessageKind.NOTIFICATION)
+    req._sends = method
+    req._kind = 'notification'
+    return req
 
 
 def send_response(req=None, method=None):
-    """Send message as a proper JSON-RPC response."""
+    """
+    Mark *req* as a handler for a server-request that requires a response.
+
+    With pygls the response is sent automatically by the feature manager when
+    the registered handler returns a value, so this decorator is retained
+    only for semantic clarity and registry bookkeeping.
+    """
     if req is None:
         return functools.partial(send_response, method=method)
-
-    return send_message(req, method, kind=MessageKind.RESPONSE)
-
-
-def send_message(req=None, method=None, kind=MessageKind.REQUEST):
-    """Call function req and then send its results via ZMQ."""
-    @functools.wraps(req)
-    def wrapper(self, *args, **kwargs):
-        params = req(self, *args, **kwargs)
-        _id = self.send(method, params, kind)
-        return _id
-    wrapper._sends = method
-    return wrapper
+    req._sends = method
+    req._kind = 'response'
+    return req
 
 
 def class_register(cls):
-    """Class decorator that allows to map LSP method names to class methods."""
+    """
+    Class decorator that builds handler and sender registries from decorated
+    methods, enabling dynamic dispatch in LSPClient.
+    """
     cls.handler_registry = {}
     cls.sender_registry = {}
+    cls.notification_registry = set()
+
     for method_name in dir(cls):
         method = getattr(cls, method_name)
         if hasattr(method, '_handle'):
-            cls.handler_registry.update({method._handle: method_name})
+            cls.handler_registry[method._handle] = method_name
         if hasattr(method, '_sends'):
-            cls.sender_registry.update({method._sends: method_name})
+            cls.sender_registry[method._sends] = method_name
+            if getattr(method, '_kind', 'request') in ('notification', 'response'):
+                cls.notification_registry.add(method._sends)
+
     return cls
 
 
 def handles(method_name):
-    """Assign an LSP method name to a python handler."""
+    """Tag a method as the handler for LSP *method_name* responses/notifications."""
     def wrapper(func):
         func._handle = method_name
         return func

spyder/plugins/completion/providers/languageserver/decorators.py

@@ -433,8 +433,7 @@ def wrap_message_box(parent):
     @Slot(str)
     def report_lsp_down(self, language):
         """
-        Report that either the transport layer or the LSP server are
-        down.
+        Report that the LSP server is down.
         """
         self.update_status(language, ClientStatus.DOWN)
 

spyder/plugins/completion/providers/languageserver/provider.py

@@ -8,17 +8,23 @@
 
 import logging
 
+from lsprotocol import types as lsp
+
 from spyder.plugins.completion.api import CompletionRequestTypes
-from spyder.plugins.completion.providers.languageserver.decorators import (
-    handles, send_response)
+from spyder.plugins.completion.providers.languageserver.decorators import handles
 
 logger = logging.getLogger(__name__)
 
 
 class ClientProvider:
     @handles(CompletionRequestTypes.CLIENT_REGISTER_CAPABILITY)
-    @send_response
-    def handle_register_capability(self, params):
+    def handle_register_capability(
+        self, params: lsp.RegistrationParams, *args
+    ) -> None:
         """TODO: Handle the glob patterns of the files to watch."""
-        logger.debug('Register Capability: {0}'.format(params))
-        return {}
+        for reg in params.registrations:
+            logger.debug(
+                'Register capability: id=%s method=%s',
+                reg.id,
+                reg.method,
+            )