Clear rejected overload probe errors when a method bind succeeds

MethodBinder probes each overload candidate with setError: false, but a
probe can still raise: the implicit-conversion catches in
Converter.ToManagedValue raise unconditionally so that Invoke can
surface the specific cause (e.g. a throwing implicit operator) as the
bind-failure reason instead of the generic no-match message.

When the raising candidate was probed after the candidate that
ultimately matched, nothing cleared the indicator before the method ran
and the otherwise successful call failed with "SystemError: ...
returned a result with an error set". Errors raised by earlier
candidates were incidentally wiped by the per-candidate
PyObject_Type/Exceptions.Clear type check, which is why the leak needs
this specific overload ordering: an exact-class-match overload
(precedence 40) binds first, then a string overload (precedence 50) is
probed and raises.

Clear any pending probe error in Bind once an overload has matched. The
bind-failure path is untouched, so a pending error is still surfaced as
the failure reason when nothing matches (ImplicitConversionErrorHandling).

Author: jhonabreul

src/embed_tests/TestMethodBinder.cs

@@ -35,6 +35,8 @@ def TestG(self):
         model.TestList(model.SomeList)
     def TestH(self):
         return self.OnlyString(TestMethodBinder.ErroredImplicitConversion())
+    def TestI(self):
+        return self.StringOrErrored(TestMethodBinder.ErroredImplicitConversion())
     def MethodTimeSpanTest(self):
         TestMethodBinder.CSharpModel.MethodDateTimeAndTimeSpan(self, timedelta(days = 1), TestMethodBinder.SomeEnu.A, pinocho = 0)
         TestMethodBinder.CSharpModel.MethodDateTimeAndTimeSpan(self, date(1, 1, 1), TestMethodBinder.SomeEnu.A, pinocho = 0)
@@ -180,6 +182,22 @@ public void ImplicitConversionErrorHandling()
             }
         }
 
+        // The exact-type overload matches first (class precedence 40), then the
+        // string overload (precedence 50) is probed and its conversion raises a
+        // TypeError (throwing implicit operator). The successful bind must not leave
+        // that probe error pending, or CPython fails the otherwise successful call
+        // with "SystemError: ... returned a result with an error set".
+        [Test]
+        public void RejectedOverloadProbeErrorDoesNotPoisonSuccessfulBind()
+        {
+            using (Py.GIL())
+            {
+                var data = (string)module.TestI();
+                Assert.AreEqual("ErroredImplicitConversion overload", data);
+                Assert.IsFalse(Exceptions.ErrorOccurred());
+            }
+        }
+
         [Test]
         public void WillAvoidUsingImplicitConversionIfPossible_String()
         {
@@ -1533,6 +1551,16 @@ public virtual string OnlyString(string data)
                 return "OnlyString impl: " + data;
             }
 
+            public string StringOrErrored(string data)
+            {
+                return "string overload";
+            }
+
+            public string StringOrErrored(ErroredImplicitConversion data)
+            {
+                return "ErroredImplicitConversion overload";
+            }
+
             public virtual string InvokeModel(string data, double anotherArgument = 0)
             {
                 return "string impl: " + data;

src/runtime/MethodBinder.cs

@@ -792,6 +792,14 @@ internal Binding Bind(BorrowedReference inst, BorrowedReference args, BorrowedRe
 
             if (matches.Count > 0 || (matchesUsingImplicitConversion != null && matchesUsingImplicitConversion.Count > 0))
             {
+                // A rejected overload's conversion probe may have raised a Python error
+                // even though probing converts with setError: false (e.g. a throwing
+                // implicit operator raises unconditionally so Invoke can surface it as
+                // the failure reason when nothing matches). Once an overload matched,
+                // that error must not survive the successful call: CPython would fail
+                // it with "SystemError: ... returned a result with an error set".
+                Exceptions.Clear();
+
                 // We favor matches that do not use implicit conversion
                 var matchesTouse = matches.Count > 0 ? matches : matchesUsingImplicitConversion;