(3/4) Use Span-Based String Concat Analyzer and Fixer

src/NetAnalyzers/CSharp/Microsoft.NetCore.Analyzers/Runtime/CSharpUseSpanBasedStringConcat.Fixer.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.NetCore.Analyzers.Runtime;
+
+namespace Microsoft.NetCore.CSharp.Analyzers.Runtime
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp)]
+    public sealed class CSharpUseSpanBasedStringConcatFixer : UseSpanBasedStringConcatFixer
+    {
+        private protected override SyntaxNode ReplaceInvocationMethodName(SyntaxGenerator generator, SyntaxNode invocationSyntax, string newName)
+        {
+            var memberAccessSyntax = (MemberAccessExpressionSyntax)((InvocationExpressionSyntax)invocationSyntax).Expression;
+            var oldNameSyntax = memberAccessSyntax.Name;
+            var newNameSyntax = generator.IdentifierName(newName).WithTriviaFrom(oldNameSyntax);
+            return invocationSyntax.ReplaceNode(oldNameSyntax, newNameSyntax);
+        }
+
+        private protected override bool IsSystemNamespaceImported(Project project, IReadOnlyList<SyntaxNode> namespaceImports)
+        {
+            foreach (var import in namespaceImports)
+            {
+                if (import is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier: { ValueText: nameof(System) } } })
+                    return true;
+            }
+            return false;
+        }
+
+        private protected override IOperation WalkDownBuiltInImplicitConversionOnConcatOperand(IOperation operand)
+        {
+            return UseSpanBasedStringConcat.CSharpWalkDownBuiltInImplicitConversionOnConcatOperand(operand);
+        }
+
+        private protected override bool IsNamedArgument(IArgumentOperation argumentOperation)
+        {
+            return argumentOperation.Syntax is ArgumentSyntax argumentSyntax && argumentSyntax.NameColon is not null;
+        }
+    }
+}

src/NetAnalyzers/CSharp/Microsoft.NetCore.Analyzers/Runtime/CSharpUseSpanBasedStringConcat.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Microsoft.NetCore.Analyzers.Runtime;
+
+namespace Microsoft.NetCore.CSharp.Analyzers.Runtime
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public sealed class CSharpUseSpanBasedStringConcat : UseSpanBasedStringConcat
+    {
+        private protected override bool TryGetTopMostConcatOperation(IBinaryOperation binaryOperation, [NotNullWhen(true)] out IBinaryOperation? rootBinaryOperation)
+        {
+            if (!IsConcatOperation(binaryOperation))
+            {
+                rootBinaryOperation = default;
+                return false;
+            }
+
+            var current = binaryOperation;
+            while (current.Parent is IBinaryOperation parentBinaryOperation && IsConcatOperation(parentBinaryOperation))
+                current = parentBinaryOperation;
+
+            rootBinaryOperation = current;
+            return true;
+
+            static bool IsConcatOperation(IBinaryOperation operation)
+            {
+                return operation.OperatorKind == BinaryOperatorKind.Add &&
+                    operation.Type.SpecialType == SpecialType.System_String;
+            }
+        }
+
+        private protected override IOperation WalkDownBuiltInImplicitConversionOnConcatOperand(IOperation operand)
+        {
+            return CSharpWalkDownBuiltInImplicitConversionOnConcatOperand(operand);
+        }
+    }
+}

src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md

@@ -8,6 +8,7 @@ CA1840 | Performance | Info | UseEnvironmentMembers, [Documentation](https://doc
 CA1841 | Performance | Info | PreferDictionaryContainsMethods, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1841)
 CA1842 | Performance | Info | DoNotUseWhenAllOrWaitAllWithSingleArgument, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1842)
 CA1843 | Performance | Info | DoNotUseWhenAllOrWaitAllWithSingleArgument, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1843)
+CA1845 | Performance | Info | UseSpanBasedStringConcat, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1845)
 
 ### Removed Rules
 

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/MicrosoftNetCoreAnalyzersResources.resx

@@ -1534,6 +1534,18 @@
     <value>and all other platforms</value>
     <comment>This call site is reachable on: 'windows' 10.0.2000 and later, and all other platforms</comment>
   </data>
