String dictionary needs to specify StringComparer

[sokunna]

We need an analyzer to enforce any dictionary with a string key to explictly specify a StringComparer.
e.g. new Dictionary<string, Guid>(StringComparer.OrdinalIgnoreCase)

[bcollamore]

Additional details from ChatGPT:

Short answer: I can’t find an existing, popular analyzer that enforces “Dictionary<string, …> (and friends) must explicitly pass a StringComparer”. The well-known rules focus on string operations (e.g., IndexOf, Equals) and telling you to pass a StringComparison value—but they don’t cover collection constructors with string keys.

Scope you could support

If you go ahead, I’d include these “dictionary-like” types where a comparer can (or should) be provided:

Dictionary<string, T> / HashSet (constructor IEqualityComparer)
Microsoft Learn

ConcurrentDictionary<string, T> (constructor comparer overloads)

ImmutableDictionary<string, T> and its factories/builders (Create(…, IEqualityComparer), ToImmutableDictionary(…, IEqualityComparer))

SortedDictionary<string, T> / SortedSet (use IComparer, so you’d suggest StringComparer.Ordinal[IgnoreCase] cast to IComparer)

(Optionally) FrozenDictionary<string, T> (.NET 8+) which also accepts a comparer at creation.

What the rule would do

Flag object (and collection) creations where the key type is string and no comparer argument is supplied.

Also flag copy constructors/factories that copy another dictionary without passing a comparer (since they inherit whatever the source had—possibly default).

Offer a code fix to add a configurable default (e.g., StringComparer.Ordinal or OrdinalIgnoreCase)—make it .editorconfig-driven.

Here is sample code it produced, noting that it has no context of this repo:

// =============================================================
// StringKeyedComparerAnalyzer – v0.1
// Enforces that string-keyed collections explicitly specify a StringComparer/IComparer<string>.
// Supports: Dictionary<string, TValue>, HashSet<string>, ConcurrentDictionary<string, TValue>,
//           SortedDictionary<string, TValue>, SortedSet<string>, ImmutableDictionary<string, TValue> (Create/CreateRange),
//           (extensible for FrozenDictionary and LINQ ToDictionary/ToHashSet in future versions).
// =============================================================

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/StringKeyedComparerAnalyzer.csproj
// ----------------------------
/*
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <Nullable>enable</Nullable>
    <AssemblyName>StringKeyedComparerAnalyzer</AssemblyName>
    <PackageId>StringKeyedComparerAnalyzer</PackageId>
    <Version>0.1.0</Version>
    <Authors>Your Name</Authors>
    <Description>Roslyn analyzer that enforces explicit StringComparer/IComparer<string> on string-keyed collections.</Description>
    <PackageTags>roslyn analyzer dictionary string comparer</PackageTags>
    <IncludeBuildOutput>true</IncludeBuildOutput>
    <NoWarn>RS2008</NoWarn>
    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis" Version="4.10.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.10.0" PrivateAssets="all" />
    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="4.10.0" PrivateAssets="all" />
  </ItemGroup>
</Project>
*/

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/Diagnostics.cs
// ----------------------------
using System.Collections.Immutable;
using Microsoft.CodeAnalysis;

namespace StringKeyedComparerAnalyzer
{
    internal static class Diagnostics
    {
        public const string Id = "DICT001";

        public static readonly DiagnosticDescriptor MissingComparer = new(
            id: Id,
            title: "Specify a StringComparer/IComparer<string> for string-keyed collections",
            messageFormat: "{0} with a string key should explicitly specify a {1}",
            category: "Usage",
            defaultSeverity: DiagnosticSeverity.Warning,
            isEnabledByDefault: true,
            description: "String-keyed collections should explicitly specify a StringComparer (or IComparer<string> for sorted collections) to avoid culture-dependent or case-sensitivity surprises.");

        public static ImmutableArray<DiagnosticDescriptor> All => ImmutableArray.Create(MissingComparer);
    }
}

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/AnalyzerOptions.cs
// ----------------------------
using Microsoft.CodeAnalysis;

