OmniSharp · david-driscoll · Aug 15, 2020 · Aug 15, 2020
diff --git a/src/Client/LanguageClientOptions.cs b/src/Client/LanguageClientOptions.cs
@@ -8,11 +8,16 @@
 using OmniSharp.Extensions.LanguageServer.Protocol.Client;
 using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Shared;
 
 namespace OmniSharp.Extensions.LanguageServer.Client
 {
     public class LanguageClientOptions : LanguageProtocolRpcOptionsBase<LanguageClientOptions>, ILanguageClientRegistry
     {
+        public LanguageClientOptions()
+        {
+            WithAssemblies(typeof(LanguageClientOptions).Assembly, typeof(LspRequestRouter).Assembly);
+        }
         public ClientCapabilities ClientCapabilities { get; set; } = new ClientCapabilities {
             Experimental = new Dictionary<string, JToken>(),
             Window = new WindowClientCapabilities(),
@@ -36,8 +41,6 @@ public string RootPath
 
         public object InitializationOptions { get; set; }
 
-        public ILspClientReceiver Receiver { get; set; } = new LspClientReceiver();
-
         ILanguageClientRegistry IJsonRpcHandlerRegistry<ILanguageClientRegistry>.AddHandler(string method, IJsonRpcHandler handler, JsonRpcHandlerOptions options) =>
             AddHandler(method, handler, options);
 

diff --git a/src/Client/LanguageClientOptionsExtensions.cs b/src/Client/LanguageClientOptionsExtensions.cs
@@ -23,7 +23,7 @@ public static LanguageClientOptions WithReceiver(
             ILspClientReceiver serverReceiver
         )
         {
-            options.Receiver = serverReceiver;
+            options.Services.AddSingleton(serverReceiver);
             return options;
         }
 

diff --git a/src/Client/LanguageClientRegistrationManager.cs b/src/Client/LanguageClientRegistrationManager.cs
@@ -22,13 +22,18 @@ namespace OmniSharp.Extensions.LanguageServer.Client
     internal class LanguageClientRegistrationManager : IRegisterCapabilityHandler, IUnregisterCapabilityHandler, IRegistrationManager, IDisposable
     {
         private readonly ISerializer _serializer;
+        private readonly ILspHandlerTypeDescriptorProvider _handlerTypeDescriptorProvider;
         private readonly ILogger<LanguageClientRegistrationManager> _logger;
         private readonly ConcurrentDictionary<string, Registration> _registrations;
         private readonly ReplaySubject<IEnumerable<Registration>> _registrationSubject;
 
-        public LanguageClientRegistrationManager(ISerializer serializer, ILogger<LanguageClientRegistrationManager> logger)
+        public LanguageClientRegistrationManager(
+            ISerializer serializer,
+            ILspHandlerTypeDescriptorProvider handlerTypeDescriptorProvider,
+            ILogger<LanguageClientRegistrationManager> logger)
         {
             _serializer = serializer;
+            _handlerTypeDescriptorProvider = handlerTypeDescriptorProvider;
             _logger = logger;
             _registrations = new ConcurrentDictionary<string, Registration>(StringComparer.OrdinalIgnoreCase);
             _registrationSubject = new ReplaySubject<IEnumerable<Registration>>(1);
@@ -65,7 +70,7 @@ public void RegisterCapabilities(ServerCapabilities serverCapabilities)
                 serverCapabilities
             ))
             {
-                var method = LspHandlerTypeDescriptorHelper.GetMethodForRegistrationOptions(registrationOptions);
+                var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
                 if (method == null)
                 {
                     _logger.LogWarning("Unable to find method for given {@RegistrationOptions}", registrationOptions);
@@ -91,7 +96,7 @@ public void RegisterCapabilities(ServerCapabilities serverCapabilities)
                    .Workspace
             ))
             {
-                var method = LspHandlerTypeDescriptorHelper.GetMethodForRegistrationOptions(registrationOptions);
+                var method = _handlerTypeDescriptorProvider.GetMethodForRegistrationOptions(registrationOptions);
                 if (method == null)
                 {
                     // TODO: Log this
@@ -117,7 +122,7 @@ private void Register(params Registration[] registrations)
 
         private void Register(Registration registration)
         {
-            var registrationType = LspHandlerTypeDescriptorHelper.GetRegistrationType(registration.Method);
+            var registrationType = _handlerTypeDescriptorProvider.GetRegistrationType(registration.Method);
             if (registrationType == null)
             {
                 _registrations.AddOrUpdate(registration.Id, x => registration, (a, b) => registration);

diff --git a/src/Client/LanguageClientServiceCollectionExtensions.cs b/src/Client/LanguageClientServiceCollectionExtensions.cs
@@ -18,15 +18,14 @@ public static class LanguageClientServiceCollectionExtensions
     {
         internal static IContainer AddLanguageClientInternals(this IContainer container, LanguageClientOptions options, IServiceProvider outerServiceProvider)
         {
-            if (options.Receiver == null)
-            {
-                throw new ArgumentException("Receiver is missing!", nameof(options));
-            }
-
             container = container.AddLanguageProtocolInternals(options);
 
             container.RegisterInstance(options.ClientCapabilities);
-            container.RegisterInstanceMany(options.Receiver);
+            container.RegisterMany<LspClientReceiver>(
+                reuse: Reuse.Singleton,
+                nonPublicServiceTypes: true,
+                ifAlreadyRegistered: IfAlreadyRegistered.Keep
+            );
             if (options.OnUnhandledException != null)
             {
                 container.RegisterInstance(options.OnUnhandledException);

diff --git a/src/Client/LspClientReceiver.cs b/src/Client/LspClientReceiver.cs
@@ -4,14 +4,21 @@
 using OmniSharp.Extensions.JsonRpc.Client;
 using OmniSharp.Extensions.JsonRpc.Server;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol.Shared;
 using OmniSharp.Extensions.LanguageServer.Protocol.Window;
 
 namespace OmniSharp.Extensions.LanguageServer.Client
 {
     public class LspClientReceiver : Receiver, ILspClientReceiver
     {
+        private readonly ILspHandlerTypeDescriptorProvider _handlerTypeDescriptorProvider;
         private bool _initialized;
 
+        public LspClientReceiver(ILspHandlerTypeDescriptorProvider handlerTypeDescriptorProvider)
+        {
+            _handlerTypeDescriptorProvider = handlerTypeDescriptorProvider;
+        }
+
         public override (IEnumerable<Renor> results, bool hasResponse) GetRequests(JToken container)
         {
             if (_initialized) return base.GetRequests(container);
@@ -23,7 +30,7 @@ public override (IEnumerable<Renor> results, bool hasResponse) GetRequests(JToke
             foreach (var item in results)
             {
                 if (item.IsRequest &&
-                    HandlerTypeDescriptorHelper.IsMethodName(item.Request.Method, typeof(IShowMessageRequestHandler)))
+                    _handlerTypeDescriptorProvider.IsMethodName(item.Request.Method, typeof(IShowMessageRequestHandler)))
                 {
                     newResults.Add(item);
                 }
@@ -32,7 +39,7 @@ public override (IEnumerable<Renor> results, bool hasResponse) GetRequests(JToke
                     newResults.Add(item);
                 }
                 else if (item.IsNotification &&
-                         HandlerTypeDescriptorHelper.IsMethodName(
+                         _handlerTypeDescriptorProvider.IsMethodName(
                              item.Notification.Method,
                              typeof(IShowMessageHandler),
                              typeof(ILogMessageHandler),

diff --git a/src/Dap.Client/DebugAdapterClientOptions.cs b/src/Dap.Client/DebugAdapterClientOptions.cs
@@ -5,12 +5,17 @@
 using OmniSharp.Extensions.DebugAdapter.Protocol;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Client;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
+using OmniSharp.Extensions.DebugAdapter.Shared;
 using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.DebugAdapter.Client
 {
     public class DebugAdapterClientOptions : DebugAdapterRpcOptionsBase<DebugAdapterClientOptions>, IDebugAdapterClientRegistry, IInitializeRequestArguments
     {
+        public DebugAdapterClientOptions()
+        {
+            WithAssemblies(typeof(DebugAdapterClientOptions).Assembly, typeof(DebugAdapterRequestRouter).Assembly);
+        }
         public override IRequestProcessIdentifier RequestProcessIdentifier { get; set; } = new ParallelRequestProcessIdentifier();
         public string ClientId { get; set; }
         public string ClientName { get; set; }

diff --git a/src/Dap.Protocol/DebugAdapterRpcOptionsBase.cs b/src/Dap.Protocol/DebugAdapterRpcOptionsBase.cs
@@ -8,7 +8,12 @@ namespace OmniSharp.Extensions.DebugAdapter.Protocol
 {
     public abstract class DebugAdapterRpcOptionsBase<T> : JsonRpcServerOptionsBase<T> where T : IJsonRpcHandlerRegistry<T>
     {
-        public DebugAdapterRpcOptionsBase() => Services.AddLogging(builder => LoggingBuilderAction?.Invoke(builder));
+        protected DebugAdapterRpcOptionsBase()
+        {
+            Services.AddLogging(builder => LoggingBuilderAction?.Invoke(builder));
+            WithAssemblies(typeof(DebugAdapterRpcOptionsBase<T>).Assembly);
+        }
+
         public ISerializer Serializer { get; set; } = new DapSerializer();
         public override IRequestProcessIdentifier RequestProcessIdentifier { get; set; } = new ParallelRequestProcessIdentifier();
         internal bool AddDefaultLoggingProvider { get; set; }

diff --git a/src/Dap.Server/DebugAdapterServerOptions.cs b/src/Dap.Server/DebugAdapterServerOptions.cs
@@ -5,12 +5,17 @@
 using OmniSharp.Extensions.DebugAdapter.Protocol;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Models;
 using OmniSharp.Extensions.DebugAdapter.Protocol.Server;
+using OmniSharp.Extensions.DebugAdapter.Shared;
 using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.DebugAdapter.Server
 {
     public class DebugAdapterServerOptions : DebugAdapterRpcOptionsBase<DebugAdapterServerOptions>, IDebugAdapterServerRegistry
     {
+        public DebugAdapterServerOptions()
+        {
+            WithAssemblies(typeof(DebugAdapterServerOptions).Assembly, typeof(DebugAdapterRequestRouter).Assembly);
+        }
         public Capabilities Capabilities { get; set; } = new Capabilities();
 
         IDebugAdapterServerRegistry IJsonRpcHandlerRegistry<IDebugAdapterServerRegistry>.AddHandler(string method, IJsonRpcHandler handler, JsonRpcHandlerOptions options) =>

diff --git a/src/Dap.Shared/DebugAdapterHandlerCollection.cs b/src/Dap.Shared/DebugAdapterHandlerCollection.cs
@@ -16,10 +16,15 @@ internal class DebugAdapterHandlerCollection : IEnumerable<IHandlerDescriptor>,
     {
         private ImmutableHashSet<HandlerDescriptor> _descriptors = ImmutableHashSet<HandlerDescriptor>.Empty;
         private readonly IServiceProvider _serviceProvider;
+        private readonly IHandlerTypeDescriptorProvider<IHandlerTypeDescriptor> _handlerTypeDescriptorProvider;
 
         public IEnumerable<IHandlerDescriptor> Descriptors => _descriptors;
 
-        public DebugAdapterHandlerCollection(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
+        public DebugAdapterHandlerCollection(IServiceProvider serviceProvider, IHandlerTypeDescriptorProvider<IHandlerTypeDescriptor> handlerTypeDescriptorProvider)
+        {
+            _serviceProvider = serviceProvider;
+            _handlerTypeDescriptorProvider = handlerTypeDescriptorProvider;
+        }
 
         public IEnumerator<IHandlerDescriptor> GetEnumerator() => _descriptors.GetEnumerator();
 
@@ -107,7 +112,7 @@ private CompositeDisposable AddHandler(IJsonRpcHandler handler, JsonRpcHandlerOp
             var cd = new CompositeDisposable();
             foreach (var (method, implementedInterface) in handler.GetType().GetTypeInfo()
                                                                   .ImplementedInterfaces
-                                                                  .Select(x => ( method: HandlerTypeDescriptorHelper.GetMethodName(x), implementedInterface: x ))
+                                                                  .Select(x => ( method: _handlerTypeDescriptorProvider.GetMethodName(x), implementedInterface: x ))
                                                                   .Distinct(new EqualityComparer())
                                                                   .Where(x => !string.IsNullOrWhiteSpace(x.method))
             )
@@ -122,7 +127,7 @@ private CompositeDisposable AddHandler(IJsonRpcHandler handler, JsonRpcHandlerOp
 
         private HandlerDescriptor GetDescriptor(string method, Type handlerType, IJsonRpcHandler handler, JsonRpcHandlerOptions options)
         {
-            var typeDescriptor = HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(handlerType);
+            var typeDescriptor = _handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(handlerType);
             var @interface = HandlerTypeDescriptorHelper.GetHandlerInterface(handlerType);
 
             return GetDescriptor(method, handlerType, handler, options, typeDescriptor, @interface);

diff --git a/src/Dap.Shared/DebugAdapterProtocolServiceCollectionExtensions.cs b/src/Dap.Shared/DebugAdapterProtocolServiceCollectionExtensions.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Reflection;
 using DryIoc;
 using OmniSharp.Extensions.DebugAdapter.Protocol;
 using OmniSharp.Extensions.JsonRpc;
@@ -15,6 +17,7 @@ internal static IContainer AddDebugAdapterProtocolInternals<T>(this IContainer c
             }
 
             container = container.AddJsonRpcServerCore(options);
+            container.RegisterInstanceMany(new HandlerTypeDescriptorProvider(options.Assemblies), nonPublicServiceTypes: true);
 
             container.RegisterInstanceMany(options.Serializer);
             container.RegisterInstance(options.RequestProcessIdentifier);

diff --git a/src/JsonRpc.Testing/JsonRpcTestOptions.cs b/src/JsonRpc.Testing/JsonRpcTestOptions.cs
@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.IO.Pipelines;
+using System.Linq;
+using System.Reflection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
@@ -25,5 +28,6 @@ public JsonRpcTestOptions(ILoggerFactory clientLoggerFactory, ILoggerFactory ser
         public TimeSpan Timeout { get; internal set; } = TimeSpan.FromMilliseconds(500);
         public TimeSpan CancellationTimeout { get; internal set; } = TimeSpan.FromMinutes(5);
         public PipeOptions DefaultPipeOptions { get; internal set; } = new PipeOptions();
+        public IEnumerable<Assembly> Assemblies { get; set; } = Enumerable.Empty<Assembly>();
     }
 }
diff --git a/src/JsonRpc.Testing/JsonRpcTestOptionsExtensions.cs b/src/JsonRpc.Testing/JsonRpcTestOptionsExtensions.cs
@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.IO.Pipelines;
+using System.Linq;
+using System.Reflection;
 using Microsoft.Extensions.Logging;
 
 namespace OmniSharp.Extensions.JsonRpc.Testing
@@ -41,5 +44,17 @@ public static JsonRpcTestOptions WithDefaultPipeOptions(this JsonRpcTestOptions
             options.DefaultPipeOptions = pipeOptions;
             return options;
         }
+
+        public static JsonRpcTestOptions WithAssemblies(this JsonRpcTestOptions options, IEnumerable<Assembly> assemblies)
+        {
+            options.Assemblies = options.Assemblies.Concat(assemblies).ToArray();
+            return options;
+        }
+
+        public static JsonRpcTestOptions WithAssemblies(this JsonRpcTestOptions options, params Assembly[] assemblies)
+        {
+            options.Assemblies = options.Assemblies.Concat(assemblies).ToArray();
+            return options;
+        }
     }
 }
diff --git a/src/JsonRpc/HandlerCollection.cs b/src/JsonRpc/HandlerCollection.cs
@@ -13,11 +13,16 @@ namespace OmniSharp.Extensions.JsonRpc
     internal class HandlerCollection : IHandlersManager, IEnumerable<IHandlerDescriptor>
     {
         private readonly IServiceProvider _serviceProvider;
+        private readonly IHandlerTypeDescriptorProvider<IHandlerTypeDescriptor> _handlerTypeDescriptorProvider;
         private ImmutableArray<IHandlerDescriptor> _descriptors = ImmutableArray<IHandlerDescriptor>.Empty;
 
         public IEnumerable<IHandlerDescriptor> Descriptors => _descriptors;
 
-        public HandlerCollection(IServiceProvider serviceProvider) => _serviceProvider = serviceProvider;
+        public HandlerCollection(IServiceProvider serviceProvider, IHandlerTypeDescriptorProvider<IHandlerTypeDescriptor> handlerTypeDescriptorProvider)
+        {
+            _serviceProvider = serviceProvider;
+            _handlerTypeDescriptorProvider = handlerTypeDescriptorProvider;
+        }
 
         private void Remove(IJsonRpcHandler handler)
         {
@@ -36,13 +41,13 @@ public IDisposable Add(params IJsonRpcHandler[] handlers)
             foreach (var handler in handlers)
             {
                 if (_descriptors.Any(z => z.Handler == handler)) continue;
-                cd.Add(Add(HandlerTypeDescriptorHelper.GetMethodName(handler.GetType()), handler, null));
+                cd.Add(Add(_handlerTypeDescriptorProvider.GetMethodName(handler.GetType()), handler, null));
             }
 
             return cd;
         }
 
-        public IDisposable Add(IJsonRpcHandler handler, JsonRpcHandlerOptions options) => Add(HandlerTypeDescriptorHelper.GetMethodName(handler.GetType()), handler, options);
+        public IDisposable Add(IJsonRpcHandler handler, JsonRpcHandlerOptions options) => Add(_handlerTypeDescriptorProvider.GetMethodName(handler.GetType()), handler, options);
 
         public IDisposable Add(string method, IJsonRpcHandler handler, JsonRpcHandlerOptions options)
         {
@@ -64,6 +69,7 @@ public IDisposable Add(string method, IJsonRpcHandler handler, JsonRpcHandlerOpt
 
             var requestProcessType =
                 options?.RequestProcessType ??
+                _handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type)?.RequestProcessType ??
                 type.GetCustomAttributes(true)
                     .Concat(@interface.GetCustomAttributes(true))
                     .OfType<ProcessAttribute>()