(4/4) Prefer 'AsSpan' over 'Substring' analyzer

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

@@ -0,0 +1,35 @@
+// 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.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.NetCore.Analyzers.Runtime;
+
+namespace Microsoft.NetCore.CSharp.Analyzers.Runtime
+{
+ [ExportCodeFixProvider(LanguageNames.CSharp)]
+ public sealed class CSharpPreferAsSpanOverSubstringFixer : PreferAsSpanOverSubstringFixer
+ {
+ private protected override void ReplaceInvocationMethodName(SyntaxEditor editor, SyntaxNode memberInvocation, string newName)
+ {
+ var cast = (InvocationExpressionSyntax)memberInvocation;
+ var memberAccessSyntax = (MemberAccessExpressionSyntax)cast.Expression;
+ var newNameSyntax = SyntaxFactory.IdentifierName(newName);
+ editor.ReplaceNode(memberAccessSyntax.Name, newNameSyntax);
+ }
+
+ private protected override void ReplaceNamedArgumentName(SyntaxEditor editor, SyntaxNode invocation, string oldArgumentName, string newArgumentName)
+ {
+ var cast = (InvocationExpressionSyntax)invocation;
+ var oldNameSyntax = cast.ArgumentList.Arguments
+ .FirstOrDefault(x => x.NameColon is not null && x.NameColon.Name.Identifier.ValueText == oldArgumentName)?.NameColon.Name;
+ if (oldNameSyntax is null)
+ return;
+ var newNameSyntax = SyntaxFactory.IdentifierName(newArgumentName);
+ editor.ReplaceNode(oldNameSyntax, newNameSyntax);
+ }
+ }
+}

src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md

@@ -1,4 +1,8 @@
 ; Please do not edit this file manually, it should only be updated through code fix application.
+### New Rules
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+CA1842 | Performance | Info | PreferAsSpanOverSubstring, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1842)
 
 ### Removed Rules
 

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

@@ -1510,4 +1510,13 @@
  <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="PreferAsSpanOverSubstringDescription" xml:space="preserve">
+ <value>'AsSpan' accomplishes the same thing as 'Substring' without incurring the allocation and O(n) string copy.</value>
+ </data>
+ <data name="PreferAsSpanOverSubstringMessage" xml:space="preserve">
+ <value>Prefer 'AsSpan' over 'Substring' when span-based overloads are available.</value>
+ </data>
+ <data name="PreferAsSpanOverSubstringTitle" xml:space="preserve">
+ <value>Prefer 'AsSpan' over 'Substring'</value>
+ </data>
 </root>

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

@@ -0,0 +1,100 @@
+// 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.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Operations;
+using RequiredSymbols = Microsoft.NetCore.Analyzers.Runtime.PreferAsSpanOverSubstring.RequiredSymbols;
+
+namespace Microsoft.NetCore.Analyzers.Runtime
+{
+ public abstract class PreferAsSpanOverSubstringFixer : CodeFixProvider
+ {
+ private const string SubstringStartIndexArgumentName = "startIndex";
+ private const string AsSpanStartArgumentName = "start";
+
+ private protected abstract void ReplaceInvocationMethodName(SyntaxEditor editor, SyntaxNode memberInvocation, string newName);
+
+ private protected abstract void ReplaceNamedArgumentName(SyntaxEditor editor, SyntaxNode invocation, string oldArgumentName, string newArgumentName);
+
+ public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(PreferAsSpanOverSubstring.RuleId);
+
+ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+ {
+ var document = context.Document;
+ var token = context.CancellationToken;
+ SyntaxNode root = await document.GetSyntaxRootAsync(token).ConfigureAwait(false);
+ SemanticModel model = await document.GetSemanticModelAsync(token).ConfigureAwait(false);
+ var compilation = model.Compilation;
+
+ if (root.FindNode(context.Span, getInnermostNodeForTie: true) is not SyntaxNode reportedNode || model.GetOperation(reportedNode, token) is not IInvocationOperation reportedInvocation)
+ return;
+ if (!RequiredSymbols.TryGetSymbols(compilation, out RequiredSymbols symbols))
+ return;
+
+ var bestCandidates = PreferAsSpanOverSubstring.GetBestSpanBasedOverloads(symbols, reportedInvocation, context.CancellationToken);
+ // We only apply the fix if there is an unambiguous best overload.
+ if (bestCandidates.Length != 1)
+ return;
+ IMethodSymbol spanBasedOverload = bestCandidates[0];
+
+ string title = MicrosoftNetCoreAnalyzersResources.PreferAsSpanOverSubstringTitle;
+ var codeAction = CodeAction.Create(title, CreateChangedDocument, title);
+ context.RegisterCodeFix(codeAction, context.Diagnostics);
+
+ async Task<Document> CreateChangedDocument(CancellationToken token)
+ {
+ var editor = await DocumentEditor.CreateAsync(document, token).ConfigureAwait(false);
+
+ foreach (var argument in reportedInvocation.Arguments)
+ {
+ IOperation value = PreferAsSpanOverSubstring.WalkDownImplicitConversions(argument.Value);
+ IParameterSymbol newParameter = spanBasedOverload.Parameters[argument.Parameter.Ordinal];
+
+ // Convert Substring invocations to equivalent AsSpan invocations.
+ if (symbols.IsAnySubstringInvocation(value) && SymbolEqualityComparer.Default.Equals(newParameter.Type, symbols.RoscharType))
+ {
+ ReplaceInvocationMethodName(editor, value.Syntax, nameof(MemoryExtensions.AsSpan));
+ // Ensure named Substring arguments get renamed to their equivalent AsSpan counterparts.
+ ReplaceNamedArgumentName(editor, value.Syntax, SubstringStartIndexArgumentName, AsSpanStartArgumentName);
+ }
+
+ // Ensure named arguments on the original overload are renamed to their 
+ // ordinal counterparts on the new overload.
+ string oldArgumentName = argument.Parameter.Name;
+ string newArgumentName = newParameter.Name;
+ ReplaceNamedArgumentName(editor, reportedInvocation.Syntax, oldArgumentName, newArgumentName);
+ }
+
+ // Import System namespace if necessary.
+ if (!IsMemoryExtensionsInScope(symbols, reportedInvocation))
+ {
+ SyntaxNode withoutSystemImport = editor.GetChangedRoot();
+ SyntaxNode systemNamespaceImportStatement = editor.Generator.NamespaceImportDeclaration(nameof(System));
+ SyntaxNode withSystemImport = editor.Generator.AddNamespaceImports(withoutSystemImport, systemNamespaceImportStatement);
+ editor.ReplaceNode(editor.OriginalRoot, withSystemImport);
+ }
+
+ return editor.GetChangedDocument();
+ }
+ }
+
+ public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+ private static bool IsMemoryExtensionsInScope(in RequiredSymbols symbols, IInvocationOperation invocation)
+ {
+ var model = invocation.SemanticModel;
+ int position = invocation.Syntax.SpanStart;
+ const string name = nameof(MemoryExtensions);
+
+ return model.LookupNamespacesAndTypes(position, name: name)
+ .Contains(symbols.MemoryExtensionsType, SymbolEqualityComparer.Default);
+ }
+ }
+}