Allow use of an elaborated type specifier in a _Generic association in C++

[aaron.ballman]

Summary

Currently, Clang accepts this code in C mode (where the tag is required to be used) but rejects it in C++ mode thinking that the association is defining a new type.

void foo(void) {
  struct S { int a; };
  _Generic(something, struct S : 1);
}

Clang thinks this in C++ because it sees struct S : when parsing the class specifier and decides that must be a type definition (because the colon signifies the presence of a base class type). This patch adds a new declarator context to represent a _Generic association so that we can distinguish these situations properly.

Fixes #55562

[erichkeane]

This mostly/all seems reasonable to me, and the diagnostics, while not perfect, are IMO a vast improvement.

clang/include/clang/Sema/DeclSpec.h

2068

Is this right? According to the comment, this is 'true'if the identifier is optional or required, but the mayOmitIdentifier, where you are returning 'true' says optional or not allowed? Does this make identifier 'not allowed' here?

[aaron.ballman]

clang/include/clang/Sema/DeclSpec.h

2068

I believe this is correct -- associations used to be handled the same as type names, and we still want to handle them effectively as type names. The only distinction between an association and a type name is whether it can be a defining type specifier or not (type name can be, association cannot be).

This is the function that tests whether you can put an identifier after the type; e.g., int a and I think it's logically consistent. May the identifier be omitted? Certainly, it must be. May it have an identifier? Definitely not.

[erichkeane]

clang/include/clang/Sema/DeclSpec.h

2068

Ok, that sounds right to me as well then. Its a little annoying/confusing I guess that these two functions combine for a bizarre tri-state: "Required/Optional/Not-allowed", and the name of mayOmitIdentifier isn't really a good one, since may I omit implies the option here...

Either way, not your ball of wax, but thanks for confirming.

[aaron.ballman]

Thanks for the reviews @erichkeane! I'll probably land this on Monday just in case @jyknight has comments.

clang/docs/ReleaseNotes.rst

 - Implement `CWG 2394 <https://wg21.link/cwg2394>`_: Const class members
   may be initialized with a defaulted default constructor under the same
   conditions it would be allowed for a const object elsewhere.
 - ``__has_unique_object_representations`` no longer reports that ``_BitInt`` types
   have unique object representations if they have padding bits.
 - Unscoped and scoped enumeration types can no longer be initialized from a
   brace-init-list containing a single element of a different scoped enumeration
   type.
+- Allow use of an elaborated type specifier as a ``_Generic`` selection
+  association in C++ mode. This fixes
+  `Issue 55562 <https://github.com/llvm/llvm-project/issues/55562>`_.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all

clang/include/clang/Parse/Parser.h

enum class DeclSpecContext {
     DSC_class,  // class context, enables 'friend'
     DSC_type_specifier, // C++ type-specifier-seq or C specifier-qualifier-list
     DSC_trailing, // C++11 trailing-type-specifier in a trailing return type
     DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration
     DSC_top_level, // top-level/namespace declaration context
     DSC_template_param, // template parameter context
     DSC_template_type_arg, // template type argument context
     DSC_objc_method_result, // ObjC method result context, enables 'instancetype'
-    DSC_condition // condition declaration context
+    DSC_condition, // condition declaration context
+    DSC_association // A _Generic selection expression's type association
   };
 
   /// Is this a context in which we are parsing just a type-specifier (or
   /// trailing-type-specifier)?
   static bool isTypeSpecifier(DeclSpecContext DSC) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_template_param:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
     case DeclSpecContext::DSC_objc_method_result:
     case DeclSpecContext::DSC_condition:
       return false;
 
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_type_specifier:
     case DeclSpecContext::DSC_trailing:
     case DeclSpecContext::DSC_alias_declaration:
+    case DeclSpecContext::DSC_association:
       return true;
     }
     llvm_unreachable("Missing DeclSpecContext case");
   }
 
   /// Whether a defining-type-specifier is permitted in a given context.
   enum class AllowDefiningTypeSpec {
     /// The grammar doesn't allow a defining-type-specifier here, and we must
     /// not parse one (eg, because a '{' could mean something else).
     No,
     /// The grammar doesn't allow a defining-type-specifier here, but we permit
     /// one for error recovery purposes. Sema will reject.
     NoButErrorRecovery,
     /// The grammar allows a defining-type-specifier here, even though it's
     /// always invalid. Sema will reject.
     YesButInvalid,
     /// The grammar allows a defining-type-specifier here, and one can be valid.
     Yes
   };
 
   /// Is this a context in which we are parsing defining-type-specifiers (and
   /// so permit class and enum definitions in addition to non-defining class and
   /// enum elaborated-type-specifiers)?
   static AllowDefiningTypeSpec
