Reduce enum stubs codegen with NativeAOT

[Sergio0694]

This PR includes some optimizations to reduce the codegen a bit more for Marshaler<T> with enum types.
It also is a little performance optimizations in that all shared stubs are now properly cached with beforefieldinit too.

[Sergio0694]

Changing this back to draft as it doesn't actually seem to be improving the size.
There's one thing though that I don't understand: both before and after, we're instantiating all lambdas for all types:

But in both cases, all of this code is guarded under some typeof(T).IsEnum check:

CsWinRT/src/WinRT.Runtime/Marshalers.cs

Lines 1568 to 1581 in ae69551

	if (typeof(T).IsEnum)
	{
	// For marshaling non-blittable enum arrays via MarshalNonBlittable
	if (typeof(T).GetEnumUnderlyingType() == typeof(int))
	{
	CopyAbi = Marshaler.CopyIntEnumFunc;
	CopyManaged = (T value, IntPtr dest) => Marshaler.CopyIntEnumFunc(value, dest);
	}
	else
	{
	CopyAbi = Marshaler.CopyUIntEnumFunc;
	CopyManaged = (T value, IntPtr dest) => Marshaler.CopyUIntEnumFunc(value, dest);
	}
	}

@MichalStrehovsky would you know why is the linker apparently not respecting this? We're wasting a lot of size just compiling generic versions of all of those helpers that we know could not possibly be used. Why is this happening despite the check? 🤔

[MichalStrehovsky]

@MichalStrehovsky would you know why is the linker apparently not respecting this? We're wasting a lot of size just compiling generic versions of all of those helpers that we know could not possibly be used. Why is this happening despite the check?

This is constructing delegates, so:

• Are you on .NET 9?
• Do you have Delegate.Method somewhere in the program?

Without those, the whole program analysis will figure out the targets of reflection before RyuJIT starts eliminating unreachable codepaths and that's a done deal unfortunately.

[Sergio0694]

Ooh I see, thank you! I guess this is just also blocked by #1444 then and fixing that will also improve this. Thank you! 🙂

[Sergio0694]

@MichalStrehovsky I don't get how this is still regressing on .NET 9, and we're not using .Method anymore. I see this:

With roots like this one:

I don't understand where are all of those generic instantiations coming from and on what closure. This PR literally only removes an existing lambda expression and replaces it with a cached, reused delegate. The weird thing is that I also don't see any generic instantiation over WithTypedT1<T>, so it's not like that path is being compiled multiple times. But then where are all of those new generic instantiations for that <>c type coming from? I don't get why is this PR regressing size 😅

[Sergio0694]

Chatted with Michal, publishing this as it's not actually regressing, just not improving much.