Added SSS002 analyzer flagging readonly fields in non-public types whose declared type is more abstract than the immediately-assigned initializer, and applied the rule across SqlType / Collation (concrete-type singletons; helper-method extraction where switch-expression inference needed widening).

Author: RyanLamansky

CLAUDE.md

@@ -98,6 +98,7 @@ When adding error coverage: add a factory; never construct directly. The number
 ## Conventions that fail builds
 
 - **SSS001** (custom analyzer): 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, explicit-interface members are exempt. Lives in `SqlServerSimulator.Analyzers/`.
+- **SSS002** (custom analyzer): a `readonly` field in a non-public-API type whose declared type is a strict supertype of its immediately-assigned initializer should be declared as the concrete type. Same-assembly callers gain no API-stability benefit from the abstraction; the concrete declaration exposes more members directly and avoids virtual dispatch. Public types are exempt; value-typed initializers (boxing) are exempt; const fields and fields without initializers don't apply. After applying the rule, switch / conditional expressions that previously inferred the (now-shed) base type may need an explicit base-type annotation — extract to a helper method with an explicit return type (`SqlType.ResolveSimpleKeyword`), declare the destination variable explicitly (`SqlType resultType = ... ? ...`), or cast a `null` arm.
 - **MSTEST0049**: async tests must thread `TestContext.CancellationToken`. Pattern: `public TestContext TestContext { get; set; } = null!;` plus a helper that uses `this.TestContext.CancellationToken`.
 - **MSTEST0037**: prefer `Assert.IsEmpty(values)` over `Assert.AreEqual(0, values.Count)`; use typed asserts over generic `Assert.AreEqual` on known types.
 - **AssemblyHooks**: each test project has `AssemblyHooks.cs` with `static [TestClass]` hosting `[AssemblyInitialize]`. The analyzer-tests warm-up specifically prevents Roslyn cache contention under parallel execution (~3x slowdown without it).

SqlServerSimulator.Analyzers.Tests/WidenedFieldTypeAnalyzerTests.cs

