NodaTime? [wip]

Author: StefH

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

@@ -2505,9 +2505,57 @@ private bool TryGetOverloadedImplicitOperator(TokenId tokenId, ref Expression le
         return overloadedImplicitOperatorFound;
     }
 
+    private bool TryGetOverloadedExplicitOperator(TokenId tokenId, ref Expression left, ref Expression right)
+    {
+        const string methodName = "op_Explicit";
+        //if (tokenId is not (TokenId.Ampersand or TokenId.DoubleAmpersand or TokenId.Bar or TokenId.DoubleBar))
+        //{
+        //    return false;
+        //}
+
+        Expression? expression = null;
+        var overloadedExplicitOperatorFound = false;
+
+        // Try to find the "op_Explicit" method on the left which takes the left as parameter and returns the type.
+        var leftType = left.Type;
+        var isNullableLeftType = TypeHelper.TryGetNonNullableType(leftType, out var nonNullableLeftType);
+        var args = new[] { left };
+        if (_methodFinder.FindMethod(leftType, methodName, true, ref expression, ref args, out var methodBaseLeft) > 0 && methodBaseLeft is MethodInfo methodInfoLeft && methodInfoLeft.ReturnType == nonNullableLeftType)
+        {
+            //if (isNullableLeftType)
+            //{
+            //    left = Expression.Convert(left, leftType);
+            //}
+            //left = Expression.Call(methodInfoLeft, left);
+
+            left = Expression.Convert(left, nonNullableLeftType, methodInfoLeft);
+
+            overloadedExplicitOperatorFound = true;
+        }
+
+        // Try to find the "op_Explicit" method on the right which takes the right as parameter and returns the type.
+        var rightType = right.Type;
+        var rightTypeIsNullable = TypeHelper.TryGetNonNullableType(rightType, out var nonNullableRightType);
+        var argsRight = new[] { right };
+        if (_methodFinder.FindMethod(rightType, methodName, true, ref expression, ref argsRight, out var methodBaseRight) > 0 && methodBaseRight is MethodInfo methodInfoRight && methodInfoRight.ReturnType == nonNullableRightType)
+        {
+            //if (rightTypeIsNullable)
+            //{
+            //    right = Expression.Convert(right, rightType);
+            //}
+            //right = Expression.Call(methodInfoRight, right);
+
+            right = Expression.Convert(right, nonNullableRightType, methodInfoRight);
+
+            overloadedExplicitOperatorFound = true;
+        }
+
+        return overloadedExplicitOperatorFound;
+    }
+
     private void CheckAndPromoteOperands(Type signatures, TokenId opId, string opName, ref Expression left, ref Expression right, int errorPos)
     {
-        Expression[] args = { left, right };
+        Expression[] args = [left, right];
 
         // 1. Try to find the Equality/Inequality operator
         // 2. Try to find the method with the given signature
@@ -2525,6 +2573,12 @@ private void CheckAndPromoteOperands(Type signatures, TokenId opId, string opNam
             return;
         }
 
+        // 4. Try to find the Explicit operator
+        if (TryGetOverloadedExplicitOperator(opId, ref left, ref right))
+        {
+            return;
+        }
+
         throw IncompatibleOperandsError(opName, left, right, errorPos);
     }
 

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

@@ -459,6 +459,18 @@ public static Type GetNonNullableType(Type type)
         return IsNullableType(type) ? type.GetTypeInfo().GetGenericTypeArguments()[0] : type;
     }
 
+    public static bool TryGetNonNullableType(Type type, [NotNullWhen(true)] out Type nullableType)
+    {
+        if (!IsNullableType(type))
+        {
+            nullableType = type;
+            return false;
+        }
+
+        nullableType = type.GetTypeInfo().GetGenericTypeArguments()[0];
+        return true;
+    }
+
     public static Type GetUnderlyingType(Type type)
     {
         Type[] genericTypeArguments = type.GetGenericArguments();