Fill nb_index slot for integer types (#1907)

filmor · web-flow · commit bd48dc118c62 · 2022-08-13T14:43:38.000-07:00
diff --git a/src/runtime/Native/ITypeOffsets.cs b/src/runtime/Native/ITypeOffsets.cs
@@ -31,6 +31,7 @@ interface ITypeOffsets
         int nb_invert { get; }
         int nb_inplace_add { get; }
         int nb_inplace_subtract { get; }
+        int nb_index { get; }
         int ob_size { get; }
         int ob_type { get; }
         int qualname { get; }
diff --git a/src/runtime/Native/TypeOffset.cs b/src/runtime/Native/TypeOffset.cs
@@ -38,6 +38,7 @@ static partial class TypeOffset
         internal static int nb_invert { get; private set; }
         internal static int nb_inplace_add { get; private set; }
         internal static int nb_inplace_subtract { get; private set; }
+        internal static int nb_index { get; private set; }
         internal static int ob_size { get; private set; }
         internal static int ob_type { get; private set; }
         internal static int qualname { get; private set; }
diff --git a/src/runtime/Types/ClassBase.cs b/src/runtime/Types/ClassBase.cs
@@ -604,17 +604,20 @@ public virtual void InitializeSlots(BorrowedReference pyType, SlotsHolder slotsH
                 case TypeCode.Int32:
                 case TypeCode.Int64:
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertInt), slotsHolder);
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_index, new Interop.B_N(DoConvertInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
                 case TypeCode.Byte:
                 case TypeCode.UInt16:
                 case TypeCode.UInt32:
                 case TypeCode.UInt64:
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertUInt), slotsHolder);
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_index, new Interop.B_N(DoConvertUInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
                 case TypeCode.Double:
                 case TypeCode.Single:
+                    TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_int, new Interop.B_N(DoConvertInt), slotsHolder);
                     TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.nb_float, new Interop.B_N(DoConvertFloat), slotsHolder);
                     break;
             }
diff --git a/src/runtime/Types/OperatorMethod.cs b/src/runtime/Types/OperatorMethod.cs
@@ -54,6 +54,7 @@ static OperatorMethod()
 
                 ["__int__"] = new SlotDefinition("__int__", TypeOffset.nb_int),
                 ["__float__"] = new SlotDefinition("__float__", TypeOffset.nb_float),
+                ["__index__"] = new SlotDefinition("__index__", TypeOffset.nb_index),
             };
             ComparisonOpMap = new Dictionary<string, string>
             {
diff --git a/src/runtime/Util/OpsHelper.cs b/src/runtime/Util/OpsHelper.cs
@@ -82,10 +82,14 @@ internal static class EnumOps<T> where T : Enum
     {
         [ForbidPythonThreads]
 #pragma warning disable IDE1006 // Naming Styles - must match Python
-        public static PyInt __int__(T value)
+        public static PyInt __index__(T value)
 #pragma warning restore IDE1006 // Naming Styles
             => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)
             ? new PyInt(Convert.ToUInt64(value))
             : new PyInt(Convert.ToInt64(value));
+        [ForbidPythonThreads]
+#pragma warning disable IDE1006 // Naming Styles - must match Python
+        public static PyInt __int__(T value) => __index__(value);
+#pragma warning restore IDE1006 // Naming Styles
     }
 }
diff --git a/tests/test_conversion.py b/tests/test_conversion.py
@@ -721,6 +721,7 @@ def test_intptr_construction():
             UIntPtr(v)
 
 def test_explicit_conversion():
+    from operator import index
     from System import (
         Int64, UInt64, Int32, UInt32, Int16, UInt16, Byte, SByte, Boolean
     )
@@ -730,18 +731,24 @@ def test_explicit_conversion():
     assert int(Boolean(True)) == 1
 
     for t in [UInt64, UInt32, UInt16, Byte]:
+        assert index(t(127)) == 127
         assert int(t(127)) == 127
         assert float(t(127)) == 127.0
 
     for t in [Int64, Int32, Int16, SByte]:
+        assert index(t(127)) == 127
+        assert index(t(-127)) == -127
         assert int(t(127)) == 127
         assert int(t(-127)) == -127
         assert float(t(127)) == 127.0
         assert float(t(-127)) == -127.0
 
-    assert int(Int64.MaxValue) == 2**63 - 1
-    assert int(Int64.MinValue) == -2**63
-    assert int(UInt64.MaxValue) == 2**64 - 1
+    assert int(Int64(Int64.MaxValue)) == 2**63 - 1
+    assert int(Int64(Int64.MinValue)) == -2**63
+    assert int(UInt64(UInt64.MaxValue)) == 2**64 - 1
 
     for t in [Single, Double]:
         assert float(t(0.125)) == 0.125
+        assert int(t(123.4)) == 123
+        with pytest.raises(TypeError):
+            index(t(123.4))

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ static OperatorMethod()`
`54`	`54`
`55`	`55`	`["__int__"] = new SlotDefinition("__int__", TypeOffset.nb_int),`
`56`	`56`	`["__float__"] = new SlotDefinition("__float__", TypeOffset.nb_float),`
	`57`	`+ ["__index__"] = new SlotDefinition("__index__", TypeOffset.nb_index),`
`57`	`58`	`};`
`58`	`59`	`ComparisonOpMap = new Dictionary<string, string>`
`59`	`60`	`{`
Original file line number	Diff line number	Diff line change
`@@ -82,10 +82,14 @@ internal static class EnumOps<T> where T : Enum`
`82`	`82`	`{`
`83`	`83`	`[ForbidPythonThreads]`
`84`	`84`	`#pragma warning disable IDE1006 // Naming Styles - must match Python`
`85`		`- public static PyInt __int__(T value)`
	`85`	`+ public static PyInt __index__(T value)`
`86`	`86`	`#pragma warning restore IDE1006 // Naming Styles`
`87`	`87`	`=> typeof(T).GetEnumUnderlyingType() == typeof(UInt64)`
`88`	`88`	`? new PyInt(Convert.ToUInt64(value))`
`89`	`89`	`: new PyInt(Convert.ToInt64(value));`
	`90`	`+ [ForbidPythonThreads]`
	`91`	`+#pragma warning disable IDE1006 // Naming Styles - must match Python`
	`92`	`+ public static PyInt __int__(T value) => __index__(value);`
	`93`	`+#pragma warning restore IDE1006 // Naming Styles`
`90`	`94`	`}`
`91`	`95`	`}`