-  isDefiningTypeSpecifierContext(DeclSpecContext DSC) {
+  isDefiningTypeSpecifierContext(DeclSpecContext DSC, bool IsCPlusPlus) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
     case DeclSpecContext::DSC_alias_declaration:
     case DeclSpecContext::DSC_objc_method_result:
       return AllowDefiningTypeSpec::Yes;
 
     case DeclSpecContext::DSC_condition:
     case DeclSpecContext::DSC_template_param:
       return AllowDefiningTypeSpec::YesButInvalid;
 
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_type_specifier:
       return AllowDefiningTypeSpec::NoButErrorRecovery;
 
+    case DeclSpecContext::DSC_association:
+      return IsCPlusPlus ? AllowDefiningTypeSpec::NoButErrorRecovery
+                         : AllowDefiningTypeSpec::Yes;
+
     case DeclSpecContext::DSC_trailing:
       return AllowDefiningTypeSpec::No;
     }
     llvm_unreachable("Missing DeclSpecContext case");
   }
 
   /// Is this a context in which an opaque-enum-declaration can appear?
   static bool isOpaqueEnumDeclarationContext(DeclSpecContext DSC) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
       return true;
 
     case DeclSpecContext::DSC_alias_declaration:
     case DeclSpecContext::DSC_objc_method_result:
     case DeclSpecContext::DSC_condition:
     case DeclSpecContext::DSC_template_param:
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_type_specifier:
     case DeclSpecContext::DSC_trailing:
+    case DeclSpecContext::DSC_association:
       return false;
     }
     llvm_unreachable("Missing DeclSpecContext case");
   }
 
   /// Is this a context in which we can perform class template argument
   /// deduction?
   static bool isClassTemplateDeductionContext(DeclSpecContext DSC) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_template_param:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
     case DeclSpecContext::DSC_condition:
     case DeclSpecContext::DSC_type_specifier:
+    case DeclSpecContext::DSC_association:
       return true;
 
     case DeclSpecContext::DSC_objc_method_result:
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_trailing:
     case DeclSpecContext::DSC_alias_declaration:
       return false;
     }

clang/include/clang/Sema/DeclSpec.h

enum class DeclaratorContext {
   LambdaExprParameter, // Lambda-expression parameter declarator.
   ConversionId,        // C++ conversion-type-id.
   TrailingReturn,      // C++11 trailing-type-specifier.
   TrailingReturnVar,   // C++11 trailing-type-specifier for variable.
   TemplateArg,         // Any template argument (in template argument list).
   TemplateTypeArg,     // Template type argument (in default argument).
   AliasDecl,           // C++11 alias-declaration.
   AliasTemplate,       // C++11 alias-declaration template.
-  RequiresExpr         // C++2a requires-expression.
+  RequiresExpr,        // C++2a requires-expression.
+  Association          // C11 _Generic selection expression association.
 };
 
 /// Information about one declarator, including the parsed type
 /// information and the identifier.
 ///
 /// When the declarator is fully formed, this is turned into the appropriate
 /// Decl object.
 ///
