Fixed bugs in InternalEnumExtensions.

Author: Timovzl

DomainModeling.Generator/EnumExtensions.cs

@@ -90,30 +90,27 @@ public static T Unless<T>(this T enumValue, bool condition)
 	public static bool HasFlags<T>(this T subject, T flag)
 		where T : unmanaged, Enum
 	{
-		var numericSubject = GetNumericValue(subject);
-		var numericFlag = GetNumericValue(flag);
+		var numericSubject = GetBinaryValue(subject);
+		var numericFlag = GetBinaryValue(flag);
 
 		return (numericSubject & numericFlag) == numericFlag;
 	}
 
 	/// <summary>
 	/// <para>
-	/// Returns the numeric value of the given <paramref name="enumValue"/>.
-	/// </para>
-	/// <para>
-	/// The resulting <see cref="UInt64"/> can be cast to the intended integral type, even if it is a signed type.
+	/// Returns the binary value of the given <paramref name="enumValue"/>, contained in a <see cref="UInt64"/>.
 	/// </para>
 	/// </summary>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	private static ulong GetNumericValue<T>(T enumValue)
+	private static ulong GetBinaryValue<T>(T enumValue)
 		where T : unmanaged, Enum
 	{
 		var result = 0UL;
 
-		// Since the actual value may be smaller than ulong's 8 bytes, we must align to the least significant byte
-		// This way, casting the ulong back to the original type gets back the exact original bytes
-		// On little-endian, that means aligning to the left of the bytes
-		// On big-endian, that means aligning to the right of the bytes
+		// TEnum could be shorter than 8 bytes
+		// Little-endian will automatically write into the least significant bytes, since those are on the left for little-endian
+		// For big-endian, they are on the right, so we need to look at the rightmost portion of the ulong, depending on size of TEnum
+		// For example, a ushort TEnum will look at the rightmost 2 bytes of the ulong
 		if (BitConverter.IsLittleEndian)
 			Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref result), enumValue);
 		else

DomainModeling.Tests/Enums/InternalEnumExtensionsTests.cs

@@ -1,4 +1,3 @@
-using System.Runtime.CompilerServices;
 using Architect.DomainModeling.Enums;
 using Xunit;
 
@@ -30,6 +29,7 @@ public void GetNumericValue_WithByte_ShouldReturnExpectedResult()
 	public void GetNumericValue_WithLong_ShouldReturnExpectedResult()
 	{
 		Assert.Equal((Int128)(-1), LongEnum.MinusOne.GetNumericValue());
+		Assert.Equal((Int128)(Int64.MinValue), LongEnum.Min.GetNumericValue());
 	}
 
 	[Fact]
@@ -39,33 +39,35 @@ public void GetNumericValue_WithUlong_ShouldReturnExpectedResult()
 	}
 
 	[Fact]
-	public void GetBinaryValue_WithByte_ShouldCastAndUnsafeConvertToUnderlyingTypeCorrectly()
+	public void GetBinaryValue_WithByte_ShouldCastAndGetEnumValueToUnderlyingTypeCorrectly()
 	{
 		var result = ByteEnum.One.GetBinaryValue();
 		Assert.Equal(1, (byte)result);
-		Assert.Equal(1, Unsafe.As<ulong, byte>(ref result));
-		Assert.Equal(ByteEnum.One, Unsafe.As<ulong, ByteEnum>(ref result));
+		Assert.Equal(ByteEnum.One, (ByteEnum)result);
+		Assert.Equal(ByteEnum.One, InternalEnumExtensions.GetEnumValue<ByteEnum>(result));
 	}
 
 	[Fact]
-	public void GetBinaryValue_WithLong_ShouldCastAndUnsafeConvertToUnderlyingTypeCorrectly()
+	public void GetBinaryValue_WithLong_ShouldCastAndGetEnumValueToUnderlyingTypeCorrectly()
 	{
 		var result1 = LongEnum.MinusOne.GetBinaryValue();
 		var result2 = LongEnum.Min.GetBinaryValue();
 
 		Assert.Equal(-1, (long)result1);
-		Assert.Equal(-1, Unsafe.As<ulong, long>(ref result1));
-		Assert.Equal(LongEnum.MinusOne, Unsafe.As<ulong, LongEnum>(ref result1));
+		Assert.Equal(LongEnum.MinusOne, (LongEnum)result1);
+		Assert.Equal(LongEnum.MinusOne, InternalEnumExtensions.GetEnumValue<LongEnum>(result1));
 
 		Assert.Equal(Int64.MinValue, (long)result2);
-		Assert.Equal(Int64.MinValue, Unsafe.As<ulong, long>(ref result2));
-		Assert.Equal(LongEnum.Min, Unsafe.As<ulong, LongEnum>(ref result2));
+		Assert.Equal(LongEnum.Min, (LongEnum)result2);
+		Assert.Equal(LongEnum.Min, InternalEnumExtensions.GetEnumValue<LongEnum>(result2));
 	}
 
 	[Fact]
