Fix OOP crash issue with copilot change analysis (#78931)

Author: CyrusNajmabadi

src/Features/Core/Portable/Copilot/CopilotChangeAnalysis.cs

@@ -55,4 +55,6 @@ internal readonly record struct CopilotCodeFixAnalysis(
     [property: DataMember(Order = 3)] Dictionary<string, TimeSpan> DiagnosticIdToApplicationTime,
     [property: DataMember(Order = 4)] Dictionary<string, HashSet<string>> DiagnosticIdToProviderName,
     [property: DataMember(Order = 5)] Dictionary<string, TimeSpan> ProviderNameToApplicationTime,
-    [property: DataMember(Order = 6)] Dictionary<string, bool> ProviderNameToHasConflict);
+    [property: DataMember(Order = 6)] Dictionary<string, bool> ProviderNameToHasConflict,
+    [property: DataMember(Order = 7)] Dictionary<string, int> ProviderNameToTotalCount,
+    [property: DataMember(Order = 8)] Dictionary<string, int> ProviderNameToSuccessCount);

src/Features/Core/Portable/Copilot/CopilotChangeAnalysisUtilities.cs

@@ -120,6 +120,8 @@ public static IDisposable LogCopilotChangeAnalysis(
             d["CodeFixAnalysis_DiagnosticIdToProviderName"] = StringifyDictionary(analysisResult.CodeFixAnalysis.DiagnosticIdToProviderName);
             d["CodeFixAnalysis_ProviderNameToApplicationTime"] = StringifyDictionary(analysisResult.CodeFixAnalysis.ProviderNameToApplicationTime);
             d["CodeFixAnalysis_ProviderNameToHasConflict"] = StringifyDictionary(analysisResult.CodeFixAnalysis.ProviderNameToHasConflict);
+            d["CodeFixAnalysis_ProviderNameToTotalCount"] = StringifyDictionary(analysisResult.CodeFixAnalysis.ProviderNameToTotalCount);
+            d["CodeFixAnalysis_ProviderNameToSuccessCount"] = StringifyDictionary(analysisResult.CodeFixAnalysis.ProviderNameToSuccessCount);
         }, args: (featureId, accepted, proposalId, analysisResult)),
         cancellationToken);
     }

src/Features/Core/Portable/Copilot/ICopilotChangeAnalysisService.cs

@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -255,30 +256,44 @@ private async Task<CopilotCodeFixAnalysis> ComputeCodeFixAnalysisAsync(
         var diagnosticIdToProviderName = new Dictionary<string, HashSet<string>>();
         var providerNameToApplicationTime = new Dictionary<string, TimeSpan>();
         var providerNameToHasConflict = new Dictionary<string, bool>();
+        var providerNameToTotalCount = new Dictionary<string, int>();
+        var providerNameToSuccessCount = new Dictionary<string, int>();
 
         var totalApplicationTimeStopWatch = SharedStopwatch.StartNew();
-        await ProducerConsumer<(CodeFixCollection collection, TimeSpan elapsedTime)>.RunParallelAsync(
+        await ProducerConsumer<(CodeFixCollection collection, bool success, TimeSpan elapsedTime)>.RunParallelAsync(
             codeFixCollections,
             produceItems: static async (codeFixCollection, callback, args, cancellationToken) =>
             {
-                var (@this, solution, _, _, _, _, _) = args;
+                var (@this, solution, _, _, _, _, _, _, _) = args;
                 var firstAction = GetFirstAction(codeFixCollection.Fixes[0]);
 
                 var applicationTimeStopWatch = SharedStopwatch.StartNew();
-                var result = await firstAction.GetPreviewOperationsAsync(solution, cancellationToken).ConfigureAwait(false);
-                callback((codeFixCollection, applicationTimeStopWatch.Elapsed));
+                var success = true;
+                try
+                {
+                    await firstAction
+                        .GetPreviewOperationsAsync(solution, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
+                {
+                    success = false;
+                }
+
+                callback((codeFixCollection, success, applicationTimeStopWatch.Elapsed));
             },
             consumeItems: static async (values, args, cancellationToken) =>
             {
-                var (@this, solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName, providerNameToApplicationTime, providerNameToHasConflict) = args;
+                var (@this, solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName,
+                    providerNameToApplicationTime, providerNameToHasConflict, providerNameToTotalCount, providerNameToSuccessCount) = args;
 
                 // Track which text span each code fix says it will be fixing.  We can use this to efficiently determine
                 // which codefixes 'conflict' with some other codefix (in that that multiple features think they can fix
                 // the same span of code).  We would need some mechanism to determine which we would prefer to take in
                 // order to have a good experience in such a case.
                 var intervalTree = new SimpleMutableIntervalTree<CodeFixCollection, CodeFixCollectionIntervalIntrospector>(new CodeFixCollectionIntervalIntrospector());
 
-                await foreach (var (codeFixCollection, applicationTime) in values)
+                await foreach (var (codeFixCollection, success, applicationTime) in values)
                 {
                     var diagnosticId = codeFixCollection.FirstDiagnostic.Id;
                     var providerName = GetProviderName(codeFixCollection);
@@ -287,6 +302,10 @@ private async Task<CopilotCodeFixAnalysis> ComputeCodeFixAnalysisAsync(
                     IncrementElapsedTime(diagnosticIdToApplicationTime, diagnosticId, applicationTime);
                     diagnosticIdToProviderName.MultiAdd(diagnosticId, providerName);
                     IncrementElapsedTime(providerNameToApplicationTime, providerName, applicationTime);
+                    IncrementCount(providerNameToTotalCount, providerName);
+
+                    if (success)
+                        IncrementCount(providerNameToSuccessCount, providerName);
 
                     intervalTree.AddIntervalInPlace(codeFixCollection);
                 }
@@ -311,7 +330,8 @@ private async Task<CopilotCodeFixAnalysis> ComputeCodeFixAnalysisAsync(
                     providerNameToHasConflict[providerName] = storedHasConflictValue || newHasConflictValue;
                 }
             },
-            args: (@this: this, newDocument.Project.Solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName, providerNameToApplicationTime, providerNameToHasConflict),
+            args: (@this: this, newDocument.Project.Solution, diagnosticIdToCount, diagnosticIdToApplicationTime, diagnosticIdToProviderName,
+            providerNameToApplicationTime, providerNameToHasConflict, providerNameToTotalCount, providerNameToSuccessCount),
             cancellationToken).ConfigureAwait(false);
         var totalApplicationTime = totalApplicationTimeStopWatch.Elapsed;
 
@@ -322,7 +342,9 @@ private async Task<CopilotCodeFixAnalysis> ComputeCodeFixAnalysisAsync(
             diagnosticIdToApplicationTime,
             diagnosticIdToProviderName,
             providerNameToApplicationTime,
-            providerNameToHasConflict);
+            providerNameToHasConflict,
+            providerNameToTotalCount,
+            providerNameToSuccessCount);
 
         Task<ImmutableArray<CodeFixCollection>> ComputeCodeFixCollectionsAsync()
         {