ContextualKeyword: cache classification on UnquotedString, retire ParserContext.AsContextual/MatchContextual, fold TRY/CATCH/THROW/WORK/DELAY/ATOMIC contextual-text matches into the enum.

Author: RyanLamansky

SqlServerSimulator.Tests.Internal/Parser/ReservedKeywordsTests.cs

@@ -11,7 +11,9 @@ namespace SqlServerSimulator.Parser;
 /// 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>).
+/// blocking <c>select 1 as throw</c>). Contextual keywords belong in
+/// <see cref="ContextualKeyword"/> instead — parser sites then read them via
+/// <see cref="Tokens.UnquotedString.ContextualKeyword"/>.
 /// </summary>
 /// <remarks>
 /// The test cross-checks both directions: every entry in <see cref="Keyword"/>
@@ -95,7 +97,7 @@ public void Keyword_Enum_MatchesCanonicalReservedList()
 
         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).");
+            $"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 Keyword. If the parser needs to recognize the identifier in specific positions, add it to ContextualKeyword instead; call sites read it via UnquotedString.ContextualKeyword (see the TRY / CATCH / THROW pattern in Simulation.TryCatch.cs / Simulation.Throw.cs).");
 
         IsEmpty(
             unexpectedOmissions,

SqlServerSimulator/Parser/ContextualKeyword.cs

@@ -11,19 +11,23 @@ namespace SqlServerSimulator.Parser;
 /// <remarks>
 /// Recognition happens at parse time, not tokenization time: tokenizer keeps
 /// emitting <see cref="Tokens.UnquotedString"/> for any unquoted identifier,
-/// and <see cref="ParserContext.MatchContextual"/> /
-/// <see cref="ParserContext.AsContextual"/> classify on demand. This keeps
-/// column references whose names happen to match a contextual keyword
-/// (e.g. <c>create table t (Output int)</c>) working without special casing
-/// — identifier positions never invoke the contextual lookup.
+/// and <see cref="Tokens.UnquotedString.ContextualKeyword"/> classifies on
+/// demand with per-token caching. This keeps column references whose names
+/// happen to match a contextual keyword (e.g. <c>create table t (Output int)</c>)
+/// working without special casing — identifier positions never invoke the
+/// contextual lookup.
 /// </remarks>
 enum ContextualKeyword
 {
-    _ = 0, // Default — current token isn't a contextual keyword.
+    NotChecked = 0, // Default field value — token hasn't been classified yet.
+    _,              // Classified: not a contextual keyword.
     Apply,
     At,
+    Atomic,
+    Catch,
     Compatibility_Level,
     Configuration,
+    Delay,
     First,
     Matched,
     Max,
@@ -38,11 +42,14 @@ enum ContextualKeyword
     Row,
     Rows,
     Scoped,
+    Throw,
     Time,
     TraceOff,
     TraceOn,
+    Try,
     Using,
     Verbose_Truncation_Warnings,
     Within,
+    Work,
     Zone,
 }

SqlServerSimulator/Parser/Expression.cs

@@ -176,10 +176,9 @@ public static Expression Parse(ParserContext context)
                 // ordered-set aggregate postfix. STRING_AGG accepts it; every
                 // other aggregate kind raises Msg 10757. WITHIN is contextual
                 // (SQL Server doesn't reserve the identifier).
-                case UnquotedString unquoted when expression is AggregateExpression aggregateForOrderBy
-                    && context.AsContextual() == ContextualKeyword.Within:
+                case UnquotedString { ContextualKeyword: ContextualKeyword.Within }
+                    when expression is AggregateExpression aggregateForOrderBy:
                     {
-                        _ = unquoted;
                         ParseWithinGroupOrderBy(aggregateForOrderBy, context);
                         continue;
                     }
@@ -188,9 +187,8 @@ public static Expression Parse(ParserContext context)
                 // reserve any of them); the runtime check rejects date/time
                 // LHS with Msg 8116. Binds tighter than `+` so the zone-name
                 // slot is a primary expression — full expressions need parens.
-                case UnquotedString atToken when context.AsContextual() == ContextualKeyword.At:
+                case UnquotedString { ContextualKeyword: ContextualKeyword.At }:
                     {
-                        _ = atToken;
                         expression = AtTimeZone.ParsePostfix(expression, context);
                         continue;
                     }

SqlServerSimulator/Parser/Expressions/AtTimeZone.cs

@@ -153,13 +153,13 @@ private static TimeZoneInfo ResolveZone(string name)
     public static AtTimeZone ParsePostfix(Expression source, ParserContext context)
     {
         // Cursor is on AT.
-        if (!context.MatchContextual(ContextualKeyword.At))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.At })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextRequired();
-        if (!context.MatchContextual(ContextualKeyword.Time))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Time })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextRequired();
-        if (!context.MatchContextual(ContextualKeyword.Zone))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Zone })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextRequired();
 

