Refactor: move implicit operator lookup to TypeHelper.TryFindImplicitConversionOperator

Agent-Logs-Url: https://github.com/zzzprojects/System.Linq.Dynamic.Core/sessions/3d221836-ae46-4e82-b79f-a67b544ee3af

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

Author: Copilot

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

@@ -680,18 +680,7 @@ private Expression ParseComparisonOperator()
 
     private static bool HasImplicitConversion(Type baseType, Type targetType)
     {
-        var baseTypeHasConversion = baseType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
-            .Any(mi => mi.GetParameters().FirstOrDefault()?.ParameterType == baseType);
-
-        if (baseTypeHasConversion)
-        {
-            return true;
-        }
-
-        return targetType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-            .Where(mi => mi.Name == "op_Implicit" && mi.ReturnType == targetType)
-            .Any(mi => mi.GetParameters().FirstOrDefault()?.ParameterType == baseType);
+        return TypeHelper.TryFindImplicitConversionOperator(baseType, targetType, out _);
     }
 
     private static ConstantExpression ParseEnumToConstantExpression(int pos, Type leftType, ConstantExpression constantExpr)

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

@@ -1,6 +1,5 @@
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Linq;
 
 namespace System.Linq.Dynamic.Core.Parser;
 
@@ -137,25 +136,7 @@ public ExpressionPromoter(ParsingConfig config)
         }
 
         // Check for implicit conversion operators (op_Implicit) from returnType to type.
-        // Look for op_Implicit on the source type or the target type.
-        var implicitOperator =
-            returnType.GetMethods(BindingFlags.Public | BindingFlags.Static)
-                .FirstOrDefault(m =>
-                {
-                    if (m.Name != "op_Implicit" || m.ReturnType != type) return false;
-                    var parameters = m.GetParameters();
-                    return parameters.Length == 1 && parameters[0].ParameterType == returnType;
-                })
-            ??
-            type.GetMethods(BindingFlags.Public | BindingFlags.Static)
-                .FirstOrDefault(m =>
-                {
-                    if (m.Name != "op_Implicit" || m.ReturnType != type) return false;
-                    var parameters = m.GetParameters();
-                    return parameters.Length == 1 && parameters[0].ParameterType == returnType;
-                });
-
-        if (implicitOperator != null)
+        if (TypeHelper.TryFindImplicitConversionOperator(returnType, type, out _))
         {
             return Expression.Convert(sourceExpression, type);
         }

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

@@ -533,4 +533,32 @@ public static bool IsDictionary(Type? type)
             TryFindGenericType(typeof(IReadOnlyDictionary<,>), type, out _);
 #endif
     }
+
+    public static bool TryFindImplicitConversionOperator(Type sourceType, Type targetType, [NotNullWhen(true)] out MethodInfo? implicitOperator)
+    {
+        // Look for op_Implicit on the source type that converts sourceType -> targetType
+        implicitOperator = sourceType.GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .FirstOrDefault(m =>
+            {
+                if (m.Name != "op_Implicit" || m.ReturnType != targetType) return false;
+                var parameters = m.GetParameters();
+                return parameters.Length == 1 && parameters[0].ParameterType == sourceType;
+            });
+
+        if (implicitOperator != null)
+        {
+            return true;
+        }
+
+        // Look for op_Implicit on the target type that converts sourceType -> targetType
+        implicitOperator = targetType.GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .FirstOrDefault(m =>
+            {
+                if (m.Name != "op_Implicit" || m.ReturnType != targetType) return false;
+                var parameters = m.GetParameters();
+                return parameters.Length == 1 && parameters[0].ParameterType == sourceType;
+            });
+
+        return implicitOperator != null;
+    }
 }