Analyzer and fixer that recommend case insensitive string comparison

src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md

@@ -14,6 +14,7 @@ CA1858 | Performance | Info | UseStartsWithInsteadOfIndexOfComparisonWithZero, [
 CA1859 | Performance | Info | UseConcreteTypeAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1859)
 CA1860 | Performance | Info | PreferLengthCountIsEmptyOverAnyAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1860)
 CA1861 | Performance | Info | AvoidConstArrays, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1861)
+CA1862 | Performance | Info | RecommendCaseInsensitiveStringComparison, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca1862)
 CA2021 | Reliability | Warning | DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca2021)
 
 ### Removed Rules

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

@@ -2054,4 +2054,22 @@ Widening and user defined conversions are not supported with generic types.</val
   <data name="PreferIsEmptyOverAnyMessage" xml:space="preserve">
     <value>Prefer an 'IsEmpty' check rather than using 'Any()', both for clarity and for performance</value>
   </data>
+  <data name="RecommendCaseInsensitiveStringComparerTitle" xml:space="preserve">
+    <value>Prefer using 'StringComparer' to perform case-insensitive string comparisons</value>
+  </data>
+  <data name="RecommendCaseInsensitiveStringComparerDescription" xml:space="preserve">
+    <value>Avoid calling 'ToLower', 'ToUpper', 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons when using 'CompareTo'. Instead, use 'StringComparer' to perform case-insensitive comparisons.</value>
+  </data>
+  <data name="RecommendCaseInsensitiveStringComparerMessage" xml:space="preserve">
+    <value>Prefer using 'StringComparer' to perform a case-insensitive comparison</value>
+  </data>
+  <data name="RecommendCaseInsensitiveStringComparisonTitle" xml:space="preserve">
+    <value>Prefer the 'StringComparison' method overloads to perform case-insensitive string comparisons</value>
+  </data>
+  <data name="RecommendCaseInsensitiveStringComparisonDescription" xml:space="preserve">
+    <value>Avoid calling 'ToLower', 'ToUpper', 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons. Instead, prefer calling the method overloads of 'Contains', 'IndexOf' and 'StartsWith' that take a 'StringComparison' enum value to perform case-insensitive comparisons.</value>
+  </data>
+  <data name="RecommendCaseInsensitiveStringComparisonMessage" xml:space="preserve">
+    <value>Prefer the string comparison method overload of '{0}' that takes a 'StringComparison' enum value to perform a case-insensitive comparison</value>
+  </data>
 </root>

src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/Performance/RecommendCaseInsensitiveStringComparison.Analyzer.cs

