Consider supporting shared code over enums

[MichalStrehovsky]

We could potentially do code sharing for enums that have the same underlying type. It would fix the issue that the non-generic Enum.GetValues currently needs to be marked AOT unfriendly, or that ASP.NET needs to do workarounds like dotnet/aspnetcore#35167 when reflection-activating Enum.TryParse<T>.

I would explicitly not go as far as code sharing with the underlying primitive type (List<SomeEnum> and List<int> would not canonicalize into the same thing) because typeof(T) == typeof(byte) and friends are often used for generic specialization in high performance code.

I'm not aware of enums being used for generic specialization in this sense, so maybe shared code for enums would be an acceptable compromise?

[jkotas]

I think that the scenarios that would be helped by this (like the ASP.NET example) are likely to have other more fundamental problems with NativeAOT compatibility. I am not convinced that this would be worth doing.

[MichalStrehovsky]

Makes sense. I'll close this for now but we can reopen if we see more wide applicability.

[davidfowl]

Is Enum.GetValues AOT unfriendly only if the Type can't be determined statically via DAM?

[MichalStrehovsky]

Enum.GetValues(Type) is unfriendly always. We don't have a DAM to specify "I would like to be able to create arrays of whatever is annotated with this at runtime". We could come up with one. Not sure it would match what DAM means. (The problem with the API is that it creates the array at runtime and arrays implement a bunch of interfaces like IList<T> that have code in it).

Enum.GetValues<T> is always safe, unless you try to MakeGenericMethod it at runtime. Then it's unsafe.

[MichalStrehovsky]

The signature of Enum.GetValues(Type) is that it returns System.Array, but the actual underlying array is T[]. We could return Underlying_Type_Of_T[] instead and that one would be always safe, but there was some compat problem I don't recall anymore that caused us to go to T[], with all of its problems.

[Suchiman]

If this proposal were implemented, then T[] where T : Enum would always be safe because only Underlying_Type_Of_T[] needs to be compiled for it to work? makes me wonder how much size saving that could get with all the crap that arrays implement.

[MichalStrehovsky]

Yeah, arrays implement a lot of stuff because of the generic interfaces. It would be a size saving, but I don't expect much more than 1%.

I tried to hack this in once, but I don't remember how far that actually went: MichalStrehovsky/corert@72cdc63

Looking at the commit, since then we made CanonBaseType derive from MetadataType so a couple of those odd places that deal with "uh oh, this is not MetadataType" can be removed.