[clang] Emit unified error for 'auto' combined with type specifiers

This change improves the diagnostic when 'auto' is combined with a type
specifier by emitting a unified error message "'auto' cannot be combined
with a type specifier" instead of the generic "cannot combine with previous
'auto' declaration specifier" error.

The parser now checks for:
1. Builtin types (int, void, char, etc.) after 'auto' using lookahead
2. Identifier types (typedefs, template parameters, etc.) using semantic
   lookup via Actions.getTypeName()

To avoid false positives, the check is limited to:
- Simple declaration contexts (DSC_normal, DSC_top_level, DSC_class)
- Simple variable declarations: 'auto Type variable_name' pattern
- Skips complex declarators (function pointers, member pointers, qualified
  names, etc.)
- Skips ambiguous cases like 'auto Type = value' where Type could be a
  variable name

For builtin types, the parser emits the error and exits early. For
identifier types, it uses semantic lookup to determine if the identifier
is a known type before emitting the error.

Test updates:
- Updated cwg3xx.cpp to account for C++98 vs C++11 behavior differences
- Updated p2.cpp to include expected warning for empty parentheses in
  block scope

Fixes incorrect diagnostics for cases like:
  auto int x;        // Now correctly diagnosed
  auto Ty x;         // Now correctly diagnosed (Ty is a type)
  auto S<T>::f();    // Correctly skipped (out-of-line definition)
  auto Class::*      // Correctly skipped (member pointer)

Signed-off-by: Osama Abdelkader <[email protected]>

Author: osamakader

clang/lib/Parse/ParseDecl.cpp

@@ -4092,24 +4092,23 @@ void Parser::ParseDeclarationSpecifiers(
                                          PrevSpec, DiagID, Policy);
       isStorageClass = true;
       break;
-    case tok::kw_auto:
-      if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) {
+    case tok::kw_auto: {
+      const Token &LA = GetLookAheadToken(1);
+      if (isKnownToBeTypeSpecifier(LA) || LA.is(tok::annot_typename)) {
         // 'auto' cannot be combined with a type specifier, except in C23 and
         // C++98.
-        if (getLangOpts().C23) {
-          // C23 allows 'auto' as storage class with type specifier.
-          isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
-                                             PrevSpec, DiagID, Policy);
-        } else if (getLangOpts().CPlusPlus11 || getLangOpts().OpenCL) {
+        if (getLangOpts().CPlusPlus11 || getLangOpts().OpenCL) {
           // In C++11+ or OpenCL, 'auto' cannot be combined with a type
           // specifier.
           isInvalid = true;
           PrevSpec = Tok.getIdentifierInfo()->getNameStart();
           DiagID = diag::err_auto_type_specifier;
+          DS.SetTypeSpecError();
         } else {
           // In C++98 or C, 'auto' can be a storage class specifier with a type.
           isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
                                              PrevSpec, DiagID, Policy);
+          isStorageClass = true;
         }
       } else {
         // 'auto' is not followed by a type specifier.
@@ -4121,10 +4120,78 @@ void Parser::ParseDeclarationSpecifiers(
           // In C (not C++11+ and not C23), 'auto' is a storage class specifier.
           isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc,
                                              PrevSpec, DiagID, Policy);
+          isStorageClass = true;
         }
       }
