Merge pull request #213 from NTaylorMullen/nimullen/exposeinitialize

Expose Initialize as a public method on ILanguageServer.

Author: david-driscoll

src/Server/LanguageServer.cs

@@ -52,6 +52,7 @@ public class LanguageServer : ILanguageServer, IInitializeHandler, IInitializedH
         private readonly CompositeDisposable _disposable = new CompositeDisposable();
         private readonly IServiceProvider _serviceProvider;
         private readonly SupportedCapabilities _supportedCapabilities;
+        private Task _initializingTask;
 
         public static Task<ILanguageServer> From(Action<LanguageServerOptions> optionsAction)
         {
@@ -301,38 +302,26 @@ public IDisposable AddTextDocumentIdentifier<T>() where T : ITextDocumentIdentif
             return _textDocumentIdentifiers.Add(ActivatorUtilities.CreateInstance<T>(_serviceProvider));
         }
 
-        private IDisposable RegisterHandlers(LspHandlerDescriptorDisposable handlerDisposable)
+        public async Task Initialize(CancellationToken token)
         {
-            using (var scope = _serviceProvider.CreateScope())
+            if (_initializingTask != null)
             {
-                var registrations = handlerDisposable.Descriptors
-                    .Where(d => d.AllowsDynamicRegistration)
-                    .Select(d => new Registration() {
-                        Id = d.Id.ToString(),
-                        Method = d.Method,
-                        RegisterOptions = d.RegistrationOptions
-                    })
-                    .ToArray();
-
-                // Fire and forget
-                DynamicallyRegisterHandlers(registrations).ToObservable().Subscribe();
+                try
+                {
+                    await _initializingTask;
+                }
+                catch
+                {
+                    // Swallow exceptions because the original initialization task will report errors if it fails (don't want to doubly report).
+                }
 
-                return new ImmutableDisposable(
-                    handlerDisposable,
-                    Disposable.Create(() => {
-                        Client.UnregisterCapability(new UnregistrationParams() {
-                            Unregisterations = registrations.ToArray()
-                        }).ToObservable().Subscribe();
-                    }));
+                return;
             }
-        }
 
-        private async Task Initialize(CancellationToken token)
-        {
-            _connection.Open();
             try
             {
-                await _initializeComplete
+                _connection.Open();
+                _initializingTask = _initializeComplete
                     .Select(result => _startedDelegates.Select(@delegate =>
                             Observable.FromAsync(() => @delegate(result))
                         )
@@ -343,6 +332,8 @@ await _initializeComplete
                 .Merge()
                 .LastAsync()
                 .ToTask(token);
+
+                await _initializingTask;
             }
             catch (TaskCanceledException e)
             {
@@ -354,6 +345,35 @@ await _initializeComplete
             }
         }
 
+        private IDisposable RegisterHandlers(LspHandlerDescriptorDisposable handlerDisposable)
+        {
+            using (var scope = _serviceProvider.CreateScope())
+            {
+                var registrations = handlerDisposable.Descriptors
+                    .Where(d => d.AllowsDynamicRegistration)
+                    .Select(d => new Registration()
+                    {
+                        Id = d.Id.ToString(),
+                        Method = d.Method,
+                        RegisterOptions = d.RegistrationOptions
+                    })
+                    .ToArray();
+
+                // Fire and forget
+                DynamicallyRegisterHandlers(registrations).ToObservable().Subscribe();
+
+                return new ImmutableDisposable(
+                    handlerDisposable,
+                    Disposable.Create(() =>
+                    {
+                        Client.UnregisterCapability(new UnregistrationParams()
+                        {
+                            Unregisterations = registrations.ToArray()
+                        }).ToObservable().Subscribe();
+                    }));
+            }
+        }
+
         async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>.Handle(InitializeParams request, CancellationToken token)
         {
             ClientSettings = request;
@@ -408,7 +428,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
 
             var ccp = new ClientCapabilityProvider(_collection);
 
-            var serverCapabilities = new ServerCapabilities() {
+            var serverCapabilities = new ServerCapabilities()
+            {
                 CodeActionProvider = ccp.GetStaticOptions(textDocumentCapabilities.CodeAction).Get<ICodeActionOptions, CodeActionOptions>(CodeActionOptions.Of),
                 CodeLensProvider = ccp.GetStaticOptions(textDocumentCapabilities.CodeLens).Get<ICodeLensOptions, CodeLensOptions>(CodeLensOptions.Of),
                 CompletionProvider = ccp.GetStaticOptions(textDocumentCapabilities.Completion).Get<ICompletionOptions, CompletionOptions>(CompletionOptions.Of),
@@ -435,8 +456,10 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
 
             if (_collection.ContainsHandler(typeof(IDidChangeWorkspaceFoldersHandler)))
             {
-                serverCapabilities.Workspace = new WorkspaceServerCapabilities() {
-                    WorkspaceFolders = new WorkspaceFolderOptions() {
+                serverCapabilities.Workspace = new WorkspaceServerCapabilities()
+                {
+                    WorkspaceFolders = new WorkspaceFolderOptions()
+                    {
                         Supported = true,
                         ChangeNotifications = Guid.NewGuid().ToString()
                     }
@@ -466,7 +489,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
                 }
                 else
                 {
-                    serverCapabilities.TextDocumentSync = new TextDocumentSyncOptions() {
+                    serverCapabilities.TextDocumentSync = new TextDocumentSyncOptions()
+                    {
                         Change = textDocumentSyncKind,
                         OpenClose = _collection.ContainsHandler(typeof(IDidOpenTextDocumentHandler)) || _collection.ContainsHandler(typeof(IDidCloseTextDocumentHandler)),
                         Save = _collection.ContainsHandler(typeof(IDidSaveTextDocumentHandler)) ?