Allow application of Attributes with "Method" AttributeUsage to expression-bodied properties

[Xenoprimate]

Initially raised here.

Consider the following code:

using System;
using System.Runtime.CompilerServices;
					
public class Program {
	
	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public string X => "X";
	
	public string Y {
		[MethodImpl(MethodImplOptions.AggressiveInlining)] get => "Y";	
	}
	
	public static void Main() { }
}

The first attribute (on property X) fails to compile as it is being applied to a property, rather than a method. However, usage of the alternative syntax [method: MethodImpl(MethodImplOptions.AggressiveInlining)] is not supported by the compiler either, and simply results in the attribute being ignored.

It would be nice to be able to apply Method-level attributes to the newer expression-bodied syntax for properties without having to fall back to the slightly-less-terse version with explicit getters.

[HaloFour]

I think that I'd rather support that via an explicit attribute target in order to avoid ambiguity, perhaps either method or get:

using System;
using System.Runtime.CompilerServices;
					
public class Program {
	
	[method: MethodImpl(MethodImplOptions.AggressiveInlining)]
	public string X => "X";
}

[Xenoprimate]

@HaloFour Yes, support for the method: prefix is what I'm proposing here.

get: would also work too I suppose, although I don't see the need for a new keyword; considering that with this particular syntax there's never going to be a set: method.

[jnm2]

get: would also work too I suppose

Though at that point why not just write the get => and put the attribute there?

[Xenoprimate]

@jnm2 To be fair, this entire request is just to avoid adding the extra get =>. If it gets accepted I doubt it'll be high priority.

It does have an effect in codebases where property get methods tend to have attributes applied a lot of the time though; mostly in terms of line-count.

[glenn-slayden]

@Xenoprimate To be fair, this entire request is just to avoid adding the extra get =>. If it gets accepted I doubt it'll be high priority.

Not entirely; when there's no set accessor, this proposal saves a whole control block of braces, which probably entails some not-insignificant number of all-so-precious newlines, depending on your { ... } code style preference. So I think...

[method: MyMethodAttribute]
public string X => "X";

versus

public string X
{
    [method: MyMethodAttribute]
    get => "X";
}

...is a pretty worthwhile savings. Even if you can abide the following, there's no doubt it's clunkier than the proposed top example:

public string X { [method: MyMethodAttribute] get => "X"; }

[glenn-slayden]

Bump.

If there are backwards-compatibility complications for the language or other syntactic problems with augmenting the behavior of the method: designator keword, the following would also be fine with me:

class MyClass
{
    [getter: DebuggerStepThrough]
    public string X => "Saves vertical space and prevents debugging distractions!";
};

[just-ero]

Would love to see some action on this. :)