Fix IndexOutOfRangeException with implicit conversion operator from base/abstract class param

Agent-Logs-Url: https://github.com/dadhi/FastExpressionCompiler/sessions/82c35acc-2d27-4de0-9359-3eb4a7da07c8

Co-authored-by: dadhi <39516+dadhi@users.noreply.github.com>

Author: Copilot

src/FastExpressionCompiler/FastExpressionCompiler.cs

@@ -3205,10 +3205,13 @@ private static bool TryEmitConvert(UnaryExpression expr, ILGenerator il, ref Com
                         EmitStoreAndLoadLocalVariableAddress(il, sourceType);
                         EmitMethodCall(il, sourceType.GetNullableValueGetterMethod());
                     }
-                    else if (methodParamType != sourceType) // This is an unlikely case of Target(Source? source)
+                    else if (methodParamType != sourceType) // This is an unlikely case of Target(Source? source), or a polymorphic base type
                     {
-                        Debug.Assert(Nullable.GetUnderlyingType(methodParamType) == sourceType, "Expecting that the parameter type is the Nullable<sourceType>");
-                        il.Demit(OpCodes.Newobj, methodParamType.GetNullableConstructor());
+                        if (Nullable.GetUnderlyingType(methodParamType) == sourceType)
+                            il.Demit(OpCodes.Newobj, methodParamType.GetNullableConstructor());
+                        // else: methodParamType is a base type/interface of sourceType - the value on the stack is already assignment-compatible, no additional emit needed
+                        else Debug.Assert(methodParamType.IsAssignableFrom(sourceType),
+                            $"Expected the conversion operator parameter type `{methodParamType}` to be either Nullable<{sourceType}> or a base type of `{sourceType}`");
                     }
 
                     EmitMethodCallOrVirtualCall(il, convertMethod);

test/FastExpressionCompiler.IssueTests/Issue500_IndexOutOfRangeException_with_value_objects_implicit_conversions.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Reflection;
+
+#if LIGHT_EXPRESSION
+using static FastExpressionCompiler.LightExpression.Expression;
+namespace FastExpressionCompiler.LightExpression.IssueTests;
+#else
+using System.Linq.Expressions;
+using static System.Linq.Expressions.Expression;
+namespace FastExpressionCompiler.IssueTests;
+#endif
+
+public class Issue500_IndexOutOfRangeException_with_value_objects_implicit_conversions : ITest
+{
+    public int Run()
+    {
+        Implicit_conv_op_via_abstract_base_class_param_in_closure();
+        Implicit_conv_op_via_non_abstract_base_class_param_in_closure();
+        Implicit_conv_op_via_abstract_base_class_param_directly();
+        return 3;
+    }
+
+    public abstract class PrimitiveValueObject<TInput, TOutput>
+    {
+        public TInput Value { get; protected set; } = default!;
+
+        public static implicit operator TInput(PrimitiveValueObject<TInput, TOutput>? primitiveValueObject) =>
+            primitiveValueObject == null ? default! : primitiveValueObject.Value;
+    }
+
+    public class MyPrimitive : PrimitiveValueObject<string, MyPrimitive>
+    {
+        public MyPrimitive(string val) => Value = val;
+    }
+
+    // Reproduces the original issue: implicit conversion operator on an abstract base class
+    // used within a closure-captured variable wrapped in Convert(..., typeof(object))
+    public void Implicit_conv_op_via_abstract_base_class_param_in_closure()
+    {
+        var captured = new MyPrimitive("Hello world");
+
+        // Expression with implicit conversion on closure-captured variable
+        System.Linq.Expressions.Expression<Func<string>> sysExpr = () => captured;
+#if LIGHT_EXPRESSION
+        var innerExpr = sysExpr.FromSysExpression();
+#else
+        var innerExpr = sysExpr;
+#endif
+
+        // Wrap in Convert to object (common pattern in LINQ providers)
+        var toObject = Convert(innerExpr.Body, typeof(object));
+        var lambda = Lambda<Func<object>>(toObject);
+
+        lambda.PrintCSharp();
+
+        var fs = lambda.CompileSys();
+        Asserts.AreEqual("Hello world", (string)fs());
+
+        var ff = lambda.CompileFast(true);
+        Asserts.AreEqual("Hello world", (string)ff());
+    }
+
+    public class NonAbstractBase<TInput, TOutput>
+    {
+        public TInput Value { get; protected set; } = default!;
+
+        public static implicit operator TInput(NonAbstractBase<TInput, TOutput>? obj) =>
+            obj == null ? default! : obj.Value;
+    }
+
+    public class DerivedPrimitive : NonAbstractBase<string, DerivedPrimitive>
+    {
+        public DerivedPrimitive(string val) => Value = val;
+    }
+
+    // Same case but with a non-abstract base class (previously caused InvalidProgramException)
+    public void Implicit_conv_op_via_non_abstract_base_class_param_in_closure()
+    {
+        var captured = new DerivedPrimitive("Hello world");
+
+        System.Linq.Expressions.Expression<Func<string>> sysExpr = () => captured;
+#if LIGHT_EXPRESSION
+        var innerExpr = sysExpr.FromSysExpression();
+#else
+        var innerExpr = sysExpr;
+#endif
+
+        var toObject = Convert(innerExpr.Body, typeof(object));
+        var lambda = Lambda<Func<object>>(toObject);
+
+        lambda.PrintCSharp();
+
+        var fs = lambda.CompileSys();
+        Asserts.AreEqual("Hello world", (string)fs());
+
+        var ff = lambda.CompileFast(true);
+        Asserts.AreEqual("Hello world", (string)ff());
+    }
+
+    // Same conversion but with a direct (non-closure) parameter; the method must be passed explicitly
+    // because the derived class does not directly declare the static op_Implicit (it is on the base class).
+    public void Implicit_conv_op_via_abstract_base_class_param_directly()
+    {
+        var param = Parameter(typeof(MyPrimitive), "p");
+
+        // Get the op_Implicit method declared on the abstract base class
+        var opImplicit = typeof(PrimitiveValueObject<string, MyPrimitive>)
+            .GetMethod("op_Implicit", BindingFlags.Public | BindingFlags.Static);
+        Asserts.IsNotNull(opImplicit);
+
+        // Convert MyPrimitive -> string via op_Implicit (which takes PrimitiveValueObject<string,MyPrimitive>)
+        // then Convert string -> object
+        var toObject = Convert(Convert(param, typeof(string), opImplicit), typeof(object));
+        var lambda = Lambda<Func<MyPrimitive, object>>(toObject, param);
+
+        lambda.PrintCSharp();
+
+        var fs = lambda.CompileSys();
+        Asserts.AreEqual("Hello world", (string)fs(new MyPrimitive("Hello world")));
+
+        var ff = lambda.CompileFast(true);
+        Asserts.AreEqual("Hello world", (string)ff(new MyPrimitive("Hello world")));
+    }
+}

test/FastExpressionCompiler.TestsRunner/Program.cs

@@ -429,6 +429,9 @@ void Run(Func<int> run, string name = null)
                 Run(new Issue461_InvalidProgramException_when_null_checking_type_by_ref().Run);
                 Run(new LightExpression.IssueTests.Issue461_InvalidProgramException_when_null_checking_type_by_ref().Run);
 
+                Run(new Issue500_IndexOutOfRangeException_with_value_objects_implicit_conversions().Run);
+                Run(new LightExpression.IssueTests.Issue500_IndexOutOfRangeException_with_value_objects_implicit_conversions().Run);
+
                 Console.WriteLine($"{Environment.NewLine}//IssueTests are passing in {sw.ElapsedMilliseconds} ms.");
             });