Make implicit numeric operators follow Python's int and float semantics

Everything went through double, so integral conversions lost precision past
2**53 and returned floats where Python gives ints. Values now behave like the
Python number their conversion maps to: exact ints for integral conversions
(unbounded, like Python), floats for floating point and decimal ones.

- operands arrive as PyObject: ints beyond Int32 failed the binder's object
  conversion, and numbers implementing __index__ or __float__ (numpy scalars,
  other CLR types with a conversion) are read too; anything else returns
  NotImplemented so Python raises its usual TypeError
- division by zero raises ZeroDivisionError instead of returning infinity
- int() truncates decimals exactly and raises ValueError/OverflowError on
  NaN/infinity
- comparisons between instances of an IComparable type use its own ordering,
  as they did before the number protocol was added
- inherited operators keep winning over the synthesized ones, as in C#;
  OperatorMethod shares the filtered list, or the inherited slot recursed

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: 2 people

CHANGELOG.md

@@ -10,7 +10,7 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ### Added
 
 -   Extension methods declared in non-framework assemblies are bound to the type they extend, so they can be called from the instance like in C# (e.g. `order_status.is_open()`). Those marked `[EditorBrowsable(EditorBrowsableState.Never)]`, or declared in a class marked so, keep their static form only
--   Types with an implicit conversion to a numeric type support Python arithmetic, comparisons, `float()` and `int()` through that conversion, unless they declare the operator themselves
+-   Types with an implicit conversion to a numeric type support Python arithmetic, comparisons, `float()` and `int()` through that conversion, behaving like a Python `int` for integral conversions and a `float` otherwise, unless they declare or inherit the operator
 -   Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax
 -   Python operator method will call C# operator method for supported binary and unary operators ([#1324][p1324]).
 -   Add GetPythonThreadID and Interrupt methods in PythonEngine

src/embed_tests/TestImplicitNumericOperators.cs

@@ -1,3 +1,4 @@
+using System;
 using NUnit.Framework;
 using Python.Runtime;
 
@@ -42,6 +43,53 @@ public ConvertibleMoney(decimal amount)
         public static ConvertibleMoney operator +(ConvertibleMoney a, ConvertibleMoney b) => new(a.Amount + b.Amount);
     }
 
+    public class ConvertibleCount
+    {
+        public long Value { get; }
+
+        public ConvertibleCount(long value)
+        {
+            Value = value;
+        }
+
+        public static implicit operator long(ConvertibleCount count) => count.Value;
+    }
+
+    public class ConvertibleBase
+    {
+        // inherited by ConvertibleDerived, it must keep winning over the synthesized one as in C#
+        public static string operator +(ConvertibleBase a, ConvertibleBase b) => "base";
+    }
+
+    public class ConvertibleDerived : ConvertibleBase
+    {
+        public decimal Amount { get; }
+
+        public ConvertibleDerived(decimal amount)
+        {
+            Amount = amount;
+        }
+
+        public static implicit operator decimal(ConvertibleDerived derived) => derived.Amount;
+    }
+
+    public class PreciseQuantity : IComparable<PreciseQuantity>
+    {
+        public decimal Value { get; }
+
+        public PreciseQuantity(decimal value)
+        {
+            Value = value;
+        }
+
+        // equal to 1 once converted to double, only the type's own ordering tells them apart
+        public static PreciseQuantity AboveOne() => new(1.0000000000000000000000000001m);
+
+        public int CompareTo(PreciseQuantity other) => Value.CompareTo(other.Value);
+
+        public static implicit operator decimal(PreciseQuantity quantity) => quantity.Value;
+    }
+
     public class NotConvertible
     {
     }
@@ -79,6 +127,62 @@ def own_operator_wins():
 
 def not_convertible():
     return hasattr(NotConvertible(), '__add__'), hasattr(NotConvertible(), '__float__')
+
+count = ConvertibleCount(2)
+big = ConvertibleCount(2**53 + 1)
+
+def integer_arithmetic():
+    results = (count + 1, 1 + count, count + count, count - 5, 10 - count, count * 3, 3 * count, -count, count + True)
+    return all(type(result) is int for result in results), results
+
+def integer_with_floats():
+    results = (count + 0.5, 0.5 + count, count * 1.5, count / 2, count / count, 3 / count)
+    return all(type(result) is float for result in results), results
+
+def large_integers():
+    exact = 2**53 + 1
+    return (int(big) == exact, big > 2**53, big - 1 == 2**53, big * big == exact * exact,
+        -big == -exact, big >= exact, big + 2**70 == exact + 2**70)
+
+def int_conversions():
+    errors = []
+    for value in (float('nan'), float('inf')):
+        try:
+            int(ConvertibleRatio(value))
+        except Exception as e:
+            errors.append(type(e).__name__)
+    return errors, int(ConvertibleRatio(-1.75)), int(ConvertibleFee(12345678901234567891)) == 12345678901234567891
+
+def division_by_zero():
+    errors = []
+    for operation in (lambda: fee / 0, lambda: 1 / ConvertibleFee(0), lambda: count / 0.0, lambda: fee / ConvertibleFee(0)):
+        try:
+            operation()
+        except ZeroDivisionError:
+            errors.append(True)
+    return len(errors)
+
+def other_numeric_operands():
+    margin = ConvertibleRatio(0.5)
+    return fee + 2**40, count + 2**70, fee + margin, count * margin, count < 2**64
+
+def unsupported_operands():
+    messages = []
+    for operation in (lambda: count + 'x', lambda: fee * None, lambda: fee < 'x', lambda: NotConvertible() - fee):
+        try:
+            operation()
+            messages.append(None)
+        except TypeError as e:
+            messages.append(str(e))
+    return messages
+
+def inherited_operator_wins():
+    derived = ConvertibleDerived(2)
+    return derived + derived, derived - ConvertibleDerived(1), float(derived)
+
+def own_ordering_wins():
+    one, above = PreciseQuantity(1), PreciseQuantity.AboveOne()
+    return above > one, one < above, above >= one, one <= above, above < one, sorted([above, one])[0] is one
 ";
 
         [OneTimeSetUp]
