Add SSS007 analyzer: a Span<char>/ReadOnlySpan<char> switch-expression arm written as a _ when scrutinee.SequenceEqual("literal") guard should be the constant string pattern "literal" (matched directly since C# 11); the enforcement companion to SSS003, which creates the stackalloc-span scrutinee that invites the guard-form mistake.

Author: RyanLamansky

CLAUDE.md

@@ -85,6 +85,7 @@ Six scopes, one home each. **Add new state to whichever class matches its true s
 - **SSS004**: two or more `if`/`else if` branches with conditions of the shape `<sameScrutinee> is <SameType> { <SameProperty>: ... }` should be a single `switch`. The `switch` form fuses isinst + ldfld; the if-chain repeats both per arm.
 - **SSS005**: a `switch` (expr or statement) whose arms are all single string/numeric compile-time constants must list them sorted — strings ordinal, numbers numerically (`_`/`null` excluded). Exempts any arm that's a guard, or/relational/recursive/`var` pattern, or an **enum/`char`/`bool`** constant (those order by meaning, not value). A switch deliberately ordered by meaning (time-unit magnitude, host level, …): wrap in `#pragma warning disable SSS005` + one-line rationale rather than sorting.
 - **SSS006**: 2+ consecutive statements that each call a self-returning `StringBuilder` method (containing-type and return-type both `StringBuilder` — `Append`/`Insert`/`Replace`/… ) on the same builder and discard the result (bare or `_ =`) should be one fluent chain. An already-chained statement is peeled to its base receiver, so `sb.Append(a).Append(b)` beside `sb.Append(c)` merges. Only fires when that base is side-effect-free (identifier / `this.field` / dotted); call-valued roots exempt. Comments between the statements don't exempt — slot them between the chained calls.
+- **SSS007**: a `switch` **expression** over `Span<char>` / `ReadOnlySpan<char>` whose arm is a discard guard `_ when <governing>.SequenceEqual("literal")` should be the constant string pattern `"literal"` — a span-of-char switch matches string constants directly since C# 11 (the compiler lowers the pattern to the same comparison). Only the pure single-invocation guard whose receiver is the switch's own governing expression is flagged (negated / `&&`-combined conditions, or ones probing a different span, are left alone). This is the enforcement companion to SSS003, which puts the uppercased scrutinee on a `stackalloc Span<char>` in the first place; the `ResolveBuiltIn` keyword tables in `Parser/Expression.cs` are the reference shape.
 - **MSTEST0049**: async tests must thread `TestContext.CancellationToken`. Pattern: `public TestContext TestContext { get; set; } = null!;`.
 - **MSTEST0037**: prefer `Assert.IsEmpty(values)` over `Assert.AreEqual(0, values.Count)`; typed asserts over generic.
 

SqlServerSimulator.Analyzers.Tests/SpanCharSequenceEqualGuardAnalyzerTests.cs

@@ -0,0 +1,117 @@
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace SqlServerSimulator.Analyzers;
+
+[TestClass]
+public sealed class SpanCharSequenceEqualGuardAnalyzerTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private Task RunAsync(string source) =>
+        new CSharpAnalyzerTest<SpanCharSequenceEqualGuardAnalyzer, DefaultVerifier>
+        { TestCode = source }.RunAsync(this.TestContext.CancellationToken);
+
+    [TestMethod]
+    public Task ReadOnlySpanGuard_Reports() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s) => s switch
+                {
+                    _ when {|SSS007:s.SequenceEqual("X")|} => 1,
+                    _ => 0,
+                };
+            }
+            """);
+
+    [TestMethod]
+    public Task WritableSpanGuard_Reports() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(string input)
+                {
+                    Span<char> s = stackalloc char[input.Length];
+                    _ = input.AsSpan().ToUpperInvariant(s);
+                    return s switch
+                    {
+                        _ when {|SSS007:s.SequenceEqual("ABC")|} => 1,
+                        _ => 0,
+                    };
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task ConstantPatternForm_DoesNotReport() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s) => s switch
+                {
+                    "X" => 1,
+                    _ => 0,
+                };
+            }
+            """);
+
+    [TestMethod]
+    public Task GuardOnDifferentSpan_DoesNotReport() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s, ReadOnlySpan<char> other) => s switch
+                {
+                    _ when other.SequenceEqual("X") => 1,
+                    _ => 0,
+                };
+            }
+            """);
+
+    [TestMethod]
+    public Task NonConstantArgument_DoesNotReport() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s, string other) => s switch
+                {
+                    _ when s.SequenceEqual(other) => 1,
+                    _ => 0,
+                };
+            }
+            """);
+
+    [TestMethod]
+    public Task NegatedGuard_DoesNotReport() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s) => s switch
+                {
+                    _ when !s.SequenceEqual("X") => 0,
+                    _ => 1,
+                };
+            }
+            """);
+
+    [TestMethod]
+    public Task CombinedGuard_DoesNotReport() =>
+        RunAsync("""
+            using System;
+            internal static class Holder
+            {
+                public static int Resolve(ReadOnlySpan<char> s) => s switch
+                {
+                    _ when s.SequenceEqual("X") && s.Length > 0 => 1,
+                    _ => 0,
+                };
+            }
+            """);
+}

SqlServerSimulator.Analyzers/SpanCharSequenceEqualGuardAnalyzer.cs

@@ -0,0 +1,119 @@
+using System.Collections.Immutable;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace SqlServerSimulator.Analyzers;
+
+/// <summary>
+/// Flags a <c>switch</c> over a <see cref="System.Span{Char}"/> /
+/// <see cref="System.ReadOnlySpan{Char}"/> whose arm is written as a discard
+/// guard <c>_ when &lt;governing&gt;.SequenceEqual("literal")</c> instead of
+/// the equivalent constant string pattern <c>"literal"</c>. Since C# 11 a
+/// span-of-char switch matches string constants directly (the compiler
+/// lowers the pattern to the same element-wise comparison), so the
+/// hand-written <c>SequenceEqual</c> guard is pure noise — and, being a
+/// guard, it also opts the whole switch out of the
+/// <c>SortedConstantSwitchAnalyzer</c> (SSS005) ordering check that the
+/// constant-pattern form would enjoy.
+/// </summary>
+/// <remarks>
+/// This is the enforcement companion to <c>TransientUpperLowerInvariant</c>
+/// (SSS003): that rule pushes an uppercased switch scrutinee onto a
+/// <c>stackalloc</c> <c>Span&lt;char&gt;</c>, and the natural next mistake is
+/// to reach for <c>SequenceEqual</c> guards — the pre-C#-11 idiom — rather
+/// than plain string-literal arms. The <c>ResolveBuiltIn</c> keyword-dispatch
+/// tables in <c>Parser/Expression.cs</c> are the reference for the intended
+/// shape: a <c>Span&lt;char&gt;</c> scrutinee with bare <c>"NAME" =&gt; …</c>
+/// arms. Only the pure single-invocation guard is flagged (a negated or
+/// <c>&amp;&amp;</c>-combined condition has no single-pattern equivalent and
+/// is left alone), and only when the receiver is the switch's own governing
+/// expression (otherwise no constant pattern can replace it).
+/// </remarks>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class SpanCharSequenceEqualGuardAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly DiagnosticDescriptor Rule = new(
+        id: "SSS007",
+        title: "Span<char> switch guard should be a constant string pattern",
+        messageFormat: "Replace the guard '_ when {0}.SequenceEqual(\"{1}\")' with the constant pattern \"{1}\" — a Span<char>/ReadOnlySpan<char> switch matches string constants directly since C# 11",
+        category: "Maintainability",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "A switch over Span<char> / ReadOnlySpan<char> matches string-literal patterns directly since C# 11 — the compiler lowers a constant string pattern to the same element-wise comparison a hand-written SequenceEqual performs. Writing the arm as a '_ when scrutinee.SequenceEqual(\"literal\")' guard is therefore redundant, and because it is a guard it also exempts the whole switch from the SSS005 sorted-arms check that the constant-pattern form would be held to. Only the pure single-invocation guard whose receiver is the switch's governing expression is flagged; a negated or combined condition, or one probing a different span, has no single-pattern equivalent and is left alone.");
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        // Switch expressions only. A discard-with-guard case label
+        // (`case _ when …`) doesn't parse as a discard in a switch statement
+        // — `_` reads as an identifier there — so the anti-pattern this rule
+        // targets can only be written in the expression form (which is also
+        // where the clean span-constant-pattern alternative applies).
+        context.RegisterSyntaxNodeAction(AnalyzeSwitchExpression, SyntaxKind.SwitchExpression);
+    }
+
+    private static void AnalyzeSwitchExpression(SyntaxNodeAnalysisContext context)
+    {
+        var switchExpression = (SwitchExpressionSyntax)context.Node;
+        var governing = switchExpression.GoverningExpression;
+        if (!IsSpanOfChar(governing, context.SemanticModel, context.CancellationToken))
+            return;
+
+        foreach (var arm in switchExpression.Arms)
+        {
+            if (arm.Pattern is DiscardPatternSyntax && arm.WhenClause is { Condition: { } condition })
+                InspectGuard(context, governing, condition);
+        }
+    }
+
+    // Reports when `condition` is exactly `<governing>.SequenceEqual(<const
+    // string>)` — the manual spelling of a constant string pattern.
+    private static void InspectGuard(SyntaxNodeAnalysisContext context, ExpressionSyntax governing, ExpressionSyntax condition)
+    {
+        // netstandard2.0 (the analyzer TFM) has no System.Index, so list
+        // patterns aren't available — match arity explicitly.
+        if (condition is not InvocationExpressionSyntax
+            {
+                Expression: MemberAccessExpressionSyntax
+                {
+                    Name.Identifier.ValueText: "SequenceEqual",
+                    Expression: { } receiver,
+                },
+                ArgumentList.Arguments: { Count: 1 } arguments,
+            })
+        {
+            return;
+        }
+
+        var argument = arguments[0].Expression;
+
+        // The receiver must be the switch's own scrutinee — a constant
+        // pattern can only replace a guard that probes the governing value.
+        if (!SyntaxFactory.AreEquivalent(receiver, governing))
+            return;
+
+        if (context.SemanticModel.GetConstantValue(argument, context.CancellationToken).Value is not string text)
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(Rule, condition.GetLocation(), receiver.ToString(), text));
+    }
+
+    // True when the switch scrutinee is System.Span<char> or
+    // System.ReadOnlySpan<char> — the two types C# 11's constant-string
+    // pattern support applies to.
+    private static bool IsSpanOfChar(ExpressionSyntax expression, SemanticModel model, CancellationToken cancellationToken) =>
+        model.GetTypeInfo(expression, cancellationToken).Type is INamedTypeSymbol
+        {
+            Name: "Span" or "ReadOnlySpan",
+            ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true },
+            TypeArguments: { Length: 1 } typeArguments,
+        } && typeArguments[0].SpecialType == SpecialType.System_Char;
+}