[Clang] Avoid crashes when parsing using enum declarations

[shafik]

Summary

In Parser::ParseUsingDeclaration(...) when we call ParseEnumSpecifier(...) it is not calling SetTypeSpecError() on DS when it detects an error. That means that DS is left set to TST_unspecified. When we then pass DS into Sema::ActOnUsingEnumDeclaration(...) we hit an llvm_unreachable(...) since it expects it to be one of three states TST_error, TST_enum or TST_typename.

This fixes https://github.com/llvm/llvm-project/issues/57347

[erichkeane]

Changes seem correct enough, and the tests all look like we're just removing incorrect diagnostics, so LGTM.

[aaron.ballman]

Thanks, this looks like it cleans up some needlessly chatty diagnostics! Just had a question that you can fix when landing if you agree, otherwise LGTM as well.

clang/lib/Parse/ParseDecl.cpp

4652

Shouldn't this be lifted out of the if statement into the parent one where we issue the error diagnostic?

[shafik]

• Move DS.SetTypeSpecError() outside the if so that it is always called when the diagnostic is triggered.

clang/lib/Parse/ParseDecl.cpp

if (getLangOpts().CPlusPlus) {
     CXXScopeSpec Spec;
     if (ParseOptionalCXXScopeSpecifier(Spec, /*ObjectType=*/nullptr,
                                        /*ObjectHasErrors=*/false,
                                        /*EnteringContext=*/true))
       return;
 
     if (Spec.isSet() && Tok.isNot(tok::identifier)) {
       Diag(Tok, diag::err_expected) << tok::identifier;
+      DS.SetTypeSpecError();
       if (Tok.isNot(tok::l_brace)) {
         // Has no name and is not a definition.
         // Skip the rest of this declarator, up until the comma or semicolon.
         SkipUntil(tok::comma, StopAtSemi);
         return;
       }
     }
 
     SS = Spec;
   }
 
   // Must have either 'enum name' or 'enum {...}' or (rarely) 'enum : T { ... }'.
   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) &&
       Tok.isNot(tok::colon)) {
     Diag(Tok, diag::err_expected_either) << tok::identifier << tok::l_brace;
 
+    DS.SetTypeSpecError();
     // Skip the rest of this declarator, up until the comma or semicolon.
     SkipUntil(tok::comma, StopAtSemi);
     return;
   }
 
   // If an identifier is present, consume and remember it.
   IdentifierInfo *Name = nullptr;
   SourceLocation NameLoc;
if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate &&
     assert(TemplateInfo.TemplateParams && "no template parameters");
     TParams = MultiTemplateParamsArg(TemplateInfo.TemplateParams->data(),
                                      TemplateInfo.TemplateParams->size());
   }
 
   if (!Name && TUK != Sema::TUK_Definition) {
     Diag(Tok, diag::err_enumerator_unnamed_no_def);
 
+    DS.SetTypeSpecError();
     // Skip the rest of this declarator, up until the comma or semicolon.
     SkipUntil(tok::comma, StopAtSemi);
     return;
   }
 
   // An elaborated-type-specifier has a much more constrained grammar:
   //
   //   'enum' nested-name-specifier[opt] identifier

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p9-0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // FIXME: We should catch the case of tag with an incomplete type here (which
 // will necessarily be ill-formed as a trailing return type for a function
 // definition), and recover with a "type cannot be defined in a trailing return
 // type" error.
-auto j() -> enum { e3 }; // expected-error{{unnamed enumeration must be a definition}} expected-error {{expected a type}}
+auto j() -> enum { e3 }; // expected-error{{unnamed enumeration must be a definition}}

clang/test/CXX/drs/dr3xx.cpp

void f() {
     bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}}
              (void(*)(S, S))operator-; // expected-error {{expected '>'}}
   }
 
   template<typename T> void f() {
     typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
     // FIXME: This shouldn't say (null).
     class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
-    enum T::template operator+<int> c; // expected-error {{expected identifier}} expected-error {{does not declare anything}}
+    enum T::template operator+<int> c; // expected-error {{expected identifier}}
     enum T::template operator+<int>::E d; // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}} expected-error {{forward reference}}
     enum T::template X<int>::E e;
     T::template operator+<int>::foobar(); // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}}
     T::template operator+<int>(0); // ok
   }
 
   template<typename T> class operator&<T*> {}; // expected-error +{{}}
   template<typename T> class T::operator& {}; // expected-error +{{}}