@@ -150,6 +254,107 @@ public void TheTypesOwnOperatorsKeepWinning()
             Assert.AreEqual(1.0, (double)result[2]);
         }
 
+        [Test]
+        public void IntegralConversionsBehaveLikeInts()
+        {
+            using var _ = Py.GIL();
+            var result = module.integer_arithmetic();
+            Assert.IsTrue((bool)result[0], "every result must be an int");
+            var expected = new long[] { 3, 3, 4, -3, 8, 6, 6, -2, 3 };
+            for (var i = 0; i < expected.Length; i++)
+            {
+                Assert.AreEqual(expected[i], (long)result[1][i], $"index {i}");
+            }
+        }
+
+        [Test]
+        public void IntegralConversionsGiveFloatsWherePythonWould()
+        {
+            using var _ = Py.GIL();
+            var result = module.integer_with_floats();
+            Assert.IsTrue((bool)result[0], "every result must be a float");
+            var expected = new[] { 2.5, 2.5, 3.0, 1.0, 1.0, 1.5 };
+            for (var i = 0; i < expected.Length; i++)
+            {
+                Assert.AreEqual(expected[i], (double)result[1][i], $"index {i}");
+            }
+        }
+
+        [Test]
+        public void LargeIntegralValuesStayExact()
+        {
+            using var _ = Py.GIL();
+            var result = module.large_integers();
+            for (var i = 0; i < 7; i++)
+            {
+                Assert.IsTrue((bool)result[i], $"index {i}");
+            }
+        }
+
+        [Test]
+        public void IntConversionFollowsPython()
+        {
+            using var _ = Py.GIL();
+            var result = module.int_conversions();
+            CollectionAssert.AreEqual(new[] { "ValueError", "OverflowError" }, ((PyObject)result[0]).As<string[]>());
+            Assert.AreEqual(-1, (int)result[1]);
+            Assert.IsTrue((bool)result[2], "decimal conversions must truncate exactly");
+        }
+
+        [Test]
+        public void DivisionByZeroRaisesLikePython()
+        {
+            using var _ = Py.GIL();
+            Assert.AreEqual(4, (int)module.division_by_zero());
+        }
+
+        [Test]
+        public void LargeIntsAndOtherNumbersAreOperands()
+        {
+            using var _ = Py.GIL();
+            var result = module.other_numeric_operands();
+            Assert.AreEqual(2.0 + Math.Pow(2, 40), (double)result[0]);
+            Assert.AreEqual("1180591620717411303426", result[1].ToString());
+            // another type with an implicit numeric conversion is read through its __float__
+            Assert.AreEqual(2.5, (double)result[2]);
+            Assert.AreEqual(1.0, (double)result[3]);
+            Assert.IsTrue((bool)result[4]);
+        }
+
+        [Test]
+        public void UnsupportedOperandsRaisePythonsTypeError()
+        {
+            using var _ = Py.GIL();
+            var messages = ((PyObject)module.unsupported_operands()).As<string[]>();
+            StringAssert.Contains("unsupported operand type(s) for +", messages[0]);
+            StringAssert.Contains("unsupported operand type(s) for *", messages[1]);
+            StringAssert.Contains("'<' not supported", messages[2]);
+            StringAssert.Contains("unsupported operand type(s) for -", messages[3]);
+        }
+
+        [Test]
+        public void InheritedOperatorsKeepWinning()
+        {
+            using var _ = Py.GIL();
+            var result = module.inherited_operator_wins();
+            Assert.AreEqual("base", (string)result[0]);
+            // subtraction is declared nowhere in the hierarchy, so the synthesized one applies
+            Assert.AreEqual(1.0, (double)result[1]);
+            Assert.AreEqual(2.0, (double)result[2]);
+        }
+
+        [Test]
+        public void TheTypesOwnOrderingWinsBetweenItsInstances()
+        {
+            using var _ = Py.GIL();
+            var result = module.own_ordering_wins();
+            var expected = new[] { true, true, true, true, false, true };
+            for (var i = 0; i < expected.Length; i++)
+            {
+                Assert.AreEqual(expected[i], (bool)result[i], $"index {i}");
+            }
+        }
+
         [Test]
         public void TypesWithoutAConversionAreUntouched()
         {

src/runtime/ClassManager.cs

@@ -417,8 +417,8 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)
             }
             else if (ImplicitNumericOps.IsSupported(type))
             {
-                // Types with an implicit numeric conversion get Python's number protocol, keeping the operators they declare themselves
-                var ops = ImplicitNumericOps.GetMethods(type).Where(op => !local.Contains(op.Name)).ToArray();
+                // Types with an implicit numeric conversion get Python's number protocol, keeping the operators they declare or inherit
+                var ops = ImplicitNumericOps.GetMethods(type);
                 foreach (var op in ops)
                 {
                     local.Add(op.Name);