@@ -0,0 +1,147 @@
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace SqlServerSimulator.Analyzers;
+
+[TestClass]
+public sealed class WidenedFieldTypeAnalyzerTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private Task RunAsync(string source) =>
+        new CSharpAnalyzerTest<WidenedFieldTypeAnalyzer, DefaultVerifier>
+        { TestCode = source }.RunAsync(this.TestContext.CancellationToken);
+
+    [TestMethod]
+    public Task BaseClassDeclared_DerivedAssigned_OnInternalType_Reports() =>
+        RunAsync("""
+            internal abstract class Base { }
+            internal sealed class Derived : Base { }
+            internal sealed class Holder
+            {
+                public static readonly Base {|SSS002:Singleton|} = new Derived();
+            }
+            """);
+
+    [TestMethod]
+    public Task InterfaceDeclared_ConcreteAssigned_OnInternalType_Reports() =>
+        RunAsync("""
+            using System.Collections.Generic;
+            internal sealed class Holder
+            {
+                private static readonly IReadOnlyList<int> {|SSS002:items|} = new List<int>();
+            }
+            """);
+
+    [TestMethod]
+    public Task SameTypeDeclaredAndAssigned_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Derived
+            {
+                public static readonly Derived Instance = new Derived();
+            }
+            """);
+
+    [TestMethod]
+    public Task PublicType_DoesNotReport() =>
+        RunAsync("""
+            public abstract class Base { }
+            public sealed class Derived : Base { }
+            public sealed class Holder
+            {
+                public static readonly Base Singleton = new Derived();
+            }
+            """);
+
+    [TestMethod]
+    public Task PublicTypeNestedInInternal_TreatedAsNonPublic_Reports() =>
+        RunAsync("""
+            internal sealed class Outer
+            {
+                public sealed class Holder
+                {
+                    public static readonly object {|SSS002:Singleton|} = new System.Text.StringBuilder();
+                }
+            }
+            """);
+
+    [TestMethod]
+    public Task NoInitializer_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Holder
+            {
+                public static readonly object Singleton;
+                static Holder() { Singleton = new System.Text.StringBuilder(); }
+            }
+            """);
+
+    [TestMethod]
+    public Task NotReadonly_DoesNotReport() =>
+        RunAsync("""
+            internal abstract class Base { }
+            internal sealed class Derived : Base { }
+            internal sealed class Holder
+            {
+                public static Base Mutable = new Derived();
+            }
+            """);
+
+    [TestMethod]
+    public Task ConstField_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Holder
+            {
+                public const int N = 42;
+            }
+            """);
+
+    [TestMethod]
+    public Task ValueTypeBoxedIntoObject_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Holder
+            {
+                public static readonly object Boxed = 42;
+            }
+            """);
+
+    [TestMethod]
+    public Task FactoryReturningSameType_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Holder
+            {
+                private static System.Text.StringBuilder Make() => new();
+                public static readonly System.Text.StringBuilder Builder = Make();
+            }
+            """);
+
+    [TestMethod]
+    public Task NullInitializer_DoesNotReport() =>
+        RunAsync("""
+            internal sealed class Holder
+            {
+                public static readonly object? Maybe = null;
+            }
+            """);
+
+    [TestMethod]
+    public Task InstanceField_OnInternalType_Reports() =>
+        RunAsync("""
+            internal abstract class Base { }
+            internal sealed class Derived : Base { }
+            internal sealed class Holder
+            {
+                public readonly Base {|SSS002:Singleton|} = new Derived();
+            }
+            """);
+
+    [TestMethod]
+    public Task TwoFieldsInOneDeclaration_BothInitializedWithDerived_BothReport() =>
+        RunAsync("""
+            internal abstract class Base { }
+            internal sealed class Derived : Base { }
+            internal sealed class Holder
+            {
+                public static readonly Base {|SSS002:A|} = new Derived(), {|SSS002:B|} = new Derived();
+            }
+            """);
+}

SqlServerSimulator.Analyzers/WidenedFieldTypeAnalyzer.cs

@@ -0,0 +1,150 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace SqlServerSimulator.Analyzers;
+
+/// <summary>
+/// Flags <c>readonly</c> fields in non-public-API types whose declared type
+/// is a strict supertype (base class or implemented interface) of the
+/// immediately-assigned initializer's static type.
+/// </summary>
+/// <remarks>
+/// <para>
+/// In a non-public type, no API-stability boundary justifies hiding the
+/// concrete shape of an immediately-bound singleton. Declaring the field as
+/// the abstract type forces every same-assembly read to go through virtual
+/// dispatch (and stops the IDE from offering members the concrete type
+/// adds). Declaring the field as the concrete type lets callers see
+/// non-virtual / non-overridden members directly and shrinks the call-site
+/// indirection.
+/// </para>
+/// <para>
+/// The rule fires only when an immediate initializer pins the runtime type
+/// at compile time. Fields without initializers, fields whose initializer
+/// already matches the declared type, and fields whose initializer is a
+/// value type (treating the declared abstract type as a deliberate boxing
+/// boundary) are exempt. Public types are also exempt: the declared type
+/// there is the documented API contract.
+/// </para>
+/// </remarks>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class WidenedFieldTypeAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly DiagnosticDescriptor Rule = new(
+        id: "SSS002",
+        title: "Field declared as an abstract type but initialized with a more specific value",
+        messageFormat: "Field '{0}' is declared as '{1}' but its initializer produces '{2}'; in non-public type '{3}', declare the field as '{2}' to expose the concrete shape directly",
+        category: "Design",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "A readonly field whose declared type is a base class or interface of its immediate initializer's runtime type provides no API-stability benefit when the containing type isn't part of the public API. Declare the field as the concrete type so same-assembly callers see the specific members and avoid virtual dispatch.");
+
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeFieldDeclaration, SyntaxKind.FieldDeclaration);
+    }
+
+    private static void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var fieldDecl = (FieldDeclarationSyntax)context.Node;
+
+        // Const fields are restricted by the compiler to compile-time
+        // primitives that must match the declared type exactly — there's no
+        // widening to flag. readonly is the gate; non-readonly fields can
+        // legitimately be reassigned to less-specific values later.
+        if (fieldDecl.Modifiers.Any(SyntaxKind.ConstKeyword))
+            return;
+        if (!fieldDecl.Modifiers.Any(SyntaxKind.ReadOnlyKeyword))
+            return;
+
+        foreach (var declarator in fieldDecl.Declaration.Variables)
+        {
+            if (declarator.Initializer is not { Value: { } initializerExpression })
+                continue;
+
+            if (context.SemanticModel.GetDeclaredSymbol(declarator, context.CancellationToken) is not IFieldSymbol field)
+                continue;
+
+            var containingType = field.ContainingType;
+            if (containingType is null || IsEffectivelyPublic(containingType))
+                continue;
+
+            if (field.Type is not INamedTypeSymbol declaredType)
+                continue;
+
+            var initializerType = context.SemanticModel.GetTypeInfo(initializerExpression, context.CancellationToken).Type;
+            if (initializerType is not INamedTypeSymbol assignedType)
+                continue;
+
+            // Same type → no widening; nothing to flag. (Reference equality
+            // via SymbolEqualityComparer is the right check; nominal name
+            // matches won't appear here because the semantic model returns
+            // the same canonical symbol on both sides.)
+            if (SymbolEqualityComparer.Default.Equals(declaredType, assignedType))
+                continue;
+
+            // Value-typed initializer with a reference-typed field is a
+            // deliberate boxing boundary — declaring the field as the value
+            // type would change semantics. Leave it alone.
+            if (assignedType.IsValueType)
+                continue;
+
+            // Confirm the declared type is actually a supertype of the
+            // assigned type. (Defensive: the code compiled, so this should
+            // always hold for a non-equal pair, but null and tuple types
+            // can sneak through TypeInfo.)
+            if (!IsAssignableTo(assignedType, declaredType))
+                continue;
+
+            var location = declarator.Identifier.GetLocation();
+            var diagnostic = Diagnostic.Create(
+                Rule,
+                location,
+                field.Name,
+                declaredType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+                assignedType.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
+                containingType.Name);
+            context.ReportDiagnostic(diagnostic);
+        }
+    }
+
+    /// <summary>
+    /// True when <paramref name="source"/> is a strict subtype of
+    /// <paramref name="target"/> — either through the base-class chain or
+    /// because <paramref name="target"/> is one of <paramref name="source"/>'s
+    /// implemented interfaces.
+    /// </summary>
+    private static bool IsAssignableTo(INamedTypeSymbol source, INamedTypeSymbol target)
+    {
+        for (var current = source.BaseType; current is not null; current = current.BaseType)
+        {
+            if (SymbolEqualityComparer.Default.Equals(current, target))
+                return true;
+        }
+        foreach (var iface in source.AllInterfaces)
+        {
+            if (SymbolEqualityComparer.Default.Equals(iface, target))
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// True iff <paramref name="type"/> and every containing type up to the
+    /// namespace are <c>public</c>. Mirrors the
+    /// <see cref="WrapperPropertyAnalyzer"/> exemption.
+    /// </summary>
+    private static bool IsEffectivelyPublic(INamedTypeSymbol type) =>
+        type.DeclaredAccessibility == Accessibility.Public
+        && (type.ContainingType is null || IsEffectivelyPublic(type.ContainingType));
+}

SqlServerSimulator.Tests.Internal/Storage/MixedTypeRowTests.cs

@@ -57,7 +57,7 @@ public void Bit_RoundTrips(bool value)
     [TestMethod]
     public void EachType_NullRoundTrips()
     {
-        foreach (var type in new[] { SqlType.Int32, SqlType.BigInt, SqlType.SmallInt, SqlType.TinyInt, SqlType.Bit })
+        foreach (var type in new SqlType[] { SqlType.Int32, SqlType.BigInt, SqlType.SmallInt, SqlType.TinyInt, SqlType.Bit })
         {
             var decoded = RowDecoder.DecodeRow([type], RowEncoder.EncodeRow([type], [SqlValue.Null(type)]));
             IsTrue(decoded[0].IsNull);

SqlServerSimulator/Collation.cs

@@ -11,15 +11,15 @@ private protected Collation()
 
     public abstract string Name { get; }
 
-    internal static readonly Collation Default = new SQL_Latin1_General_CP1_CI_AS();
+    internal static readonly SQL_Latin1_General_CP1_CI_AS Default = new();
 
     public abstract int Compare(string? x, string? y);
 
     public virtual bool Equals(string? x, string? y) => this.Compare(x, y) == 0;
 
     public abstract int GetHashCode(string obj);
 
-    private sealed class SQL_Latin1_General_CP1_CI_AS : Collation
+    internal sealed class SQL_Latin1_General_CP1_CI_AS : Collation
     {
         public override string Name => "SQL_Latin1_General_CP1_CI_AS";
 

SqlServerSimulator/Parser/Expressions/TwoSidedExpression.cs

@@ -279,7 +279,7 @@ private static decimal MoneyOrIntegerToDecimal(SqlValue v) =>
     private protected static SqlValue ApproximateArithmetic(SqlValue left, SqlValue right, char op)
     {
         var resultIsReal = left.Type == SqlType.Real && right.Type == SqlType.Real;
-        var resultType = resultIsReal ? SqlType.Real : SqlType.Float;
+        SqlType resultType = resultIsReal ? SqlType.Real : SqlType.Float;
         if (left.IsNull || right.IsNull)
             return SqlValue.Null(resultType);