Beautify enum declarations by referencing previously declared members

Enum members whose value duplicates an earlier member now reference it
(Item2B = Item2A), [Flags] members combine earlier single-bit members
(All = Item1 | Item2 | Item3) or their complement (NotItem1 = ~Item1)
instead of showing a bare number.

Several guardrails keep the output faithful to how such enums are
written by hand: only previously declared members are referenced (field
row order); a multi-bit value lying entirely within a larger, earlier
member is a field encoding inside that mask, not a flag union, and
stays numeric, as do zero-valued members of [Flags] enums, which
routinely have several unrelated zero members. The ~X form is
suppressed in byte/ushort enum declarations, where the initializer
constant folds in int and would not compile. Enums with unusual
underlying types (bool, native int) keep the plain constant conversion.
With these rules, decompiling System.Private.CoreLib reproduces the
hand-written declarations of TypeAttributes, MethodAttributes,
AttributeTargets and FileAttributes almost verbatim.

Assisted-by: Claude:claude-fable-5:Claude Code

Author: siegfriedpammer

ICSharpCode.Decompiler.Tests/TestCases/Pretty/EnumTests.cs

@@ -51,7 +51,7 @@ public enum EnumDuplicateItemTest
 			Item0 = 0,
 			Item1 = 1,
 			Item2A = 2,
-			Item2B = 2
+			Item2B = Item2A
 		}
 
 		public enum LongBasedEnum : long
@@ -88,7 +88,16 @@ public enum SimpleFlagsEnum
 			Item1 = 1,
 			Item2 = 2,
 			Item3 = 4,
-			All = 7
+			All = Item1 | Item2 | Item3
+		}
+
+		[Flags]
+		public enum SelfReferentialEnum
+		{
+			None = 0,
+			Item1 = 1,
+			Item2 = Item1,
+			Item3 = 3
 		}
 
 		[Flags]
@@ -102,6 +111,78 @@ public enum NegativeValueWithoutFlags
 			Value = -2147483647
 		}
 
+		public enum NonFlagsDuplicateItems
+		{
+			OK = 200,
+			Default = OK,
+			NoContent = 204
+		}
+
+		public enum ZeroDuplicateItems
+		{
+			Unknown = 0,
+			Default = Unknown
+		}
+
+		[Flags]
+		public enum ZeroDuplicateFlags
+		{
+			None = 0,
+			Default = 0,
+			Item1 = 1
+		}
+
+		[Flags]
+		public enum MaskFamilyFlags
+		{
+			VisibilityMask = 7,
+			NotPublic = 0,
+			Public = 1,
+			NestedPublic = 2,
+			NestedPrivate = 3,
+			LayoutMask = 0x18,
+			AutoLayout = 0,
+			SequentialLayout = 8,
+			ExplicitLayout = 0x10
+		}
+
+		[Flags]
+		public enum UnsignedFlags : uint
+		{
+			None = 0u,
+			Item1 = 1u,
+			Item2 = 2u,
+			Item3 = 4u,
+			All = uint.MaxValue,
+			NotItem1 = ~Item1
+		}
+
+		[Flags]
+		public enum ByteFlags : byte
+		{
+			None = 0,
+			Item1 = 1,
+			Item2 = 2,
+			NotItem2 = 0xFD
+		}
+
+		[Flags]
+		public enum ShortFlags : short
+		{
+			None = 0,
+			Item1 = 1,
+			NotItem1 = ~Item1
+		}
+
+		[Flags]
+		public enum FlagsWithNegation
+		{
+			None = 0,
+			Item1 = 1,
+			Item2 = 2,
+			NotItem1 = ~Item1
+		}
+
 		public AttributeTargets SingleEnumValue()
 		{
 			return AttributeTargets.Class;
@@ -142,6 +223,21 @@ public object PreservingTypeWhenBoxedTwoEnum()
 			return AttributeTargets.Class | AttributeTargets.Delegate;
 		}
 
