[AST][2/4] Move the bit-fields from FunctionDecl and CXXConstructorDecl into DeclContext

[bricci]

Summary

This patch follows https://reviews.llvm.org/D49729
and is followed by https://reviews.llvm.org/D49733
and https://reviews.llvm.org/D49734.

Move the bits from FunctionDecl and CXXConstructorDecl
into DeclContext.

[erichkeane]

Anotherone in need of clang-format, otherwise seems alright to me.

include/clang/AST/Decl.h

1809

I'm not sure I see the value of these. FunctiondeclBits is littered around here a bit, so I don't think these additional ones have all that much value. At least the MultiVersion case actually doesn't do anything but call these.

2033

Newline.

[bricci]

• ran clang-format on the changes
• removed the unnecessary setPureImpl, isMultiVersionImpl and setMultiVersionImpl. However unfortunately I think that isDeletedImpl has to stay because ASTDeclWriter::VisitFunctionDecl need to access this bit but we do not want to make ASTDeclWriter a friend of FunctionDeclBitfields just for this. FWIW I have renamed it to isDeletedBit...

[bricci]

rebased after the great whitespace trimming

include/clang/AST/Decl.h

 /// function. Only one of those FunctionDecls will be found when
 /// traversing the list of declarations in the context of the
 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
 /// contains all of the information known about the function. Other,
 /// previous declarations of the function are available via the
 /// getPreviousDecl() chain.
 class FunctionDecl : public DeclaratorDecl, public DeclContext,
                      public Redeclarable<FunctionDecl> {
+  // This class stores some data in DeclContext::FunctionDeclBits
+  // to save some space. Use the provided accessors to access it.
 public:
   /// The kind of templated function a FunctionDecl can be.
   enum TemplatedKind {
     TK_NonTemplate,
     TK_FunctionTemplate,
     TK_MemberSpecialization,
     TK_FunctionTemplateSpecialization,
     TK_DependentFunctionTemplateSpecialization
   };
 
 private:
   /// A new[]'d array of pointers to VarDecls for the formal
   /// parameters of this function.  This is null if a prototype or if there are
   /// no formals.
   ParmVarDecl **ParamInfo = nullptr;
 
   LazyDeclStmtPtr Body;
 
-  // FIXME: This can be packed into the bitfields in DeclContext.
-  // NOTE: VC++ packs bitfields poorly if the types differ.
-  unsigned SClass : 3;
-  unsigned IsInline : 1;
-  unsigned IsInlineSpecified : 1;
-
-protected:
-  // This is shared by CXXConstructorDecl, CXXConversionDecl, and
-  // CXXDeductionGuideDecl.
-  unsigned IsExplicitSpecified : 1;
-
-private:
-  unsigned IsVirtualAsWritten : 1;
-  unsigned IsPure : 1;
-  unsigned HasInheritedPrototype : 1;
-  unsigned HasWrittenPrototype : 1;
-  unsigned IsDeleted : 1;
-  unsigned IsTrivial : 1; // sunk from CXXMethodDecl
-
-  /// This flag indicates whether this function is trivial for the purpose of
-  /// calls. This is meaningful only when this function is a copy/move
-  /// constructor or a destructor.
-  unsigned IsTrivialForCall : 1;
-
-  unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
-  unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
-  unsigned HasImplicitReturnZero : 1;
-  unsigned IsLateTemplateParsed : 1;
-  unsigned IsConstexpr : 1;
-  unsigned InstantiationIsPending : 1;
-
-  /// Indicates if the function uses __try.
-  unsigned UsesSEHTry : 1;
-
-  /// Indicates if the function was a definition but its body was
-  /// skipped.
-  unsigned HasSkippedBody : 1;
-
-  /// Indicates if the function declaration will have a body, once we're done
-  /// parsing it.
-  unsigned WillHaveBody : 1;
-
-  /// Indicates that this function is a multiversioned function using attribute
-  /// 'target'.
-  unsigned IsMultiVersion : 1;
-
-protected:
-  /// [C++17] Only used by CXXDeductionGuideDecl. Declared here to avoid
-  /// increasing the size of CXXDeductionGuideDecl by the size of an unsigned
-  /// int as opposed to adding a single bit to FunctionDecl.
-  /// Indicates that the Deduction Guide is the implicitly generated 'copy
-  /// deduction candidate' (is used during overload resolution).
-  unsigned IsCopyDeductionCandidate : 1;
-
-private:
-
-  /// Store the ODRHash after first calculation.
-  unsigned HasODRHash : 1;
   unsigned ODRHash;
 
   /// End part of this FunctionDecl's source range.
   ///
   /// We could compute the full range in getSourceRange(). However, when we're
   /// dealing with a function definition deserialized from a PCH/AST file,
   /// we can only compute the full range once the function body has been
   /// de-serialized, so it's far better to have the (sometimes-redundant)
private:
 
   /// Specify that this record is an instantiation of the
   /// member function FD.
   void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
                                         TemplateSpecializationKind TSK);
 
   void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
 