clang/test/Parser/cxx20-using-enum.cpp

+// RUN: %clang_cc1 -std=c++20 -verify %s
+
+namespace GH57347 {
+namespace A {}
+
+void f() {
+  using enum A::+; // expected-error {{expected identifier}}
+  using enum; // expected-error {{expected identifier or '{'}}
+  using enum class; // expected-error {{expected identifier or '{'}}
+  using enum : blah; // expected-error {{unknown type name 'blah'}} expected-error {{unnamed enumeration must be a definition}}
+}
+}

clang/test/Parser/recovery.cpp

namespace pr15133 {
 
   struct S2 :: S3 :: public S2 {  // expected-error{{'public' cannot be a part of nested name specifier; did you mean ':'?}}
   };
 }
 
 namespace InvalidEmptyNames {
 // These shouldn't crash, the diagnostics aren't important.
 struct ::, struct ::; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}}
-enum ::, enum ::; // expected-error 2 {{expected identifier}} expected-warning {{declaration does not declare anything}}
+enum ::, enum ::; // expected-error 2 {{expected identifier}}
 struct ::__super, struct ::__super; // expected-error 2 {{expected identifier}} expected-error 2 {{expected '::' after '__super'}}
 struct ::template foo, struct ::template bar; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}}
 struct ::foo struct::; // expected-error {{no struct named 'foo' in the global namespace}} expected-error {{expected identifier}} expected-error {{declaration of anonymous struct must be a definition}}
 class :: : {} a;  // expected-error {{expected identifier}} expected-error {{expected class name}}
 }

clang/test/Sema/enum.c

 };
 
 struct EnumRedeclStruct {
   enum {
     PR15071_One // expected-error {{redefinition of enumerator 'PR15071_One'}}
   } e;
 };
 
-enum struct GH42372_1 { // expected-error {{expected identifier or '{'}} expected-warning {{declaration does not declare anything}}
+enum struct GH42372_1 { // expected-error {{expected identifier or '{'}}
   One
 };
 
 // Because class is not a keyword in C, this looks like a forward declaration.
 // expected-error@+4 {{expected ';' after top level declarator}}
 // expected-error@+3 {{tentative definition has type 'enum class' that is never completed}}
 // expected-warning@+2 {{ISO C forbids forward references to 'enum' types}}
 // expected-note@+1 {{forward declaration of 'enum class'}}
 enum class GH42372_2 {
   One
 };

clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp

#endif
   }
 }
 
 namespace nested_name {
   template<typename T> int a; // expected-note {{variable template 'a' declared here}}
   a<int>::b c; // expected-error {{qualified name refers into a specialization of variable template 'a'}}
 
   class a<int> {}; // expected-error {{identifier followed by '<' indicates a class template specialization but 'a' refers to a variable template}}
-  enum a<int> {}; // expected-error {{expected identifier or '{'}} expected-warning {{does not declare anything}}
+  enum a<int> {}; // expected-error {{expected identifier or '{'}}
 }
 
 namespace PR18530 {
   template<typename T> int a;
   int a<int>; // expected-error {{requires 'template<>'}}
 }
 
 namespace PR19152 {

clang/test/SemaCXX/enum-scoped.cpp

 enum class Redeclare7;         // expected-note{{previous declaration is here}} expected-note{{previous declaration is here}}
 enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}}
 enum class Redeclare7 : short; // expected-error{{redeclared with different underlying type}}
 
 enum : long {
   long_enum_val = 10000
 };
 
-enum : long x; // expected-error{{unnamed enumeration must be a definition}} \
-// expected-warning{{declaration does not declare anything}}
+enum : long x; // expected-error{{unnamed enumeration must be a definition}}
 
 void PR9333() {
   enum class scoped_enum { yes, no, maybe };
   scoped_enum e = scoped_enum::yes;
   if (e == scoped_enum::no) { }
 }
 
 // <rdar://problem/9366066>