ensure that internal classes can be registered via Microsoft DI (#324)

david-driscoll · web-flow · commit 5ae6c9a5fb00 · 2020-08-21T01:29:46.000-04:00
* ensure that internal classes can be registered via Microsoft DI

* Added facade for client and server

* Fixed semantic delta params

* Updated test
diff --git a/sample/SampleServer/SemanticTokensHandler.cs b/sample/SampleServer/SemanticTokensHandler.cs
@@ -46,7 +46,7 @@ public override async Task<SemanticTokens> Handle(
             return result;
         }
 
-        public override async Task<SemanticTokensFullOrDelta> Handle(
+        public override async Task<SemanticTokensFullOrDelta?> Handle(
             SemanticTokensDeltaParams request,
             CancellationToken cancellationToken
         )
diff --git a/src/Client/LanguageClientServiceCollectionExtensions.cs b/src/Client/LanguageClientServiceCollectionExtensions.cs
@@ -40,6 +40,7 @@ internal static IContainer AddLanguageClientInternals(this IContainer container,
             container.RegisterMany<GeneralLanguageClient>(serviceTypeCondition: type => type.Name.Contains(nameof(GeneralLanguageClient)), reuse: Reuse.Singleton);
             container.RegisterMany<WindowLanguageClient>(serviceTypeCondition: type => type.Name.Contains(nameof(WindowLanguageClient)), reuse: Reuse.Singleton);
             container.RegisterMany<WorkspaceLanguageClient>(serviceTypeCondition: type => type.Name.Contains(nameof(WorkspaceLanguageClient)), reuse: Reuse.Singleton);
+            container.RegisterMany<DefaultLanguageClientFacade>(serviceTypeCondition: type => type.Name.Contains("LanguageClientFacade"), reuse: Reuse.Singleton);
             container.RegisterInstance<IOptionsFactory<LanguageClientOptions>>(new ValueOptionsFactory<LanguageClientOptions>(options));
 
             container.RegisterMany<LanguageClient>(serviceTypeCondition: type => type == typeof(ILanguageClient) || type == typeof(LanguageClient), reuse: Reuse.Singleton);
diff --git a/src/JsonRpc/DryIoc/DryIocAdapter.cs b/src/JsonRpc/DryIoc/DryIocAdapter.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Dynamic;
 using DryIoc;
 using Microsoft.Extensions.DependencyInjection;
 using OmniSharp.Extensions.JsonRpc;
@@ -150,7 +151,9 @@ public static void RegisterDescriptor(this IContainer container, ServiceDescript
                 container.RegisterMany(
                     new [] {descriptor.ImplementationType},
                     reuse: reuse,
-                    serviceTypeCondition: type => type == descriptor.ImplementationType || type == descriptor.ServiceType || typeof(IEventingHandler).IsAssignableFrom(type) || typeof(IJsonRpcHandler).IsAssignableFrom(type));
+                    serviceTypeCondition: type => type == descriptor.ImplementationType || type == descriptor.ServiceType || typeof(IEventingHandler).IsAssignableFrom(type) || typeof(IJsonRpcHandler).IsAssignableFrom(type),
+                    nonPublicServiceTypes: true
+                );
             }
             else if (descriptor.ImplementationFactory != null)
             {
@@ -160,15 +163,19 @@ public static void RegisterDescriptor(this IContainer container, ServiceDescript
 
                 container.RegisterDelegate(true, descriptor.ServiceType,
                     descriptor.ImplementationFactory,
-                    reuse);
+                    reuse
+                );
             }
             else
             {
                 // ensure eventing handlers are pulled in automagically.
                 if (!(descriptor.ImplementationInstance is IEnumerable<object>) && (descriptor.ImplementationInstance is IEventingHandler || descriptor.ImplementationInstance is IJsonRpcHandler))
                 {
 
-                    container.RegisterInstanceMany(descriptor.ImplementationInstance);
+                    container.RegisterInstanceMany(
+                        descriptor.ImplementationInstance,
+                        nonPublicServiceTypes: true
+                    );
                 }
                 else
                 {
diff --git a/src/JsonRpc/JsonRpcServer.cs b/src/JsonRpc/JsonRpcServer.cs
@@ -7,9 +7,10 @@
 
 namespace OmniSharp.Extensions.JsonRpc
 {
-    public class JsonRpcServer : JsonRpcServerBase, IJsonRpcServer
+    public class JsonRpcServer : JsonRpcServerBase, IJsonRpcServer, IServiceProvider
     {
         private readonly Connection _connection;
+        private readonly IServiceProvider _serviceProvider;
         private readonly CompositeDisposable _disposable;
 
         internal static IContainer CreateContainer(JsonRpcServerOptions options, IServiceProvider outerServiceProvider) =>
@@ -61,6 +62,7 @@ IServiceProvider serviceProvider
         ) : base(handlerCollection, responseRouter)
         {
             _connection = connection;
+            _serviceProvider = serviceProvider;
             _disposable = options.Value.CompositeDisposable;
             _disposable.Add(_connection);
             if (serviceProvider is IDisposable disposable)
@@ -83,5 +85,7 @@ public IDisposable Register(Action<IJsonRpcServerRegistry> registryAction)
             registryAction(new JsonRpcServerRegistry(manager));
             return manager.GetDisposable();
         }
+
+        object IServiceProvider.GetService(Type serviceType) => _serviceProvider.GetService(serviceType);
     }
 }
diff --git a/src/Protocol/Client/DefaultLanguageClientFacade.cs b/src/Protocol/Client/DefaultLanguageClientFacade.cs
@@ -0,0 +1,27 @@
+﻿using System;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Protocol.Progress;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Client
+{
+    internal class DefaultLanguageClientFacade : LanguageProtocolProxy, ILanguageClientFacade
+    {
+        public DefaultLanguageClientFacade(
+            IResponseRouter requestRouter, IServiceProvider serviceProvider, IProgressManager progressManager,
+            ILanguageProtocolSettings languageProtocolSettings, ITextDocumentLanguageClient textDocument, IClientLanguageClient client, IGeneralLanguageClient general, IWindowLanguageClient window, IWorkspaceLanguageClient workspace
+        ) : base(requestRouter, serviceProvider, progressManager, languageProtocolSettings)
+        {
+            TextDocument = textDocument;
+            Client = client;
+            General = general;
+            Window = window;
+            Workspace = workspace;
+        }
+
+        public ITextDocumentLanguageClient TextDocument { get; }
+        public IClientLanguageClient Client { get; }
+        public IGeneralLanguageClient General { get; }
+        public IWindowLanguageClient Window { get; }
+        public IWorkspaceLanguageClient Workspace { get; }
+    }
+}
diff --git a/src/Protocol/Client/ILanguageClient.cs b/src/Protocol/Client/ILanguageClient.cs
@@ -7,19 +7,12 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Client
 {
-    public interface ILanguageClient : ILanguageClientProxy, IJsonRpcHandlerInstance<ILanguageClientRegistry>, IDisposable
+    public interface ILanguageClient : ILanguageClientFacade, IJsonRpcHandlerInstance<ILanguageClientRegistry>, IDisposable
     {
-        ITextDocumentLanguageClient TextDocument { get; }
-        IClientLanguageClient Client { get; }
-        IGeneralLanguageClient General { get; }
-        IWindowLanguageClient Window { get; }
-        IWorkspaceLanguageClient Workspace { get; }
         IServiceProvider Services { get; }
         IClientWorkDoneManager WorkDoneManager { get; }
         IRegistrationManager RegistrationManager { get; }
         ILanguageClientWorkspaceFoldersManager WorkspaceFoldersManager { get; }
-        InitializeParams ClientSettings { get; }
-        InitializeResult ServerSettings { get; }
         Task Initialize(CancellationToken token);
         Task Shutdown();
     }
diff --git a/src/Protocol/Client/ILanguageClientFacade.cs b/src/Protocol/Client/ILanguageClientFacade.cs
@@ -0,0 +1,11 @@
+﻿namespace OmniSharp.Extensions.LanguageServer.Protocol.Client
+{
+    public interface ILanguageClientFacade : ILanguageClientProxy
+    {
+        ITextDocumentLanguageClient TextDocument { get; }
+        IClientLanguageClient Client { get; }
+        IGeneralLanguageClient General { get; }
+        IWindowLanguageClient Window { get; }
+        IWorkspaceLanguageClient Workspace { get; }
+    }
+}
diff --git a/src/Protocol/Document/Proposals/ISemanticTokensDeltaHandler.cs b/src/Protocol/Document/Proposals/ISemanticTokensDeltaHandler.cs
@@ -23,7 +23,7 @@ public interface ISemanticTokensHandler : IJsonRpcRequestHandler<SemanticTokensP
     [Parallel]
     [Method(TextDocumentNames.SemanticTokensFullDelta, Direction.ClientToServer)]
     public interface ISemanticTokensDeltaHandler :
-        IJsonRpcRequestHandler<SemanticTokensDeltaParams, SemanticTokensFullOrDelta>,
+        IJsonRpcRequestHandler<SemanticTokensDeltaParams, SemanticTokensFullOrDelta?>,
         IRegistration<SemanticTokensRegistrationOptions>, ICapability<SemanticTokensCapability>, IDoesNotParticipateInRegistration
     {
     }
@@ -54,7 +54,7 @@ public virtual async Task<SemanticTokens> Handle(SemanticTokensParams request, C
             return builder.Commit().GetSemanticTokens();
         }
 
-        public virtual async Task<SemanticTokensFullOrDelta> Handle(SemanticTokensDeltaParams request, CancellationToken cancellationToken)
+        public virtual async Task<SemanticTokensFullOrDelta?> Handle(SemanticTokensDeltaParams request, CancellationToken cancellationToken)
         {
             var document = await GetSemanticTokensDocument(request, cancellationToken);
             var builder = document.Edit(request);
@@ -206,7 +206,7 @@ public static IRequestProgressObservable<SemanticTokensPartialResult, SemanticTo
                 }, cancellationToken
             );
 
-        public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult, SemanticTokensFullOrDelta> RequestSemanticTokensDelta(
+        public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult, SemanticTokensFullOrDelta?> RequestSemanticTokensDelta(
             this ITextDocumentLanguageClient mediator, SemanticTokensDeltaParams @params, CancellationToken cancellationToken = default
         ) =>
             mediator.ProgressManager.MonitorUntil(
@@ -216,7 +216,7 @@ public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult,
                         return new SemanticTokensFullOrDelta(
                             new SemanticTokensDelta {
                                 Edits = partial.Delta.Edits,
-                                ResultId = result.Delta?.ResultId ?? result.Full?.ResultId
+                                ResultId = result?.Delta?.ResultId ?? result?.Full?.ResultId
                             }
                         );
                     }
@@ -226,7 +226,7 @@ public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult,
                         return new SemanticTokensFullOrDelta(
                             new SemanticTokens {
                                 Data = partial.Full.Data,
-                                ResultId = result.Full?.ResultId ?? result.Delta?.ResultId
+                                ResultId = result?.Full?.ResultId ?? result?.Delta?.ResultId
                             }
                         );
                     }
diff --git a/src/Protocol/Models/Proposals/SemanticTokensDeltaParams.cs b/src/Protocol/Models/Proposals/SemanticTokensDeltaParams.cs
@@ -9,7 +9,7 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals
     [Obsolete(Constants.Proposal)]
     [Method(TextDocumentNames.SemanticTokensFullDelta, Direction.ClientToServer)]
     public class SemanticTokensDeltaParams : IWorkDoneProgressParams, ITextDocumentIdentifierParams,
-                                             IPartialItemRequest<SemanticTokensFullOrDelta, SemanticTokensFullOrDeltaPartialResult>
+                                             IPartialItemRequest<SemanticTokensFullOrDelta?, SemanticTokensFullOrDeltaPartialResult>
     {
         /// <summary>
         /// The text document.
diff --git a/src/Protocol/Server/DefaultLanguageServerFacade.cs b/src/Protocol/Server/DefaultLanguageServerFacade.cs
@@ -0,0 +1,27 @@
+﻿using System;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Protocol.Progress;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Server
+{
+    internal class DefaultLanguageServerFacade : LanguageProtocolProxy, ILanguageServerFacade
+    {
+        public DefaultLanguageServerFacade(
+            IResponseRouter requestRouter, IServiceProvider serviceProvider, IProgressManager progressManager,
+            ILanguageProtocolSettings languageProtocolSettings, ITextDocumentLanguageServer textDocument, IClientLanguageServer client, IGeneralLanguageServer general, IWindowLanguageServer window, IWorkspaceLanguageServer workspace
+        ) : base(requestRouter, serviceProvider, progressManager, languageProtocolSettings)
+        {
+            TextDocument = textDocument;
+            Client = client;
+            General = general;
+            Window = window;
+            Workspace = workspace;
+        }
+
+        public ITextDocumentLanguageServer TextDocument { get; }
+        public IClientLanguageServer Client { get; }
+        public IGeneralLanguageServer General { get; }
+        public IWindowLanguageServer Window { get; }
+        public IWorkspaceLanguageServer Workspace { get; }
+    }
+}
diff --git a/src/Protocol/Server/ILanguageServer.cs b/src/Protocol/Server/ILanguageServer.cs
@@ -7,13 +7,8 @@
 
 namespace OmniSharp.Extensions.LanguageServer.Protocol.Server
 {
-    public interface ILanguageServer : ILanguageServerProxy, IJsonRpcHandlerInstance<ILanguageServerRegistry>, IDisposable
+    public interface ILanguageServer : ILanguageServerFacade, IJsonRpcHandlerInstance<ILanguageServerRegistry>, IDisposable
     {
-        ITextDocumentLanguageServer TextDocument { get; }
-        IClientLanguageServer Client { get; }
-        IGeneralLanguageServer General { get; }
-        IWindowLanguageServer Window { get; }
-        IWorkspaceLanguageServer Workspace { get; }
         IServiceProvider Services { get; }
         IServerWorkDoneManager WorkDoneManager { get; }
         ILanguageServerConfiguration Configuration { get; }
diff --git a/src/Protocol/Server/ILanguageServerFacade.cs b/src/Protocol/Server/ILanguageServerFacade.cs
@@ -0,0 +1,11 @@
+﻿namespace OmniSharp.Extensions.LanguageServer.Protocol.Server
+{
+    public interface ILanguageServerFacade : ILanguageServerProxy
+    {
+        ITextDocumentLanguageServer TextDocument { get; }
+        IClientLanguageServer Client { get; }
+        IGeneralLanguageServer General { get; }
+        IWindowLanguageServer Window { get; }
+        IWorkspaceLanguageServer Workspace { get; }
+    }
+}
diff --git a/src/Server/LanguageServerServiceCollectionExtensions.cs b/src/Server/LanguageServerServiceCollectionExtensions.cs
@@ -43,6 +43,7 @@ internal static IContainer AddLanguageServerInternals(this IContainer container,
             container.RegisterMany<GeneralLanguageServer>(serviceTypeCondition: type => type.Name.Contains(nameof(GeneralLanguageServer)), reuse: Reuse.Singleton);
             container.RegisterMany<WindowLanguageServer>(serviceTypeCondition: type => type.Name.Contains(nameof(WindowLanguageServer)), reuse: Reuse.Singleton);
             container.RegisterMany<WorkspaceLanguageServer>(serviceTypeCondition: type => type.Name.Contains(nameof(WorkspaceLanguageServer)), reuse: Reuse.Singleton);
+            container.RegisterMany<DefaultLanguageServerFacade>(serviceTypeCondition: type => type.Name.Contains("LanguageServerFacade"), reuse: Reuse.Singleton);
             container.RegisterInstance<IOptionsFactory<LanguageServerOptions>>(new ValueOptionsFactory<LanguageServerOptions>(options));
 
             container.RegisterMany<LanguageServer>(serviceTypeCondition: type => type == typeof(ILanguageServer) || type == typeof(LanguageServer), reuse: Reuse.Singleton);
diff --git a/test/JsonRpc.Tests/ServiceCollectionSupportTests.cs b/test/JsonRpc.Tests/ServiceCollectionSupportTests.cs
@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using MediatR;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
@@ -255,6 +256,24 @@ public void Should_Throw_When_Multiple_Servers_Are_Added_And_Attempt_To_Resolve_
             a.Should().Throw<NotSupportedException>();
         }
 
+        [Fact]
+        public async Task Should_Register_Private_Classes_With_Dry_Ioc()
+        {
+            var server = await JsonRpcServer.From(
+                options => {
+
+                    var pipe = new Pipe();
+                    options
+                       .WithInput(pipe.Reader)
+                       .WithOutput(pipe.Writer);
+
+                    options.Services.AddSingleton<TestClass, InternalTestClass>();
+                }
+            );
+            server.GetService<InternalTestClass>().Should().NotBeNull();
+            server.GetService<TestClass>().Should().NotBeNull().And.BeOfType<InternalTestClass>();
+        }
+
         [Method("outside")]
         private class Request : IRequest<Response>
         {
@@ -297,5 +316,14 @@ private class OutsideService
 
             public string Value { get; }
         }
+
+        internal class TestClass
+        {
+
+        }
+
+        internal class InternalTestClass : TestClass
+        {
+        }
     }
 }
diff --git a/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs b/test/Lsp.Tests/Integration/DynamicRegistrationTests.cs
@@ -118,6 +118,7 @@ public async Task Should_Unregister_Dynamically_While_Server_Is_Running()
                     await WaitForRegistrationUpdate();
                     disposable.Dispose();
                     await WaitForRegistrationUpdate();
+                    await Task.Delay(1000);
                 }
 
                 Client.RegistrationManager.CurrentRegistrations.Should().NotContain(
diff --git a/test/Lsp.Tests/Integration/InitializationTests.cs b/test/Lsp.Tests/Integration/InitializationTests.cs
@@ -1,10 +1,16 @@
 ﻿using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using OmniSharp.Extensions.JsonRpc.Testing;
 using OmniSharp.Extensions.LanguageProtocol.Testing;
 using OmniSharp.Extensions.LanguageServer.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol.Server;
 using OmniSharp.Extensions.LanguageServer.Protocol.Window;
 using OmniSharp.Extensions.LanguageServer.Server;
 using Xunit;
@@ -27,6 +33,28 @@ public async Task Logs_should_be_allowed_during_startup()
             _logs.Should().ContainInOrder("OnInitialize", "OnInitialized");
         }
 
+        [Fact]
+        public async Task Facades_should_be_resolvable()
+        {
+            var (client, server) = await Initialize(ConfigureClient, ConfigureServer);
+
+            client.Services.GetService<ILanguageClientFacade>().Should().NotBeNull();
+            server.Services.GetService<ILanguageServerFacade>().Should().NotBeNull();
+            // This ensures that the facade made it.
+            var response = await client.RequestCodeLens(new CodeLensParams(), CancellationToken);
+        }
+
+        class CodeLensHandlerA : CodeLensHandler
+        {
+            public CodeLensHandlerA(ILanguageServerFacade languageServerFacade) : base(new CodeLensRegistrationOptions())
+            {
+                languageServerFacade.Should().NotBeNull();
+            }
+
+            public override Task<CodeLensContainer> Handle(CodeLensParams request, CancellationToken cancellationToken) => Task.FromResult(new CodeLensContainer());
+
+            public override Task<CodeLens> Handle(CodeLens request, CancellationToken cancellationToken) => Task.FromResult(request);
+        }
         private readonly List<string> _logs = new List<string>();
 
         private void ConfigureClient(LanguageClientOptions options) =>
@@ -40,6 +68,7 @@ private void ConfigureServer(LanguageServerOptions options)
                     return Task.CompletedTask;
                 }
             );
+            options.AddHandler<CodeLensHandlerA>();
             options.OnInitialized(
                 (server, request, response, token) => {
                     server.Window.LogInfo("OnInitialized");

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public override async Task<SemanticTokens> Handle(`
`46`	`46`	`return result;`
`47`	`47`	`}`
`48`	`48`
`49`		`- public override async Task<SemanticTokensFullOrDelta> Handle(`
	`49`	`+ public override async Task<SemanticTokensFullOrDelta?> Handle(`
`50`	`50`	`SemanticTokensDeltaParams request,`
`51`	`51`	`CancellationToken cancellationToken`
`52`	`52`	`)`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Dynamic;`
`3`	`4`	`using DryIoc;`
`4`	`5`	`using Microsoft.Extensions.DependencyInjection;`
`5`	`6`	`using OmniSharp.Extensions.JsonRpc;`
`@@ -150,7 +151,9 @@ public static void RegisterDescriptor(this IContainer container, ServiceDescript`
`150`	`151`	`container.RegisterMany(`
`151`	`152`	`new [] {descriptor.ImplementationType},`
`152`	`153`	`reuse: reuse,`
`153`		`- serviceTypeCondition: type => type == descriptor.ImplementationType \|\| type == descriptor.ServiceType \|\| typeof(IEventingHandler).IsAssignableFrom(type) \|\| typeof(IJsonRpcHandler).IsAssignableFrom(type));`
	`154`	`+ serviceTypeCondition: type => type == descriptor.ImplementationType \|\| type == descriptor.ServiceType \|\| typeof(IEventingHandler).IsAssignableFrom(type) \|\| typeof(IJsonRpcHandler).IsAssignableFrom(type),`
	`155`	`+ nonPublicServiceTypes: true`
	`156`	`+ );`
`154`	`157`	`}`
`155`	`158`	`else if (descriptor.ImplementationFactory != null)`
`156`	`159`	`{`
`@@ -160,15 +163,19 @@ public static void RegisterDescriptor(this IContainer container, ServiceDescript`
`160`	`163`
`161`	`164`	`container.RegisterDelegate(true, descriptor.ServiceType,`
`162`	`165`	`descriptor.ImplementationFactory,`
`163`		`- reuse);`
	`166`	`+ reuse`
	`167`	`+ );`
`164`	`168`	`}`
`165`	`169`	`else`
`166`	`170`	`{`
`167`	`171`	`// ensure eventing handlers are pulled in automagically.`
`168`	`172`	`if (!(descriptor.ImplementationInstance is IEnumerable<object>) && (descriptor.ImplementationInstance is IEventingHandler \|\| descriptor.ImplementationInstance is IJsonRpcHandler))`
`169`	`173`	`{`
`170`	`174`
`171`		`- container.RegisterInstanceMany(descriptor.ImplementationInstance);`
	`175`	`+ container.RegisterInstanceMany(`
	`176`	`+ descriptor.ImplementationInstance,`
	`177`	`+ nonPublicServiceTypes: true`
	`178`	`+ );`
`172`	`179`	`}`
`173`	`180`	`else`
`174`	`181`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,10 @@`
`7`	`7`
`8`	`8`	`namespace OmniSharp.Extensions.JsonRpc`
`9`	`9`	`{`
`10`		`- public class JsonRpcServer : JsonRpcServerBase, IJsonRpcServer`
	`10`	`+ public class JsonRpcServer : JsonRpcServerBase, IJsonRpcServer, IServiceProvider`
`11`	`11`	`{`
`12`	`12`	`private readonly Connection _connection;`
	`13`	`+ private readonly IServiceProvider _serviceProvider;`
`13`	`14`	`private readonly CompositeDisposable _disposable;`
`14`	`15`
`15`	`16`	`internal static IContainer CreateContainer(JsonRpcServerOptions options, IServiceProvider outerServiceProvider) =>`
`@@ -61,6 +62,7 @@ IServiceProvider serviceProvider`
`61`	`62`	`) : base(handlerCollection, responseRouter)`
`62`	`63`	`{`
`63`	`64`	`_connection = connection;`
	`65`	`+ _serviceProvider = serviceProvider;`
`64`	`66`	`_disposable = options.Value.CompositeDisposable;`
`65`	`67`	`_disposable.Add(_connection);`
`66`	`68`	`if (serviceProvider is IDisposable disposable)`
`@@ -83,5 +85,7 @@ public IDisposable Register(Action<IJsonRpcServerRegistry> registryAction)`
`83`	`85`	`registryAction(new JsonRpcServerRegistry(manager));`
`84`	`86`	`return manager.GetDisposable();`
`85`	`87`	`}`
	`88`	`+`
	`89`	`+ object IServiceProvider.GetService(Type serviceType) => _serviceProvider.GetService(serviceType);`
`86`	`90`	`}`
`87`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public interface ISemanticTokensHandler : IJsonRpcRequestHandler<SemanticTokensP`
`23`	`23`	`[Parallel]`
`24`	`24`	`[Method(TextDocumentNames.SemanticTokensFullDelta, Direction.ClientToServer)]`
`25`	`25`	`public interface ISemanticTokensDeltaHandler :`
`26`		`- IJsonRpcRequestHandler<SemanticTokensDeltaParams, SemanticTokensFullOrDelta>,`
	`26`	`+ IJsonRpcRequestHandler<SemanticTokensDeltaParams, SemanticTokensFullOrDelta?>,`
`27`	`27`	`IRegistration<SemanticTokensRegistrationOptions>, ICapability<SemanticTokensCapability>, IDoesNotParticipateInRegistration`
`28`	`28`	`{`
`29`	`29`	`}`
`@@ -54,7 +54,7 @@ public virtual async Task<SemanticTokens> Handle(SemanticTokensParams request, C`
`54`	`54`	`return builder.Commit().GetSemanticTokens();`
`55`	`55`	`}`
`56`	`56`
`57`		`- public virtual async Task<SemanticTokensFullOrDelta> Handle(SemanticTokensDeltaParams request, CancellationToken cancellationToken)`
	`57`	`+ public virtual async Task<SemanticTokensFullOrDelta?> Handle(SemanticTokensDeltaParams request, CancellationToken cancellationToken)`
`58`	`58`	`{`
`59`	`59`	`var document = await GetSemanticTokensDocument(request, cancellationToken);`
`60`	`60`	`var builder = document.Edit(request);`
`@@ -206,7 +206,7 @@ public static IRequestProgressObservable<SemanticTokensPartialResult, SemanticTo`
`206`	`206`	`}, cancellationToken`
`207`	`207`	`);`
`208`	`208`
`209`		`- public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult, SemanticTokensFullOrDelta> RequestSemanticTokensDelta(`
	`209`	`+ public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult, SemanticTokensFullOrDelta?> RequestSemanticTokensDelta(`
`210`	`210`	`this ITextDocumentLanguageClient mediator, SemanticTokensDeltaParams @params, CancellationToken cancellationToken = default`
`211`	`211`	`) =>`
`212`	`212`	`mediator.ProgressManager.MonitorUntil(`
`@@ -216,7 +216,7 @@ public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult,`
`216`	`216`	`return new SemanticTokensFullOrDelta(`
`217`	`217`	`new SemanticTokensDelta {`
`218`	`218`	`Edits = partial.Delta.Edits,`
`219`		`- ResultId = result.Delta?.ResultId ?? result.Full?.ResultId`
	`219`	`+ ResultId = result?.Delta?.ResultId ?? result?.Full?.ResultId`
`220`	`220`	`}`
`221`	`221`	`);`
`222`	`222`	`}`
`@@ -226,7 +226,7 @@ public static IRequestProgressObservable<SemanticTokensFullOrDeltaPartialResult,`
`226`	`226`	`return new SemanticTokensFullOrDelta(`
`227`	`227`	`new SemanticTokens {`
`228`	`228`	`Data = partial.Full.Data,`
`229`		`- ResultId = result.Full?.ResultId ?? result.Delta?.ResultId`
	`229`	`+ ResultId = result?.Full?.ResultId ?? result?.Delta?.ResultId`
`230`	`230`	`}`
`231`	`231`	`);`
`232`	`232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals`
`9`	`9`	`[Obsolete(Constants.Proposal)]`
`10`	`10`	`[Method(TextDocumentNames.SemanticTokensFullDelta, Direction.ClientToServer)]`
`11`	`11`	`public class SemanticTokensDeltaParams : IWorkDoneProgressParams, ITextDocumentIdentifierParams,`
`12`		`- IPartialItemRequest<SemanticTokensFullOrDelta, SemanticTokensFullOrDeltaPartialResult>`
	`12`	`+ IPartialItemRequest<SemanticTokensFullOrDelta?, SemanticTokensFullOrDeltaPartialResult>`
`13`	`13`	`{`
`14`	`14`	`/// <summary>`
`15`	`15`	`/// The text document.`