Merge upstream/master into bug-attribute-suggestion-quality

Keeps the Jaro-Winkler scoring from this branch in ClassBase while
retaining Util.LevenshteinDistance, which MethodBinder's unexpected-kwarg
suggestion (#144) still uses.

Also moves the DiagnoseClosestOverloadMismatch block inside the
bind-failure try so master compiles again: #144 wrapped the message
construction (including the candidates declaration) in try/catch after
#145 had added the mismatch diagnosis below it, leaving 'candidates' out
of scope at its use site.

Author: jhonabreul

src/embed_tests/TestBindFailureDiagnosis.cs

@@ -0,0 +1,109 @@
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    /// <summary>
+    /// The bind-failure TypeError must pinpoint the first argument that fails to
+    /// match the nearest overload.
+    /// </summary>
+    public class TestBindFailureDiagnosis
+    {
+        public class OrdersTarget
+        {
+            public string PlaceOrder(string symbol, decimal quantity, bool asynchronous = false, string tag = "", int depth = 0) => "decimal";
+            public string PlaceOrder(string symbol, int quantity, bool asynchronous = false, string tag = "", int depth = 0) => "int";
+        }
+
+        public class SingleOverloadTarget
+        {
+            public int Compute(int periods) => periods;
+        }
+
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        private static string TypeErrorMessageOf(string call)
+        {
+            using var _ = Py.GIL();
+            var module = PyModule.FromString("TestBindFailureDiagnosis_" + TestContext.CurrentContext.Test.Name, $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+AddReference(""System"")
+
+from Python.EmbeddingTest import *
+
+def get_error():
+    target = TestBindFailureDiagnosis.OrdersTarget()
+    single = TestBindFailureDiagnosis.SingleOverloadTarget()
+    try:
+        {call}
+    except TypeError as e:
+        return str(e)
+    return None
+");
+            using var result = module.GetAttr("get_error").Invoke();
+            Assert.IsFalse(result.IsNone(), "expected the call to raise a TypeError");
+            return result.As<string>();
+        }
+
+        [Test]
+        public void PinpointsFirstMismatchedPositionalArgument()
+        {
+            var message = TypeErrorMessageOf("target.place_order('SPY', -10, 'exit signal')");
+
+            Assert.That(message, Does.StartWith("No method matches given arguments for place_order: "));
+            Assert.That(message, Does.Contain("The following overloads are available:"));
+            Assert.That(message, Does.Contain("Argument mismatch: argument 3 ('asynchronous') expected bool, got str."));
+        }
+
+        [Test]
+        public void PinpointsMismatchedKeywordArgument()
+        {
+            var message = TypeErrorMessageOf("target.place_order('SPY', 10, tag=5)");
+
+            Assert.That(message, Does.Contain("Argument mismatch: keyword argument 'tag' expected str, got int."));
+        }
+
+        [Test]
+        public void PinpointsMismatchOnSingleOverloadMethods()
+        {
+            var message = TypeErrorMessageOf("single.compute('abc')");
+
+            Assert.That(message, Does.Contain("The expected signature is:"));
+            Assert.That(message, Does.Contain("Argument mismatch: argument 1 ('periods') expected int, got str."));
+        }
+
+        [Test]
+        public void SkipsDiagnosisWhenAllGivenArgumentsMatch()
+        {
+            // Pure arity failure: no mismatched argument to single out.
+            var message = TypeErrorMessageOf("single.compute(1, 2)");
+
+            Assert.That(message, Does.Contain("No method matches given arguments for compute"));
+            Assert.That(message, Does.Not.Contain("Argument mismatch:"));
+        }
+
+        [Test]
+        public void DiagnosisSurvivesTheOverloadsHintExtraction()
+        {
+            // Lean keeps the message from the overloads marker onwards; the diagnosis
+            // must be inside that region to reach users.
+            var message = TypeErrorMessageOf("target.place_order('SPY', -10, 'exit signal')");
+
+            var hintStart = message.IndexOf("The following overloads are available:");
+            Assert.GreaterOrEqual(hintStart, 0);
+            var hint = message.Substring(hintStart);
+            Assert.That(hint, Does.Contain("Argument mismatch: argument 3 ('asynchronous') expected bool, got str."));
+        }
+    }
+}

src/embed_tests/TestFloatToIntConversion.cs

@@ -41,6 +41,43 @@ def overloaded_named(value):
 
 def single_params(value):
     return IntTaker(0).ComputeScaled(value)
+
+class FloatSubclass(float):
+    # numpy.float64-like: a float subclass
+    pass
+
+class FloatLike:
+    # numpy.float32-like: float and (truncating) int conversions, no __index__
+    def __init__(self, v):
+        self._v = v
+    def __float__(self):
+        return float(self._v)
+    def __int__(self):
+        return int(self._v)
+
+class IndexLike:
+    # numpy.int64-like: a true integer type advertising __index__
+    def __init__(self, v):
+        self._v = v
+    def __index__(self):
+        return int(self._v)
+    def __float__(self):
+        return float(self._v)
+
+def single_ctor_float_subclass(value):
+    return IntTaker(FloatSubclass(value)).Value
+
+def overloaded_ctor_float_subclass(value):
+    return OverloadedIntTaker(FloatSubclass(value)).Value
+
+def single_ctor_float_like(value):
+    return IntTaker(FloatLike(value)).Value
+
+def overloaded_ctor_float_like(value):
+    return OverloadedIntTaker(FloatLike(value)).Value
+
+def single_ctor_index_like(value):
+    return IntTaker(IndexLike(value)).Value
 ";
 
         [OneTimeSetUp]
@@ -87,6 +124,45 @@ public void NonIntegralFloat_IsRejected(string func)
             Assert.AreEqual("TypeError", ex.Type.Name);
         }
 
