Nested type support for 'enum' types

[tagcode]

Classes, structs, record, interfaces all allow nested types, but enums do not. Would it be possible to add support for 'enum' types also?

public static void Do<T>(T obj) where T : MyEnum.IProperty
{
    if (obj.HasAll(MyEnum.Flag1 | MyEnum.Flag2)) { } // .. do something
}

[Flags]
public enum MyEnum : int
{
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4;

    public interface IProperty {
        MyEnum Flags { get; set; }
    }

    public static class Extensions {
        public static bool HasAll(this IProperty enumProperty, MyEnum expectedFlags) => (enumProperty.Flags & expectedFlags) == expectedFlags;
    }
}

[jnm2]

I would also really like to be able to declare methods and properties inside enums.

[colejohnson66]

I've long desired this too, and was hoping implicit extensions would help, but they've been pushed off again (for valid reasons, though).

IIRC, as far as the IL is concerned, an enum is just a class inheriting from System.Enum that contains a single (value) field, and static literal (consts) for each entry. So there's nothing inherent in the IL to prevent methods and properties (the runtime may have assumptions that would need to be changed).

[tagcode]

Yeah. Lets see what it could look like.

[Flags]
public enum MyEnum : int
{
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4;

    public bool HasAll(MyEnum expectedFlags) => (this & expectedFlags) == expectedFlags;
    public bool HasAny(MyEnum expectedFlags) => (this & expectedFlags) != 0;
    public MyEnum WithFlag3 => this | Flag3;
    public MyEnum WithoutFlag3 => this & ~Flag3;
}

Nice. Kind of like a struct.

[tagcode]

I'd like to be able to implement interfaces too. For example ISpanParsable.

[Flags]
public enum MyEnum : int, ISpanParsable<MyEnum>
{
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4;

    public static MyEnum Parse(ReadOnlySpan<char> s, IFormatProvider? provider) => throw new NotImplementedException();
    public static MyEnum Parse(string s, IFormatProvider? provider) => throw new NotImplementedException();
    public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out MyEnum result) => throw new NotImplementedException();
    public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out MyEnum result) => throw new NotImplementedException();
}

[tagcode]

And implicit operators

[Flags]
public enum MyEnum : int
{
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4;

    public static implicit operator OtherType(MyEnum enum) => new OtherType(...);
}

[TahirAhmadov]

@tagcode I think it's better to have a semicolon after the last enum option and before other members.