[Clang] Conform to C++17 definition of literal types

[leoetlino]

Summary

C++17 changed the definition of literal types so that unions that
have at least one non-static data member of non-volatile literal type
are also considered literal types.

This patch implements that new rule and also adds a test for closure
types (10.5.2) and for unions (10.5.3) to the existing test file for
literal types.

[leoetlino]

Fix Clang.CodeGenCXX::mangle-class-nttp.cpp test

[leoetlino]

fix formatting issues (sorry for the spam!)

[leoetlino]

ping (as per the contributing guidelines)

clang/include/clang/AST/CXXRecordDeclDefinitionBits.def

 
 /// True if a defaulted destructor for this class would be constexpr.
 FIELD(DefaultedDestructorIsConstexpr, 1, NO_MERGE)
 
 /// True when this class contains at least one non-static data
 /// member or base class of non-literal or volatile type.
 FIELD(HasNonLiteralTypeFieldsOrBases, 1, NO_MERGE)
 
+/// True when this class contains at least one non-static data
+/// member of non-volatile literal type.
+FIELD(HasNonVolatileLiteralTypeFields, 1, NO_MERGE)
+
 /// True if this class is a structural type, assuming it is a literal type.
 FIELD(StructuralIfLiteral, 1, NO_MERGE)
 
 /// Whether we have a C++11 user-provided default constructor (not
 /// explicitly deleted or defaulted).
 FIELD(UserProvidedDefaultConstructor, 1, NO_MERGE)
 
 /// The special members which have been declared for this class,

clang/include/clang/AST/DeclCXX.h

public:
   }
 
   /// Determine whether this class has a non-literal or/ volatile type
   /// non-static data member or base class.
   bool hasNonLiteralTypeFieldsOrBases() const {
     return data().HasNonLiteralTypeFieldsOrBases;
   }
 
+  /// Determine whether this class has a non-volatile literal type
+  /// non-static data member.
+  bool hasNonVolatileLiteralTypeFields() const {
+    return data().HasNonVolatileLiteralTypeFields;
+  }
+
   /// Determine whether this class has a using-declaration that names
   /// a user-declared base class constructor.
   bool hasInheritedConstructor() const {
     return data().HasInheritedConstructor;
   }
 
   /// Determine whether this class has a using-declaration that names
   /// a base class assignment operator.
public:
   ///       or constructor template that is not a copy or move constructor, and
   ///     - all of its non-static data members and base classes are of literal
   ///       types
   ///
   /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
   /// treating types with trivial default constructors as literal types.
   ///
   /// Only in C++17 and beyond, are lambdas literal types.
+  /// A union is a literal type if at least one of its non-static data members
+  /// is of non-volatile literal type.
   bool isLiteral() const {
     const LangOptions &LangOpts = getLangOpts();
+
+    bool FieldsOk = !hasNonLiteralTypeFieldsOrBases();
+    if (LangOpts.CPlusPlus17 && isUnion()) {
+      FieldsOk = !hasDirectFields() || hasNonVolatileLiteralTypeFields();
+    }
+
     return (LangOpts.CPlusPlus20 ? hasConstexprDestructor()
                                           : hasTrivialDestructor()) &&
            (!isLambda() || LangOpts.CPlusPlus17) &&
-           !hasNonLiteralTypeFieldsOrBases() &&
+           FieldsOk &&
            (isAggregate() || isLambda() ||
             hasConstexprNonCopyMoveConstructor() ||
             hasTrivialDefaultConstructor());
   }
 
   /// Determine whether this is a structural type.
   bool isStructural() const {
     return isLiteral() && data().StructuralIfLiteral;

clang/lib/AST/DeclCXX.cpp

CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
     : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
       Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
       Abstract(false), IsStandardLayout(true), IsCXX11StandardLayout(true),
       HasBasesWithFields(false), HasBasesWithNonStaticDataMembers(false),
       HasPrivateFields(false), HasProtectedFields(false),
       HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),
       HasOnlyCMembers(true), HasInClassInitializer(false),
       HasUninitializedReferenceMember(false), HasUninitializedFields(false),
       HasInheritedConstructor(false),
       HasInheritedDefaultConstructor(false),
       HasInheritedAssignment(false),
       NeedOverloadResolutionForCopyConstructor(false),
       NeedOverloadResolutionForMoveConstructor(false),
       NeedOverloadResolutionForCopyAssignment(false),
       NeedOverloadResolutionForMoveAssignment(false),
       NeedOverloadResolutionForDestructor(false),
       DefaultedCopyConstructorIsDeleted(false),
       DefaultedMoveConstructorIsDeleted(false),
       DefaultedCopyAssignmentIsDeleted(false),
       DefaultedMoveAssignmentIsDeleted(false),
       DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All),
       HasTrivialSpecialMembersForCall(SMF_All),
       DeclaredNonTrivialSpecialMembers(0),
       DeclaredNonTrivialSpecialMembersForCall(0), HasIrrelevantDestructor(true),
       HasConstexprNonCopyMoveConstructor(false),
       HasDefaultedDefaultConstructor(false),
       DefaultedDefaultConstructorIsConstexpr(true),
       HasConstexprDefaultConstructor(false),
       DefaultedDestructorIsConstexpr(true),