namespace StringKeyedComparerAnalyzer
{
    internal static class AnalyzerOptionsHelper
    {
        // .editorconfig:
        // dotnet_diagnostic.DICT001.preferred_string_comparer = Ordinal | OrdinalIgnoreCase | CurrentCulture | CurrentCultureIgnoreCase | InvariantCulture | InvariantCultureIgnoreCase
        private const string PreferredComparerKey = "dotnet_diagnostic.DICT001.preferred_string_comparer";

        public static string GetPreferredComparer(AnalyzerConfigOptionsProvider provider)
        {
            if (provider.GlobalOptions.TryGetValue(PreferredComparerKey, out var value) && !string.IsNullOrWhiteSpace(value))
                return value.Trim();
            return "Ordinal"; // sensible default
        }

        public static string GetComparerExpression(bool sorted, string preferred)
        {
            // StringComparer implements both IEqualityComparer<string> and IComparer<string>
            // so we can use the same expression for sorted and unsorted collections.
            return $"System.StringComparer.{preferred}";
        }
    }
}

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/WellKnownTypes.cs
// ----------------------------
using Microsoft.CodeAnalysis;

namespace StringKeyedComparerAnalyzer
{
    internal sealed class WellKnownTypes
    {
        public INamedTypeSymbol? String { get; }
        public INamedTypeSymbol? IEqualityComparer_T { get; }
        public INamedTypeSymbol? IComparer_T { get; }
        public INamedTypeSymbol? Dictionary_T2 { get; }
        public INamedTypeSymbol? HashSet_T { get; }
        public INamedTypeSymbol? ConcurrentDictionary_T2 { get; }
        public INamedTypeSymbol? SortedDictionary_T2 { get; }
        public INamedTypeSymbol? SortedSet_T { get; }
        public INamedTypeSymbol? ImmutableDictionary_T2 { get; }
        public INamespaceSymbol? ImmutableNamespace { get; }
        public INamespaceSymbol? FrozenNamespace { get; }

        private WellKnownTypes(Compilation compilation)
        {
            String = compilation.GetSpecialType(SpecialType.System_String);
            IEqualityComparer_T = compilation.GetTypeByMetadataName("System.Collections.Generic.IEqualityComparer`1");
            IComparer_T = compilation.GetTypeByMetadataName("System.Collections.Generic.IComparer`1");
            Dictionary_T2 = compilation.GetTypeByMetadataName("System.Collections.Generic.Dictionary`2");
            HashSet_T = compilation.GetTypeByMetadataName("System.Collections.Generic.HashSet`1");
            ConcurrentDictionary_T2 = compilation.GetTypeByMetadataName("System.Collections.Concurrent.ConcurrentDictionary`2");
            SortedDictionary_T2 = compilation.GetTypeByMetadataName("System.Collections.Generic.SortedDictionary`2");
            SortedSet_T = compilation.GetTypeByMetadataName("System.Collections.Generic.SortedSet`1");
            ImmutableDictionary_T2 = compilation.GetTypeByMetadataName("System.Collections.Immutable.ImmutableDictionary`2");
            ImmutableNamespace = compilation.GlobalNamespace.GetNamespaceMembers().FirstOrDefault(n => n.Name == "System")?
                .GetNamespaceMembers().FirstOrDefault(n => n.Name == "Collections")?
                .GetNamespaceMembers().FirstOrDefault(n => n.Name == "Immutable");
            FrozenNamespace = compilation.GlobalNamespace.GetNamespaceMembers().FirstOrDefault(n => n.Name == "System")?
                .GetNamespaceMembers().FirstOrDefault(n => n.Name == "Collections")?
                .GetNamespaceMembers().FirstOrDefault(n => n.Name == "Frozen");
        }

        public static WellKnownTypes Create(Compilation compilation) => new(compilation);
    }
}

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/StringKeyedComparerAnalyzer.cs
// ----------------------------
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;

namespace StringKeyedComparerAnalyzer
{
    [DiagnosticAnalyzer(LanguageNames.CSharp)]
    public sealed class StringKeyedComparerAnalyzer : DiagnosticAnalyzer
    {
        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => Diagnostics.All;

