[Alpha] Language Server Protocol

src/OmniSharp.Abstractions/AssemblyInfo.cs

@@ -4,4 +4,5 @@
 [assembly: InternalsVisibleTo("OmniSharp.Roslyn")]
 [assembly: InternalsVisibleTo("OmniSharp.Roslyn.CSharp")]
 [assembly: InternalsVisibleTo("OmniSharp.DotNetTest.Tests")]
-[assembly: InternalsVisibleTo("OmniSharp.Tests")]
+[assembly: InternalsVisibleTo("OmniSharp.Tests")]
+[assembly: InternalsVisibleTo("OmniSharp")]

src/OmniSharp.Abstractions/Models/Events/EventTypes.cs

@@ -2,13 +2,13 @@ namespace OmniSharp.Models.Events
 {
     public static class EventTypes
     {
-        public static readonly string ProjectAdded = nameof(ProjectAdded);
-        public static readonly string ProjectChanged = nameof(ProjectChanged);
-        public static readonly string ProjectRemoved = nameof(ProjectRemoved);
-        public static readonly string Error = nameof(Error);
-        public static readonly string Diagnostic = nameof(Diagnostic);
-        public static readonly string PackageRestoreStarted = nameof(PackageRestoreStarted);
-        public static readonly string PackageRestoreFinished = nameof(PackageRestoreFinished);
-        public static readonly string UnresolvedDependencies = nameof(UnresolvedDependencies);
+        public const string ProjectAdded = nameof(ProjectAdded);
+        public const string ProjectChanged = nameof(ProjectChanged);
+        public const string ProjectRemoved = nameof(ProjectRemoved);
+        public const string Error = nameof(Error);
+        public const string Diagnostic = nameof(Diagnostic);
+        public const string PackageRestoreStarted = nameof(PackageRestoreStarted);
+        public const string PackageRestoreFinished = nameof(PackageRestoreFinished);
+        public const string UnresolvedDependencies = nameof(UnresolvedDependencies);
     }
-}
+}

src/OmniSharp.Host/CompositionHostBuilder.cs

@@ -23,20 +23,17 @@ public class CompositionHostBuilder
     {
         private readonly IServiceProvider _serviceProvider;
         private readonly IOmniSharpEnvironment _environment;
-        private readonly ISharedTextWriter _writer;
         private readonly IEventEmitter _eventEmitter;
         private readonly IEnumerable<Assembly> _assemblies;
 
         public CompositionHostBuilder(
             IServiceProvider serviceProvider,
             IOmniSharpEnvironment environment,
-            ISharedTextWriter writer,
             IEventEmitter eventEmitter,
             IEnumerable<Assembly> assemblies = null)
         {
             _serviceProvider = serviceProvider;
             _environment = environment;
-            _writer = writer;
             _eventEmitter = eventEmitter;
             _assemblies = assemblies ?? Array.Empty<Assembly>();
         }
@@ -64,7 +61,6 @@ public CompositionHost Build()
                 .WithProvider(MefValueProvider.From(memoryCache))
                 .WithProvider(MefValueProvider.From(loggerFactory))
                 .WithProvider(MefValueProvider.From(_environment))
-                .WithProvider(MefValueProvider.From(_writer))
                 .WithProvider(MefValueProvider.From(options.CurrentValue))
                 .WithProvider(MefValueProvider.From(options.CurrentValue.FormattingOptions))
                 .WithProvider(MefValueProvider.From(assemblyLoader))
@@ -95,13 +91,21 @@ public CompositionHostBuilder WithOmniSharpAssemblies()
             var assemblies = DiscoverOmniSharpAssemblies();
 
             return new CompositionHostBuilder(
-                _serviceProvider, _environment, _writer, _eventEmitter, assemblies);
+                _serviceProvider,
+                _environment,
+                _eventEmitter,
+                _assemblies.Concat(assemblies).Distinct()
+            );
         }
 
         public CompositionHostBuilder WithAssemblies(params Assembly[] assemblies)
         {
             return new CompositionHostBuilder(
-                _serviceProvider, _environment, _writer, _eventEmitter, assemblies);
+                _serviceProvider,
+                _environment,
+                _eventEmitter,
+                _assemblies.Concat(assemblies).Distinct()
+            );
         }
 
         private List<Assembly> DiscoverOmniSharpAssemblies()