+  // These simple getters/setters are used to hide where the corresponding
+  // bit is stored. This avoid littering the place with "FunctionDeclBits.".
+  // This is needed because setPure, isDeleted, isMultiversion
+  // and setMultiVersion do not simply set/read the corresponding bit.
+  void setPureImpl(bool isPure) { FunctionDeclBits.IsPure = isPure; }
+  bool isDeletedImpl() const { return FunctionDeclBits.IsDeleted; }
+  bool isMultiVersionImpl() const { return FunctionDeclBits.IsMultiVersion; }
+  void setMultiVersionImpl(bool B) { FunctionDeclBits.IsMultiVersion = B; }
+
+  /// Whether an ODRHash has been stored.
+  bool hasODRHash() const { return FunctionDeclBits.HasODRHash; }
+  /// State that an ODRHash has been stored.
+  void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }
+
 protected:
   FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
-               bool isConstexprSpecified)
-      : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
-                       StartLoc),
-        DeclContext(DK), redeclarable_base(C), SClass(S),
-        IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
-        IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
-        HasInheritedPrototype(false), HasWrittenPrototype(true),
-        IsDeleted(false), IsTrivial(false), IsTrivialForCall(false),
-        IsDefaulted(false),
-        IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
-        IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
-        InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
-        WillHaveBody(false), IsMultiVersion(false),
-        IsCopyDeductionCandidate(false), HasODRHash(false), ODRHash(0),
-        EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {}
+               bool isConstexprSpecified);
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
   FunctionDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
   }
 
   FunctionDecl *getPreviousDeclImpl() override {
public:
   }
 
   /// Returns whether this specific declaration of the function is also a
   /// definition that does not contain uninstantiated body.
   ///
   /// This does not determine whether the function has been defined (e.g., in a
   /// previous definition); for that information, use isDefined.
   bool isThisDeclarationADefinition() const {
-    return IsDeleted || IsDefaulted || Body || HasSkippedBody ||
-           IsLateTemplateParsed || WillHaveBody || hasDefiningAttr();
+    return isDeletedAsWritten() || isDefaulted() ||
+           Body || hasSkippedBody() || isLateTemplateParsed() ||
+           willHaveBody() || hasDefiningAttr();
   }
 
   /// Returns whether this specific declaration of the function has a body.
   bool doesThisDeclarationHaveABody() const {
-    return Body || IsLateTemplateParsed;
+    return Body || isLateTemplateParsed();
   }
 
   void setBody(Stmt *B);
   void setLazyBody(uint64_t Offset) { Body = Offset; }
 
   /// Whether this function is variadic.
   bool isVariadic() const;
 
   /// Whether this function is marked as virtual explicitly.
-  bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
-  void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }
+  bool isVirtualAsWritten() const {
+    return FunctionDeclBits.IsVirtualAsWritten;
+  }
+
+  /// State that this function is marked as virtual explicitly.
+  void setVirtualAsWritten(bool V) {
+    FunctionDeclBits.IsVirtualAsWritten = V;
+  }
 
   /// Whether this virtual function is pure, i.e. makes the containing class
   /// abstract.
-  bool isPure() const { return IsPure; }
+  bool isPure() const { return FunctionDeclBits.IsPure; }
   void setPure(bool P = true);
 
   /// Whether this templated function will be late parsed.
-  bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
-  void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }
+  bool isLateTemplateParsed() const {
+    return FunctionDeclBits.IsLateTemplateParsed;
+  }
+
+  /// State that this templated function will be late parsed.
+  void setLateTemplateParsed(bool ILT = true) {
+    FunctionDeclBits.IsLateTemplateParsed = ILT;
+  }
 
   /// Whether this function is "trivial" in some specialized C++ senses.
   /// Can only be true for default constructors, copy constructors,
   /// copy assignment operators, and destructors.  Not meaningful until
   /// the class has been fully built by Sema.
-  bool isTrivial() const { return IsTrivial; }
-  void setTrivial(bool IT) { IsTrivial = IT; }
+  bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
+  void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }
 
-  bool isTrivialForCall() const { return IsTrivialForCall; }
-  void setTrivialForCall(bool IT) { IsTrivialForCall = IT; }
+  bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
+  void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }
 
   /// Whether this function is defaulted per C++0x. Only valid for
   /// special member functions.
-  bool isDefaulted() const { return IsDefaulted; }
-  void setDefaulted(bool D = true) { IsDefaulted = D; }
+  bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
+  void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }
 
   /// Whether this function is explicitly defaulted per C++0x. Only valid
   /// for special member functions.
-  bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
-  void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }
+  bool isExplicitlyDefaulted() const {
+    return FunctionDeclBits.IsExplicitlyDefaulted;
+  }
+  void setExplicitlyDefaulted(bool ED = true) {
+    FunctionDeclBits.IsExplicitlyDefaulted = ED;
+  }
 
   /// Whether falling off this function implicitly returns null/zero.
   /// If a more specific implicit return value is required, front-ends
   /// should synthesize the appropriate return statements.
