Move most CXXRecordDecl::DefinitionData bit-fields out into a separate

file.

Reduces duplication and thereby reduces the risk that someone will
forget to update one of these places, as I did when adding
DefaultedDestructorIsConstexpr (though I've been unable to produce
a testcase for which that matters so far).

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@374484 91177308-0d34-0410-b5e6-96231b3b80d8

include/clang/AST/CXXRecordDeclDefinitionBits.def

@@ -0,0 +1,236 @@
+//===-- CXXRecordDeclDefinitionBits.def - Class definition bits -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file enumerates the various bitfields that we want to store on C++ class
+// definitions.
+//
+//===----------------------------------------------------------------------===//
+//
+/// @file CXXRecordDeclDefinitionBits.def
+///
+/// In this file, each of the bitfields representing data about a C++ class
+/// results in an expansion of the FIELD macro, which should be defined before
+/// including this file.
+///
+/// The macro have three operands:
+///
+/// Name: The name of the field, as a member of CXXRecordDecl::DefinitionData.
+///
+/// BitWidth: The width of the field in bits.
+///
+/// MergePolicy: How to behave when the value of the field is different in
+/// multiple translation units, one of:
+///   NO_MERGE: It is an ODR violation if the fields do not match.
+///   MERGE_OR: Merge the fields by ORing them together.
+
+#ifndef FIELD
+#error define FIELD before including this file
+#endif
+
+/// True if this class has any user-declared constructors.
+FIELD(UserDeclaredConstructor, 1, NO_MERGE)
+
+/// The user-declared special members which this class has.
+FIELD(UserDeclaredSpecialMembers, 6, NO_MERGE)
+
+/// True when this class is an aggregate.
+FIELD(Aggregate, 1, NO_MERGE)
+
+/// True when this class is a POD-type.
+FIELD(PlainOldData, 1, NO_MERGE)
+
+/// True when this class is empty for traits purposes, that is:
+///  * has no data members other than 0-width bit-fields and empty fields
+///    marked [[no_unique_address]]
+///  * has no virtual function/base, and
+///  * doesn't inherit from a non-empty class.
+/// Doesn't take union-ness into account.
+FIELD(Empty, 1, NO_MERGE)
+
+/// True when this class is polymorphic, i.e., has at
+/// least one virtual member or derives from a polymorphic class.
+FIELD(Polymorphic, 1, NO_MERGE)
+
+/// True when this class is abstract, i.e., has at least
+/// one pure virtual function, (that can come from a base class).
+FIELD(Abstract, 1, NO_MERGE)
+
+/// True when this class is standard-layout, per the applicable
+/// language rules (including DRs).
+FIELD(IsStandardLayout, 1, NO_MERGE)
+
+/// True when this class was standard-layout under the C++11
+/// definition.
+///
+/// C++11 [class]p7.  A standard-layout class is a class that:
+/// * has no non-static data members of type non-standard-layout class (or
+///   array of such types) or reference,
+/// * has no virtual functions (10.3) and no virtual base classes (10.1),
+/// * has the same access control (Clause 11) for all non-static data
+///   members
+/// * has no non-standard-layout base classes,
+/// * either has no non-static data members in the most derived class and at
+///   most one base class with non-static data members, or has no base
+///   classes with non-static data members, and
+/// * has no base classes of the same type as the first non-static data
+///   member.
+FIELD(IsCXX11StandardLayout, 1, NO_MERGE)
+
+/// True when any base class has any declared non-static data
+/// members or bit-fields.
+/// This is a helper bit of state used to implement IsStandardLayout more
+/// efficiently.
+FIELD(HasBasesWithFields, 1, NO_MERGE)
+
+/// True when any base class has any declared non-static data
+/// members.
+/// This is a helper bit of state used to implement IsCXX11StandardLayout
+/// more efficiently.
+FIELD(HasBasesWithNonStaticDataMembers, 1, NO_MERGE)
+
+/// True when there are private non-static data members.
+FIELD(HasPrivateFields, 1, NO_MERGE)
+
+/// True when there are protected non-static data members.
+FIELD(HasProtectedFields, 1, NO_MERGE)
+
+/// True when there are private non-static data members.
+FIELD(HasPublicFields, 1, NO_MERGE)
+
+/// True if this class (or any subobject) has mutable fields.
+FIELD(HasMutableFields, 1, NO_MERGE)
+
+/// True if this class (or any nested anonymous struct or union)
+/// has variant members.
+FIELD(HasVariantMembers, 1, NO_MERGE)
+
+/// True if there no non-field members declared by the user.
+FIELD(HasOnlyCMembers, 1, NO_MERGE)
+
+/// True if any field has an in-class initializer, including those
+/// within anonymous unions or structs.
+FIELD(HasInClassInitializer, 1, NO_MERGE)
+
+/// True if any field is of reference type, and does not have an
+/// in-class initializer.
+///
+/// In this case, value-initialization of this class is illegal in C++98
+/// even if the class has a trivial default constructor.
+FIELD(HasUninitializedReferenceMember, 1, NO_MERGE)
+
+/// True if any non-mutable field whose type doesn't have a user-
+/// provided default ctor also doesn't have an in-class initializer.
+FIELD(HasUninitializedFields, 1, NO_MERGE)
+
+/// True if there are any member using-declarations that inherit
+/// constructors from a base class.
+FIELD(HasInheritedConstructor, 1, NO_MERGE)
+
+/// True if there are any member using-declarations named
+/// 'operator='.
+FIELD(HasInheritedAssignment, 1, NO_MERGE)
+
+/// These flags are \c true if a defaulted corresponding special
+/// member can't be fully analyzed without performing overload resolution.
+/// @{
+FIELD(NeedOverloadResolutionForCopyConstructor, 1, NO_MERGE)
+FIELD(NeedOverloadResolutionForMoveConstructor, 1, NO_MERGE)
+FIELD(NeedOverloadResolutionForMoveAssignment, 1, NO_MERGE)
+FIELD(NeedOverloadResolutionForDestructor, 1, NO_MERGE)
+/// @}
+
+/// These flags are \c true if an implicit defaulted corresponding
+/// special member would be defined as deleted.
+/// @{
+FIELD(DefaultedCopyConstructorIsDeleted, 1, NO_MERGE)
+FIELD(DefaultedMoveConstructorIsDeleted, 1, NO_MERGE)
+FIELD(DefaultedMoveAssignmentIsDeleted, 1, NO_MERGE)
+FIELD(DefaultedDestructorIsDeleted, 1, NO_MERGE)
+/// @}
+
+/// The trivial special members which this class has, per
+/// C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25,
+/// C++11 [class.dtor]p5, or would have if the member were not suppressed.
+///
+/// This excludes any user-declared but not user-provided special members
+/// which have been declared but not yet defined.
+FIELD(HasTrivialSpecialMembers, 6, MERGE_OR)
+
+/// These bits keep track of the triviality of special functions for the
+/// purpose of calls. Only the bits corresponding to SMF_CopyConstructor,
+/// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
+FIELD(HasTrivialSpecialMembersForCall, 6, MERGE_OR)
+
+/// The declared special members of this class which are known to be
+/// non-trivial.
+///
+/// This excludes any user-declared but not user-provided special members
+/// which have been declared but not yet defined, and any implicit special
+/// members which have not yet been declared.
+FIELD(DeclaredNonTrivialSpecialMembers, 6, MERGE_OR)
+
+/// These bits keep track of the declared special members that are
+/// non-trivial for the purpose of calls.
+/// Only the bits corresponding to SMF_CopyConstructor,
+/// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
+FIELD(DeclaredNonTrivialSpecialMembersForCall, 6, MERGE_OR)
+
+/// True when this class has a destructor with no semantic effect.
+FIELD(HasIrrelevantDestructor, 1, NO_MERGE)
+
+/// True when this class has at least one user-declared constexpr
+/// constructor which is neither the copy nor move constructor.
+FIELD(HasConstexprNonCopyMoveConstructor, 1, MERGE_OR)
+
+/// True if this class has a (possibly implicit) defaulted default
+/// constructor.
+FIELD(HasDefaultedDefaultConstructor, 1, MERGE_OR)
+
+/// True if a defaulted default constructor for this class would
+/// be constexpr.
+FIELD(DefaultedDefaultConstructorIsConstexpr, 1, NO_MERGE)
+
+/// True if this class has a constexpr default constructor.
+///
+/// This is true for either a user-declared constexpr default constructor
+/// or an implicitly declared constexpr default constructor.
+FIELD(HasConstexprDefaultConstructor, 1, MERGE_OR)
+
+/// 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)
+
+/// 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,
+/// either by the user or implicitly.
+FIELD(DeclaredSpecialMembers, 6, MERGE_OR)
+
+/// Whether an implicit copy constructor could have a const-qualified
+/// parameter, for initializing virtual bases and for other subobjects.
+FIELD(ImplicitCopyConstructorCanHaveConstParamForVBase, 1, NO_MERGE)
+FIELD(ImplicitCopyConstructorCanHaveConstParamForNonVBase, 1, NO_MERGE)
+
+/// Whether an implicit copy assignment operator would have a
+/// const-qualified parameter.
+FIELD(ImplicitCopyAssignmentHasConstParam, 1, NO_MERGE)
+
+/// Whether any declared copy constructor has a const-qualified
+/// parameter.
+FIELD(HasDeclaredCopyConstructorWithConstParam, 1, MERGE_OR)
+
+/// Whether any declared copy assignment operator has either a
+/// const-qualified reference parameter or a non-reference parameter.
+FIELD(HasDeclaredCopyAssignmentWithConstParam, 1, MERGE_OR)
+
+#undef FIELD