-	public void GetBinaryValue_WithUlong_ShouldCastAndUnsafeConvertToUnderlyingTypeCorrectly()
+	public void GetBinaryValue_WithUlong_ShouldCastAndGetEnumValueToUnderlyingTypeCorrectly()
 	{
 		var result = UlongEnum.Max.GetBinaryValue();
-		Assert.Equal(UInt64.MaxValue, result); // Already the type we would cast to
+		Assert.Equal(UInt64.MaxValue, result); // Already the type we would cast to
+		Assert.Equal(UlongEnum.Max, (UlongEnum)result);
+		Assert.Equal(UlongEnum.Max, InternalEnumExtensions.GetEnumValue<UlongEnum>(result));
 	}
 }

DomainModeling/Enums/DefinedEnum.cs

@@ -1,7 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using Architect.DomainModeling.Enums;
-
+using Architect.DomainModeling.Enums;
+
 #pragma warning disable IDE0130 // Namespace does not match folder structure
 namespace Architect.DomainModeling;
 
@@ -68,9 +67,9 @@ public static class UndefinedValues<TEnum>
 		private static readonly bool IsFlags = typeof(TEnum).IsDefined(typeof(FlagsAttribute), inherit: false);
 		internal static readonly ulong AllFlags = Enum.GetValues<TEnum>().Aggregate(0UL, (current, next) => current | next.GetBinaryValue());
 
-		public static TEnum UndefinedValue { get; } = ~AllFlags is var unusedBits && Unsafe.As<ulong, TEnum>(ref unusedBits) is var value && value.GetBinaryValue() != 0UL // Any bits unused?
+		public static TEnum UndefinedValue { get; } = ~AllFlags is var unusedBits && InternalEnumExtensions.GetEnumValue<TEnum>(unusedBits) is var value && value.GetBinaryValue() is not 0UL // Any bits unused?
 			? value
-			: !IsFlags && InternalEnumExtensions.TryGetUndefinedValue(out value) // With all bits used, for non-flags we can still look for an individual unused value, since values are not combined
+			: !IsFlags && InternalEnumExtensions.TryGetUndefinedValue<TEnum>(out value) // With all bits used, for non-flags we can still look for an individual unused value, since values are not combined
 			? value
 			: throw new NotSupportedException($"Type {typeof(TEnum).Name} does not leave any possible values undefined (or flag bits unused).");
 	}

DomainModeling/Enums/InternalEnumExtensions.cs

