[clang] Add simple utils to ensure static assert on bit count of DeclContext

[danix800]

Summary

Manually counting bits for DeclContext is error-prone. These two are still out-dated:

1. NumObjCMethodDeclBits (25, not 24)
2. NumBlockDeclBits (6, not 5)

Although no harm at this moment but it's still misleading and might cause problem
for the future.

Two simple reflection-like utilities countBits & countFields are added for auto-
updating these bits at compile time and static assert on syncing with any changes.

Static assert on bit count is preserved since it's informative.

Bitfields cannot be listed at compile time easily, but assert on countFields can still
catch errors if fields are added/removed.

[danix800]

Remove ununsed code.

[danix800]

Apply git-clang-format

clang/include/clang/AST/DeclBase.h

 
 #include "clang/AST/ASTDumperUtils.h"
 #include "clang/AST/AttrIterator.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Specifiers.h"
+#include "clang/Support/BitFieldReflection.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/PrettyStackTrace.h"
class DeclContext {
   /// hasNeedToReconcileExternalVisibleStorage
   friend class ExternalASTSource;
   /// For CreateStoredDeclsMap
   friend class DependentDiagnostic;
   /// For hasNeedToReconcileExternalVisibleStorage,
   /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
   friend class ASTWriter;
 
+#define BITSOF_FIELD(CLASS, FIELD)                                             \
+  BitFieldReflector::countBits(                                                \
+      BitFieldReflector::instanceOf<CLASS##Bitfields,                          \
+                                    decltype(CLASS##Bitfields{}.FIELD)>()      \
+          .FIELD)
+#define STATIC_ASSERT_BITFIELDS(CLASS, BITS, FIELDS)                           \
+  static_assert(                                                               \
+      Num##CLASS##Bits == BITS &&                                              \
+          BitFieldReflector::FieldCounter<CLASS##Bitfields>::value == FIELDS,  \
+      "You need to update Num" #CLASS                                          \
+      "Bits or number of fields after changing " #CLASS "Bitfields!")
+
   // We use uint64_t in the bit-fields below since some bit-fields
   // cross the unsigned boundary and this breaks the packing.
 
   /// Stores the bits used by DeclContext.
   /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
   /// methods in DeclContext should be updated appropriately.
   class DeclContextBitfields {
+  public:
     friend class DeclContext;
     /// DeclKind - This indicates which class this is.
     uint64_t DeclKind : 7;
 
     /// Whether this declaration context also has some external
     /// storage that contains additional declarations that are lexically
     /// part of this context.
     mutable uint64_t ExternalLexicalStorage : 1;
public:
     mutable uint64_t HasLazyExternalLexicalLookups : 1;
 
     /// If \c true, lookups should only return identifier from
     /// DeclContext scope (for example TranslationUnit). Used in
     /// LookupQualifiedName()
     mutable uint64_t UseQualifiedLookup : 1;
   };
 
+#define BITSOF(FIELD) BITSOF_FIELD(DeclContext, FIELD)
   /// Number of bits in DeclContextBitfields.
-  enum { NumDeclContextBits = 13 };
+  enum {
+    NumDeclContextBits = BITSOF(DeclKind) + BITSOF(ExternalLexicalStorage) +
+                         BITSOF(ExternalVisibleStorage) +
+                         BITSOF(NeedToReconcileExternalVisibleStorage) +
+                         BITSOF(HasLazyLocalLexicalLookups) +
+                         BITSOF(HasLazyExternalLexicalLookups) +
+                         BITSOF(UseQualifiedLookup)
+  };
+  STATIC_ASSERT_BITFIELDS(DeclContext, 13, 7);
 
   /// Stores the bits used by TagDecl.
   /// If modified NumTagDeclBits and the accessor
   /// methods in TagDecl should be updated appropriately.
   class TagDeclBitfields {
+  public:
     friend class TagDecl;
     /// For the bits in DeclContextBitfields
     uint64_t : NumDeclContextBits;
 
     /// The TagKind enum.
     uint64_t TagDeclKind : 3;
 
     /// True if this is a definition ("struct foo {};"), false if it is a
public:
     /// the TU.
     uint64_t IsCompleteDefinitionRequired : 1;
 
     /// Whether this tag is a definition which was demoted due to
     /// a module merge.
     uint64_t IsThisDeclarationADemotedDefinition : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(TagDecl, FIELD)
   /// Number of non-inherited bits in TagDeclBitfields.
-  enum { NumTagDeclBits = 10 };
+  enum {
+    NumTagDeclBits = BITSOF(TagDeclKind) + BITSOF(IsCompleteDefinition) +
+                     BITSOF(IsBeingDefined) + BITSOF(IsEmbeddedInDeclarator) +
+                     BITSOF(IsFreeStanding) + BITSOF(MayHaveOutOfDateDef) +
+                     BITSOF(IsCompleteDefinitionRequired) +
+                     BITSOF(IsThisDeclarationADemotedDefinition)
+  };
+  STATIC_ASSERT_BITFIELDS(TagDecl, 10, 8);
 
   /// Stores the bits used by EnumDecl.
   /// If modified NumEnumDeclBit and the accessor
   /// methods in EnumDecl should be updated appropriately.
   class EnumDeclBitfields {
+  public:
     friend class EnumDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in TagDeclBitfields.
     uint64_t : NumTagDeclBits;
 
     /// Width in bits required to store all the non-negative
     /// enumerators of this enum.
public:
     /// True if this is an enumeration with fixed underlying type. Only
     /// possible in C++11, Microsoft extensions, or Objective C mode.
     uint64_t IsFixed : 1;
 
     /// True if a valid hash is stored in ODRHash.
     uint64_t HasODRHash : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(EnumDecl, FIELD)
   /// Number of non-inherited bits in EnumDeclBitfields.
-  enum { NumEnumDeclBits = 20 };
+  enum {
+    NumEnumDeclBits = BITSOF(NumPositiveBits) + BITSOF(NumNegativeBits) +
+                      BITSOF(IsScoped) + BITSOF(IsScopedUsingClassTag) +
+                      BITSOF(IsFixed) + BITSOF(HasODRHash)
+  };
+  STATIC_ASSERT_BITFIELDS(EnumDecl, 20, 6);
 
   /// Stores the bits used by RecordDecl.
   /// If modified NumRecordDeclBits and the accessor
   /// methods in RecordDecl should be updated appropriately.
   class RecordDeclBitfields {
+  public:
     friend class RecordDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in TagDeclBitfields.
     uint64_t : NumTagDeclBits;
 
     /// This is true if this struct ends with a flexible
     /// array member (e.g. int X[]) or if this union contains a struct that does.
public:
     /// Indicates whether this struct has had its field layout randomized.
     uint64_t IsRandomized : 1;
 
     /// True if a valid hash is stored in ODRHash. This should shave off some
     /// extra storage and prevent CXXRecordDecl to store unused bits.
     uint64_t ODRHash : 26;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(RecordDecl, FIELD)
   /// Number of non-inherited bits in RecordDeclBitfields.
-  enum { NumRecordDeclBits = 41 };
+  enum {
+    NumRecordDeclBits =
+        BITSOF(HasFlexibleArrayMember) + BITSOF(AnonymousStructOrUnion) +
+        BITSOF(HasObjectMember) + BITSOF(HasVolatileMember) +
+        BITSOF(LoadedFieldsFromExternalStorage) +
+        BITSOF(NonTrivialToPrimitiveDefaultInitialize) +
+        BITSOF(NonTrivialToPrimitiveCopy) +
+        BITSOF(NonTrivialToPrimitiveDestroy) +
+        BITSOF(HasNonTrivialToPrimitiveDefaultInitializeCUnion) +
+        BITSOF(HasNonTrivialToPrimitiveDestructCUnion) +
+        BITSOF(HasNonTrivialToPrimitiveCopyCUnion) +
+        BITSOF(ParamDestroyedInCallee) + BITSOF(ArgPassingRestrictions) +
+        BITSOF(IsRandomized) + BITSOF(ODRHash)
+  };
+  STATIC_ASSERT_BITFIELDS(RecordDecl, 41, 15);
 
   /// Stores the bits used by OMPDeclareReductionDecl.
   /// If modified NumOMPDeclareReductionDeclBits and the accessor
   /// methods in OMPDeclareReductionDecl should be updated appropriately.
   class OMPDeclareReductionDeclBitfields {
+  public:
     friend class OMPDeclareReductionDecl;
     /// For the bits in DeclContextBitfields
     uint64_t : NumDeclContextBits;
 
     /// Kind of initializer,
     /// function call or omp_priv<init_expr> initialization.
     uint64_t InitializerKind : 2;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(OMPDeclareReductionDecl, FIELD)
   /// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
-  enum { NumOMPDeclareReductionDeclBits = 2 };
+  enum { NumOMPDeclareReductionDeclBits = BITSOF(InitializerKind) };
+  STATIC_ASSERT_BITFIELDS(OMPDeclareReductionDecl, 2, 1);
 
   /// Stores the bits used by FunctionDecl.
   /// If modified NumFunctionDeclBits and the accessor
   /// methods in FunctionDecl and CXXDeductionGuideDecl
   /// (for DeductionCandidateKind) should be updated appropriately.
   class FunctionDeclBitfields {
+  public:
     friend class FunctionDecl;
     /// For DeductionCandidateKind
     friend class CXXDeductionGuideDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
 
     uint64_t SClass : 3;
     uint64_t IsInline : 1;
public:
     /// Indicates if the function uses Floating Point Constrained Intrinsics
     uint64_t UsesFPIntrin : 1;
 
     // Indicates this function is a constrained friend, where the constraint
     // refers to an enclosing template for hte purposes of [temp.friend]p9.
     uint64_t FriendConstraintRefersToEnclosingTemplate : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(FunctionDecl, FIELD)
   /// Number of non-inherited bits in FunctionDeclBitfields.
-  enum { NumFunctionDeclBits = 31 };
+  enum {
+    NumFunctionDeclBits =
+        BITSOF(SClass) + BITSOF(IsInline) + BITSOF(IsInlineSpecified) +
+        BITSOF(IsVirtualAsWritten) + BITSOF(IsPure) +
+        BITSOF(HasInheritedPrototype) + BITSOF(HasWrittenPrototype) +
+        BITSOF(IsDeleted) + BITSOF(IsTrivial) + BITSOF(IsTrivialForCall) +
+        BITSOF(IsDefaulted) + BITSOF(IsExplicitlyDefaulted) +
+        BITSOF(HasDefaultedFunctionInfo) + BITSOF(IsIneligibleOrNotSelected) +
+        BITSOF(HasImplicitReturnZero) + BITSOF(IsLateTemplateParsed) +
+        BITSOF(ConstexprKind) +
+        BITSOF(BodyContainsImmediateEscalatingExpression) +
+        BITSOF(InstantiationIsPending) + BITSOF(UsesSEHTry) +
+        BITSOF(HasSkippedBody) + BITSOF(WillHaveBody) + BITSOF(IsMultiVersion) +
+        BITSOF(DeductionCandidateKind) + BITSOF(HasODRHash) +
+        BITSOF(UsesFPIntrin) + BITSOF(FriendConstraintRefersToEnclosingTemplate)
+  };
+  STATIC_ASSERT_BITFIELDS(FunctionDecl, 31, 27);
 
   /// Stores the bits used by CXXConstructorDecl. If modified
   /// NumCXXConstructorDeclBits and the accessor
   /// methods in CXXConstructorDecl should be updated appropriately.
   class CXXConstructorDeclBitfields {
+  public:
     friend class CXXConstructorDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in FunctionDeclBitfields.
     uint64_t : NumFunctionDeclBits;
 
     /// 20 bits to fit in the remaining available space.
     /// Note that this makes CXXConstructorDeclBitfields take
     /// exactly 64 bits and thus the width of NumCtorInitializers
     /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
     /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
     uint64_t NumCtorInitializers : 17;
     uint64_t IsInheritingConstructor : 1;
 
     /// Whether this constructor has a trail-allocated explicit specifier.
     uint64_t HasTrailingExplicitSpecifier : 1;
     /// If this constructor does't have a trail-allocated explicit specifier.
     /// Whether this constructor is explicit specified.
     uint64_t IsSimpleExplicit : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(CXXConstructorDecl, FIELD)
   /// Number of non-inherited bits in CXXConstructorDeclBitfields.
   enum {
-    NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
-  };
+    NumCXXConstructorDeclBits =
+        BITSOF(NumCtorInitializers) + BITSOF(IsInheritingConstructor) +
+        BITSOF(HasTrailingExplicitSpecifier) + BITSOF(IsSimpleExplicit)
+  };
+  STATIC_ASSERT_BITFIELDS(CXXConstructorDecl, 20, 4);
+
+  static_assert(NumDeclContextBits + NumFunctionDeclBits +
+                        NumCXXConstructorDeclBits ==
+                    64,
+                "You need to update NumCtorInitializers so that "
+                "CXXConstructorDeclBitfields take exactly 64 bits!");
 
   /// Stores the bits used by ObjCMethodDecl.
   /// If modified NumObjCMethodDeclBits and the accessor
   /// methods in ObjCMethodDecl should be updated appropriately.
   class ObjCMethodDeclBitfields {
+  public:
     friend class ObjCMethodDecl;
 
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
 
     /// The conventional meaning of this method; an ObjCMethodFamily.
     /// This is not serialized; instead, it is computed on demand and
     /// cached.
public:
     /// A method in an implementation is not considered as overriding the same
     /// method in the interface or its categories.
     uint64_t IsOverriding : 1;
 
     /// Indicates if the method was a definition but its body was skipped.
     uint64_t HasSkippedBody : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(ObjCMethodDecl, FIELD)
   /// Number of non-inherited bits in ObjCMethodDeclBitfields.
-  enum { NumObjCMethodDeclBits = 24 };
+  enum {
+    NumObjCMethodDeclBits =
+        BITSOF(Family) + BITSOF(IsInstance) + BITSOF(IsVariadic) +
+        BITSOF(IsPropertyAccessor) + BITSOF(IsSynthesizedAccessorStub) +
+        BITSOF(IsDefined) + BITSOF(IsRedeclaration) + BITSOF(HasRedeclaration) +
+        BITSOF(DeclImplementation) + BITSOF(objcDeclQualifier) +
+        BITSOF(RelatedResultType) + BITSOF(SelLocsKind) + BITSOF(IsOverriding) +
+        BITSOF(HasSkippedBody)
+  };
+  STATIC_ASSERT_BITFIELDS(ObjCMethodDecl, 25, 14);
 
   /// Stores the bits used by ObjCContainerDecl.
   /// If modified NumObjCContainerDeclBits and the accessor
   /// methods in ObjCContainerDecl should be updated appropriately.
   class ObjCContainerDeclBitfields {
     friend class ObjCContainerDecl;
     /// For the bits in DeclContextBitfields
     uint32_t : NumDeclContextBits;
 
     // Not a bitfield but this saves space.
     // Note that ObjCContainerDeclBitfields is full.
     SourceLocation AtStart;
   };
 
   /// Number of non-inherited bits in ObjCContainerDeclBitfields.
   /// Note that here we rely on the fact that SourceLocation is 32 bits
   /// wide. We check this with the static_assert in the ctor of DeclContext.
   enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
 
   /// Stores the bits used by LinkageSpecDecl.
   /// If modified NumLinkageSpecDeclBits and the accessor
   /// methods in LinkageSpecDecl should be updated appropriately.
   class LinkageSpecDeclBitfields {
+  public:
     friend class LinkageSpecDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
 
     /// The language for this linkage specification with values
     /// in the enum LinkageSpecDecl::LanguageIDs.
     uint64_t Language : 3;
 
     /// True if this linkage spec has braces.
     /// This is needed so that hasBraces() returns the correct result while the
     /// linkage spec body is being parsed.  Once RBraceLoc has been set this is
     /// not used, so it doesn't need to be serialized.
     uint64_t HasBraces : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(LinkageSpecDecl, FIELD)
   /// Number of non-inherited bits in LinkageSpecDeclBitfields.
-  enum { NumLinkageSpecDeclBits = 4 };
+  enum { NumLinkageSpecDeclBits = BITSOF(Language) + BITSOF(HasBraces) };
+  STATIC_ASSERT_BITFIELDS(LinkageSpecDecl, 4, 2);
 
   /// Stores the bits used by BlockDecl.
   /// If modified NumBlockDeclBits and the accessor
   /// methods in BlockDecl should be updated appropriately.
   class BlockDeclBitfields {
+  public:
     friend class BlockDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
 
     uint64_t IsVariadic : 1;
     uint64_t CapturesCXXThis : 1;
     uint64_t BlockMissingReturnType : 1;
     uint64_t IsConversionFromLambda : 1;
 
     /// A bit that indicates this block is passed directly to a function as a
     /// non-escaping parameter.
     uint64_t DoesNotEscape : 1;
 
     /// A bit that indicates whether it's possible to avoid coying this block to
     /// the heap when it initializes or is assigned to a local variable with
     /// automatic storage.
     uint64_t CanAvoidCopyToHeap : 1;
   };
 
+#undef BITSOF
+#define BITSOF(FIELD) BITSOF_FIELD(BlockDecl, FIELD)
   /// Number of non-inherited bits in BlockDeclBitfields.
-  enum { NumBlockDeclBits = 5 };
+  enum {
+    NumBlockDeclBits = BITSOF(IsVariadic) + BITSOF(CapturesCXXThis) +
+                       BITSOF(BlockMissingReturnType) +
+                       BITSOF(IsConversionFromLambda) + BITSOF(DoesNotEscape) +
+                       BITSOF(CanAvoidCopyToHeap)
+  };
+  STATIC_ASSERT_BITFIELDS(BlockDecl, 6, 6);
+
+#undef BITSOF
+#undef BITSOF_FIELD
+#undef STATIC_ASSERT_BITFIELDS
 
   /// Pointer to the data structure used to lookup declarations
   /// within this context (or a DependentStoredDeclsMap if this is a
   /// dependent context). We maintain the invariant that, if the map
   /// contains an entry for a DeclarationName (and we haven't lazily
   /// omitted anything), then it contains all relevant entries for that
   /// name (modulo the hasExternalDecls() flag).
   mutable StoredDeclsMap *LookupPtr = nullptr;

clang/include/clang/Support/BitFieldReflection.h

+//===------- BitFieldReflection.h - BitField Reflection Utils ---*- 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 defines simple reflection utility for bit-fields.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CLANG_SUPPORT_BIT_FIELD_REFLECTION_H
+#define CLANG_SUPPORT_BIT_FIELD_REFLECTION_H
+
+#include <cstddef>
+#include <limits>
+#include <tuple>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wbitfield-constant-conversion"
+#pragma clang diagnostic ignored "-Wmissing-field-initializers"
+#elif defined __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#pragma GCC diagnostic ignored "-Woverflow"
+#endif
+
+namespace clang {
+
+class BitFieldReflector {
+public:
+  template <typename FieldT>
+  static constexpr auto countBits(FieldT F, size_t StartBit = 0) ->
+      typename std::enable_if<std::is_unsigned<FieldT>::value, size_t>::type {
+    return (StartBit == sizeof(FieldT) * 8)
+               ? 0
+               : (countBits(F, StartBit + 1) +
+                  ((F & (1ULL << StartBit)) ? 1 : 0));
+  }
+
+  template <typename StructT, typename FieldT>
+  static constexpr StructT instanceOf() {
+    static_assert(std::is_unsigned<FieldT>::value,
+                  "Bit field is not unsigned!");
+    return instanceOfImpl<StructT, FieldT>(StructT{}, 0);
+  }
+
+private:
+  template <typename StructT, typename FieldT, FieldT...>
+  static constexpr StructT instanceOfImpl(StructT S, ...) {
+    return S;
+  }
+
+  template <typename StructT, typename FieldT, FieldT... Inits>
+  static constexpr StructT instanceOfImpl(StructT S, decltype(StructT{Inits...},
+                                                              int()) = 0) {
+    return instanceOfImpl<StructT, FieldT, Inits..., static_cast<FieldT>(-1)>(
+        StructT{Inits...}, 0);
+  }
+
+private:
+  struct is_implicitly_convertible {
+    template <typename T> constexpr operator T() const;
+  };
+
+  template <typename, typename, typename...>
+  struct is_initializable_ : std::false_type {};
+
+  template <typename T, typename... From>
+  struct is_initializable_<std::void_t<decltype(T{{std::declval<From>()}...})>,
+                           T, From...> : std::true_type {};
+
+  template <typename T, typename... From>
+  using is_initializable = is_initializable_<std::void_t<>, T, From...>;
+
+  template <typename, typename... Args>
+  static constexpr size_t countFields(std::false_type) {
+    return sizeof...(Args) ? sizeof...(Args) - 1 : 0;
+  }
+
+  template <typename T, typename... Args>
+  static constexpr size_t countFields(std::true_type) {
+    return countFields<T, Args..., is_implicitly_convertible>(
+        is_initializable<T, Args..., is_implicitly_convertible>());
+  }
+
+public:
+  template <typename T>
+  struct FieldCounter
+      : public std::integral_constant<size_t,
+                                      countFields<T>(is_initializable<T>())> {};
+};
+
+} // namespace clang
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#elif defined __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#endif // CLANG_SUPPORT_BIT_FIELD_REFLECTION_H

clang/lib/Serialization/ASTWriterDecl.cpp

 
 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
   VisitTypedefNameDecl(D);
   Record.AddDeclRef(D->getDescribedAliasTemplate());
   Code = serialization::DECL_TYPEALIAS;
 }
 
 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
-  static_assert(DeclContext::NumTagDeclBits == 10,
-                "You need to update the serializer after you change the "
-                "TagDeclBits");
-
   VisitRedeclarable(D);
   VisitTypeDecl(D);
   Record.push_back(D->getIdentifierNamespace());
   Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
   if (!isa<CXXRecordDecl>(D))
     Record.push_back(D->isCompleteDefinition());
   Record.push_back(D->isEmbeddedInDeclarator());
   Record.push_back(D->isFreeStanding());
   Record.push_back(D->isCompleteDefinitionRequired());
   Record.AddSourceRange(D->getBraceRange());
 
   if (D->hasExtInfo()) {
     Record.push_back(1);
     Record.AddQualifierInfo(*D->getExtInfo());
   } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
     Record.push_back(2);
     Record.AddDeclRef(TD);
     Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
   } else {
     Record.push_back(0);
   }
 }
 
 void ASTDeclWriter::VisitEnumDecl(EnumDecl *D) {
-  static_assert(DeclContext::NumEnumDeclBits == 20,
-                "You need to update the serializer after you change the "
-                "EnumDeclBits");
-
   VisitTagDecl(D);
   Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
   if (!D->getIntegerTypeSourceInfo())
     Record.AddTypeRef(D->getIntegerType());
   Record.AddTypeRef(D->getPromotionType());
   Record.push_back(D->getNumPositiveBits());
   Record.push_back(D->getNumNegativeBits());
   Record.push_back(D->isScoped());
if (D->getDeclContext() == D->getLexicalDeclContext() &&
       !needsAnonymousDeclarationNumber(D) &&
       D->getDeclName().getNameKind() == DeclarationName::Identifier)
     AbbrevToUse = Writer.getDeclEnumAbbrev();
 
   Code = serialization::DECL_ENUM;
 }
 
 void ASTDeclWriter::VisitRecordDecl(RecordDecl *D) {
-  static_assert(DeclContext::NumRecordDeclBits == 41,
-                "You need to update the serializer after you change the "
-                "RecordDeclBits");
-
   VisitTagDecl(D);
   Record.push_back(D->hasFlexibleArrayMember());
   Record.push_back(D->isAnonymousStructOrUnion());
   Record.push_back(D->hasObjectMember());
   Record.push_back(D->hasVolatileMember());
   Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize());
   Record.push_back(D->isNonTrivialToPrimitiveCopy());
   Record.push_back(D->isNonTrivialToPrimitiveDestroy());
if (D->hasExtInfo()) {
     Record.AddStmt(Info->TrailingRequiresClause);
   }
   // The location information is deferred until the end of the record.
   Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
                                            : QualType());
 }
 
 void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
-  static_assert(DeclContext::NumFunctionDeclBits == 31,
-                "You need to update the serializer after you change the "
-                "FunctionDeclBits");
-
   VisitRedeclarable(D);
 
   Record.push_back(D->getTemplatedKind());
   switch (D->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
     break;
   case FunctionDecl::TK_DependentNonTemplate:
     Record.AddDeclRef(D->getInstantiatedFromDecl());
void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
   addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   Record.AddDeclRef(D->Ctor);
   VisitFunctionDecl(D);
   Record.push_back(static_cast<unsigned char>(D->getDeductionCandidateKind()));
   Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
 }
 
 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
-  static_assert(DeclContext::NumObjCMethodDeclBits == 24,
-                "You need to update the serializer after you change the "
-                "ObjCMethodDeclBits");
-
   VisitNamedDecl(D);
   // FIXME: convert to LazyStmtPtr?
   // Unlike C/C++, method bodies will never be in header files.
   bool HasBodyStuff = D->getBody() != nullptr;
   Record.push_back(HasBodyStuff);
   if (HasBodyStuff) {
     Record.AddStmt(D->getBody());
   }
void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
   Record.push_back(D->Index);
   Record.AddSourceLocation(D->VarianceLoc);
   Record.AddSourceLocation(D->ColonLoc);
 
   Code = serialization::DECL_OBJC_TYPE_PARAM;
 }
 
 void ASTDeclWriter::VisitObjCContainerDecl(ObjCContainerDecl *D) {
-  static_assert(DeclContext::NumObjCContainerDeclBits == 51,
-                "You need to update the serializer after you change the "
-                "ObjCContainerDeclBits");
-
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getAtStartLoc());
   Record.AddSourceRange(D->getAtEndRange());
   // Abstract class (no need to define a stable serialization::DECL code).
 }
 
 void ASTDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
   VisitRedeclarable(D);
void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
   Record.push_back(CD->isNothrow() ? 1 : 0);
   // Body is stored by VisitCapturedStmt.
   for (unsigned I = 0; I < CD->getNumParams(); ++I)
     Record.AddDeclRef(CD->getParam(I));
   Code = serialization::DECL_CAPTURED;
 }
 
 void ASTDeclWriter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
-  static_assert(DeclContext::NumLinkageSpecDeclBits == 4,
-                "You need to update the serializer after you change the"
-                "LinkageSpecDeclBits");
-
   VisitDecl(D);
   Record.push_back(D->getLanguage());
   Record.AddSourceLocation(D->getExternLoc());
   Record.AddSourceLocation(D->getRBraceLoc());
   Code = serialization::DECL_LINKAGE_SPEC;
 }
 
