Auto is incorrectly rejected in C23 when it occurs after the type specifiers in a declaration

[Halalaluyafail3]

The following program demonstrates the issue:

int main(){
    auto long long d1;
    long auto long d2;
    long long auto d3;
}

The order of declaration specifiers in a declaration shouldn't matter, so all 3 declarations should be accepted. However, Clang specifically rejects the third declaration of d3 and only in C23 mode. GCC and Clang in a pre-C23 mode will accept this code.

[Halalaluyafail3]

Also, this issue is specific to auto. All other storage-class specifiers do not have this issue.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Halalaluyafail3)

The following program demonstrates the issue: ```c int main(){ auto long long d1; long auto long d2; long long auto d3; } ``` The order of declaration specifiers in a declaration shouldn't matter, so all 3 declarations should be accepted. However, Clang specifically rejects the third declaration of `d3` and only in C23 mode. GCC and Clang in a pre-C23 mode will accept this code.

[Fznamznon]

So, without constexpr it is auto as a storage specifier and long long as a type specifier. Not sure what long auto long means though. Note it is not brought by #163469 - https://godbolt.org/z/hbTed6xe9 . I don't think the order should matter either.

[Halalaluyafail3]

Not sure what long auto long means though.

It should mean the same thing as the other two, the order doesn't matter and each long is a separate declaration specifier. Hence, you can put other declaration specifiers between them.

[AaronBallman]

CC @a-tarasyuk

[Halalaluyafail3]

It seems like in some cases it will even cause an error when auto is at the start:

auto typeof(0)t;

Neither order is accepted here. With pre-C23 -std=gnu options both orders are accepted. The issues with typeof also seem to apply to atomic type specifiers (_Atomic(type)). Type qualifiers also seem to be impacted too, in a way I don't understand (probably that they can't immediately follow auto?):

const auto int x;
auto const int y;
auto int const z;

Only the declarations of x and z are accepted (ignoring the warning for uninitialized const objects). The issues with type qualifiers also seem to apply to alignment specifiers (alignas(alignment)).