Proposal: Allow variance on interface implementation

[huoyaoyuan]

When the member method's signature does not exactally equal to the interface member, but suitable to the variance rule, let the compiler generate an EIMI method to do the convertion.
The variance rule here can be more wider than delegate/interface, since boxing can be done in the generated method.

Sample:

The most famous sample is IEnumerable<T>. It inherits from IEnumerable, which contains a method GetEnumerator() that has same name but different return type, so every class implements it has to provide an EIMI method.

class A<T> : IEnumerable<T>
{
    struct Enumerator : IEnumerator<T>
    {
        //...
    }
    public Enumerator GetEnumerator() => new Enumerator(this);
}

Generated:

IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); //boxing here
IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();

And in the case that a public IEnumerator<T> GetEnumerator() is provided, the EIMI IEnumerable.GetEnumerator() can also be generated.

Question

Does CLR requires exactly same signature on interface implementing (in verifiable code)?
If not, EIMI mothod that just does implicit reference conversions can be skipped. Boxing conversions always need one.

[jnm2]

What is EIMI?

[huoyaoyuan]

@jnm2 Explicit Interface Member Implementations.