Implement Use 'StartsWith' instead of 'IndexOf' analyzer

src/NetAnalyzers/CSharp/Microsoft.NetCore.Analyzers/Performance/CSharpUseStartsWithInsteadOfIndexOfComparisonWithZero.Fixer.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Composition;
+using Analyzer.Utilities;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.NetCore.Analyzers.Performance;
+
+namespace Microsoft.NetCore.CSharp.Analyzers.Performance
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    public sealed class CSharpUseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFix : UseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFix
+    {
+        protected override SyntaxNode AppendElasticMarker(SyntaxNode replacement)
+            => replacement.WithTrailingTrivia(SyntaxFactory.ElasticMarker);
+
+        protected override SyntaxNode HandleCharStringComparisonOverload(SyntaxGenerator generator, SyntaxNode instance, SyntaxNode[] arguments, bool shouldNegate)
+        {
+            // For 'x.IndexOf(ch, stringComparison)', we switch to 'x.AsSpan().StartsWith(stackalloc char[1] { ch }, stringComparison)'
+            var (argumentSyntax, index) = GetCharacterArgumentAndIndex(arguments);
+            arguments[index] = argumentSyntax.WithExpression(SyntaxFactory.StackAllocArrayCreationExpression(
+                SyntaxFactory.ArrayType(
+                    (TypeSyntax)generator.TypeExpression(SpecialType.System_Char),
+                    SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList((ExpressionSyntax)generator.LiteralExpression(1))))),
+                SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, SyntaxFactory.SingletonSeparatedList(argumentSyntax.Expression))
+                ));
+            instance = generator.InvocationExpression(generator.MemberAccessExpression(instance, "AsSpan")).WithAdditionalAnnotations(new SyntaxAnnotation("SymbolId", "System.MemoryExtensions")).WithAddImportsAnnotation();
+            return CreateStartsWithInvocationFromArguments(generator, instance, arguments, shouldNegate);
+        }
+
+        private static (ArgumentSyntax Argument, int Index) GetCharacterArgumentAndIndex(SyntaxNode[] arguments)
+        {
+            var firstArgument = (ArgumentSyntax)arguments[0];
+            if (firstArgument.NameColon is null or { Name.Identifier.Value: "value" })
+            {
+                return (firstArgument, 0);
+            }
+
+            return ((ArgumentSyntax)arguments[1], 1);
+        }
+    }
+}

src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md

@@ -10,6 +10,7 @@ CA1512 | Maintainability | Info | UseExceptionThrowHelpers, [Documentation](http
 CA1513 | Maintainability | Info | UseExceptionThrowHelpers, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1513)
 CA1856 | Performance | Error | ConstantExpectedAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1856)
 CA1857 | Performance | Warning | ConstantExpectedAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1857)
