Fix nullable IComparable types not working with relational operators (>, >=, <, <=)

When comparing two values of the same nullable type (e.g., Instant?) using relational
operators, the check for IComparable<> interface was done on the nullable type itself
(Nullable<T>), which doesn't directly implement IComparable<>. The fix uses
TypeHelper.GetNonNullableType() to get the underlying type first, so that if T
implements IComparable<T>, nullable T? also works correctly with relational operators.

Fixes: Operator '>' incompatible with operand types 'Instant?' and 'Instant?'

Agent-Logs-Url: https://github.com/zzzprojects/System.Linq.Dynamic.Core/sessions/b497145d-ba3d-430a-b608-eda596efffdd

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

Author: Copilot

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

@@ -607,7 +607,8 @@ private Expression ParseComparisonOperator()
                 bool typesAreSameAndImplementCorrectInterface = false;
                 if (left.Type == right.Type)
                 {
-                    var interfaces = left.Type.GetInterfaces().Where(x => x.GetTypeInfo().IsGenericType);
+                    var typeToCheck = TypeHelper.GetNonNullableType(left.Type);
+                    var interfaces = typeToCheck.GetInterfaces().Where(x => x.GetTypeInfo().IsGenericType);
                     if (isEquality)
                     {
                         typesAreSameAndImplementCorrectInterface = interfaces.Any(x => x.GetGenericTypeDefinition() == typeof(IEquatable<>));

test/System.Linq.Dynamic.Core.Tests/TypeConvertors/NodaTimeConverterTests.cs

@@ -158,6 +158,59 @@ public void FilterByNullableLocalDate_WithDynamicExpressionParser_CompareWithNul
             result.Should().HaveCount(numberOfEntities);
         }
 
+        private class EntityWithInstant
+        {
+            public Instant Timestamp { get; set; }
+            public Instant? TimestampNullable { get; set; }
+        }
+
+        [Theory]
+        [InlineData(">")]
+        [InlineData(">=")]
+        [InlineData("<")]
+        [InlineData("<=")]
+        public void FilterByInstant_WithRelationalOperator(string op)
+        {
+            // Arrange
+            var now = SystemClock.Instance.GetCurrentInstant();
+            var data = new List<EntityWithInstant>
+            {
+                new EntityWithInstant { Timestamp = now - Duration.FromHours(1) },
+                new EntityWithInstant { Timestamp = now },
+                new EntityWithInstant { Timestamp = now + Duration.FromHours(1) }
+            }.AsQueryable();
+
+            // Act
+            var result = data.Where($"Timestamp {op} @0", now).ToList();
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
+        [Theory]
+        [InlineData(">")]
+        [InlineData(">=")]
+        [InlineData("<")]
+        [InlineData("<=")]
+        public void FilterByNullableInstant_WithRelationalOperator(string op)
+        {
+            // Arrange
+            var now = SystemClock.Instance.GetCurrentInstant();
+            var data = new List<EntityWithInstant>
+            {
+                new EntityWithInstant { TimestampNullable = now - Duration.FromHours(1) },
+                new EntityWithInstant { TimestampNullable = now },
+                new EntityWithInstant { TimestampNullable = now + Duration.FromHours(1) },
+                new EntityWithInstant { TimestampNullable = null }
+            }.AsQueryable();
+
+            // Act
+            var result = data.Where($"TimestampNullable {op} @0", now).ToList();
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
         public class LocalDateConverter : TypeConverter
         {
             public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) => sourceType == typeof(string);