+		public SimpleFlagsEnum SignedEnumComplement()
+		{
+			return ~SimpleFlagsEnum.Item1;
+		}
+
+		public UnsignedFlags UnsignedEnumComplement()
+		{
+			return ~UnsignedFlags.Item2;
+		}
+
+		public ByteFlags ByteEnumComplement()
+		{
+			return ~ByteFlags.Item1;
+		}
+
 		public void EnumInNotZeroCheck(SimpleEnum value, NoZero value2)
 		{
 			if (value != SimpleEnum.Item1)

ICSharpCode.Decompiler/CSharp/CSharpDecompiler.cs

@@ -2369,7 +2369,18 @@ EntityDeclaration DoDecompile(IField field, DecompileRun decompileRun, ITypeReso
 					object? constantValue = field.GetConstantValue();
 					if (constantValue != null)
 					{
-						enumDec.Initializer = typeSystemAstBuilder.ConvertConstantValue(decompilationContext.CurrentTypeDefinition.EnumUnderlyingType!, constantValue);
+						TypeCode underlyingTypeCode = ReflectionHelper.GetTypeCode(decompilationContext.CurrentTypeDefinition.EnumUnderlyingType);
+						if (underlyingTypeCode is >= TypeCode.SByte and <= TypeCode.UInt64)
+						{
+							long initValue = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, false);
+							enumDec.Initializer = typeSystemAstBuilder.ConvertEnumValue(decompilationContext.CurrentTypeDefinition, initValue, field);
+						}
+						else
+						{
+							// Unusual underlying types (bool, native int, ...) cannot be losslessly
+							// squeezed through the long-based member-reference beautification.
+							enumDec.Initializer = typeSystemAstBuilder.ConvertConstantValue(decompilationContext.CurrentTypeDefinition.EnumUnderlyingType!, constantValue);
+						}
 					}
 					enumDec.Attributes.AddRange(field.GetAttributes().Select(a => new AttributeSection(typeSystemAstBuilder.ConvertAttribute(a))));
 					enumDec.AddAnnotation(new MemberResolveResult(null, field));

ICSharpCode.Decompiler/CSharp/Syntax/TypeSystemAstBuilder.cs

@@ -23,6 +23,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
 using System.Runtime.CompilerServices;
 
 using ICSharpCode.Decompiler.CSharp.Resolver;
@@ -1293,26 +1294,47 @@ bool IsFlagsEnum(ITypeDefinition type)
 			return type.HasAttribute(KnownAttribute.Flags);
 		}
 
-		Expression ConvertEnumValue(IType type, long val)
+		/// <summary>
+		/// Converts a numeric enum value into its enum member representation, if possible.
+		/// Uses a series of enum members concatenated by <c>|</c>, if necessary.
+		/// Returns <c>(EnumType)value</c> (or the plain numeric value, if <paramref name="declaringEnumMember"/> is set), if it fails.
+		/// <para>
+		/// If <paramref name="declaringEnumMember"/> is set to a non-<see langword="null"/> value,
+		/// unqualified references are used and self references are avoided. Also, casts to EnumType are dropped.
+		/// </para>
+		/// </summary>
+		internal Expression ConvertEnumValue(IType type, long val, IField? declaringEnumMember = null)
 		{
 			ITypeDefinition enumDefinition = type.GetDefinition()!;
 			TypeCode enumBaseTypeCode = ReflectionHelper.GetTypeCode(enumDefinition.EnumUnderlyingType);
+			bool isFlags = IsFlagsEnum(enumDefinition);
 			var fields = enumDefinition.Fields
 				.Select(PrepareConstant)
-				.Where(f => f.field != null)
+				.WhereNotNull()
 				.ToArray();
-			foreach (var (value, field) in fields)
+			int declaringTokenRowNumber = declaringEnumMember == null ? int.MaxValue : MetadataTokens.GetRowNumber(declaringEnumMember.MetadataToken);
+			foreach (var (value, field, weight) in fields)
 			{
-				if (value == val)
+				// In a [Flags] enum declaration, only reference single-bit members directly:
+				// combined values are built from their flag components below (so that
+				// e.g. All = Item1 | Item2 | Item3), and zero members stay numeric, because
+				// mask-style enums routinely contain several unrelated zero members
+				// (e.g. MethodAttributes.PrivateScope/ReuseSlot).
+				if (value == val && (declaringEnumMember == null || !isFlags || weight == 1))
 				{
-					var mre = new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name);
-					if (AddResolveResultAnnotations)
-						mre.AddAnnotation(new MemberResolveResult(mre.Target.GetResolveResult(), field));
-					return mre;
+					if (field == declaringEnumMember || (declaringTokenRowNumber < MetadataTokens.GetRowNumber(field.MetadataToken)))
+					{
+						return ConvertConstantValue(enumDefinition.EnumUnderlyingType!, CSharpPrimitiveCast.Cast(enumBaseTypeCode, val, false));
+					}
+					return MakeEnumMemberReference(field);
 				}
 			}
-			if (IsFlagsEnum(enumDefinition))
+			if (isFlags)
 			{
+				// The complement of a byte- or ushort-based enum member is computed in int and
+				// therefore negative, which an enum member initializer cannot implicitly convert
+				// back to the underlying type -- the ~X form would not compile there.
+				bool complementCompiles = declaringEnumMember == null || enumBaseTypeCode is not (TypeCode.Byte or TypeCode.UInt16);
 				long enumValue = val;
 				Expression? expr = null;
 				long negatedEnumValue = ~val;
@@ -1333,24 +1355,27 @@ Expression ConvertEnumValue(IType type, long val)
 						break;
 				}
 				Expression? negatedExpr = null;
