Fix all providers support

src/OmniSharp.Abstractions/Models/v1/FixAll/FixAllItem.cs

@@ -0,0 +1,15 @@
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    public class FixAllItem
+    {
+        public FixAllItem() {}
+        public FixAllItem(string id, string message)
+        {
+            Id = id;
+            Message = message;
+        }
+
+        public string Id { get; set; }
+        public string Message { get; set; }
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FixAll/GetFixAllRequest.cs

@@ -0,0 +1,11 @@
+using OmniSharp.Mef;
+using OmniSharp.Models;
+
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    [OmniSharpEndpoint(OmniSharpEndpoints.GetFixAll, typeof(GetFixAllRequest), typeof(GetFixAllResponse))]
+    public class GetFixAllRequest: SimpleFileRequest
+    {
+        public FixAllScope Scope { get; set; } = FixAllScope.Document;
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FixAll/GetFixAllResponse.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    public class GetFixAllResponse
+    {
+        public GetFixAllResponse(IEnumerable<FixAllItem> fixableItems)
+        {
+            Items = fixableItems;
+        }
+
+        public IEnumerable<FixAllItem> Items { get; set; }
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FixAll/RunFixAllRequest.cs

@@ -0,0 +1,17 @@
+using OmniSharp.Mef;
+using OmniSharp.Models;
+
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    [OmniSharpEndpoint(OmniSharpEndpoints.RunFixAll, typeof(RunFixAllRequest), typeof(RunFixAllResponse))]
+    public class RunFixAllRequest : SimpleFileRequest
+    {
+        public FixAllScope Scope { get; set; } = FixAllScope.Document;
+
+        // If this is null -> filter not set -> try to fix all issues in current defined scope.
+        public FixAllItem[] FixAllFilter { get; set; }
+        public int Timeout { get; set; } = 3000;
+        public bool WantsAllCodeActionOperations { get; set; }
+        public bool WantsTextChanges { get; set; }
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FixAll/RunFixAllResponse.cs

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using OmniSharp.Models;
+
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    public class RunFixAllResponse : IAggregateResponse
+    {
+        public RunFixAllResponse()
+        {
+            Changes = new List<FileOperationResponse>();
+        }
+
+        public IEnumerable<FileOperationResponse> Changes { get; set; }
+
+        public IAggregateResponse Merge(IAggregateResponse response) { return response; }
+    }
+}

src/OmniSharp.Abstractions/Models/v1/FixAll/RunFixAllScope.cs

@@ -0,0 +1,9 @@
+namespace OmniSharp.Abstractions.Models.V1.FixAll
+{
+    public enum FixAllScope
+    {
+        Document = 0,
+        Project = 1,
+        Solution = 2
+    }
+}

src/OmniSharp.Abstractions/OmniSharpEndpoints.cs

@@ -34,7 +34,8 @@ public static class OmniSharpEndpoints
         public const string WorkspaceInformation = "/projects";
         public const string ProjectInformation = "/project";
         public const string FixUsings = "/fixusings";
-
+        public const string RunFixAll = "/runfixall";
+        public const string GetFixAll = "/getfixall";
         public const string CheckAliveStatus = "/checkalivestatus";
         public const string CheckReadyStatus = "/checkreadystatus";
         public const string StopServer = "/stopserver";

src/OmniSharp.Roslyn.CSharp/Helpers/DiagnosticExtensions.cs

@@ -1,16 +1,16 @@
 using Microsoft.CodeAnalysis;
 using OmniSharp.Models.Diagnostics;
+using OmniSharp.Roslyn.CSharp.Services.Diagnostics;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace OmniSharp.Helpers
 {
     internal static class DiagnosticExtensions
     {
         private static readonly ImmutableHashSet<string> _tagFilter =
-            ImmutableHashSet.Create<string>("Unnecessary");
+            ImmutableHashSet.Create("Unnecessary");
 
         internal static DiagnosticLocation ToDiagnosticLocation(this Diagnostic diagnostic)
         {
@@ -32,9 +32,10 @@ internal static DiagnosticLocation ToDiagnosticLocation(this Diagnostic diagnost
             };
         }
 
-        internal static IEnumerable<DiagnosticLocation> DistinctDiagnosticLocationsByProject(this IEnumerable<(string projectName, Diagnostic diagnostic)> diagnostics)
+        internal static IEnumerable<DiagnosticLocation> DistinctDiagnosticLocationsByProject(this IEnumerable<DocumentDiagnostics> documentDiagnostic)
         {
-            return diagnostics
+            return documentDiagnostic
+                .SelectMany(x => x.Diagnostics, (parent, child) => (projectName: parent.ProjectName, diagnostic: child))
                 .Select(x => new
                 {
                     location = x.diagnostic.ToDiagnosticLocation(),

src/OmniSharp.Roslyn.CSharp/Services/Diagnostics/CodeCheckService.cs

@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using System.Collections.Immutable;
+using System.Collections.Immutable;
 using System.Composition;
 using System.Linq;
 using System.Threading.Tasks;
@@ -9,7 +8,6 @@
 using OmniSharp.Mef;
 using OmniSharp.Models;
 using OmniSharp.Models.CodeCheck;
-using OmniSharp.Models.Diagnostics;
 using OmniSharp.Options;
 using OmniSharp.Roslyn.CSharp.Workers.Diagnostics;
 
@@ -45,11 +43,11 @@ public async Task<QuickFixResponse> Handle(CodeCheckRequest request)
             return GetResponseFromDiagnostics(diagnostics, request.FileName);
         }
 
-        private static QuickFixResponse GetResponseFromDiagnostics(ImmutableArray<(string projectName, Diagnostic diagnostic)> diagnostics, string fileName)
+        private static QuickFixResponse GetResponseFromDiagnostics(ImmutableArray<DocumentDiagnostics> diagnostics, string fileName)
         {
             var diagnosticLocations = diagnostics
-                .Where(x => (string.IsNullOrEmpty(fileName)
-                    || x.diagnostic.Location.GetLineSpan().Path == fileName))
+                .Where(x => string.IsNullOrEmpty(fileName)
+                    || x.DocumentPath == fileName)
                 .DistinctDiagnosticLocationsByProject()
                 .Where(x => x.FileName != null);
 

src/OmniSharp.Roslyn.CSharp/Services/Refactoring/DocumentWithFixProvidersAndMatchingDiagnostics.cs

@@ -0,0 +1,102 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using OmniSharp.Roslyn.CSharp.Services.Diagnostics;
+
+namespace OmniSharp.Roslyn.CSharp.Services.Refactoring
+{
+
+    public class DocumentWithFixProvidersAndMatchingDiagnostics
+    {
+        private readonly DocumentDiagnostics _documentDiagnostics;
+
+        // http://source.roslyn.io/#Microsoft.VisualStudio.LanguageServices.CSharp/LanguageService/CSharpCodeCleanupFixer.cs,d9a375db0f1e430e,references
+        // CS8019 isn't directly used (via roslyn) but has an analyzer that report different diagnostic based on CS8019 to improve user experience.
+        private static readonly Dictionary<string, string> _customDiagVsFixMap = new Dictionary<string, string>
+        {
+            { "CS8019", "RemoveUnnecessaryImportsFixable" }
+        };
+
+        private DocumentWithFixProvidersAndMatchingDiagnostics(CodeFixProvider provider, DocumentDiagnostics documentDiagnostics)
+        {
+            CodeFixProvider = provider;
+            _documentDiagnostics = documentDiagnostics;
+            FixAllProvider = provider.GetFixAllProvider();
+        }
+
+        public CodeFixProvider CodeFixProvider { get; }
+        public FixAllProvider FixAllProvider { get; }
+        public DocumentId DocumentId => _documentDiagnostics.DocumentId;
+        public ProjectId ProjectId => _documentDiagnostics.ProjectId;
+        public string DocumentPath => _documentDiagnostics.DocumentPath;
+
+        public IEnumerable<(string id, string messsage)> FixableDiagnostics => _documentDiagnostics.Diagnostics
+            .Where(x => HasFixToShow(x.Id))
+            .Select(x => (x.Id, x.GetMessage()));
+
+        // Theres specific filterings between what is shown and what is fixed because of some custom mappings
+        // between diagnostics and their fixers. We dont want to show text 'RemoveUnnecessaryImportsFixable: ...'
+        // but instead 'CS8019: ...' where actual fixer is RemoveUnnecessaryImportsFixable behind the scenes.
+        private bool HasFixToShow(string diagnosticId)
+        {
+            return CodeFixProvider.FixableDiagnosticIds.Any(id => id == diagnosticId) && !_customDiagVsFixMap.ContainsValue(diagnosticId) || HasMappedFixAvailable(diagnosticId);
+        }
+
+        public bool HasFixForId(string diagnosticId)
+        {
+            return CodeFixProvider.FixableDiagnosticIds.Any(id => id == diagnosticId && !_customDiagVsFixMap.ContainsKey(diagnosticId)) || HasMappedFixAvailable(diagnosticId);
+        }
+
+        private bool HasMappedFixAvailable(string diagnosticId)
+        {
+            return (_customDiagVsFixMap.ContainsKey(diagnosticId) && CodeFixProvider.FixableDiagnosticIds.Any(id => id == _customDiagVsFixMap[diagnosticId]));
+        }
+
+        public static ImmutableArray<DocumentWithFixProvidersAndMatchingDiagnostics> CreateWithMatchingProviders(ImmutableArray<CodeFixProvider> providers, DocumentDiagnostics documentDiagnostics)
+        {
+            return
+                providers
+                    .Select(provider => new DocumentWithFixProvidersAndMatchingDiagnostics(provider, documentDiagnostics))
+                    .Where(x => x._documentDiagnostics.Diagnostics.Any(d => x.HasFixToShow(d.Id)) || x._documentDiagnostics.Diagnostics.Any(d => x.HasFixForId(d.Id)))
+                    .Where(x => x.FixAllProvider != null)
+                    .ToImmutableArray();
+        }
+
+        public async Task<(CodeAction action, ImmutableArray<string> idsToFix)> RegisterCodeFixesOrDefault(Document document)
+        {
+            CodeAction action = null;
+
+            var fixableDiagnostics = _documentDiagnostics
+                .Diagnostics
+                .Where(x => HasFixForId(x.Id))
+                .ToImmutableArray();
+
+            foreach (var diagnostic in fixableDiagnostics)
+            {
+                var context = new CodeFixContext(
+                document,
+                diagnostic,
+                (a, _) =>
+                {
+                    if (action == null)
+                    {
+                        action = a;
+                    }
+                },
+                CancellationToken.None);
+
+                await CodeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(false);
+            }
+
+            if(action == null)
+                return default;
+
+            return (action, fixableDiagnostics.Select(x => x.Id).Distinct().ToImmutableArray());
+        }
+    }
+}

src/OmniSharp.Roslyn.CSharp/Services/Refactoring/GetFixAllCodeActionService.cs

@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.Extensions.Logging;
+using OmniSharp.Abstractions.Models.V1.FixAll;
+using OmniSharp.Mef;
+using OmniSharp.Roslyn.CSharp.Services.Refactoring.V2;
+using OmniSharp.Roslyn.CSharp.Workers.Diagnostics;
+using OmniSharp.Services;
+
+namespace OmniSharp.Roslyn.CSharp.Services.Refactoring
+{
+    [OmniSharpHandler(OmniSharpEndpoints.GetFixAll, LanguageNames.CSharp)]
+    public class GetFixAllCodeActionService : BaseCodeActionService<GetFixAllRequest, GetFixAllResponse>
+    {
+        [ImportingConstructor]
+        public GetFixAllCodeActionService(
+            OmniSharpWorkspace workspace,
+            [ImportMany] IEnumerable<ICodeActionProvider> providers,
+            ILoggerFactory loggerFactory,
+            ICsDiagnosticWorker diagnostics,
+            CachingCodeFixProviderForProjects codeFixesForProject
+        ) : base(workspace, providers, loggerFactory.CreateLogger<GetFixAllCodeActionService>(), diagnostics, codeFixesForProject)
+        {
+        }
+
+        public override async Task<GetFixAllResponse> Handle(GetFixAllRequest request)
+        {
+            var availableFixes = await GetDiagnosticsMappedWithFixAllProviders(request.Scope, request.FileName);
+
+            var distinctDiagnosticsThatCanBeFixed = availableFixes
+                .SelectMany(x => x.FixableDiagnostics)
+                .GroupBy(x => x.id) // Distinct isn't good fit here since theres cases where Id has multiple different messages based on location, just show one of them.
+                .Select(x => x.First())
+                .Select(x => new FixAllItem(x.id, x.messsage))
+                .OrderBy(x => x.Id)
+                .ToArray();
+
+            return new GetFixAllResponse(distinctDiagnosticsThatCanBeFixed);
+        }
+    }
+}