Make many fixes to the roslyn recipe runner

Author: macsux

Rewrite/src/Rewrite.MSBuild/DiffHelper.cs

@@ -0,0 +1,34 @@
+using DiffPlex.DiffBuilder;
+using DiffPlex.DiffBuilder.Model;
+
+namespace Rewrite.MSBuild;
+
+public static class DiffHelper
+{
+    /// <summary>
+    /// Compares two strings and returns line numbers (1-based) where differences occur.
+    /// </summary>
+    /// <param name="oldText">The original text.</param>
+    /// <param name="newText">The modified text.</param>
+    /// <returns>A list of line numbers that differ between the two texts.</returns>
+    public static List<int> GetDifferentLineNumbers(string oldText, string newText)
+    {
+        var differ = new SideBySideDiffBuilder(new DiffPlex.Differ());
+        var diff = differ.BuildDiffModel(oldText, newText);
+
+        var differingLines = new List<int>();
+
+        for (int i = 0; i < diff.OldText.Lines.Count; i++)
+        {
+            var oldLine = diff.OldText.Lines[i];
+            var newLine = diff.NewText.Lines[i];
+
+            if (oldLine.Type != ChangeType.Unchanged || newLine.Type != ChangeType.Unchanged)
+            {
+                differingLines.Add(i + 1); // +1 for 1-based line numbers
+            }
+        }
+
+        return differingLines;
+    }
+}

Rewrite/src/Rewrite.MSBuild/RecipeExecutionContext.cs

@@ -68,7 +68,8 @@ public Recipe CreateRecipe(params IReadOnlyCollection<RecipeStartInfo> recipeSta
             throw new InvalidOperationException("Different recipe types cannot be mixed in same execution context");
         }
 
-        var recipeType = recipeStartInfos.First().Kind;
+        var recipeStartInfo = recipeStartInfos.First();
+        var recipeType = recipeStartInfo.Kind;
 
 
 
