Jan 6, 2022 · Dec 31, 2021
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
                }
            }

            // 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/native/ITypeOffsets.cs b/src/runtime/native/ITypeOffsets.cs
        int nb_multiply { get; }
        int nb_true_divide { get; }
        int nb_and { get; }
        int nb_int { get; }
        int nb_or { get; }
        int nb_xor { get; }
        int nb_lshift { get; }
diff --git a/src/runtime/native/TypeOffset.cs b/src/runtime/native/TypeOffset.cs
        internal static int nb_and { get; private set; }
        internal static int nb_or { get; private set; }
        internal static int nb_xor { get; private set; }
        internal static int nb_int { get; private set; }
        internal static int nb_lshift { get; private set; }
        internal static int nb_rshift { get; private set; }
        internal static int nb_remainder { get; private set; }
diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text;

 namespace Python.Runtime
                ["op_OnesComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert),
                ["op_UnaryNegation"] = new SlotDefinition("__neg__", TypeOffset.nb_negative),
                ["op_UnaryPlus"] = new SlotDefinition("__pos__", TypeOffset.nb_positive),

                ["__int__"] = new SlotDefinition("__int__", TypeOffset.nb_int),
            };
            ComparisonOpMap = new Dictionary<string, string>
            {
        /// </summary>
        public static void FixupSlots(BorrowedReference pyType, Type clrType)
        {
            const BindingFlags flags = BindingFlags.Public | BindingFlags.Static;
            Debug.Assert(_opType != null);

            var staticMethods =
                clrType.IsEnum ? typeof(EnumOps<>).MakeGenericType(clrType).GetMethods(flags)
                : clrType.GetMethods(flags);
            var operatorCandidates = GetOperatorCandidates(clrType);

            foreach (var method instaticMethods)
            foreach (var method inoperatorCandidates)
            {
                // We only want to override slots for operators excluding
                // comparison operators, which are handled by ClassBase.tp_richcompare.
            }
        }

        static IEnumerable<MethodInfo> GetOperatorCandidates(Type clrType)
        {
            const BindingFlags flags = BindingFlags.Public | BindingFlags.Static;
            if (clrType.IsEnum)
            {
                return typeof(EnumOps<>).MakeGenericType(clrType).GetMethods(flags)
                    .Concat(typeof(FlagEnumOps<>).MakeGenericType(clrType).GetMethods(flags));
            }

            return clrType.GetMethods(flags);
        }

        public static string GetPyMethodName(string clrName)
        {
            if (OpMethodMap.ContainsKey(clrName))
diff --git a/src/runtime/opshelper.cs b/src/runtime/opshelper.cs
    internal class OpsAttribute: Attribute { }

    [Ops]
    internal static classEnumOps<T> where T : Enum
    internal static classFlagEnumOps<T> where T : Enum
    {
        static readonly Func<T, T, T> and = BinaryOp(Expression.And);
        static readonly Func<T, T, T> or = BinaryOp(Expression.Or);
            });
        }
    }

    [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));
    }
 }
diff --git a/src/testing/enumtest.cs b/src/testing/enumtest.cs
        Two,
        Three,
        Four,
        Five
        Five,
        Max = long.MaxValue,
        Min = long.MinValue,
    }

    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
    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
Expand Up		@@ -346,15 +346,25 @@ 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
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,6 +21,7 @@ interface ITypeOffsets
		int nb_multiply { get; }
		int nb_true_divide { get; }
		int nb_and { get; }
		int nb_int { get; }
		int nb_or { get; }
		int nb_xor { get; }
		int nb_lshift { get; }
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -30,6 +30,7 @@ static partial class TypeOffset
		internal static int nb_and { get; private set; }
		internal static int nb_or { get; private set; }
		internal static int nb_xor { get; private set; }
		internal static int nb_int { get; private set; }
		internal static int nb_lshift { get; private set; }
		internal static int nb_rshift { get; private set; }
		internal static int nb_remainder { get; private set; }
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -1,8 +1,8 @@
		using System;
		using System.Collections.Generic;
		using System.Diagnostics;
		using System.Linq;
		using System.Reflection;
		using System.Runtime.InteropServices;
		using System.Text;

		namespace Python.Runtime
Expand DownExpand Up		@@ -51,6 +51,8 @@ static OperatorMethod()
		["op_OnesComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert),
		["op_UnaryNegation"] = new SlotDefinition("__neg__", TypeOffset.nb_negative),
		["op_UnaryPlus"] = new SlotDefinition("__pos__", TypeOffset.nb_positive),

		["__int__"] = new SlotDefinition("__int__", TypeOffset.nb_int),
		};
		ComparisonOpMap = new Dictionary<string, string>
		{
Expand DownExpand Up		@@ -97,14 +99,11 @@ public static bool IsComparisonOp(MethodBase method)
		/// </summary>
		public static void FixupSlots(BorrowedReference pyType, Type clrType)
		{
		const BindingFlags flags = BindingFlags.Public \| BindingFlags.Static;
		Debug.Assert(_opType != null);

		var staticMethods =
		clrType.IsEnum ? typeof(EnumOps<>).MakeGenericType(clrType).GetMethods(flags)
		: clrType.GetMethods(flags);
		var operatorCandidates = GetOperatorCandidates(clrType);

		foreach (var method instaticMethods)
		foreach (var method inoperatorCandidates)
		{
		// We only want to override slots for operators excluding
		// comparison operators, which are handled by ClassBase.tp_richcompare.
Expand All		@@ -124,6 +123,18 @@ public static void FixupSlots(BorrowedReference pyType, Type clrType)
		}
		}

		static IEnumerable<MethodInfo> GetOperatorCandidates(Type clrType)
		{
		const BindingFlags flags = BindingFlags.Public \| BindingFlags.Static;
		if (clrType.IsEnum)
		{
		return typeof(EnumOps<>).MakeGenericType(clrType).GetMethods(flags)
		.Concat(typeof(FlagEnumOps<>).MakeGenericType(clrType).GetMethods(flags));
		}

		return clrType.GetMethods(flags);
		}

		public static string GetPyMethodName(string clrName)
		{
		if (OpMethodMap.ContainsKey(clrName))
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -38,7 +38,7 @@ public static Expression EnumUnderlyingValue(Expression enumValue)
		internal class OpsAttribute: Attribute { }

		[Ops]
		internal static classEnumOps<T> where T : Enum
		internal static classFlagEnumOps<T> where T : Enum
		{
		static readonly Func<T, T, T> and = BinaryOp(Expression.And);
		static readonly Func<T, T, T> or = BinaryOp(Expression.Or);
Expand DownExpand Up		@@ -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));
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -72,7 +72,9 @@ public enum LongEnum : long
		Two,
		Three,
		Four,
		Five
		Five,
		Max = long.MaxValue,
		Min = long.MinValue,
		}

		public enum ULongEnum : ulong
Expand All		@@ -82,7 +84,8 @@ public enum ULongEnum : ulong
		Two,
		Three,
		Four,
		Five
		Five,
		Max = ulong.MaxValue,
		}

		[Flags]
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Expand Down