[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/CompletionHandler.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Capabilities.Client;
+using OmniSharp.Extensions.LanguageServer.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Mef;
+using OmniSharp.Models.AutoComplete;
+using OmniSharp.Models.TypeLookup;
+
+namespace OmniSharp.LanguageServerProtocol.Handlers
+{
+    [Shared, Export(typeof(CompletionHandler))]
+    class CompletionHandler : ICompletionHandler
+    {
+        public static IEnumerable<IJsonRpcHandler> Enumerate(RequestHandlers handlers)
+        {
+            foreach (var (selector, handler) in handlers
+                .OfType<Mef.IRequestHandler<AutoCompleteRequest, IEnumerable<AutoCompleteResponse>>>())
+                if (handler != null)
+                    yield return new CompletionHandler(handler, selector);
+        }
+
+        private CompletionCapability _capability;
+        private readonly Mef.IRequestHandler<AutoCompleteRequest, IEnumerable<AutoCompleteResponse>> _autoCompleteHandler;
+        private readonly DocumentSelector _documentSelector;
+
+        private static readonly IDictionary<string, CompletionItemKind> _kind = new Dictionary<string, CompletionItemKind>{
+            // types
+            { "Class",  CompletionItemKind.Class },
+            { "Delegate", CompletionItemKind.Class }, // need a better option for this.
+            { "Enum", CompletionItemKind.Enum },
+            { "Interface", CompletionItemKind.Interface },
+            { "Struct", CompletionItemKind.Class }, // TODO: Is struct missing from enum?
+
+            // variables
+            { "Local", CompletionItemKind.Variable },
+            { "Parameter", CompletionItemKind.Variable },
+            { "RangeVariable", CompletionItemKind.Variable },
+
+            // members
+            { "Const", CompletionItemKind.Value }, // TODO: Is const missing from enum?
+            { "EnumMember", CompletionItemKind.Enum },
+            { "Event", CompletionItemKind.Function }, // TODO: Is event missing from enum?
+            { "Field", CompletionItemKind.Field },
+            { "Method", CompletionItemKind.Method },
+            { "Property", CompletionItemKind.Property },
+
+            // other stuff
+            { "Label", CompletionItemKind.Unit }, // need a better option for this.
+            { "Keyword", CompletionItemKind.Keyword },
+            { "Namespace", CompletionItemKind.Module }
+        };
+
+        private static CompletionItemKind GetCompletionItemKind(string key)
+        {
+            if (string.IsNullOrEmpty(key))
+            {
+                return CompletionItemKind.Property;
+            }
+            if(_kind.TryGetValue(key, out var completionItemKind))
+            {
+                return completionItemKind;
+            }
+            return CompletionItemKind.Property;
+        }
+
+        [ImportingConstructor]
+        public CompletionHandler(Mef.IRequestHandler<AutoCompleteRequest, IEnumerable<AutoCompleteResponse>> autoCompleteHandler, DocumentSelector documentSelector)
+        {
+            _autoCompleteHandler = autoCompleteHandler;
+            _documentSelector = documentSelector;
+        }
+
+        public async Task<CompletionList> Handle(TextDocumentPositionParams request, CancellationToken token)
+        {
+            var omnisharpRequest = new AutoCompleteRequest()
+            {
+                FileName = Helpers.FromUri(request.TextDocument.Uri),
+                Column = Convert.ToInt32(request.Position.Character),
+                Line = Convert.ToInt32(request.Position.Line),
+                WantKind = true,
+                WantDocumentationForEveryCompletionResult = true,
+                WantReturnType = true
+            };
+
+            var omnisharpResponse = await _autoCompleteHandler.Handle(omnisharpRequest);
+
+            var completions = new Dictionary<string, List<CompletionItem>>();
+            foreach (var response in omnisharpResponse)
+            {
+                var completionItem = new CompletionItem {
+                    Label = response.CompletionText,
+                    Detail = !string.IsNullOrEmpty(response.ReturnType) ? 
+                            response.DisplayText : 
+                            $"{response.ReturnType} {response.DisplayText}",
+                    Documentation = response.Description,
+                    Kind = GetCompletionItemKind(response.Kind),
+                    InsertText = response.CompletionText,
+                };
+
+                if(!completions.ContainsKey(completionItem.Label))
+                {
+                    completions[completionItem.Label] = new List<CompletionItem>();
+                }
+                completions[completionItem.Label].Add(completionItem);
+            }
+
+            var result = new List<CompletionItem>();
+            foreach (var key in completions.Keys)
+            {
+                var suggestion = completions[key][0];
+                var overloadCount = completions[key].Count - 1;
+
+                if (overloadCount > 0)
+                {
+                    // indicate that there is more
+                    suggestion.Detail = $"{suggestion.Detail} (+ {overloadCount} overload(s))";
+                }
+
+                result.Add(suggestion);
+            }
+
+            return new CompletionList(result);
+        }
+
+        public CompletionRegistrationOptions GetRegistrationOptions()
+        {
+            return new CompletionRegistrationOptions()
+            {
+                DocumentSelector = _documentSelector
+            };
+        }
+
+        public void SetCapability(CompletionCapability capability)
+        {
+            _capability = capability;
+        }
+    }
+}