-				foreach (var (fieldValue, field) in fields.OrderByDescending(f => CalculateHammingWeight(unchecked((ulong)f.value))))
+				foreach (var (fieldValue, field, weight) in fields.OrderByDescending(f => f.weight))
 				{
-					if (fieldValue == 0)
+					if (fieldValue == 0 || field == declaringEnumMember)
 						continue;   // skip None enum value
 
+					if (declaringTokenRowNumber < MetadataTokens.GetRowNumber(field.MetadataToken))
+						continue;
+
 					if ((fieldValue & enumValue) == fieldValue)
 					{
-						var fieldExpression = new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name);
+						var fieldExpression = MakeEnumMemberReference(field);
 						if (expr == null)
 							expr = fieldExpression;
 						else
 							expr = new BinaryOperatorExpression(expr, BinaryOperatorType.BitwiseOr, fieldExpression);
 
 						enumValue &= ~fieldValue;
 					}
-					if ((fieldValue & negatedEnumValue) == fieldValue)
+					if (complementCompiles && (fieldValue & negatedEnumValue) == fieldValue)
 					{
-						var fieldExpression = new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name);
+						var fieldExpression = MakeEnumMemberReference(field);
 						if (negatedExpr == null)
 							negatedExpr = fieldExpression;
 						else
@@ -1359,28 +1384,43 @@ Expression ConvertEnumValue(IType type, long val)
 						negatedEnumValue &= ~fieldValue;
 					}
 				}
-				if (enumValue == 0 && expr != null)
+				// A multi-bit value that lies entirely within a larger, previously declared member
+				// is usually a field encoding inside that mask (e.g. TypeAttributes.NestedPrivate
+				// within VisibilityMask), not a union of independent flags; keep it numeric.
+				bool isEncodedInEarlierMask = declaringEnumMember != null && fields.Any(
+					f => f.field != declaringEnumMember
+						&& MetadataTokens.GetRowNumber(f.field.MetadataToken) < declaringTokenRowNumber
+						&& (f.value & val) == val && f.value != val);
+				if (enumValue == 0 && expr != null && !isEncodedInEarlierMask)
 				{
 					if (!(negatedEnumValue == 0 && negatedExpr != null && negatedExpr.Descendants.Count() < expr.Descendants.Count()))
 					{
 						return expr;
 					}
 				}
-				if (negatedEnumValue == 0 && negatedExpr != null)
+				if (complementCompiles && negatedEnumValue == 0 && negatedExpr != null)
 				{
 					return new UnaryOperatorExpression(UnaryOperatorType.BitNot, negatedExpr);
 				}
 			}
-			return new CastExpression(ConvertType(type), new PrimitiveExpression(CSharpPrimitiveCast.Cast(enumBaseTypeCode, val, false)));
 
-			(long value, IField field) PrepareConstant(IField field)
+			var numericExpression = ConvertConstantValue(enumDefinition.EnumUnderlyingType!, CSharpPrimitiveCast.Cast(enumBaseTypeCode, val, false));
+			if (declaringEnumMember != null)
+			{
+				return numericExpression;
+			}
+			return new CastExpression(ConvertType(type), numericExpression);
+
+			(long value, IField field, int weight)? PrepareConstant(IField field)
 			{
 				if (!field.IsConst)
-					return (-1, null!);
+					return null;
 				object? constantValue = field.GetConstantValue();
 				if (constantValue == null)
-					return (-1, null!);
-				return ((long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, checkForOverflow: false), field);
+					return null;
+				var value = (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, checkForOverflow: false);
+				var weight = CalculateHammingWeight(unchecked((ulong)value));
+				return (value, field, weight);
 			}
 
 			// see https://en.wikipedia.org/wiki/Hamming_weight
@@ -1395,6 +1435,24 @@ int CalculateHammingWeight(ulong value)
 				x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
 				return unchecked((int)((x * h01) >> 56));  //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 
 			}
+
+			Expression MakeEnumMemberReference(IField field)
+			{
+				if (declaringEnumMember == null)
+				{
+					var mre = new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(type)), field.Name);
+					if (AddResolveResultAnnotations)
+						mre.AddAnnotation(new MemberResolveResult(mre.Target.GetResolveResult(), field));
+					return mre;
+				}
+				else
+				{
+					var ie = new IdentifierExpression(field.Name);
+					if (AddResolveResultAnnotations)
+						ie.AddAnnotation(new MemberResolveResult(null, field));
+					return ie;
+				}
+			}
 		}
 
 		static bool IsValidFraction(long num, long den)

ICSharpCode.Decompiler/Util/CollectionExtensions.cs

@@ -253,6 +253,30 @@ public static IEnumerable<U> SelectWithIndex<T, U>(this IEnumerable<T> source, F
 			}
 		}
 
+		/// <summary>
+		/// Filters out null elements, narrowing the element type to non-nullable.
+		/// </summary>
+		public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source) where T : class
+		{
+			foreach (var item in source)
+			{
+				if (item != null)
+					yield return item;
+			}
+		}
+
+		/// <summary>
+		/// Filters out null elements and unwraps the remaining values.
+		/// </summary>
+		public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source) where T : struct
+		{
+			foreach (var item in source)
+			{
+				if (item.HasValue)
+					yield return item.GetValueOrDefault();
+			}
+		}
+
 		/// <summary>
 		/// The merge step of merge sort.
 		/// </summary>