@@ -1,47 +1,42 @@
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
 namespace Architect.DomainModeling.Enums;
 
 internal static class InternalEnumExtensions
 {
-	private static readonly byte DefaultUndefinedValue = 191; // Greatest prime under 3/4 of Byte.MaxValue
-	private static readonly ushort FallbackUndefinedValue = 49139; // Greatest prime under 3/4 of UInt16.MaxValue
-
+	private static readonly ulong DefaultUndefinedValue = 191; // Greatest prime under 3/4 of Byte.MaxValue
+	private static readonly ulong FallbackUndefinedValue = 49139; // Greatest prime under 3/4 of UInt16.MaxValue
+
 	/// <summary>
 	/// <para>
 	/// Attempts to return one of a small set of predefined values if one is undefined for <typeparamref name="TEnum"/>.
 	/// </para>
 	/// <para>
-	/// Does not accounts for the <see cref="FlagsAttribute"/>.
+	/// Does not account for the <see cref="FlagsAttribute"/>.
 	/// </para>
 	/// </summary>
 	public static bool TryGetUndefinedValueFast<TEnum>(out TEnum value)
 		where TEnum : unmanaged, Enum
-	{
-		var defaultUndefined = Unsafe.As<byte, TEnum>(ref Unsafe.AsRef(in DefaultUndefinedValue));
-		if (!Enum.IsDefined(defaultUndefined))
-		{
-			value = defaultUndefined;
+	{
+		value = GetEnumValue<TEnum>(DefaultUndefinedValue);
+		if (!Enum.IsDefined(value))
 			return true;
-		}
-
-		var fallbackUndefined = Unsafe.As<ushort, TEnum>(ref Unsafe.AsRef(in FallbackUndefinedValue));
-		if (Unsafe.SizeOf<TEnum>() >= 2 && !Enum.IsDefined(fallbackUndefined))
-		{
-			value = fallbackUndefined;
+
+		value = GetEnumValue<TEnum>(FallbackUndefinedValue);
+		if (Unsafe.SizeOf<TEnum>() >= 2 && !Enum.IsDefined(value))
 			return true;
-		}
 
 		value = default;
 		return false;
-	}
-
+	}
+
 	/// <summary>
 	/// <para>
 	/// Attempts to find an undefined value for <typeparamref name="TEnum"/>.
 	/// </para>
 	/// <para>
-	/// Does not accounts for the <see cref="FlagsAttribute"/>.
+	/// Does not account for the <see cref="FlagsAttribute"/>.
 	/// </para>
 	/// </summary>
 	public static bool TryGetUndefinedValue<TEnum>(out TEnum value)
@@ -51,17 +46,17 @@ public static bool TryGetUndefinedValue<TEnum>(out TEnum value)
 			return true;
 
 		var values = Enum.GetValues<TEnum>();
-		System.Diagnostics.Debug.Assert(values.Select(GetBinaryValue).Order().SequenceEqual(values.Select(GetBinaryValue)), "Enum.GetValues() was expected to return elements in binary order.");
-
-		// If we do not end with the binary maximum, then use that
-		var enumBinaryMax = ~0UL >> (64 - 8 * Unsafe.SizeOf<TEnum>()); // E.g. 64-0 bits for ulong/long, 64-32 for uint/int, and so on
+		Debug.Assert(values.Select(GetBinaryValue).Order().SequenceEqual(values.Select(GetBinaryValue)), "Enum.GetValues() was expected to return elements in binary order.");
+
+		// If we do not end with the binary maximum, then use that
+		var enumBinaryMax = ~0UL >> (64 - 8 * Unsafe.SizeOf<TEnum>()); // E.g. 64-0 bits for ulong/long, 64-32 for uint/int, and so on
 		if (values.Length == 0 || values[^1].GetBinaryValue() < enumBinaryMax)
 		{
-			value = Unsafe.As<ulong, TEnum>(ref enumBinaryMax);
+			value = GetEnumValue<TEnum>(enumBinaryMax);
 			return true;
-		}
-
-		// If we do not start with the default, then use that
+		}
+
+		// If we do not start with the default, then use that
 		ulong previousValue;
 		if ((previousValue = values[0].GetBinaryValue()) != 0UL)
 		{
@@ -70,67 +65,86 @@ public static bool TryGetUndefinedValue<TEnum>(out TEnum value)
 		}
 
 		foreach (var definedValue in values.Skip(1))
-		{
-			// If there is a gap between the current and previous item
+		{
+			// If there is a gap between the current and previous item
 			var currentValue = definedValue.GetBinaryValue();
 			if (currentValue > previousValue + 1)
 			{
-				previousValue++;
-				value = Unsafe.As<ulong, TEnum>(ref previousValue);
+				value = GetEnumValue<TEnum>(previousValue + 1);
 				return true;
 			}
 			previousValue = currentValue;
 		}
 
 		value = default;
 		return false;
-	}
-
+	}
+
 	/// <summary>
-	/// Returns the numeric value of the given <paramref name="enumValue"/>.
+	/// Returns the numeric value of the given <paramref name="enumValue"/>.
+	/// Unlike <see cref="GetBinaryValue"/>, this retains negative values for signed enum types.
 	/// </summary>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	public static Int128 GetNumericValue<T>(this T enumValue)
