Moved repeated expression parsing logic to a central location.

Author: RyanLamansky

SqlServerSimulator/Parser/Expression.cs

@@ -58,13 +58,10 @@ public static Expression Parse(ParserContext context)
                 expression = Expression.Parse(context);
                 break;
             case Operator { Character: '-' }:
-                context.MoveNextRequired();
-                expression = Parse(context);
-                expression = new Subtract(new Value(new DataValue(0, DataType.BuiltInDbInt32)), expression);
+                expression = new Subtract(new Value(new DataValue(0, DataType.BuiltInDbInt32)), context);
                 break;
             case Operator { Character: '(' }:
-                context.MoveNextRequired();
-                expression = new Parenthesized(Parse(context));
+                expression = new Parenthesized(context);
                 break;
             default:
                 throw SimulatedSqlException.SyntaxErrorNear(context);
@@ -75,36 +72,28 @@ public static Expression Parse(ParserContext context)
             switch (context.GetNextOptional())
             {
                 case Operator { Character: '+' }:
-                    context.MoveNextRequired();
-                    expression = new Add(expression, Parse(context));
+                    expression = new Add(expression, context);
                     break;
                 case Operator { Character: '-' }:
-                    context.MoveNextRequired();
-                    expression = new Subtract(expression, Parse(context));
+                    expression = new Subtract(expression, context);
                     break;
                 case Operator { Character: '*' }:
-                    context.MoveNextRequired();
-                    expression = new Multiply(expression, Parse(context));
+                    expression = new Multiply(expression, context);
                     break;
                 case Operator { Character: '/' }:
-                    context.MoveNextRequired();
-                    expression = new Divide(expression, Parse(context));
+                    expression = new Divide(expression, context);
                     break;
                 case Operator { Character: '%' }:
-                    context.MoveNextRequired();
-                    expression = new Modulus(expression, Parse(context));
+                    expression = new Modulus(expression, context);
                     break;
                 case Operator { Character: '&' }:
-                    context.MoveNextRequired();
-                    expression = new BitwiseAnd(expression, Parse(context));
+                    expression = new BitwiseAnd(expression, context);
                     break;
                 case Operator { Character: '|' }:
-                    context.MoveNextRequired();
-                    expression = new BitwiseOr(expression, Parse(context));
+                    expression = new BitwiseOr(expression, context);
                     break;
                 case Operator { Character: '^' }:
-                    context.MoveNextRequired();
-                    expression = new BitwiseExclusiveOr(expression, Parse(context));
+                    expression = new BitwiseExclusiveOr(expression, context);
                     break;
 
                 case Operator { Character: '.' }:
@@ -120,10 +109,7 @@ public static Expression Parse(ParserContext context)
                 case Operator { Character: '(' }:
                     {
                         if (expression is not Reference reference)
-                        {
-                            expression = new Parenthesized(Parse(context));
                             break;
-                        }
 
                         context.MoveNextRequired(); // Move past (
                         expression = ResolveBuiltIn(reference.Name, context);

SqlServerSimulator/Parser/Expressions/Add.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class Add(Expression left, Expression right) : MathExpression(left, right)
+internal sealed class Add(Expression left, ParserContext context) : MathExpression(left, context)
 {
     public override byte Precedence => 3;
 

SqlServerSimulator/Parser/Expressions/BitwiseAnd.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class BitwiseAnd(Expression left, Expression right) : BitwiseExpression(left, right)
+internal sealed class BitwiseAnd(Expression left, ParserContext context) : BitwiseExpression(left, context)
 {
     public override byte Precedence => 3;
 

SqlServerSimulator/Parser/Expressions/BitwiseExclusiveOr.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class BitwiseExclusiveOr(Expression left, Expression right) : BitwiseExpression(left, right)
+internal sealed class BitwiseExclusiveOr(Expression left, ParserContext context) : BitwiseExpression(left, context)
 {
     public override byte Precedence => 3;
 

SqlServerSimulator/Parser/Expressions/BitwiseExpression.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal abstract class BitwiseExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
+internal abstract class BitwiseExpression(Expression left, ParserContext context) : TwoSidedExpression(left, context)
 {
     protected abstract DataValue Run(DataType.BitwiseCompatibleDataType common, DataValue left, DataValue right);
 

SqlServerSimulator/Parser/Expressions/BitwiseOr.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class BitwiseOr(Expression left, Expression right) : BitwiseExpression(left, right)
+internal sealed class BitwiseOr(Expression left, ParserContext context) : BitwiseExpression(left, context)
 {
     public override byte Precedence => 3;
 

SqlServerSimulator/Parser/Expressions/Divide.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class Divide(Expression left, Expression right) : MathExpression(left, right)
+internal sealed class Divide(Expression left, ParserContext context) : MathExpression(left, context)
 {
     public override byte Precedence => 2;
 

SqlServerSimulator/Parser/Expressions/MathExpression.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal abstract class MathExpression(Expression left, Expression right) : TwoSidedExpression(left, right)
+internal abstract class MathExpression(Expression left, ParserContext context) : TwoSidedExpression(left, context)
 {
     protected abstract DataValue Run(DataType.NumericCompatibleDataType common, DataValue left, DataValue right);
 

SqlServerSimulator/Parser/Expressions/Modulus.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class Modulus(Expression left, Expression right) : MathExpression(left, right)
+internal sealed class Modulus(Expression left, ParserContext context) : MathExpression(left, context)
 {
     public override byte Precedence => 3;
 

SqlServerSimulator/Parser/Expressions/Multiply.cs

@@ -1,6 +1,6 @@
 namespace SqlServerSimulator.Parser.Expressions;
 
-internal sealed class Multiply(Expression left, Expression right) : MathExpression(left, right)
+internal sealed class Multiply(Expression left, ParserContext context) : MathExpression(left, context)
 {
     public override byte Precedence => 2;