-  bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
-  void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }
+  bool hasImplicitReturnZero() const {
+    return FunctionDeclBits.HasImplicitReturnZero;
+  }
+  void setHasImplicitReturnZero(bool IRZ) {
+    FunctionDeclBits.HasImplicitReturnZero = IRZ;
+  }
 
   /// Whether this function has a prototype, either because one
   /// was explicitly written or because it was "inherited" by merging
   /// a declaration without a prototype with a declaration that has a
   /// prototype.
   bool hasPrototype() const {
-    return HasWrittenPrototype || HasInheritedPrototype;
+    return hasWrittenPrototype() || hasInheritedPrototype();
   }
 
-  bool hasWrittenPrototype() const { return HasWrittenPrototype; }
+  bool hasWrittenPrototype() const {
+    return FunctionDeclBits.HasWrittenPrototype;
+  }
+  void setHasWrittenPrototype(bool P = true) {
+    FunctionDeclBits.HasWrittenPrototype = P;
+  }
 
   /// Whether this function inherited its prototype from a
   /// previous declaration.
-  bool hasInheritedPrototype() const { return HasInheritedPrototype; }
-  void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
+  bool hasInheritedPrototype() const {
+    return FunctionDeclBits.HasInheritedPrototype;
+  }
+  void setHasInheritedPrototype(bool P = true) {
+    FunctionDeclBits.HasInheritedPrototype = P;
+  }
 
   /// Whether this is a (C++11) constexpr function or constexpr constructor.
-  bool isConstexpr() const { return IsConstexpr; }
-  void setConstexpr(bool IC) { IsConstexpr = IC; }
+  bool isConstexpr() const { return FunctionDeclBits.IsConstexpr; }
+  void setConstexpr(bool IC) { FunctionDeclBits.IsConstexpr = IC; }
 
   /// Whether the instantiation of this function is pending.
   /// This bit is set when the decision to instantiate this function is made
   /// and unset if and when the function body is created. That leaves out
   /// cases where instantiation did not happen because the template definition
   /// was not seen in this TU. This bit remains set in those cases, under the
   /// assumption that the instantiation will happen in some other TU.
-  bool instantiationIsPending() const { return InstantiationIsPending; }
-  void setInstantiationIsPending(bool IC) { InstantiationIsPending = IC; }
+  bool instantiationIsPending() const {
+    return FunctionDeclBits.InstantiationIsPending;
+  }
+  void setInstantiationIsPending(bool IC) {
+    FunctionDeclBits.InstantiationIsPending = IC;
+  }
 
   /// Indicates the function uses __try.
-  bool usesSEHTry() const { return UsesSEHTry; }
-  void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }
+  bool usesSEHTry() const { return FunctionDeclBits.UsesSEHTry; }
+  void setUsesSEHTry(bool UST) { FunctionDeclBits.UsesSEHTry = UST; }
 
   /// Whether this function has been deleted.
   ///
   /// A function that is "deleted" (via the C++0x "= delete" syntax)
   /// acts like a normal function, except that it cannot actually be
   /// called or have its address taken. Deleted functions are
   /// typically used in C++ overload resolution to attract arguments
   /// whose type or lvalue/rvalue-ness would permit the use of a
   /// different overload that would behave incorrectly. For example,
   /// one might use deleted functions to ban implicit conversion from
   /// a floating-point number to an Integer type:
   ///
   /// @code
   /// struct Integer {
   ///   Integer(long); // construct from a long
   ///   Integer(double) = delete; // no construction from float or double
   ///   Integer(long double) = delete; // no construction from long double
   /// };
   /// @endcode
   // If a function is deleted, its first declaration must be.
-  bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
-  bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
-  void setDeletedAsWritten(bool D = true) { IsDeleted = D; }
+  bool isDeleted() const {
+    return getCanonicalDecl()->isDeletedImpl();
+  }
+  bool isDeletedAsWritten() const {
+    return isDeletedImpl() && !isDefaulted();
+  }
+  void setDeletedAsWritten(bool D = true) { FunctionDeclBits.IsDeleted = D; }
 
   /// Determines whether this function is "main", which is the
   /// entry point into an executable program.
   bool isMain() const;
 
   /// Determines whether this function is a MSVCRT user defined entry
   /// point.
   bool isMSVCRTEntryPoint() const;
public:
   /// Determines whether this is a global function.
   bool isGlobal() const;
 
   /// Determines whether this function is known to be 'noreturn', through
   /// an attribute on its declaration or its type.
   bool isNoReturn() const;
 
   /// True if the function was a definition but its body was skipped.
-  bool hasSkippedBody() const { return HasSkippedBody; }
-  void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
+  bool hasSkippedBody() const { return FunctionDeclBits.HasSkippedBody; }
+  void setHasSkippedBody(bool Skipped = true) {
+    FunctionDeclBits.HasSkippedBody = Skipped;
+  }
 
   /// True if this function will eventually have a body, once it's fully parsed.
-  bool willHaveBody() const { return WillHaveBody; }
-  void setWillHaveBody(bool V = true) { WillHaveBody = V; }
+  bool willHaveBody() const { return FunctionDeclBits.WillHaveBody; }
+  void setWillHaveBody(bool V = true) { FunctionDeclBits.WillHaveBody = V; }
 
   /// True if this function is considered a multiversioned function.
