@@ -346,15 +346,26 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)
                 }
             }
 
-            // 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
 
@@ -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)
 
@@ -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,16 @@ static Func<T, T> UnaryOp(Func<Expression, UnaryExpression> op)
             });
         }
     }
+
+    [Ops]
+    internal static class EnumOps<T> where T : Enum
+    {
+        [ForbidPythonThreads]
+#pragma warning disable IDE1006 // Naming Styles - must match Python
+        public static PyInt __int__(T value)
+#pragma warning restore IDE1006 // Naming Styles
+            => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)
+            ? new PyInt(Convert.ToUInt64(value))
+            : new PyInt(Convert.ToInt64(value));
+    }
 }
@@ -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]
 
@@ -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
`@@ -346,15 +346,26 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)`
`346`	`346`	`}`
`347`	`347`	`}`
`348`	`348`
`349`		`- // only [Flags] enums support bitwise operations`
`350`		`- if (type.IsEnum && type.IsFlagsEnum())`
	`349`	`+`
	`350`	`+ if (type.IsEnum)`
`351`	`351`	`{`
`352`	`352`	`var opsImpl = typeof(EnumOps<>).MakeGenericType(type);`
`353`	`353`	`foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))`
`354`	`354`	`{`
`355`	`355`	`local.Add(op.Name);`
`356`	`356`	`}`
`357`	`357`	`info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();`
	`358`	`+`
	`359`	`+ // only [Flags] enums support bitwise operations`
	`360`	`+ if (type.IsFlagsEnum())`
	`361`	`+ {`
	`362`	`+ opsImpl = typeof(FlagEnumOps<>).MakeGenericType(type);`
	`363`	`+ foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags))`
	`364`	`+ {`
	`365`	`+ local.Add(op.Name);`
	`366`	`+ }`
	`367`	`+ info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray();`
	`368`	`+ }`
`358`	`369`	`}`
`359`	`370`
`360`	`371`	`// 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,16 @@ 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`	`+#pragma warning disable IDE1006 // Naming Styles - must match Python`
	`83`	`+ public static PyInt __int__(T value)`
	`84`	`+#pragma warning restore IDE1006 // Naming Styles`
	`85`	`+ => typeof(T).GetEnumUnderlyingType() == typeof(UInt64)`
	`86`	`+ ? new PyInt(Convert.ToUInt64(value))`
	`87`	`+ : new PyInt(Convert.ToInt64(value));`
	`88`	`+ }`
`77`	`89`	`}`