Migrated the last Collation.Default references to higher-fidelity placeholders.

Author: RyanLamansky

CLAUDE.md

@@ -50,7 +50,7 @@ Layout: `Storage/` (pages, types, row encoder/decoder, heap, constraints, lock m
 `FromSource[]`; rows during enumeration are `byte[]?[]`, one slot per source, null = NULL-filled outer-join side (LEFT/RIGHT/FULL/OUTER APPLY). Column resolution is qualifier-aware via `FindSourceColumn` / `ResolveAcrossTuple`; ambiguous unqualified name → Msg 209.
 
 ### `MultiPartName`
-Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`, `ImmediateQualifier` (null when unqualified — pair with `Collation.Default.Equals(name.ImmediateQualifier, "INSERTED")`, the equality folds null into `false`), `Count`, `ToString()`. 5th segment → Msg 4104.
+Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`, `ImmediateQualifier` (null when unqualified — pair with `Collation.Baseline.Equals(name.ImmediateQualifier, "INSERTED")`, the equality folds null into `false`), `Count`, `ToString()`. 5th segment → Msg 4104.
 
 ### Exception factories
 `SimulatedSqlException` constructor is private; each error case is an `internal static` factory in a topical partial (`TypeErrors`, `SchemaErrors`, `ConstraintErrors`, `ResolutionErrors`, `QueryErrors`, `SyntaxErrors`). The number lands in `Data["HelpLink.EvtID"]`. **Grep for an existing factory before adding a new one.**

SqlServerSimulator.Tests.Internal/CollationTests.cs

@@ -5,17 +5,17 @@ namespace SqlServerSimulator;
 /// <summary>
 /// Algorithm-contract tests for the <see cref="Collation"/> implementations
 /// that aren't routed through public SQL today. The default collation's
-/// behavior (<see cref="Collation.Default"/>) and the parser-driven
+/// behavior (<see cref="Collation.Baseline"/>) and the parser-driven
 /// name-resolution surface (<see cref="Collation.TryGet"/> /
 /// <see cref="Collation.IsRecognized"/>) are exercised in the public
 /// <c>CollationBehaviorTests</c> / <c>CollationMetadataTests</c> /
 /// <c>LikeTests</c>; this file keeps the non-default-collation algorithm
 /// contracts and the internal-only null handling of
-/// <see cref="Collation.Default"/>'s <see cref="IComparer{T}"/> /
+/// <see cref="Collation.Baseline"/>'s <see cref="IComparer{T}"/> /
 /// <see cref="IEqualityComparer{T}"/> contracts. The non-default
 /// algorithms exist in the code but aren't called from any public SQL
 /// site (every string op outside the LIKE case-sensitivity flag still
-/// goes through <see cref="Collation.Default"/> — see
+/// goes through <see cref="Collation.Baseline"/> — see
 /// <c>docs/claude/database-options.md</c>); the tests pin the contract
 /// so the algorithms behave correctly once routing lands.
 /// </summary>
@@ -44,12 +44,12 @@ public sealed class CollationTests
     [TestMethod]
     public void Sql_NullHandling()
     {
-        IsTrue(Collation.Default.Equals(null, null));
-        IsFalse(Collation.Default.Equals(null, ""));
-        IsFalse(Collation.Default.Equals("", null));
-        AreEqual(0, Collation.Default.Compare(null, null));
-        IsLessThan(0, Collation.Default.Compare(null, "x"));
-        IsGreaterThan(0, Collation.Default.Compare("x", null));
+        IsTrue(Collation.Baseline.Equals(null, null));
+        IsFalse(Collation.Baseline.Equals(null, ""));
+        IsFalse(Collation.Baseline.Equals("", null));
+        AreEqual(0, Collation.Baseline.Compare(null, null));
+        IsLessThan(0, Collation.Baseline.Compare(null, "x"));
+        IsGreaterThan(0, Collation.Baseline.Compare("x", null));
     }
 
     // ---- Latin1_General_100_CI_AS (Windows-style v100) ----
@@ -155,6 +155,6 @@ public void Bin_StrictCodepoint_DistinguishesNfdAndNfc()
         const string nfc = "é";
         const string nfd = "é";
         IsFalse(Latin1GeneralBin.Equals(nfc, nfd));
-        IsTrue(Collation.Default.Equals(nfc, nfd));
+        IsTrue(Collation.Baseline.Equals(nfc, nfd));
     }
 }