-  bool isMultiVersion() const { return getCanonicalDecl()->IsMultiVersion; }
+  bool isMultiVersion() const {
+    return getCanonicalDecl()->isMultiVersionImpl();
+  }
 
   /// Sets the multiversion state for this declaration and all of its
   /// redeclarations.
   void setIsMultiVersion(bool V = true) {
-    getCanonicalDecl()->IsMultiVersion = V;
+    getCanonicalDecl()->setMultiVersionImpl(V);
   }
 
   /// True if this function is a multiversioned dispatch function as a part of
   /// the cpu_specific/cpu_dispatch functionality.
   bool isCPUDispatchMultiVersion() const;
   /// True if this function is a multiversioned processor specific function as a
   /// part of the cpu_specific/cpu_dispatch functionality.
   bool isCPUSpecificMultiVersion() const;
public:
   const Attr *getUnusedResultAttr() const;
 
   /// Returns true if this function or its return type has the
   /// warn_unused_result attribute.
   bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }
 
   /// Returns the storage class as written in the source. For the
   /// computed linkage of symbol, see getLinkage.
-  StorageClass getStorageClass() const { return StorageClass(SClass); }
+  StorageClass getStorageClass() const {
+    return static_cast<StorageClass>(FunctionDeclBits.SClass);
+  }
+  void setStorageClass(StorageClass SClass) {
+    FunctionDeclBits.SClass = SClass;
+  }
 
   /// Determine whether the "inline" keyword was specified for this
   /// function.
-  bool isInlineSpecified() const { return IsInlineSpecified; }
+  bool isInlineSpecified() const {
+    return FunctionDeclBits.IsInlineSpecified;
+  }
 
   /// Set whether the "inline" keyword was specified for this function.
   void setInlineSpecified(bool I) {
-    IsInlineSpecified = I;
-    IsInline = I;
+    FunctionDeclBits.IsInlineSpecified = I;
+    FunctionDeclBits.IsInline = I;
   }
 
   /// Flag that this function is implicitly inline.
-  void setImplicitlyInline() {
-    IsInline = true;
+  void setImplicitlyInline(bool I = true) {
+    FunctionDeclBits.IsInline = I;
   }
 
   /// Determine whether this function should be inlined, because it is
   /// either marked "inline" or "constexpr" or is a member function of a class
   /// that was defined in the class body.
-  bool isInlined() const { return IsInline; }
+  bool isInlined() const {
+    return FunctionDeclBits.IsInline;
+  }
+
+  /// Whether this function is marked as explicit explicitly.
+  bool isExplicitSpecified() const {
+    return FunctionDeclBits.IsExplicitSpecified;
+  }
+
+  /// State that this function is marked as explicit explicitly.
+  void setExplicitSpecified(bool ExpSpec = true) {
+    FunctionDeclBits.IsExplicitSpecified = ExpSpec;
+  }
 
   bool isInlineDefinitionExternallyVisible() const;
 
   bool isMSExternInline() const;
 
   bool doesDeclarationForceExternallyVisibleDefinition() const;
 
   /// Whether this function declaration represents an C++ overloaded

include/clang/AST/DeclCXX.h

private:
   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                         bool IsExplicit, const DeclarationNameInfo &NameInfo,
                         QualType T, TypeSourceInfo *TInfo,
                         SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
                      SC_None, false, false) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
-    IsExplicitSpecified = IsExplicit;
+    setExplicitSpecified(IsExplicit);
+    setIsCopyDeductionCandidate(false);
   }
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   static CXXDeductionGuideDecl *Create(ASTContext &C, DeclContext *DC,
                                        SourceLocation StartLoc, bool IsExplicit,
                                        const DeclarationNameInfo &NameInfo,
                                        QualType T, TypeSourceInfo *TInfo,
                                        SourceLocation EndLocation);
 
   static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   /// Whether this deduction guide is explicit.
-  bool isExplicit() const { return IsExplicitSpecified; }
-
-  /// Whether this deduction guide was declared with the 'explicit' specifier.
-  bool isExplicitSpecified() const { return IsExplicitSpecified; }
+  bool isExplicit() const {
+    return isExplicitSpecified();
+  }
 
   /// Get the template for which this guide performs deduction.
   TemplateDecl *getDeducedTemplate() const {
     return getDeclName().getCXXDeductionGuideTemplate();
   }
 