SqlServerSimulator/Parser/Expressions/Cast.cs

@@ -85,7 +85,7 @@ internal static (SqlType targetType, int? targetMaxLength) ParseTargetTypeSpec(P
             var lengthToken = context.GetNextRequired();
             declaredMaxLength = lengthToken is Numeric { Value: { IsNull: false } numericValue }
                 ? numericValue.AsInt32
-                : context.MatchContextual(ContextualKeyword.Max)
+                : context.Token is UnquotedString { ContextualKeyword: ContextualKeyword.Max }
                     ? SqlType.MaxLengthSentinel
                     : throw SimulatedSqlException.SyntaxErrorNear(context);
             switch (context.GetNextRequired())

SqlServerSimulator/Parser/Expressions/WindowExpression.cs

@@ -191,7 +191,7 @@ public static WindowExpression WrapAggregate(AggregateExpression aggregate, Pars
     /// <c>ORDER</c>, <c>ROWS</c>, <c>RANGE</c>, or the closing <c>)</c>).
     /// </summary>
     private static Expression[] ParseOptionalPartitionBy(ParserContext context) =>
-        !context.MatchContextual(ContextualKeyword.Partition)
+        context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Partition }
             ? []
             : context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.By }
                 ? throw SimulatedSqlException.SyntaxErrorNear(context)
@@ -207,10 +207,13 @@ private static Expression[] ParseOptionalPartitionBy(ParserContext context) =>
     /// </summary>
     private static void RejectFrameSpec(ParserContext context)
     {
-        if (context.MatchContextual(ContextualKeyword.Rows))
-            throw new NotSupportedException("Explicit window frame ROWS BETWEEN inside OVER isn't modeled; only the implicit default frame is supported.");
-        if (context.MatchContextual(ContextualKeyword.Range))
-            throw new NotSupportedException("Explicit window frame RANGE BETWEEN inside OVER isn't modeled; only the implicit default frame is supported.");
+        switch (context.Token)
+        {
+            case UnquotedString { ContextualKeyword: ContextualKeyword.Rows }:
+                throw new NotSupportedException("Explicit window frame ROWS BETWEEN inside OVER isn't modeled; only the implicit default frame is supported.");
+            case UnquotedString { ContextualKeyword: ContextualKeyword.Range }:
+                throw new NotSupportedException("Explicit window frame RANGE BETWEEN inside OVER isn't modeled; only the implicit default frame is supported.");
+        }
     }
 
     /// <summary>

SqlServerSimulator/Parser/ParserContext.cs

@@ -215,30 +215,6 @@ public ParserContext MoveNextRequiredReturnSelf()
         return this;
     }
 
-    /// <summary>
-    /// Classifies the current <see cref="Token"/> as a
-    /// <see cref="ContextualKeyword"/>: returns the matching value if
-    /// <see cref="Token"/> is an unquoted identifier whose text matches one
-    /// of the contextual-keyword names case-insensitively, otherwise
-    /// returns <see cref="ContextualKeyword._"/> (zero / default). Useful
-    /// for switch-style dispatch on positions that accept several optional
-    /// keywords (e.g. DBCC <c>TRACEON</c>/<c>TRACEOFF</c>).
-    /// </summary>
-    public ContextualKeyword AsContextual() =>
-        this.Token is UnquotedString u
-        && Enum.TryParse<ContextualKeyword>(u.Span, ignoreCase: true, out var keyword)
-        && keyword != ContextualKeyword._
-        ? keyword
-        : ContextualKeyword._;
-
-    /// <summary>
-    /// Returns true when <see cref="Token"/> is an unquoted identifier that
-    /// matches the given <paramref name="expected"/> contextual keyword
-    /// (case-insensitive). Use for required-keyword guards in parser flows;
-    /// for switch-on-classification, see <see cref="AsContextual"/>.
-    /// </summary>
-    public bool MatchContextual(ContextualKeyword expected) => AsContextual() == expected;
-
     /// <summary>
     /// Advances <see cref="Token"/> to the next token in the enumeration, throwing an exception if the end was reached instead.
     /// </summary>

SqlServerSimulator/Parser/Selection.OpenJson.cs

@@ -281,7 +281,7 @@ private static OpenJsonColumn[] ParseOpenJsonWithColumns(ParserContext context,
                 var lengthToken = context.GetNextRequired();
                 declaredMaxLength = lengthToken is Numeric { Value: { IsNull: false } numericValue }
                     ? numericValue.AsInt32
-                    : context.MatchContextual(ContextualKeyword.Max)
+                    : context.Token is UnquotedString { ContextualKeyword: ContextualKeyword.Max }
                         ? SqlType.MaxLengthSentinel
                         : throw SimulatedSqlException.SyntaxErrorNear(context);
 

SqlServerSimulator/Parser/Selection.cs

@@ -227,7 +227,7 @@ private static void ParseOptionClause(ParserContext context)
         while (true)
         {
             context.MoveNextRequired();
-            if (!context.MatchContextual(ContextualKeyword.MaxRecursion))
+            if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.MaxRecursion })
                 throw new NotSupportedException("Only OPTION (MAXRECURSION N) is modeled in the OPTION clause.");
 
             if (context.GetNextRequired() is not Numeric { Value: { IsNull: false } limitValue })
