Flesh out attributes which affect the language in some way

[jnm2]

https://github.com/dotnet/csharplang/blob/master/spec/attributes.md#reserved-attributes says:

A small number of attributes affect the language in some way. These attributes include:

and lists AttributeUsageAttribute, ConditionalAttribute, ObsoleteAttribute, CallerLineNumberAttribute, CallerFilePathAttribute, and CallerMemberNameAttribute.

Shouldn't DecimalConstantAttribute, DefaultMemberAttribute, DynamicAttribute, ExtensionAttribute, FixedBufferAttribute, IndexerNameAttribute, InternalsVisibleToAttribute, ParamArrayAttribute, and TupleElementNamesAttribute also be listed? Each of those affects what C# syntax may be used. I'm looking for more of these, too.

(Does the presence of DateTimeConstantAttribute in IL, emitted by some other compiler, affect the C# compiler?)

[NightElfik]

Should FlagsAttribute be also on your list? It allows bit-wise operations directly on enums.

[Joe4evr]

Should FlagsAttribute be also on your list? It allows bit-wise operations directly on enums.

Nope, you can use bit-wise operators without FlagsAttribute.

[NightElfik]

@Joe4evr You are right, my bad. However, [Flags] actually changes how .ToString() works:

[Flags]
public enum A {	Foo = 1, Bar = 2 }
public enum B {	Foo = 1, Bar = 2 }

public class Program {
    public static void Main(string[] args) {
        Console.WriteLine((A.Foo | A.Bar).ToString());
        Console.WriteLine((B.Foo | B.Bar).ToString());
    }
}

Output:

Foo, Bar
3

[yaakov-h]

[Flags] doesn't change the language or the syntax, it's merely used at runtime for formatting. The above is controlled here.

[svick]

@jnm2 I think the difference between the two groups is that attributes like ObsoleteAttribute directly appear in C# source, while attributes like DynamicAttribute serve as metadata representation of some C# concept (in this case dynamic).

From the point of view of someone who uses the C# language, but never inspects the generated IL (using Reflection or some other means), you need to know about ObsoleteAttribute, but not about DynamicAttribute, that's just an implementation detail. And I think that's the point of view the spec is written from.

I'm not against calling out attributes from the second group in the spec (since they have an effect on the C# language, in that you are not allowed to use those attributes directly), but they're not on the same level as the ones that are already there.

Also, it might be useful to document how the C# compiler represents its constructs in IL (whether that documentation would be part of the spec or not), since that information is useful for authors of other .Net languages who want to interoperate with C#. But that's probably a different discussion.

[jnm2]

@svick But any of them can appear directly in source and do affect C# syntax when they do. For example, there's no reason I can't write [ParamsArray] instead of params and have the same effect on C# syntax, just like I might write [Conditional("DEBUG")] and watch the effect it has on syntax.

In other words, when listing attributes that “affect the language in some way,” ParamsArrayAttribute and the rest match that heading every bit as much as ObsoleteAttribute.

[svick]

@jnm2

there's no reason I can't write [ParamArray] instead of params and have the same effect on C# syntax

There is:

error CS0674: Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead.

[jnm2]

@svick Good catch, but suffice it to say that you might be writing using 1) an older version of the compiler which doesn't recognize the attribute, 2) a different language like IL where you are still interested in how the attributes “affect the [C#] language in some way,” 3) a tool which needs an exhaustive list of such attributes to reverse-engineer the C# syntax and determine breaking changes to consuming code.

Also, DecimalConstantAttribute, IndexerNameAttribute and InternalsVisibleToAttribute are legal in current C# syntax and have an effect on consuming C# syntax.

[yaakov-h]

InternalsVisibleTo doesn’t actually change the syntax, does it?

[jnm2]

@yaakov-h If you remove or change it, syntax that was previously valid starts giving a visibility error message in exactly the same manner as ObsoleteAttribute.

[svick]

@jnm2 Those are valid reasons to document those attributes and I agree that they should be documented. Though I don't know if the spec is the right place to do it (at least for those that are just metadata representations of C# features like dynamic or params).

[jnm2]

The spec already started down the path of documenting them at https://github.com/dotnet/csharplang/blob/master/spec/attributes.md#reserved-attributes, so I'm not sure why it wouldn't be logical to just flesh out the section. If the section moves to another C#-to-IL-representation spec, so be it. Either way, this issue tracks fleshing it out.

[jnm2]

New one shipping in .NET Framework 4.7.1 too: IsByRefLikeAttribute. This is why I'm asking for a centralized location to see the list of attributes, links to documentation of implementation of the C# feature in IL, and the ability to see updates to the document.

[jnm2]

@gafter, what's the likelihood that this (and similar C# documentation issues) will get organized?

[gafter]

@jnm2 I think it is getting organized right here. We don't currently have any plans to devote our own resources to the task.

[jnm2]

I spotted new ones with C# 7.2:
System.Runtime.CompilerServices.IsReadOnlyAttribute
System.Runtime.CompilerServices.IsByRefLikeAttribute

Any I missed?

[yaakov-h]

There's also NullableAttribute from the NNRT prototype.

[jnm2]

Just put two and two together thanks to @svick and realized SpecialNameAttribute needs to be on the list.

[tannergooding]

@jnm2, most of the attributes in the System.Runtime.CompilerServices and several in the System.Runtime.InteropServices namespace also impact certain things.

SerializableAttribute does as well (it emits the serializable IL flag on the type).

[jnm2]

C# documentation now has 'Language Reference > Attributes read by the compiler'!

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/attributes/general