-  void setIsCopyDeductionCandidate() {
-    IsCopyDeductionCandidate = true;
+  void setIsCopyDeductionCandidate(bool isCDC = true) {
+    FunctionDeclBits.IsCopyDeductionCandidate = isCDC;
+  }
+  bool isCopyDeductionCandidate() const {
+    return FunctionDeclBits.IsCopyDeductionCandidate;
   }
-
-  bool isCopyDeductionCandidate() const { return IsCopyDeductionCandidate; }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == CXXDeductionGuide; }
 };
 
 /// Represents a static or instance method of a struct/union/class.
 ///

 /// class X {
 /// public:
 ///   explicit X(int); // represented by a CXXConstructorDecl.
 /// };
 /// \endcode
 class CXXConstructorDecl final
     : public CXXMethodDecl,
       private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor> {
+  // This class stores some data in DeclContext::CXXConstructorDeclBits
+  // to save some space. Use the provided accessors to access it.
+
   /// \name Support for base and member initializers.
   /// \{
   /// The arguments used to initialize the base or member.
   LazyCXXCtorInitializersPtr CtorInitializers;
-  unsigned NumCtorInitializers : 31;
-  /// \}
-
-  /// Whether this constructor declaration is an implicitly-declared
-  /// inheriting constructor.
-  unsigned IsInheritingConstructor : 1;
 
   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                      const DeclarationNameInfo &NameInfo,
                      QualType T, TypeSourceInfo *TInfo,
                      bool isExplicitSpecified, bool isInline,
                      bool isImplicitlyDeclared, bool isConstexpr,
-                     InheritedConstructor Inherited)
-    : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, isConstexpr, SourceLocation()),
-      NumCtorInitializers(0), IsInheritingConstructor((bool)Inherited) {
-    setImplicit(isImplicitlyDeclared);
-    if (Inherited)
-      *getTrailingObjects<InheritedConstructor>() = Inherited;
-    IsExplicitSpecified = isExplicitSpecified;
-  }
+                     InheritedConstructor Inherited);
 
   void anchor() override;
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
   friend TrailingObjects;
 
init_iterator init_begin() {
     return const_cast<init_iterator>(ConstThis->init_begin());
   }
 
   /// Retrieve an iterator to the first initializer.
   init_const_iterator init_begin() const;
 
   /// Retrieve an iterator past the last initializer.
   init_iterator       init_end()       {
-    return init_begin() + NumCtorInitializers;
+    return init_begin() + getNumCtorInitializers();
   }
 
   /// Retrieve an iterator past the last initializer.
   init_const_iterator init_end() const {
-    return init_begin() + NumCtorInitializers;
+    return init_begin() + getNumCtorInitializers();
   }
 
   using init_reverse_iterator = std::reverse_iterator<init_iterator>;
   using init_const_reverse_iterator =
       std::reverse_iterator<init_const_iterator>;
 
   init_reverse_iterator init_rbegin() {
     return init_reverse_iterator(init_end());
   }
   init_const_reverse_iterator init_rbegin() const {
     return init_const_reverse_iterator(init_end());
   }
 
   init_reverse_iterator init_rend() {
     return init_reverse_iterator(init_begin());
   }
   init_const_reverse_iterator init_rend() const {
     return init_const_reverse_iterator(init_begin());
   }
 
   /// Determine the number of arguments used to initialize the member
   /// or base.
   unsigned getNumCtorInitializers() const {
-      return NumCtorInitializers;
+      return CXXConstructorDeclBits.NumCtorInitializers;
   }
 
   void setNumCtorInitializers(unsigned numCtorInitializers) {
-    NumCtorInitializers = numCtorInitializers;
+    CXXConstructorDeclBits.NumCtorInitializers = numCtorInitializers;
+    // This assert added because NumCtorInitializers is stored
+    // in CXXConstructorDeclBits as a bitfield and its width has
+    // been shrunk from 32 bits to fit into CXXConstructorDeclBitfields.
+    assert(CXXConstructorDeclBits.NumCtorInitializers ==
+           numCtorInitializers && "NumCtorInitializers overflow!");
   }
 
   void setCtorInitializers(CXXCtorInitializer **Initializers) {
     CtorInitializers = Initializers;
   }
 
