The error: CS0236 is reported incorrectly on a nullable enum property with same name as enum type.

[JoeRobich]

As reported by @PaulHazelton in dotnet/vscode-csharp#4763

The following code produces the CS0236 error incorrectly:

#nullable enable
namespace MyNamespace
{
	public enum MyEnum
	{
		VALUE1,
		VALUE2
	}

	public class MyClass
	{
		public MyEnum? MyEnum { get; set; } = MyEnum.VALUE1;	// <-- this line produces CS0236
		// If the question mark is omitted, there is no error reported.
	}
}

Without the question mark, the compiler correctly knows that MyEnum at (Ln 12, Col 46) is referring to the enum type, not the property. However, with the question mark the error is reported, the compiler seems to think that (Ln 12, Col 47) refers to the property MyEnum instead of the type.

I'm not sure if this issue is caused by the omnisharp-vscode extension, or by a compiler (and I'm not sure what compiler I'm using).

Note that this error is entirely avoidable by having the property name differ from the type name, however this is recommended by Microsoft

CONSIDER giving a property the same name as its type.
For example, the following property correctly gets and sets an enum value named Color, so the property is named Color:

[alrz]

(If you were wondering)

error CS0236: A field initializer cannot reference the non-static field, method, or property 'MyClass.MyEnum'

[RikkiGibson]

This appears to be a request to change name lookup rules. Has the compiler always had this behavior?

[jaredpar]

This behavior is "By Design". Most of the relevant information is contained in the identical simple names and type names portion of the specification.

Essentially in the case where you have an expression in the form E.I where E can refer to both a type name or a value (property, field, etc ...) then the compiler will consider both possible interpretations and choose the one without error. This only happens though when the type of E as an expression is the same type when E is considered as a type.

In the case without Nullable<T> the type of the property MyClass.MyEnum is the same as MyEnum. Once the return type is Nullable<MyEnum> though then this does not hold, hence the disambiguation does not come into play here.

[CyrusNajmabadi]

Yup. Was about to say what jared said. This is almost the Color Color case. That said, if you are interested in this working, you could start a discussion over at dotnet/csharplang about if it's worthwhile to relax the language to allow this to work.