Optimize codegen performance for real world solutions

Based on the ASP.NET Core solution, we added the following optimizations:

* Add a FixAll provider to support batch code fixing of all mocks/stunts that need codegen
* Do not get *all* diagnostics from *all* analyzers when getting code fixes, but only those from analyzers that produce diagnostics the desired code fix provider can actually fix (otherwise, we were also getting a ton of diagnostics that might have nothing to do with the code fix provider and intended code fix name)

This *significantly* improves the performance of the code generation with real world solutions.

src/Stunts/Stunts.CodeFix/Properties/Resources.resx

@@ -141,9 +141,6 @@
   <data name="DuplicateBaseType_Title" xml:space="preserve">
     <value>Multiple base types specified</value>
   </data>
-  <data name="GenerateStuntCodeFix_FixAllTitle" xml:space="preserve">
-    <value>Generate all stunts in {0} {1}</value>
-  </data>
   <data name="GenerateStuntCodeFix_Title" xml:space="preserve">
     <value>Generate Stunt</value>
   </data>
@@ -183,6 +180,12 @@
   <data name="SealedBaseType_Title" xml:space="preserve">
     <value>Invalid sealed base type</value>
   </data>
+  <data name="StuntCodeAction_Title" xml:space="preserve">
+    <value>Fix {0}</value>
+  </data>
+  <data name="StuntFixAllProvider_Title" xml:space="preserve">
+    <value>Fix all {0} in {1}</value>
+  </data>
   <data name="UnsupportedNestedTypeAnalyzer_Description" xml:space="preserve">
     <value>Generating code for nested types is not supported yet.</value>
   </data>
@@ -192,9 +195,6 @@
   <data name="UnsupportedNestedTypeAnalyzer_Title" xml:space="preserve">
     <value>Unsupported nested type</value>
   </data>
-  <data name="UpdateStuntCodeFix_FixAllTitle" xml:space="preserve">
-    <value>Update all stunts in {0} {1}</value>
-  </data>
   <data name="UpdateStuntCodeFix_Title" xml:space="preserve">
     <value>Update Stunt</value>
   </data>

src/Stunts/Stunts.CodeFix/StuntCodeAction.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Simplification;
+using Stunts.Properties;
 
 namespace Stunts
 {
@@ -22,6 +23,14 @@ public class StuntCodeAction : CodeAction
         readonly Diagnostic diagnostic;
         readonly NamingConvention naming;
 
+        /// <summary>
+        /// Initializes the action.
+        /// </summary>
+        public StuntCodeAction(Document document, Diagnostic diagnostic, NamingConvention naming)
+            : this(Resources.StuntCodeAction_Title, document, diagnostic, naming)
+        {
+        }
+
         /// <summary>
         /// Initializes the action.
         /// </summary>
@@ -34,7 +43,9 @@ public StuntCodeAction(string title, Document document, Diagnostic diagnostic, N
         }
 
         /// <inheritdoc />
-        public override string EquivalenceKey => diagnostic.Id + ":" + diagnostic.Properties["TargetFullName"];
+        //public override string EquivalenceKey => diagnostic.Id + ":" + diagnostic.Properties["TargetFullName"];
+
+        public override string EquivalenceKey => diagnostic.Id;
 
         /// <inheritdoc />
         public override string Title => title;
@@ -62,6 +73,12 @@ protected override async Task<Document> GetChangedDocumentAsync(CancellationToke
                 .Where(t => t != null)
                 .ToArray();
 
+            var name = naming.GetFullName(symbols);
+            // Check if the compilation already contains the type, which will be 
+            // the case in batch fixing
+            if (compilation.GetTypeByMetadataName(name) != null)
+                return document;
+
             var generator = SyntaxGenerator.GetGenerator(document.Project);
             var stunts = CreateGenerator(naming);
 

src/Stunts/Stunts.CodeFix/StuntCodeFixProvider.cs

@@ -78,6 +78,7 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
         /// <returns></returns>
         // See https://github.com/dotnet/roslyn/blob/master/docs/analyzers/FixAllProvider.md for more information on Fix All Providers
         //public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
-        public override FixAllProvider GetFixAllProvider() => null;
+        public override FixAllProvider GetFixAllProvider()
+            => new StuntFixAllProvider(FixableDiagnosticIds.First(), CreateCodeAction);
     }
 }

src/Stunts/Stunts.CodeFix/StuntFixAllProvider.cs