-  /// Whether this function is marked as explicit explicitly.
-  bool isExplicitSpecified() const { return IsExplicitSpecified; }
-
   /// Whether this function is explicit.
   bool isExplicit() const {
     return getCanonicalDecl()->isExplicitSpecified();
   }
 
   /// Determine whether this constructor is a delegating constructor.
   bool isDelegatingConstructor() const {
     return (getNumCtorInitializers() == 1) &&
public:
 
   /// Determine whether this is a member template specialization that
   /// would copy the object to itself. Such constructors are never used to copy
   /// an object.
   bool isSpecializationCopyingObject() const;
 
   /// Determine whether this is an implicit constructor synthesized to
   /// model a call to a constructor inherited from a base class.
-  bool isInheritingConstructor() const { return IsInheritingConstructor; }
+  bool isInheritingConstructor() const {
+    return CXXConstructorDeclBits.IsInheritingConstructor;
+  }
+
+  /// State that this is an implicit constructor synthesized to
+  /// model a call to a constructor inherited from a base class.
+  void setInheritingConstructor(bool isIC = true) {
+    CXXConstructorDeclBits.IsInheritingConstructor = isIC;
+  }
 
   /// Get the constructor that this inheriting constructor is based on.
   InheritedConstructor getInheritedConstructor() const {
-    return IsInheritingConstructor ? *getTrailingObjects<InheritedConstructor>()
-                                   : InheritedConstructor();
+    return isInheritingConstructor() ?
+      *getTrailingObjects<InheritedConstructor>() : InheritedConstructor();
   }
 
   CXXConstructorDecl *getCanonicalDecl() override {
     return cast<CXXConstructorDecl>(FunctionDecl::getCanonicalDecl());
   }
   const CXXConstructorDecl *getCanonicalDecl() const {
     return const_cast<CXXConstructorDecl*>(this)->getCanonicalDecl();
   }

 class CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline,
                     bool isExplicitSpecified, bool isConstexpr,
                     SourceLocation EndLocation)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
                       SC_None, isInline, isConstexpr, EndLocation) {
-    IsExplicitSpecified = isExplicitSpecified;
+    setExplicitSpecified(isExplicitSpecified);
   }
 
   void anchor() override;
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                    SourceLocation StartLoc,
                                    const DeclarationNameInfo &NameInfo,
                                    QualType T, TypeSourceInfo *TInfo,
                                    bool isInline, bool isExplicit,
                                    bool isConstexpr,
                                    SourceLocation EndLocation);
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
-  /// Whether this function is marked as explicit explicitly.
-  bool isExplicitSpecified() const { return IsExplicitSpecified; }
-
   /// Whether this function is explicit.
   bool isExplicit() const {
     return getCanonicalDecl()->isExplicitSpecified();
   }
 
   /// Returns the type that this conversion function is converting to.
   QualType getConversionType() const {
     return getType()->getAs<FunctionType>()->getReturnType();

lib/AST/Decl.cpp

 unsigned ParmVarDecl::getParameterIndexLarge() const {
   return getASTContext().getParameterIndex(this);
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionDecl Implementation
 //===----------------------------------------------------------------------===//
 
+FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
+              SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
+              QualType T, TypeSourceInfo *TInfo, StorageClass S,
+              bool isInlineSpecified, bool isConstexprSpecified)
+      : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(),
+                      T, TInfo, StartLoc),
+        DeclContext(DK), redeclarable_base(C), ODRHash(0),
+        EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
+  setStorageClass(S);
+  setInlineSpecified(isInlineSpecified);
+  setExplicitSpecified(false);
+  setVirtualAsWritten(false);
+  setPureImpl(false);
+  setHasInheritedPrototype(false);
+  setHasWrittenPrototype(true);
+  setDeletedAsWritten(false);
+  setTrivial(false);
+  setTrivialForCall(false);
+  setDefaulted(false);
+  setExplicitlyDefaulted(false);
+  setHasImplicitReturnZero(false);
+  setLateTemplateParsed(false);
+  setConstexpr(isConstexprSpecified);
+  setInstantiationIsPending(false);
+  setUsesSEHTry(false);
+  setHasSkippedBody(false);
+  setWillHaveBody(false);
+  setMultiVersionImpl(false);
+  setHasODRHash(false);
+}
+
 void FunctionDecl::getNameForDiagnostic(
     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
   const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
   if (TemplateArgs)
     printTemplateArgumentList(OS, TemplateArgs->asArray(), Policy);
 }
 

 
 void FunctionDecl::setBody(Stmt *B) {
   Body = B;
   if (B)
     EndRangeLoc = B->getLocEnd();
 }
 
 void FunctionDecl::setPure(bool P) {
-  IsPure = P;
+  setPureImpl(P);
   if (P)
     if (auto *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
       Parent->markedVirtualFunctionPure();
 }
 
 template<std::size_t Len>
 static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
   IdentifierInfo *II = ND->getIdentifier();
FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
 
   if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
     FunctionTemplateDecl *PrevFunTmpl
       = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
     assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
     FunTmpl->setPreviousDecl(PrevFunTmpl);
   }
   
-  if (PrevDecl && PrevDecl->IsInline)
-    IsInline = true;
+  if (PrevDecl && PrevDecl->isInlined())
+    setImplicitlyInline(true);
 }
 
 FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
 
 /// Returns a value indicating whether this function
 /// corresponds to a builtin function.
 ///
 /// The function corresponds to a built-in function if it is
if (isExternC()) {
         return Builtin::BIbzero;
     }
     break;
   }
   return 0;
 }
 
 unsigned FunctionDecl::getODRHash() const {
-  assert(HasODRHash);
+  assert(hasODRHash());
   return ODRHash;
 }
 
 unsigned FunctionDecl::getODRHash() {
-  if (HasODRHash)
+  if (hasODRHash())
     return ODRHash;
 
   if (auto *FT = getInstantiatedFromMemberFunction()) {
-    HasODRHash = true;
+    setHasODRHash(true);
     ODRHash = FT->getODRHash();
     return ODRHash;
   }
 
   class ODRHash Hash;
   Hash.AddFunctionDecl(this);
-  HasODRHash = true;
+  setHasODRHash(true);
   ODRHash = Hash.CalculateHash();
   return ODRHash;
 }
 
 //===----------------------------------------------------------------------===//
 // FieldDecl Implementation
 //===----------------------------------------------------------------------===//
 
FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
                                    QualType T, TypeSourceInfo *TInfo,
                                    StorageClass SC,
                                    bool isInlineSpecified,
                                    bool hasWrittenPrototype,
                                    bool isConstexprSpecified) {
   FunctionDecl *New =
       new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
                                SC, isInlineSpecified, isConstexprSpecified);
-  New->HasWrittenPrototype = hasWrittenPrototype;
+  New->setHasWrittenPrototype(hasWrittenPrototype);
   return New;
 }
 
 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
                                   DeclarationNameInfo(), QualType(), nullptr,
                                   SC_None, false, false);
 }

lib/AST/DeclCXX.cpp

