Updated latest version of the 0.16 spec

Directory.Build.targets

@@ -26,8 +26,8 @@
         <PackageReference Update="xunit" Version="2.4.1"/>
         <PackageReference Update="FluentAssertions" Version="5.10.2"/>
         <PackageReference Update="NSubstitute" Version="4.2.1"/>
-        <PackageReference Update="Autofac" Version="4.8.1"/>
-        <PackageReference Update="Autofac.Extensions.DependencyInjection" Version="4.3.1"/>
+        <PackageReference Update="DryIoc.dll" Version="4.2.5" />
+        <PackageReference Update="DryIoc.Microsoft.DependencyInjection " Version="4.0.0" />
         <PackageReference Update="Serilog.Extensions.Logging" Version="2.0.2"/>
         <PackageReference Update="Serilog.Sinks.XUnit" Version="1.0.21"/>
         <PackageReference Update="XunitXml.TestLogger" Version="2.1.26"/>

sample/SampleServer/Program.cs

@@ -1,10 +1,14 @@
 using System;
+using System.Diagnostics;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json.Linq;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Protocol;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals;
 using OmniSharp.Extensions.LanguageServer.Server;
 using Serilog;
 
@@ -40,15 +44,18 @@ static async Task MainAsync(string[] args)
                     .WithInput(Console.OpenStandardInput())
                     .WithOutput(Console.OpenStandardOutput())
                     .ConfigureLogging(x => x
-                        .AddSerilog()
+                        .AddSerilog(Log.Logger)
                         .AddLanguageProtocolLogging()
                         .SetMinimumLevel(LogLevel.Debug))
                     .WithHandler<TextDocumentHandler>()
                     .WithHandler<DidChangeWatchedFilesHandler>()
                     .WithHandler<FoldingRangeHandler>()
                     .WithHandler<MyWorkspaceSymbolsHandler>()
                     .WithHandler<MyDocumentSymbolHandler>()