+  <data name="UseSpanBasedStringConcatDescription" xml:space="preserve">
+    <value>It is more efficient to use 'AsSpan' and 'string.Concat', instead of 'Substring' and a concatenation operator.</value>
+  </data>
+  <data name="UseSpanBasedStringConcatMessage" xml:space="preserve">
+    <value>Use span-based 'string.Concat' and 'AsSpan' instead of 'Substring'</value>
+  </data>
+  <data name="UseSpanBasedStringConcatTitle" xml:space="preserve">
+    <value>Use span-based 'string.Concat'</value>
+  </data>
+  <data name="UseSpanBasedStringConcatCodeFixTitle" xml:space="preserve">
+    <value>Use 'AsSpan' with 'string.Concat'</value>
+  </data>
   <data name="PreferDictionaryContainsKeyCodeFixTitle" xml:space="preserve">
     <value>Use 'ContainsKey'</value>
   </data>
@@ -1589,4 +1601,4 @@
   <data name="DoNotUseWhenAllWithSingleTaskFix" xml:space="preserve">
     <value>Replace 'WhenAll' call with argument</value>
   </data>
-</root>
+</root>

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/UseSpanBasedStringConcat.Fixer.cs

@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Analyzer.Utilities;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Operations;
+using Resx = Microsoft.NetCore.Analyzers.MicrosoftNetCoreAnalyzersResources;
+using RequiredSymbols = Microsoft.NetCore.Analyzers.Runtime.UseSpanBasedStringConcat.RequiredSymbols;
+
+namespace Microsoft.NetCore.Analyzers.Runtime
+{
+    public abstract class UseSpanBasedStringConcatFixer : CodeFixProvider
+    {
+        private protected const string AsSpanName = nameof(MemoryExtensions.AsSpan);
+        private protected const string AsSpanStartParameterName = "start";
+        private protected const string ToStringName = nameof(ToString);
+
+        private protected abstract SyntaxNode ReplaceInvocationMethodName(SyntaxGenerator generator, SyntaxNode invocationSyntax, string newName);
+
+        private protected abstract bool IsSystemNamespaceImported(Project project, IReadOnlyList<SyntaxNode> namespaceImports);
+
+        private protected abstract IOperation WalkDownBuiltInImplicitConversionOnConcatOperand(IOperation operand);
+
+        private protected abstract bool IsNamedArgument(IArgumentOperation argumentOperation);
+
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(UseSpanBasedStringConcat.RuleId);
+
+        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var document = context.Document;
+            var diagnostic = context.Diagnostics.First();
+            var cancellationToken = context.CancellationToken;
+            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var compilation = model.Compilation;
+            SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+            if (!RequiredSymbols.TryGetSymbols(compilation, out var symbols))
+                return;
+            if (root.FindNode(context.Span, getInnermostNodeForTie: true) is not SyntaxNode concatExpressionSyntax)
+                return;
+
+            //  OperatorKind will be BinaryOperatorKind.Concatenate, even when '+' is used instead of '&' in Visual Basic.
+            if (model.GetOperation(concatExpressionSyntax, cancellationToken) is not IBinaryOperation concatOperation
+                || concatOperation.OperatorKind is not (BinaryOperatorKind.Add or BinaryOperatorKind.Concatenate))
+            {
+                return;
+            }
+
+            var operands = UseSpanBasedStringConcat.FlattenBinaryOperation(concatOperation);
+
+            //  Bail out if we don't have a long enough span-based string.Concat overload.
+            if (!symbols.TryGetRoscharConcatMethodWithArity(operands.Length, out IMethodSymbol? roscharConcatMethod))
+                return;
+
+            //  Bail if none of the operands are a non-conditional substring invocation. This could be the case if the
+            //  only substring invocations in the expression were conditional invocations.
+            if (!operands.Any(IsAnyNonConditionalSubstringInvocation))
+                return;
+
+            var codeAction = CodeAction.Create(
+                Resx.UseSpanBasedStringConcatCodeFixTitle,
+                FixConcatOperationChain,
+                Resx.UseSpanBasedStringConcatCodeFixTitle);
+            context.RegisterCodeFix(codeAction, diagnostic);
+
+            return;
+
+            // Local functions
+
+            bool IsAnyNonConditionalSubstringInvocation(IOperation operation)
+            {
+                var value = WalkDownBuiltInImplicitConversionOnConcatOperand(operation);
+                return value is IInvocationOperation invocation && symbols.IsAnySubstringMethod(invocation.TargetMethod);
+            }
+
+            async Task<Document> FixConcatOperationChain(CancellationToken cancellationToken)
+            {
+                RoslynDebug.Assert(roscharConcatMethod is not null);
+
+                var editor = await DocumentEditor.CreateAsync(document, cancellationToken).ConfigureAwait(false);
+                var generator = editor.Generator;
+
+                SyntaxNode stringTypeNameSyntax = generator.TypeExpressionForStaticMemberAccess(symbols.StringType);
+                SyntaxNode concatMemberAccessSyntax = generator.MemberAccessExpression(stringTypeNameSyntax, roscharConcatMethod.Name);
+
+                //  Save leading and trailing trivia so it can be attached to the outside of the string.Concat invocation node.
+                var leadingTrivia = operands.First().Syntax.GetLeadingTrivia();
+                var trailingTrivia = operands.Last().Syntax.GetTrailingTrivia();
+
+                var arguments = ImmutableArray.CreateBuilder<SyntaxNode>(operands.Length);
+                foreach (var operand in operands)
+                    arguments.Add(ConvertOperandToArgument(symbols, generator, operand));
+
+                //  Strip off leading and trailing trivia from first and last operand nodes, respectively, and
+                //  reattach it to the outside of the newly-created string.Concat invocation node.
+                arguments[0] = arguments[0].WithoutLeadingTrivia();
+                arguments[^1] = arguments[^1].WithoutTrailingTrivia();
+                SyntaxNode concatMethodInvocationSyntax = generator.InvocationExpression(concatMemberAccessSyntax, arguments.MoveToImmutable())
+                    .WithLeadingTrivia(leadingTrivia)
+                    .WithTrailingTrivia(trailingTrivia);
+
+                SyntaxNode newRoot = generator.ReplaceNode(root, concatExpressionSyntax, concatMethodInvocationSyntax);
+
+                //  Import 'System' namespace if it's absent.
+                if (!IsSystemNamespaceImported(context.Document.Project, generator.GetNamespaceImports(newRoot)))
+                {
+                    SyntaxNode systemNamespaceImport = generator.NamespaceImportDeclaration(nameof(System));
+                    newRoot = generator.AddNamespaceImports(newRoot, systemNamespaceImport);
+                }
+
+                editor.ReplaceNode(root, newRoot);
+                return editor.GetChangedDocument();
+            }
+        }
+
+        public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+        private SyntaxNode ConvertOperandToArgument(in RequiredSymbols symbols, SyntaxGenerator generator, IOperation operand)
+        {
+            var value = WalkDownBuiltInImplicitConversionOnConcatOperand(operand);
+
+            //  Convert substring invocations to equivalent AsSpan invocation.
+            if (value is IInvocationOperation invocation && symbols.IsAnySubstringMethod(invocation.TargetMethod))
+            {
+                SyntaxNode invocationSyntax = invocation.Syntax;
+
+                //  Swap out parameter names if named-arguments are used. 
+                if (TryGetNamedStartIndexArgument(symbols, invocation, out var namedStartIndexArgument))
+                {
+                    var renamedArgumentSyntax = generator.Argument(AsSpanStartParameterName, RefKind.None, namedStartIndexArgument.Value.Syntax);
+                    invocationSyntax = generator.ReplaceNode(invocationSyntax, namedStartIndexArgument.Syntax, renamedArgumentSyntax);
+                }
+                var asSpanInvocationSyntax = ReplaceInvocationMethodName(generator, invocationSyntax, AsSpanName);
+                return generator.Argument(asSpanInvocationSyntax);
+            }
+            //  Character literals become string literals.
+            else if (value.Type.SpecialType == SpecialType.System_Char && value is ILiteralOperation literalOperation && literalOperation.ConstantValue.HasValue)
+            {
+                var stringLiteral = generator.LiteralExpression(literalOperation.ConstantValue.Value.ToString()).WithTriviaFrom(literalOperation.Syntax);
+                return generator.Argument(stringLiteral);
+            }
+            else
+            {
+                return generator.Argument(value.Syntax);
+            }
+
+            bool TryGetNamedStartIndexArgument(in RequiredSymbols symbols, IInvocationOperation substringInvocation, [NotNullWhen(true)] out IArgumentOperation? namedStartIndexArgument)
+            {
+                RoslynDebug.Assert(symbols.IsAnySubstringMethod(substringInvocation.TargetMethod));
+
+                foreach (var argument in substringInvocation.Arguments)
+                {
+                    if (IsNamedArgument(argument) && symbols.IsAnySubstringStartIndexParameter(argument.Parameter))
+                    {
+                        namedStartIndexArgument = argument;
+                        return true;
+                    }
+                }
+
+                namedStartIndexArgument = default;
+                return false;
+            }
+        }
+    }
+}