Update SA1649CodeFixProvider to use method WithDocumentName in Solution if it is available #2277

Author: bjornhellander

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/DocumentationRules/SA1649CodeFixProvider.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-#nullable disable
-
 namespace StyleCop.Analyzers.DocumentationRules
 {
     using System.Collections.Immutable;
@@ -14,6 +12,7 @@ namespace StyleCop.Analyzers.DocumentationRules
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CodeFixes;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1649FileNameMustMatchTypeName"/>.
@@ -27,7 +26,7 @@ internal class SA1649CodeFixProvider : CodeFixProvider
             ImmutableArray.Create(SA1649FileNameMustMatchTypeName.DiagnosticId);
 
         /// <inheritdoc/>
-        public override FixAllProvider GetFixAllProvider()
+        public override FixAllProvider? GetFixAllProvider()
         {
             // The batch fixer can't handle code fixes that create new files
             return null;
@@ -55,25 +54,32 @@ private static async Task<Solution> GetTransformedSolutionAsync(Document documen
             var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var expectedFileName = diagnostic.Properties[SA1649FileNameMustMatchTypeName.ExpectedFileNameKey];
 
-            var newSolution = ReplaceDocument(solution, document, document.Id, syntaxRoot, expectedFileName);
+            var newSolution = RenameDocument(solution, document, document.Id, syntaxRoot, expectedFileName);
 
             // Make sure to also update other projects which reference the same file
             foreach (var linkedDocumentId in document.GetLinkedDocumentIds())
             {
-                newSolution = ReplaceDocument(newSolution, null, linkedDocumentId, syntaxRoot, expectedFileName);
+                newSolution = RenameDocument(newSolution, null, linkedDocumentId, syntaxRoot, expectedFileName);
             }
 
             return newSolution;
         }
 
-        private static Solution ReplaceDocument(Solution solution, Document document, DocumentId documentId, SyntaxNode syntaxRoot, string expectedFileName)
+        private static Solution RenameDocument(Solution solution, Document? document, DocumentId documentId, SyntaxNode syntaxRoot, string expectedFileName)
         {
-            document ??= solution.GetDocument(documentId);
+            // First try to use the "new" WithDocumentName method. This will return null if it is not available in the current Roslyn version.
+            var newSolution = solution.WithDocumentName(documentId, expectedFileName);
+            if (newSolution != null)
+            {
+                return newSolution;
+            }
 
+            // Continue by instead removing and re-adding the file again
+            document ??= solution.GetDocument(documentId);
             var newDocumentFilePath = document.FilePath != null ? Path.Combine(Path.GetDirectoryName(document.FilePath), expectedFileName) : null;
             var newDocumentId = DocumentId.CreateNewId(documentId.ProjectId);
 
-            var newSolution = solution
+            newSolution = solution
                 .RemoveDocument(documentId)
                 .AddDocument(newDocumentId, expectedFileName, syntaxRoot, document.Folders, newDocumentFilePath);
             return newSolution;

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Lightup/SolutionExtensions.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+
+    internal static class SolutionExtensions
+    {
+        private static readonly Func<Solution, DocumentId, string, Solution> WithDocumentNameAccessor;
+
+        static SolutionExtensions()
+        {
+            WithDocumentNameAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<Solution, DocumentId, string, Solution>(typeof(Solution), typeof(DocumentId), typeof(string), nameof(WithDocumentName));
+        }
+
+        public static Solution WithDocumentName(this Solution solution, DocumentId documentId, string name)
+        {
+            return WithDocumentNameAccessor(solution, documentId, name);
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs

@@ -394,6 +394,98 @@ static TProperty FallbackAccessor(TSyntax syntax, TArg argument)
             return expression.Compile();
         }
 
+        internal static Func<TSyntax, TArg1, TArg2, TProperty> CreateSyntaxPropertyAccessor<TSyntax, TArg1, TArg2, TProperty>(Type type, Type argumentType1, Type argumentType2, string accessorMethodName)
+        {
+            static TProperty FallbackAccessor(TSyntax syntax, TArg1 argument1, TArg2 argument2)
+            {
+                if (syntax == null)
+                {
+                    // Unlike an extension method which would throw ArgumentNullException here, the light-up
+                    // behavior needs to match behavior of the underlying property.
+                    throw new NullReferenceException();
+                }
+
+                return default;
+            }
+
+            if (type == null)
+            {
+                return FallbackAccessor;
+            }
+
+            if (!typeof(TSyntax).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
+            {
+                throw new InvalidOperationException();
+            }
+
+            if (!typeof(TArg1).GetTypeInfo().IsAssignableFrom(argumentType1.GetTypeInfo()))
+            {
+                throw new InvalidOperationException();
+            }
+
+            if (!typeof(TArg2).GetTypeInfo().IsAssignableFrom(argumentType2.GetTypeInfo()))
+            {
+                throw new InvalidOperationException();
+            }
+
+            var methods = type.GetTypeInfo().GetDeclaredMethods(accessorMethodName);
+            MethodInfo method = null;
+            foreach (var candidate in methods)
+            {
+                var parameters = candidate.GetParameters();
+                if (parameters.Length != 2)
+                {
+                    continue;
+                }
+
+                if (!Equals(argumentType1, parameters[0].ParameterType))
+                {
+                    continue;
+                }
+
+                if (!Equals(argumentType2, parameters[1].ParameterType))
+                {
+                    continue;
+                }
+
+                method = candidate;
+            }
+
+            if (method == null)
+            {
+                return FallbackAccessor;
+            }
+
+            if (!typeof(TProperty).GetTypeInfo().IsAssignableFrom(method.ReturnType.GetTypeInfo()))
+            {
+                throw new InvalidOperationException();
+            }
+
+            var syntaxParameter = Expression.Parameter(typeof(TSyntax), "syntax");
+            var arg1Parameter = Expression.Parameter(typeof(TArg1), "arg1");
+            var arg2Parameter = Expression.Parameter(typeof(TArg2), "arg2");
+            Expression instance =
+                type.GetTypeInfo().IsAssignableFrom(typeof(TSyntax).GetTypeInfo())
+                ? (Expression)syntaxParameter
+                : Expression.Convert(syntaxParameter, type);
+            Expression argument1 =
+                argumentType1.GetTypeInfo().IsAssignableFrom(typeof(TArg1).GetTypeInfo())
+                ? (Expression)arg1Parameter
+                : Expression.Convert(arg1Parameter, argumentType1);
+            Expression argument2 =
+                argumentType2.GetTypeInfo().IsAssignableFrom(typeof(TArg2).GetTypeInfo())
+                ? (Expression)arg2Parameter
+                : Expression.Convert(arg2Parameter, argumentType2);
+
+            Expression<Func<TSyntax, TArg1, TArg2, TProperty>> expression =
+                Expression.Lambda<Func<TSyntax, TArg1, TArg2, TProperty>>(
+                    Expression.Call(instance, method, argument1, argument2),
+                    syntaxParameter,
+                    arg1Parameter,
+                    arg2Parameter);
+            return expression.Compile();
+        }
+
         internal static TryGetValueAccessor<TSyntax, TKey, TValue> CreateTryGetValueAccessor<TSyntax, TKey, TValue>(Type type, Type keyType, string methodName)
         {
             static bool FallbackAccessor(TSyntax syntax, TKey key, out TValue value)