@@ -1,23 +1,29 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Text;
+using Stunts.Properties;
 
 namespace Stunts
 {
     class StuntFixAllProvider : FixAllProvider
     {
-        string titleFormat;
-        string diagnosticId;
+        readonly string diagnosticId;
+        readonly Func<Document, Diagnostic, CodeAction> codeActionFactory;
 
-        public StuntFixAllProvider(string titleFormat, string diagnosticId)
+        public StuntFixAllProvider(string diagnosticId, Func<Document, Diagnostic, CodeAction> codeActionFactory)
         {
-            this.titleFormat = titleFormat;
             this.diagnosticId = diagnosticId;
+            this.codeActionFactory = codeActionFactory;
         }
 
         public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
@@ -34,7 +40,7 @@ public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
                         if (diagnostics.Length > 0)
                             diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(fixAllContext.Project, diagnostics));
 
-                        title = string.Format(titleFormat, "document", fixAllContext.Document.Name);
+                        title = string.Format(Resources.StuntFixAllProvider_Title, diagnosticId, fixAllContext.Document.Name);
                         break;
                     }
 
@@ -45,7 +51,7 @@ public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
                         if (diagnostics.Length > 0)
                             diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics));
 
-                        title = string.Format(titleFormat, "project", fixAllContext.Project.Name);
+                        title = string.Format(Resources.StuntFixAllProvider_Title, diagnosticId, fixAllContext.Project.Name);
                         break;
                     }
 
@@ -58,7 +64,10 @@ public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
                                 diagnosticsToFix.Add(new KeyValuePair<Project, ImmutableArray<Diagnostic>>(project, diagnostics));
                         }
 
-                        title = string.Format(titleFormat, "solution", "");
+                        title = string.Format(Resources.StuntFixAllProvider_Title, diagnosticId, 
+                            fixAllContext.Solution.FilePath == null ? 
+                            nameof(FixAllScope.Solution) : 
+                            Path.GetFileName(fixAllContext.Solution.FilePath));
                         break;
                     }
 
@@ -68,48 +77,101 @@ public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
                     break;
             }
 
-            return new FixAllProxiesCodeAction(title, fixAllContext.Solution, diagnosticsToFix);
+            return new FixAllProxiesCodeAction(title, fixAllContext.Solution, diagnosticsToFix, codeActionFactory);
         }
 
         class FixAllProxiesCodeAction : CodeAction
         {
-            string title;
-            Solution solution;
-            List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix;
-
-            public FixAllProxiesCodeAction(string title, Solution solution, List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix)
+            readonly string title;
+            readonly Solution solution;
+            readonly List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix;
+            readonly Func<Document, Diagnostic, CodeAction> codeActionFactory;
+
+            public FixAllProxiesCodeAction(string title, 
+                Solution solution, 
+                List<KeyValuePair<Project, ImmutableArray<Diagnostic>>> diagnosticsToFix, 
+                Func<Document, Diagnostic, CodeAction> codeActionFactory)
             {
                 this.title = title;
                 this.solution = solution;
                 this.diagnosticsToFix = diagnosticsToFix;
+                this.codeActionFactory = codeActionFactory;
             }
 
             public override string Title => title;
 
             protected override async Task<Solution> GetChangedSolutionAsync(CancellationToken cancellationToken)
             {
-                var changedSolution = solution;
+                var currentSolution = solution;
+                var fixerTasks = new List<Task>();
+                var addedDocs = new ConcurrentBag<Document>();
+                var updatedDocs = new ConcurrentBag<Document>();
+
                 foreach (var pair in diagnosticsToFix)
                 {
-                    var project = changedSolution.GetProject(pair.Key.Id);
+                    var project = solution.GetProject(pair.Key.Id);
+                    Debug.Assert(project != null, "Failed to get project from solution.");
                     var diagnostics = pair.Value;
 
-                    var group = diagnostics.GroupBy(d => d.Properties["Name"]);
+                    var group = diagnostics.GroupBy(d => d.Properties["TargetFullName"]);
                     foreach (var diag in group)
                     {
                         var diagnostic = diag.First();
-                        var document = project.GetDocument(diagnostic.Location.SourceTree);
-                        var codeAction = new StuntCodeAction(Title, document, diagnostic, new NamingConvention());
+                        var document = diagnostic.Location.IsInSource ?
+                            project.Documents.FirstOrDefault(doc => doc.FilePath == diagnostic.Location.SourceTree.FilePath) :
+                            project.GetDocument(diagnostic.Location.SourceTree);
+
+                        Debug.Assert(document != null, "Failed to locate document from diagnostic.");
 
-                        var operations = await codeAction.GetOperationsAsync(cancellationToken);
-                        ApplyChangesOperation operation;
-                        if ((operation = operations.OfType<ApplyChangesOperation>().FirstOrDefault()) != null)
-                            changedSolution = operation.ChangedSolution;
+                        fixerTasks.Add(Task.Run(async () =>
+                        {
+                            // NOTE: stunts don't need to update the source document where the diagnostic 
+                            // was reported, so we don't need any of the document updating stuff that 
+                            // we need when applying code fixers in the moq/stunt codegen itself on its own 
+                            // document. So we just apply the workspace changes and that's it.
+                            var codeAction = codeActionFactory(document, diagnostic);
+                            var operations = await codeAction.GetOperationsAsync(cancellationToken);
+                            var applyChanges = operations.OfType<ApplyChangesOperation>().FirstOrDefault();
+                            if (applyChanges != null)
+                            {
+                                var changes = applyChanges.ChangedSolution.GetChanges(currentSolution);
+                                foreach (var change in changes.GetProjectChanges())
+                                {
+                                    foreach (var addedId in change.GetAddedDocuments())
+                                    {
+                                        addedDocs.Add(applyChanges.ChangedSolution.GetDocument(addedId));
+                                    }
+                                    foreach (var changedId in change.GetChangedDocuments(true))
+                                    {
+                                        updatedDocs.Add(applyChanges.ChangedSolution.GetDocument(changedId));
+                                    }
+                                }
+                            }
+                        }));
                     }
                 }
 
-                return changedSolution;
+                await Task.WhenAll(fixerTasks).ConfigureAwait(false);
+
+                foreach (var addedDoc in addedDocs)
+                {
+                    var addedText = await addedDoc.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                    var addedVersion = await addedDoc.GetTextVersionAsync(cancellationToken).ConfigureAwait(false);
+                    currentSolution = currentSolution.AddDocument(DocumentInfo.Create(
+                        addedDoc.Id, addedDoc.Name, addedDoc.Folders,
+                        addedDoc.SourceCodeKind,
+                        TextLoader.From(TextAndVersion.Create(addedText, addedVersion, addedDoc.FilePath)),
+                        addedDoc.FilePath));
+                }
+
+                foreach (var updatedDoc in updatedDocs)
+                {
+                    var updatedText = await updatedDoc.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                    currentSolution = currentSolution.WithDocumentText(updatedDoc.Id, updatedText);
+                }
+
+                return currentSolution;
             }
         }
     }
