TRY/CATCH + ERROR_*() + live @@error + THROW: catches SimulatedSqlException at the per-statement dispatch boundary when inside a TRY frame. Splits DispatchOneStatement into a wrapper + Core iterator (yield can't coexist with try/catch in C# iterators) so the wrapper can materialize Core's outcomes and intercept thrown errors into BatchContext.InFlightError + ErrorSignaled flag (added to IsSkipping). After a catch, the cursor scans forward to the next statement boundary so the outer dispatch loop can resume cleanly — without this scan it'd re-dispatch the same partially-parsed statement and infinite-loop. ERROR_NUMBER / ERROR_MESSAGE / ERROR_SEVERITY / ERROR_STATE / ERROR_LINE / ERROR_PROCEDURE zero-arg scalars read InFlightError and return typed NULL outside CATCH. @@error live-tracks Connection.LastErrorNumber (set by the wrap on catch, reset to 0 on successful statement completion); was hardcoded 0. THROW ships both forms — bare re-raise from CATCH (Msg 10704 outside) and value-form (number, message, state) with fixed severity 16. Nested TRY/CATCH saves+restores InFlightError around inner CATCH so re-throw paths surface correctly to the outer CATCH. Fidelity gaps: parse-time name-resolution errors ARE caught (no compile/runtime split — same root cause as Q15 un-taken-IF gap); divide-by-zero raises raw DivideByZeroException not SimulatedSqlException so TRY/CATCH can't catch it (pre-existing); RAISERROR and XACT_STATE/XACT_ABORT deferred.

Author: RyanLamansky

CLAUDE.md

@@ -0,0 +1,106 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// Pins the <see cref="Keyword"/> enum against the authoritative T-SQL
+/// reserved keywords list at
+/// <c>https://learn.microsoft.com/en-us/sql/t-sql/language-elements/reserved-keywords-transact-sql</c>.
+/// Any change to <see cref="Keyword"/> must be verified against that page —
+/// adding a contextual keyword (e.g. <c>THROW</c>, <c>TRY</c>, <c>CATCH</c>)
+/// to this enum is a bug because the tokenizer relies on the enum to decide
+/// what surfaces as <c>ReservedKeyword</c> vs. <c>UnquotedString</c>, and a
+/// non-reserved word being treated as reserved breaks valid SQL (e.g.
+/// blocking <c>select 1 as throw</c>).
+/// </summary>
+/// <remarks>
+/// The test cross-checks both directions: every entry in <see cref="Keyword"/>
+/// must appear in the canonical list, and every canonical entry must appear
+/// in <see cref="Keyword"/>. The single exception is <c>WITHIN GROUP</c>,
+/// which appears in the canonical list as a two-word entry but is omitted
+/// from the enum — <see cref="Keyword"/>'s trailing comment notes that
+/// <c>WITHIN</c> alone isn't enforced as a reserved word in real SQL Server
+/// and <c>GROUP</c> is already covered, so a multi-word enum entry would be
+/// functionally irrelevant. The omission is hardcoded into
+/// <see cref="DocumentedOmissions"/> rather than parameterized — the
+/// "reserved keyword list is frozen" rule has no anticipated exceptions
+/// beyond this one structural quirk.
+/// </remarks>
+[TestClass]
+public sealed class ReservedKeywordsTests
+{
+    /// <summary>
+    /// The canonical reserved-keyword set, transcribed verbatim from
+    /// <c>https://learn.microsoft.com/en-us/sql/t-sql/language-elements/reserved-keywords-transact-sql</c>.
+    /// Updates here must be verified against that page; do not edit to
+    /// match the enum without re-checking the source.
+    /// </summary>
+    private static readonly HashSet<string> CanonicalReservedKeywords =
+    [
+        "ADD", "ALL", "ALTER", "AND", "ANY", "AS", "ASC", "AUTHORIZATION",
+        "BACKUP", "BEGIN", "BETWEEN", "BREAK", "BROWSE", "BULK", "BY",
+        "CASCADE", "CASE", "CHECK", "CHECKPOINT", "CLOSE", "CLUSTERED", "COALESCE",
+        "COLLATE", "COLUMN", "COMMIT", "COMPUTE", "CONSTRAINT", "CONTAINS",
+        "CONTAINSTABLE", "CONTINUE", "CONVERT", "CREATE", "CROSS", "CURRENT",
+        "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR",
+        "DATABASE", "DBCC", "DEALLOCATE", "DECLARE", "DEFAULT", "DELETE", "DENY",
+        "DESC", "DISK", "DISTINCT", "DISTRIBUTED", "DOUBLE", "DROP", "DUMP",
+        "ELSE", "END", "ERRLVL", "ESCAPE", "EXCEPT", "EXEC", "EXECUTE", "EXISTS",
+        "EXIT", "EXTERNAL",
+        "FETCH", "FILE", "FILLFACTOR", "FOR", "FOREIGN", "FREETEXT", "FREETEXTTABLE",
+        "FROM", "FULL", "FUNCTION",
+        "GOTO", "GRANT", "GROUP",
+        "HAVING", "HOLDLOCK",
+        "IDENTITY", "IDENTITY_INSERT", "IDENTITYCOL", "IF", "IN", "INDEX", "INNER",
+        "INSERT", "INTERSECT", "INTO", "IS",
+        "JOIN",
+        "KEY", "KILL",
+        "LEFT", "LIKE", "LINENO", "LOAD",
+        "MERGE",
+        "NATIONAL", "NOCHECK", "NONCLUSTERED", "NOT", "NULL", "NULLIF",
+        "OF", "OFF", "OFFSETS", "ON", "OPEN", "OPENDATASOURCE", "OPENQUERY",
+        "OPENROWSET", "OPENXML", "OPTION", "OR", "ORDER", "OUTER", "OVER",
+        "PERCENT", "PIVOT", "PLAN", "PRECISION", "PRIMARY", "PRINT", "PROC",
+        "PROCEDURE", "PUBLIC",
+        "RAISERROR", "READ", "READTEXT", "RECONFIGURE", "REFERENCES", "REPLICATION",
+        "RESTORE", "RESTRICT", "RETURN", "REVERT", "REVOKE", "RIGHT", "ROLLBACK",
+        "ROWCOUNT", "ROWGUIDCOL", "RULE",
+        "SAVE", "SCHEMA", "SECURITYAUDIT", "SELECT", "SEMANTICKEYPHRASETABLE",
+        "SEMANTICSIMILARITYDETAILSTABLE", "SEMANTICSIMILARITYTABLE", "SESSION_USER",
+        "SET", "SETUSER", "SHUTDOWN", "SOME", "STATISTICS", "SYSTEM_USER",
+        "TABLE", "TABLESAMPLE", "TEXTSIZE", "THEN", "TO", "TOP", "TRAN",
+        "TRANSACTION", "TRIGGER", "TRUNCATE", "TRY_CONVERT", "TSEQUAL",
+        "UNION", "UNIQUE", "UNPIVOT", "UPDATE", "UPDATETEXT", "USE", "USER",
+        "VALUES", "VARYING", "VIEW",
+        "WAITFOR", "WHEN", "WHERE", "WHILE", "WITH", "WITHIN GROUP", "WRITETEXT",
+    ];
+
+    /// <summary>
+    /// The only canonical entry the enum intentionally omits — a multi-word
+    /// reserved keyword whose component words don't independently behave as
+    /// reserved in real SQL Server (see class doc).
+    /// </summary>
+    private static readonly HashSet<string> DocumentedOmissions = ["WITHIN GROUP"];
+
+    [TestMethod]
+    public void Keyword_Enum_MatchesCanonicalReservedList()
+    {
+        var enumNames = Enum.GetNames<Keyword>()
+            .Where(n => n != "_")
+            .Select(n => n.ToUpperInvariant())
+            .ToHashSet();
+
+        var unexpectedExtras = enumNames.Except(CanonicalReservedKeywords).Order().ToList();
+        var unexpectedOmissions = CanonicalReservedKeywords.Except(enumNames).Except(DocumentedOmissions).Order().ToList();
+
+        IsEmpty(
+            unexpectedExtras,
+            $"Keyword enum has entries not in the canonical reserved list at {SourceUrl}: {string.Join(", ", unexpectedExtras)}. The reserved-keyword list is frozen — remove the entry from the enum (and route any contextual-keyword usage through UnquotedString, matching the TRY / CATCH / THROW pattern).");
+
+        IsEmpty(
+            unexpectedOmissions,
+            $"Keyword enum is missing canonical reserved keywords from {SourceUrl}: {string.Join(", ", unexpectedOmissions)}. Add them to the enum.");
+    }
+
+    private const string SourceUrl = "https://learn.microsoft.com/en-us/sql/t-sql/language-elements/reserved-keywords-transact-sql";
+}

SqlServerSimulator.Tests.Internal/Parser/ReservedKeywordsTests.cs

@@ -171,14 +171,6 @@ public void IfBody_NestedBlock_DispatchesInnerStatement()
         => AreEqual("inside-if", new Simulation().ExecuteScalar(
             "begin if 1=1 select 'inside-if' end"));
 
-    [TestMethod]
-    public void BeginTry_NotSupported()
-    {
-        var ex = Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(
-            "if 1=1 begin try select 1 end try begin catch select 2 end catch"));
-        Contains("TRY", ex.Message, StringComparison.Ordinal);
-    }
-
     [TestMethod]
     public void BeginAtomic_NotSupported()
         => Throws<NotSupportedException>(() => new Simulation().ExecuteNonQuery(