-      HasNonLiteralTypeFieldsOrBases(false), StructuralIfLiteral(true),
+      HasNonLiteralTypeFieldsOrBases(false),
+      HasNonVolatileLiteralTypeFields(false), StructuralIfLiteral(true),
       UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
       ImplicitCopyConstructorCanHaveConstParamForVBase(true),
       ImplicitCopyConstructorCanHaveConstParamForNonVBase(true),
       ImplicitCopyAssignmentHasConstParam(true),
       HasDeclaredCopyConstructorWithConstParam(false),
       HasDeclaredCopyAssignmentWithConstParam(false),
       IsAnyDestructorNoReturn(false), IsLambda(false),
       IsParsingBaseSpecifiers(false), ComputedVisibleConversions(false),
if (!Field->hasInClassInitializer() && !Field->isMutable()) {
       if (CXXRecordDecl *FieldType = T->getAsCXXRecordDecl()) {
         if (FieldType->hasDefinition() && !FieldType->allowConstDefaultInit())
           data().HasUninitializedFields = true;
       } else {
         data().HasUninitializedFields = true;
       }
     }
 
+    const bool IsNonVolatileLiteralTypeField =
+        T->isLiteralType(Context) && !T.isVolatileQualified();
     // Record if this field is the first non-literal or volatile field or base.