+        // 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)
+        {
+            Assert.AreEqual(5, Call(func, 5.0));
+        }
+
+        [TestCase("single_ctor_float_subclass")]
+        [TestCase("overloaded_ctor_float_subclass")]
+        public void NonIntegralFloatSubclass_IsRejected(string func)
+        {
+            var ex = Assert.Throws<PythonException>(() => Call(func, 5.5));
+            Assert.AreEqual("TypeError", ex.Type.Name);
+        }
+
+        // __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)
+        {
+            Assert.AreEqual(5, Call(func, 5.0));
+        }
+
+        [TestCase("single_ctor_float_like")]
+        [TestCase("overloaded_ctor_float_like")]
+        public void NonIntegralFloatLike_IsRejected(string func)
+        {
+            var ex = Assert.Throws<PythonException>(() => Call(func, 5.5));
+            Assert.AreEqual("TypeError", ex.Type.Name);
+        }
+
+        // __index__ types (e.g. numpy.int64) are integers, not float-like.
+        [Test]
+        public void IndexLike_IsAccepted()
+        {
+            Assert.AreEqual(5, Call("single_ctor_index_like", 5.0));
+        }
+
         // When no overload matches, the error should hint the expected signature(s).
         [Test]
         public void ErrorMessage_SingleOverload_ShowsExpectedSignature()

src/runtime/Converter.cs

@@ -907,6 +907,28 @@ internal static int ToInt32(BorrowedReference value)
             return checked((int)num);
         }
 
+        /// <summary>
+        /// 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)
+        {
+            // fast path for the common case: actual ints
+            if (Runtime.PyInt_Check(value) || Runtime.PyBool_Check(value))
+            {
+                return false;
+            }
+
+            if (Runtime.PyObject_TypeCheck(value, Runtime.PyFloatType))
+            {
+                return true;
+            }
+
+            return Runtime.PyObject_HasAttrString(value, "__float__") != 0
+                && Runtime.PyObject_HasAttrString(value, "__index__") == 0;
+        }
+
         /// <summary>
         /// Convert a Python value to an instance of a primitive managed type.
         /// </summary>
@@ -918,14 +940,17 @@ 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 (tc.IsInteger() && Runtime.PyFloat_Check(value))
+            // 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())
+                {
+                    // don't let a failed __float__ probe leak
+                    Exceptions.Clear();
+                    goto type_error;
+                }
                 if (double.IsNaN(dbl) || double.IsInfinity(dbl) || Math.Truncate(dbl) != dbl)
                 {
                     goto type_error;