        public override void Initialize(AnalysisContext context)
        {
            context.EnableConcurrentExecution();
            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

            context.RegisterCompilationStartAction(static compilationContext =>
            {
                var wellKnown = WellKnownTypes.Create(compilationContext.Compilation);

                compilationContext.RegisterOperationAction(ctx => AnalyzeObjectCreation(ctx, wellKnown), OperationKind.ObjectCreation);
                compilationContext.RegisterOperationAction(ctx => AnalyzeInvocation(ctx, wellKnown), OperationKind.Invocation);
            });
        }

        private static void AnalyzeObjectCreation(OperationAnalysisContext context, WellKnownTypes types)
        {
            var creation = (IObjectCreationOperation)context.Operation;
            var constructed = creation.Type as INamedTypeSymbol;
            if (constructed == null)
                return;

            // Determine if this is one of the supported collection types with string key
            if (!TryGetCollectionInfo(constructed, types, out var kind, out var requiresComparerType))
                return;

            // If a comparer argument is already provided, nothing to do
            var ctor = creation.Constructor;
            if (ctor == null)
                return;

            if (HasRequiredComparerParameter(ctor, requiresComparerType, types, out _))
                return; // explicit comparer provided

            // No comparer in the selected overload → report
            var collectionDisplay = constructed.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
            var comparerDisplay = requiresComparerType == RequiredComparer.IEqualityComparer
                ? "StringComparer/IEqualityComparer<string>"
                : "StringComparer/IComparer<string>";

            context.ReportDiagnostic(Diagnostic.Create(
                Diagnostics.MissingComparer,
                creation.Syntax.GetLocation(),
                collectionDisplay,
                comparerDisplay));
        }

        private static void AnalyzeInvocation(OperationAnalysisContext context, WellKnownTypes types)
        {
            var invocation = (IInvocationOperation)context.Operation;
            var targetMethod = invocation.TargetMethod;

            // ImmutableDictionary.Create<TKey, TValue>(...) without comparer
            if (targetMethod.ContainingType.Equals(types.ImmutableDictionary_T2?.ConstructedFrom, SymbolEqualityComparer.Default))
            {
                if (targetMethod.Name is "Create" or "CreateRange")
                {
                    var typeArgs = targetMethod.TypeArguments;
                    if (typeArgs.Length == 2 && SymbolEqualityComparer.Default.Equals(typeArgs[0], types.String))
                    {
                        if (!HasRequiredComparerParameter(targetMethod, RequiredComparer.IEqualityComparer, types, out _))
                        {
                            var collectionDisplay = targetMethod.ContainingType.Construct(typeArgs.ToArray()).ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
                            context.ReportDiagnostic(Diagnostic.Create(
                                Diagnostics.MissingComparer,
                                invocation.Syntax.GetLocation(),
                                collectionDisplay,
                                "StringComparer/IEqualityComparer<string>"));
                        }
                    }
                }
            }

            // NOTE: Future: Detect FrozenDictionary.ToFrozenDictionary and LINQ ToDictionary/ToHashSet overloads.
        }

        private enum CollectionKind { DictionaryLike, HashSet, SortedDictionaryLike, SortedSet }
        private enum RequiredComparer { IEqualityComparer, IComparer }

