Consolidated single-character tokens into the new Operator token.

Author: RyanLamansky

SqlServerSimulator/Parser/Expression.cs

@@ -68,7 +68,7 @@ public static Expression Parse(ParserContext context)
                 case Name name:
                     expression = new Reference(name);
                     break;
-                case Plus:
+                case Operator { Character: '+' }:
                     if (expression is null)
                     {
                         context.MoveNextRequired();
@@ -87,7 +87,7 @@ public static Expression Parse(ParserContext context)
 
                     tokenWasRead = true;
                     break;
-                case Minus:
+                case Operator { Character: '-' }:
                     if (expression is null)
                     {
                         context.MoveNextRequired();
@@ -108,7 +108,7 @@ public static Expression Parse(ParserContext context)
                     tokenWasRead = true;
                     break;
 
-                case Period:
+                case Operator { Character: '.' }:
                     if (expression is null)
                         throw new NotSupportedException("Simulated expression parser doesn't know how to handle '.' at the start of an expression.");
 
@@ -119,12 +119,12 @@ public static Expression Parse(ParserContext context)
                         reference.AddMultiPartComponent(context.GetNextRequired<Name>());
                     }
                     break;
-                case Comma:
-                case CloseParentheses:
+                case Operator { Character: ',' }:
+                case Operator { Character: ')' }:
                     if (expression is null)
                         throw SimulatedSqlException.SyntaxErrorNear(context.Token);
                     return expression;
-                case OpenParentheses:
+                case Operator { Character: '(' }:
                     {
                         if (expression is not Reference reference)
                             throw SimulatedSqlException.SyntaxErrorNear(context.Token);

SqlServerSimulator/Parser/ParserContext.cs

@@ -128,6 +128,9 @@ private bool MoveNext()
             if (token is Whitespace)
                 continue;
 
+#if DEBUG
+            tokens.Add(token);
+#endif
             this.Token = token;
             return true;
         }
@@ -137,6 +140,11 @@ private bool MoveNext()
     }
 
 #if DEBUG
+    /// <summary>
+    /// Contains all the non-whitespace tokens that have been read so far.
+    /// </summary>
+    private readonly List<Token> tokens = [];
+
     /// <summary>
     /// Returns a string representation of the tokenized command.
     /// The <see cref="Token"/> token is wrapped by '»' and '«'.

SqlServerSimulator/Parser/Selection.cs

@@ -29,13 +29,14 @@ public static Selection Parse(ParserContext context, uint depth)
         {
             // SQL Server doesn't require outer parentheses.
             // When Expression.Parse supports them, the checks for them here should be removed.
-            context.MoveNextRequired<OpenParentheses>();
+            if (context.GetNextRequired<Operator>() is not { Character: '(' })
+                throw SimulatedSqlException.SyntaxErrorNear(context.Token);
             context.MoveNextRequired();
 
             var resolvedExpression = Expression.Parse(context).Run(name => throw SimulatedSqlException.ColumnReferenceNotAllowed(name));
             topCount = resolvedExpression is int unboxed ? unboxed : throw SimulatedSqlException.TopFetchRequiresInteger();
 
-            if (context.Token is not null and not CloseParentheses)
+            if (context.Token is not null and not Operator { Character: ')' })
                 throw SimulatedSqlException.SyntaxErrorNear(context.Token);
 
             context.MoveNextRequired();
@@ -57,10 +58,10 @@ public static Selection Parse(ParserContext context, uint depth)
 
             switch (context.Token)
             {
-                case Comma:
+                case Operator { Character: ',' }:
                     continue;
 
-                case CloseParentheses:
+                case Operator { Character: ')' }:
                     if (depth == 0)
                         throw SimulatedSqlException.SyntaxErrorNear(context.Token);
 
@@ -104,7 +105,7 @@ public static Selection Parse(ParserContext context, uint depth)
                                 }))]))
                                 ));
 
-                        case OpenParentheses:
+                        case Operator { Character: '(' }:
                             if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Select })
                                 throw SimulatedSqlException.SyntaxErrorNear(context.Token);
 

SqlServerSimulator/Parser/Tokenizer.cs

@@ -24,13 +24,7 @@ static class Tokenizer
             '@' => ParseAtOrDoubleAtPrefixedString(command, ref index),
             '-' => ParseMinusOrComment(command, ref index),
             '[' => ParseBracketDelimitedString(command, ref index),
-            '+' => new Plus(command, index),
-            '*' => new Asterisk(command, index),
-            '(' => new OpenParentheses(command, index),
-            ')' => new CloseParentheses(command, index),
-            ',' => new Comma(command, index),
-            '.' => new Period(command, index),
-            ';' => new StatementTerminator(command, index),
+            '+' or '*' or '(' or ')' or ',' or '.' or ';' => new Operator(command, index),
             var c => throw SimulatedSqlException.SyntaxErrorNear(c) // Might throw on valid-but-unsupported syntax.
         };
 
@@ -120,11 +114,11 @@ private static Token ParseMinusOrComment(string command, ref int index)
     {
         var start = index;
         if (++index == command.Length)
-            return new Minus(command, --index);
+            return new Operator(command, --index);
         if (command[index] != '-')
         {
             index--;
-            return new Minus(command, index);
+            return new Operator(command, index);
         }
 
         while (++index < command.Length)

SqlServerSimulator/Parser/Tokens/Asterisk.cs

@@ -0,0 +1,10 @@
+namespace SqlServerSimulator.Parser.Tokens;
+
+/// <summary>
+/// Represents any of the various single-character operators.
+/// </summary>
+/// <remarks>Multi-character operators use <see cref="ReservedKeyword"/>.</remarks>
+internal sealed class Operator(string command, int index) : Token(command, index, 1)
+{
+    public char Character => base.Source[0];
+}