-      isStorageClass = true;
-      break;
+      // Only if Next token is a known type name (typedef, template param, etc
+      // ) Check this only if we set 'auto' as a type specifier and haven't
+      // already detected an error. Only check in simple declaration contexts
+      // to avoid false positives with member pointers, out-of-line
+      // definitions, etc. Only check when we're sure it's a simple variable
+      // declaration: 'auto Type variable_name' where the identifier is
+      // followed by another identifier (the variable name), not by '(', '::',
+      //  '<', '[', etc.
+      if (getLangOpts().CPlusPlus11 && !isInvalid &&
+          DS.getTypeSpecType() == DeclSpec::TST_auto &&
+          (DSContext == DeclSpecContext::DSC_normal ||
+           DSContext == DeclSpecContext::DSC_top_level ||
+           DSContext == DeclSpecContext::DSC_class)) {
+        // Re-check the lookahead token in case it was annotated
+        const Token &NextLA = GetLookAheadToken(1);
+
+        // Check for builtin type keywords (int, void, char, etc.)
+        if (NextLA.isOneOf(tok::kw_int, tok::kw_void, tok::kw_char,
+                           tok::kw_char8_t, tok::kw_char16_t, tok::kw_char32_t,
+                           tok::kw_wchar_t, tok::kw_bool, tok::kw_float,
+                           tok::kw_double, tok::kw__Bool, tok::kw___bool,
+                           tok::kw_half, tok::kw___bf16, tok::kw__ExtInt,
+                           tok::kw__BitInt)) {
+          // Builtin type after 'auto' => always an error in C++11+
+          Diag(NextLA.getLocation(), diag::err_auto_type_specifier);
+
+          DS.SetTypeSpecError();
+          ConsumeToken(); // Consume 'auto'
+          ConsumeToken(); // Consume the builtin type token
+          goto DoneWithDeclSpec;
+        }
+
+        // Check for identifier types
+        if (NextLA.is(tok::identifier)) {
+          // Check what comes after the identifier to determine if this is a
+          // simple variable declaration or something more complex.
+          const Token &AfterNext = GetLookAheadToken(2);
+          // Skip if followed by: '(', '::', '<', '[', '*', '&', etc.
+          // Only check if followed by another identifier (variable name).
+          // Don't check if followed by '=' because 'auto Type = value' is
+          // ambiguous: Type could be a variable name that happens to share a
+          // name with a type.
+          if (AfterNext.isOneOf(tok::l_paren, tok::coloncolon, tok::less,
+                                tok::l_square, tok::star, tok::amp, tok::ampamp,
+                                tok::kw_const, tok::kw_volatile,
+                                tok::kw_restrict, tok::equal)) {
+            // Complex declarator or ambiguous case - skip the check
+          } else if (AfterNext.is(tok::identifier)) {
+            // This looks like a simple variable declaration: 'auto Type name'
+            // Query Sema: Is this identifier a known-type at this point?
+            IdentifierInfo *II = NextLA.getIdentifierInfo();
+            ParsedType TypeRep = Actions.getTypeName(
+                *II, NextLA.getLocation(), getCurScope(), nullptr, false, false,
+                nullptr, false, false,
+                isClassTemplateDeductionContext(DSContext));
+
+            if (TypeRep) {
+              // We have 'auto' followed by a known type => always an error in
+              // C++11+
+              Diag(NextLA.getLocation(), diag::err_auto_type_specifier);
+              DS.SetTypeSpecError();
+              ConsumeToken(); // Consume 'auto'
+              ConsumeToken(); // Consume the type name token
+              goto DoneWithDeclSpec;
+            }
+          }
+        }
+      }
+    } break;
     case tok::kw___auto_type:
       Diag(Tok, diag::ext_auto_type);
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto_type, Loc, PrevSpec,

clang/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp

@@ -61,8 +61,10 @@ void foo(auto int ap, register int rp) {
   auto void abf();
 #if __cplusplus >= 201103L // C++11 or later
 // expected-error@-2 {{'auto' cannot be combined with a type specifier}}
+// expected-warning@-3 {{empty parentheses interpreted as a function declaration}}
+// expected-note@-4 {{replace parentheses with an initializer to declare a variable}}
 #else
-// expected-error@-4 {{illegal storage class on function}}
+// expected-error@-6 {{illegal storage class on function}}
 #endif
 
   register int rbo;

clang/test/CXX/drs/cwg3xx.cpp

@@ -1739,8 +1739,8 @@ namespace cwg396 { // cwg396: 3.0
     int (i); // #cwg396-i
     auto int (i);
     // since-cxx11-error@-1 {{'auto' cannot be combined with a type specifier}}
-    // expected-error@-2 {{redefinition of 'i'}}
-    //   expected-note@#cwg396-i {{previous definition is here}}
+    // cxx98-error@-2 {{redefinition of 'i'}}
+    //   cxx98-note@#cwg396-i {{previous definition is here}}
   }
 } // namespace cwg396
 

clang/test/Parser/cxx-auto-type-specifier.cpp

@@ -20,3 +20,11 @@ void h() {
   auto z = 'c';
 }
 
+template <typename Ty>
+void g() {
+  auto Ty x;     // expected-error {{'auto' cannot be combined with a type specifier}}
+}
+
+void test() {
+  g<float>();
+}