Continued migration away from Collation.Default to more accurate alternatives.

Author: RyanLamansky

CLAUDE.md

@@ -77,7 +77,7 @@ Six scopes, one home each. **Add new state to whichever class matches its true s
 
 ## Conventions that fail builds
 
-- **SSS001**: non-public types may not have auto-properties or trivial wrappers over same-type fields. Expose the field directly: `public readonly T Foo = expr;`. Overrides, abstracts, statics, and interface implementations exempt.
+- **SSS001**: non-public types may not have auto-properties or trivial wrappers over same-type fields. Expose the field directly: `public readonly T Foo = expr;` (or `static readonly` for static-singleton state). Overrides, abstracts, and interface implementations exempt.
 - **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.

SqlServerSimulator.Analyzers.Tests/WrapperPropertyAnalyzerTests.cs

@@ -151,12 +151,15 @@ internal sealed class C : B
             }
             """);
 
+    // Static auto-properties on non-public types have the same overhead as
+    // instance ones — a backing field plus a getter method, no API-stability
+    // benefit. Convert to `public static readonly int Value = 42;`.
     [TestMethod]
-    public Task StaticProperty_DoesNotReport() =>
+    public Task StaticAutoProperty_Reports() =>
         RunAsync("""
             internal static class C
             {
-                public static int Value { get; } = 42;
+                public static int {|SSS001:Value|} { get; } = 42;
             }
             """);
 

SqlServerSimulator.Analyzers/WrapperPropertyAnalyzer.cs

@@ -24,7 +24,10 @@ namespace SqlServerSimulator.Analyzers;
 /// Public types are exempt — there the property provides genuine API-stability
 /// flexibility (the rationale behind CA2227 and similar guidance). Overrides and
 /// explicit interface implementations are also exempt: their API shape is
-/// dictated by the base type or interface and isn't optional.
+/// dictated by the base type or interface and isn't optional. Static
+/// auto-properties / wrappers are <em>not</em> exempt — they carry the same
+/// backing-field + getter-method overhead as instance ones with no compensating
+/// API-stability benefit on a non-public type.
 /// </para>
 /// </remarks>
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
@@ -57,7 +60,7 @@ private static void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context
         if (context.SemanticModel.GetDeclaredSymbol(propertyDecl, context.CancellationToken) is not IPropertySymbol property)
             return;
 
-        if (property.IsStatic || property.GetMethod is null)
+        if (property.GetMethod is null)
             return;
 
         // Overrides, abstract/extern declarations, explicit interface

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -223,25 +223,31 @@ public void CsDatabase_CreateSchemaFullwidthSys_StillRejectedAsReserved()
         _ = CsCollation().AssertSqlError("CREATE SCHEMA ｓys", 2760);
     }
 
+    /// <summary>
+    ///`SP_EXECUTESQL` doesn't case-equal `sp_executesql` under CS, so
+    ///the dispatch falls through to generic user-proc lookup which
+    ///also misses → Msg 2812 "Could not find stored procedure".
+    /// </summary>
     [TestMethod]
     public void CsDatabase_SystemProcSpExecuteSql_UppercaseCase_NotFound()
-        // `SP_EXECUTESQL` doesn't case-equal `sp_executesql` under CS, so
-        // the dispatch falls through to generic user-proc lookup which
-        // also misses → Msg 2812 "Could not find stored procedure".
         => _ = CsCollation().AssertSqlError("EXEC SP_EXECUTESQL N'select 1'", 2812);
 
+    /// <summary>
+    /// Probe-confirmed: ｓp_executesql width-folds to sp_executesql
+    /// under CS_AS (IgnoreWidth stays on), so dispatch still routes
+    /// through the simulator's sp_executesql handler.
+    /// </summary>
     [TestMethod]
     public void CsDatabase_SystemProcSpExecuteSql_FullwidthCase_Dispatches()
-        // Probe-confirmed: ｓp_executesql width-folds to sp_executesql
-        // under CS_AS (IgnoreWidth stays on), so dispatch still routes
-        // through the simulator's sp_executesql handler.
         => AreEqual(1, CsCollation().ExecuteScalar("EXEC ｓp_executesql N'select 1'"));
 
+    /// <summary>
+    /// hierarchyid:: is the canonical lowercase form; HIERARCHYID
+    /// doesn't case-equal it under CS, so the static-call dispatch
+    /// misses and the parser raises a syntax error.
+    /// </summary>
     [TestMethod]
     public void CsDatabase_HierarchyIdTypePrefix_UppercaseHIERARCHYID_NotResolved()
-        // hierarchyid:: is the canonical lowercase form; HIERARCHYID
-        // doesn't case-equal it under CS, so the static-call dispatch
-        // misses and the parser raises a syntax error.
         => _ = Throws<Exception>(() => CsCollation().ExecuteScalar(
             "SELECT HIERARCHYID::GetRoot()"));
 

SqlServerSimulator/BuiltInResources.cs

@@ -86,7 +86,7 @@ private static Dictionary<string, HeapTable> BuildSystemHeapTables()
             _ = systypes.Heap.Insert(RowEncoder.EncodeRow(systypes.Schema, values));
         }
 
-        return new(Collation.Default) { [systypes.Name] = systypes };
+        return new(BuiltInToken.Comparer) { [systypes.Name] = systypes };
     }
 
     private static SqlValue ObjectToSqlValue(object? value, SqlType type) =>
@@ -1096,7 +1096,7 @@ private static Dictionary<string, CatalogView> BuildCatalogViews()
         };
         var serversView = new CatalogView("servers", serversColumns, EnumerateSysServers);
 
-        return new Dictionary<string, CatalogView>(Collation.Default)
+        return new Dictionary<string, CatalogView>(BuiltInToken.Comparer)
         {
             ["sys.databases"] = databasesView,
             ["sys.servers"] = serversView,
@@ -2116,7 +2116,7 @@ private static IEnumerable<SqlValue[]> EnumerateSysXmlIndexes(Parser.BatchContex
                 // Build a quick name→objectId map so secondary indexes can
                 // resolve their using_xml_index_id from the recorded
                 // UsingPrimaryIndexName.
-                var primaryIds = new Dictionary<string, int>(Collation.Default);
+                var primaryIds = new Dictionary<string, int>(database.Collation);
                 foreach (var ix in table.XmlIndexes)
                 {
                     if (ix.IsPrimary)

SqlServerSimulator/BuiltInToken.cs

@@ -83,4 +83,20 @@ public static bool EqualsAny(string? value, params ReadOnlySpan<string> options)
     /// </summary>
     public static int GetHashCode(string value) =>
         compareInfo.GetHashCode(value, Options);
+
+    /// <summary>
+    /// Singleton <see cref="IEqualityComparer{T}"/> wrapper for use as a
+    /// dictionary / hashset comparer. The wire-up routes through the
+    /// static <see cref="Equals(string?, string?)"/> /
+    /// <see cref="GetHashCode(string)"/> entry points, so dict-backed
+    /// state stays semantically identical to ad-hoc compares.
+    /// </summary>
+    internal static readonly ComparerImpl Comparer = new();
+
+    internal sealed class ComparerImpl : IEqualityComparer<string>
+    {
+        public bool Equals(string? x, string? y) => BuiltInToken.Equals(x, y);
+
+        public int GetHashCode(string obj) => BuiltInToken.GetHashCode(obj);
+    }
 }

SqlServerSimulator/Parser/Expressions/Grouping.cs

@@ -49,7 +49,7 @@ internal static bool FindArg(IReadOnlyList<Expression> haystack, Expression argu
         var leaf = reference.ReferencedName.Leaf;
         foreach (var entry in haystack)
         {
-            if (entry is Reference r && Collation.Default.Equals(r.ReferencedName.Leaf, leaf))
+            if (entry is Reference r && BuiltInToken.Equals(r.ReferencedName.Leaf, leaf))
                 return true;
         }
         return false;

SqlServerSimulator/Parser/Expressions/TypeId.cs

@@ -56,7 +56,7 @@ public override SqlValue Run(RuntimeContext runtime)
         // through the schema's TableTypes dict.
         foreach (var row in BuiltInResources.SystypesRowData)
         {
-            if (Collation.Default.Equals((string)row[0]!, leafPart))
+            if (BuiltInToken.Equals((string)row[0]!, leafPart))
                 return SqlValue.FromInt32(Convert.ToInt32(row[3]!, System.Globalization.CultureInfo.InvariantCulture));
         }
 

SqlServerSimulator/Parser/Selection.Execution.Aggregate.cs

@@ -165,7 +165,7 @@ SqlValue ResolveByGroupKey(MultiPartName name)
                     for (var i = 0; i < capturedSet.Length; i++)
                     {
                         if (capturedSet[i] is Reference r
-                            && Collation.Default.Equals(r.Name, name.Leaf))
+                            && BuiltInToken.Equals(r.Name, name.Leaf))
                         {
                             return state.KeyValues[i];
                         }
@@ -176,7 +176,7 @@ SqlValue ResolveByGroupKey(MultiPartName name)
                     foreach (var expr in fromClause.AllGroupingExpressions)
                     {
                         if (expr is Reference r
-                            && Collation.Default.Equals(r.Name, name.Leaf))
+                            && BuiltInToken.Equals(r.Name, name.Leaf))
                         {
                             return SqlValue.Null(expr.GetSqlType(resolveColumnType));
                         }

SqlServerSimulator/Parser/Selection.Execution.OrderBy.cs

@@ -39,7 +39,7 @@ private static SqlValue[] ComputeOrderKeys(
             {
                 for (var j = 0; j < outputColumnNames.Length; j++)
                 {
-                    if (Collation.Default.Equals(outputColumnNames[j], name.Leaf))
+                    if (BuiltInToken.Equals(outputColumnNames[j], name.Leaf))
                         return projected[j];
                 }
                 return distinct