Enum constants are decompiled as their underlying type

[cervengoc]

It seems like decompiling an expression like this results loosing the enum type of the constant TestEnum.First, and having only an Int32 value of 1.

public enum TestEnum {
  None = 0,
  First = 1,
  Second = 2
}

public class Test {
  public TestEnum EnumProperty { get; set; }
  [Decompileable]
  public bool IsFirst { get { return EnumProperty == TestEnum.First; } }
}

[hazzik]

The compiler will create the same expression. There are tests which verify that.

[drielnox]

Is this corrected? I have the latest version and have problems with this in particular. Here's a sample of my code.

    public enum MovementStateEnum
    {
        Unknown = 0,
        Pending = 1,
        Active = 2,
        Done = 3,
        Aborted = 4,
    }

    public abstract class Position
    {
        public int Capacity { get; protected set; }

        public int AvailableCapacity =>
            Capacity
            - Containers.Count(x => x.ContainerStateId == ContainerStateEnum.Stored)
            // walk-around to work
            //- IncomingMovements.Count(x => new[] { (int)MovementStateEnum.Pending, (int)MovementStateEnum.Active }.Contains((int)x.StateId));
            - IncomingMovements.Count(x => new[] { MovementStateEnum.Pending, MovementStateEnum.Active }.Contains(x.StateId));

        public virtual ICollection<Container> Containers { get; protected set; }

        public virtual ICollection<Movement> IncomingMovements { get; protected set; }
    }

        public RackPosition GetAvailablePosition(int entryStrategyId, ABCCodeEnum productIr)
        {
            var bestPosition = Set
                .Where(x => x.Zone.EntryStrategyZones
                    .Any(y => y.EntryStrategyId == entryStrategyId))
                .Where(x => !x.BlockedIn)
                .Where(x => x.IsAvailable)
                .Where(x => x.AvailableCapacity.Computed() > 0)
                .OrderBy(x => x.Zone.EntryStrategyZones
                    .Select(y => y.Order)
                    .FirstOrDefault())
                .ThenByDescending(x => x.ABCCode <= productIr
                    ? 'Z' - 'A' - x.ABCCode - (int)productIr
                    : x.ABCCode - 'A')
                .ThenBy(x => x.Isle.Priority)
                .ThenBy(x => x.YScore)
                .ThenBy(x => x.XScore);

            return bestPosition
                .Decompile()
                .FirstOrDefault();
        }

And throws this:

System.InvalidOperationException: An expression of type 'System.Int32' cannot be used to initialize an array of type 'MovementStateEnum'