Merge pull request #2017 from sharwell/apply-fixes

Add /apply option to write /fixall changes back to disk

Author: sharwell

StyleCop.Analyzers/StyleCopTester/Program.cs

@@ -74,6 +74,16 @@ private static async Task MainAsync(string[] args, CancellationToken cancellatio
             }
             else
             {
+                bool applyChanges = args.Contains("/apply");
+                if (applyChanges)
+                {
+                    if (!args.Contains("/fixall"))
+                    {
+                        Console.Error.WriteLine("Error: /apply can only be used with /fixall");
+                        return;
+                    }
+                }
+
                 Stopwatch stopwatch = Stopwatch.StartNew();
                 var analyzers = GetAllAnalyzers();
 
@@ -91,7 +101,7 @@ private static async Task MainAsync(string[] args, CancellationToken cancellatio
 
                 Console.WriteLine($"Loaded solution in {stopwatch.ElapsedMilliseconds}ms");
 
-                if (!args.Contains("/nostats"))
+                if (args.Contains("/stats"))
                 {
                     List<Project> csharpProjects = solution.Projects.Where(i => i.Language == LanguageNames.CSharp).ToList();
 
@@ -107,7 +117,9 @@ private static async Task MainAsync(string[] args, CancellationToken cancellatio
 
                 stopwatch.Restart();
 
-                var diagnostics = await GetAnalyzerDiagnosticsAsync(solution, solutionPath, analyzers, cancellationToken).ConfigureAwait(true);
+                bool force = args.Contains("/force");
+
+                var diagnostics = await GetAnalyzerDiagnosticsAsync(solution, solutionPath, analyzers, force, cancellationToken).ConfigureAwait(true);
                 var allDiagnostics = diagnostics.SelectMany(i => i.Value).ToImmutableArray();
 
                 Console.WriteLine($"Found {allDiagnostics.Length} diagnostics in {stopwatch.ElapsedMilliseconds}ms");
@@ -140,7 +152,7 @@ private static async Task MainAsync(string[] args, CancellationToken cancellatio
 
                 if (args.Contains("/fixall"))
                 {
-                    await TestFixAllAsync(stopwatch, solution, diagnostics, cancellationToken).ConfigureAwait(true);
+                    await TestFixAllAsync(stopwatch, solution, diagnostics, applyChanges, cancellationToken).ConfigureAwait(true);
                 }
             }
         }
@@ -177,7 +189,7 @@ private static void WriteDiagnosticResults(ImmutableArray<Tuple<ProjectId, Diagn
             File.WriteAllText(uniqueFileName, uniqueOutput.ToString(), Encoding.UTF8);
         }
 
-        private static async Task TestFixAllAsync(Stopwatch stopwatch, Solution solution, ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>> diagnostics, CancellationToken cancellationToken)
+        private static async Task TestFixAllAsync(Stopwatch stopwatch, Solution solution, ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>> diagnostics, bool applyChanges, CancellationToken cancellationToken)
         {
             Console.WriteLine("Calculating fixes");
 
@@ -191,6 +203,11 @@ private static async Task TestFixAllAsync(Stopwatch stopwatch, Solution solution
             }
 
             Console.WriteLine($"Found {equivalenceGroups.Count} equivalence groups.");
+            if (applyChanges && equivalenceGroups.Count > 1)
+            {
+                Console.Error.WriteLine("/apply can only be used with a single equivalence group.");
+                return;
+            }
 
             Console.WriteLine("Calculating changes");
 
@@ -200,7 +217,24 @@ private static async Task TestFixAllAsync(Stopwatch stopwatch, Solution solution
                 {
                     stopwatch.Restart();
                     Console.WriteLine($"Calculating fix for {fix.CodeFixEquivalenceKey} using {fix.FixAllProvider} for {fix.NumberOfDiagnostics} instances.");
-                    await fix.GetOperationsAsync(cancellationToken).ConfigureAwait(true);
+                    var operations = await fix.GetOperationsAsync(cancellationToken).ConfigureAwait(true);
+                    if (applyChanges)
+                    {
+                        var applyOperations = operations.OfType<ApplyChangesOperation>().ToList();
+                        if (applyOperations.Count > 1)
+                        {
+                            Console.Error.WriteLine("/apply can only apply a single code action operation.");
+                        }
+                        else if (applyOperations.Count == 0)
+                        {
+                            Console.WriteLine("No changes were found to apply.");
+                        }
+                        else
+                        {
+                            applyOperations[0].Apply(solution.Workspace, cancellationToken);
+                        }
+                    }
+
                     WriteLine($"Calculating changes completed in {stopwatch.ElapsedMilliseconds}ms. This is {fix.NumberOfDiagnostics / stopwatch.Elapsed.TotalSeconds:0.000} instances/second.", ConsoleColor.Yellow);
                 }
                 catch (Exception ex)
@@ -389,7 +423,7 @@ private static ImmutableDictionary<FixAllProvider, ImmutableHashSet<string>> Get
             return fixAllProviders.ToImmutableDictionary();
         }
 
-        private static async Task<ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>>> GetAnalyzerDiagnosticsAsync(Solution solution, string solutionPath, ImmutableArray<DiagnosticAnalyzer> analyzers, CancellationToken cancellationToken)
+        private static async Task<ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>>> GetAnalyzerDiagnosticsAsync(Solution solution, string solutionPath, ImmutableArray<DiagnosticAnalyzer> analyzers, bool force, CancellationToken cancellationToken)
         {
             List<KeyValuePair<ProjectId, Task<ImmutableArray<Diagnostic>>>> projectDiagnosticTasks = new List<KeyValuePair<ProjectId, Task<ImmutableArray<Diagnostic>>>>();
 
@@ -401,7 +435,7 @@ private static async Task<ImmutableDictionary<ProjectId, ImmutableArray<Diagnost
                     continue;
                 }
 
-                projectDiagnosticTasks.Add(new KeyValuePair<ProjectId, Task<ImmutableArray<Diagnostic>>>(project.Id, GetProjectAnalyzerDiagnosticsAsync(analyzers, project, cancellationToken)));
+                projectDiagnosticTasks.Add(new KeyValuePair<ProjectId, Task<ImmutableArray<Diagnostic>>>(project.Id, GetProjectAnalyzerDiagnosticsAsync(analyzers, project, force, cancellationToken)));
             }
 
             ImmutableDictionary<ProjectId, ImmutableArray<Diagnostic>>.Builder projectDiagnosticBuilder = ImmutableDictionary.CreateBuilder<ProjectId, ImmutableArray<Diagnostic>>();
@@ -418,17 +452,22 @@ private static async Task<ImmutableDictionary<ProjectId, ImmutableArray<Diagnost
         /// </summary>
         /// <param name="analyzers">The list of analyzers that should be used</param>
         /// <param name="project">The project that should be analyzed</param>
+        /// <param name="force"><see langword="true"/> to force the analyzers to be enabled; otherwise,
+        /// <see langword="false"/> to use the behavior configured for the specified <paramref name="project"/>.</param>
         /// <param name="cancellationToken">The cancellation token that the task will observe.</param>
         /// <returns>A list of diagnostics inside the project</returns>
-        private static async Task<ImmutableArray<Diagnostic>> GetProjectAnalyzerDiagnosticsAsync(ImmutableArray<DiagnosticAnalyzer> analyzers, Project project, CancellationToken cancellationToken)
+        private static async Task<ImmutableArray<Diagnostic>> GetProjectAnalyzerDiagnosticsAsync(ImmutableArray<DiagnosticAnalyzer> analyzers, Project project, bool force, CancellationToken cancellationToken)
         {
             var supportedDiagnosticsSpecificOptions = new Dictionary<string, ReportDiagnostic>();
-            foreach (var analyzer in analyzers)
+            if (force)
             {
-                foreach (var diagnostic in analyzer.SupportedDiagnostics)
+                foreach (var analyzer in analyzers)
                 {
-                    // make sure the analyzers we are testing are enabled
-                    supportedDiagnosticsSpecificOptions[diagnostic.Id] = ReportDiagnostic.Default;
+                    foreach (var diagnostic in analyzer.SupportedDiagnostics)
+                    {
+                        // make sure the analyzers we are testing are enabled
+                        supportedDiagnosticsSpecificOptions[diagnostic.Id] = ReportDiagnostic.Default;
+                    }
                 }
             }
 
@@ -452,10 +491,12 @@ private static void PrintHelp()
             Console.WriteLine("Usage: StyleCopTester [options] <Solution>");
             Console.WriteLine("Options:");
             Console.WriteLine("/all       Run all StyleCopAnalyzers analyzers, including ones that are disabled by default");
-            Console.WriteLine("/nostats   Disable the display of statistics");
+            Console.WriteLine("/stats     Display statistics of the solution");
             Console.WriteLine("/codefixes Test single code fixes");
             Console.WriteLine("/fixall    Test fix all providers");
             Console.WriteLine("/id:<id>   Enable analyzer with diagnostic ID < id > (when this is specified, only this analyzer is enabled)");
+            Console.WriteLine("/apply     Write code fix changes back to disk");
+            Console.WriteLine("/force     Force an analyzer to be enabled, regardless of the configured rule set(s) for the solution");
         }
     }
 }

StyleCop.Analyzers/StyleCopTester/StyleCopTester.csproj

@@ -37,7 +37,7 @@
     <CodeAnalysisRuleSet>..\StyleCop.Analyzers.Internal.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup>
-    <StartArguments>..\..\StyleCopAnalyzers.sln</StartArguments>
+    <StartArguments>..\..\StyleCopAnalyzers.sln /stats</StartArguments>
     <StartWorkingDirectory>$(MSBuildProjectDirectory)</StartWorkingDirectory>
   </PropertyGroup>
   <PropertyGroup>