Why does variance apply to static abstract members in interfaces?

[Richiban]

I was surprised to see that this doesn't compile:

public interface IFoo<out T, TThis> where TThis : IFoo<T, TThis>
{    
    public static abstract TThis Create(T val);
}

It results in the usual error error CS1961: Invalid variance: The type parameter 'T' must be contravariantly valid on 'IFoo<T>.Create(T)'. 'T' is covariant. on the T val parameter of the static abstract member Create.

The thing is, I can't figure out why variance applies to static members. The purpose of variance is so that an instance of IFoo<A> :> IFoo<B> iff A :> B (and vice versa), but none of this applies for statics. Perhaps there's an example of code that would not be typesafe if this was allowed, but I can't see it.

---

Strangely enough, this is allowed:

public interface IFoo<out T, TThis> where TThis : IFoo<T, TThis>
{    
    static TThis Create(T val) => throw new NotImplementedException();
}

so it's the abstractness of the member that causes it to be checked for variance; I'm not sure I understand the significance.

[FaustVX]

This is not related to static
sharplab.io
It's because out T generic parameter is only possible in return.

[Richiban]

I think you've misunderstood my question. I'm saying that variance absolutely makes sense for instance methods; I'm saying that it doesn't make sense for static methods. My question is specifically related to statics.

[FaustVX]

Ok, but the variance and static is still not related.
It's the interface that has variance, whether it has static member or not, is irrelevant for the compiler.

You could even have an empty interface with variance and still no warning
interface IFoo<out T, TThis> where TThis : IFoo<T, TThis> {}

[Richiban]

Ok, but the variance and static is still not related

Yes, I know that; I'm asking why. The compiler must, at some point, loop through the members of an interface, checking they comply with the declared variance. I'm saying that it should skip over static members, because variance there makes no sense, and I'm asking why it doesn't do that. I'm looking for examples of code that would be invalid if this were the case.

[FaustVX]

Maybe because the static abstract feature is new, and they didn't though of that situation because instance method does works this way.

[Richiban]

Yeah, I guess it's possible it's just an oversight.

[tfenise]

Variance does apply to static members.

interface IFoo<in T, TThis> where TThis : IFoo<T, TThis>
{
    static abstract TThis Create(T val);
}

class C : IFoo<object, C>
{
    public static C Create(object val) => new C();
}

static class S
{
    static T Create<T>(string val) where T : IFoo<string, T> => T.Create(val);

    static C Create(string val) => Create<C>(val);//this compiles due to contravariance.
}