Explicit this/base keywords in the nameof expression at the attribute argument

[Takym]

The feature, which is nameof(this.XXX), was allowed as "a bug" and has been abolished because it violates the language specification (for more details, see dotnet/roslyn#82251). I propose that this feature be restored, and the base keyword should also be supported in the same way.

public class C
{
    public int P { get; set; }

    [SomeAttribute(nameof(this.P))] // abolished
    [SomeAttribute(nameof(P))]      // current workaround
    public void M()
    {
        /* ... */
    }
}

I organize the benefits and drawbacks here, including the points raised in the issue dotnet/roslyn#82251 and my points.

Benefits are:

1. Can clearly explain intentions to other programmers that an instance member is referenced.
2. Can receive IDE/compiler support in ambiguity scenario: accurate descriptions in the tooltip, refactoring for renaming, existence check of instance members, filtered code completion list by instance members, etc.
3. Can compile existing codebases that use nameof(this.XXX) again.

Drawbacks are:

1. It may feel redundant to add this/base prefix to a member name.
   • I think there is no problem with just providing a choice. I agree that it costs writers to type, but it does not cost readers.
2. nameof does not support another disambiguity. Why should this be treated as special?
   • I believe it makes sense to make improvements that eliminate ambiguity, even if it does not cover all cases.
3. Implementing this feature may make the compiler code complex.

[MulleDK19]

It may also feel redundant to add this. to any other access, but it makes it very quickly clear that you're referring to an instance member rather than a static member.

This "bug" did absolutely not need fixing; the specification did.. they don't make specific updates to the language because it might break existing projects, but this "fix" literally broke every single code base I have..

[rickbrew]

I agree completely, I'd really like this to be "un"-fixed

[AartBluestoke]

are there any circumstances where 'this' is required - inside a function a local variable can shadow a member,

current style recommendations are :
"In C#, use the this keyword primarily to resolve naming conflicts between local variables/parameters and class members (fields/properties). While some developers use this. consistently to improve readability and identify member access, it is generally considered syntax bloat when not strictly required"

when things are ambiguous, do we care:

one of the examples at https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/this is

public class Employee
{
    private string alias;
    private string name;

    [SomeAttribute(nameof(alias))]  <-- do we care that without 'this', we can't disambiguate the parameter below vs this.alias above?
    public Employee(string name, string alias)
    {
        // Use this to qualify the members of the class
        // instead of the constructor parameters.
        this.name = name;
        this.alias = alias;
    }
}