Skip PyObject overloads from the hinted signatures

PyObject parameters accept any Python object and render as Any, so hinting
them carries no type information: they are typically the very overloads that
just rejected the value. Skip them in FormatOverloads so consumers do not
have to filter them out themselves. If every candidate takes a PyObject,
they are shown anyway rather than producing no hint at all.

Author: jhonabreul

src/embed_tests/TestFloatToIntConversion.cs

@@ -100,9 +100,12 @@ public void ErrorMessage_SingleOverload_ShowsExpectedSignature()
         public void ErrorMessage_MultipleOverloads_ListsCandidates()
         {
             var ex = Assert.Throws<PythonException>(() => Call("overloaded_ctor", 5.5));
-            StringAssert.Contains("The following overloads are available:", ex.Message);
-            // The int overload is surfaced, hinting an integer was expected.
+            // The int overload is surfaced, hinting an integer was expected. The
+            // PyObject overload is skipped (it carries no type information), which
+            // leaves a single hinted signature here.
+            StringAssert.Contains("The expected signature is:", ex.Message);
             StringAssert.Contains("range: int", ex.Message);
+            StringAssert.DoesNotContain("volume_selector", ex.Message);
         }
 
         // The hinted signatures use the snake_case name Python callers use, not the

src/embed_tests/TestMethodSignatureFormatter.cs

@@ -80,6 +80,50 @@ public void RendersConstructorsWithDisplayName()
             Assert.AreEqual("SampleTarget(period: timedelta, start_time: Optional[timedelta] = None)", signature);
         }
 
+        [Test]
+        public void SkipsPyObjectOverloadsFromHints()
+        {
+            var hint = MethodSignatureFormatter.FormatOverloads(typeof(MixedOverloadsTarget).GetConstructors(),
+                displayName: nameof(MixedOverloadsTarget));
+
+            StringAssert.Contains("The following overloads are available:", hint);
+            StringAssert.Contains("MixedOverloadsTarget(period: timedelta)", hint);
+            StringAssert.Contains("MixedOverloadsTarget(max_count: int)", hint);
+            StringAssert.DoesNotContain("py_func", hint);
+        }
+
+        [Test]
+        public void ShowsPyObjectOverloadsWhenThereIsNothingElseToHint()
+        {
+            var hint = MethodSignatureFormatter.FormatOverloads(typeof(PyObjectOnlyTarget).GetConstructors(),
+                displayName: nameof(PyObjectOnlyTarget));
+
+            StringAssert.Contains("The expected signature is:", hint);
+            StringAssert.Contains("PyObjectOnlyTarget(py_func: Any)", hint);
+        }
+
+        private class MixedOverloadsTarget
+        {
+            public MixedOverloadsTarget(TimeSpan period)
+            {
+            }
+
+            public MixedOverloadsTarget(int maxCount)
+            {
+            }
+
+            public MixedOverloadsTarget(PyObject pyFunc)
+            {
+            }
+        }
+
+        private class PyObjectOnlyTarget
+        {
+            public PyObjectOnlyTarget(PyObject pyFunc)
+            {
+            }
+        }
+
         private class SampleTarget
         {
             public SampleTarget(TimeSpan period, TimeSpan? startTime = null)

src/runtime/MethodSignatureFormatter.cs

@@ -17,6 +17,10 @@ public static class MethodSignatureFormatter
         /// Formats the signatures of the candidate overloads as an error message hint,
         /// so the caller can see what the method expects, e.g.
         /// "The following overloads are available:" followed by one signature per line.
+        /// Overloads taking PyObject parameters are skipped: they accept any Python
+        /// object and carry no type information (they are typically the overloads that
+        /// just rejected the value). If every candidate takes a PyObject, they are shown
+        /// anyway rather than producing no hint at all.
         /// Returns an empty string if there are no signatures to show.
         /// </summary>
         /// <param name="methods">The candidate overloads</param>
@@ -34,16 +38,19 @@ public static string FormatOverloads(IEnumerable<MethodBase> methods, int maxSho
             // the original failure.
             try
             {
+                var candidates = methods.Where(method => method != null).ToList();
+                var withoutPyObject = candidates.Where(method => !TakesPyObject(method)).ToList();
+                if (withoutPyObject.Count > 0)
+                {
+                    candidates = withoutPyObject;
+                }
+
                 // Distinct signatures, preserving order. Snake-cased duplicates and
                 // repeated overloads collapse into a single entry.
                 var signatures = new List<string>();
                 var seen = new HashSet<string>();
-                foreach (var method in methods)
+                foreach (var method in candidates)
                 {
-                    if (method == null)
-                    {
-                        continue;
-                    }
                     var signature = FormatSignature(method, displayName);
                     if (seen.Add(signature))
                     {
@@ -123,6 +130,22 @@ internal static string SnakeCaseName(MethodBase method)
             return method.IsConstructor ? method.Name : method.Name.ToSnakeCase();
         }
 
+        /// <summary>
+        /// Determines whether any of the method's parameters is a PyObject
+        /// </summary>
+        private static bool TakesPyObject(MethodBase method)
+        {
+            return method.GetParameters().Any(parameter =>
+            {
+                var type = parameter.ParameterType;
+                if (type.IsByRef)
+                {
+                    type = type.GetElementType();
+                }
+                return typeof(PyObject).IsAssignableFrom(type);
+            });
+        }
+
         /// <summary>
         /// Produces the Python-side name for a CLR type, following the conversions the
         /// runtime performs on arguments: primitives map to their Python equivalents