        private static bool TryGetCollectionInfo(INamedTypeSymbol constructed, WellKnownTypes types, out CollectionKind kind, out RequiredComparer requires)
        {
            kind = default;
            requires = default;

            // HashSet<string>
            if (constructed.ConstructedFrom.Equals(types.HashSet_T, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 1 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.HashSet;
                    requires = RequiredComparer.IEqualityComparer;
                    return true;
                }
                return false;
            }

            // Dictionary<string, TValue>
            if (constructed.ConstructedFrom.Equals(types.Dictionary_T2, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 2 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.DictionaryLike;
                    requires = RequiredComparer.IEqualityComparer;
                    return true;
                }
                return false;
            }

            // ConcurrentDictionary<string, TValue>
            if (constructed.ConstructedFrom.Equals(types.ConcurrentDictionary_T2, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 2 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.DictionaryLike;
                    requires = RequiredComparer.IEqualityComparer;
                    return true;
                }
                return false;
            }

            // SortedDictionary<string, TValue>
            if (constructed.ConstructedFrom.Equals(types.SortedDictionary_T2, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 2 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.SortedDictionaryLike;
                    requires = RequiredComparer.IComparer;
                    return true;
                }
                return false;
            }

            // SortedSet<string>
            if (constructed.ConstructedFrom.Equals(types.SortedSet_T, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 1 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.SortedSet;
                    requires = RequiredComparer.IComparer;
                    return true;
                }
                return false;
            }

            // ImmutableDictionary<string, TValue>
            if (constructed.ConstructedFrom.Equals(types.ImmutableDictionary_T2, SymbolEqualityComparer.Default))
            {
                if (constructed.TypeArguments.Length == 2 && SymbolEqualityComparer.Default.Equals(constructed.TypeArguments[0], types.String))
                {
                    kind = CollectionKind.DictionaryLike;
                    requires = RequiredComparer.IEqualityComparer;
                    return true;
                }
                return false;
            }

            return false;
        }

        private static bool HasRequiredComparerParameter(IMethodSymbol method, RequiredComparer requires, WellKnownTypes types, out int comparerParamIndex)
        {
            comparerParamIndex = -1;

            foreach (var (param, index) in method.Parameters.Select((p, i) => (p, i)))
            {
                if (requires == RequiredComparer.IEqualityComparer &&
                    param.Type is INamedTypeSymbol p &&
                    p.OriginalDefinition.Equals(types.IEqualityComparer_T, SymbolEqualityComparer.Default) &&
                    p.TypeArguments.Length == 1 && SymbolEqualityComparer.Default.Equals(p.TypeArguments[0], types.String))
                {
                    comparerParamIndex = index;
                    return true;
                }

                if (requires == RequiredComparer.IComparer &&
                    param.Type is INamedTypeSymbol p2 &&
                    p2.OriginalDefinition.Equals(types.IComparer_T, SymbolEqualityComparer.Default) &&
                    p2.TypeArguments.Length == 1 && SymbolEqualityComparer.Default.Equals(p2.TypeArguments[0], types.String))
                {
                    comparerParamIndex = index;
                    return true;
                }
            }

            return false;
        }
    }
}

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/StringKeyedComparerCodeFixProvider.cs
// ----------------------------
using System.Collections.Immutable;
using System.Composition;
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.CodeAnalysis.Operations;
using System.Threading.Tasks;

