[PATCH] D93630: [Attr] Apply GNU-style attributes to expression statements

[Aaron Ballman via Phabricator via cfe-commits]

aaron.ballman added a comment.

In D93630#2468168 <https://reviews.llvm.org/D93630#2468168>, @vsavchenko wrote:

> @aaron.ballman I totally agree, but I also would like to understand. 
> `__attribute__` is a GNU extension, right?

Correct.

> Then why does it affect the grammar of C?  I always thought that attributes should be somewhat transparent for parsers, but it looks like in this situation all compilers automatically assume that `__attribute__` begins a declaration.

GNU attributes are kind of awful in that they "slide" around to whatever construct seems to make the most sense based on the given attribute. My guess is that this assumption is baked into compilers because otherwise there would be parsing ambiguities. e.g., `__attribute__((attr)) int x = ..., y, z;` could either be a declaration attribute that applies to `x`, `y`, and `z` or maybe it's a statement attribute that's meant to suppress a diagnostic on the initialization of x (that sort of thing), and it would take too much lookahead to make a determination based on the attribute name.

> It is unclear to me why `*x;`, `[[unknown]] *x;` (dereference of x) and `__attribute__((unknown)) *x;` (declaration of `int *`) have different meanings.

C and C++ style attributes have a very well-defined meaning in terms of what they appertain to based on the syntactic location of the attribute rather than based on the name of the attribute. That's why `[[attr]] *x;` and `__attribute__((attr))) *x` behave differently.

> Does it essentially mean that there is no way to implement statement attributes in C/Obj-C?
> Because even if we introduce some heuristics for understanding that what we parsed is a declaration attribute -> what follows must be a declaration, attributes that can be applied to both declaration and statements will cause confusion.

That was really the crux of the problem I kept running into as well. I wouldn't say there's "no way" to do it, but it's not as trivial as it feels like it should be.

If we could tell that the attribute is a decl or stmt attribute, we could throw our hands up in that specific circumstance and say "this code is ambiguous", but then we're extending the syntactic locations of where GNU attributes can be written and what they mean (so we'd diverge from GCC). But then again, we've done that before (such as with allowing you to write a GNU-style attribute on a function definition, as in: https://godbolt.org/z/PGrfP3 (but this has caused users some pain, from what I understand).

Perhaps coordinating with the GCC folks on this may not be a bad idea. However, taking a step back -- what attributes would need this functionality (and couldn't be written on something within the expression statement)?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D93630/new/

https://reviews.llvm.org/D93630