Fix the TypeClassParameter analyzer (#244)

- Fix GetRenamedSolution() to work on Visual Studio 2022

Author: maroontress-tomohisa

CodeFixes/Refactoring/TypeClassParameter/CodeFixer.cs

@@ -85,31 +85,32 @@ private static async Task<Solution> Replace(
     }
 
     private static async Task<Solution?> Replace2(
-        Document realDocument,
-        ParameterSyntax realNode,
+        Document document,
+        ParameterSyntax node,
         CancellationToken cancellationToken)
     {
-        var documentId = realDocument.Id;
-        var realRoot = realNode.SyntaxTree
+        var documentId = document.Id;
+        var root = node.SyntaxTree
             .GetRoot(cancellationToken);
-        var solution = realDocument.Project
-            .Solution
-            .WithDocumentSyntaxRoot(
-                documentId, realRoot.TrackNodes(realNode));
-        if (solution.GetDocument(documentId) is not {} document
-            || await document.GetSyntaxRootAsync(cancellationToken)
-                .ConfigureAwait(false) is not {} root)
+        var solution = document.Project
+            .Solution;
+        if (await document.GetSemanticModelAsync(cancellationToken)
+                .ConfigureAwait(false) is not {} model)
         {
             return null;
         }
-        var node = root.FindNode(realNode.Span);
-        if (await Documents.GetSymbols(document, node, cancellationToken)
-                .ConfigureAwait(false) is not {} symbols
+        var symbolizer = new Symbolizer(model, cancellationToken);
+        if (symbolizer.ToSymbol(node) is not {} parameterSymbol
+            || parameterSymbol.ContainingSymbol
+                is not IMethodSymbol methodSymbol
             || node.Parent is not {} parent)
         {
             return null;
         }
-        var (model, parameterSymbol, methodSymbol) = symbols;
+        /*
+            The kind of symbols to look up could be restricted to several
+            types, but for safety, it is not restricted.
+        */
         var allSymbolNameSet = new HashSet<string>(
             model.LookupSymbols(parent.SpanStart)
                 .Select(s => s.Name));
@@ -124,7 +125,7 @@ private static async Task<Solution> Replace(
             .ToList();
         return namesakes.Any()
             ? await kit.GetRenamedSolution(
-                namesakes[0], name, allSymbolNameSet, documentId, realNode)
+                namesakes[0], name, allSymbolNameSet, documentId, node)
             : await kit.GetNewSolution(parameterSymbol, methodSymbol, root);
     }
 

CodeFixes/Refactoring/TypeClassParameter/SolutionKit.cs

@@ -6,6 +6,7 @@ namespace StyleChecker.CodeFixes.Refactoring.TypeClassParameter;
 using System.Threading.Tasks;
 using Maroontress.Roastery;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.FindSymbols;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Rename;
@@ -68,8 +69,8 @@ public class SolutionKit(
     /// <param name="documentId">
     /// The document ID.
     /// </param>
-    /// <param name="realNode">
-    /// The syntax node being tracked.
+    /// <param name="node">
+    /// The parameter syntax node (of a method or a local function).
     /// </param>
     /// <returns>
     /// The renamed solution.
@@ -79,40 +80,51 @@ public class SolutionKit(
         string name,
         ISet<string> allSymbolNameSet,
         DocumentId documentId,
-        SyntaxNode realNode)
+        ParameterSyntax node)
     {
-        if (GetRenamingIndex(allSymbolNameSet, 0, name) is not {} k)
+        if (await Document.GetSemanticModelAsync(CancellationToken)
+                .ConfigureAwait(false) is not {} model)
         {
             return null;
         }
-        var options = default(SymbolRenameOptions);
-        var newSolution = await Renamer.RenameSymbolAsync(
-                Solution,
-                symbol,
-                options,
-                $"{name}_{k}",
-                CancellationToken)
-            .ConfigureAwait(false);
-        var projectId = Document.Project.Id;
-        if (newSolution.GetProject(projectId) is not {} project)
+        var symbolier = new Symbolizer(model, CancellationToken);
+        if (GetRenamingIndex(allSymbolNameSet, 0, name) is not {} k
+            || symbolier.ToSymbol(node) is not {} parameter)
         {
             return null;
         }
-        var newDocument = project.Documents
-            .Where(d => d.Id == documentId)
-            .First();
-        if (await newDocument.GetSyntaxRootAsync(CancellationToken)
-                .ConfigureAwait(false) is not {} root
-            || root.GetCurrentNode(realNode) is not {} node
-            || await Documents.GetSymbols(newDocument, node, CancellationToken)
-                .ConfigureAwait(false) is not {} symbols)
+        var options = default(SymbolRenameOptions);
+        var newName = $"{name}_{k}";
+
+        /*
+            Note:
+
+            SyntaxNode.TrackNodes() and SyntaxNode.GetCurrentNode() do not
+            always work before and after a call to Renamer.RenameSymbolAsync()
+            (especially not in Visual Studio IDE). Instead, use
+            SymbolFinder.FindSimilarSymbols() to track nodes by their
+            corresponding symbols.
+        */
+        var newSolution = await RenameSymbolAsync(
+            Solution, symbol, options, newName);
+        var projectId = Document.Project.Id;
+        if (newSolution.GetProject(projectId) is not {} newProject
+            || newProject.Documents
+                .FirstOrDefault(d => d.Id == documentId) is not {} newDocument
+            || await GetSyntaxRootAsync(newDocument) is not {} newRoot
+            || await GetCompilationAsync(newProject) is not {} newCompilation
+            || FindFirstSimilarSymbol(parameter, newCompilation)
+                is not {} newParameter
+            || newParameter.DeclaringSyntaxReferences
+                .Select(async r => await GetSyntaxAsync(r))
+                .FirstOrDefault() is not {} newNode
+            || newParameter.ContainingSymbol is not IMethodSymbol newMethod)
         {
-            return null;
+            return newSolution;
         }
         var kit = new SolutionKit(
             newSolution, newDocument, TypeName, CancellationToken);
-        return await kit.GetNewSolution(
-            symbols.Parameter, symbols.Method, root);
+        return await kit.GetNewSolution(newParameter, newMethod, newRoot);
     }
 
     /// <summary>
@@ -144,9 +156,7 @@ public class SolutionKit(
         }
         var index = parameter.Index;
 
-        var allReferences = await SymbolFinder.FindReferencesAsync(
-                methodSymbol, Solution, CancellationToken)
-            .ConfigureAwait(false);
+        var allReferences = await FindReferencesAsync(methodSymbol, Solution);
         var documentGroups = allReferences.SelectMany(r => r.Locations)
             .GroupBy(w => w.Document);
         if (DocumentUpdater.UpdateMainDocument(
@@ -197,4 +207,49 @@ public class SolutionKit(
         set.Add(id);
         return index;
     }
+
+    private async Task<Solution> RenameSymbolAsync(
+        Solution solution,
+        ISymbol symbol,
+        SymbolRenameOptions options,
+        string newName)
+    {
+        return await Renamer.RenameSymbolAsync(
+                solution, symbol, options, newName, CancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    private async Task<SyntaxNode?> GetSyntaxRootAsync(Document document)
+    {
+        return await document.GetSyntaxRootAsync(CancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    private async Task<Compilation?> GetCompilationAsync(Project project)
+    {
+        return await project.GetCompilationAsync(CancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    private T FindFirstSimilarSymbol<T>(T symbol, Compilation compilation)
+        where T : ISymbol
+    {
+        return SymbolFinder.FindSimilarSymbols(
+                symbol, compilation, CancellationToken)
+            .FirstOrDefault();
+    }
+
+    private async Task<IEnumerable<ReferencedSymbol>> FindReferencesAsync(
+        ISymbol symbol, Solution solution)
+    {
+        return await SymbolFinder.FindReferencesAsync(
+                symbol, solution, CancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    private async Task<SyntaxNode> GetSyntaxAsync(SyntaxReference reference)
+    {
+        return await reference.GetSyntaxAsync(CancellationToken)
+            .ConfigureAwait(false);
+    }
 }