C# 13 ref struct interfaces - explicit interface members

[tmds]

Describe the issue or suggestion

The documentation on ref struct interfaces here: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-13#ref-struct-interfaces is stating:

From that rule, ref struct types can't declare methods that explicitly implement an interface method.

What does this mean?

I thought it meant the following would be disallowed, but it works fine.

MyRefStruct s = default;
CallFoo(s);

void CallFoo<T>(T instance) where T : IA, IB, allows ref struct
{
    CallFooForIA(instance);
    CallFooForIB(instance);
}

void CallFooForIA<T>(T instance) where T : IA, allows ref struct
    => instance.Foo();

void CallFooForIB<T>(T instance) where T : IB, allows ref struct
    => instance.Foo();

interface IA
{
    void Foo() { }
}

interface IB
{
    void Foo() { }
}

ref struct MyRefStruct : IA, IB
{
    void IA.Foo() { Console.WriteLine("IA.Foo"); }
    void IB.Foo() { Console.WriteLine("IB.Foo"); }
}

cc @BillWagner

[BillWagner]

Great catch @tmds

Your example points to a subtlety in the restriction on explicit interface implementation and ref struct: The only way to call that method is through a generic method that has the allow ref struct anti-constraint.

See this sharplab for a slight addition to your sample:

using System;

MyRefStruct s = default;
CallFoo(s);
DirectCallFooIA(s); // error CS1503: cannot convert from `MyRefStruct` to `IA`

void CallFoo<T>(T instance) where T : IA, IB, allows ref struct
{
    CallFooForIA(instance);
    CallFooForIB(instance);
}

void DirectCallFooIA(IA instance) => instance.Foo();

void CallFooForIA<T>(T instance) where T : IA, allows ref struct
    => instance.Foo();

void CallFooForIB<T>(T instance) where T : IB, allows ref struct
    => instance.Foo();

interface IA
{
    void Foo() { }
}

interface IB
{
    void Foo() { }
}

ref struct MyRefStruct : IA, IB
{
    void IA.Foo() { Console.WriteLine("IA.Foo"); }
    void IB.Foo() { Console.WriteLine("IB.Foo"); }
}

This text should clarify that restriction. In addition, the text on the ref struct language reference should be augmented with this information.

[BillWagner]

The compiler can generate code to call a Dispose method that is explicitly implemented as well. See sharplab

using System;

using var s = new S();

s.M();

public ref struct S : IDisposable 
{
    public void M() {}
    void IDisposable.Dispose() {
    }
}