+CA1858 | Performance | Info | UseStartsWithInsteadOfIndexOfComparisonWithZero, [Documentation](https://docs.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1858)
 
 ### Removed Rules
 

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

@@ -2031,6 +2031,15 @@
   <data name="PreventNumericIntPtrUIntPtrBehavioralChangesConversionThrowsMessage" xml:space="preserve">
     <value>Starting with .NET 7 the explicit conversion '{0}' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.</value>
   </data>
+  <data name="UseStartsWithInsteadOfIndexOfComparisonWithZeroDescription" xml:space="preserve">
+    <value>It is both clearer and likely faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero.</value>
+  </data>
+  <data name="UseStartsWithInsteadOfIndexOfComparisonWithZeroMessage" xml:space="preserve">
+    <value>Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0</value>
+  </data>
+  <data name="UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle" xml:space="preserve">
+    <value>Use 'StartsWith'</value>
+  </data>
   <data name="UseArgumentNullExceptionThrowHelperTitle" xml:space="preserve">
     <value>Use ArgumentNullException throw helper</value>
   </data>
@@ -2052,5 +2061,4 @@
   <data name="UseThrowHelperFix" xml:space="preserve">
     <value>Use '{0}.{1}'</value>
   </data>
-
 </root>

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Performance/UseStartsWithInsteadOfIndexOfComparisonWithZero.Fixer.cs

@@ -0,0 +1,102 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Editing;
+
+namespace Microsoft.NetCore.Analyzers.Performance
+{
+    public abstract class UseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFix : CodeFixProvider
+    {
+        public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(UseStartsWithInsteadOfIndexOfComparisonWithZero.RuleId);
+
+        public override FixAllProvider GetFixAllProvider()
+            => WellKnownFixAllProviders.BatchFixer;
+
+        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var document = context.Document;
+            var diagnostic = context.Diagnostics[0];
+            var root = await document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var node = root.FindNode(context.Span, getInnermostNodeForTie: true);
+
+            context.RegisterCodeFix(
+                CodeAction.Create(MicrosoftNetCoreAnalyzersResources.UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle,
+                createChangedDocument: async cancellationToken =>
+                {
+                    var instance = root.FindNode(diagnostic.AdditionalLocations[0].SourceSpan);
+                    var arguments = new SyntaxNode[diagnostic.AdditionalLocations.Count - 1];
+                    for (int i = 1; i < diagnostic.AdditionalLocations.Count; i++)
+                    {
+                        arguments[i - 1] = root.FindNode(diagnostic.AdditionalLocations[i].SourceSpan);
+                    }
+
+                    var generator = SyntaxGenerator.GetGenerator(document);
+                    var shouldNegate = diagnostic.Properties.TryGetValue(UseStartsWithInsteadOfIndexOfComparisonWithZero.ShouldNegateKey, out _);
+
+                    _ = diagnostic.Properties.TryGetValue(UseStartsWithInsteadOfIndexOfComparisonWithZero.ExistingOverloadKey, out var overloadValue);
+                    switch (overloadValue)
+                    {
+                        // For 'IndexOf(string)' and 'IndexOf(string, stringComparison)', we replace with StartsWith(same arguments)
+                        case UseStartsWithInsteadOfIndexOfComparisonWithZero.OverloadString:
+                        case UseStartsWithInsteadOfIndexOfComparisonWithZero.OverloadString_StringComparison:
+                            return document.WithSyntaxRoot(root.ReplaceNode(node, CreateStartsWithInvocationFromArguments(generator, instance, arguments, shouldNegate)));
+
+                        // For 'a.IndexOf(ch, stringComparison)':
+                        // C#: Use 'a.AsSpan().StartsWith(stackalloc char[1] { ch }, stringComparison)'
+                        // https://learn.microsoft.com/dotnet/api/system.memoryextensions.startswith?view=net-7.0#system-memoryextensions-startswith(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-stringcomparison)
+                        // VB: Use a.StartsWith(c.ToString(), stringComparison)
+                        case UseStartsWithInsteadOfIndexOfComparisonWithZero.OverloadChar_StringComparison:
+                            return document.WithSyntaxRoot(root.ReplaceNode(node, HandleCharStringComparisonOverload(generator, instance, arguments, shouldNegate)));
+
+                        // If 'StartsWith(char)' is available, use it. Otherwise check '.Length > 0 && [0] == ch'
+                        // For negation, we use '.Length == 0 || [0] != ch'
+                        case UseStartsWithInsteadOfIndexOfComparisonWithZero.OverloadChar:
+                            var semanticModel = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+                            var startsWithSymbols = semanticModel.Compilation.GetSpecialType(SpecialType.System_String).GetMembers("StartsWith");
+                            if (startsWithSymbols.Any(s => s is IMethodSymbol { Parameters: [{ Type.SpecialType: SpecialType.System_Char }] }))
+                            {
+                                return document.WithSyntaxRoot(root.ReplaceNode(node, CreateStartsWithInvocationFromArguments(generator, instance, arguments, shouldNegate)));
+                            }
+
+                            var lengthAccess = generator.MemberAccessExpression(instance, "Length");
+                            var zeroLiteral = generator.LiteralExpression(0);
+
+                            var indexed = generator.ElementAccessExpression(instance, zeroLiteral);
+                            var ch = root.FindNode(arguments[0].Span, getInnermostNodeForTie: true);
+
+                            var replacement = shouldNegate
+                                ? generator.LogicalOrExpression(
+                                    generator.ValueEqualsExpression(lengthAccess, zeroLiteral),
+                                    generator.ValueNotEqualsExpression(indexed, ch))
+                                : generator.LogicalAndExpression(
+                                    generator.GreaterThanExpression(lengthAccess, zeroLiteral),
+                                    generator.ValueEqualsExpression(indexed, ch));
+
+                            return document.WithSyntaxRoot(root.ReplaceNode(node, AppendElasticMarker(replacement)));
+
+                        default:
+                            Debug.Fail("This should never happen.");
+                            return document;
+                    }
+
+                },
+                equivalenceKey: nameof(MicrosoftNetCoreAnalyzersResources.UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle)),
+                context.Diagnostics);
+        }
+
+        protected abstract SyntaxNode HandleCharStringComparisonOverload(SyntaxGenerator generator, SyntaxNode instance, SyntaxNode[] arguments, bool shouldNegate);
+        protected abstract SyntaxNode AppendElasticMarker(SyntaxNode replacement);
+
+        protected static SyntaxNode CreateStartsWithInvocationFromArguments(SyntaxGenerator generator, SyntaxNode instance, SyntaxNode[] arguments, bool shouldNegate)
+        {
+            var expression = generator.InvocationExpression(generator.MemberAccessExpression(instance, "StartsWith"), arguments);
+            return shouldNegate ? generator.LogicalNotExpression(expression) : expression;
+        }
+    }
+}

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Performance/UseStartsWithInsteadOfIndexOfComparisonWithZero.cs