bool mayOmitIdentifier() const {
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
     case DeclaratorContext::RequiresExpr:
+    case DeclaratorContext::Association:
       return true;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// mayHaveIdentifier - Return true if the identifier is either optional or
   /// required.  This is true for normal declarators and prototypes, but not
   /// typenames.
bool mayHaveIdentifier() const {
     case DeclaratorContext::ObjCResult:
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
+    case DeclaratorContext::Association:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// Return true if the context permits a C++17 decomposition declarator.
   bool mayHaveDecompositionDeclarator() const {
     switch (Context) {
bool mayHaveDecompositionDeclarator() const {
     case DeclaratorContext::ObjCCatch:
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
+    case DeclaratorContext::Association:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be
   /// followed by a C++ direct initializer, e.g. "int x(1);".
   bool mayBeFollowedByCXXDirectInit() const {
bool mayBeFollowedByCXXDirectInit() const {
     case DeclaratorContext::AliasTemplate:
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::RequiresExpr:
+    case DeclaratorContext::Association:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// isPastIdentifier - Return true if we have parsed beyond the point where
   /// the name would appear. (This may happen even if we haven't actually parsed
   /// a name, perhaps because this context doesn't require one.)
bool isFunctionDeclarationContext() const {
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
     case DeclaratorContext::RequiresExpr:
+    case DeclaratorContext::Association:
       return false;
     }
     llvm_unreachable("unknown context kind!");
   }
 
   /// Determine whether this declaration appears in a context where an
   /// expression could appear.
   bool isExpressionContext() const {
bool isExpressionContext() const {
     case DeclaratorContext::ObjCCatch:
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::RequiresExpr:
+    case DeclaratorContext::Association:
       return false;
 
     case DeclaratorContext::Block:
     case DeclaratorContext::ForInit:
     case DeclaratorContext::SelectionInit:
     case DeclaratorContext::Condition:
     case DeclaratorContext::TemplateArg:
       return true;

clang/lib/Parse/ParseDecl.cpp

if (Context == DeclaratorContext::TemplateArg ||
       Context == DeclaratorContext::TemplateTypeArg)
     return DeclSpecContext::DSC_template_type_arg;
   if (Context == DeclaratorContext::TrailingReturn ||
       Context == DeclaratorContext::TrailingReturnVar)
     return DeclSpecContext::DSC_trailing;
   if (Context == DeclaratorContext::AliasDecl ||
       Context == DeclaratorContext::AliasTemplate)
     return DeclSpecContext::DSC_alias_declaration;
+  if (Context == DeclaratorContext::Association)
+    return DeclSpecContext::DSC_association;
   return DeclSpecContext::DSC_normal;
 }
 
 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
 ///
 /// FIXME: Simply returns an alignof() expression if the argument is a
 /// type. Ideally, the type should be propagated directly into Sema.
 ///
void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
   // specifier.
   bool shouldDelayDiagsInTag =
     (TemplateInfo.Kind == ParsedTemplateInfo::ExplicitInstantiation ||
      TemplateInfo.Kind == ParsedTemplateInfo::ExplicitSpecialization);
   SuppressAccessChecks diagsFromTag(*this, shouldDelayDiagsInTag);
 
   // Determine whether this declaration is permitted to have an enum-base.
   AllowDefiningTypeSpec AllowEnumSpecifier =
-      isDefiningTypeSpecifierContext(DSC);
+      isDefiningTypeSpecifierContext(DSC, getLangOpts().CPlusPlus);
   bool CanBeOpaqueEnumDeclaration =
       DS.isEmpty() && isOpaqueEnumDeclarationContext(DSC);
   bool CanHaveEnumBase = (getLangOpts().CPlusPlus11 || getLangOpts().ObjC ||
                           getLangOpts().MicrosoftExt) &&
                          (AllowEnumSpecifier == AllowDefiningTypeSpec::Yes ||
                           CanBeOpaqueEnumDeclaration);
 
   CXXScopeSpec &SS = DS.getTypeSpecScope();

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
   // For these, DSC is DeclSpecContext::DSC_type_specifier or
   // DeclSpecContext::DSC_alias_declaration.
 
   // If there are attributes after class name, parse them.
   MaybeParseCXX11Attributes(Attributes);
 
   const PrintingPolicy &Policy = Actions.getASTContext().getPrintingPolicy();
   Sema::TagUseKind TUK;
-  if (isDefiningTypeSpecifierContext(DSC) == AllowDefiningTypeSpec::No ||
+  if (isDefiningTypeSpecifierContext(DSC, getLangOpts().CPlusPlus) ==
+          AllowDefiningTypeSpec::No ||
       (getLangOpts().OpenMP && OpenMPDirectiveParsing))
     TUK = Sema::TUK_Reference;
   else if (Tok.is(tok::l_brace) ||
+           (DSC != DeclSpecContext::DSC_association &&
                 (getLangOpts().CPlusPlus && Tok.is(tok::colon)) ||
             (isClassCompatibleKeyword() &&
-            (NextToken().is(tok::l_brace) || NextToken().is(tok::colon)))) {
+             (NextToken().is(tok::l_brace) || NextToken().is(tok::colon))))) {
     if (DS.isFriendSpecified()) {
       // C++ [class.friend]p2:
       //   A class shall not be defined in a friend declaration.
       Diag(Tok.getLocation(), diag::err_friend_decl_defines_type)
         << SourceRange(DS.getFriendSpecLoc());
 
       // Skip everything up to the semicolon, so that this looks like a proper
       // friend class (or template thereof) declaration.

clang/lib/Parse/ParseExpr.cpp

if (Tok.is(tok::kw_default)) {
         Diag(DefaultLoc, diag::note_previous_default_assoc);
         SkipUntil(tok::r_paren, StopAtSemi);
         return ExprError();
       }
       DefaultLoc = ConsumeToken();
       Ty = nullptr;
     } else {
       ColonProtectionRAIIObject X(*this);
-      TypeResult TR = ParseTypeName();
+      TypeResult TR = ParseTypeName(nullptr, DeclaratorContext::Association);
       if (TR.isInvalid()) {
         SkipUntil(tok::r_paren, StopAtSemi);
         return ExprError();
       }
       Ty = TR.get();
     }
     Types.push_back(Ty);
 

clang/lib/Sema/SemaType.cpp

if (Deduced) {
     case DeclaratorContext::FunctionalCast:
       if (isa<DeducedTemplateSpecializationType>(Deduced))
         break;
       if (SemaRef.getLangOpts().CPlusPlus2b && IsCXXAutoType &&
           !Auto->isDecltypeAuto())
         break; // auto(x)
       LLVM_FALLTHROUGH;
     case DeclaratorContext::TypeName:
+    case DeclaratorContext::Association:
       Error = 15; // Generic
       break;
     case DeclaratorContext::File:
     case DeclaratorContext::Block:
     case DeclaratorContext::ForInit:
     case DeclaratorContext::SelectionInit:
     case DeclaratorContext::Condition:
       // FIXME: P0091R3 (erroneously) does not permit class template argument
if (SemaRef.getLangOpts().CPlusPlus &&
     case DeclaratorContext::FunctionalCast:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TemplateParam:
     case DeclaratorContext::CXXNew:
     case DeclaratorContext::CXXCatch:
     case DeclaratorContext::ObjCCatch:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
+    case DeclaratorContext::Association:
       DiagID = diag::err_type_defined_in_type_specifier;
       break;
     case DeclaratorContext::Prototype:
     case DeclaratorContext::LambdaExprParameter:
     case DeclaratorContext::ObjCParameter:
     case DeclaratorContext::ObjCResult:
     case DeclaratorContext::KNRTypeList:
     case DeclaratorContext::RequiresExpr:
if (IsTypedefName) {
     case DeclaratorContext::LambdaExprParameter:
     case DeclaratorContext::ObjCCatch:
     case DeclaratorContext::TemplateParam:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
     case DeclaratorContext::TypeName:
     case DeclaratorContext::FunctionalCast:
     case DeclaratorContext::RequiresExpr:
+    case DeclaratorContext::Association:
       // Don't infer in these contexts.
       break;
     }
   }
 
   // Local function that returns true if its argument looks like a va_list.
   auto isVaList = [&S](QualType T) -> bool {
     auto *typedefTy = T->getAs<TypedefType>();
if (D.hasEllipsis()) {
     case DeclaratorContext::ObjCCatch:
     case DeclaratorContext::BlockLiteral:
     case DeclaratorContext::LambdaExpr:
     case DeclaratorContext::ConversionId:
     case DeclaratorContext::TrailingReturn:
     case DeclaratorContext::TrailingReturnVar:
     case DeclaratorContext::TemplateArg:
     case DeclaratorContext::TemplateTypeArg:
+    case DeclaratorContext::Association:
       // FIXME: We may want to allow parameter packs in block-literal contexts
       // in the future.
       S.Diag(D.getEllipsisLoc(),
              diag::err_ellipsis_in_declarator_not_parameter);
       D.setEllipsisLoc(SourceLocation());
       break;
     }
   }

clang/test/Sema/generic-selection.c

_Static_assert( // ext-warning {{'_Static_assert' is a C11 extension}}
     ) == 4, "we had better pick int!");
   _Static_assert( // ext-warning {{'_Static_assert' is a C11 extension}}
     _Generic(t, // ext-warning {{'_Generic' is a C11 extension}}
       struct Test : 1,
       const struct Test : 2, // expected-warning {{due to lvalue conversion of the controlling expression, association of type 'const struct Test' will never be selected because it is qualified}}
       default : 3
     ) == 1, "we had better pick struct Test, not const struct Test!"); // C-specific result
 }
+
+void GH55562(void) {
+  // Ensure that you can still define a type within a generic selection
+  // association (despite it not being particularly useful).
+  (void)_Generic(1, struct S { int a; } : 0, default : 0); // ext-warning {{'_Generic' is a C11 extension}}
+  struct S s = { 0 };
+  int i = s.a;
+}

clang/test/SemaCXX/generic-selection.cpp

static_assert(
     ) == 4, "we had better pick int, not const int!");
   static_assert(
     _Generic(t,
       Test : 1,
       const Test : 2,  // Ok in C++, warned in C
       default : 3
     ) == 2, "we had better pick const Test, not Test!"); // C++-specific result
 }
+
+namespace GH55562 {
+struct S { // expected-note {{declared here}}
+  int i;
+};
+
+void func(struct S s) {
+  // We would previously reject this because the parser thought 'struct S :'
+  // was the start of a definition (with a base class specifier); it's not, it
+  // is an elaborated type specifier followed by the association's value and
+  // it should work the same as in C.
+  (void)_Generic(s, struct S : 1);
+
+  // The rest of these cases test that we still produce a reasonable diagnostic
+  // when referencing an unknown type or trying to define a type in other ways.
+  (void)_Generic(s, struct T : 1);            // expected-error {{type 'struct T' in generic association incomplete}}
+  (void)_Generic(s, struct U { int a; } : 1); // expected-error {{'U' cannot be defined in a type specifier}}
+  (void)_Generic(s, struct V : S);            // expected-error {{'S' does not refer to a value}}
+  (void)_Generic(s, struct W : S { int b; } : 1); // expected-error {{expected '(' for function-style cast or type construction}}
+}
+} // namespace GH55562