Added two new code analysis rules: SSS005 (sort simple switches) and SSS006 (chain StringBuilder APIs where possible).

Author: RyanLamansky

CLAUDE.md

@@ -81,6 +81,8 @@ Six scopes, one home each. **Add new state to whichever class matches its true s
 - **SSS002**: a `readonly` field in a non-public-API type whose declared type is a strict supertype of its initializer should be declared as the concrete type. Public types, value-typed initializers (boxing), const fields, and uninitialized fields exempt.
 - **SSS003**: `string.ToUpperInvariant()` / `ToLowerInvariant()` whose result is the *governing expression* of a `switch` allocates a temporary string. Use the `Span<char>` overload — `Span<char> buf = stackalloc char[s.Length]; s.AsSpan().ToUpperInvariant(buf)` — and switch on the resulting count.
 - **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.
 - **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/ChainableStringBuilderCallsAnalyzerTests.cs

@@ -0,0 +1,214 @@
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace SqlServerSimulator.Analyzers;
+
+[TestClass]
+public sealed class ChainableStringBuilderCallsAnalyzerTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private Task RunAsync(string source) =>
+        new CSharpAnalyzerTest<ChainableStringBuilderCallsAnalyzer, DefaultVerifier>
+        { TestCode = source }.RunAsync(this.TestContext.CancellationToken);
+
+    private const string Preamble = "using System.Text;\n";
+
+    [TestMethod]
+    public Task TwoDiscardedAppends_Reports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    {|SSS006:_ = sb.Append("a");|}
+                    _ = sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task ThreeAppends_ExampleShape_Reports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb, byte[] bytes)
+                {
+                    {|SSS006:_ = sb.Append('"');|}
+                    _ = sb.Append(System.Convert.ToBase64String(bytes));
+                    _ = sb.Append('"');
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task TwoBareAppends_Reports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    {|SSS006:sb.Append("a");|}
+                    sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task AppendLineAndInsert_SelfReturningMethods_Report() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    {|SSS006:_ = sb.AppendLine("a");|}
+                    _ = sb.Insert(0, "b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task FieldReceiver_Reports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                private readonly StringBuilder sb = new();
+                void M()
+                {
+                    {|SSS006:_ = this.sb.Append("a");|}
+                    _ = this.sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task CommentBetween_StillReports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    {|SSS006:_ = sb.Append("a");|}
+                    // a documented step
+                    _ = sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task SingleAppend_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb) => sb.Append("a");
+            }
+            """);
+
+    [TestMethod]
+    public Task DifferentBuildersInterleaved_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb, StringBuilder other)
+                {
+                    _ = sb.Append("a");
+                    _ = other.Append("b");
+                    _ = sb.Append("c");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task NonBuilderStatementBetween_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    _ = sb.Append("a");
+                    System.Console.WriteLine();
+                    _ = sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task MethodCallReceiver_NotSimple_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                StringBuilder Get() => new();
+                void M()
+                {
+                    _ = Get().Append("a");
+                    _ = Get().Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task CapturedReturnThenAppend_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    var captured = sb.Append("a");
+                    _ = sb.Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task BareAppendAfterExistingChain_Reports() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    {|SSS006:_ = sb.Append("a").Append("b");|}
+                    _ = sb.Append("c");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task LoneExistingChain_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                void M(StringBuilder sb)
+                {
+                    _ = sb.Append("a").Append("b");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task ChainsOnCallValuedRoot_DoesNotReport() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                StringBuilder Get() => new();
+                void M()
+                {
+                    _ = Get().Append("a").Append("b");
+                    _ = Get().Append("c");
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task RunFollowedByToString_ReportsOnlyTheAppendRun() =>
+        RunAsync(Preamble + """
+            internal sealed class C
+            {
+                string M(StringBuilder sb)
+                {
+                    {|SSS006:_ = sb.Append("a");|}
+                    _ = sb.Append("b");
+                    return sb.ToString();
+                }
+            }
+            """);
+}