src/OmniSharp.Host/Internal/CommandOptionExtensions.cs

@@ -14,5 +14,10 @@ public static T GetValueOrDefault<T>(this CommandOption opt, T defaultValue)
 
             return defaultValue;
         }
+
+        public static bool GetValueOrDefault(this CommandOption opt, bool defaultValue)
+        {
+            return opt.Value() == "on" || defaultValue;
+        }
     }
 }

src/OmniSharp.Http/Startup.cs

@@ -19,22 +19,20 @@ class Startup
     {
         private readonly IOmniSharpEnvironment _environment;
         private readonly IEventEmitter _eventEmitter;
-        private readonly ISharedTextWriter _writer;
         private readonly IConfigurationRoot _configuration;
         private CompositionHost _compositionHost;
 
         public Startup(IOmniSharpEnvironment environment, IEventEmitter eventEmitter, ISharedTextWriter writer)
         {
             _environment = environment;
             _eventEmitter = eventEmitter;
-            _writer = writer;
             _configuration = new ConfigurationBuilder(environment).Build();
         }
 
         public IServiceProvider ConfigureServices(IServiceCollection services)
         {
             var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_configuration, services);
-            _compositionHost = new CompositionHostBuilder(serviceProvider, _environment, _writer, _eventEmitter)
+            _compositionHost = new CompositionHostBuilder(serviceProvider, _environment, _eventEmitter)
                 .WithOmniSharpAssemblies()
                 .Build();
 
@@ -46,7 +44,6 @@ public void Configure(
             IServiceProvider serviceProvider,
             ILoggerFactory loggerFactory,
             IEventEmitter eventEmitter,
-            ISharedTextWriter writer,
             HttpEnvironment httpEnvironment,
             IOptionsMonitor<OmniSharpOptions> options)
         {

src/OmniSharp.LanguageServerProtocol/AssemblyInfo.cs

@@ -0,0 +1,6 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("TestUtility")]
+[assembly: InternalsVisibleTo("OmniSharp")]
+[assembly: InternalsVisibleTo("OmniSharp.Stdio.Tests")]
+[assembly: InternalsVisibleTo("OmniSharp.LanguageServer.Tests")]

src/OmniSharp.LanguageServerProtocol/Eventing/LanguageServerEventEmitter.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Linq;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using OmniSharp.Eventing;
+using OmniSharp.Extensions.LanguageServer;
+using OmniSharp.Extensions.LanguageServer.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Models.Diagnostics;
+using OmniSharp.Models.Events;
+using OmniSharp.Stdio.Protocol;
+using OmniSharp.Stdio.Services;
+
+namespace OmniSharp.LanguageServerProtocol.Eventing
+{
+    public class LanguageServerEventEmitter : IEventEmitter
+    {
+        private readonly LanguageServer _server;
+
+        public LanguageServerEventEmitter(LanguageServer server)
+        {
+            _server = server;
+        }
+
+        public void Emit(string kind, object args)
+        {
+            switch (kind)
+            {
+                case EventTypes.Diagnostic:
+                    if (args is DiagnosticMessage message)
+                    {
+                        var groups = message.Results
+                            // TODO: Make this is correct
+                            .GroupBy(z => Helpers.ToUri(z.FileName), z => z.QuickFixes);
+
+                        foreach (var group in groups)
+                        {
+                            _server.PublishDiagnostics(new PublishDiagnosticsParams()
+                            {
+                                Uri = group.Key,
+                                Diagnostics = group
+                                    .SelectMany(z => z.Select(v => v.ToDiagnostic()))
+                                    .ToArray()
+                            });
+                        }
+                    }
+                    break;
+                case EventTypes.ProjectAdded:
+                case EventTypes.ProjectChanged:
+                case EventTypes.ProjectRemoved:
+                case EventTypes.Error:
+                case EventTypes.PackageRestoreStarted:
+                case EventTypes.PackageRestoreFinished:
+                case EventTypes.UnresolvedDependencies:
+                    // TODO:
+                    break;
+            }
+        }
+    }
+}

src/OmniSharp.LanguageServerProtocol/Handlers/DefinitionHandler.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using OmniSharp.Extensions.LanguageServer.Capabilities.Client;
+using OmniSharp.Extensions.LanguageServer.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Mef;
+using OmniSharp.Models.GotoDefinition;
+using static OmniSharp.LanguageServerProtocol.Helpers;
+
+namespace OmniSharp.LanguageServerProtocol.Handlers
+{
+    [Shared, Export(typeof(DefinitionHandler))]
+    class DefinitionHandler : IDefinitionHandler
+    {
+        private DefinitionCapability _capability;
+        private readonly IRequestHandler<GotoDefinitionRequest, GotoDefinitionResponse> _definitionHandler;
+        private readonly DocumentSelector _documentSelector;
+
+        [ImportingConstructor]
+        public DefinitionHandler(IEnumerable<IRequestHandler> handlers, DocumentSelector documentSelector)
+        {
+            _definitionHandler = handlers.OfType<IRequestHandler<GotoDefinitionRequest, GotoDefinitionResponse>>().Single();
+            _documentSelector = documentSelector;
+        }
+
+        public TextDocumentRegistrationOptions GetRegistrationOptions()
+        {
+            return new TextDocumentRegistrationOptions()
+            {
+                DocumentSelector = _documentSelector
+            };
+        }
+
+        public async Task<LocationOrLocations> Handle(TextDocumentPositionParams request, CancellationToken token)
+        {
+            var omnisharpRequest = new GotoDefinitionRequest()
+            {
+                FileName = Helpers.FromUri(request.TextDocument.Uri),
+                Column = Convert.ToInt32(request.Position.Character),
+                Line = Convert.ToInt32(request.Position.Line)
+            };
+
+            var omnisharpResponse = await _definitionHandler.Handle(omnisharpRequest);
+
+            return new LocationOrLocations(new Location()
+            {
+                Uri = Helpers.ToUri(omnisharpResponse.FileName),
+                Range = ToRange((omnisharpResponse.Column, omnisharpResponse.Line))
+            });
+        }
+
+        public void SetCapability(DefinitionCapability capability)
+        {
+            _capability = capability;
+        }
+    }
+}

src/OmniSharp.LanguageServerProtocol/Handlers/HoverHandler.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using OmniSharp.Extensions.LanguageServer.Capabilities.Client;
+using OmniSharp.Extensions.LanguageServer.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Mef;
+using OmniSharp.Models.TypeLookup;
+
+namespace OmniSharp.LanguageServerProtocol.Handlers
+{
+    [Shared, Export(typeof(HoverHandler))]
+    class HoverHandler : IHoverHandler
+    {
+        private HoverCapability _capability;
+        private readonly IRequestHandler<TypeLookupRequest, TypeLookupResponse> _definitionHandler;
+        private readonly DocumentSelector _documentSelector;
+
+        [ImportingConstructor]
+        public HoverHandler(IEnumerable<IRequestHandler> handlers, DocumentSelector documentSelector)
+        {
+            _definitionHandler = handlers.OfType<IRequestHandler<TypeLookupRequest, TypeLookupResponse>>().Single();
+            _documentSelector = documentSelector;
+        }
+
+        public TextDocumentRegistrationOptions GetRegistrationOptions()
+        {
+            return new TextDocumentRegistrationOptions()
+            {
+                DocumentSelector = _documentSelector
+            };
+        }
+
+        public async Task<Hover> Handle(TextDocumentPositionParams request, CancellationToken token)
+        {
+            var omnisharpRequest = new TypeLookupRequest()
+            {
+                FileName = Helpers.FromUri(request.TextDocument.Uri),
+                Column = Convert.ToInt32(request.Position.Character),
+                Line = Convert.ToInt32(request.Position.Line),
+                IncludeDocumentation = true
+            };
+
+            var omnisharpResponse = await _definitionHandler.Handle(omnisharpRequest);
+
+            return new Hover()
+            {
+                // TODO: Range?  We don't currently have that!
+                // Range =
+                Contents = new MarkedStringContainer(omnisharpResponse.Type, omnisharpResponse.Documentation)
+            };
+        }
+
+        public void SetCapability(HoverCapability capability)
+        {
+            _capability = capability;
+        }
+    }
+}