disabled using __float__ during implicit conversions to .NET floating point types

lostmsu · lostmsu · commit 26add1e8b73d · 2021-10-02T10:49:24.000-07:00
arbitrary Python objects are no longer implicitly converted to .NET bool type this is a continuation of #1568
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -71,6 +71,9 @@ See [Mixins/collections.py](src/runtime/Mixins/collections.py).
 -   BREAKING: When trying to convert Python `int` to `System.Object`, result will
 be of type `PyInt` instead of `System.Int32` due to possible loss of information.
 Python `float` will continue to be converted to `System.Double`.
+-   BREAKING: Python.NET will no longer implicitly convert types like `numpy.float64`, that implement `__float__` to
+`System.Single` and `System.Double`. An explicit conversion is required on Python or .NET side.
+-   BREAKING: Python.NET will no longer implicitly convert any Python object to `System.Boolean`.
 -   BREAKING: `PyObject.GetAttr(name, default)` now only ignores `AttributeError` (previously ignored all exceptions).
 -   BREAKING: `PyObject` no longer implements `IEnumerable<PyObject>`.
 Instead, `PyIterable` does that.
diff --git a/README.rst b/README.rst
@@ -77,7 +77,7 @@ Example
            dynamic sin = np.sin;
            Console.WriteLine(sin(5));
 
-           double c = np.cos(5) + sin(5);
+           double c = (double)(np.cos(5) + sin(5));
            Console.WriteLine(c);
 
            dynamic a = np.array(new List<float> { 1, 2, 3 });
diff --git a/src/embed_tests/NumPyTests.cs b/src/embed_tests/NumPyTests.cs
@@ -40,7 +40,7 @@ public void TestReadme()
             dynamic sin = np.sin;
             StringAssert.StartsWith("-0.95892", sin(5).ToString());
 
-            double c = np.cos(5) + sin(5);
+            double c = (double)(np.cos(5) + sin(5));
             Assert.AreEqual(-0.675262, c, 0.01);
 
             dynamic a = np.array(new List<float> { 1, 2, 3 });
diff --git a/src/embed_tests/TestConverter.cs b/src/embed_tests/TestConverter.cs
@@ -116,6 +116,13 @@ public void ConvertOverflow()
             }
         }
 
+        [Test]
+        public void NoImplicitConversionToBool()
+        {
+            var pyObj = new PyList(items: new[] { 1.ToPython(), 2.ToPython() }).ToPython();
+            Assert.Throws<InvalidCastException>(() => pyObj.As<bool>());
+        }
+
         [Test]
         public void ToNullable()
         {
diff --git a/src/runtime/converter.cs b/src/runtime/converter.cs
@@ -2,6 +2,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Globalization;
 using System.Reflection;
 using System.Runtime.InteropServices;
@@ -501,6 +502,44 @@ internal static bool ToManagedValue(IntPtr value, Type obType,
             return ToPrimitive(value, obType, out result, setError);
         }
 
+        /// <remarks>
+        /// Unlike <see cref="ToManaged(BorrowedReference, Type, out object?, bool)"/>,
+        /// this method does not have a <c>setError</c> parameter, because it should
+        /// only be called after <see cref="ToManaged(BorrowedReference, Type, out object?, bool)"/>.
+        /// </remarks>
+        internal static bool ToManagedExplicit(BorrowedReference value, Type obType,
+            out object? result)
+        {
+            result = null;
+
+            // this method would potentially clean any existing error resulting in information loss
+            Debug.Assert(Runtime.PyErr_Occurred() == null);
+
+            string? converterName =
+                  IsInteger(obType) ? "__int__"
+                : IsFloatingNumber(obType) ? "__float__"
+                : null;
+
+            if (converterName is null) return false;
+
+            Debug.Assert(obType.IsPrimitive);
+
+            using var converter = Runtime.PyObject_GetAttrString(value, converterName);
+            if (converter.IsNull())
+            {
+                Exceptions.Clear();
+                return false;
+            }
+
+            using var explicitlyCoerced = Runtime.PyObject_CallObject(converter, BorrowedReference.Null);
+            if (explicitlyCoerced.IsNull())
+            {
+                Exceptions.Clear();
+                return false;
+            }
+            return ToPrimitive(explicitlyCoerced, obType, out result, false);
+        }
+
         static object? ToPyObjectSubclass(ConstructorInfo ctor, PyObject instance, bool setError)
         {
             try
@@ -544,6 +583,8 @@ internal static int ToInt32(BorrowedReference value)
             return checked((int)num);
         }
 
+        private static bool ToPrimitive(BorrowedReference value, Type obType, out object? result, bool setError)
+            => ToPrimitive(value.DangerousGetAddress(), obType, out result, setError);
         /// <summary>
         /// Convert a Python value to an instance of a primitive managed type.
         /// </summary>
@@ -590,7 +631,18 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object? result, b
                     }
 
                 case TypeCode.Boolean:
