Parser advance-then-pass pattern simplified via helper function.

Author: RyanLamansky

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -16,10 +16,8 @@ private protected BooleanExpression(Expression left, Expression right)
     }
 
     private protected BooleanExpression(Expression left, ParserContext context)
+        : this(left, Expression.Parse(context.MoveNextRequiredReturnSelf()))
     {
-        this.left = left;
-        context.MoveNextRequired();
-        this.right = Expression.Parse(context);
     }
 
     public static BooleanExpression Parse(Expression left, ParserContext context) => context.Token switch

SqlServerSimulator/Parser/Expression.cs

@@ -34,38 +34,18 @@ private protected Expression()
     /// <exception cref="NotSupportedException">A condition was encountered that may be valid but can't currently be parsed.</exception>
     public static Expression Parse(ParserContext context)
     {
-        Expression expression;
-
-        switch (context.Token)
+        var expression = context.Token switch
         {
-            case Numeric number:
-                expression = new Value(number.Value);
-                break;
-            case AtPrefixedString atPrefixed:
-                expression = new Value(atPrefixed, context);
-                break;
-            case DoubleAtPrefixedString doubleAtPrefixedString:
-                expression = new Value(doubleAtPrefixedString);
-                break;
-            case ReservedKeyword { Keyword: Keyword.Null }:
-                expression = new Value();
-                break;
-            case Name name:
-                expression = new Reference(name);
-                break;
-            case Operator { Character: '+' }:
-                context.MoveNextRequired();
-                expression = Expression.Parse(context);
-                break;
-            case Operator { Character: '-' }:
-                expression = new Subtract(new Value(new DataValue(0, DataType.BuiltInDbInt32)), context);
-                break;
-            case Operator { Character: '(' }:
-                expression = new Parenthesized(context);
-                break;
-            default:
-                throw SimulatedSqlException.SyntaxErrorNear(context);
-        }
+            Numeric number => new Value(number.Value),
+            AtPrefixedString atPrefixed => new Value(atPrefixed, context),
+            DoubleAtPrefixedString doubleAtPrefixedString => new Value(doubleAtPrefixedString),
+            ReservedKeyword { Keyword: Keyword.Null } => new Value(),
+            Name name => new Reference(name),
+            Operator { Character: '+' } => Expression.Parse(context.MoveNextRequiredReturnSelf()),
+            Operator { Character: '-' } => new Subtract(new Value(new DataValue(0, DataType.BuiltInDbInt32)), context),
+            Operator { Character: '(' } => new Parenthesized(context),
+            _ => throw SimulatedSqlException.SyntaxErrorNear(context)
+        };
 
         while (true)
         {

SqlServerSimulator/Parser/Expressions/Parenthesized.cs

@@ -3,15 +3,9 @@
 /// <summary>
 /// An expression that's wrapped in parentheses, potentially affecting the order of operations.
 /// </summary>
-internal sealed class Parenthesized : Expression
+internal sealed class Parenthesized(ParserContext context) : Expression
 {
-    private readonly Expression wrapped;
-
-    public Parenthesized(ParserContext context)
-    {
-        context.MoveNextRequired();
-        this.wrapped = Parse(context);
-    }
+    private readonly Expression wrapped = Parse(context.MoveNextRequiredReturnSelf());
 
     public override DataValue Run(Func<List<string>, DataValue> getColumnValue) => wrapped.Run(getColumnValue);
 

SqlServerSimulator/Parser/Expressions/TwoSidedExpression.cs

@@ -1,16 +1,8 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal abstract class TwoSidedExpression : Expression
+internal abstract class TwoSidedExpression(Expression left, ParserContext context) : Expression
 {
-    private Expression left, right;
-
-    public TwoSidedExpression(Expression left, ParserContext context)
-    {
-        this.left = left;
-
-        context.MoveNextRequired();
-        this.right = Parse(context);
-    }
+    private Expression left = left, right = Parse(context.MoveNextRequiredReturnSelf());
 
     public TwoSidedExpression AdjustForPrecedence()
     {

SqlServerSimulator/Parser/ParserContext.cs

@@ -64,7 +64,6 @@ public void MoveNextOptional()
 
     /// <summary>
     /// Returns the next token in the enumeration, or null.
-    /// Also updates <see cref="Token"/> to the new value.
     /// </summary>
     /// <returns>The next token if the enumerator was advanced, otherwise null.</returns>
     public Token? GetNextOptional()
@@ -74,7 +73,6 @@ public void MoveNextOptional()
 
     /// <summary>
     /// Returns the next token in the enumeration, throwing an exception if the end was reached instead.
-    /// Also updates <see cref="Token"/> to the new value.
     /// </summary>
     /// <returns>The next token.</returns>
     /// <exception cref="SimulatedSqlException">Incorrect syntax near '{token}'.</exception>
@@ -86,7 +84,6 @@ public Token GetNextRequired()
 
     /// <summary>
     /// Returns the next token in the enumeration, throwing an exception if the end was reached instead or the token is the wrong type.
-    /// Also updates <see cref="Token"/> to the new value.
     /// </summary>
     /// <typeparam name="T">The expected type of the new token.</typeparam>
     /// <returns>The next token.</returns>
@@ -100,17 +97,15 @@ public T GetNextRequired<T>()
     }
 
     /// <summary>
-    /// Advances <see cref="Token"/> to the next token in the enumeration, throwing an exception if the end was reached instead or the token is the wrong type.
+    /// Advances <see cref="Token"/> to the next token in the enumeration, throwing an exception if the end was reached instead.
+    /// The <see cref="ParserContext"/> used for this call is returned.
     /// </summary>
-    /// <typeparam name="T">The expected type of the new token.</typeparam>
+    /// <returns>This instance.</returns>
     /// <exception cref="SimulatedSqlException">Incorrect syntax near '{token}'.</exception>
-    public void MoveNextRequired<T>()
-        where T : Token
+    public ParserContext MoveNextRequiredReturnSelf()
     {
-        var previous = this.Token;
-
-        if (!MoveNext() || this.Token is not T)
-            throw SimulatedSqlException.SyntaxErrorNear(previous);
+        this.MoveNextRequired();
+        return this;
     }
 
     /// <summary>

SqlServerSimulator/Parser/Selection.cs

@@ -21,15 +21,13 @@ internal sealed class Selection
     /// <exception cref="NotSupportedException">A condition was encountered that may be valid but can't currently be parsed.</exception>
     public static Selection Parse(ParserContext context, uint depth)
     {
-        context.MoveNextRequired();
-
         int? topCount = null;
 
-        if (context.Token is ReservedKeyword { Keyword: Keyword.Top })
+        if (context.GetNextRequired() is ReservedKeyword { Keyword: Keyword.Top })
         {
-            context.MoveNextRequired();
-
-            var resolvedExpression = Expression.Parse(context).Run(name => throw SimulatedSqlException.ColumnReferenceNotAllowed(name));
+            var resolvedExpression = Expression
+                .Parse(context.MoveNextRequiredReturnSelf())
+                .Run(name => throw SimulatedSqlException.ColumnReferenceNotAllowed(name));
             topCount = resolvedExpression.Value is int unboxed ? unboxed : throw SimulatedSqlException.TopFetchRequiresInteger();
         }
 
@@ -157,8 +155,7 @@ [.. expressions.Select(x => x.Run(columnName => getColumnValueFromRow(row, colum
                     throw SimulatedSqlException.SyntaxErrorNear(context);
 
                 case ReservedKeyword { Keyword: Keyword.Where }:
-                    context.MoveNextRequired();
-                    excluders.Add(BooleanExpression.Parse(Expression.Parse(context), context));
+                    excluders.Add(BooleanExpression.Parse(Expression.Parse(context.MoveNextRequiredReturnSelf()), context));
                     continue;
             }
 

SqlServerSimulator/Simulation.cs

@@ -66,8 +66,7 @@ internal IEnumerable<SimulatedStatementOutcome> CreateResultSetsForCommand(Simul
 
                                 var nullable = true;
 
-                                context.MoveNextRequired();
-                                if (context.Token is ReservedKeyword next)
+                                if (context.GetNextRequired() is ReservedKeyword next)
                                 {
                                     switch (next.Keyword)
                                     {