Accept integral-valued floats for integer parameters, reject non-integral

Passing a Python float where a .NET integer parameter was expected behaved
inconsistently:

- Single-overload targets silently truncated any float (e.g. 5.5 -> 5) via
  Converter.ToManaged.
- Overloaded targets rejected every float, including integral-valued ones
  (e.g. 5.0), with "No method matches given arguments" because the overload
  disambiguation path did not treat float->int as a valid conversion. This
  broke calls like RangeConsolidator(period) in Lean when period was a float.

Make both paths consistent: an integral-valued float (5.0) is accepted and
converted for integer parameters, while a non-integral float (5.5) is
rejected with a TypeError instead of being silently truncated.

- MethodBinder: treat integral Python floats as implicit-conversion candidates
  for integer parameters (enums excluded).
- Converter.ToPrimitive: reject non-integral Python floats targeting integer
  types so truncation never happens silently.
- Add a shared Type.IsInteger() helper in Util and use it in both places.
- Add TestFloatToIntConversion covering single and overloaded ctor/method.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jhonabreul

src/embed_tests/TestFloatToIntConversion.cs

@@ -0,0 +1,117 @@
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    /// <summary>
+    /// Passing a Python float where a .NET integer is expected.
+    ///
+    /// A float that holds an integral value (e.g. 5.0) is accepted and converted;
+    /// a non-integral float (e.g. 5.5) is rejected rather than silently truncated.
+    /// This must hold regardless of whether the target method/constructor has a
+    /// single signature or several overloads (the latter reproduces Lean's
+    /// RangeConsolidator(period), which has two int-first constructor overloads).
+    /// </summary>
+    public class TestFloatToIntConversion
+    {
+        private PyModule _module;
+
+        private const string TestModule = @"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+from Python.EmbeddingTest import IntTaker, OverloadedIntTaker
+
+def single_ctor(value):
+    return IntTaker(value).Value
+
+def single_method(value):
+    return IntTaker(0).Echo(value)
+
+def overloaded_ctor(value):
+    return OverloadedIntTaker(value).Value
+
+def overloaded_method(value):
+    return OverloadedIntTaker(0).Echo(value)
+";
+
+        [OneTimeSetUp]
+        public void Setup()
+        {
+            PythonEngine.Initialize();
+            _module = PyModule.FromString("float_to_int_module", TestModule);
+        }
+
+        [OneTimeTearDown]
+        public void TearDown()
+        {
+            _module.Dispose();
+            PythonEngine.Shutdown();
+        }
+
+        private int Call(string func, double value)
+        {
+            using (Py.GIL())
+            using (var arg = value.ToPython())
+            {
+                return _module.InvokeMethod(func, arg).As<int>();
+            }
+        }
+
+        // An integral-valued float is accepted and converted, single or overloaded.
+        [TestCase("single_ctor")]
+        [TestCase("single_method")]
+        [TestCase("overloaded_ctor")]
+        [TestCase("overloaded_method")]
+        public void IntegralFloat_IsAccepted(string func)
+        {
+            Assert.AreEqual(5, Call(func, 5.0));
+        }
+
+        // A non-integral float is rejected (no silent truncation) for every target.
+        [TestCase("single_ctor")]
+        [TestCase("single_method")]
+        [TestCase("overloaded_ctor")]
+        [TestCase("overloaded_method")]
+        public void NonIntegralFloat_IsRejected(string func)
+        {
+            var ex = Assert.Throws<PythonException>(() => Call(func, 5.5));
+            Assert.AreEqual("TypeError", ex.Type.Name);
+        }
+    }
+
+    public class IntTaker
+    {
+        public int Value { get; }
+
+        public IntTaker(int value)
+        {
+            Value = value;
+        }
+
+        public int Echo(int value) => value;
+    }
+
+    /// <summary>
+    /// Mimics Lean's RangeConsolidator: two overloads that both take an int first
+    /// parameter, differing only in the (defaulted) later parameters. This forces the
+    /// binder through its overload-disambiguation path.
+    /// </summary>
+    public class OverloadedIntTaker
+    {
+        public int Value { get; }
+
+        public OverloadedIntTaker(int range, System.Func<int, int> selector = null)
+        {
+            Value = range;
+        }
+
+        public OverloadedIntTaker(int range, PyObject selector, PyObject volumeSelector = null)
+        {
+            Value = range;
+        }
+
+        public int Echo(int value, System.Func<int, int> selector = null) => value;
+
+        public int Echo(int value, PyObject selector, PyObject other = null) => value;
+    }
+}

src/runtime/Converter.cs

@@ -895,6 +895,20 @@ internal static bool ToPrimitive(BorrowedReference value, Type obType, out objec
 
             TypeCode tc = Type.GetTypeCode(obType);
 
+            // A Python float with a fractional part must not be silently truncated
+            // into an integer parameter. Integral-valued floats (e.g. 5.0) are still
+            // accepted. This keeps single- and multi-overload binding consistent:
+            // MethodBinder only treats integral floats as candidates for integer
+            // parameters, and this guard enforces the same rule at conversion time.
+            if (obType.IsInteger() && Runtime.PyFloat_Check(value))
+            {
+                double dbl = Runtime.PyFloat_AsDouble(value);
+                if (double.IsNaN(dbl) || double.IsInfinity(dbl) || Math.Truncate(dbl) != dbl)
+                {
+                    goto type_error;
+                }
+            }
+
             switch (tc)
             {
                 case TypeCode.Object:

src/runtime/MethodBinder.cs

@@ -679,6 +679,19 @@ internal Binding Bind(BorrowedReference inst, BorrowedReference args, BorrowedRe
                                                 implicitConversions++;
                                             }
                                         }
+                                        // accepts integral-valued Python floats (e.g. 5.0) for integer
+                                        // parameters. Converter.ToManaged rejects non-integral floats
+                                        // (e.g. 5.5) so we don't silently truncate. Enums are excluded
+                                        // on purpose.
+                                        else if (Runtime.PyFloat_Check(op) && underlyingType.IsInteger() && !underlyingType.IsEnum)
+                                        {
+                                            clrtype = parameter.ParameterType;
+                                            typematch = Converter.ToManaged(op, clrtype, out arg, false);
+                                            if (typematch)
+                                            {
+                                                implicitConversions++;
+                                            }
+                                        }
                                         if (!typematch)
                                         {
                                             // this takes care of implicit conversions

src/runtime/Util/Util.cs

@@ -303,5 +303,28 @@ public static bool IsDelegate(this Type type)
         {
             return type.IsSubclassOf(typeof(Delegate));
         }
+
+        /// <summary>
+        /// Determines whether the specified type is a CLR integer type (signed or unsigned).
+        /// Enums report an integral <see cref="TypeCode"/> too, so callers that want to
+        /// exclude them must check <see cref="Type.IsEnum"/> separately.
+        /// </summary>
+        public static bool IsInteger(this Type type)
+        {
+            switch (Type.GetTypeCode(type))
+            {
+                case TypeCode.Byte:
+                case TypeCode.SByte:
+                case TypeCode.Int16:
+                case TypeCode.UInt16:
+                case TypeCode.Int32:
+                case TypeCode.UInt32:
+                case TypeCode.Int64:
+                case TypeCode.UInt64:
+                    return true;
+                default:
+                    return false;
+            }
+        }
     }
 }