if (isInClassMemberInitializer()) {
     if (Expr *I = D->getInClassInitializer())
       return I->getSourceRange();
     return {};
   }
 
   return SourceRange(getSourceLocation(), getRParenLoc());
 }
 
+CXXConstructorDecl::CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD,
+              SourceLocation StartLoc,const DeclarationNameInfo &NameInfo,
+              QualType T, TypeSourceInfo *TInfo,
+              bool isExplicitSpecified, bool isInline,
+              bool isImplicitlyDeclared, bool isConstexpr,
+              InheritedConstructor Inherited)
+    : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
+                    SC_None, isInline, isConstexpr, SourceLocation()) {
+  setNumCtorInitializers(0);
+  setInheritingConstructor(static_cast<bool>(Inherited));
+  setImplicit(isImplicitlyDeclared);
+  if (Inherited)
+    *getTrailingObjects<InheritedConstructor>() = Inherited;
+  setExplicitSpecified(isExplicitSpecified);
+}
+
 void CXXConstructorDecl::anchor() {}
 
 CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID,
                                                            bool Inherited) {
   unsigned Extra = additionalSizeToAlloc<InheritedConstructor>(Inherited);
   auto *Result = new (C, ID, Extra) CXXConstructorDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
       false, false, false, false, InheritedConstructor());
-  Result->IsInheritingConstructor = Inherited;
+  Result->setInheritingConstructor(Inherited);
   return Result;
 }
 
 CXXConstructorDecl *
 CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
                            SourceLocation StartLoc,
                            const DeclarationNameInfo &NameInfo,
                            QualType T, TypeSourceInfo *TInfo,

lib/Serialization/ASTReaderDecl.cpp

 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
   return Loc.F->DeclsCursor.GetCurrentBitNo() + Loc.F->GlobalBitOffset;
 }
 
 void ASTDeclReader::ReadFunctionDefinition(FunctionDecl *FD) {
   if (Record.readInt())
     Reader.DefinitionSource[FD] = Loc.F->Kind == ModuleKind::MK_MainFile;
   if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
-    CD->NumCtorInitializers = Record.readInt();
-    if (CD->NumCtorInitializers)
+    CD->setNumCtorInitializers(Record.readInt());
+    if (CD->getNumCtorInitializers())
       CD->CtorInitializers = ReadGlobalOffset();
   }
   // Store the offset of the body so we can lazily load it later.
   Reader.PendingBodies[FD] = GetCurrentCursorOffset();
   HasPendingBody = true;
 }
 
 void ASTDeclReader::Visit(Decl *D) {
void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   }
 
   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName());
   FD->IdentifierNamespace = Record.readInt();
 
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
-  FD->SClass = (StorageClass)Record.readInt();
-  FD->IsInline = Record.readInt();
-  FD->IsInlineSpecified = Record.readInt();
-  FD->IsExplicitSpecified = Record.readInt();
-  FD->IsVirtualAsWritten = Record.readInt();
-  FD->IsPure = Record.readInt();
-  FD->HasInheritedPrototype = Record.readInt();
-  FD->HasWrittenPrototype = Record.readInt();
-  FD->IsDeleted = Record.readInt();
-  FD->IsTrivial = Record.readInt();
-  FD->IsTrivialForCall = Record.readInt();
-  FD->IsDefaulted = Record.readInt();
-  FD->IsExplicitlyDefaulted = Record.readInt();
-  FD->HasImplicitReturnZero = Record.readInt();
-  FD->IsConstexpr = Record.readInt();
-  FD->UsesSEHTry = Record.readInt();
-  FD->HasSkippedBody = Record.readInt();
-  FD->IsMultiVersion = Record.readInt();
-  FD->IsLateTemplateParsed = Record.readInt();
-  FD->setCachedLinkage(Linkage(Record.readInt()));
+  FD->setStorageClass(static_cast<StorageClass>(Record.readInt()));
+  FD->setInlineSpecified(Record.readInt());
+  FD->setImplicitlyInline(Record.readInt());
+  FD->setExplicitSpecified(Record.readInt());
+  FD->setVirtualAsWritten(Record.readInt());
+  FD->setPureImpl(Record.readInt());
+  FD->setHasInheritedPrototype(Record.readInt());
+  FD->setHasWrittenPrototype(Record.readInt());
+  FD->setDeletedAsWritten(Record.readInt());
+  FD->setTrivial(Record.readInt());
+  FD->setTrivialForCall(Record.readInt());
+  FD->setDefaulted(Record.readInt());
+  FD->setExplicitlyDefaulted(Record.readInt());
+  FD->setHasImplicitReturnZero(Record.readInt());
+  FD->setConstexpr(Record.readInt());
+  FD->setUsesSEHTry(Record.readInt());
+  FD->setHasSkippedBody(Record.readInt());
+  FD->setMultiVersionImpl(Record.readInt());
+  FD->setLateTemplateParsed(Record.readInt());
+
+  FD->setCachedLinkage(static_cast<Linkage>(Record.readInt()));
   FD->EndRangeLoc = ReadSourceLocation();
 
   FD->ODRHash = Record.readInt();
