C23 parsing of auto type inference doesn't correctly consider typedefs

[Halalaluyafail3]

The following program demonstrates the issue:

int main(){
    typedef int x;
    {
        auto x y;
    }
}

The declaration auto x y; should be "declaration of y with type x" where auto has no effect because it's not specifying type inference here. However, in C23 mode Clang will see the x after auto and then assume that it should be "declaration of x with inferred type". Afterwards it will then complain because there is no initializer. GCC and Clang in pre-C23 modes will accept this code. Related to #164921 example 3, but I split this into a separate issue because it changes the meaning of valid code.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Halalaluyafail3)

The following program demonstrates the issue: ```c int main(){ typedef int x; { auto x y; } } ``` The declaration `auto x y;` should be "declaration of y with type x" where auto has no effect because it's not specifying type inference here. However, in C23 mode Clang will see the `x` after `auto` and then assume that it should be "declaration of x with inferred type". Afterwards it will then complain because there is no initializer. GCC and Clang in pre-C23 modes will accept this code. Related to #164921 example 3, but I split this into a separate issue because it changes the meaning of valid code.

[AaronBallman]

The issue is here:

llvm-project/clang/lib/Parse/ParseDecl.cpp

Line 4097 in fe5f499

if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {

and also applies in C++ because we continue to support auto as a storage class specifier for the moment.

We don't know that x is a type-name because we've not called TryAnnotateTypeOrScopeToken() to convert the identifier token into an annot_typename token. However, those annotation functions operate on the currently lexed token and potentially push a new annotation token to the token stream; they don't take the current token and classify it. There is ClassifyName(), but that expects the scope specifier to have been fully parsed before calling it in C++, so something like this is not a valid solution:

        auto IsTypeName = [&](Token T) {
          if (T.getKind() == tok::identifier) {
            CXXScopeSpec &SS = DS.getTypeSpecScope();
            IdentifierInfo *Name = T.getIdentifierInfo();
            Sema::NameClassification Class = Actions.ClassifyName(
                getCurScope(), SS, Name, T.getLocation(), GetLookAheadToken(2));
            return Class.getKind() == NameClassificationKind::Type;
          }
          return false;
        };
        Token NextTok = GetLookAheadToken(1);
        if (isKnownToBeTypeSpecifier(NextTok) || IsTypeName(NextTok)) {
          ...
        }