Skipped statements compile-then-skip like real SQL Server: a missing base object in an un-taken branch parses to completion via placeholder FROM-source/call metadata and is discarded whole.

Author: RyanLamansky

.editorconfig

@@ -16,6 +16,7 @@ dotnet_diagnostic.IDE0022.severity = none # Use block body for method
 dotnet_diagnostic.IDE0023.severity = none # Use block body for conversion operator
 dotnet_diagnostic.IDE0024.severity = none # Use block body for operator
 dotnet_diagnostic.IDE0040.severity = none # Add accessibility modifiers
+dotnet_diagnostic.IDE0045.severity = none # Forced ternary operators can be too unreadable.
 dotnet_diagnostic.IDE0061.severity = none # Use block body for local function
 dotnet_diagnostic.IDE0072.severity = none # Add missing cases
 

SqlServerSimulator.Tests.SqlClient/BatchErrorRecoveryTests.cs

@@ -93,6 +93,42 @@ public async Task DacFxShape_MissingObjectMidBatch_ExactlyOneErrorToken_LaterSta
         AreEqual(208, errors[0]);
     }
 
+    /// <summary>
+    /// The SSMS Query Store shape over the wire: a missing table behind an
+    /// EXISTS inside an un-taken outer IF, whose inner IF carries an ELSE.
+    /// Before skip-mode placeholder parse-continuation, the missing table threw
+    /// mid-parse and the recovery scan orphaned the inner ELSE into a bare
+    /// statement — the continue-on-error wire path turned that into a runaway
+    /// error stream (the SSMS Query Store probe crash of 2026-07-15). The
+    /// statement now parses to completion and is discarded, so the batch streams
+    /// only the trailing SELECT with no error token.
+    /// </summary>
+    [TestMethod]
+    public async Task SkippedBranch_ExistsMissingTableWithInnerElse_StreamsCleanly()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+
+        var errors = new List<int>();
+        await using var connection = new SqlConnection(Wire.ConnectionString(listener));
+        connection.FireInfoMessageEventOnUserErrors = true;
+        connection.InfoMessage += (_, e) =>
+        {
+            foreach (SqlError error in e.Errors)
+                errors.Add(error.Number);
+        };
+        await connection.OpenAsync(TestContext.CancellationToken);
+
+        await using var command = new SqlCommand(
+            "if 1 = 0 begin if exists(select * from missing) select 1 as r else select 2 as r end "
+            + "select 'after' as r", connection);
+        await using var reader = await command.ExecuteReaderAsync(TestContext.CancellationToken);
+        IsTrue(await reader.ReadAsync(TestContext.CancellationToken));
+        AreEqual("after", reader.GetString(0));
+        IsFalse(await reader.NextResultAsync(TestContext.CancellationToken));
+        IsEmpty(errors);
+    }
+
     [TestMethod]
     public async Task UseHintUnknownName_SurfacesMsg10715()
     {

SqlServerSimulator.Tests/BatchErrorRecoveryTests.cs

@@ -96,13 +96,27 @@ public void SkipModeBranch_ToleratesMissingObject_Unchanged()
             select 7
             """));
 
+    /// <summary>
+    /// A missing column on a <em>resolvable</em> table aborts the batch even
+    /// from an un-taken IF branch. Probe-confirmed (SQL Server 2025,
+    /// 2026-07-17): real SQL Server binds the columns of an existing table at
+    /// compile time and raises Msg 207 regardless of the branch being dead, so
+    /// the statement after the IF never runs. Deferred name resolution applies
+    /// only when the base object is itself missing (see
+    /// <see cref="SkipModeBranch_ToleratesMissingObject_Unchanged"/>) — a
+    /// resolvable table's columns bind eagerly.
+    /// </summary>
     [TestMethod]
-    public void SkipModeBranch_ToleratesMissingColumn_Unchanged()
-        => AreEqual(7, new Simulation().ExecuteScalar("""
-            create table t (id int);
-            if 1 = 0 select no_such_col from t;
-            select 7
-            """));
+    public void SkipModeBranch_MissingColumnOnResolvableTable_AbortsBatch()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int); create table marker (n int)").ExecuteNonQuery();
+        using var failing = connection.CreateCommand(
+            "insert marker values (1); if 1 = 0 select no_such_col from t; insert marker values (2)");
+        var ex = Throws<SimulatedSqlException>(() => failing.ExecuteNonQuery());
+        AreEqual(207, ex.Number);
+        AreEqual(1, connection.CreateCommand("select count(*) from marker").ExecuteScalar());
+    }
 
     [TestMethod]
     public void ContinuableError_DoesNotAbort_FollowingRuns()

SqlServerSimulator.Tests/SkipModeNameResolutionTests.cs

@@ -4,13 +4,16 @@ namespace SqlServerSimulator;
 
 /// <summary>
 /// Deferred name resolution in skipped control-flow branches. Real SQL Server
-/// binds object / column names lazily, so an un-taken IF / WHILE branch (or a
-/// block skipped after BREAK / CONTINUE / RETURN) that references a
-/// nonexistent table / column compiles fine and is discarded. The simulator
-/// resolves names inline with parsing, so it swallows the Msg 208 / Msg 207
-/// that would otherwise surface — but only while dispatching in skip mode.
-/// A taken branch still raises, and syntax / structural errors in skipped
-/// branches still raise (only name resolution defers).
+/// binds base object names lazily, so an un-taken IF / WHILE branch (or a block
+/// skipped after BREAK / CONTINUE / RETURN) that references a nonexistent table
+/// / view / function compiles fine and is discarded. The simulator resolves
+/// names inline with parsing, so a skip-mode FROM / function-call miss
+/// substitutes placeholder metadata and the statement parses to completion (no
+/// Msg 208 / 4121). Deferral is scoped to the missing base object, though: a
+/// missing column on a <em>resolvable</em> table binds eagerly and raises
+/// Msg 207 even in a dead branch (probe-confirmed against SQL Server 2025), and
+/// a taken branch still raises. Syntax / structural errors in skipped branches
+/// still raise (only name resolution of a missing object defers).
 /// </summary>
 [TestClass]
 public sealed class SkipModeNameResolutionTests
@@ -29,12 +32,19 @@ public void IfFalse_UnknownTable_NoBlock()
     public void IfTrue_UnknownTable_StillRaises208()
         => new Simulation().AssertSqlError("if 1 = 1 select * from nosuchtable", 208);
 
+    /// <summary>
+    /// A missing column on a <em>resolvable</em> table is not deferred — real
+    /// SQL Server binds an existing table's columns at compile time and raises
+    /// Msg 207 even from an un-taken branch (probe-confirmed SQL Server 2025,
+    /// 2026-07-17). Contrast <see cref="IfFalse_UnknownTable_NoBlock"/>, where
+    /// the missing base object defers.
+    /// </summary>
     [TestMethod]
-    public void IfFalse_UnknownColumnInKnownTable_Tolerated()
+    public void IfFalse_UnknownColumnInKnownTable_StillRaises207()
     {
         var sim = new Simulation();
         _ = sim.ExecuteNonQuery("create table t (id int)");
-        AreEqual("ok", sim.ExecuteScalar("if 1 = 0 begin select bad_col from t end select 'ok'"));
+        _ = sim.AssertSqlError("if 1 = 0 begin select bad_col from t end select 'ok'", 207);
     }
 
     [TestMethod]
@@ -136,4 +146,136 @@ public void TableVariableDeclaredInSkippedBranch_UsableAfter()
     [TestMethod]
     public void SetUndeclaredVariableInSkippedBranch_StillRaises137()
         => new Simulation().AssertSqlError("if 1 = 0 begin set @never = 1 end select 'ok'", 137);
+
+    // ---- Placeholder parse-continuation (probe matrix, 2026-07-17) ----
+
+    /// <summary>
+    /// A missing schema-qualified scalar function in an un-taken branch defers
+    /// (probe-confirmed: real SQL Server binds user functions lazily too, unlike
+    /// a bare 1-part call which is a compile-time Msg 195). The call parses to
+    /// completion and is discarded.
+    /// </summary>
+    [TestMethod]
+    public void IfFalse_UnknownQualifiedFunction_Tolerated()
+        => AreEqual("ok", new Simulation().ExecuteScalar(
+            "if 1 = 0 select dbo.no_such_fn(1, 2) select 'ok'"));
+
+    /// <summary>
+    /// A bare (1-part) unresolved function is NOT deferred — real SQL Server
+    /// treats it as a missing built-in and raises Msg 195 at compile time, even
+    /// in a dead branch.
+    /// </summary>
+    [TestMethod]
+    public void IfFalse_UnknownBareFunction_StillRaises195()
+        => new Simulation().AssertSqlError("if 1 = 0 select no_such_fn(1) select 'ok'", 195);
+
+    /// <summary>
+    /// The un-taken THEN branch defers, so its trailing ELSE runs — the missing
+    /// function must not orphan the ELSE into a spurious Msg 102.
+    /// </summary>
+    [TestMethod]
+    public void IfFalse_UnknownFunctionThenElse_ElseRuns()
+        => AreEqual("else", new Simulation().ExecuteScalar(
+            "if 1 = 0 select dbo.no_such_fn(1) as r else select 'else' as r"));
+
+    /// <summary>
+    /// The SSMS Query Store / server-properties shape: a missing table behind an
+    /// EXISTS in an un-taken outer branch. Regression for the orphaned-fragment
+    /// cascade — the recovery scan used to abandon this mid-parse and re-dispatch
+    /// the inner branch as a bare statement (spurious Msg 102 / 156).
+    /// </summary>
+    [TestMethod]
+    public void SkippedOuter_ExistsMissingTableWithInnerElse_Tolerated()
+        => AreEqual("after", new Simulation().ExecuteScalar("""
+            if 1 = 0 begin if exists(select * from missing) select 1 as r else select 2 as r end
+            select 'after' as r
+            """));
+
+    /// <summary>
+    /// The same EXISTS-behind-a-missing-table shape at top level: the un-taken
+    /// THEN's inner IF/ELSE parses to completion and the following statement
+    /// runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_ExistsMissingTableWithElse_Tolerated()
+        => AreEqual("after", new Simulation().ExecuteScalar(
+            "if 1 = 0 if exists(select * from missing) select 1 as r else select 2 as r select 'after' as r"));
+
+    /// <summary>
+    /// A missing table plus a second missing table inside a scalar subquery,
+    /// both in the un-taken THEN — the whole statement defers, the ELSE runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_MissingTableWithMissingSubqueryTable_ElseRuns()
+        => AreEqual("else", new Simulation().ExecuteScalar(
+            "if 1 = 0 select * from missing where a = (select b from other) else select 'else' as r"));
+
+    /// <summary>
+    /// A missing table behind a CASE WHEN EXISTS in a skipped block, with the
+    /// block's own ELSE — parses to completion and the ELSE runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedBlock_CaseWhenExistsMissing_ElseRuns()
+        => AreEqual("else", new Simulation().ExecuteScalar("""
+            if 1 = 0 begin select case when exists(select * from missing) then 1 else 2 end as r end
+            else select 'else' as r
+            """));
+
+    /// <summary>
+    /// A missing TVF invoked in the FROM clause of an un-taken branch defers
+    /// (the argument list is parsed and discarded); the ELSE runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_MissingTvfInFrom_ElseRuns()
+        => AreEqual("else", new Simulation().ExecuteScalar(
+            "if 1 = 0 select * from dbo.no_such_tvf(1, 2) else select 'else' as r"));
+
+    /// <summary>
+    /// ORDER BY referencing a column of a missing table defers along with the
+    /// table — no compile error in the dead branch.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_MissingTableOrderByMissingColumn_Tolerated()
+        => AreEqual("ok", new Simulation().ExecuteScalar(
+            "if 1 = 0 select * from missing order by also_missing select 'ok'"));
+
+    /// <summary>
+    /// ORDER BY referencing a missing column of a <em>resolvable</em> table is
+    /// not deferred — Msg 207 fires even in the dead branch.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_KnownTableOrderByMissingColumn_StillRaises207()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int)");
+        _ = sim.AssertSqlError("if 1 = 0 select id from t order by nope select 'ok'", 207);
+    }
+
+    /// <summary>
+    /// A missing table in one statement of a skipped block plus a missing column
+    /// on a resolvable table in the next: real SQL Server binds the resolvable
+    /// table's columns eagerly, so Msg 207 wins and aborts the batch — the
+    /// block's ELSE never runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedBlock_MissingTableThenBadColumnOnRealTable_Raises207()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int)");
+        _ = sim.AssertSqlError("""
+            if 1 = 0 begin select * from missing; select bad_col from t end
+            else select 'else' as r
+            select 'after' as r
+            """, 207);
+    }
+
+    /// <summary>
+    /// A qualified column reference against a placeholder (missing) table
+    /// resolves leniently, so the whole SELECT parses to completion and the ELSE
+    /// runs.
+    /// </summary>
+    [TestMethod]
+    public void SkippedIf_QualifiedColumnsOnMissingTable_ElseRuns()
+        => AreEqual("else", new Simulation().ExecuteScalar(
+            "if 1 = 0 select m.foo, m.bar from missing m else select 'else' as r"));
 }

SqlServerSimulator/Parser/Expression.cs

@@ -298,13 +298,38 @@ public static Expression Parse(ParserContext context)
                         // probe-confirmed real SQL Server treats a table-valued
                         // function used in scalar position as "missing scalar
                         // UDF or ambiguous" rather than a distinct error.
-                        expression = reference.ReferencedName.Count >= 2
-                            ? VarbinaryToHex.TryResolve(reference.ReferencedName, context) is { } systemFunction
-                                ? systemFunction
-                                : context.Batch.TryResolveFunction(reference.ReferencedName, out var function) && function is ScalarFunction scalarFn
-                                    ? UserFunctionCall.ParseCall(scalarFn, context)
-                                    : throw SimulatedSqlException.CannotFindUserDefinedFunction(reference.ReferencedName)
-                            : ResolveBuiltIn(reference.Name, context);
+                        if (reference.ReferencedName.Count >= 2)
+                        {
+                            if (VarbinaryToHex.TryResolve(reference.ReferencedName, context) is { } systemFunction)
+                            {
+                                expression = systemFunction;
+                            }
+                            else if (context.Batch.TryResolveFunction(reference.ReferencedName, out var function) && function is ScalarFunction scalarFn)
+                            {
+                                expression = UserFunctionCall.ParseCall(scalarFn, context);
+                            }
+                            else if (context.Batch.IsSkipping)
+                            {
+                                // Skip mode: real SQL Server defers user-function
+                                // binding, so an un-taken branch calling a missing
+                                // schema-qualified function compiles and is
+                                // discarded. Parse-and-discard the argument list so
+                                // the statement (and any trailing ELSE / END) parses
+                                // to completion instead of throwing Msg 4121 mid-
+                                // expression. A bare 1-part unrecognized function
+                                // still raises Msg 195 below — real SQL Server errors
+                                // on that at compile time even in a dead branch.
+                                expression = ParseDeferredCallAndDiscard(context);
+                            }
+                            else
+                            {
+                                throw SimulatedSqlException.CannotFindUserDefinedFunction(reference.ReferencedName);
+                            }
+                        }
+                        else
+                        {
+                            expression = ResolveBuiltIn(reference.Name, context);
+                        }
                         // ResolveBuiltIn / ParseCall leave context.Token at the
                         // closing ). The next loop iteration's GetNextOptional
                         // advances past it; advancing here would skip an extra token.
@@ -362,6 +387,33 @@ public static Expression Parse(ParserContext context)
         }
     }
 
+    /// <summary>
+    /// Skip-mode fallback for a schema-qualified function call whose name
+    /// doesn't resolve. Parses and discards the comma-separated argument list
+    /// so the cursor advances past the call, then returns a placeholder NULL
+    /// expression. On entry the cursor is on the token after the opening
+    /// <c>(</c>; on return it sits on the closing <c>)</c>, matching
+    /// <see cref="UserFunctionCall.ParseFunctionArguments"/>'s post-condition so
+    /// the outer parse loop resumes cleanly. Never runs outside skip mode — the
+    /// discarded statement is conceptually never bound.
+    /// </summary>
+    private static Value ParseDeferredCallAndDiscard(ParserContext context)
+    {
+        if (context.Token is not Operator { Character: ')' })
+        {
+            while (true)
+            {
+                _ = Parse(context);
+                if (context.Token is Operator { Character: ')' })
+                    break;
+                if (context.Token is not Operator { Character: ',' })
+                    throw SimulatedSqlException.SyntaxErrorNear(context);
+                context.MoveNextRequired();
+            }
+        }
+        return new Value();
+    }
+
     /// <summary>
     /// Consumes a <c>WITHIN GROUP (ORDER BY expr [ASC|DESC] [, ...])</c>
     /// postfix and attaches the parsed items to <paramref name="aggregate"/>.