Added id and AllowsDynamicRegistration to descriptor, removed registration and create the registrations on demand as needed

Author: david-driscoll

src/JsonRpc/RequestRouterBase.cs

@@ -65,7 +65,7 @@ public async Task RouteNotification(TDescriptor descriptor, Notification notific
                                 @params = notification.Params?.ToObject(descriptor.Params, _serializer.JsonSerializer);
                             }
 
-                            await HandleNotification(mediator, descriptor, @params ?? EmptyRequest.Instance, token);
+                            await HandleNotification(mediator, descriptor, @params ?? Activator.CreateInstance(descriptor.Params), token);
                         }
                     }
                     catch (Exception e)

src/Server/Abstractions/ILspHandlerDescriptor.cs

@@ -6,10 +6,11 @@ namespace OmniSharp.Extensions.LanguageServer.Server.Abstractions
 {
     public interface ILspHandlerDescriptor : IHandlerDescriptor
     {
+        Guid Id { get; }
         bool HasRegistration { get; }
         Type RegistrationType { get; }
-        object RegisterOptions { get; }
-        Registration Registration { get; }
+        object RegistrationOptions { get; }
+        bool AllowsDynamicRegistration { get; }
 
         bool HasCapability { get; }
         Type CapabilityType { get; }

src/Server/ClientCapabilityProvider.cs

@@ -92,29 +92,29 @@ public TOptions Get<TInterface, TOptions>(Func<TInterface, TOptions> action)
                 where TOptions : class
             {
                 return _collection
-                    .Select(x => x.RegisterOptions is TInterface cl ? action(cl) : null)
+                    .Select(x => x.RegistrationOptions is TInterface cl ? action(cl) : null)
                     .FirstOrDefault(x => x != null);
             }
 
             public Supports<TOptions> Can<TInterface, TOptions>(Func<TInterface, TOptions> action)
                 where TOptions : class
             {
                 var options = _collection
-                    .Select(x => x.RegisterOptions is TInterface cl ? action(cl) : null)
+                    .Select(x => x.RegistrationOptions is TInterface cl ? action(cl) : null)
                     .FirstOrDefault(x => x != null);
                 if (options == null)
                     return Supports.OfBoolean<TOptions>(false);
 
                 return _collection
-                    .Select(x => x.RegisterOptions is TInterface cl ? action(cl) : null)
+                    .Select(x => x.RegistrationOptions is TInterface cl ? action(cl) : null)
                     .FirstOrDefault(x => x != null);
             }
 
             public TOptions Reduce<TInterface, TOptions>(Func<IEnumerable<TInterface>, TOptions> action)
                 where TOptions : class
             {
                 return action(_collection
-                    .Select(x => x.RegisterOptions is TInterface cl ? cl : default)
+                    .Select(x => x.RegistrationOptions is TInterface cl ? cl : default)
                     .Where(x => x != null));
             }
         }

src/Server/HandlerCollection.cs

@@ -145,7 +145,6 @@ private HandlerDescriptor GetDescriptor(string method, Type handlerType, IJsonRp
 
             Type @params = null;
             object registrationOptions = null;
-            Registration registration = null;
             if (@interface.GetTypeInfo().IsGenericType)
             {
                 @params = @interface.GetTypeInfo().GetGenericArguments()[0];
@@ -156,15 +155,6 @@ private HandlerDescriptor GetDescriptor(string method, Type handlerType, IJsonRp
                 registrationOptions = GetRegistrationMethod
                     .MakeGenericMethod(registrationType)
                     .Invoke(null, new object[] { handler });
-
-                if (_supportedCapabilities.AllowsDynamicRegistration(capabilityType))
-                {
-                    registration = new Registration() {
-                        Id = Guid.NewGuid().ToString(),
-                        Method = method,
-                        RegisterOptions = registrationOptions
-                    };
-                }
             }
 
             var key = "default";
@@ -194,7 +184,7 @@ private HandlerDescriptor GetDescriptor(string method, Type handlerType, IJsonRp
                 @params,
                 registrationType,
                 registrationOptions,
-                registration,
+                registrationType != null && _supportedCapabilities.AllowsDynamicRegistration(capabilityType),
                 capabilityType,
                 () => {
                     _handlers.RemoveWhere(d => d.Handler == handler);

src/Server/HandlerDescriptor.cs

@@ -22,12 +22,13 @@ public HandlerDescriptor(
             Type handlerType,
             Type @params,
             Type registrationType,
-            object registerOptions,
-            Registration registration,
+            object registrationOptions,
+            bool allowsDynamicRegistration,
             Type capabilityType,
             Action disposeAction)
         {
             _disposeAction = disposeAction;
+            Id = Guid.NewGuid();
             Method = method;
             Key = key;
             ImplementationType = handler.GetType();
@@ -36,8 +37,8 @@ public HandlerDescriptor(
             Params = @params;
             Response = Response;
             RegistrationType = registrationType;
-            RegisterOptions = registerOptions;
-            Registration = registration;
+            RegistrationOptions = registrationOptions;
+            AllowsDynamicRegistration = allowsDynamicRegistration;
             CapabilityType = capabilityType;
 
             var requestInterface = @params?.GetInterfaces()
@@ -65,10 +66,11 @@ public HandlerDescriptor(
         public Type ImplementationType { get; }
         public Type HandlerType { get; }
 
+        public Guid Id { get; }
         public bool HasRegistration => RegistrationType != null;
         public Type RegistrationType { get; }
-        public object RegisterOptions { get; }
-        public Registration Registration { get; }
+        public object RegistrationOptions { get; }
+        public bool AllowsDynamicRegistration { get; }
 
         public bool HasCapability => CapabilityType != null;
         public Type CapabilityType { get; }

src/Server/ISupportedCapabilities.cs

@@ -6,7 +6,6 @@ namespace OmniSharp.Extensions.LanguageServer.Server
 {
     public interface ISupportedCapabilities
     {
-        bool AllowsDynamicRegistration(ILspHandlerDescriptor descriptor);
         bool AllowsDynamicRegistration(Type capabilityType);
         void SetCapability(ILspHandlerDescriptor descriptor, IJsonRpcHandler handler);
     }

src/Server/LanguageServer.cs

@@ -328,8 +328,12 @@ private IDisposable RegisterHandlers(LspHandlerDescriptorDisposable handlerDispo
             using (var scope = _serviceProvider.CreateScope())
             {
                 var registrations = handlerDisposable.Descriptors
-                    .Select(x => x.Registration)
-                    .Where(x => x != null)
+                    .Where(d => d.AllowsDynamicRegistration)
+                    .Select(d => new Registration() {
+                        Id = d.Id.ToString(),
+                        Method = d.Method,
+                        RegisterOptions = d.RegistrationOptions
+                    })
                     .ToArray();
 
                 // Fire and forget

src/Server/Matchers/ExecuteCommandMatcher.cs

@@ -28,7 +28,7 @@ public IEnumerable<ILspHandlerDescriptor> FindHandler(object parameters, IEnumer
                 _logger.LogTrace("Registration options {OptionsName}", executeCommandParams.GetType().FullName);
                 foreach (var descriptor in descriptors)
                 {
-                    if (descriptor.RegisterOptions is ExecuteCommandRegistrationOptions registrationOptions && registrationOptions.Commands.Any(x => x == executeCommandParams.Command))
+                    if (descriptor.RegistrationOptions is ExecuteCommandRegistrationOptions registrationOptions && registrationOptions.Commands.Any(x => x == executeCommandParams.Command))
                     {
                         _logger.LogTrace("Checking handler {Method}:{Handler}",
                             executeCommandParams.Command,

src/Server/Matchers/TextDocumentMatcher.cs

@@ -75,7 +75,7 @@ private IEnumerable<ILspHandlerDescriptor> GetHandler(IEnumerable<ILspHandlerDes
             foreach (var descriptor in descriptors)
             {
                 _logger.LogTrace("Checking handler {Method}:{Handler}", method, descriptor.ImplementationType.FullName);
-                var registrationOptions = descriptor.RegisterOptions as ITextDocumentRegistrationOptions;
+                var registrationOptions = descriptor.RegistrationOptions as ITextDocumentRegistrationOptions;
 
                 _logger.LogTrace("Registration options {OptionsName}", registrationOptions?.GetType().FullName);
                 _logger.LogTrace("Document Selector {DocumentSelector}", registrationOptions?.DocumentSelector.ToString());

src/Server/SupportedCapabilities.cs

@@ -28,16 +28,6 @@ public void Add(IEnumerable<ISupports> supports)
             }
         }
 
-        public bool AllowsDynamicRegistration(ILspHandlerDescriptor descriptor)
-        {
-            if (descriptor.HasCapability && _supports.TryGetValue(descriptor.CapabilityType, out var capability))
-            {
-                if (capability is DynamicCapability dc)
-                    return dc.DynamicRegistration;
-            }
-            return false;
-        }
-
         public bool AllowsDynamicRegistration(Type capabilityType)
         {
             if (_supports.TryGetValue(capabilityType, out var capability))