include/clang/AST/DeclCXX.h

@@ -277,210 +277,9 @@ class CXXRecordDecl : public RecordDecl {
   };
 
   struct DefinitionData {
-    /// True if this class has any user-declared constructors.
-    unsigned UserDeclaredConstructor : 1;
-
-    /// The user-declared special members which this class has.
-    unsigned UserDeclaredSpecialMembers : 6;
-
-    /// True when this class is an aggregate.
-    unsigned Aggregate : 1;
-
-    /// True when this class is a POD-type.
-    unsigned PlainOldData : 1;
-
-    /// True when this class is empty for traits purposes, that is:
-    ///  * has no data members other than 0-width bit-fields and empty fields
-    ///    marked [[no_unique_address]]
-    ///  * has no virtual function/base, and
-    ///  * doesn't inherit from a non-empty class.
-    /// Doesn't take union-ness into account.
-    unsigned Empty : 1;
-
-    /// True when this class is polymorphic, i.e., has at
-    /// least one virtual member or derives from a polymorphic class.
-    unsigned Polymorphic : 1;
-
-    /// True when this class is abstract, i.e., has at least
-    /// one pure virtual function, (that can come from a base class).
-    unsigned Abstract : 1;
-
-    /// True when this class is standard-layout, per the applicable
-    /// language rules (including DRs).
-    unsigned IsStandardLayout : 1;
-
-    /// True when this class was standard-layout under the C++11
-    /// definition.
-    ///
-    /// C++11 [class]p7.  A standard-layout class is a class that:
-    /// * has no non-static data members of type non-standard-layout class (or
-    ///   array of such types) or reference,
-    /// * has no virtual functions (10.3) and no virtual base classes (10.1),
-    /// * has the same access control (Clause 11) for all non-static data
-    ///   members
-    /// * has no non-standard-layout base classes,
-    /// * either has no non-static data members in the most derived class and at
-    ///   most one base class with non-static data members, or has no base
-    ///   classes with non-static data members, and
-    /// * has no base classes of the same type as the first non-static data
-    ///   member.
-    unsigned IsCXX11StandardLayout : 1;
-
-    /// True when any base class has any declared non-static data
-    /// members or bit-fields.
-    /// This is a helper bit of state used to implement IsStandardLayout more
-    /// efficiently.
-    unsigned HasBasesWithFields : 1;
-
-    /// True when any base class has any declared non-static data
-    /// members.
-    /// This is a helper bit of state used to implement IsCXX11StandardLayout
-    /// more efficiently.
-    unsigned HasBasesWithNonStaticDataMembers : 1;
-
-    /// True when there are private non-static data members.
-    unsigned HasPrivateFields : 1;
-
-    /// True when there are protected non-static data members.
-    unsigned HasProtectedFields : 1;
-
-    /// True when there are private non-static data members.
-    unsigned HasPublicFields : 1;
-
-    /// True if this class (or any subobject) has mutable fields.
-    unsigned HasMutableFields : 1;
-
-    /// True if this class (or any nested anonymous struct or union)
-    /// has variant members.
-    unsigned HasVariantMembers : 1;
-
-    /// True if there no non-field members declared by the user.
-    unsigned HasOnlyCMembers : 1;
-
-    /// True if any field has an in-class initializer, including those
-    /// within anonymous unions or structs.
-    unsigned HasInClassInitializer : 1;
-
-    /// True if any field is of reference type, and does not have an
-    /// in-class initializer.
-    ///
-    /// In this case, value-initialization of this class is illegal in C++98
-    /// even if the class has a trivial default constructor.
-    unsigned HasUninitializedReferenceMember : 1;
-
-    /// True if any non-mutable field whose type doesn't have a user-
-    /// provided default ctor also doesn't have an in-class initializer.
-    unsigned HasUninitializedFields : 1;
-
-    /// True if there are any member using-declarations that inherit
-    /// constructors from a base class.
-    unsigned HasInheritedConstructor : 1;
-
-    /// True if there are any member using-declarations named
-    /// 'operator='.
-    unsigned HasInheritedAssignment : 1;
-
-    /// These flags are \c true if a defaulted corresponding special
-    /// member can't be fully analyzed without performing overload resolution.
-    /// @{
-    unsigned NeedOverloadResolutionForCopyConstructor : 1;
-    unsigned NeedOverloadResolutionForMoveConstructor : 1;
-    unsigned NeedOverloadResolutionForMoveAssignment : 1;
-    unsigned NeedOverloadResolutionForDestructor : 1;
-    /// @}
-
-    /// These flags are \c true if an implicit defaulted corresponding
-    /// special member would be defined as deleted.
-    /// @{
-    unsigned DefaultedCopyConstructorIsDeleted : 1;
-    unsigned DefaultedMoveConstructorIsDeleted : 1;
-    unsigned DefaultedMoveAssignmentIsDeleted : 1;
-    unsigned DefaultedDestructorIsDeleted : 1;
-    /// @}
-
-    /// The trivial special members which this class has, per
-    /// C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25,
-    /// C++11 [class.dtor]p5, or would have if the member were not suppressed.
-    ///
-    /// This excludes any user-declared but not user-provided special members
-    /// which have been declared but not yet defined.
-    unsigned HasTrivialSpecialMembers : 6;
-
-    /// These bits keep track of the triviality of special functions for the
-    /// purpose of calls. Only the bits corresponding to SMF_CopyConstructor,
-    /// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
-    unsigned HasTrivialSpecialMembersForCall : 6;
-
-    /// The declared special members of this class which are known to be
-    /// non-trivial.
-    ///
-    /// This excludes any user-declared but not user-provided special members
-    /// which have been declared but not yet defined, and any implicit special
-    /// members which have not yet been declared.
-    unsigned DeclaredNonTrivialSpecialMembers : 6;
-
-    /// These bits keep track of the declared special members that are
-    /// non-trivial for the purpose of calls.
-    /// Only the bits corresponding to SMF_CopyConstructor,
-    /// SMF_MoveConstructor, and SMF_Destructor are meaningful here.
-    unsigned DeclaredNonTrivialSpecialMembersForCall : 6;
-
-    /// True when this class has a destructor with no semantic effect.
-    unsigned HasIrrelevantDestructor : 1;
-
-    /// True when this class has at least one user-declared constexpr
-    /// constructor which is neither the copy nor move constructor.
-    unsigned HasConstexprNonCopyMoveConstructor : 1;
-
-    /// True if this class has a (possibly implicit) defaulted default
-    /// constructor.
-    unsigned HasDefaultedDefaultConstructor : 1;
-
-    /// True if a defaulted default constructor for this class would
-    /// be constexpr.
-    unsigned DefaultedDefaultConstructorIsConstexpr : 1;
-
-    /// True if this class has a constexpr default constructor.
-    ///
-    /// This is true for either a user-declared constexpr default constructor
-    /// or an implicitly declared constexpr default constructor.
-    unsigned HasConstexprDefaultConstructor : 1;
-
-    /// True if a defaulted destructor for this class would be constexpr.
-    unsigned DefaultedDestructorIsConstexpr : 1;
-
-    /// True when this class contains at least one non-static data
-    /// member or base class of non-literal or volatile type.
-    unsigned HasNonLiteralTypeFieldsOrBases : 1;
-
-    /// True when visible conversion functions are already computed
-    /// and are available.
-    unsigned ComputedVisibleConversions : 1;
-
-    /// Whether we have a C++11 user-provided default constructor (not
-    /// explicitly deleted or defaulted).
-    unsigned UserProvidedDefaultConstructor : 1;
-
-    /// The special members which have been declared for this class,
-    /// either by the user or implicitly.
-    unsigned DeclaredSpecialMembers : 6;
-
-    /// Whether an implicit copy constructor could have a const-qualified
-    /// parameter, for initializing virtual bases and for other subobjects.
-    unsigned ImplicitCopyConstructorCanHaveConstParamForVBase : 1;
-    unsigned ImplicitCopyConstructorCanHaveConstParamForNonVBase : 1;
-
-    /// Whether an implicit copy assignment operator would have a
-    /// const-qualified parameter.
-    unsigned ImplicitCopyAssignmentHasConstParam : 1;
-
-    /// Whether any declared copy constructor has a const-qualified
-    /// parameter.
-    unsigned HasDeclaredCopyConstructorWithConstParam : 1;
-
-    /// Whether any declared copy assignment operator has either a
-    /// const-qualified reference parameter or a non-reference parameter.
-    unsigned HasDeclaredCopyAssignmentWithConstParam : 1;
+    #define FIELD(Name, Width, Merge) \
+    unsigned Name : Width;
+    #include "CXXRecordDeclDefinitionBits.def"
 
     /// Whether this class describes a C++ lambda.
     unsigned IsLambda : 1;
@@ -488,6 +287,10 @@ class CXXRecordDecl : public RecordDecl {
     /// Whether we are currently parsing base specifiers.
     unsigned IsParsingBaseSpecifiers : 1;
 
+    /// True when visible conversion functions are already computed
+    /// and are available.
+    unsigned ComputedVisibleConversions : 1;
+
     unsigned HasODRHash : 1;
 
     /// A hash of parts of the class to help in ODR checking.

lib/AST/ASTImporter.cpp

@@ -1836,71 +1836,10 @@ Error ASTNodeImporter::ImportDefinition(
 
     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
-    ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
-    ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
-    ToData.Aggregate = FromData.Aggregate;
-    ToData.PlainOldData = FromData.PlainOldData;
-    ToData.Empty = FromData.Empty;
-    ToData.Polymorphic = FromData.Polymorphic;
-    ToData.Abstract = FromData.Abstract;
-    ToData.IsStandardLayout = FromData.IsStandardLayout;
-    ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
-    ToData.HasBasesWithFields = FromData.HasBasesWithFields;
-    ToData.HasBasesWithNonStaticDataMembers =
-        FromData.HasBasesWithNonStaticDataMembers;
-    ToData.HasPrivateFields = FromData.HasPrivateFields;
-    ToData.HasProtectedFields = FromData.HasProtectedFields;
-    ToData.HasPublicFields = FromData.HasPublicFields;
-    ToData.HasMutableFields = FromData.HasMutableFields;
-    ToData.HasVariantMembers = FromData.HasVariantMembers;
-    ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
-    ToData.HasInClassInitializer = FromData.HasInClassInitializer;
-    ToData.HasUninitializedReferenceMember
-      = FromData.HasUninitializedReferenceMember;
-    ToData.HasUninitializedFields = FromData.HasUninitializedFields;
-    ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
-    ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
-    ToData.NeedOverloadResolutionForCopyConstructor
-      = FromData.NeedOverloadResolutionForCopyConstructor;
-    ToData.NeedOverloadResolutionForMoveConstructor
-      = FromData.NeedOverloadResolutionForMoveConstructor;
-    ToData.NeedOverloadResolutionForMoveAssignment
-      = FromData.NeedOverloadResolutionForMoveAssignment;
-    ToData.NeedOverloadResolutionForDestructor
-      = FromData.NeedOverloadResolutionForDestructor;
-    ToData.DefaultedCopyConstructorIsDeleted
-      = FromData.DefaultedCopyConstructorIsDeleted;
-    ToData.DefaultedMoveConstructorIsDeleted
-      = FromData.DefaultedMoveConstructorIsDeleted;
-    ToData.DefaultedMoveAssignmentIsDeleted
-      = FromData.DefaultedMoveAssignmentIsDeleted;
-    ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
-    ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
-    ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
-    ToData.HasConstexprNonCopyMoveConstructor
-      = FromData.HasConstexprNonCopyMoveConstructor;
-    ToData.HasDefaultedDefaultConstructor
-      = FromData.HasDefaultedDefaultConstructor;
-    ToData.DefaultedDefaultConstructorIsConstexpr
-      = FromData.DefaultedDefaultConstructorIsConstexpr;
-    ToData.HasConstexprDefaultConstructor
-      = FromData.HasConstexprDefaultConstructor;
-    ToData.HasNonLiteralTypeFieldsOrBases
-      = FromData.HasNonLiteralTypeFieldsOrBases;
-    // ComputedVisibleConversions not imported.
-    ToData.UserProvidedDefaultConstructor
-      = FromData.UserProvidedDefaultConstructor;
-    ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
-    ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
-      = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
-    ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
-      = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
-    ToData.ImplicitCopyAssignmentHasConstParam
-      = FromData.ImplicitCopyAssignmentHasConstParam;
-    ToData.HasDeclaredCopyConstructorWithConstParam
-      = FromData.HasDeclaredCopyConstructorWithConstParam;
-    ToData.HasDeclaredCopyAssignmentWithConstParam
-      = FromData.HasDeclaredCopyAssignmentWithConstParam;
+
+    #define FIELD(Name, Width, Merge) \
+    ToData.Name = FromData.Name;
+    #include "clang/AST/CXXRecordDeclDefinitionBits.def"
 
     // Copy over the data stored in RecordDeclBits
     ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());

lib/AST/DeclCXX.cpp

@@ -96,14 +96,15 @@ CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
       DefaultedDefaultConstructorIsConstexpr(true),
       HasConstexprDefaultConstructor(false),
       DefaultedDestructorIsConstexpr(true),
-      HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
+      HasNonLiteralTypeFieldsOrBases(false),
       UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
       ImplicitCopyConstructorCanHaveConstParamForVBase(true),
       ImplicitCopyConstructorCanHaveConstParamForNonVBase(true),
       ImplicitCopyAssignmentHasConstParam(true),
       HasDeclaredCopyConstructorWithConstParam(false),
       HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false),
-      IsParsingBaseSpecifiers(false), HasODRHash(false), Definition(D) {}
+      IsParsingBaseSpecifiers(false), ComputedVisibleConversions(false),
+      HasODRHash(false), Definition(D) {}
 
 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
   return Bases.get(Definition->getASTContext().getExternalSource());

lib/Serialization/ASTReaderDecl.cpp

@@ -1656,55 +1656,11 @@ void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
 
 void ASTDeclReader::ReadCXXDefinitionData(
     struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D) {
+  #define FIELD(Name, Width, Merge) \
+  Data.Name = Record.readInt();
+  #include "clang/AST/CXXRecordDeclDefinitionBits.def"
+
   // Note: the caller has deserialized the IsLambda bit already.
-  Data.UserDeclaredConstructor = Record.readInt();
-  Data.UserDeclaredSpecialMembers = Record.readInt();
-  Data.Aggregate = Record.readInt();
-  Data.PlainOldData = Record.readInt();
-  Data.Empty = Record.readInt();
-  Data.Polymorphic = Record.readInt();
-  Data.Abstract = Record.readInt();
-  Data.IsStandardLayout = Record.readInt();
-  Data.IsCXX11StandardLayout = Record.readInt();
-  Data.HasBasesWithFields = Record.readInt();
-  Data.HasBasesWithNonStaticDataMembers = Record.readInt();
-  Data.HasPrivateFields = Record.readInt();
-  Data.HasProtectedFields = Record.readInt();
-  Data.HasPublicFields = Record.readInt();
-  Data.HasMutableFields = Record.readInt();
-  Data.HasVariantMembers = Record.readInt();
-  Data.HasOnlyCMembers = Record.readInt();
-  Data.HasInClassInitializer = Record.readInt();
-  Data.HasUninitializedReferenceMember = Record.readInt();
-  Data.HasUninitializedFields = Record.readInt();
-  Data.HasInheritedConstructor = Record.readInt();
-  Data.HasInheritedAssignment = Record.readInt();
-  Data.NeedOverloadResolutionForCopyConstructor = Record.readInt();
-  Data.NeedOverloadResolutionForMoveConstructor = Record.readInt();
-  Data.NeedOverloadResolutionForMoveAssignment = Record.readInt();
-  Data.NeedOverloadResolutionForDestructor = Record.readInt();
-  Data.DefaultedCopyConstructorIsDeleted = Record.readInt();
-  Data.DefaultedMoveConstructorIsDeleted = Record.readInt();
-  Data.DefaultedMoveAssignmentIsDeleted = Record.readInt();
-  Data.DefaultedDestructorIsDeleted = Record.readInt();
-  Data.HasTrivialSpecialMembers = Record.readInt();
-  Data.HasTrivialSpecialMembersForCall = Record.readInt();
-  Data.DeclaredNonTrivialSpecialMembers = Record.readInt();
-  Data.DeclaredNonTrivialSpecialMembersForCall = Record.readInt();
-  Data.HasIrrelevantDestructor = Record.readInt();
-  Data.HasConstexprNonCopyMoveConstructor = Record.readInt();
-  Data.HasDefaultedDefaultConstructor = Record.readInt();
-  Data.DefaultedDefaultConstructorIsConstexpr = Record.readInt();
-  Data.HasConstexprDefaultConstructor = Record.readInt();
-  Data.HasNonLiteralTypeFieldsOrBases = Record.readInt();
-  Data.ComputedVisibleConversions = Record.readInt();
-  Data.UserProvidedDefaultConstructor = Record.readInt();
-  Data.DeclaredSpecialMembers = Record.readInt();
-  Data.ImplicitCopyConstructorCanHaveConstParamForVBase = Record.readInt();
-  Data.ImplicitCopyConstructorCanHaveConstParamForNonVBase = Record.readInt();
-  Data.ImplicitCopyAssignmentHasConstParam = Record.readInt();
-  Data.HasDeclaredCopyConstructorWithConstParam = Record.readInt();
-  Data.HasDeclaredCopyAssignmentWithConstParam = Record.readInt();
   Data.ODRHash = Record.readInt();
   Data.HasODRHash = true;
 
@@ -1719,7 +1675,9 @@ void ASTDeclReader::ReadCXXDefinitionData(
     Data.VBases = ReadGlobalOffset();
 
   Record.readUnresolvedSet(Data.Conversions);
-  Record.readUnresolvedSet(Data.VisibleConversions);
+  Data.ComputedVisibleConversions = Record.readInt();
+  if (Data.ComputedVisibleConversions)
+    Record.readUnresolvedSet(Data.VisibleConversions);
   assert(Data.Definition && "Data.Definition should be already set!");
   Data.FirstFriend = ReadDeclID();
 
@@ -1792,63 +1750,17 @@ void ASTDeclReader::MergeDefinitionData(
     return;
   }
 
-  // FIXME: Move this out into a .def file?
   bool DetectedOdrViolation = false;
-#define OR_FIELD(Field) DD.Field |= MergeDD.Field;
-#define MATCH_FIELD(Field) \
+
+  #define FIELD(Name, Width, Merge) Merge(Name)
+  #define MERGE_OR(Field) DD.Field |= MergeDD.Field;
+  #define NO_MERGE(Field) \
     DetectedOdrViolation |= DD.Field != MergeDD.Field; \
-    OR_FIELD(Field)
-  MATCH_FIELD(UserDeclaredConstructor)
-  MATCH_FIELD(UserDeclaredSpecialMembers)
-  MATCH_FIELD(Aggregate)
-  MATCH_FIELD(PlainOldData)
-  MATCH_FIELD(Empty)
-  MATCH_FIELD(Polymorphic)
-  MATCH_FIELD(Abstract)
-  MATCH_FIELD(IsStandardLayout)
-  MATCH_FIELD(IsCXX11StandardLayout)
-  MATCH_FIELD(HasBasesWithFields)
-  MATCH_FIELD(HasBasesWithNonStaticDataMembers)
-  MATCH_FIELD(HasPrivateFields)
-  MATCH_FIELD(HasProtectedFields)
-  MATCH_FIELD(HasPublicFields)
-  MATCH_FIELD(HasMutableFields)
-  MATCH_FIELD(HasVariantMembers)
-  MATCH_FIELD(HasOnlyCMembers)
-  MATCH_FIELD(HasInClassInitializer)
-  MATCH_FIELD(HasUninitializedReferenceMember)
-  MATCH_FIELD(HasUninitializedFields)
-  MATCH_FIELD(HasInheritedConstructor)
-  MATCH_FIELD(HasInheritedAssignment)
-  MATCH_FIELD(NeedOverloadResolutionForCopyConstructor)
-  MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
-  MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
-  MATCH_FIELD(NeedOverloadResolutionForDestructor)
-  MATCH_FIELD(DefaultedCopyConstructorIsDeleted)
-  MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
-  MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
-  MATCH_FIELD(DefaultedDestructorIsDeleted)
-  OR_FIELD(HasTrivialSpecialMembers)
-  OR_FIELD(HasTrivialSpecialMembersForCall)
-  OR_FIELD(DeclaredNonTrivialSpecialMembers)
-  OR_FIELD(DeclaredNonTrivialSpecialMembersForCall)
-  MATCH_FIELD(HasIrrelevantDestructor)
-  OR_FIELD(HasConstexprNonCopyMoveConstructor)
-  OR_FIELD(HasDefaultedDefaultConstructor)
-  MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
-  OR_FIELD(HasConstexprDefaultConstructor)
-  MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
-  // ComputedVisibleConversions is handled below.
-  MATCH_FIELD(UserProvidedDefaultConstructor)
-  OR_FIELD(DeclaredSpecialMembers)
-  MATCH_FIELD(ImplicitCopyConstructorCanHaveConstParamForVBase)
-  MATCH_FIELD(ImplicitCopyConstructorCanHaveConstParamForNonVBase)
-  MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
-  OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
-  OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
-  MATCH_FIELD(IsLambda)
-#undef OR_FIELD
-#undef MATCH_FIELD
+    MERGE_OR(Field)
+  #include "clang/AST/CXXRecordDeclDefinitionBits.def"
+  NO_MERGE(IsLambda)
+  #undef NO_MERGE
+  #undef MERGE_OR
 
   if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
     DetectedOdrViolation = true;

lib/Serialization/ASTWriter.cpp

@@ -6141,54 +6141,10 @@ void ASTRecordWriter::AddCXXCtorInitializers(
 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) {
   auto &Data = D->data();
   Record->push_back(Data.IsLambda);
-  Record->push_back(Data.UserDeclaredConstructor);
-  Record->push_back(Data.UserDeclaredSpecialMembers);
-  Record->push_back(Data.Aggregate);
-  Record->push_back(Data.PlainOldData);
-  Record->push_back(Data.Empty);
-  Record->push_back(Data.Polymorphic);
-  Record->push_back(Data.Abstract);
-  Record->push_back(Data.IsStandardLayout);
-  Record->push_back(Data.IsCXX11StandardLayout);
-  Record->push_back(Data.HasBasesWithFields);
-  Record->push_back(Data.HasBasesWithNonStaticDataMembers);
-  Record->push_back(Data.HasPrivateFields);
-  Record->push_back(Data.HasProtectedFields);
-  Record->push_back(Data.HasPublicFields);
-  Record->push_back(Data.HasMutableFields);
-  Record->push_back(Data.HasVariantMembers);
-  Record->push_back(Data.HasOnlyCMembers);
-  Record->push_back(Data.HasInClassInitializer);
-  Record->push_back(Data.HasUninitializedReferenceMember);
-  Record->push_back(Data.HasUninitializedFields);
-  Record->push_back(Data.HasInheritedConstructor);
-  Record->push_back(Data.HasInheritedAssignment);
-  Record->push_back(Data.NeedOverloadResolutionForCopyConstructor);
-  Record->push_back(Data.NeedOverloadResolutionForMoveConstructor);
-  Record->push_back(Data.NeedOverloadResolutionForMoveAssignment);
-  Record->push_back(Data.NeedOverloadResolutionForDestructor);
-  Record->push_back(Data.DefaultedCopyConstructorIsDeleted);
-  Record->push_back(Data.DefaultedMoveConstructorIsDeleted);
-  Record->push_back(Data.DefaultedMoveAssignmentIsDeleted);
-  Record->push_back(Data.DefaultedDestructorIsDeleted);
-  Record->push_back(Data.HasTrivialSpecialMembers);
-  Record->push_back(Data.HasTrivialSpecialMembersForCall);
-  Record->push_back(Data.DeclaredNonTrivialSpecialMembers);
-  Record->push_back(Data.DeclaredNonTrivialSpecialMembersForCall);
-  Record->push_back(Data.HasIrrelevantDestructor);
-  Record->push_back(Data.HasConstexprNonCopyMoveConstructor);
-  Record->push_back(Data.HasDefaultedDefaultConstructor);
-  Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr);
-  Record->push_back(Data.HasConstexprDefaultConstructor);
-  Record->push_back(Data.HasNonLiteralTypeFieldsOrBases);
-  Record->push_back(Data.ComputedVisibleConversions);
-  Record->push_back(Data.UserProvidedDefaultConstructor);
-  Record->push_back(Data.DeclaredSpecialMembers);
-  Record->push_back(Data.ImplicitCopyConstructorCanHaveConstParamForVBase);
-  Record->push_back(Data.ImplicitCopyConstructorCanHaveConstParamForNonVBase);
-  Record->push_back(Data.ImplicitCopyAssignmentHasConstParam);
-  Record->push_back(Data.HasDeclaredCopyConstructorWithConstParam);
-  Record->push_back(Data.HasDeclaredCopyAssignmentWithConstParam);
+
+  #define FIELD(Name, Width, Merge) \
+  Record->push_back(Data.Name);
+  #include "clang/AST/CXXRecordDeclDefinitionBits.def"
 
   // getODRHash will compute the ODRHash if it has not been previously computed.
   Record->push_back(D->getODRHash());
@@ -6210,7 +6166,9 @@ void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) {
     AddCXXBaseSpecifiers(Data.vbases());
 
   AddUnresolvedSet(Data.Conversions.get(*Writer->Context));
-  AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context));
+  Record->push_back(Data.ComputedVisibleConversions);
+  if (Data.ComputedVisibleConversions)
+    AddUnresolvedSet(Data.VisibleConversions.get(*Writer->Context));
   // Data.Definition is the owning decl, no need to write it.
   AddDeclRef(D->getFirstFriend());