-    if (!T->isLiteralType(Context) || T.isVolatileQualified())
+    if (IsNonVolatileLiteralTypeField)
+      data().HasNonVolatileLiteralTypeFields = true;
+    else
       data().HasNonLiteralTypeFieldsOrBases = true;
 
     if (Field->hasInClassInitializer() ||
         (Field->isAnonymousStructOrUnion() &&
          Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
       data().HasInClassInitializer = true;
 
       // C++11 [class]p5:

clang/test/CXX/basic/basic.types/p10.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1y %s -DCXX1Y
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -DCXX11 -DCXX11_OR_LATER
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1y %s -DCXX1Y -DCXX11_OR_LATER -DCXX1Y_OR_LATER
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s -DCXX17 -DCXX11_OR_LATER -DCXX1Y_OR_LATER -DCXX17_OR_LATER
 
 struct NonLiteral { NonLiteral(); };
 
 // A type is a literal type if it is:
 
 // [C++1y] - void
 constexpr void f() {}
-#ifndef CXX1Y
+#ifdef CXX11
 // expected-error@-2 {{'void' is not a literal type}}
 #endif
 
 // - a scalar type
 constexpr int f1(double) { return 0; }
 
 // - a reference type
 struct S { S(); };
 constexpr int f2(S &) { return 0; }
 
 struct BeingDefined;
 extern BeingDefined beingdefined;
-struct BeingDefined { 
+struct BeingDefined {
   static constexpr BeingDefined& t = beingdefined;
 };
 
 // - a class type that has all of the following properties:
 
 // (implied) - it is complete
 
 struct Incomplete; // expected-note 2{{forward declaration of 'Incomplete'}}

 };
 constexpr int f(TrivDtor) { return 0; }
 struct TrivDefaultedDtor {
   constexpr TrivDefaultedDtor();
   ~TrivDefaultedDtor() = default;
 };
 constexpr int f(TrivDefaultedDtor) { return 0; }
 
-//  - it is an aggregate type or has at least one constexpr constructor or
+//  - it is [a closure type [C++17]], an aggregate type or has at least one constexpr constructor or
 //    constexpr constructor template that is not a copy or move constructor
+#ifndef CXX17_OR_LATER
+// expected-error@+4 {{not a literal type}}
+// expected-note@+2 {{lambda closure types are non-literal types before C++17}}
+#endif
+auto closure = [] {};
+constexpr int f(decltype(closure)) { return 0; }
 struct Agg {
   int a;
   char *b;
 };
 constexpr int f3(Agg a) { return a.a; }
 struct CtorTemplate {
   template<typename T> constexpr CtorTemplate(T);
 };

 };
 template<typename T> struct DerivedFromVBase : T { // expected-note {{struct with virtual base class is not a literal type}}
   constexpr DerivedFromVBase();
 };
 constexpr int f(DerivedFromVBase<HasVBase>) {} // expected-error {{constexpr function's 1st parameter type 'DerivedFromVBase<HasVBase>' is not a literal type}}
 template<typename T> constexpr DerivedFromVBase<T>::DerivedFromVBase() : T() {}
 constexpr int nVBase = (DerivedFromVBase<HasVBase>(), 0); // expected-error {{constant expression}} expected-note {{cannot construct object of type 'DerivedFromVBase<HasVBase>' with virtual base class in a constant expression}}
 
-//  - it has all non-static data members and base classes of literal types
+//  - [C++17] if it is a union, at least one of its non-static data members is of non-volatile literal type, and
+//  - [if it is not a union [C++17]] it has all non-static data members and base classes of literal types
 struct NonLitMember {
   S s; // expected-note {{has data member 's' of non-literal type 'S'}}
 };
 constexpr int f(NonLitMember) {} // expected-error {{1st parameter type 'NonLitMember' is not a literal type}}
 struct NonLitBase :
   S { // expected-note {{base class 'S' of non-literal type}}
   constexpr NonLitBase();
 };
 constexpr int f(NonLitBase) { return 0; } // expected-error {{'NonLitBase' is not a literal type}}
 struct LitMemBase : Agg {
   Agg agg;
 };
 template<typename T>
 struct MemberType {
   T t; // expected-note {{'MemberType<NonLiteral>' is not literal because it has data member 't' of non-literal type 'NonLiteral'}}
   constexpr MemberType();
 };
 constexpr int f(MemberType<int>) { return 0; }
 constexpr int f(MemberType<NonLiteral>) { return 0; } // expected-error {{not a literal type}}
 
+template<typename T>
+union UnionType {
+  char c;
+  T t;
+  constexpr UnionType() : c{} {}
+};
+constexpr int f(UnionType<int>) { return 0; }
+#ifndef CXX17_OR_LATER
+// expected-error@+3 {{not a literal type}}
+// expected-note@-6 {{'UnionType<NonLiteral>' is not literal because it has data member 't' of non-literal type 'NonLiteral'}}
+#endif
+constexpr int f(UnionType<NonLiteral>) { return 0; }
+
 // - an array of literal type [C++1y] other than an array of runtime bound
 struct ArrGood {
   Agg agg[24];
   double d[12];
   TrivDtor td[3];
   TrivDefaultedDtor tdd[3];
 };
 constexpr int f(ArrGood) { return 0; }