Add Msg 8133 enforcement for all-bare-NULL CASE / IIF — compile-time check on every THEN body + ELSE (absent ELSE = implicit NULL); typed NULL (CAST(NULL AS T)) satisfies the rule; (NULL) paren-wrap still trips via Parenthesized unwrap helper Expression.IsBareNullLiteral.

Author: RyanLamansky

CLAUDE.md

@@ -104,7 +104,7 @@ The dispatch loop drains optional `;`s at the top of each iteration and trusts e
 - Boolean combinators (WHERE / MERGE-ON / CHECK): `AND` / `OR` / `NOT`, parens, `IS [NOT] NULL`, `[NOT] IN (literal,...)`. Tri-valued.
 - Set ops (UNION / UNION ALL / INTERSECT / EXCEPT): standard precedence (INTERSECT > UNION/EXCEPT). **NULLs are equal during set-op dedup/matching** (opposite of `=`'s tri-state). Per-branch ORDER BY in non-final branch → Msg 156. Top-level ORDER BY references first-branch column names only.
 - `SELECT *`: bare and qualified `<source>.*`. Multi-source `*` keeps duplicate names. Unbound `<qualifier>.*` → Msg 4104.
-- CASE: searched + simple. UNKNOWN excludes (matches WHERE); simple-form `CASE NULL WHEN NULL` falls through. Result type from `SqlType.Promote` over THEN/ELSE.
+- CASE: searched + simple. UNKNOWN excludes (matches WHERE); simple-form `CASE NULL WHEN NULL` falls through. Result type from `SqlType.Promote` over THEN/ELSE. **Msg 8133** fires at parse when every result expression (every THEN body + the explicit ELSE if present; an absent ELSE counts as implicit bare NULL) is a bare `NULL` literal — `Expression.IsBareNullLiteral` unwraps `Parenthesized` so `(NULL)` still trips. A single typed branch (e.g. `CAST(NULL AS int)`) satisfies the rule. `IIF` enforces the same check on its two value arms (real SQL Server desugars IIF to CASE).
 - `ISNULL` truncates fallback to first arg's type. `IIF` = sugar for searched CASE. `NULLIF(a, b)` = `CASE WHEN a = b THEN NULL ELSE a END`. EF emits `ISNULL` only for `??` with a CAST; bare `??` emits `COALESCE`. Neither IIF nor NULLIF is EF-emitted (LINQ ternary → CASE) — load-bearing for `FromSqlInterpolated`.
 
 ### JOINs / APPLY
@@ -418,7 +418,6 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - `OUTPUT INTO @table_var`, `OUTPUT DELETED.*` / `INSERTED.*` star expansion.
 - MERGE source subqueries; MERGE target column refs in `ON`; `WHEN MATCHED` UPDATE/DELETE branches; `$action`.
 - Msg 8141 (inline CHECK referencing a peer column — SQL Server rejects at CREATE TABLE; simulator allows).
-- Msg 8133 (CASE where every branch is bare `NULL`; simulator returns NULL of `int`).
 - `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).
 - Heap allocation tracking (flat page list, no IAM/PFS).
 - Compound assignment (`SET @v += expr` / `-=` / `*=` etc.) — rewrite as `SET @v = @v + expr`. The arithmetic-operator runtime is locked behind `protected` instance methods on `TwoSidedExpression`; exposing them as static helpers is the prerequisite refactor.

SqlServerSimulator.Tests/CaseExpressionTests.cs

@@ -174,4 +174,91 @@ public void Case_MissingEnd_RaisesSyntaxError()
         var ex = Throws<DbException>(() => _ = new Simulation().ExecuteScalar("select case when 1=1 then 'a'"));
         AreEqual("102", ex.Data["HelpLink.EvtID"]);
     }
+
+    // === Msg 8133: every result expression is a bare NULL ===
+    // Probed against SQL Server 2025 (2026-05-11). Class 16 State 1 verbatim:
+    // "At least one of the result expressions in a CASE specification must
+    //  be an expression other than the NULL constant."
+
+    [TestMethod]
+    public void Case_AllBareNull_NoElse_Searched_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then null end",
+            8133,
+            "At least one of the result expressions in a CASE specification must be an expression other than the NULL constant.");
+
+    [TestMethod]
+    public void Case_AllBareNull_WithElseNull_Searched_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then null else null end",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_MultipleWhens_NoElse_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then null when 1=0 then null end",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_Simple_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case 1 when 1 then null else null end",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_SimpleNoElse_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case 1 when 1 then null end",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_ParenWrapped_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then (null) else (null) end",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_DoubleParenWrapped_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then ((null)) else null end",
+            8133);
+
+    [TestMethod]
+    public void Case_TypedNullElse_Accepted()
+    {
+        // A typed NULL (`cast(null as int)`) on any branch satisfies the
+        // rule because the result type can be inferred.
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar(
+            "select case when 1=1 then null else cast(null as int) end"));
+    }
+
+    [TestMethod]
+    public void Case_TypedNullThen_Accepted()
+    {
+        AreEqual(DBNull.Value, new Simulation().ExecuteScalar(
+            "select case when 1=1 then cast(null as varchar(10)) else null end"));
+    }
+
+    [TestMethod]
+    public void Case_OneBranchTyped_OneBareNull_Accepted()
+    {
+        // One typed branch satisfies Msg 8133. Use int branches because the
+        // simulator currently types bare NULL as int and a varchar typed
+        // branch would collide on Promote (pre-existing fidelity gap that's
+        // orthogonal to Msg 8133).
+        AreEqual(7, new Simulation().ExecuteScalar(
+            "select case when 1=1 then 7 when 1=0 then null else null end"));
+    }
+
+    [TestMethod]
+    public void Case_AllBareNull_InWhere_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select 1 where case when 1=1 then null else null end is null",
+            8133);
+
+    [TestMethod]
+    public void Case_AllBareNull_Nested_OuterTrips_Msg8133()
+        => new Simulation().AssertSqlError(
+            "select case when 1=1 then case when 1=1 then null else null end else null end",
+            8133);
 }

SqlServerSimulator.Tests/IsNullIifNullIfTests.cs

@@ -196,6 +196,35 @@ public void NullIf_ThreeArgs_RaisesSyntax()
         _ = Throws<DbException>(() => ExecuteScalar("select nullif(1, 2, 3)"));
     }
 
+    // === Msg 8133 via IIF: IIF desugars to CASE so all-bare-NULL arms ===
+    // share the CASE wording. Probed against SQL Server 2025 (2026-05-11).
+
+    [TestMethod]
+    public void Iif_BothArmsBareNull_Msg8133()
+        => AssertSqlError("select iif(1=1, null, null)", 8133,
+            "At least one of the result expressions in a CASE specification must be an expression other than the NULL constant.");
+
+    [TestMethod]
+    public void Iif_BothArmsBareNullParenWrapped_Msg8133()
+        => AssertSqlError("select iif(1=1, (null), (null))", 8133);
+
+    [TestMethod]
+    public void Iif_OneArmTypedNull_Accepted()
+    {
+        // A typed NULL on one arm satisfies the rule.
+        AreEqual(DBNull.Value, ExecuteScalar("select iif(1=1, null, cast(null as int))"));
+    }
+
+    [TestMethod]
+    public void Iif_OneArmTyped_OneArmBareNull_Accepted()
+    {
+        // One typed arm satisfies Msg 8133. Int both sides because the
+        // simulator currently types bare NULL as int (cross-family
+        // varchar+null promotion is a pre-existing fidelity gap orthogonal
+        // to Msg 8133).
+        AreEqual(7, ExecuteScalar("select iif(1=1, 7, null)"));
+    }
+
     // EF Core emits NULLIF for safe-divide: a / NULLIF(b, 0).
     [TestMethod]
     public void NullIf_FromTableRow_EfCoreSafeDividePattern()

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -311,4 +311,19 @@ internal static SimulatedSqlException FunctionMayNotHaveWithinGroup(string funct
     /// </summary>
     internal static SimulatedSqlException IntegerIndexNotAllowedInOrderedAggregate() =>
         new("Windowed functions, aggregates and NEXT VALUE FOR functions do not support integer indices as ORDER BY clause expressions.", 5308, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 8133 — every result expression in a
+    /// <c>CASE</c> specification is a bare <c>NULL</c> literal. SQL Server
+    /// requires at least one branch (THEN body or explicit ELSE) to be a
+    /// typed expression so the result type can be inferred. An absent ELSE
+    /// is treated as implicit NULL — so a single <c>WHEN cond THEN NULL</c>
+    /// with no ELSE also fires Msg 8133. Probe-confirmed against SQL Server
+    /// 2025 (2026-05-11): Class 16, State 1, verbatim wording. Also fires
+    /// for <c>IIF(cond, NULL, NULL)</c> (real SQL Server desugars IIF to
+    /// CASE); <c>COALESCE(NULL, NULL)</c> takes a different path (Msg 4127)
+    /// and <c>NULLIF</c> a third (Msg 4151).
+    /// </summary>
+    internal static SimulatedSqlException AllResultsInCaseAreNull() =>
+        new("At least one of the result expressions in a CASE specification must be an expression other than the NULL constant.", 8133, 16, 1);
 }

SqlServerSimulator/Parser/Expression.cs

@@ -322,6 +322,24 @@ private static void ParseWithinGroupOrderBy(AggregateExpression aggregate, Parse
     /// </summary>
     internal virtual bool ResultIsNullable(Func<MultiPartName, bool> resolveColumnNullable) => true;
 
+    /// <summary>
+    /// Returns true when <paramref name="expression"/> is a bare <c>NULL</c>
+    /// literal at the syntactic level — that is, the keyword <c>NULL</c>
+    /// optionally wrapped in any number of parentheses. A typed NULL like
+    /// <c>CAST(NULL AS int)</c> is NOT a bare NULL (it's a <see cref="Cast"/>
+    /// expression carrying a typed value). Used by <see cref="CaseExpression"/>
+    /// and <see cref="Iif"/> to enforce SQL Server's Msg 8133 rule: every
+    /// result expression in a CASE specification being a bare NULL is a
+    /// compile-time error, but a single explicitly-typed NULL among the
+    /// branches satisfies the rule.
+    /// </summary>
+    internal static bool IsBareNullLiteral(Expression expression) => expression switch
+    {
+        Parenthesized p => IsBareNullLiteral(p.Wrapped),
+        Value v => v.Constant.IsNull,
+        _ => false,
+    };
+
     /// <summary>
     /// Parses a grouped expression starting at the opening <c>(</c>. Two
     /// shapes share the leading paren: a parenthesized expression

SqlServerSimulator/Parser/Expressions/CaseExpression.cs

@@ -161,13 +161,24 @@ public static CaseExpression ParseCase(ParserContext context)
             elseBranch = Expression.Parse(context);
         }
 
+        // Real SQL Server fires Msg 8133 at compile time when every result
+        // expression — every THEN body, plus the explicit ELSE if present
+        // (absent ELSE = implicit NULL) — is a bare NULL literal. A typed
+        // NULL (e.g. `CAST(NULL AS int)`) satisfies the rule because its
+        // type isn't ambiguous. Probe-confirmed against SQL Server 2025.
+        var anyTypedBranch = elseBranch is not null && !IsBareNullLiteral(elseBranch);
+        for (var i = 0; !anyTypedBranch && i < thens.Count; i++)
+            anyTypedBranch = !IsBareNullLiteral(thens[i]);
+
         return context.Token is not ReservedKeyword { Keyword: Keyword.End }
             ? throw SimulatedSqlException.SyntaxErrorNear(context)
-            : new CaseExpression(
-                input,
-                input is null ? [.. searchedWhensList!] : null,
-                input is not null ? [.. compareValuesList!] : null,
-                [.. thens],
-                elseBranch);
+            : !anyTypedBranch
+                ? throw SimulatedSqlException.AllResultsInCaseAreNull()
+                : new CaseExpression(
+                    input,
+                    input is null ? [.. searchedWhensList!] : null,
+                    input is not null ? [.. compareValuesList!] : null,
+                    [.. thens],
+                    elseBranch);
     }
 }

SqlServerSimulator/Parser/Expressions/Iif.cs

@@ -26,6 +26,14 @@ public Iif(ParserContext context)
         if (context.Token is not Tokens.Operator { Character: ',' })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         this.falseValue = Parse(context.MoveNextRequiredReturnSelf());
+
+        // IIF desugars to a searched CASE in SQL Server, so Msg 8133 fires
+        // when both value arms are bare NULL literals — probe-confirmed
+        // against SQL Server 2025 (verbatim CASE wording, not an IIF-specific
+        // message). A single typed NULL (`CAST(NULL AS int)`) on either arm
+        // satisfies the rule.
+        if (IsBareNullLiteral(this.trueValue) && IsBareNullLiteral(this.falseValue))
+            throw SimulatedSqlException.AllResultsInCaseAreNull();
     }
 
     public override SqlValue Run(RuntimeContext runtime)

SqlServerSimulator/Parser/Expressions/Parenthesized.cs

@@ -9,9 +9,12 @@ namespace SqlServerSimulator.Parser.Expressions;
 /// </summary>
 internal sealed class Parenthesized(Expression wrapped) : Expression
 {
-    public override Storage.SqlValue Run(RuntimeContext runtime) => wrapped.Run(runtime);
+    /// <summary>The expression nested inside the parentheses. Exposed so callers (notably <see cref="Expression.IsBareNullLiteral"/>) can peer through paren wrappers.</summary>
+    public readonly Expression Wrapped = wrapped;
 
-    public override Storage.SqlType GetSqlType(Func<MultiPartName, Storage.SqlType> resolveColumnType) => wrapped.GetSqlType(resolveColumnType);
+    public override Storage.SqlValue Run(RuntimeContext runtime) => this.Wrapped.Run(runtime);
 
-    internal override string DebugDisplay() => $"( {wrapped.DebugDisplay()} )";
+    public override Storage.SqlType GetSqlType(Func<MultiPartName, Storage.SqlType> resolveColumnType) => this.Wrapped.GetSqlType(resolveColumnType);
+
+    internal override string DebugDisplay() => $"( {this.Wrapped.DebugDisplay()} )";
 }