Why does the JIT box ValueTuple twice, even when TFrom == TTo?

[daiplusplus]

In this thread, I used IL Emit to allow a generic method over ValueTuple to retain C# tuple member names after re-learning that the is operator in if( someValueType is TTo other ) will cause boxing of someValueType.

...but I also saw that the JIT in .NET 5.0 still boxes someValueType when its type TFrom is the same as TTo - which should be entirely unnecessary.

Screenshot proof:

To reproduce, copy and paste this into a .NET 5.0 console project as a Release build:

using System;
using System.Diagnostics;

namespace UnsafeVsSafeBoxing
{
	public static class SafeButBoxedValueCasts<TFrom,TTo>
		where TFrom : struct
		where TTo   : struct
	{
		public static TTo Convert( TFrom source )
		{
			if( source is TTo to )
			{
				return to;
			}
			else
			{
				throw new ArgumentException( message: "Value is not TTo: " + source.GetType().FullName + ".", paramName: nameof(source) );
			}
		}
	}

	public static class Program
	{
		public static void Main( String[] args )
		{
			Console.WriteLine( "Press [Enter] to start..." );
			_ = Console.ReadLine();

			// Warmup and correctness:
			{
//				var a = UnsafeValueCasts      < ValueTuple<Int32,String>, (Int32 x, String y) >.Convert( ( 123, "string1" ) );
				var b = SafeButBoxedValueCasts< ValueTuple<Int32,String>, (Int32 x, String y) >.Convert( ( 456, "string2" ) );
			}

			{
//				var x = UnsafeValueCasts      < (Int32 x, String y), ValueTuple<Int32,String> >.Convert( ( 789, "string3" ) );
				var y = SafeButBoxedValueCasts< (Int32 x, String y), ValueTuple<Int32,String> >.Convert( ( 012, "string4" ) );
			}
			
			const Int32 ITERATIONS = 10 * 1000;

			Stopwatch sw = Stopwatch.StartNew();

			Int64 nvm = 0;

//			for( Int32 i = 0; i < ITERATIONS; i++ )
//			{
//				var x = UnsafeValueCasts< ValueTuple<Int32,String>, (Int32 x, String y) >.Convert( ( i, "string5" ) );
//
//				nvm += x.x; // So the op isn't elided by the compiler.
//			}

			TimeSpan unsafeTime = sw.Elapsed;

			sw.Restart();

			for( Int32 i = 0; i < ITERATIONS; i++ )
			{
				var x = SafeButBoxedValueCasts< ValueTuple<Int32,String>, (Int32 x, String y) >.Convert( ( i, "string6" ) );

				nvm += x.x; // So the op isn't elided by the compiler.
		
			}

			TimeSpan safeTime = sw.Elapsed;

			Console.WriteLine( "Inconsequential sum: {0}", nvm );
			Console.WriteLine( "{0:N0} iterations: Unsafe time: {1:N2}ms. Safe time: {2:N2}ms", ITERATIONS, unsafeTime.TotalMilliseconds, safeTime.TotalMilliseconds );
		}
	}
}

[EgorBo]

@Jehoel in your specific case it should help to add [MethodImpl(MethodImplOptions.AggressiveInlining)] on top of Convert method. Unfortunately we don't elide boxing for this case: https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABAJgEYBYAKGIAYACAZQAtsoAHAGW2ADoASgFcAdhgCW+GAG4ac6jQDaAKXEYA4jBEwo4sAAoMATw4wIAM30A1bABshMACpCOtmAB5xYtA2Lk6AHwAlD7GphbWdg7Orh5eGD5+gUFBALo0xADMvuRIvqTM2OYwAEJCGCUQCDAAJjb2MADCeBi47o4AYlAQ+D6OjhABNAwjDADuLDowDJ3d+AwgDLgYUEJgGMOjE1MzAwtLK2sb1ADemyNZOXn9EAyNECIAbjoYNTX6sz1LEEJQYDBBc4MM7UUZghjicwMfS4H5/abiXC7W4YCCA0HgkYgzGY4gAdgYqNkGMxAF8gWD8QwajBzNghLYMMSweTqKSgA=
because of String in ValueTuple signature (ValueType<int, __Canon>).

[daiplusplus]

Is that behaviour documented anywhere? I don't believe I've ever came across anything that suggested significant differences in performance between generic methods based on whether value-types and reference-types are coexisting in the same generic type or scope - doesn't this also mean that KeyValuePair<TKey,TValue> is also affected by this same gotcha?

[EgorBo]

Is that behaviour documented anywhere?

Boxing is quite popular in generic code, see IL for your method: sharplab - there are even two here.

In some specific cases runtime can optimize it.

KeyValuePair<TKey,TValue> is also affected by this same gotcha?

depends on TKey, TValue and the context. In some patterns we might give up on removing redundant boxings for "shared" structs, e.g. #58554