Add tests for numeric promotions

Author: rameel

src/Ramstack.ExpressionParser/ExpressionBuilder.Helpers.cs

@@ -186,12 +186,28 @@ private static Expression ApplyBinaryExpression(Identifier op, Func<Expression,
         return result;
     }
 
-    //
-    // 12.4.7 Numeric promotions
-    // https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions#1247-numeric-promotions
-    //
     private static void ApplyBinaryNumericPromotions(Identifier op, ref Expression lhs, ref Expression rhs)
     {
+        //
+        // 12.4.7.3 Binary numeric promotions
+        // https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions#12473-binary-numeric-promotions
+        //
+        // Binary numeric promotion implicitly converts both operands to a common type which,
+        // in case of the non-relational operators, also becomes the result type of the operation.
+        // Binary numeric promotion consists of applying the following rules, in the order they appear here:
+        //
+        // * If either operand is of type decimal, the other operand is converted to type decimal,
+        //   or a binding-time error occurs if the other operand is of type float or double.
+        // * Otherwise, if either operand is of type double, the other operand is converted to type double.
+        // * Otherwise, if either operand is of type float, the other operand is converted to type float.
+        // * Otherwise, if either operand is of type ulong, the other operand is converted to type ulong,
+        //   or a binding-time error occurs if the other operand is of type sbyte, short, int, or long.
+        // * Otherwise, if either operand is of type long, the other operand is converted to type long.
+        // * Otherwise, if either operand is of type uint and the other operand is of type sbyte, short, or int,
+        //   both operands are converted to type long.
+        // * Otherwise, if either operand is of type uint, the other operand is converted to type uint.
+        // * Otherwise, both operands are converted to type int.
+
         var lhsType = lhs.Type;
         var rhsType = rhs.Type;
 
@@ -221,8 +237,10 @@ private static void ApplyBinaryNumericPromotions(Identifier op, ref Expression l
 
             if (conversionType == typeof(decimal))
             {
+                //
                 // If either operand is of type decimal, the other operand is converted to type decimal,
                 // or a compile-time error occurs if the other operand is of type float or double.
+                //
                 if (lhsType == typeof(double)
                     || lhsType == typeof(float)
                     || rhsType == typeof(double)
@@ -231,8 +249,10 @@ private static void ApplyBinaryNumericPromotions(Identifier op, ref Expression l
             }
             else if (conversionType == typeof(ulong))
             {
-                // if either operand is of type ulong, the other operand is converted to type ulong,
+                //
+                // If either operand is of type ulong, the other operand is converted to type ulong,
                 // or a compile-time error occurs if the other operand is of type sbyte, short, int, or long.
+                //
                 if (lhsType == typeof(sbyte)
                     || lhsType == typeof(short)
                     || lhsType == typeof(int)
@@ -245,8 +265,10 @@ private static void ApplyBinaryNumericPromotions(Identifier op, ref Expression l
             }
             else if (conversionType == typeof(uint))
             {
-                // if either operand is of type uint and the other operand is of type sbyte, short, or int,
+                //
+                // If either operand is of type uint and the other operand is of type sbyte, short, or int,
                 // both operands are converted to type long.
+                //
                 if (lhsType == typeof(sbyte)
                     || lhsType == typeof(short)
                     || lhsType == typeof(int)

src/Ramstack.ExpressionParser/ExpressionParser.Parser.cs

@@ -42,7 +42,8 @@ private static Parser<Expr> CreateParser()
             ).Void();
 
         var number_literal =
-            ConstantNumberParser.NumericLiteral
+            ConstantNumberParser
+                .NumericLiteral
                 .Do(Expr (v) => new Expr.Literal(v));
 
         var string_literal =
@@ -262,8 +263,8 @@ static Expr HijackMemberExpression(Expr result, Expr value)
     }
 
     private static Identifier CreateIdentifier(string v) =>
-        new(v);
+        new Identifier(v);
 
     private static Identifier CreateIdentifier(char v) =>
-        new(new string(v, 1));
+        new Identifier(v.ToString());
 }

tests/Rmastack.ExpressionParser.Tests/Data/Errors.txt

@@ -87,3 +87,46 @@ Ambiguous match found:\n    Char Chars [Int32] (in System.String)
 
 StringSplitOptions.None | StringComparison.Ordinal
 Operator '|' cannot be applied to operands of type 'System.StringSplitOptions' and 'System.StringComparison'.
+
+#######################################
+###### Binary Numeric Promotions ######
+#######################################
+
+#######################################
+# If either operand is of type decimal, a binding-time error occurs
+# if the other operand is of type float or double.
+
+1.0 + 2.0m
+Operator '+' cannot be applied to operands of type 'System.Double' and 'System.Decimal'.
+
+1.0m + 2.0d
+Operator '+' cannot be applied to operands of type 'System.Decimal' and 'System.Double'.
+
+1.0f + 2.0m
+Operator '+' cannot be applied to operands of type 'System.Single' and 'System.Decimal'.
+
+1.0m + 2.0f
+Operator '+' cannot be applied to operands of type 'System.Decimal' and 'System.Single'.
+
+#######################################
+# If either operand is of type ulong, a binding-time error occurs
+# if the other operand is of type sbyte, short, int, or long.
+
+1ul + 2:sbyte
+Operator '+' cannot be applied to operands of type 'System.UInt64' and 'System.SByte'.
+
+1ul + 2:short
+Operator '+' cannot be applied to operands of type 'System.UInt64' and 'System.Int16'.
+
+1ul + 2:int
+Operator '+' cannot be applied to operands of type 'System.UInt64' and 'System.Int32'.
+
+1ul + 2:long
+Operator '+' cannot be applied to operands of type 'System.UInt64' and 'System.Int64'.
+
+#######################################
+###### Unary Numeric Promotions  ######
+#######################################
+
+-1ul
+Unary operator '-' cannot be applied to operand of type 'System.UInt64'.