@@ -1014,7 +1014,7 @@ private static bool TryParseJoinKeyword(ParserContext context, out JoinKind kind
                     kind = JoinKind.Cross;
                     return true;
                 }
-                if (context.MatchContextual(ContextualKeyword.Apply))
+                if (context.Token is UnquotedString { ContextualKeyword: ContextualKeyword.Apply })
                 {
                     kind = JoinKind.CrossApply;
                     return true;
@@ -1026,7 +1026,7 @@ private static bool TryParseJoinKeyword(ParserContext context, out JoinKind kind
             // cases above). The cursor is on OUTER; advance and require APPLY.
             case Keyword.Outer:
                 context.MoveNextRequired();
-                if (!context.MatchContextual(ContextualKeyword.Apply))
+                if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Apply })
                     throw SimulatedSqlException.SyntaxErrorNear(context);
                 kind = JoinKind.OuterApply;
                 return true;
@@ -1193,7 +1193,7 @@ private static void ConsumeOffsetFetch(ParserContext context, FromClause fromCla
         if (context.Token is ReservedKeyword { Keyword: Keyword.Fetch })
             throw SimulatedSqlException.FetchInvalidUsageWithoutOffset();
 
-        if (!context.MatchContextual(ContextualKeyword.Offset))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Offset })
             return;
 
         context.MoveNextRequired();
@@ -1207,15 +1207,15 @@ private static void ConsumeOffsetFetch(ParserContext context, FromClause fromCla
             throw SimulatedSqlException.OffsetMustNotBeNegative();
         fromClause.OffsetCount = offsetCount;
 
-        if (!context.MatchContextual(ContextualKeyword.Row) && !context.MatchContextual(ContextualKeyword.Rows))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Row or ContextualKeyword.Rows })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextOptional();
 
         if (context.Token is not ReservedKeyword { Keyword: Keyword.Fetch })
             return;
 
         context.MoveNextRequired();
-        if (!context.MatchContextual(ContextualKeyword.Next) && !context.MatchContextual(ContextualKeyword.First))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Next or ContextualKeyword.First })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextRequired();
 
@@ -1229,11 +1229,11 @@ private static void ConsumeOffsetFetch(ParserContext context, FromClause fromCla
             throw SimulatedSqlException.FetchMustBeGreaterThanZero();
         fromClause.FetchCount = fetchCount;
 
-        if (!context.MatchContextual(ContextualKeyword.Row) && !context.MatchContextual(ContextualKeyword.Rows))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Row or ContextualKeyword.Rows })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextRequired();
 
-        if (!context.MatchContextual(ContextualKeyword.Only))
+        if (context.Token is not UnquotedString { ContextualKeyword: ContextualKeyword.Only })
             throw SimulatedSqlException.SyntaxErrorNear(context);
         context.MoveNextOptional();
     }

SqlServerSimulator/Parser/Tokens/UnquotedString.cs

@@ -1,4 +1,4 @@
-namespace SqlServerSimulator.Parser.Tokens;
+namespace SqlServerSimulator.Parser.Tokens;
 
 sealed class UnquotedString : Name
 {
@@ -9,6 +9,29 @@ private UnquotedString(string command, int index, int length)
 
     public override ReadOnlySpan<char> Span => Source;
 
+    /// <summary>
+    /// Lazily classifies this token against <see cref="Parser.ContextualKeyword"/>.
+    /// First access parses <see cref="Span"/> via <see cref="Enum.TryParse{TEnum}(ReadOnlySpan{char}, bool, out TEnum)"/>
+    /// (case-insensitive); the result is cached on the field so repeat reads at
+    /// the same token are constant-time. A miss — or a pathological identifier
+    /// matching either sentinel name (<c>NotChecked</c> / <c>_</c>) — collapses
+    /// to <see cref="ContextualKeyword._"/>.
+    /// </summary>
+    public ContextualKeyword ContextualKeyword
+    {
+        get
+        {
+            if (field == ContextualKeyword.NotChecked)
+            {
+                field = Enum.TryParse<ContextualKeyword>(this.Span, ignoreCase: true, out var keyword)
+                    && keyword is not (ContextualKeyword.NotChecked or ContextualKeyword._)
+                    ? keyword
+                    : ContextualKeyword._;
+            }
+            return field;
+        }
+    }
+
     /// <summary>
     /// Returns either an <see cref="UnquotedString"/> or <see cref="ReservedKeyword"/> depending on input.
     /// </summary>