Merge main to main-vs-deps

src/Analyzers/Core/Analyzers/IDEDiagnosticIdToOptionMappingHelper.cs

@@ -27,6 +27,10 @@ public static bool TryGetMappedOptions(string diagnosticId, string language, [No
                (s_diagnosticIdToLanguageSpecificOptionsMap.TryGetValue(language, out var map) &&
                 map.TryGetValue(diagnosticId, out options));
 
+        public static bool IsKnownIDEDiagnosticId(string diagnosticId)
+            => s_diagnosticIdToOptionMap.ContainsKey(diagnosticId) ||
+               s_diagnosticIdToLanguageSpecificOptionsMap.Values.Any(map => map.ContainsKey(diagnosticId));
+
         public static void AddOptionMapping(string diagnosticId, ImmutableHashSet<IPerLanguageOption> perLanguageOptions)
         {
             diagnosticId = diagnosticId ?? throw new ArgumentNullException(nameof(diagnosticId));

src/EditorFeatures/CSharp/CodeCleanup/CSharpCodeCleanupService.cs

@@ -267,8 +267,8 @@ internal class CSharpCodeCleanupService : AbstractCodeCleanupService
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CSharpCodeCleanupService(ICodeFixService codeFixService)
-            : base(codeFixService)
+        public CSharpCodeCleanupService(ICodeFixService codeFixService, IDiagnosticAnalyzerService diagnosticAnalyzerService)
+            : base(codeFixService, diagnosticAnalyzerService)
         {
         }
 

src/EditorFeatures/CSharpTest/Formatting/CodeCleanupTests.TestFixers.cs

@@ -0,0 +1,179 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Formatting
+{
+    public partial class CodeCleanupTests
+    {
+        private abstract class TestThirdPartyCodeFix : CodeFixProvider
+        {
+            public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create("HasDefaultCase");
+
+            public override Task RegisterCodeFixesAsync(CodeFixContext context)
+            {
+                foreach (var diagnostic in context.Diagnostics)
+                {
+                    context.RegisterCodeFix(
+                        CodeAction.Create(
+                            "Remove default case",
+                            async cancellationToken =>
+                            {
+                                var root = await context.Document.GetSyntaxRootAsync(cancellationToken);
+                                Assumes.NotNull(root);
+                                var sourceTree = diagnostic.Location.SourceTree;
+                                Assumes.NotNull(sourceTree);
+                                var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
+                                Assumes.NotNull(node?.Parent);
+                                var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
+                                Assumes.NotNull(newRoot);
+                                return context.Document.WithSyntaxRoot(newRoot);
+                            },
+                            nameof(TestThirdPartyCodeFix)),
+                        diagnostic);
+                }
+
+                return Task.CompletedTask;
+            }
+        }
+
+        [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
+        private class TestThirdPartyCodeFixWithFixAll : TestThirdPartyCodeFix
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public TestThirdPartyCodeFixWithFixAll()
+            {
+            }
+
+            public override FixAllProvider GetFixAllProvider() => BatchFixAllProvider.Instance;
+        }
+
+        [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
+        private class TestThirdPartyCodeFixWithOutFixAll : TestThirdPartyCodeFix
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public TestThirdPartyCodeFixWithOutFixAll()
+            {
+            }
+        }
+
+        [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
+        private class TestThirdPartyCodeFixModifiesSolution : TestThirdPartyCodeFix
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public TestThirdPartyCodeFixModifiesSolution()
+            {
+            }
+
+            public override FixAllProvider GetFixAllProvider() => new ModifySolutionFixAll();
+
+            private class ModifySolutionFixAll : FixAllProvider
+            {
+                public override Task<CodeAction?> GetFixAsync(FixAllContext fixAllContext)
+                {
+                    var solution = fixAllContext.Solution;
+                    return Task.FromResult<CodeAction?>(CodeAction.Create(
+                            "Remove default case",
+                            async cancellationToken =>
+                            {
+                                var toFix = await fixAllContext.GetDocumentDiagnosticsToFixAsync();
+                                Project? project = null;
+                                foreach (var kvp in toFix)
+                                {
+                                    var document = kvp.Key;
+                                    project ??= document.Project;
+                                    var diagnostics = kvp.Value;
+                                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                                    Assumes.NotNull(root);
+                                    foreach (var diagnostic in diagnostics)
+                                    {
+                                        var sourceTree = diagnostic.Location.SourceTree;
+                                        Assumes.NotNull(sourceTree);
+                                        var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
+                                        Assumes.NotNull(node?.Parent);
+                                        var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
+                                        Assumes.NotNull(newRoot);
+                                        document = document.WithSyntaxRoot(newRoot);
+                                    }
+
+                                    solution = solution.WithDocumentText(document.Id, await document.GetTextAsync());
+                                }
+
+                                Assumes.NotNull(project);
+                                return solution.AddDocument(DocumentId.CreateNewId(project.Id), "new.cs", SourceText.From(""));
+                            },
+                            nameof(TestThirdPartyCodeFix)));
+                }
+            }
+        }
+
+        [PartNotDiscoverable, Shared, ExportCodeFixProvider(LanguageNames.CSharp)]
+        private class TestThirdPartyCodeFixDoesNotSupportDocumentScope : TestThirdPartyCodeFix
+        {
+            [ImportingConstructor]
+            [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+            public TestThirdPartyCodeFixDoesNotSupportDocumentScope()
+            {
+            }
+
+            public override FixAllProvider GetFixAllProvider() => new ModifySolutionFixAll();
+
+            private class ModifySolutionFixAll : FixAllProvider
+            {
+                public override IEnumerable<FixAllScope> GetSupportedFixAllScopes()
+                {
+                    return new[] { FixAllScope.Project, FixAllScope.Solution, FixAllScope.Custom };
+                }
+
+                public override Task<CodeAction?> GetFixAsync(FixAllContext fixAllContext)
+                {
+                    var solution = fixAllContext.Solution;
+                    return Task.FromResult<CodeAction?>(CodeAction.Create(
+                            "Remove default case",
+                            async cancellationToken =>
+                            {
+                                var toFix = await fixAllContext.GetDocumentDiagnosticsToFixAsync();
+                                Project? project = null;
+                                foreach (var kvp in toFix)
+                                {
+                                    var document = kvp.Key;
+                                    project ??= document.Project;
+                                    var diagnostics = kvp.Value;
+                                    var root = await document.GetSyntaxRootAsync(cancellationToken);
+                                    Assumes.NotNull(root);
+                                    foreach (var diagnostic in diagnostics)
+                                    {
+                                        var sourceTree = diagnostic.Location.SourceTree;
+                                        Assumes.NotNull(sourceTree);
+                                        var node = (await sourceTree.GetRootAsync(cancellationToken)).FindNode(diagnostic.Location.SourceSpan);
+                                        Assumes.NotNull(node?.Parent);
+                                        var newRoot = root.RemoveNode(node.Parent, SyntaxRemoveOptions.KeepNoTrivia);
+                                        Assumes.NotNull(newRoot);
+                                        document = document.WithSyntaxRoot(newRoot);
+                                    }
+
+                                    solution = solution.WithDocumentText(document.Id, await document.GetTextAsync());
+                                }
+
+                                Assumes.NotNull(project);
+                                return solution.AddDocument(DocumentId.CreateNewId(project.Id), "new.cs", SourceText.From(""));
+                            },
+                            nameof(TestThirdPartyCodeFix)));
+                }
+            }
+        }
+    }
+}