@@ -0,0 +1,205 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+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;
+
+    /// <summary>
+    /// CA1862: Prefer the StringComparison method overloads to perform case-insensitive string comparisons.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]
+    public sealed class RecommendCaseInsensitiveStringComparisonAnalyzer : DiagnosticAnalyzer
+    {
+        internal const string RuleId = "CA1862";
+
+        internal const string StringComparisonInvariantCultureIgnoreCaseName = "InvariantCultureIgnoreCase";
+        internal const string StringComparisonCurrentCultureIgnoreCaseName = "CurrentCultureIgnoreCase";
+        internal const string StringToLowerMethodName = "ToLower";
+        internal const string StringToUpperMethodName = "ToUpper";
+        internal const string StringToLowerInvariantMethodName = "ToLowerInvariant";
+        internal const string StringToUpperInvariantMethodName = "ToUpperInvariant";
+        internal const string StringContainsMethodName = "Contains";
+        internal const string StringIndexOfMethodName = "IndexOf";
+        internal const string StringStartsWithMethodName = "StartsWith";
+        internal const string StringCompareToMethodName = "CompareTo";
+
+        private static readonly LocalizableString s_localizableStringComparisonTitle = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparisonTitle));
+        private static readonly LocalizableString s_localizableStringComparisonMessage = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparisonMessage));
+        private static readonly LocalizableString s_localizableStringComparisonDescription = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparisonDescription));
+
+        private static readonly LocalizableString s_localizableStringComparerTitle = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparerTitle));
+        private static readonly LocalizableString s_localizableStringComparerMessage = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparerMessage));
+        private static readonly LocalizableString s_localizableStringComparerDescription = CreateLocalizableResourceString(nameof(RecommendCaseInsensitiveStringComparerDescription));
+
+        internal static readonly DiagnosticDescriptor RecommendCaseInsensitiveStringComparisonRule = DiagnosticDescriptorHelper.Create(
+            RuleId,
+            s_localizableStringComparisonTitle,
+            s_localizableStringComparisonMessage,
+            DiagnosticCategory.Performance,
+            RuleLevel.IdeSuggestion,
+            s_localizableStringComparisonDescription,
+            isPortedFxCopRule: false,
+            isDataflowRule: false);
+
+        internal static readonly DiagnosticDescriptor RecommendCaseInsensitiveStringComparerRule = DiagnosticDescriptorHelper.Create(
+            RuleId,
+            s_localizableStringComparerTitle,
+            s_localizableStringComparerMessage,
+            DiagnosticCategory.Performance,
+            RuleLevel.IdeSuggestion,
+            s_localizableStringComparerDescription,
+            isPortedFxCopRule: false,
+            isDataflowRule: false);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
+            RecommendCaseInsensitiveStringComparisonRule, RecommendCaseInsensitiveStringComparerRule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.RegisterCompilationStartAction(AnalyzeCompilationStart);
+        }
+
+        private void AnalyzeCompilationStart(CompilationStartAnalysisContext context)
+        {
+            // Retrieve the essential types: string, StringComparison, StringComparer
+
+            if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemString, out INamedTypeSymbol? stringType))
+            {
+                return;
+            }
+
+            if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemStringComparison, out INamedTypeSymbol? stringComparisonType))
+            {
+                return;
+            }
+
+            if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemStringComparer, out INamedTypeSymbol? stringComparerType))
+            {
+                return;
+            }
+
+            // Retrieve the offending parameterless methods: ToLower, ToLowerInvariant, ToUpper, ToUpperInvariant
+
+            IMethodSymbol? toLowerParameterlessMethod = stringType.GetMembers(StringToLowerMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos();
+            if (toLowerParameterlessMethod == null)
+            {
+                return;
+            }
+
+            IMethodSymbol? toLowerInvariantParameterlessMethod = stringType.GetMembers(StringToLowerInvariantMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos();
+            if (toLowerInvariantParameterlessMethod == null)
+            {
+                return;
+            }
+
+            IMethodSymbol? toUpperParameterlessMethod = stringType.GetMembers(StringToUpperMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos();
+            if (toUpperParameterlessMethod == null)
+            {
+                return;
+            }
+
+            IMethodSymbol? toUpperInvariantParameterlessMethod = stringType.GetMembers(StringToUpperInvariantMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos();
+            if (toUpperInvariantParameterlessMethod == null)
+            {
+                return;
+            }
+
+            // Retrieve the diagnosable string overload methods: Contains, IndexOf, StartsWith, CompareTo
+
+            ParameterInfo[] stringParameter = new[]
+            {
+                ParameterInfo.GetParameterInfo(stringType)
+            };
+
+            IMethodSymbol? containsStringMethod = stringType.GetMembers(StringContainsMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos(stringParameter);
+            if (containsStringMethod == null)
+            {
+                return;
+            }
+
+            // TODO: There are more overloads that take StringComparison, diagnose only the simple one for now
+            IMethodSymbol? indexOfStringMethod = stringType.GetMembers(StringIndexOfMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos(stringParameter);
+            if (indexOfStringMethod == null)
+            {
+                return;
+            }
+
+            IMethodSymbol? startsWithStringMethod = stringType.GetMembers(StringStartsWithMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos(stringParameter);
+            if (startsWithStringMethod == null)
+            {
+                return;
+            }
+
+            IMethodSymbol? compareToStringMethod = stringType.GetMembers(StringCompareToMethodName).OfType<IMethodSymbol>().GetFirstOrDefaultMemberWithParameterInfos(stringParameter);
+            if (compareToStringMethod == null)
+            {
+                return;
+            }
+
+            // Retrieve the StringComparer properties that need to be flagged: CurrentCultureIgnoreCase, InvariantCultureIgnoreCase
+
+            IEnumerable<IPropertySymbol> ccicPropertyGroup = stringComparerType.GetMembers(StringComparisonCurrentCultureIgnoreCaseName).OfType<IPropertySymbol>();
+            if (!ccicPropertyGroup.Any())
+            {
+                return;
+            }
+
+            IEnumerable<IPropertySymbol> icicPropertyGroup = stringComparerType.GetMembers(StringComparisonInvariantCultureIgnoreCaseName).OfType<IPropertySymbol>();
+            if (!icicPropertyGroup.Any())
+            {
+                return;
+            }
+
+            context.RegisterOperationAction(context =>
+            {
+                IInvocationOperation caseChangingInvocation = (IInvocationOperation)context.Operation;
+                IMethodSymbol caseChangingMethod = caseChangingInvocation.TargetMethod;
+
+                if (!caseChangingMethod.Equals(toLowerParameterlessMethod) &&
+                    !caseChangingMethod.Equals(toLowerInvariantParameterlessMethod) &&
+                    !caseChangingMethod.Equals(toUpperParameterlessMethod) &&
+                    !caseChangingMethod.Equals(toUpperInvariantParameterlessMethod))
+                {
+                    return;
+                }
+
+                if (caseChangingInvocation.Parent is not IInvocationOperation diagnosableInvocation)
+                {
+                    return;
+                }
+
+                var diagnosableMethod = diagnosableInvocation.TargetMethod;
+
+                DiagnosticDescriptor rule;
+                if (diagnosableMethod.Equals(containsStringMethod) ||
+                    diagnosableMethod.Equals(indexOfStringMethod) ||
+                    diagnosableMethod.Equals(startsWithStringMethod))
+                {
+                    rule = RecommendCaseInsensitiveStringComparisonRule;
+                }
+                else if (diagnosableMethod.Equals(compareToStringMethod))
+                {
+                    rule = RecommendCaseInsensitiveStringComparerRule;
+                }
+                else
+                {
+                    return;
+                }
+
+                context.ReportDiagnostic(diagnosableInvocation.CreateDiagnostic(rule, diagnosableMethod.Name));
+
+            }, OperationKind.Invocation);
+        }
+    }
+}