Nullable value type receiver of a constrained call is unexpectedly copied

[AlekseyTs]

        [Fact]
        public void GenericTypeParameterAsReceiver_Call_Nullable()
        {
            var source = @"
using System;

#pragma warning disable CS0659 // 'Item' overrides Object.Equals(object o) but does not override Object.GetHashCode()
    
struct Item
{
    public int Count;

    public override bool Equals(object obj)
    {
        Console.WriteLine(""Position Equals for item '{0}'"", Count);
        return base.Equals(obj);
    }
}

class Program
{
    static void Main()
    {
        Item? item1 = new Item {Count = 1};
        Call1(item1);
        Item? item2 = new Item {Count = 2};
        Call2(ref item2);
    }

    static void Call1<T>(T item)
    {
        item.Equals(GetOffset(ref item));
    }

    static void Call2<T>(ref T item)
    {
        item.Equals(GetOffset(ref item));
    }
    
    static int value = 0;
    static int GetOffset<T>(ref T item)
    {
        item = (T)(object)new Item {Count = --value};
        return 0;
    }
}
";
            var verifier = CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: @"
Position Equals for item '-1'
Position Equals for item '-2'
").VerifyDiagnostics();
        }

Observed:

Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen.CodeGenCallTests.GenericTypeParameterAsReceiver_Call_Nullable [FAIL]
  Roslyn.Test.Utilities.ExecutionException : 
  Execution failed for assembly 'd9d40dcd-4b54-4258-8425-bf38af6ab1e7, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
  Expected: 
  Position Equals for item '-1'
  Position Equals for item '-2'
  
  Actual: Position Equals for item '1'
  Position Equals for item '2'

This is a regression from #65642

[AlekseyTs]

Reverting the fix due to dotnet/runtime#80429 (comment)

[AlekseyTs]

The scenario that is affected is very restricted:

• The unexpected copy is created only for an invocation of a virtual method declared by System.Object or by System.ValueType.
• The unexpected copy is created only if the method invocation has non-trivial argument.
• The fact that the copy is taken can be observed only if the method is overridden by System.Nullable<T> (otherwise the receiver is going to be boxed and copied anyway).

At the moment, System.Nullable<T> overrides ToString, GetHashCode and Equals. Only Equals meets all the requirements. So, only invocations of Equals could potentially be performed on a receiver that doesn't have mutations that the argument expression performs. Only for invocation of Equals mutations performed by Equals of the underlying type potentially are not be observable by the caller in the receiver of System.Nullable<T> type.

Given this, we are comfortable with not fixing this regression for now. We might revisit this decision once a code gen strategy with acceptable performance characteristics becomes available.