-		where T : unmanaged, Enum
-	{
-		// Optimized by JIT, as Type.GetTypeCode(T) is treated as a constant
-		return Type.GetTypeCode(typeof(T)) switch
-		{
-			TypeCode.Byte => (Int128)Unsafe.As<T, byte>(ref enumValue),
-			TypeCode.SByte => (Int128)Unsafe.As<T, sbyte>(ref enumValue),
-			TypeCode.Int16 => (Int128)Unsafe.As<T, short>(ref enumValue),
-			TypeCode.UInt16 => (Int128)Unsafe.As<T, ushort>(ref enumValue),
-			TypeCode.Int32 => (Int128)Unsafe.As<T, int>(ref enumValue),
-			TypeCode.UInt32 => (Int128)Unsafe.As<T, uint>(ref enumValue),
-			TypeCode.Int64 => (Int128)Unsafe.As<T, long>(ref enumValue),
-			TypeCode.UInt64 => (Int128)Unsafe.As<T, ulong>(ref enumValue),
-			_ => default,
-		};
-	}
-
+	public static Int128 GetNumericValue<TEnum>(this TEnum enumValue)
+		where TEnum : unmanaged, Enum
+	{
+		// Branches optimized away by JIT, as Type.GetEnumUnderlyingType() is [Intrinsic] and treated as a constant
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(byte)) return (Int128)Unsafe.As<TEnum, byte>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(sbyte)) return (Int128)Unsafe.As<TEnum, sbyte>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(ushort)) return (Int128)Unsafe.As<TEnum, ushort>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(short)) return (Int128)Unsafe.As<TEnum, short>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(uint)) return (Int128)Unsafe.As<TEnum, uint>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(int)) return (Int128)Unsafe.As<TEnum, int>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(ulong)) return (Int128)Unsafe.As<TEnum, ulong>(ref enumValue);
+		if (typeof(TEnum).GetEnumUnderlyingType() == typeof(long)) return (Int128)Unsafe.As<TEnum, long>(ref enumValue);
+		throw new UnreachableException();
+	}
+
 	/// <summary>
 	/// <para>
 	/// Returns the binary value of the given <paramref name="enumValue"/>, contained in a <see cref="UInt64"/>.
 	/// </para>
-	/// <para>
-	/// The original value's bytes can be retrieved by doing a cast or <see cref="Unsafe.As{TFrom, TTo}"/> to the original enum or underlying type.
+	/// <para>
+	/// This method is the inverse of <see cref="GetEnumValue"/>.
 	/// </para>
 	/// </summary>
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	public static ulong GetBinaryValue<T>(this T enumValue)
-		where T : unmanaged, Enum
+	public static ulong GetBinaryValue<TEnum>(this TEnum enumValue)
+		where TEnum : unmanaged, Enum
 	{
-		var result = 0UL;
-
-		// Since the actual value may be smaller than ulong's 8 bytes, we must align to the least significant byte
-		// This way, casting the ulong back to the original type gets back the exact original bytes
-		// On little-endian, that means aligning to the left of the bytes
-		// On big-endian, that means aligning to the right of the bytes
+		var result = 0UL;
+
+		// TEnum could be shorter than 8 bytes
+		// Little-endian will automatically write into the least significant bytes, since those are on the left for little-endian
+		// For big-endian, they are on the right, so we need to look at the rightmost portion of the ulong, depending on size of TEnum
+		// For example, a ushort TEnum will look at the rightmost 2 bytes of the ulong
 		if (BitConverter.IsLittleEndian)
 			Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref result), enumValue);
 		else
-			Unsafe.WriteUnaligned(ref Unsafe.Add(ref Unsafe.As<ulong, byte>(ref result), sizeof(ulong) - Unsafe.SizeOf<T>()), enumValue);
+			Unsafe.WriteUnaligned(ref Unsafe.Add(ref Unsafe.As<ulong, byte>(ref result), sizeof(ulong) - Unsafe.SizeOf<TEnum>()), enumValue);
 
 		return result;
+	}
+
+	/// <summary>
+	/// <para>
+	/// Returns the <typeparamref name="TEnum"/> enum value of the given <paramref name="binaryValue"/>.
+	/// </para>
+	/// <para>
+	/// This method is the inverse of <see cref="GetBinaryValue"/>.
+	/// </para>
+	/// </summary>
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	public static TEnum GetEnumValue<TEnum>(ulong binaryValue)
+		where TEnum : unmanaged, Enum
+	{
+		// TEnum could be shorter than 8 bytes
+		// Little-endian will automatically write into the least significant bytes, since those are on the left for little-endian
+		// For big-endian, they are on the right, so we need to look at the rightmost portion of the ulong, depending on size of TEnum
+		// For example, a ushort TEnum will look at the rightmost 2 bytes of the ulong
+		if (BitConverter.IsLittleEndian)
+			return Unsafe.ReadUnaligned<TEnum>(ref Unsafe.As<ulong, byte>(ref binaryValue));
+		else
+			return Unsafe.ReadUnaligned<TEnum>(ref Unsafe.Add(ref Unsafe.As<ulong, byte>(ref binaryValue), sizeof(ulong) - Unsafe.SizeOf<TEnum>()));
 	}
-}
+}