-  FD->HasODRHash = true;
+  FD->setHasODRHash(true);
 
   switch ((FunctionDecl::TemplatedKind)Record.readInt()) {
   case FunctionDecl::TK_NonTemplate:
     mergeRedeclarable(FD, Redecl);
     break;
   case FunctionDecl::TK_FunctionTemplate:
     // Merged when we merge the template.
     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>());
if (KeyFn && D->isCompleteDefinition())
       C.KeyFunctions[D] = KeyFn;
   }
 
   return Redecl;
 }
 
 void ASTDeclReader::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
   VisitFunctionDecl(D);
-  D->IsCopyDeductionCandidate = Record.readInt();
+  D->setIsCopyDeductionCandidate(Record.readInt());
 }
 
 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
   VisitFunctionDecl(D);
 
   unsigned NumOverridenMethods = Record.readInt();
   if (D->isCanonicalDecl()) {
     while (NumOverridenMethods--) {
void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
   auto *FD = static_cast<FunctionDecl *>(D);
   auto *PrevFD = cast<FunctionDecl>(Previous);
 
   FD->RedeclLink.setPrevious(PrevFD);
   FD->First = PrevFD->First;
 
   // If the previous declaration is an inline function declaration, then this
   // declaration is too.
-  if (PrevFD->IsInline != FD->IsInline) {
+  if (PrevFD->isInlined() != FD->isInlined()) {
     // FIXME: [dcl.fct.spec]p4:
     //   If a function with external linkage is declared inline in one
     //   translation unit, it shall be declared inline in all translation
     //   units in which it appears.
     //
     // Be careful of this case:
     //
     // module A:
     //   template<typename T> struct X { void f(); };
     //   template<typename T> inline void X<T>::f() {}
     //
     // module B instantiates the declaration of X<int>::f
     // module C instantiates the definition of X<int>::f
     //
     // If module B and C are merged, we do not have a violation of this rule.
-    FD->IsInline = true;
+    FD->setImplicitlyInline(true);
   }
 
   // If we need to propagate an exception specification along the redecl
   // chain, make a note of that so that we can do so later.
   auto *FPT = FD->getType()->getAs<FunctionProtoType>();
   auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
   if (FPT && PrevFPT) {
     bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());

lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   VisitRedeclarable(D);
   VisitDeclaratorDecl(D);
   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
   Record.push_back(D->getIdentifierNamespace());
   
   // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
   // after everything else is written.
   
-  Record.push_back((int)D->SClass); // FIXME: stable encoding
-  Record.push_back(D->IsInline);
-  Record.push_back(D->IsInlineSpecified);
-  Record.push_back(D->IsExplicitSpecified);
-  Record.push_back(D->IsVirtualAsWritten);
-  Record.push_back(D->IsPure);
-  Record.push_back(D->HasInheritedPrototype);
-  Record.push_back(D->HasWrittenPrototype);
-  Record.push_back(D->IsDeleted);
-  Record.push_back(D->IsTrivial);
-  Record.push_back(D->IsTrivialForCall);
-  Record.push_back(D->IsDefaulted);
-  Record.push_back(D->IsExplicitlyDefaulted);
-  Record.push_back(D->HasImplicitReturnZero);
-  Record.push_back(D->IsConstexpr);
-  Record.push_back(D->UsesSEHTry);
-  Record.push_back(D->HasSkippedBody);
-  Record.push_back(D->IsMultiVersion);
-  Record.push_back(D->IsLateTemplateParsed);
+  Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
+  Record.push_back(D->isInlineSpecified());
+  Record.push_back(D->isInlined());
+  Record.push_back(D->isExplicitSpecified());
+  Record.push_back(D->isVirtualAsWritten());
+  Record.push_back(D->isPure());
+  Record.push_back(D->hasInheritedPrototype());
+  Record.push_back(D->hasWrittenPrototype());
+  Record.push_back(D->isDeletedImpl());
+  Record.push_back(D->isTrivial());
+  Record.push_back(D->isTrivialForCall());
+  Record.push_back(D->isDefaulted());
+  Record.push_back(D->isExplicitlyDefaulted());
+  Record.push_back(D->hasImplicitReturnZero());
+  Record.push_back(D->isConstexpr());
+  Record.push_back(D->usesSEHTry());
+  Record.push_back(D->hasSkippedBody());
+  Record.push_back(D->isMultiVersionImpl());
+  Record.push_back(D->isLateTemplateParsed());
   Record.push_back(D->getLinkageInternal());
   Record.AddSourceLocation(D->getLocEnd());
 
   Record.push_back(D->getODRHash());
 
   Record.push_back(D->getTemplatedKind());
   switch (D->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(D->param_size());
   for (auto P : D->parameters())
     Record.AddDeclRef(P);
   Code = serialization::DECL_FUNCTION;
 }
 
 void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
   VisitFunctionDecl(D);
-  Record.push_back(D->IsCopyDeductionCandidate);
+  Record.push_back(D->isCopyDeductionCandidate());
   Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
 }
 
 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   VisitNamedDecl(D);
   // FIXME: convert to LazyStmtPtr?
   // Unlike C/C++, method bodies will never be in header files.
   bool HasBodyStuff = D->getBody() != nullptr     ||