Extensions: Extension method prevents extension property of the same name from being accessed

[nike4613]

_ = new C().Something(); // OK
_ = new C().Something; // error CS9286: 'C' does not contain a definition for 'Something' and no accessible extension member 'Something' for receiver of type 'C' could be found (are you missing a using directive or an assembly reference?)

class C
{

}

static class D
{
    public static bool Something(this C c) => true;

    extension(C c)
    {
        public bool Something => false;
    }
}

Moving the extension property to a different container class does not change the error. IDE hover seems to usually show the property, but not always (though I can't reproduce when I saw it not doing so).

This is disallowed:

class A
{
    public bool Something => false;
    public bool Something() => true; // error CS0102: The type 'A' already contains a definition for 'Something'
}

But this is allowed, and works as expected:

Console.WriteLine(new A().Something()); // prints True
Console.WriteLine(new A().Something); // prints False

class A
{
    public bool Something => false;
}

static class B
{
    public static bool Something(this A a) => true;
}

Version Used:

error CS8304: Compiler version: '4.14.0-3.25262.10 (8edf7bcd)'. Language version: preview.

[jcouv]

This is by-design. Although this portion was not fully spelled out in the extensions spec yet, it falls out of existing rules for member lookup:

Finally, having removed hidden members, the result of the lookup is determined:
If the set consists of a single member that is not a method, then this member is the result of the lookup.
Otherwise, if the set contains only methods, then this group of methods is the result of the lookup.
Otherwise, the lookup is ambiguous, and a binding-time error occurs.

Your final scenario works because the property is an instance member and the method is an extension method, and instance members always come before extensions. This does not inform how instance members should resolve with other instance members, or how extension members should resolve with other extension members.

Note: for completeness, although this was not in the examples you provided, there is scenario where the compiler deviates from the spec and allows methods and some other members to be resolved together (methods are given preference over non-methods). That is an implementation bug (documented spec deviation) and LDM decided not to carry it forward for extensions (ie. we're sticking to the spec).