@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using Analyzer.Utilities;
+using Analyzer.Utilities.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Microsoft.NetCore.Analyzers.Performance
+{
+    using static MicrosoftNetCoreAnalyzersResources;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]
+    public sealed class UseStartsWithInsteadOfIndexOfComparisonWithZero : DiagnosticAnalyzer
+    {
+        internal const string RuleId = "CA1858";
+        internal const string ShouldNegateKey = "ShouldNegate";
+
+        internal const string ExistingOverloadKey = "ExistingOverload";
+
+        internal const string OverloadString = "String";
+        internal const string OverloadString_StringComparison = "String,StringComparison";
+        internal const string OverloadChar = "Char";
+        internal const string OverloadChar_StringComparison = "Char,StringComparison";
+
+        internal static readonly DiagnosticDescriptor Rule = DiagnosticDescriptorHelper.Create(
+            id: "CA1858",
+            title: CreateLocalizableResourceString(nameof(UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle)),
+            messageFormat: CreateLocalizableResourceString(nameof(UseStartsWithInsteadOfIndexOfComparisonWithZeroMessage)),
+            category: DiagnosticCategory.Performance,
+            ruleLevel: RuleLevel.IdeSuggestion,
+            description: CreateLocalizableResourceString(nameof(UseStartsWithInsteadOfIndexOfComparisonWithZeroDescription)),
+            isPortedFxCopRule: false,
+            isDataflowRule: false
+            );
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+            context.RegisterCompilationStartAction(context =>
+            {
+                var stringType = context.Compilation.GetSpecialType(SpecialType.System_String);
+                if (stringType.GetMembers("StartsWith").FirstOrDefault() is not IMethodSymbol)
+                {
+                    return;
+                }
+
+                var indexOf = stringType.GetMembers("IndexOf").OfType<IMethodSymbol>();
+                var indexOfMethodsBuilder = ImmutableArray.CreateBuilder<(IMethodSymbol IndexOfSymbol, string OverloadPropertyValue)>();
+                AddIfNotNull((indexOf.SingleOrDefault(s => s.Parameters is [{ Type.SpecialType: SpecialType.System_String }]), OverloadString));
+                AddIfNotNull((indexOf.SingleOrDefault(s => s.Parameters is [{ Type.SpecialType: SpecialType.System_Char }]), OverloadChar));
+                AddIfNotNull((indexOf.SingleOrDefault(s => s.Parameters is [{ Type.SpecialType: SpecialType.System_String }, { Name: "comparisonType" }]), OverloadString_StringComparison));
+                AddIfNotNull((indexOf.SingleOrDefault(s => s.Parameters is [{ Type.SpecialType: SpecialType.System_Char }, { Name: "comparisonType" }]), OverloadChar_StringComparison));
+                if (indexOfMethodsBuilder.Count == 0)
+                {
+                    return;
+                }
+
+                var indexOfMethods = indexOfMethodsBuilder.ToImmutable();
+
+                context.RegisterOperationAction(context =>
+                {
+                    var binaryOperation = (IBinaryOperation)context.Operation;
+                    if (binaryOperation.OperatorKind is not (BinaryOperatorKind.Equals or BinaryOperatorKind.NotEquals))
+                    {
+                        return;
+                    }
+
+                    if (IsIndexOfComparedWithZero(binaryOperation.LeftOperand, binaryOperation.RightOperand, indexOfMethods, out var additionalLocations, out var properties) ||
+                        IsIndexOfComparedWithZero(binaryOperation.RightOperand, binaryOperation.LeftOperand, indexOfMethods, out additionalLocations, out properties))
+                    {
+                        if (binaryOperation.OperatorKind == BinaryOperatorKind.NotEquals)
+                        {
+                            properties = properties.Add(ShouldNegateKey, "");
+                        }
+
+                        context.ReportDiagnostic(binaryOperation.CreateDiagnostic(Rule, additionalLocations, properties));
+                    }
+
+                }, OperationKind.Binary);
+
+                void AddIfNotNull((IMethodSymbol? Symbol, string OverloadPropertyValue) item)
+                {
+                    if (item.Symbol is not null)
+                    {
+                        indexOfMethodsBuilder.Add((item.Symbol, item.OverloadPropertyValue));
+                    }
+                }
+            });
+        }
+
+        private static bool IsIndexOfComparedWithZero(
+            IOperation left, IOperation right,
+            ImmutableArray<(IMethodSymbol Symbol, string OverloadPropertyValue)> indexOfMethods,
+            out ImmutableArray<Location> additionalLocations,
+            out ImmutableDictionary<string, string?> properties)
+        {
+            properties = ImmutableDictionary<string, string?>.Empty;
+
+            if (right.ConstantValue is { HasValue: true, Value: 0 } &&
+                left is IInvocationOperation invocation)
+            {
+                foreach (var (indexOfMethod, overloadPropertyValue) in indexOfMethods)
+                {
+                    if (indexOfMethod.Parameters.Length == invocation.Arguments.Length && indexOfMethod.Equals(invocation.TargetMethod, SymbolEqualityComparer.Default))
+                    {
+                        var locationsBuilder = ImmutableArray.CreateBuilder<Location>();
+                        locationsBuilder.Add(invocation.Instance.Syntax.GetLocation());
+                        locationsBuilder.AddRange(invocation.Arguments.Select(arg => arg.Syntax.GetLocation()));
+                        additionalLocations = locationsBuilder.ToImmutable();
+
+                        properties = properties.Add(ExistingOverloadKey, overloadPropertyValue);
+                        return true;
+                    }
+                }
+            }
+
+            additionalLocations = ImmutableArray<Location>.Empty;
+            return false;
+        }
+    }
+}

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf

@@ -3007,6 +3007,21 @@
         <target state="translated">Preferovat možnost Vymazat před možností Fill</target>
         <note />
       </trans-unit>
+      <trans-unit id="UseStartsWithInsteadOfIndexOfComparisonWithZeroDescription">
+        <source>It is both clearer and likely faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero.</source>
+        <target state="new">It is both clearer and likely faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="UseStartsWithInsteadOfIndexOfComparisonWithZeroMessage">
+        <source>Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0</source>
+        <target state="new">Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle">
+        <source>Use 'StartsWith'</source>
+        <target state="new">Use 'StartsWith'</target>
+        <note />
+      </trans-unit>
       <trans-unit id="UseStringEqualsOverStringCompareCodeFixTitle">
         <source>Use 'string.Equals'</source>
         <target state="translated">Použít string.Equals</target>