12.6.6 function member invocation lacks specification of timing of reading receiver

[GeeLaw]

Describe the bug In 12.6.6 function member invocation, for E.M(args...), if E is not value type or does not implement M, then:

1. evaluate E
2. evaluate args...
3. if E is value type, box it and treat it as the boxed instance
4. invoke M

Suppose E is classified as a variable, then it's unclear when the value of E is read. Is it right after 1, or right before 3? The two options are not equivalent, because evaluation of args... could modify the value stored in that variable.

After some testing, it turns out that

• when E is reference type, the value (reference) is read right after 1,
  • Suppose E is the identifier of a local variable and args... reassigns this variable, the receiver of E.M(args...) is the (old) object before reassignment.
• but, when E is value type, the value is read right before 3.
  • Suppose E is the identifier of a local variable and args... reassigns this variable, the receiver of E.M(args...) is a boxed instance of the reassigned (new) value.

The timings are different!

Example

See replies to this issue.

Expected behavior

The standard should clearly specify the timing of reading of value from variable.

Additional context

Found when investigating the semantics of constrained. callvirt.. See dotnet/dotnet-api-docs#12359.

[GeeLaw]

In the code below:

• The first, inner invocation of Foo is always on variable face1 after assignment.
• The second, outer invocation of Foo is always on variable face1. The second line of output in each case will show whether the value of face1 for the outer invocation is read before/after evaluation of arguments.

Test code:

using System;
using System.Runtime.CompilerServices;

namespace SomewhatSurprising
{
  class Program
  {
    interface IFace
    {
      virtual int Foo(int bar)
      {
        Console.WriteLine("IFace.Foo on " + ToString());
        return 0;
      }
    }

    [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
    static ref T Assign<T>(ref T dst, T src)
    {
      dst = src;
      return ref dst;
    }

    [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
    static void Foo_IFace(IFace face1, IFace face2)
    {
      try
      {
        face1.Foo(Assign(ref face1, face2).Foo(0));
        Console.WriteLine("Foo, IFace.");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Foo, IFace: " + ex.Message);
      }
    }

    [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
    static void Foo_TFace<TFace>(TFace face1, TFace face2) where TFace : IFace
    {
      try
      {
        face1.Foo(Assign(ref face1, face2).Foo(0));
        Console.WriteLine("Foo, TFace.");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Foo, TFace: " + ex.Message);
      }
    }

    [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
    static void Foo_TFace_class<TFace>(TFace face1, TFace face2) where TFace : class, IFace
    {
      try
      {
        face1.Foo(Assign(ref face1, face2).Foo(0));
        Console.WriteLine("Foo, TFace, class.");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Foo, TFace, class: " + ex.Message);
      }
    }

    [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
    static void Foo_TFace_struct<TFace>(TFace face1, TFace face2) where TFace : struct, IFace
    {
      try
      {
        face1.Foo(Assign(ref face1, face2).Foo(0));
        Console.WriteLine("Foo, TFace, struct.");
      }
      catch (Exception ex)
      {
        Console.WriteLine("Foo, TFace, struct: " + ex.Message);
      }
    }

    class CFoo : IFace
    {
      private int id_;
      public CFoo(int id) { id_ = id; }
      public int Foo(int bar)
      {
        Console.WriteLine("CFoo.Foo on CFoo " + id_.ToString());
        return bar;
      }
    }

    struct SFoo : IFace
    {
      private int id_;
      public SFoo(int id) { id_ = id; }
      public int Foo(int bar)
      {
        Console.WriteLine("SFoo.Foo on SFoo " + id_.ToString());
        return bar;
      }
    }

    struct SBox : IFace
    {
      private int id_;
      public SBox(int id) { id_ = id; }
      public override string ToString()
      {
        return "SBox " + id_.ToString();
      }
    }

    static void Main()
    {
      // class
      Foo_IFace(new CFoo(1), new CFoo(2));
      Console.WriteLine();
      Foo_TFace(new CFoo(1), new CFoo(2));
      Console.WriteLine();
      Foo_TFace_class(new CFoo(1), new CFoo(2));
      Console.WriteLine();
      // struct, not implementing
      Foo_IFace(new SBox(1), new SBox(2));
      Console.WriteLine();
      Foo_TFace(new SBox(1), new SBox(2));
      Console.WriteLine();
      Foo_TFace_struct(new SBox(1), new SBox(2));
      Console.WriteLine();
    }
  }
}

For reference type (IFace, CFoo), let the objects initially referred to by face1, face2 be obj1, obj2, respectively, then consistently face1.Foo(Assign(ref face1, face2).Foo(0)) causes:

• first, inner invocation of Foo on obj2;
• second, outer invocation of Foo on obj1, although face1 refers to obj2 after evaluation of arguments.

The value in face1 for the outer invocation is read before evaluating argument expression Assign(ref face1, face2).Foo(0).

For value type not implementing the target method (SBox), for face1.Foo(Assign(ref face1, face2).Foo(0)), the execution is as follows:

• reference to face1 is stored (which refers to a value value1), as the outer invocation receiver;
• call Assign(ref face1, face2), causing face1 to have value2 referred to by face2 and having a ref return ref ref3, which happens to be ref face1;
• box value in ref3 (i.e., value2) to obtain obj4;
• call Foo on obj4;
• box value in face1 (this is the outer face1; i.e., value2) to obtain obj5;
• call Foo on obj5.

The value in face1 for the outer invocation is read after evaluating argument expression.

This is proven by the output:

CFoo.Foo on CFoo 2
CFoo.Foo on CFoo 1
Foo, IFace.

CFoo.Foo on CFoo 2
CFoo.Foo on CFoo 1
Foo, TFace.

CFoo.Foo on CFoo 2
CFoo.Foo on CFoo 1
Foo, TFace, class.

IFace.Foo on SBox 2
IFace.Foo on SBox 1
Foo, IFace.

IFace.Foo on SBox 2
IFace.Foo on SBox 2
Foo, TFace.

IFace.Foo on SBox 2
IFace.Foo on SBox 2
Foo, TFace, struct.