C23 constexpr + auto + type shouldn't be a valid combination

[Halalaluyafail3]

The following program demonstrates this issue:

int main(){
    constexpr auto int x={};
}

This program is invalid because:

thread_local shall not appear in the declaration specifiers of a function declaration. auto shall only
appear in the declaration specifiers of an identifier with file scope or along with other storage-class
specifiers if the type is to be inferred from an initializer.

...

If auto appears with another storage-class specifier, or if it appears in a declaration at file scope, it is
ignored for the purposes of determining a storage duration or linkage. In this case, it indicates only
that the declared type may be inferred.

Section 6.7.2 "Storage-class specifiers" Paragraphs 4 and 15 ISO/IEC 9899:2024

constexpr is a storage-class specifier, so here auto is specifying type inference (and if it wasn't, it would violate the constraint in paragraph 4). I can't find any wording to say that using a type specifier with auto for type inference is invalid, but {} surely isn't valid with type inference. Note that Clang doesn't accept the following:

auto int x={};
int main(){}

GCC also doesn't accept either program.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Halalaluyafail3)

The following program demonstrates this issue: ```c int main(){ constexpr auto int x={}; } ``` This program is invalid because: > thread_local shall not appear in the declaration specifiers of a function declaration. auto shall only appear in the declaration specifiers of an identifier with file scope or along with other storage-class specifiers if the type is to be inferred from an initializer. > > ... > > If auto appears with another storage-class specifier, or if it appears in a declaration at file scope, it is ignored for the purposes of determining a storage duration or linkage. In this case, it indicates only that the declared type may be inferred.

Section 6.7.2 "Storage-class specifiers" Paragraphs 4 and 15 ISO/IEC 9899:2024

constexpr is a storage-class specifier, so here auto is specifying type inference (and if it wasn't, it would violate the constraint in paragraph 4). I can't find any wording to say that using a type specifier with auto for type inference is invalid, but {} surely isn't valid with type inference. Note that Clang doesn't accept the following:

auto int x={};
int main(){}

GCC also doesn't accept either program.

[llvmbot]

Hi!

This issue may be a good introductory issue for people new to working on LLVM. If you would like to work on this issue, your first steps are:

1. Check that no other contributor is working on this issue. If someone is assigned to the issue or claimed to be working on it, ping the person. After one week without a response, the assignee may be changed.
2. Leave a comment indicating that you are working on the issue, or just create a pull request after following the steps below. Mention this issue in the description of the pull request.
3. Fix the issue locally.
4. Run the test suite locally. Remember that the subdirectories under test/ create fine-grained testing targets, so you can e.g. use make check-clang-ast to only run Clang's AST tests.
5. Create a Git commit.
6. Run git clang-format HEAD~1 to format your changes.
7. Open a pull request to the upstream repository on GitHub. Detailed instructions can be found in GitHub's documentation. Mention this issue in the description of the pull request.

If you have any further questions about this issue, don't hesitate to ask via a comment in the thread below.

[llvmbot]

@llvm/issue-subscribers-good-first-issue

Author: None (Halalaluyafail3)

The following program demonstrates this issue: ```c int main(){ constexpr auto int x={}; } ``` This program is invalid because: > thread_local shall not appear in the declaration specifiers of a function declaration. auto shall only appear in the declaration specifiers of an identifier with file scope or along with other storage-class specifiers if the type is to be inferred from an initializer. > > ... > > If auto appears with another storage-class specifier, or if it appears in a declaration at file scope, it is ignored for the purposes of determining a storage duration or linkage. In this case, it indicates only that the declared type may be inferred.

Section 6.7.2 "Storage-class specifiers" Paragraphs 4 and 15 ISO/IEC 9899:2024

constexpr is a storage-class specifier, so here auto is specifying type inference (and if it wasn't, it would violate the constraint in paragraph 4). I can't find any wording to say that using a type specifier with auto for type inference is invalid, but {} surely isn't valid with type inference. Note that Clang doesn't accept the following:

auto int x={};
int main(){}

GCC also doesn't accept either program.

[AaronBallman]

This may be a good first issue; I think you can update DeclSpec::Finish() or thereabouts to catch the duplicated specifiers:

llvm-project/clang/lib/Sema/DeclSpec.cpp

Line 1128 in 8a27b48

void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {