Static Abstracts in Interface - Design Question

[giladfrid009]

I've been thinking about it, and can't figure out why use the abstract keyword for declaring such methods.
Why the declaration syntax for such methods is:

interface Foo
{
    static abstract int Bar();
}

and not simply:

interface Foo
{
    static int Bar();
}

I think the declaration syntax without abstract is more clear, and is more consistent with the design of other features of interfaces. i.e:

interface Foo
{
    int Bar1(); //regular interface method
    int Bar2() { return 0; } //default interface method
    static int Bar3(); //regular static interface method
    static int Bar4() { return 0; } //default static interface method
}

[huoyaoyuan]

Because static methods in interfaces were introduced in C# 8, and means non-abstract method.

[Phantonia]

Interface types already support classic static members since C# 8 I believe:

https://sharplab.io/#v2:EYLgtghglgdgNAFxAJwK4wD4AEBMBGAWAChiBJUmBAU2QDMIBjKgOgAkqAbDgewHVvkHACYAKAJQBuYsVjU6jKgAJylGvSbEA3sUW7FWACyKAytzBV+yANbipRPYp16seAGz6j7LnwHDxT3W17B2c8AE4RACIvHkUAd18hSMkAxQBfYjSgA=

The abstract modifier is needed in order to not change the meaning of existing code. Static members without a body do not compile today but it would be too confusing for static members to mean two drastically different things.

[giladfrid009]

I'm aware regarding the existing static members, but currently the behavior for non-static methods in interface is:

• no body -> abstract
• has body -> default implementation

Why not to use the same logic with static methods in interfaces, especially since currently static methods without a body do not compile?
I don't think the behavior is confusing with non-static interface methods, and therefore I don't think that implementing static methods the same way would be confusing.
For me personally, adding abstract creates more confusion since this keyword is associated (at least so far) with classes.

[CyrusNajmabadi]

no body -> abstract

Consider:

static int Prop { get; }

This is static with no body. But this means it's an auto prop (that's not abstract).

So to make it abstract we need a way to mark it as such. And because of that, we would want methods to be consistent with this.

[333fred]

Additionally, if we ever want to support DIMs for static virtuals (which we do) we'd need a keyword for that anyway. Better to keep the experience between those the same.

[giladfrid009]

This is static with no body. But this means it's an auto prop (that's not abstract).

I see the reason, even thought currently a non-static property of this form is considered abstract: int Prop { get; }.
The only way, as far as I know, of implementing an interface property within the interface itself is by adding a getter or a setter body.
Therefore there would be an inconsistency between:

• static int Prop { get; } -> not abstract
• int Prop { get; } -> abstract