Fix enum type preservation in additive arithmetic operations (#976)

* Initial plan

* Fix: enum + int and int + enum now return enum type (C# semantics); enum - int returns enum type

Agent-Logs-Url: https://github.com/zzzprojects/System.Linq.Dynamic.Core/sessions/0cb2e89e-56b5-4db3-8850-f5013136f847

Co-authored-by: StefH <249938+StefH@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: StefH <249938+StefH@users.noreply.github.com>

Author: Copilot

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -766,14 +766,34 @@ private Expression ParseAdditive()
                     }
                     else
                     {
+                        var leftTypeForAdd = left.Type;
+                        var rightTypeForAdd = right.Type;
                         CheckAndPromoteOperands(typeof(IAddSignatures), op.Id, op.Text, ref left, ref right, op.Pos);
                         left = _expressionHelper.GenerateAdd(left, right);
+                        // C# semantics: enum + int = enum, int + enum = enum
+                        if (TypeHelper.IsEnumType(leftTypeForAdd) && TypeHelper.IsNumericType(rightTypeForAdd))
+                        {
+                            left = Expression.Convert(left, leftTypeForAdd);
+                        }
+                        else if (TypeHelper.IsNumericType(leftTypeForAdd) && TypeHelper.IsEnumType(rightTypeForAdd))
+                        {
+                            left = Expression.Convert(left, rightTypeForAdd);
+                        }
                     }
                     break;
 
                 case TokenId.Minus:
-                    CheckAndPromoteOperands(typeof(ISubtractSignatures), op.Id, op.Text, ref left, ref right, op.Pos);
-                    left = _expressionHelper.GenerateSubtract(left, right);
+                    {
+                        var leftTypeForSubtract = left.Type;
+                        var rightTypeForSubtract = right.Type;
+                        CheckAndPromoteOperands(typeof(ISubtractSignatures), op.Id, op.Text, ref left, ref right, op.Pos);
+                        left = _expressionHelper.GenerateSubtract(left, right);
+                        // C# semantics: enum - int = enum (but enum - enum = underlying int type)
+                        if (TypeHelper.IsEnumType(leftTypeForSubtract) && TypeHelper.IsNumericType(rightTypeForSubtract))
+                        {
+                            left = Expression.Convert(left, leftTypeForSubtract);
+                        }
+                    }
                     break;
             }
         }

test/System.Linq.Dynamic.Core.Tests/QueryableTests.Select.cs

@@ -224,8 +224,34 @@ public void Select_Dynamic_Add_Integer_And_DayOfWeekEnum()
             // Act
             var rangeResult = range.AsQueryable().Select("it + DayOfWeek.Monday");
 
-            // Assert
-            Assert.Equal(range.Select(x => x + DayOfWeek.Monday).Cast<int>().ToArray(), rangeResult.Cast<int>().ToArray());
+            // Assert - C# semantics: int + enum = enum
+            Assert.Equal(range.Select(x => x + DayOfWeek.Monday).ToArray(), rangeResult.Cast<DayOfWeek>().ToArray());
+        }
+
+        [Fact]
+        public void Select_Dynamic_Subtract_DayOfWeekEnum_And_Integer()
+        {
+            // Arrange
+            var range = new DayOfWeek[] { DayOfWeek.Tuesday };
+
+            // Act
+            var rangeResult = range.AsQueryable().Select("it - 1");
+
+            // Assert - C# semantics: enum - int = enum
+            Assert.Equal(range.Select(x => x - 1).ToArray(), rangeResult.Cast<DayOfWeek>().ToArray());
+        }
+
+        [Fact]
+        public void Select_Dynamic_Subtract_DayOfWeekEnum_And_DayOfWeekEnum()
+        {
+            // Arrange
+            var range = new DayOfWeek[] { DayOfWeek.Tuesday };
+
+            // Act
+            var rangeResult = range.AsQueryable().Select("it - DayOfWeek.Monday");
+
+            // Assert - C# semantics: enum - enum = underlying int type
+            Assert.Equal(range.Select(x => x - DayOfWeek.Monday).ToArray(), rangeResult.Cast<int>().ToArray());
         }
 
         [Fact]