provide __int__ instance method on .NET enum types to support int(Enum.Member)

lostmsu · lostmsu · commit 0916b0b8ed04 · 2021-12-30T16:40:09.000-08:00
implements pythonnet#1585
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -345,15 +345,26 @@ private static ClassInfo GetClassInfo(Type type)
                 }
             }
 
-            // only [Flags] enums support bitwise operations
-            if (type.IsEnum && type.IsFlagsEnum())
+
+            if (type.IsEnum)
             {
                 var opsImpl = typeof(EnumOps<>).MakeGenericType(type);
                 foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))
                 {
                     local.Add(op.Name);
                 }
                 info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();
+
+                // only [Flags] enums support bitwise operations
+                if (type.IsFlagsEnum())
+                {
+                    opsImpl = typeof(FlagEnumOps<>).MakeGenericType(type);
+                    foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))
+                    {
+                        local.Add(op.Name);
+                    }
+                    info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();
+                }
             }
 
             // Now again to filter w/o losing overloaded member info
diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -101,7 +101,7 @@ public static void FixupSlots(BorrowedReference pyType, Type clrType)
             Debug.Assert(_opType != null);
 
             var staticMethods =
-                clrType.IsEnum ? typeof(EnumOps<>).MakeGenericType(clrType).GetMethods(flags)
+                clrType.IsEnum ? typeof(FlagEnumOps<>).MakeGenericType(clrType).GetMethods(flags)
                 : clrType.GetMethods(flags);
 
             foreach (var method in staticMethods)
diff --git a/src/runtime/opshelper.cs b/src/runtime/opshelper.cs
@@ -38,7 +38,7 @@ public static Expression EnumUnderlyingValue(Expression enumValue)
     internal class OpsAttribute: Attribute { }
 
     [Ops]
-    internal static class EnumOps<T> where T : Enum
+    internal static class FlagEnumOps<T> where T : Enum
     {
         static readonly Func<T, T, T> and = BinaryOp(Expression.And);
         static readonly Func<T, T, T> or = BinaryOp(Expression.Or);
@@ -74,4 +74,14 @@ static Func<T, T> UnaryOp(Func<Expression, UnaryExpression> op)
             });
         }
     }
+
+    [Ops]
+    internal static class EnumOps<T> where T : Enum
+    {
+        [ForbidPythonThreads]
+        public static PyInt __int__(T value)
+            => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)
+            ? new PyInt(Convert.ToUInt64(value))
+            : new PyInt(Convert.ToInt64(value));
+    }
 }
diff --git a/src/testing/enumtest.cs b/src/testing/enumtest.cs
@@ -72,7 +72,9 @@ public enum LongEnum : long
         Two,
         Three,
         Four,
-        Five
+        Five,
+        Max = long.MaxValue,
+        Min = long.MinValue,
     }
 
     public enum ULongEnum : ulong
@@ -82,7 +84,8 @@ public enum ULongEnum : ulong
         Two,
         Three,
         Four,
-        Five
+        Five,
+        Max = ulong.MaxValue,
     }
 
     [Flags]
diff --git a/tests/test_enum.py b/tests/test_enum.py
@@ -87,6 +87,15 @@ def test_ulong_enum():
     assert Test.ULongEnum.Two == Test.ULongEnum(2)
 
 
+def test_long_enum_to_int():
+    assert int(Test.LongEnum.Max) == 9223372036854775807
+    assert int(Test.LongEnum.Min) == -9223372036854775808
+
+
+def test_ulong_enum_to_int():
+    assert int(Test.ULongEnum.Max) == 18446744073709551615
+
+
 def test_instantiate_enum_fails():
     """Test that instantiation of an enum class fails."""
     from System import DayOfWeek

Original file line number	Diff line number	Diff line change
`@@ -345,15 +345,26 @@ private static ClassInfo GetClassInfo(Type type)`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`348`		`- // only [Flags] enums support bitwise operations`
`349`		`- if (type.IsEnum && type.IsFlagsEnum())`
	`348`	`+`
	`349`	`+ if (type.IsEnum)`
`350`	`350`	`{`
`351`	`351`	`var opsImpl = typeof(EnumOps<>).MakeGenericType(type);`
`352`	`352`	`foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))`
`353`	`353`	`{`
`354`	`354`	`local.Add(op.Name);`
`355`	`355`	`}`
`356`	`356`	`info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();`
	`357`	`+`
	`358`	`+ // only [Flags] enums support bitwise operations`
	`359`	`+ if (type.IsFlagsEnum())`
	`360`	`+ {`
	`361`	`+ opsImpl = typeof(FlagEnumOps<>).MakeGenericType(type);`
	`362`	`+ foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))`
	`363`	`+ {`
	`364`	`+ local.Add(op.Name);`
	`365`	`+ }`
	`366`	`+ info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();`
	`367`	`+ }`
`357`	`368`	`}`
`358`	`369`
`359`	`370`	`// Now again to filter w/o losing overloaded member info`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public static Expression EnumUnderlyingValue(Expression enumValue)`
`38`	`38`	`internal class OpsAttribute: Attribute { }`
`39`	`39`
`40`	`40`	`[Ops]`
`41`		`- internal static class EnumOps<T> where T : Enum`
	`41`	`+ internal static class FlagEnumOps<T> where T : Enum`
`42`	`42`	`{`
`43`	`43`	`static readonly Func<T, T, T> and = BinaryOp(Expression.And);`
`44`	`44`	`static readonly Func<T, T, T> or = BinaryOp(Expression.Or);`
`@@ -74,4 +74,14 @@ static Func<T, T> UnaryOp(Func<Expression, UnaryExpression> op)`
`74`	`74`	`});`
`75`	`75`	`}`
`76`	`76`	`}`
	`77`	`+`
	`78`	`+ [Ops]`
	`79`	`+ internal static class EnumOps<T> where T : Enum`
	`80`	`+ {`
	`81`	`+ [ForbidPythonThreads]`
	`82`	`+ public static PyInt __int__(T value)`
	`83`	`+ => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)`
	`84`	`+ ? new PyInt(Convert.ToUInt64(value))`
	`85`	`+ : new PyInt(Convert.ToInt64(value));`
	`86`	`+ }`
`77`	`87`	`}`