-                    .WithHandler<SemanticTokens>()
+                    .WithHandler<SemanticTokensHandler>()
+                    // Linking here because the spec changed but vscode is behind
+                    .WithLink(TextDocumentNames.SemanticTokensFull, "textDocument/semanticTokens")
+                    .WithLink(TextDocumentNames.SemanticTokensFullDelta, "textDocument/semanticTokens/edits")
                     .WithServices(x => x.AddLogging(b => b.SetMinimumLevel(LogLevel.Trace)))
                     .WithServices(services => {
                         services.AddSingleton(provider => {

sample/SampleServer/SemanticTokens.cs → sample/SampleServer/SemanticTokensHandler.cs

@@ -7,45 +7,45 @@
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
 using OmniSharp.Extensions.LanguageServer.Protocol.Document.Proposals;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals;
 
 namespace SampleServer
 {
 #pragma warning disable 618
-    public class SemanticTokens : SemanticTokensHandler
+    public class SemanticTokensHandler : SemanticTokensHandlerBase
     {
         private readonly ILogger _logger;
 
-        public SemanticTokens(ILogger<SemanticTokens> logger) : base(new SemanticTokensRegistrationOptions() {
+        public SemanticTokensHandler(ILogger<SemanticTokensHandler> logger) : base(new SemanticTokensRegistrationOptions() {
             DocumentSelector = DocumentSelector.ForLanguage("csharp"),
             Legend = new SemanticTokensLegend(),
-            DocumentProvider = new Supports<SemanticTokensDocumentProviderOptions>(true,
-                new SemanticTokensDocumentProviderOptions() {
-                    Edits = true
-                }),
-            RangeProvider = true
+            Full = new SemanticTokensCapabilityRequestFull() {
+                Delta = true
+            },
+            Range = true
         })
         {
             _logger = logger;
         }
 
-        public override async Task<OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals.SemanticTokens> Handle(
+        public override async Task<SemanticTokens> Handle(
             SemanticTokensParams request, CancellationToken cancellationToken)
         {
             var result = await base.Handle(request, cancellationToken);
             return result;
         }
 
-        public override async Task<OmniSharp.Extensions.LanguageServer.Protocol.Models.Proposals.SemanticTokens> Handle(
+        public override async Task<SemanticTokens> Handle(
             SemanticTokensRangeParams request, CancellationToken cancellationToken)
         {
             var result = await base.Handle(request, cancellationToken);
             return result;
         }
 
-        public override async Task<SemanticTokensOrSemanticTokensEdits> Handle(SemanticTokensEditsParams request,
+        public override async Task<SemanticTokensFullOrDelta> Handle(SemanticTokensDeltaParams request,
             CancellationToken cancellationToken)
         {
             var result = await base.Handle(request, cancellationToken);

src/Client/LanguageClient.cs

@@ -48,7 +48,7 @@ public class LanguageClient : JsonRpcServerBase, ILanguageClient
         private readonly object _initializationOptions;
         private readonly IWorkspaceFoldersManager _workspaceFoldersManager;
         private readonly DocumentUri _rootUri;
-        private readonly InitializeTrace _trace;
+        private readonly TraceValue _traceValue;
         private readonly IRegistrationManager _registrationManager;
         private readonly ClientCapabilities _clientCapabilities;
         private readonly IProgressManager _progressManager;
@@ -121,7 +121,7 @@ internal LanguageClient(LanguageClientOptions options) : base(options)
             // _initializedDelegates = initializedDelegates;
             _startedDelegates = options.StartedDelegates;
             _rootUri = options.RootUri;
-            _trace = options.Trace;
+            _traceValue = options.TraceValue;
             _initializationOptions = options.InitializationOptions;
 
             services.AddSingleton<IOutputHandler>(_ =>
@@ -200,6 +200,7 @@ internal LanguageClient(LanguageClientOptions options) : base(options)
             var serviceIdentifiers = _serviceProvider.GetServices<ITextDocumentIdentifier>().ToArray();
             _disposable.Add(_textDocumentIdentifiers.Add(serviceIdentifiers));
             _disposable.Add(_collection.Add(serviceHandlers));
+            options.AddLinks(_collection);
         }
 
         public ITextDocumentLanguageClient TextDocument { get; }
@@ -220,7 +221,7 @@ internal LanguageClient(LanguageClientOptions options) : base(options)
         public async Task Initialize(CancellationToken token)
         {
             var @params = new InitializeParams {
-                Trace = _trace,
+                Trace = _traceValue,
                 Capabilities = _clientCapabilities,
                 ClientInfo = _clientInfo,
                 RootUri = _rootUri,

src/Client/LanguageClientOptions.cs

@@ -44,7 +44,7 @@ public string RootPath
             set => RootUri = DocumentUri.FromFileSystemPath(value);
         }
 
-        public InitializeTrace Trace { get; set; }
+        public TraceValue TraceValue { get; set; }
 
         public object InitializationOptions { get; set; }
 

src/Client/LanguageClientOptionsExtensions.cs

@@ -56,9 +56,9 @@ public static LanguageClientOptions WithRootPath(this LanguageClientOptions opti
             return options;
         }
 
-        public static LanguageClientOptions WithTrace(this LanguageClientOptions options, InitializeTrace trace)
+        public static LanguageClientOptions WithTrace(this LanguageClientOptions options, TraceValue traceValue)
         {
-            options.Trace = trace;
+            options.TraceValue = traceValue;
             return options;
         }
 

src/Client/RegistrationManager.cs

@@ -36,16 +36,23 @@ public RegistrationManager(ISerializer serializer, ILogger<RegistrationManager>
 
         Task<Unit> IRequestHandler<RegistrationParams, Unit>.Handle(RegistrationParams request, CancellationToken cancellationToken)
         {
-            Register(request.Registrations.ToArray());
+            lock (this)
+            {
+                Register(request.Registrations.ToArray());
+            }
+
             _registrationSubject.OnNext(_registrations.Values);
             return Unit.Task;
         }
 
         Task<Unit> IRequestHandler<UnregistrationParams, Unit>.Handle(UnregistrationParams request, CancellationToken cancellationToken)
         {
-            foreach (var item in request.Unregisterations ?? new UnregistrationContainer())
+            lock (this)
             {
-                _registrations.TryRemove(item.Id, out _);
+                foreach (var item in request.Unregisterations ?? new UnregistrationContainer())
+                {
+                    _registrations.TryRemove(item.Id, out _);
+                }
             }
 
             _registrationSubject.OnNext(_registrations.Values);

src/JsonRpc.Testing/AggregateSettler.cs

@@ -19,7 +19,7 @@ public Task SettleNext()
         {
             return _settlers.ToObservable()
                 .Select(z => z.Settle())
-                .Switch()
+                .Merge()
                 .Take(1)
                 //.Amb(Observable.Timer(_waitTime + _waitTime).Select(z => Unit.Value))
                 .ToTask();

src/JsonRpc.Testing/Settler.cs

@@ -27,10 +27,10 @@ public Settler(TimeSpan waitTime, TimeSpan timeout, CancellationToken cancellati
                     acc += next;
                     return acc;
                 })
-                .Select(z => z <= 0 ? Observable.Timer(waitTime).Select(_ => Unit.Default).Timeout(timeout, Observable.Return(Unit.Default)) : Observable.Never<Unit>())
-                .Switch()
                 .Replay(1)
-                .RefCount();
+                .RefCount()
+                .Select(z => z <= 0 ? Observable.Timer(waitTime).Select(_ => Unit.Default).Timeout(timeout, Observable.Return(Unit.Default)) : Observable.Never<Unit>())
+                .Switch();
             _requester = subject;
         }
 
@@ -43,7 +43,7 @@ public Task SettleNext()
 
         public IObservable<Unit> Settle()
         {
-            return _settle;
+            return _settle.Timeout(_timeout).Catch<Unit, Exception>(_ => Observable.Empty<Unit>());
         }
 
         void IRequestSettler.OnStartRequest()

src/JsonRpc/CompositeHandlersManager.cs

@@ -27,6 +27,8 @@ public IDisposable Add(string method, IJsonRpcHandler handler, JsonRpcHandlerOpt
             return result;
         }
 
+        public IDisposable AddLink(string sourceMethod, string destinationMethod) => _parent.AddLink(sourceMethod, destinationMethod);
+
         public CompositeDisposable GetDisposable() => _compositeDisposable;
     }
 }

src/JsonRpc/HandlerCollection.cs

@@ -9,9 +9,11 @@
 
 namespace OmniSharp.Extensions.JsonRpc
 {
+
+
     public class HandlerCollection : IEnumerable<IHandlerDescriptor>, IHandlersManager
     {
-        internal readonly List<HandlerInstance> _handlers = new List<HandlerInstance>();
+        internal readonly List<IHandlerDescriptor> _handlers = new List<IHandlerDescriptor>();
 
         public HandlerCollection() { }
 
@@ -70,6 +72,41 @@ public void Dispose()
             }
         }
 
+        [DebuggerDisplay("{Method}")]
+        internal class LinkedHandler : IHandlerDescriptor, IDisposable
+        {
+            private readonly IHandlerDescriptor _descriptor;
+            private readonly Action _disposeAction;
+
+            public LinkedHandler(string method, IHandlerDescriptor descriptor, Action disposeAction)
+            {
+                _descriptor = descriptor;
+                _disposeAction = disposeAction;
+                Method = method;
+            }
+            public string Method { get; }
+            public Type HandlerType => _descriptor.HandlerType;
+
+            public Type ImplementationType => _descriptor.ImplementationType;
+
+            public Type Params => _descriptor.Params;
+
+            public Type Response => _descriptor.Response;
+
+            public bool HasReturnType => _descriptor.HasReturnType;
+
+            public bool IsDelegatingHandler => _descriptor.IsDelegatingHandler;
+
+            public IJsonRpcHandler Handler => _descriptor.Handler;
+
+            public RequestProcessType? RequestProcessType => _descriptor.RequestProcessType;
+
+            public void Dispose()
+            {
+                _disposeAction();
+            }
+        }
+
         public IEnumerator<IHandlerDescriptor> GetEnumerator()
         {
             return _handlers.GetEnumerator();
@@ -82,8 +119,11 @@ IEnumerator IEnumerable.GetEnumerator()
 
         private void Remove(IJsonRpcHandler handler)
         {
-            var i = _handlers.Find(instance => instance.Handler == handler);
-            if (i != null) _handlers.Remove(i);
+            var handlers = _handlers.FindAll(instance => instance.Handler == handler);
+            foreach (var item in handlers)
+            {
+                _handlers.Remove(item);
+            }
         }
 
         public IDisposable Add(params IJsonRpcHandler[] handlers)
@@ -132,6 +172,14 @@ public IDisposable Add(string method, IJsonRpcHandler handler, JsonRpcHandlerOpt
             return h;
         }
 
+        public IDisposable AddLink(string sourceMethod, string destinationMethod)
+        {
+            var source = _handlers.Find(z => z.Method == sourceMethod);
+            var h = new LinkedHandler(destinationMethod, source, () => _handlers.RemoveAll(z => z.Method == destinationMethod));
+            _handlers.Add(h);
+            return h;
+        }
+
         private static readonly Type[] HandlerTypes = {
             typeof(IJsonRpcNotificationHandler),
             typeof(IJsonRpcNotificationHandler<>),

src/JsonRpc/IHandlersManager.cs

@@ -6,5 +6,6 @@ public interface IHandlersManager
     {
         IDisposable Add(IJsonRpcHandler handler, JsonRpcHandlerOptions options);
         IDisposable Add(string method, IJsonRpcHandler handler, JsonRpcHandlerOptions options);
+        IDisposable AddLink(string sourceMethod, string destinationMethod);
     }
 }

src/JsonRpc/JsonRpcOptionsRegistryBase.cs

@@ -1,11 +1,21 @@
 using System;
+using System.Collections.Generic;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
     public abstract class JsonRpcOptionsRegistryBase<T> : JsonRpcCommonMethodsBase<T> where T : IJsonRpcHandlerRegistry<T>
     {
         public IServiceCollection Services { get; set;  } = new ServiceCollection();
+        protected internal HashSet<(string source, string destination)> Links= new HashSet<(string source, string destination)>();
+
+        public void AddLinks(IHandlersManager handlersManager)
+        {
+            foreach (var link in Links)
+            {
+                handlersManager.AddLink(link.source, link.destination);
+            }
+        }
 
         #region AddHandler
 

src/JsonRpc/JsonRpcServer.cs

@@ -98,6 +98,7 @@ internal JsonRpcServer(JsonRpcServerOptions options) : base(options)
             );
             _disposable.Add(_connection);
             _collection.Add(_serviceProvider.GetRequiredService<IEnumerable<IJsonRpcHandler>>().ToArray());
+            options.AddLinks(_collection);
         }
 
         private async Task Initialize(CancellationToken cancellationToken)

src/JsonRpc/JsonRpcServerOptionsBase.cs

@@ -139,5 +139,11 @@ public T WithMaximumRequestTimeout(TimeSpan maximumRequestTimeout)
             MaximumRequestTimeout = maximumRequestTimeout;
             return (T)(object) this;
         }
+
+        public T WithLink(string source, string destination)
+        {
+            Links.Add((source, destination));
+            return (T)(object) this;
+        }
     }
 }

src/Protocol/AbstractHandlers.cs

@@ -68,6 +68,8 @@ async Task<TResponse> IRequestHandler<TItem, TResponse>.Handle(TItem request,
                 }
 
                 var subject = new AsyncSubject<TItem>();
+                // in the event nothing is emitted...
+                subject.OnNext(default);
                 Handle(request, subject, cancellationToken);
                 return _factory(await subject);
             }

src/Protocol/Client/Capabilities/CallHierarchyCapability.cs

@@ -0,0 +1,16 @@
+using System;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document.Proposals;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities
+{
+    /// <summary>
+    /// Capabilities specific to the `textDocument/callHierarchy`.
+    ///
+    /// @since 3.16.0
+    /// </summary>
+    [Obsolete(Constants.Proposal)]
+    public class CallHierarchyCapability : DynamicCapability, ConnectedCapability<ICallHierarchyHandler>,
+        ConnectedCapability<ICallHierarchyIncomingHandler>, ConnectedCapability<ICallHierarchyOutgoingHandler>
+    {
+    }
+}