[Sema] Better fix for tags defined inside an enumeration (PR28903).

[vsapsai]

Summary

When we encounter an opening parenthesis and parse the rest as type
cast, use DeclSpecContext DSC_type_specifier so we hit the existing check
that prevents defining tags in contexts where type specifier is expected.

This reverts implementation done in r313386, r313894, and keeps the tests.

rdar://problem/28530809

[vsapsai]

Ping. The change can be still applied on trunk without changes, all tests are passing.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_type_defined_in_result_type : Error<
   "%0 cannot be defined in the result type of a function">;
 def err_type_defined_in_param_type : Error<
   "%0 cannot be defined in a parameter type">;
 def err_type_defined_in_alias_template : Error<
   "%0 cannot be defined in a type alias template">;
 def err_type_defined_in_condition : Error<
   "%0 cannot be defined in a condition">;
-def err_type_defined_in_enum : Error<
-  "%0 cannot be defined in an enumeration">;
 
 def note_pure_virtual_function : Note<
   "unimplemented pure virtual method %0 in %1">;
 
 def note_pure_qualified_call_kext : Note<
   "qualified call to %0::%1 is treated as a virtual call to %1 due to -fapple-kext">;
 
 def err_deleted_decl_not_first : Error<

clang/lib/Parse/ParseExpr.cpp

if (isAmbiguousTypeId && !stopIfCastExpr) {
       ExprResult res = ParseCXXAmbiguousParenExpression(ExprType, CastTy, T,
                                                         ColonProtection);
       RParenLoc = T.getCloseLocation();
       return res;
     }
 
     // Parse the type declarator.
     DeclSpec DS(AttrFactory);
-    ParseSpecifierQualifierList(DS);
+    ParseSpecifierQualifierList(DS, AS_none, DSC_type_specifier);
     Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
     ParseDeclarator(DeclaratorInfo);
     
     // If our type is followed by an identifier and either ':' or ']', then 
     // this is probably an Objective-C message send where the leading '[' is
     // missing. Recover as if that were the case.
     if (!DeclaratorInfo.isInvalidType() && Tok.is(tok::identifier) &&
         !InMessageExpression && getLangOpts().ObjC1 &&

clang/lib/Sema/SemaDecl.cpp

CreateNewDecl:
   //   A type-specifier-seq shall not define a class or enumeration [...].
   if (getLangOpts().CPlusPlus && (IsTypeSpecifier || IsTemplateParamOrArg) &&
       TUK == TUK_Definition) {
     Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
       << Context.getTagDeclType(New);
     Invalid = true;
   }
 
-  if (!Invalid && getLangOpts().CPlusPlus && TUK == TUK_Definition &&
-      DC->getDeclKind() == Decl::Enum) {
-    Diag(New->getLocation(), diag::err_type_defined_in_enum)
-      << Context.getTagDeclType(New);
-    Invalid = true;
-  }
-
   // Maybe add qualifier info.
   if (SS.isNotEmpty()) {
     if (SS.isSet()) {
       // If this is either a declaration or a definition, check the
       // nested-name-specifier against the current context. We don't do this
       // for explicit specializations, because they have similar checking
       // (with more specific diagnostics) in the call to
       // CheckMemberSpecialization, below.

clang/test/CXX/drs/dr5xx.cpp

const dr539( // expected-error {{requires a type specifier}}
   new const; // expected-error {{expected a type}}
   try {} catch (const n) {} // expected-error {{unknown type name 'n'}}
   try {} catch (const) {} // expected-error {{expected a type}}
   if (const n = 0) {} // expected-error {{requires a type specifier}}
   switch (const n = 0) {} // expected-error {{requires a type specifier}}
   while (const n = 0) {} // expected-error {{requires a type specifier}}
   for (const n = 0; // expected-error {{requires a type specifier}}
        const m = 0; ) {} // expected-error {{requires a type specifier}}
-  sizeof(const); // expected-error {{requires a type specifier}}
+  sizeof(const); // expected-error {{expected a type}}
   struct S {
     const n; // expected-error {{requires a type specifier}}
     operator const(); // expected-error {{expected a type}}
   };
 #if __cplusplus >= 201103L
   int arr[3];
   // FIXME: The extra braces here are to avoid the parser getting too
   // badly confused when recovering here. We should fix this recovery.

clang/test/SemaCXX/enum.cpp

 #if __cplusplus >= 201103L
 // expected-warning@-2 {{not an integral constant expression}}
 // expected-note@-3 {{value 28958703552 is outside the range of representable values}}
 #endif
 
 // PR28903
 struct PR28903 {
   enum {
-    PR28903_A = (enum { // expected-error-re {{'PR28903::(anonymous enum at {{.*}})' cannot be defined in an enumeration}}
+    PR28903_A = (enum { // expected-error-re {{'PR28903::(anonymous enum at {{.*}})' cannot be defined in a type specifier}}
       PR28903_B,
       PR28903_C = PR28903_B
     })
   };
 };