SqlServerSimulator.Tests.Internal/Parser/TokenLineNumberTests.cs

@@ -77,7 +77,7 @@ public void NewlineWithinACommentToken_PushesLaterTokensDown()
     private static IEnumerable<Token> TokenizeMeaningful(string command)
     {
         var index = 0;
-        while (Tokenizer.NextToken(command, ref index, Collation.Default) is Token t)
+        while (Tokenizer.NextToken(command, ref index, Collation.Baseline) is Token t)
         {
             if (t is Whitespace or Comment)
                 continue;

SqlServerSimulator.Tests.Internal/Storage/PromoteStringConcatTests.cs

@@ -13,35 +13,35 @@ public sealed class PromoteStringConcatTests
 {
     [TestMethod]
     public void Varchar_Plus_Varchar_SumsLengths() =>
-        AreEqual(30, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(20, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(30, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), VarcharSqlType.Get(20, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Varchar_Plus_Varchar_CapsAt8000() =>
-        AreEqual(8000, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(8000, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(100, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(8000, ((VarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(8000, Collation.Baseline, Coercibility.CoercibleDefault), VarcharSqlType.Get(100, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void NVarchar_Plus_NVarchar_SumsLengths_CapsAt4000() =>
-        AreEqual(4000, ((NVarcharSqlType)SqlType.PromoteForArithmetic(NVarcharSqlType.Get(3000, Collation.Default, Coercibility.CoercibleDefault), NVarcharSqlType.Get(2000, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(4000, ((NVarcharSqlType)SqlType.PromoteForArithmetic(NVarcharSqlType.Get(3000, Collation.Baseline, Coercibility.CoercibleDefault), NVarcharSqlType.Get(2000, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Char_Plus_Varchar_DropsToVarcharOfCombinedLength() =>
-        AreEqual(15, ((VarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetChar(5), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(15, ((VarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetChar(5), VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void NChar_Plus_Varchar_PromotesToNVarcharOfCombinedLength() =>
-        AreEqual(15, ((NVarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetNChar(5), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(15, ((NVarcharSqlType)SqlType.PromoteForArithmetic(SqlType.GetNChar(5), VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Varchar_Plus_NVarchar_PromotesToNVarcharOfCombinedLength() =>
-        AreEqual(30, ((NVarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), NVarcharSqlType.Get(20, Collation.Default, Coercibility.CoercibleDefault), '+')).length);
+        AreEqual(30, ((NVarcharSqlType)SqlType.PromoteForArithmetic(VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), NVarcharSqlType.Get(20, Collation.Baseline, Coercibility.CoercibleDefault), '+')).length);
 
     [TestMethod]
     public void Unspecified_Plus_BoundedVarchar_DropsToUnspecified()
     {
         // Length 0 means "we don't know"; the result can't reliably claim
         // a sum, so it falls back to the length-unspecified form.
-        var result = SqlType.PromoteForArithmetic(VarcharSqlType.Get(0, Collation.Default, Coercibility.CoercibleDefault), VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+');
-        AreSame(VarcharSqlType.Get(0, Collation.Default, Coercibility.CoercibleDefault), result);
+        var result = SqlType.PromoteForArithmetic(VarcharSqlType.Get(0, Collation.Baseline, Coercibility.CoercibleDefault), VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), '+');
+        AreSame(VarcharSqlType.Get(0, Collation.Baseline, Coercibility.CoercibleDefault), result);
     }
 
     [TestMethod]
@@ -52,8 +52,8 @@ public void Text_Plus_Varchar_DropsToVarcharUnspecified()
         // Implicit coercibility (it's a column-typed family), so the
         // Collation.Resolve hand-off yields Implicit rather than
         // CoercibleDefault.
-        var result = SqlType.PromoteForArithmetic(SqlType.Text, VarcharSqlType.Get(10, Collation.Default, Coercibility.CoercibleDefault), '+');
-        AreSame(VarcharSqlType.Get(0, Collation.Default, Coercibility.Implicit), result);
+        var result = SqlType.PromoteForArithmetic(SqlType.Text, VarcharSqlType.Get(10, Collation.Baseline, Coercibility.CoercibleDefault), '+');
+        AreSame(VarcharSqlType.Get(0, Collation.Baseline, Coercibility.Implicit), result);
     }
 
     [TestMethod]
@@ -62,6 +62,6 @@ public void NText_Plus_Char_DropsToNVarcharUnspecified()
         // NText carries Implicit; the char(5) bridge is also Implicit (via
         // SqlType.GetChar's static helper), so the resolved rank is Implicit.
         var result = SqlType.PromoteForArithmetic(SqlType.NText, SqlType.GetChar(5), '+');
-        AreSame(NVarcharSqlType.Get(0, Collation.Default, Coercibility.Implicit), result);
+        AreSame(NVarcharSqlType.Get(0, Collation.Baseline, Coercibility.Implicit), result);
     }
 }

SqlServerSimulator.Tests/Bacpac/BacpacLoaderTests.cs

@@ -696,7 +696,7 @@ public void Collation_RoundsTripsThrough_sys_databases_AndDatabasePropertyEx()
         // Whitelisted collation stored on Database.CollationName + surfaced
         // through sys.databases.collation_name and DATABASEPROPERTYEX.
         // Comparison semantics still route through the default per
-        // Collation.Default; the metadata is honest about the declaration.
+        // Collation.Baseline; the metadata is honest about the declaration.
         using var bacpac = BacpacBuilder.Create()
             .DatabaseOption("Collation", "Latin1_General_100_CI_AS")
             .Build();

SqlServerSimulator.Tests/NameComparisonRegimeTests.cs

@@ -314,7 +314,7 @@ public void ServerCollationName_SeededDatabase_CreateSchemaDBO_CoexistsWithDbo()
 
     // ===== Scalar-function result types carry the active DB collation =====
     // CHAR(N) / NCHAR(N) result types pin the active database's collation
-    // rather than the storage-baseline Collation.Default, so a CS-DB
+    // rather than the storage-baseline Collation.Baseline, so a CS-DB
     // compare between two function-returned strings goes through the
     // CS comparer. Probe-confirmed against real SQL Server CS database
     // (2026-05-22): CHAR(65) = CHAR(97) returns 'neq' (literals don't
@@ -357,4 +357,21 @@ public void CsDatabase_TwoNVarcharLiteralsCompareCaseSensitively()
     [TestMethod]
     public void CiDatabase_TwoVarcharLiterals_StillEqualUnderCi()
         => AreEqual("eq", new Simulation().ExecuteScalar("SELECT IIF('A' = 'a', 'eq', 'neq')"));
+
+    // ===== Catalog views pin _desc columns to the catalog collation =====
+    // BuildCatalogViews declares _desc columns at Catalog (Latin1_General_CI_AS_KS_WS)
+    // + Implicit. Under a CS-server simulation, the literal carries CS at
+    // CoercibleDefault rank (via the tokenizer threading). Collation.Resolve
+    // picks the column's Implicit-rank Catalog collation (CI), so the user
+    // can still query catalog _desc values without case-matching the
+    // declared enum string — matching real SQL Server's behavior.
+
+    [TestMethod]
+    public void CsDatabase_CatalogTypeDescMatchesLowercaseUnderCatalogCollation()
+    {
+        var sim = new Simulation { ServerCollationName = "SQL_Latin1_General_CP1_CS_AS" };
+        _ = sim.ExecuteNonQuery("create table dbo.catalog_t (id int)");
+        AreEqual(1, sim.ExecuteScalar(
+            "select count(*) from sys.objects where name = N'catalog_t' and type_desc = N'user_table'"));
+    }
 }