namespace StringKeyedComparerAnalyzer
{
    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(StringKeyedComparerCodeFixProvider)), Shared]
    public sealed class StringKeyedComparerCodeFixProvider : CodeFixProvider
    {
        public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(Diagnostics.Id);

        public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
            if (root is null)
                return;

            var diagnostic = context.Diagnostics.First();
            var node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
            if (node is null)
                return;

            var model = await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
            if (model is null)
                return;

            var options = await context.Document.GetAnalyzerConfigOptionsAsync(context.CancellationToken).ConfigureAwait(false);
            var preferred = AnalyzerOptionsHelper.GetPreferredComparer(options);

            // Try object creation first
            if (node.FirstAncestorOrSelf<ObjectCreationExpressionSyntax>() is { } objCreation)
            {
                context.RegisterCodeFix(
                    Microsoft.CodeAnalysis.CodeActions.CodeAction.Create(
                        title: $"Add StringComparer.{preferred}",
                        createChangedDocument: ct => AddComparerToObjectCreationAsync(context.Document, objCreation, preferred, ct),
                        equivalenceKey: "AddStringComparer"),
                    diagnostic);
                return;
            }

            // Try invocation (e.g., ImmutableDictionary.Create)
            if (node.FirstAncestorOrSelf<InvocationExpressionSyntax>() is { } invocation)
            {
                context.RegisterCodeFix(
                    Microsoft.CodeAnalysis.CodeActions.CodeAction.Create(
                        title: $"Pass StringComparer.{preferred}",
                        createChangedDocument: ct => AddComparerToInvocationAsync(context.Document, invocation, preferred, ct),
                        equivalenceKey: "AddStringComparerInvocation"),
                    diagnostic);
                return;
            }
        }

        private static async Task<Document> AddComparerToObjectCreationAsync(Document document, ObjectCreationExpressionSyntax creation, string preferred, System.Threading.CancellationToken ct)
        {
            var editor = await DocumentEditor.CreateAsync(document, ct).ConfigureAwait(false);

            var comparerExpr = SyntaxFactory.ParseExpression(AnalyzerOptionsHelper.GetComparerExpression(sorted: false, preferred));

            ArgumentSyntax comparerArg = SyntaxFactory.Argument(comparerExpr);
            var newCreation = creation.WithArgumentList(
                (creation.ArgumentList ?? SyntaxFactory.ArgumentList()).AddArguments(comparerArg));

            editor.ReplaceNode(creation, newCreation);
            return editor.GetChangedDocument();
        }

        private static async Task<Document> AddComparerToInvocationAsync(Document document, InvocationExpressionSyntax invocation, string preferred, System.Threading.CancellationToken ct)
        {
            var editor = await DocumentEditor.CreateAsync(document, ct).ConfigureAwait(false);

            var comparerExpr = SyntaxFactory.ParseExpression(AnalyzerOptionsHelper.GetComparerExpression(sorted: false, preferred));
            ArgumentSyntax comparerArg = SyntaxFactory.Argument(comparerExpr);

            var newInvocation = invocation.WithArgumentList(
                (invocation.ArgumentList ?? SyntaxFactory.ArgumentList()).AddArguments(comparerArg));

            editor.ReplaceNode(invocation, newInvocation);
            return editor.GetChangedDocument();
        }
    }
}

// ----------------------------
// File: src/StringKeyedComparerAnalyzer/README.md
// ----------------------------
/*
# StringKeyedComparerAnalyzer

**Rule DICT001**: For string-keyed collections, require an explicit comparer.

### Supported types
- Dictionary<string, TValue>
- HashSet<string>
- ConcurrentDictionary<string, TValue>
- SortedDictionary<string, TValue> (uses IComparer<string>)
- SortedSet<string> (uses IComparer<string>)
- ImmutableDictionary<string, TValue> (Create/CreateRange)

> Roadmap: FrozenDictionary, LINQ ToDictionary/ToHashSet, Immutable* builder/factory overloads.

### Configuration (.editorconfig)
```ini
# Severity (optional)
dotnet_diagnostic.DICT001.severity = warning

# Preferred comparer for code fix (Ordinal | OrdinalIgnoreCase | CurrentCulture | CurrentCultureIgnoreCase | InvariantCulture | InvariantCultureIgnoreCase)
dotnet_diagnostic.DICT001.preferred_string_comparer = Ordinal

Examples

// ❌ Diagnostic (no comparer supplied)
var d = new Dictionary<string, Guid>();

// ✅ OK
var d2 = new Dictionary<string, Guid>(StringComparer.OrdinalIgnoreCase);

// ❌ Diagnostic
var set = new HashSet<string>();

// ✅ OK
var set2 = new HashSet<string>(StringComparer.Ordinal);

// ❌ Diagnostic
var sd = new SortedDictionary<string, int>();

// ✅ OK (StringComparer implements IComparer<string>)
var sd2 = new SortedDictionary<string, int>(StringComparer.Ordinal);

// ImmutableDictionary
// ❌ Diagnostic
var im = System.Collections.Immutable.ImmutableDictionary.Create<string, int>();

// ✅ OK
var im2 = System.Collections.Immutable.ImmutableDictionary.Create<string, int>(StringComparer.Ordinal);

Notes

• The code fix uses fully-qualified System.StringComparer.* to avoid requiring using System;.
• Copy constructors without comparer (e.g., new Dictionary<string, T>(other)) will be flagged; prefer the overload taking a comparer, or ensure other.Comparer is acceptable and pass it explicitly.
  */