-}
+}

src/Stunts/Stunts.Sdk/DocumentExtensions.cs

@@ -93,8 +93,24 @@ static async Task<ImmutableArray<ICodeFix>> GetCodeFixes(
             if (analyzers.IsDefaultOrEmpty)
                 analyzers = builtInAnalyzers.Value;
 
-            var analyerCompilation = compilation.WithAnalyzers(analyzers, cancellationToken: cancellationToken);
-            var allDiagnostics = await analyerCompilation.GetAllDiagnosticsAsync(cancellationToken);
+            var supportedAnalyers = analyzers
+                .Where(a => a.SupportedDiagnostics.Any(d => provider.FixableDiagnosticIds.Contains(d.Id)))
+                .ToImmutableArray();
+
+            var allDiagnostics = default(ImmutableArray<Diagnostic>);
+
+            // This may be a compiler warning/error, not an analyzer-produced one, such as 
+            // the missing abstract method implementations.
+            if (supportedAnalyers.IsEmpty)
+            {
+                allDiagnostics = compilation.GetDiagnostics(cancellationToken);
+            }
+            else
+            {
+                var analyerCompilation = compilation.WithAnalyzers(supportedAnalyers, cancellationToken: cancellationToken);
+                allDiagnostics = await analyerCompilation.GetAllDiagnosticsAsync(cancellationToken);
+            }
+
             var diagnostics = allDiagnostics
                 .Where(x => provider.FixableDiagnosticIds.Contains(x.Id))
                 // Only consider the diagnostics raised by the target document.
@@ -111,9 +127,21 @@ await provider.RegisterCodeFixesAsync(
                     cancellationToken));
             }
 
-            return codeFixes.ToImmutableArray();
+            var finalFixes = new List<ICodeFix>();
+
+            // All code actions without equivalence keys must be applied individually.
+            finalFixes.AddRange(codeFixes.Where(x => x.Action.EquivalenceKey == null));
+            // All code actions with the same equivalence key should be applied only once.
+            finalFixes.AddRange(codeFixes
+                .Where(x => x.Action.EquivalenceKey != null)
+                .GroupBy(x => x.Action.EquivalenceKey)
+                .Select(x => x.First()));
+
+            return finalFixes.ToImmutableArray();
         }
 
+        // Debug view of all available providers and their metadata
+        // document.Project.Solution.Workspace.Services.HostServices.GetExports<CodeFixProvider, IDictionary<string, object>>().OrderBy(x => x.Metadata["Name"]?.ToString()).Select(x => $"{x.Metadata["Name"]}: {string.Join(", ", (string[])x.Metadata["Languages"])}"  ).ToList()
         static CodeFixProvider GetCodeFixProvider(Document document, string codeFixName)
             => codeFixName == nameof(OverrideAllMembersCodeFix) ? new OverrideAllMembersCodeFix() :
                 document.Project.Solution.Workspace.Services.HostServices