 void ASTDeclWriter::VisitExportDecl(ExportDecl *D) {
if (D->getDeclContext() == D->getLexicalDeclContext() &&
       D->hasWrittenPrototype() &&
       D->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
     AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
 
   Code = serialization::DECL_CXX_METHOD;
 }
 
 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
-  static_assert(DeclContext::NumCXXConstructorDeclBits == 20,
-                "You need to update the serializer after you change the "
-                "CXXConstructorDeclBits");
-
   Record.push_back(D->getTrailingAllocKind());
   addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   if (auto Inherited = D->getInheritedConstructor()) {
     Record.AddDeclRef(Inherited.getShadowDecl());
     Record.AddDeclRef(Inherited.getConstructor());
   }
 
   VisitCXXMethodDecl(D);
void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
   Record.push_back(D->isFailed());
   Record.AddStmt(D->getMessage());
   Record.AddSourceLocation(D->getRParenLoc());
   Code = serialization::DECL_STATIC_ASSERT;
 }
 
 /// Emit the DeclContext part of a declaration context decl.
 void ASTDeclWriter::VisitDeclContext(DeclContext *DC) {
-  static_assert(DeclContext::NumDeclContextBits == 13,
-                "You need to update the serializer after you change the "
-                "DeclContextBits");
-
   Record.AddOffset(Writer.WriteDeclContextLexicalBlock(Context, DC));
   Record.AddOffset(Writer.WriteDeclContextVisibleBlock(Context, DC));
 }
 
 const Decl *ASTWriter::getFirstLocalDecl(const Decl *D) {
   assert(IsLocalDecl(D) && "expected a local declaration");
 
   const Decl *Canon = D->getCanonicalDecl();

 
 void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
   Record.writeOMPChildren(D->Data);
   VisitDecl(D);
   Code = serialization::DECL_OMP_REQUIRES;
 }
 
 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
-  static_assert(DeclContext::NumOMPDeclareReductionDeclBits == 2,
-                "You need to update the serializer after you change the "
-                "NumOMPDeclareReductionDeclBits");
-
   VisitValueDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddStmt(D->getCombinerIn());
   Record.AddStmt(D->getCombinerOut());
   Record.AddStmt(D->getCombiner());
   Record.AddStmt(D->getInitOrig());
   Record.AddStmt(D->getInitPriv());
   Record.AddStmt(D->getInitializer());