@@ -137,13 +138,15 @@ private Recipe CreateRoslynRecipe(params IReadOnlyCollection<RecipeStartInfo> re
     {
         var recipeStartInfo =  recipeStartInfos.First();
         var solutionFilePath = (string)recipeStartInfo.Arguments[nameof(RoslynRecipe.SolutionFilePath)].Value!;
+        var dryRun = (bool)recipeStartInfo.Arguments[nameof(RoslynRecipe.DryRun)].Value!;
         var diagnosticIds = recipeStartInfos.Select(x => x.Id).ToHashSet();
 
         var roslynRecipe = new RoslynRecipe(_recipeAssemblies, _loggerFactory.CreateLogger<RoslynRecipe>())
         {
             DiagnosticIds = diagnosticIds,
             ApplyFixer = true,
-            SolutionFilePath = solutionFilePath
+            SolutionFilePath = solutionFilePath,
+            DryRun = dryRun
         };
         return roslynRecipe;
     }

Rewrite/src/Rewrite.MSBuild/RecipeExecutionResult.cs

@@ -6,4 +6,4 @@ public record RecipeExecutionResult(string SolutionFile, TimeSpan ExecutionTime,
 
 public record IssueFixResult(string IssueId, TimeSpan ExecutionTime, List<DocumentFixResult> Fixes);
 
-public record DocumentFixResult(string FileName);
+public record DocumentFixResult(string FileName, List<int> LineNumbers);

Rewrite/src/Rewrite.MSBuild/Rewrite.MSBuild.csproj

@@ -5,6 +5,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <PackageReference Include="DiffPlex" Version="1.7.2" />
         <PackageReference Include="NMica.Utils" Version="3.0.0" />
         <PackageReference Include="Serilog" Version="4.2.0" />
         <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />

Rewrite/src/Rewrite.MSBuild/RoslynRecipe.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Reflection;
 using System.Runtime.Loader;
+using Microsoft.Build.Exceptions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
@@ -89,6 +90,7 @@ public async Task<RecipeExecutionResult> Execute(CancellationToken cancellationT
             .Cast<CodeFixProvider>()
             .Where(x => x.FixableDiagnosticIds.Any())
             .SelectMany(fixer => fixer.FixableDiagnosticIds.Select(id => (Id: id, Fixer: fixer)))
+            .DistinctBy(x => x.Id)
             .ToDictionary(x => x.Id, x => x.Fixer);
 
         var analyzersWithFixersById = allAnalyzers
@@ -108,20 +110,39 @@ public async Task<RecipeExecutionResult> Execute(CancellationToken cancellationT
             return new RecipeExecutionResult(SolutionFilePath, watch.Elapsed, []);
         }
 
-        var issuesBeingFixed = analyzersWithFixersById.Select(x =>
-        {
-            var diagnostic = x.Value.Analyzer.SupportedDiagnostics.First(y => y.Id == x.Key);
-            return $"{diagnostic.Id}: {diagnostic.Title}";
-        });
-        
-        log.LogDebug("Solution {SolutionFilePath} loaded in {Elapsed}. Fixing {@Issues}", SolutionFilePath, watch.Elapsed, issuesBeingFixed);
-        
-        var issuesTypesInCodebase = (await GetDiagnostics(solution, analyzersWithFixersById, cancellationToken))
+        // var issuesBeingFixed = analyzersWithFixersById.Select(x =>
+        // {
+        //     var diagnostic = x.Value.Analyzer.SupportedDiagnostics.First(y => y.Id == x.Key);
+        //     return $"{diagnostic.Id}: {diagnostic.Title}";
+        // });
+
+        var loadedTime = watch.Elapsed;
+
+        var allDiagnostics = await GetDiagnostics(solution, analyzersWithFixersById, cancellationToken);
+        var issuesTypesInCodebase = allDiagnostics
+            .Where(x => this.DiagnosticIds.Contains(x.Id))
             .Select(x => x.Id)
             .ToHashSet();
         var analyzersWithFixersByIdForIssuesInCodebase = analyzersWithFixersById
             .Where(x => issuesTypesInCodebase.Contains(x.Key))
             .ToDictionary(x => x.Key, x => x.Value);
+        
+        log.LogDebug("Solution {SolutionFilePath} loaded in {Elapsed}", SolutionFilePath, loadedTime);
+        if (analyzersWithFixersByIdForIssuesInCodebase.Count == 0)
+        {
+            log.LogDebug("No fixable issues found in solution");
+        }
+        // else
+        // {
+        //     var issueCounts = allDiagnostics
+        //         .GroupBy(x => x.Id)
+        //         .Select(x  => new 
+        //         {
+        //             IssueId = $"{x.Key}: {x.First().Descriptor.Title}",
+        //             Occurances = x.Count()
+        //         });
+        //     log.LogDebug("Fixing {@Issues}", issueCounts);
+        // }
 
         foreach (var (issueId, (analyzer, codeFixProvider)) in analyzersWithFixersByIdForIssuesInCodebase)
         {
@@ -134,96 +155,142 @@ public async Task<RecipeExecutionResult> Execute(CancellationToken cancellationT
                 {issueId, (analyzer, codeFixProvider)}
             };
             var diagnostics = await GetDiagnostics(solution, analyzersToRun, cancellationToken);
-            var diagnosticsById = diagnostics.ToLookup(x => x.Id);
-            var diagnosticsToProcess = diagnosticsById.ToList();
-            
-            foreach (var diagnosticIssue in diagnosticsToProcess)
+            diagnostics = diagnostics
+                .Where(x => x.Id == issueId)
+                .ToList();
+            if (diagnostics.Count == 0)
             {
-                var diagnostic = diagnosticIssue.First();
-                var document = solution.Solution.GetDocument(diagnostic.Location.SourceTree) ?? throw new Exception($"Could not find document associated with {diagnostic.Id} {diagnostic.Descriptor.Title}");
-
-                var diagnosticsByDocument = diagnosticIssue
-                    .Select(x => (Diagnostic: x, Document: solution.Solution.GetDocument(x.Location.SourceTree)))
-                    .Where(x => x.Document != null)
-                    .GroupBy(x => x.Document!, x => x.Diagnostic)
-                    .Where(x => x.Key is not SourceGeneratedDocument)
-                    .ToImmutableDictionary(x => x.Key, x => x.ToImmutableArray());
+                continue;
+            }
 
+            var diagnosticsByDocument = diagnostics
+                .Select(x => (Diagnostic: x, Document: solution.Solution.GetDocument(x.Location.SourceTree)))
+                .Where(x => x.Document != null)
+                .GroupBy(x => x.Document!, x => x.Diagnostic)
+                .Where(x => x.Key is not SourceGeneratedDocument)
+                .ToImmutableDictionary(x => x.Key, x => x.ToImmutableArray());
 
+            var diagnosticProvider = new FixMultipleDiagnosticProvider(diagnosticsByDocument);
+            // var codeFixProvider = analyzersWithFixersById[diagnosticIssue.Key].Fixer;
+            var fixAllProvider = codeFixProvider.GetFixAllProvider();
 
-                var diagnosticProvider = new FixMultipleDiagnosticProvider(diagnosticsByDocument);
-                // var codeFixProvider = analyzersWithFixersById[diagnosticIssue.Key].Fixer;
-                var fixAllProvider = codeFixProvider.GetFixAllProvider() ?? throw new InvalidOperationException($"Bulk fix provider not available for {diagnosticIssue.Key}: {diagnosticIssue.First().Descriptor.Title}");
+            if (fixAllProvider == null)
+            {
+                fixAllProvider = WellKnownFixAllProviders.BatchFixer;
+                // throw new InvalidOperationException($"Bulk fix provider not available for {issueId}: {diagnostic.Descriptor.Title}");
+            }
 
-                log.LogDebug("Fixing {DiagnosticId}: '{Title}' using {TypeName} in {DocumentCount} documents ({OccurrenceCount} occurrences)",
-                    diagnosticIssue.Key,
-                    diagnosticIssue.First().Descriptor.Title,
-                    codeFixProvider.GetType().Name,
-                    diagnosticsByDocument.Keys.Count(),
-                    diagnosticsToProcess.SelectMany(x => x).Count()
-                    );
+            Diagnostic? sampledDiagnostic = null;
+            string? equivalenceKey = null;
+            // try to find first viable fixup type for this issue type
+            foreach(var diagnostic in diagnostics)
+            {
+                var document = solution.Solution.GetDocument(diagnostic.Location.SourceTree);
+                if (document == null)
+                    throw new Exception($"Could not find document associated with {diagnostic.Id} {diagnostic.Descriptor.Title}");
 
                 var actions = new List<CodeAction>();
-                var context = new CodeFixContext(document, diagnostic, (a, d) => actions.Add(a), CancellationToken.None);
-                await codeFixProvider.RegisterCodeFixesAsync(context);
-                if (actions.Count == 0)
+                
+                var context = new CodeFixContext(document!, diagnostic, (a, d) => actions.Add(a), CancellationToken.None);
+                try
                 {
-                    log.LogDebug("No code fixes found");
+                    await codeFixProvider.RegisterCodeFixesAsync(context);
+                }
+                catch (Exception)
+                {
+                    // log.LogError(e, "Code fix up for {IssueId} failed due it its own internal logic", issueId);
                     continue;
                 }
 
+
+                if (actions.Count == 0)
+                {
+                    // log.LogDebug("No fixable issues found");
+                    continue;
+                }
+                
                 var codeFixAction = actions[0];
+                
+                //codeFixAction.
                 if (!codeFixAction.NestedActions.IsEmpty)
                 {
-                    log.LogWarning("Skipping refactoring of recipe {DiagnosticId} because there's multiple variations of refactoring that can be applied", diagnosticIssue.Key);
+                    // log.LogWarning("Skipping refactoring of recipe {DiagnosticId} because there's multiple variations of refactoring that can be applied", issueId);
                     continue;
                 }
+                sampledDiagnostic = diagnostic;
+                equivalenceKey = codeFixAction.EquivalenceKey;
+                break;
+            }
 
-                var fixAllContext = new FixAllContext(
-                    diagnosticsByDocument.Keys.First(),
-                    codeFixProvider,
-                    FixAllScope.Solution,
-                    actions.First().EquivalenceKey,
-                    [diagnosticIssue.Key],
-                    diagnosticProvider,
-                    cancellationToken);
+            if (sampledDiagnostic == null)
+            {
+                // generally we end up here when an analyzer has a fixer associated with it, but fixer determined that it can't actually fix it automatically (didn't register any code actions)
+                log.LogDebug("No fixable issues found in solution");
+                break;
+            }
 
+            log.LogDebug("Fixing {DiagnosticId}: '{Title}' using {TypeName} in {DocumentCount} documents ({OccurrenceCount} occurrences)",
+                issueId,
+                sampledDiagnostic.Descriptor.Title,
+                codeFixProvider.GetType().Name,
+                diagnosticsByDocument.Keys.Count(),
+                diagnostics.Count()
+            );
+            
+            var fixAllContext = new FixAllContext(
+                diagnosticsByDocument.Keys.First(),
+                codeFixProvider,
+                FixAllScope.Solution,
+                equivalenceKey,
+                [issueId],
+                diagnosticProvider,
+                cancellationToken);
+            Solution newSolution;
+            try
+            {
                 var codeAction = await fixAllProvider.GetFixAsync(fixAllContext) ?? throw new Exception("Code action was not found");
-
+            
                 var operations = await codeAction.GetOperationsAsync(cancellationToken);
                 var applyChangesOperation = operations.OfType<ApplyChangesOperation>().First();
-                var newSolution = applyChangesOperation.ChangedSolution;
-                // var affectedDocumentIds = await GetChangedDocumentsAsync(solution.Solution, newSolution, cancellationToken);
-                // var affectedDocuments = affectedDocumentIds
-                //     .Select(docId => solution.Solution.GetDocument(docId)?.FilePath)
-                //     .Where(x => x != null)
-                //     .Select(x => ((AbsolutePath)SolutionFilePath).GetRelativePathTo((AbsolutePath)x));
-                // changedFiles.AddRange(affectedDocuments);
-                // foreach (var docId in affectedDocuments.Take(1))
-                // {
-                //     var before = (await solution.Solution.GetDocument(docId)!.GetTextAsync()).ToString();
-                //     var after = (await newSolution.GetDocument(docId)!.GetTextAsync()).ToString();
-                //
-                //     var diffs = StringDiffer.GetDifferences(before, after);
-                //     Console.WriteLine(solution.Solution.GetDocument(docId).FilePath);
-                //     Console.WriteLine("======");
-                //     Console.WriteLine(diffs);
-                // }
-                
-                solution.Solution = newSolution;
-                var affectedDocumentIds = await GetChangedDocumentsAsync(originalSolution, solution.Solution, cancellationToken);
-                var affectedDocuments = affectedDocumentIds
-                    .Select(docId => solution.Solution.GetDocument(docId)!)
-                    .ToList();
-                var issueFixResult = new IssueFixResult(
-                    IssueId: issueId, 
-                    ExecutionTime: recipeWatch.Elapsed, 
-                    Fixes: affectedDocuments
-                        .Select(x => new DocumentFixResult(x.FilePath!))
-                        .ToList());
-                fixedIssues.Add(issueFixResult);
-                recipeWatch.Stop();
+                newSolution = applyChangesOperation.ChangedSolution;
+            }
+            catch (Exception e)
+            {
+                log.LogError(e, "Unable to apply {IssueId} do to internal CodeFixup logic error", issueId);
+                continue;
             }
+            
+            // var affectedDocumentIds = await GetChangedDocumentsAsync(solution.Solution, newSolution, cancellationToken);
+            // var affectedDocuments = affectedDocumentIds
+            //     .Select(docId => solution.Solution.GetDocument(docId)?.FilePath)
+            //     .Where(x => x != null)
+            //     .Select(x => ((AbsolutePath)SolutionFilePath).GetRelativePathTo((AbsolutePath)x));
+            // changedFiles.AddRange(affectedDocuments);
+            // foreach (var docId in affectedDocuments.Take(1))
+            // {
+            //     var before = (await solution.Solution.GetDocument(docId)!.GetTextAsync()).ToString();
+            //     var after = (await newSolution.GetDocument(docId)!.GetTextAsync()).ToString();
+            //
+            //     var diffs = StringDiffer.GetDifferences(before, after);
+            //     Console.WriteLine(solution.Solution.GetDocument(docId).FilePath);
+            //     Console.WriteLine("======");
+            //     Console.WriteLine(diffs);
+            // }
+            
+            solution.Solution = newSolution;
+            var affectedDocumentIds = await GetChangedDocumentsAsync(originalSolution, solution.Solution, cancellationToken);
+            var affectedDocuments = affectedDocumentIds
+                .Select(x => (Document: solution.Solution.GetDocument(x.DocumentId)!, x.ChangedLineNumbers))
+                .ToList();
+            var issueFixResult = new IssueFixResult(
+                IssueId: issueId, 
+                ExecutionTime: recipeWatch.Elapsed, 
+                Fixes: affectedDocuments
+                    .Select(x => new DocumentFixResult(x.Document.FilePath!, x.ChangedLineNumbers))
+                    .ToList());
+            fixedIssues.Add(issueFixResult);
+            recipeWatch.Stop();
+            
         }
 
         if (!DryRun)
@@ -263,12 +330,12 @@ private async Task<List<Diagnostic>> GetDiagnostics(
         return diagnostics;
     }
 
-    static async Task<IEnumerable<DocumentId>> GetChangedDocumentsAsync(
+    static async Task<IEnumerable<(DocumentId DocumentId, List<int> ChangedLineNumbers)>> GetChangedDocumentsAsync(
         Solution oldSolution,
         Solution newSolution,
         CancellationToken cancellationToken = default)
     {
-        var changedDocumentIds = new List<DocumentId>();
+        var changedDocumentIds = new List<(DocumentId, List<int> ChangedLineNumbers)>();
 
         foreach (var projectId in newSolution.ProjectIds)
         {
@@ -291,7 +358,9 @@ static async Task<IEnumerable<DocumentId>> GetChangedDocumentsAsync(
 
                 if (!oldText.ContentEquals(newText))
                 {
-                    changedDocumentIds.Add(documentId);
+                    var diffLineNumbers = DiffHelper.GetDifferentLineNumbers(oldText.ToString(), newText.ToString());
+                    changedDocumentIds.Add((documentId,diffLineNumbers));
+                    
                 }
             }
         }

Rewrite/src/Rewrite.Server/Commands/ConfigureInterceptor.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Rewrite.Diagnostics;
@@ -16,6 +17,10 @@ public void Intercept(CommandContext context, CommandSettings settings)
         Logging.ConfigureLogging(commonSettings.LogFilePath);
         builder.Logging.ClearProviders();
         builder.Logging.AddSerilog();
+        builder.Configuration
+            .AddYamlFile("appsettings.yaml")
+            .AddYamlFile($"appsettings.{builder.Environment.EnvironmentName}.yaml", optional: true)
+            .AddEnvironmentVariables();
         builder.Services.AddSingleton<RecipeManager>();
         builder.Services.AddSingleton<NuGet.Common.ILogger, NugetLogger>();
         builder.Services.AddSingleton(commonSettings);