-                    result = Runtime.PyObject_IsTrue(value) != 0;
+                    if (value == Runtime.PyTrue)
+                    {
+                        result = true;
+                    }
+                    else if (value == Runtime.PyFalse)
+                    {
+                        result = false;
+                    }
+                    else if (setError)
+                    {
+                        goto type_error;
+                    }
                     return true;
 
                 case TypeCode.Byte:
@@ -768,6 +820,10 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object? result, b
 
                 case TypeCode.Single:
                     {
+                        if (!Runtime.PyFloat_Check(value) && !Runtime.PyInt_Check(value))
+                        {
+                            goto type_error;
+                        }
                         double num = Runtime.PyFloat_AsDouble(value);
                         if (num == -1.0 && Exceptions.ErrorOccurred())
                         {
@@ -786,6 +842,10 @@ private static bool ToPrimitive(IntPtr value, Type obType, out object? result, b
 
                 case TypeCode.Double:
                     {
+                        if (!Runtime.PyFloat_Check(value) && !Runtime.PyInt_Check(value))
+                        {
+                            goto type_error;
+                        }
                         double num = Runtime.PyFloat_AsDouble(value);
                         if (num == -1.0 && Exceptions.ErrorOccurred())
                         {
@@ -933,6 +993,13 @@ private static bool ToArray(IntPtr value, Type obType, out object? result, bool
             result = items;
             return true;
         }
+
+        internal static bool IsFloatingNumber(Type type) => type == typeof(float) || type == typeof(double);
+        internal static bool IsInteger(Type type)
+            => type == typeof(Byte) || type == typeof(SByte)
+            || type == typeof(Int16) || type == typeof(UInt16)
+            || type == typeof(Int32) || type == typeof(UInt32)
+            || type == typeof(Int64) || type == typeof(UInt64);
     }
 
     public static class ConverterExtension
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
@@ -1293,7 +1293,21 @@ public override bool TryInvoke(InvokeBinder binder, object[] args, out object re
 
         public override bool TryConvert(ConvertBinder binder, out object result)
         {
-            return Converter.ToManaged(this.obj, binder.Type, out result, false);
+            // always try implicit conversion first
+            if (Converter.ToManaged(this.obj, binder.Type, out result, false))
+            {
+                return true;
+            }
+
+            if (binder.Explicit)
+            {
+                Runtime.PyErr_Fetch(out var errType, out var errValue, out var tb);
+                bool converted = Converter.ToManagedExplicit(Reference, binder.Type, out result);
+                Runtime.PyErr_Restore(errType.StealNullable(), errValue.StealNullable(), tb.StealNullable());
+                return converted;
+            }
+
+            return false;
         }
 
         public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)

Original file line number	Diff line number	Diff line change
`@@ -116,6 +116,13 @@ public void ConvertOverflow()`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
	`119`	`+ [Test]`
	`120`	`+ public void NoImplicitConversionToBool()`
	`121`	`+ {`
	`122`	`+ var pyObj = new PyList(items: new[] { 1.ToPython(), 2.ToPython() }).ToPython();`
	`123`	`+ Assert.Throws<InvalidCastException>(() => pyObj.As<bool>());`
	`124`	`+ }`
	`125`	`+`
`119`	`126`	`[Test]`
`120`	`127`	`public void ToNullable()`
`121`	`128`	`{`