Tighten comments in float-like integer conversion guard and tests

Author: jhonabreul

src/embed_tests/TestFloatToIntConversion.cs

@@ -124,9 +124,7 @@ public void NonIntegralFloat_IsRejected(string func)
             Assert.AreEqual("TypeError", ex.Type.Name);
         }
 
-        // A float subclass (e.g. numpy.float64) follows the same rule as a plain
-        // float: integral values convert, fractional ones are rejected instead of
-        // being silently truncated through __int__.
+        // Float subclasses (e.g. numpy.float64) follow the plain-float rule.
         [TestCase("single_ctor_float_subclass")]
         [TestCase("overloaded_ctor_float_subclass")]
         public void IntegralFloatSubclass_IsAccepted(string func)
@@ -142,9 +140,7 @@ public void NonIntegralFloatSubclass_IsRejected(string func)
             Assert.AreEqual("TypeError", ex.Type.Name);
         }
 
-        // A number that defines __float__ but no __index__ (e.g. numpy.float32) is
-        // float-like: integral values convert, fractional ones are rejected instead
-        // of being silently truncated through __int__.
+        // __float__-only numbers (e.g. numpy.float32) follow the plain-float rule.
         [TestCase("single_ctor_float_like")]
         [TestCase("overloaded_ctor_float_like")]
         public void IntegralFloatLike_IsAccepted(string func)
@@ -160,8 +156,7 @@ public void NonIntegralFloatLike_IsRejected(string func)
             Assert.AreEqual("TypeError", ex.Type.Name);
         }
 
-        // A true integer type advertising __index__ (e.g. numpy.int64) is not
-        // float-like and keeps converting even though it also defines __float__.
+        // __index__ types (e.g. numpy.int64) are integers, not float-like.
         [Test]
         public void IndexLike_IsAccepted()
         {

src/runtime/Converter.cs

@@ -908,16 +908,13 @@ internal static int ToInt32(BorrowedReference value)
         }
 
         /// <summary>
-        /// Determines whether a Python value is a floating-point number: a Python
-        /// float (including subclasses such as numpy.float64) or a number that
-        /// defines a float conversion but no lossless integer conversion
-        /// (__float__ without __index__, e.g. numpy.float32). Integer values,
-        /// including bools and types with __index__ such as numpy.int64, are not
-        /// float-like.
+        /// True for Python floats (including subclasses like numpy.float64) and for
+        /// numbers with __float__ but no __index__ (like numpy.float32); __index__
+        /// marks a type as losslessly int-convertible, so those are not float-like.
         /// </summary>
         private static bool IsFloatLike(BorrowedReference value)
         {
-            // The common case for integer parameters is an actual int; exit fast.
+            // fast path for the common case: actual ints
             if (Runtime.PyInt_Check(value) || Runtime.PyBool_Check(value))
             {
                 return false;
@@ -943,20 +940,14 @@ internal static bool ToPrimitive(BorrowedReference value, Type obType, out objec
 
             TypeCode tc = Type.GetTypeCode(obType);
 
-            // A float-like value with a fractional part must not be silently truncated
-            // into an integer parameter. Integral-valued ones (e.g. 5.0) are still
-            // accepted. Besides Python floats this covers float subclasses such as
-            // numpy.float64 and __float__-only numbers such as numpy.float32, which
-            // would otherwise be truncated below through PyNumber_Long/__int__.
-            // 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.
+            // Reject non-integral float-like values (incl. numpy floats) for integer
+            // targets; the PyNumber_Long path below would silently truncate them.
             if (tc.IsInteger() && IsFloatLike(value))
             {
                 double dbl = Runtime.PyFloat_AsDouble(value);
                 if (dbl == -1.0 && Exceptions.ErrorOccurred())
                 {
-                    // __float__ itself failed; don't let the probe error leak
+                    // don't let a failed __float__ probe leak
                     Exceptions.Clear();
                     goto type_error;
                 }

tests/test_conversion.py

@@ -268,9 +268,7 @@ def test_int64_conversion():
 
 
 def test_numpy_float_to_int_conversion():
-    """A numpy float with a fractional value is rejected for integer targets
-    instead of being silently truncated; integral-valued numpy floats convert.
-    Numpy integer scalars are unaffected."""
+    """Non-integral numpy floats are rejected for integer targets, not truncated."""
     np = pytest.importorskip("numpy")
 
     ob = ConversionTest()