[NFC] [Serialization] Add static assert for the size of the decls to mention developers to remember to touch the serializer after them modified the field of decls

[ChuanqiXu]

Summary

It is easy for the developers to forget to touch the serializer after them add new field to decls. Then if the existing tests fail to catch such cases, it may be a bug report from users some day. And it is time-consuming to solve such bugs.

To mitigate the problem, I add the static_asserts in the serializer. So that the developers can understand they need to modify the serializer after they saw the static assertion failure. Although this can't solve all the problems, I feel the current status can be much better.

[erichkeane]

This is great! This is definitely a mistake I've made a few times :) The solution itself is only so-so, but I don't have an idea for a better one, so I think this can do for now.

[erichkeane]

Ah, Windows build failures are obviously relevant :) One gotcha here is going to be to chase down all the sizes of the records on different platforms.

[ChuanqiXu]

Ah, Windows build failures are obviously relevant :) One gotcha here is going to be to chase down all the sizes of the records on different platforms.

The failure shouldn't be related the patch since the patch itself should only cause static assert failures. I saw you guys have already found the solutions in D141954. So I am going to land this.

[thakis]

clang/lib/Serialization/ASTWriterDecl.cpp

2313

How can this work? This includes an ArrayRef (http://llvm-cs.pcc.me.uk/tools/clang/include/clang/AST/DeclOpenMP.h#221) which contains a pointer and a size_t. That alone will be 16 bytes on 64-bit builds and 8 bytes on 32-bit builds.

[ChuanqiXu]

clang/lib/Serialization/ASTWriterDecl.cpp

2313

You're right that I forgot the case for 32-bit machine. I've reverted the patch. And I need to look for better solutions.

[thakis]

Also fails on 64-bit windows fwiw: http://45.33.8.238/win/73344/step_4.txt

[thakis]

Thanks for the fast revert!

[ChuanqiXu]

It passes on the previous windows CI. It looks like the assertion for sizeof(...) is indeed not a good idea.

[erichkeane]

In D141992#4063978, @ChuanqiXu wrote:

Ah, Windows build failures are obviously relevant :) One gotcha here is going to be to chase down all the sizes of the records on different platforms.

The failure shouldn't be related the patch since the patch itself should only cause static assert failures. I saw you guys have already found the solutions in D141954. So I am going to land this.

No, that patch was talking about the libcxx issue. The windows issues I saw in pre-commit CI on this patch were it hitting your assert all over the place.

[ChuanqiXu]

This is only part of the original revision, which contains platform independent assertion only.

clang/include/clang/AST/DeclBase.h

 ///   ObjCContainerDecl
 ///   LinkageSpecDecl
 ///   ExportDecl
 ///   BlockDecl
 ///   CapturedDecl
 class DeclContext {
   /// For makeDeclVisibleInContextImpl
   friend class ASTDeclReader;
+  /// For checking the new bits in the Serialization part.
+  friend class ASTDeclWriter;
   /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
   /// hasNeedToReconcileExternalVisibleStorage
   friend class ExternalASTSource;
   /// For CreateStoredDeclsMap
   friend class DependentDiagnostic;
   /// For hasNeedToReconcileExternalVisibleStorage,
   /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
   friend class ASTWriter;

clang/lib/Serialization/ASTWriter.cpp

 
 // FIXME: Move this out of the main ASTRecordWriter interface.
 void ASTRecordWriter::AddCXXCtorInitializers(
     ArrayRef<CXXCtorInitializer *> CtorInits) {
   AddOffset(EmitCXXCtorInitializers(*Writer, CtorInits));
 }
 
 void ASTRecordWriter::AddCXXDefinitionData(const CXXRecordDecl *D) {
+  static_assert(sizeof(decltype(D->data())) == 104 &&
+                    sizeof(CXXRecordDecl::LambdaDefinitionData) == 144,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   auto &Data = D->data();
   Record->push_back(Data.IsLambda);
 
   #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.

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::Visit(Decl *D) {
   // If this declaration is also a DeclContext, write blocks for the
   // declarations that lexically stored inside its context and those
   // declarations that are visible from its context.
   if (DeclContext *DC = dyn_cast<DeclContext>(D))
     VisitDeclContext(DC);
 }
 
 void ASTDeclWriter::VisitDecl(Decl *D) {
+  static_assert(sizeof(Decl) == 40, "You need to update the serializer after "
+                                    "you change the fields of Decls.");
+
   Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
   if (D->getDeclContext() != D->getLexicalDeclContext())
     Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
   else
     Record.push_back(0);
   Record.push_back(D->isInvalidDecl());
   Record.push_back(D->hasAttrs());
   if (D->hasAttrs())
while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) {
       if (!NS->isInlineNamespace())
         break;
       DC = NS->getParent();
     }
   }
 }
 
 void ASTDeclWriter::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
+  static_assert(sizeof(PragmaCommentDecl) == 40,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   StringRef Arg = D->getArg();
   Record.push_back(Arg.size());
   VisitDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.push_back(D->getCommentKind());
   Record.AddString(Arg);
   Code = serialization::DECL_PRAGMA_COMMENT;
 }
 
 void ASTDeclWriter::VisitPragmaDetectMismatchDecl(
     PragmaDetectMismatchDecl *D) {
+  static_assert(sizeof(PragmaDetectMismatchDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   StringRef Name = D->getName();
   StringRef Value = D->getValue();
   Record.push_back(Name.size() + 1 + Value.size());
   VisitDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddString(Name);
   Record.AddString(Value);
   Code = serialization::DECL_PRAGMA_DETECT_MISMATCH;
 }
 
 void ASTDeclWriter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
   llvm_unreachable("Translation units aren't directly serialized");
 }
 
 void ASTDeclWriter::VisitNamedDecl(NamedDecl *D) {
+  static_assert(sizeof(NamedDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddDeclarationName(D->getDeclName());
   Record.push_back(needsAnonymousDeclarationNumber(D)
                        ? Writer.getAnonymousDeclarationNumber(D)
                        : 0);
 }
 
 void ASTDeclWriter::VisitTypeDecl(TypeDecl *D) {
+  static_assert(sizeof(TypeDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
 }
 
 void ASTDeclWriter::VisitTypedefNameDecl(TypedefNameDecl *D) {
+  static_assert(sizeof(TypedefNameDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitTypeDecl(D);
   Record.AddTypeSourceInfo(D->getTypeSourceInfo());
   Record.push_back(D->isModed());
   if (D->isModed())
     Record.AddTypeRef(D->getUnderlyingType());
   Record.AddDeclRef(D->getAnonDeclWithTypedefName(false));
 }
 
 void ASTDeclWriter::VisitTypedefDecl(TypedefDecl *D) {
+  static_assert(sizeof(TypedefDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitTypedefNameDecl(D);
   if (D->getDeclContext() == D->getLexicalDeclContext() &&
       !D->hasAttrs() &&
       !D->isImplicit() &&
       D->getFirstDecl() == D->getMostRecentDecl() &&
       !D->isInvalidDecl() &&
       !D->isTopLevelDeclInObjCContainer() &&
       !D->isModulePrivate() &&
       !needsAnonymousDeclarationNumber(D) &&
       D->getDeclName().getNameKind() == DeclarationName::Identifier)
     AbbrevToUse = Writer.getDeclTypedefAbbrev();
 
   Code = serialization::DECL_TYPEDEF;
 }
 
 void ASTDeclWriter::VisitTypeAliasDecl(TypeAliasDecl *D) {
+  static_assert(sizeof(TypeAliasDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitTypedefNameDecl(D);
   Record.AddDeclRef(D->getDescribedAliasTemplate());
   Code = serialization::DECL_TYPEALIAS;
 }
 
 void ASTDeclWriter::VisitTagDecl(TagDecl *D) {
+  static_assert(DeclContext::NumTagDeclBits == 10 && sizeof(TagDecl) == 128,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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 && sizeof(EnumDecl) == 160,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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 == 15 &&
+                    sizeof(RecordDecl) == 128,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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->getDeclContext() == D->getLexicalDeclContext() &&
       !needsAnonymousDeclarationNumber(D) &&
       D->getDeclName().getNameKind() == DeclarationName::Identifier)
     AbbrevToUse = Writer.getDeclRecordAbbrev();
 
   Code = serialization::DECL_RECORD;
 }
 
 void ASTDeclWriter::VisitValueDecl(ValueDecl *D) {
+  static_assert(sizeof(ValueDecl) == 56,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddTypeRef(D->getType());
 }
 
 void ASTDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) {
+  static_assert(sizeof(EnumConstantDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.push_back(D->getInitExpr()? 1 : 0);
   if (D->getInitExpr())
     Record.AddStmt(D->getInitExpr());
   Record.AddAPSInt(D->getInitVal());
 
   Code = serialization::DECL_ENUM_CONSTANT;
 }
 
 void ASTDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) {
+  static_assert(sizeof(DeclaratorDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.AddSourceLocation(D->getInnerLocStart());
   Record.push_back(D->hasExtInfo());
   if (D->hasExtInfo()) {
     DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
     Record.AddQualifierInfo(*Info);
     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 == 29 &&
+                    sizeof(FunctionDecl) == 168,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
 
   Record.push_back(D->getTemplatedKind());
   switch (D->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
     break;
   case FunctionDecl::TK_DependentNonTemplate:
     Record.AddDeclRef(D->getInstantiatedFromDecl());
static void addExplicitSpecifier(ExplicitSpecifier ES,
   Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
   Record.push_back(Kind);
   if (ES.getExpr()) {
     Record.AddStmt(ES.getExpr());
   }
 }
 
 void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
+  static_assert(sizeof(CXXDeductionGuideDecl) == 184,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   Record.AddDeclRef(D->Ctor);
   VisitFunctionDecl(D);
   Record.push_back(D->isCopyDeductionCandidate());
   Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
 }
 
 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
+  static_assert(DeclContext::NumObjCMethodDeclBits == 24 &&
+                    sizeof(ObjCMethodDecl) == 136,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   Record.push_back(NumStoredSelLocs);
   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
     Record.AddSourceLocation(SelLocs[i]);
 
   Code = serialization::DECL_OBJC_METHOD;
 }
 
 void ASTDeclWriter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
+  static_assert(sizeof(ObjCTypeParamDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitTypedefNameDecl(D);
   Record.push_back(D->Variance);
   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 &&
+                    sizeof(ObjCContainerDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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) {
+  static_assert(sizeof(ObjCInterfaceDecl) == 128,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitObjCContainerDecl(D);
   Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
   AddObjCTypeParamList(D->TypeParamList);
 
   Record.push_back(D->isThisDeclarationADefinition());
   if (D->isThisDeclarationADefinition()) {
     // Write the DefinitionData
if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
         (void)Writer.GetDeclRef(Cat);
     }
   }
 
   Code = serialization::DECL_OBJC_INTERFACE;
 }
 
 void ASTDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
+  static_assert(sizeof(ObjCIvarDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitFieldDecl(D);
   // FIXME: stable encoding for @public/@private/@protected/@package
   Record.push_back(D->getAccessControl());
   Record.push_back(D->getSynthesize());
 
   if (D->getDeclContext() == D->getLexicalDeclContext() &&
       !D->hasAttrs() &&
       !D->isImplicit() &&
       !D->isUsed(false) &&
       !D->isInvalidDecl() &&
       !D->isReferenced() &&
       !D->isModulePrivate() &&
       !D->getBitWidth() &&
       !D->hasExtInfo() &&
       D->getDeclName())
     AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
 
   Code = serialization::DECL_OBJC_IVAR;
 }
 
 void ASTDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
+  static_assert(sizeof(ObjCProtocolDecl) == 112,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitObjCContainerDecl(D);
 
   Record.push_back(D->isThisDeclarationADefinition());
   if (D->isThisDeclarationADefinition()) {
     Record.push_back(D->protocol_size());
     for (const auto *I : D->protocols())
       Record.AddDeclRef(I);
     for (const auto &PL : D->protocol_locs())
       Record.AddSourceLocation(PL);
     Record.push_back(D->getODRHash());
   }
 
   Code = serialization::DECL_OBJC_PROTOCOL;
 }
 
 void ASTDeclWriter::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
+  static_assert(sizeof(ObjCAtDefsFieldDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitFieldDecl(D);
   Code = serialization::DECL_OBJC_AT_DEFS_FIELD;
 }
 
 void ASTDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
+  static_assert(sizeof(ObjCCategoryDecl) == 152,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitObjCContainerDecl(D);
   Record.AddSourceLocation(D->getCategoryNameLoc());
   Record.AddSourceLocation(D->getIvarLBraceLoc());
   Record.AddSourceLocation(D->getIvarRBraceLoc());
   Record.AddDeclRef(D->getClassInterface());
   AddObjCTypeParamList(D->TypeParamList);
   Record.push_back(D->protocol_size());
   for (const auto *I : D->protocols())
     Record.AddDeclRef(I);
   for (const auto &PL : D->protocol_locs())
     Record.AddSourceLocation(PL);
   Code = serialization::DECL_OBJC_CATEGORY;
 }
 
 void ASTDeclWriter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
+  static_assert(sizeof(ObjCCompatibleAliasDecl) == 56,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddDeclRef(D->getClassInterface());
   Code = serialization::DECL_OBJC_COMPATIBLE_ALIAS;
 }
 
 void ASTDeclWriter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
+  static_assert(sizeof(ObjCPropertyDecl) == 128,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getAtLoc());
   Record.AddSourceLocation(D->getLParenLoc());
   Record.AddTypeRef(D->getType());
   Record.AddTypeSourceInfo(D->getTypeSourceInfo());
   // FIXME: stable encoding
   Record.push_back((unsigned)D->getPropertyAttributes());
   Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
   // FIXME: stable encoding
   Record.push_back((unsigned)D->getPropertyImplementation());
   Record.AddDeclarationName(D->getGetterName());
   Record.AddSourceLocation(D->getGetterNameLoc());
   Record.AddDeclarationName(D->getSetterName());
   Record.AddSourceLocation(D->getSetterNameLoc());
   Record.AddDeclRef(D->getGetterMethodDecl());
   Record.AddDeclRef(D->getSetterMethodDecl());
   Record.AddDeclRef(D->getPropertyIvarDecl());
   Code = serialization::DECL_OBJC_PROPERTY;
 }
 
 void ASTDeclWriter::VisitObjCImplDecl(ObjCImplDecl *D) {
+  static_assert(sizeof(ObjCImplDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitObjCContainerDecl(D);
   Record.AddDeclRef(D->getClassInterface());
   // Abstract class (no need to define a stable serialization::DECL code).
 }
 
 void ASTDeclWriter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
+  static_assert(sizeof(ObjCCategoryImplDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitObjCImplDecl(D);
   Record.AddSourceLocation(D->getCategoryNameLoc());
   Code = serialization::DECL_OBJC_CATEGORY_IMPL;
 }
 
 void ASTDeclWriter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
+  static_assert(sizeof(ObjCImplementationDecl) == 136,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitObjCImplDecl(D);
   Record.AddDeclRef(D->getSuperClass());
   Record.AddSourceLocation(D->getSuperClassLoc());
   Record.AddSourceLocation(D->getIvarLBraceLoc());
   Record.AddSourceLocation(D->getIvarRBraceLoc());
   Record.push_back(D->hasNonZeroConstructors());
   Record.push_back(D->hasDestructors());
   Record.push_back(D->NumIvarInitializers);
   if (D->NumIvarInitializers)
     Record.AddCXXCtorInitializers(
         llvm::ArrayRef(D->init_begin(), D->init_end()));
   Code = serialization::DECL_OBJC_IMPLEMENTATION;
 }
 
 void ASTDeclWriter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
+  static_assert(sizeof(ObjCPropertyImplDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddDeclRef(D->getPropertyDecl());
   Record.AddDeclRef(D->getPropertyIvarDecl());
   Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
   Record.AddDeclRef(D->getGetterMethodDecl());
   Record.AddDeclRef(D->getSetterMethodDecl());
   Record.AddStmt(D->getGetterCXXConstructor());
   Record.AddStmt(D->getSetterCXXAssignment());
   Code = serialization::DECL_OBJC_PROPERTY_IMPL;
 }
 
 void ASTDeclWriter::VisitFieldDecl(FieldDecl *D) {
+  static_assert(sizeof(FieldDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDeclaratorDecl(D);
   Record.push_back(D->isMutable());
 
   FieldDecl::InitStorageKind ISK = D->InitStorage.getInt();
   Record.push_back(ISK);
   if (ISK == FieldDecl::ISK_CapturedVLAType)
     Record.AddTypeRef(QualType(D->getCapturedVLAType(), 0));
   else if (ISK)
if (D->getDeclContext() == D->getLexicalDeclContext() &&
       !ObjCAtDefsFieldDecl::classofKind(D->getKind()) &&
       D->getDeclName())
     AbbrevToUse = Writer.getDeclFieldAbbrev();
 
   Code = serialization::DECL_FIELD;
 }
 
 void ASTDeclWriter::VisitMSPropertyDecl(MSPropertyDecl *D) {
+  static_assert(sizeof(MSPropertyDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDeclaratorDecl(D);
   Record.AddIdentifierRef(D->getGetterId());
   Record.AddIdentifierRef(D->getSetterId());
   Code = serialization::DECL_MS_PROPERTY;
 }
 
 void ASTDeclWriter::VisitMSGuidDecl(MSGuidDecl *D) {
+  static_assert(sizeof(MSGuidDecl) == 152,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   MSGuidDecl::Parts Parts = D->getParts();
   Record.push_back(Parts.Part1);
   Record.push_back(Parts.Part2);
   Record.push_back(Parts.Part3);
   Record.append(std::begin(Parts.Part4And5), std::end(Parts.Part4And5));
   Code = serialization::DECL_MS_GUID;
 }
 
 void ASTDeclWriter::VisitUnnamedGlobalConstantDecl(
     UnnamedGlobalConstantDecl *D) {
+  static_assert(sizeof(UnnamedGlobalConstantDecl) == 136,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.AddAPValue(D->getValue());
   Code = serialization::DECL_UNNAMED_GLOBAL_CONSTANT;
 }
 
 void ASTDeclWriter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
+  static_assert(sizeof(TemplateParamObjectDecl) == 136,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.AddAPValue(D->getValue());
   Code = serialization::DECL_TEMPLATE_PARAM_OBJECT;
 }
 
 void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
+  static_assert(sizeof(IndirectFieldDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.push_back(D->getChainingSize());
 
   for (const auto *P : D->chain())
     Record.AddDeclRef(P);
   Code = serialization::DECL_INDIRECTFIELD;
 }
 
 void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
+  static_assert(sizeof(VarDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitDeclaratorDecl(D);
   Record.push_back(D->getStorageClass());
   Record.push_back(D->getTSCSpec());
   Record.push_back(D->getInitStyle());
   Record.push_back(D->isARCPseudoStrong());
   if (!isa<ParmVarDecl>(D)) {
     Record.push_back(D->isThisDeclarationADemotedDefinition());
if (D->getDeclContext() == D->getLexicalDeclContext() &&
       D->getStorageDuration() != SD_Static &&
       !D->getMemberSpecializationInfo())
     AbbrevToUse = Writer.getDeclVarAbbrev();
 
   Code = serialization::DECL_VAR;
 }
 
 void ASTDeclWriter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
+  static_assert(sizeof(ImplicitParamDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitVarDecl(D);
   Code = serialization::DECL_IMPLICIT_PARAM;
 }
 
 void ASTDeclWriter::VisitParmVarDecl(ParmVarDecl *D) {
+  static_assert(sizeof(ParmVarDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitVarDecl(D);
   Record.push_back(D->isObjCMethodParameter());
   Record.push_back(D->getFunctionScopeDepth());
   Record.push_back(D->getFunctionScopeIndex());
   Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
   Record.push_back(D->isKNRPromoted());
   Record.push_back(D->hasInheritedDefaultArg());
   Record.push_back(D->hasUninstantiatedDefaultArg());
void ASTDeclWriter::VisitDecompositionDecl(DecompositionDecl *D) {
 
   VisitVarDecl(D);
   for (auto *B : D->bindings())
     Record.AddDeclRef(B);
   Code = serialization::DECL_DECOMPOSITION;
 }
 
 void ASTDeclWriter::VisitBindingDecl(BindingDecl *D) {
+  static_assert(sizeof(BindingDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.AddStmt(D->getBinding());
   Code = serialization::DECL_BINDING;
 }
 
 void ASTDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
+  static_assert(sizeof(FileScopeAsmDecl) == 56,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddStmt(D->getAsmString());
   Record.AddSourceLocation(D->getRParenLoc());
   Code = serialization::DECL_FILE_SCOPE_ASM;
 }
 
 void ASTDeclWriter::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
+  static_assert(sizeof(TopLevelStmtDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddStmt(D->getStmt());
   Code = serialization::DECL_TOP_LEVEL_STMT_DECL;
 }
 
 void ASTDeclWriter::VisitEmptyDecl(EmptyDecl *D) {
+  static_assert(sizeof(EmptyDecl) == 40,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Code = serialization::DECL_EMPTY;
 }
 
 void ASTDeclWriter::VisitLifetimeExtendedTemporaryDecl(
     LifetimeExtendedTemporaryDecl *D) {
+  static_assert(sizeof(LifetimeExtendedTemporaryDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddDeclRef(D->getExtendingDecl());
   Record.AddStmt(D->getTemporaryExpr());
   Record.push_back(static_cast<bool>(D->getValue()));
   if (D->getValue())
     Record.AddAPValue(*D->getValue());
   Record.push_back(D->getManglingNumber());
   Code = serialization::DECL_LIFETIME_EXTENDED_TEMPORARY;
 }
 void ASTDeclWriter::VisitBlockDecl(BlockDecl *D) {
+  static_assert(DeclContext::NumBlockDeclBits == 5 && sizeof(BlockDecl) == 128,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddStmt(D->getBody());
   Record.AddTypeSourceInfo(D->getSignatureAsWritten());
   Record.push_back(D->param_size());
   for (ParmVarDecl *P : D->parameters())
     Record.AddDeclRef(P);
   Record.push_back(D->isVariadic());
   Record.push_back(D->blockMissingReturnType());
for (const auto &capture : D->captures()) {
 
     if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
   }
 
   Code = serialization::DECL_BLOCK;
 }
 
 void ASTDeclWriter::VisitCapturedDecl(CapturedDecl *CD) {
+  static_assert(sizeof(CapturedDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.push_back(CD->getNumParams());
   VisitDecl(CD);
   Record.push_back(CD->getContextParamPosition());
   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 &&
+                    sizeof(LinkageSpecDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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) {
+  static_assert(sizeof(ExportDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddSourceLocation(D->getRBraceLoc());
   Code = serialization::DECL_EXPORT;
 }
 
 void ASTDeclWriter::VisitLabelDecl(LabelDecl *D) {
+  static_assert(sizeof(LabelDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getBeginLoc());
   Code = serialization::DECL_LABEL;
 }
 
 
 void ASTDeclWriter::VisitNamespaceDecl(NamespaceDecl *D) {
+  static_assert(sizeof(NamespaceDecl) == 112,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitNamedDecl(D);
   Record.push_back(D->isInline());
   Record.push_back(D->isNested());
   Record.AddSourceLocation(D->getBeginLoc());
   Record.AddSourceLocation(D->getRBraceLoc());
 
   if (D->isOriginalNamespace())
if (Writer.hasChain() && D->isAnonymousNamespace() &&
     if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
       Writer.DeclUpdates[Parent].push_back(
           ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
     }
   }
 }
 
 void ASTDeclWriter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
+  static_assert(sizeof(NamespaceAliasDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getNamespaceLoc());
   Record.AddSourceLocation(D->getTargetNameLoc());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddDeclRef(D->getNamespace());
   Code = serialization::DECL_NAMESPACE_ALIAS;
 }
 
 void ASTDeclWriter::VisitUsingDecl(UsingDecl *D) {
+  static_assert(sizeof(UsingDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getUsingLoc());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
   Record.AddDeclRef(D->FirstUsingShadow.getPointer());
   Record.push_back(D->hasTypename());
   Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
   Code = serialization::DECL_USING;
 }
 
 void ASTDeclWriter::VisitUsingEnumDecl(UsingEnumDecl *D) {
+  static_assert(sizeof(UsingEnumDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getUsingLoc());
   Record.AddSourceLocation(D->getEnumLoc());
   Record.AddTypeSourceInfo(D->getEnumType());
   Record.AddDeclRef(D->FirstUsingShadow.getPointer());
   Record.AddDeclRef(Context.getInstantiatedFromUsingEnumDecl(D));
   Code = serialization::DECL_USING_ENUM;
 }
 
 void ASTDeclWriter::VisitUsingPackDecl(UsingPackDecl *D) {
+  static_assert(sizeof(UsingPackDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.push_back(D->NumExpansions);
   VisitNamedDecl(D);
   Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
   for (auto *E : D->expansions())
     Record.AddDeclRef(E);
   Code = serialization::DECL_USING_PACK;
 }
 
 void ASTDeclWriter::VisitUsingShadowDecl(UsingShadowDecl *D) {
+  static_assert(sizeof(UsingShadowDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
   VisitNamedDecl(D);
   Record.AddDeclRef(D->getTargetDecl());
   Record.push_back(D->getIdentifierNamespace());
   Record.AddDeclRef(D->UsingOrNextShadow);
   Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
   Code = serialization::DECL_USING_SHADOW;
 }
 
 void ASTDeclWriter::VisitConstructorUsingShadowDecl(
     ConstructorUsingShadowDecl *D) {
+  static_assert(sizeof(ConstructorUsingShadowDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitUsingShadowDecl(D);
   Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
   Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
   Record.push_back(D->IsVirtual);
   Code = serialization::DECL_CONSTRUCTOR_USING_SHADOW;
 }
 
 void ASTDeclWriter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
+  static_assert(sizeof(UsingDirectiveDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Record.AddSourceLocation(D->getUsingLoc());
   Record.AddSourceLocation(D->getNamespaceKeyLocation());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddDeclRef(D->getNominatedNamespace());
   Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
   Code = serialization::DECL_USING_DIRECTIVE;
 }
 
 void ASTDeclWriter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
+  static_assert(sizeof(UnresolvedUsingValueDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitValueDecl(D);
   Record.AddSourceLocation(D->getUsingLoc());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
   Record.AddSourceLocation(D->getEllipsisLoc());
   Code = serialization::DECL_UNRESOLVED_USING_VALUE;
 }
 
 void ASTDeclWriter::VisitUnresolvedUsingTypenameDecl(
                                                UnresolvedUsingTypenameDecl *D) {
+  static_assert(sizeof(UnresolvedUsingTypenameDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitTypeDecl(D);
   Record.AddSourceLocation(D->getTypenameLoc());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddSourceLocation(D->getEllipsisLoc());
   Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
 }
 
 void ASTDeclWriter::VisitUnresolvedUsingIfExistsDecl(
     UnresolvedUsingIfExistsDecl *D) {
+  static_assert(sizeof(UnresolvedUsingIfExistsDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   Code = serialization::DECL_UNRESOLVED_USING_IF_EXISTS;
 }
 
 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
+  static_assert(sizeof(CXXRecordDecl) == 144,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRecordDecl(D);
 
   enum {
     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
   };
   if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
     Record.push_back(CXXRecTemplate);
     Record.AddDeclRef(TemplD);
void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
   // deserializing every method so we can compute it.
   if (D->isCompleteDefinition())
     Record.AddDeclRef(Context.getCurrentKeyFunction(D));
 
   Code = serialization::DECL_CXX_RECORD;
 }
 
 void ASTDeclWriter::VisitCXXMethodDecl(CXXMethodDecl *D) {
+  static_assert(sizeof(CXXMethodDecl) == 168,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitFunctionDecl(D);
   if (D->isCanonicalDecl()) {
     Record.push_back(D->size_overridden_methods());
     for (const CXXMethodDecl *MD : D->overridden_methods())
       Record.AddDeclRef(MD);
   } else {
     // We only need to record overridden methods once for the canonical decl.
     Record.push_back(0);
   }
 
   if (D->getDeclContext() == D->getLexicalDeclContext() &&
       D->getFirstDecl() == D->getMostRecentDecl() && !D->isInvalidDecl() &&
       !D->hasAttrs() && !D->isTopLevelDeclInObjCContainer() &&
       D->getDeclName().getNameKind() == DeclarationName::Identifier &&
       !D->hasExtInfo() && !D->hasInheritedPrototype() &&
       D->hasWrittenPrototype() &&
       D->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
     AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
 
   Code = serialization::DECL_CXX_METHOD;
 }
 
 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
+  static_assert(DeclContext::NumCXXConstructorDeclBits == 22 &&
+                    sizeof(CXXConstructorDecl) == 176,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.push_back(D->getTrailingAllocKind());
   addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   if (auto Inherited = D->getInheritedConstructor()) {
     Record.AddDeclRef(Inherited.getShadowDecl());
     Record.AddDeclRef(Inherited.getConstructor());
   }
 
   VisitCXXMethodDecl(D);
   Code = serialization::DECL_CXX_CONSTRUCTOR;
 }
 
 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
+  static_assert(sizeof(CXXDestructorDecl) == 184,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitCXXMethodDecl(D);
 
   Record.AddDeclRef(D->getOperatorDelete());
   if (D->getOperatorDelete())
     Record.AddStmt(D->getOperatorDeleteThisArg());
 
   Code = serialization::DECL_CXX_DESTRUCTOR;
 }
 
 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
+  static_assert(sizeof(CXXConversionDecl) == 176,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   VisitCXXMethodDecl(D);
   Code = serialization::DECL_CXX_CONVERSION;
 }
 
 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
+  static_assert(sizeof(ImportDecl) == 56,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
   ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
   Record.push_back(!IdentifierLocs.empty());
   if (IdentifierLocs.empty()) {
     Record.AddSourceLocation(D->getEndLoc());
     Record.push_back(1);
   } else {
     for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
       Record.AddSourceLocation(IdentifierLocs[I]);
     Record.push_back(IdentifierLocs.size());
   }
   // Note: the number of source locations must always be the last element in
   // the record.
   Code = serialization::DECL_IMPORT;
 }
 
 void ASTDeclWriter::VisitAccessSpecDecl(AccessSpecDecl *D) {
+  static_assert(sizeof(AccessSpecDecl) == 40,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddSourceLocation(D->getColonLoc());
   Code = serialization::DECL_ACCESS_SPEC;
 }
 
 void ASTDeclWriter::VisitFriendDecl(FriendDecl *D) {
+  static_assert(sizeof(FriendDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   // Record the number of friend type template parameter lists here
   // so as to simplify memory allocation during deserialization.
   Record.push_back(D->NumTPLists);
   VisitDecl(D);
   bool hasFriendDecl = D->Friend.is<NamedDecl*>();
   Record.push_back(hasFriendDecl);
   if (hasFriendDecl)
     Record.AddDeclRef(D->getFriendDecl());
   else
     Record.AddTypeSourceInfo(D->getFriendType());
   for (unsigned i = 0; i < D->NumTPLists; ++i)
     Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
   Record.AddDeclRef(D->getNextFriend());
   Record.push_back(D->UnsupportedFriend);
   Record.AddSourceLocation(D->FriendLoc);
   Code = serialization::DECL_FRIEND;
 }
 
 void ASTDeclWriter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
+  static_assert(sizeof(FriendTemplateDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.push_back(D->getNumTemplateParameters());
   for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
     Record.AddTemplateParameterList(D->getTemplateParameterList(i));
   Record.push_back(D->getFriendDecl() != nullptr);
   if (D->getFriendDecl())
     Record.AddDeclRef(D->getFriendDecl());
   else
     Record.AddTypeSourceInfo(D->getFriendType());
   Record.AddSourceLocation(D->getFriendLoc());
   Code = serialization::DECL_FRIEND_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitTemplateDecl(TemplateDecl *D) {
+  static_assert(sizeof(TemplateDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
 
   Record.AddTemplateParameterList(D->getTemplateParameters());
   Record.AddDeclRef(D->getTemplatedDecl());
 }
 
 void ASTDeclWriter::VisitConceptDecl(ConceptDecl *D) {
+  static_assert(sizeof(ConceptDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitTemplateDecl(D);
   Record.AddStmt(D->getConstraintExpr());
   Code = serialization::DECL_CONCEPT;
 }
 
 void ASTDeclWriter::VisitImplicitConceptSpecializationDecl(
     ImplicitConceptSpecializationDecl *D) {
+  static_assert(sizeof(ImplicitConceptSpecializationDecl) == 40,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.push_back(D->getTemplateArguments().size());
   VisitDecl(D);
   for (const TemplateArgument &Arg : D->getTemplateArguments())
     Record.AddTemplateArgument(Arg);
   Code = serialization::DECL_IMPLICIT_CONCEPT_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
+  static_assert(sizeof(RequiresExprBodyDecl) == 72,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Code = serialization::DECL_REQUIRES_EXPR_BODY;
 }
 
 void ASTDeclWriter::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
+  static_assert(sizeof(RedeclarableTemplateDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarable(D);
 
   // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
   // getCommonPtr() can be used while this is still initializing.
   if (D->isFirstDecl()) {
     // This declaration owns the 'common' pointer, so serialize that data now.
     Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
     if (D->getInstantiatedFromMemberTemplate())
       Record.push_back(D->isMemberSpecialization());
   }
 
   VisitTemplateDecl(D);
   Record.push_back(D->getIdentifierNamespace());
 }
 
 void ASTDeclWriter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
+  static_assert(sizeof(ClassTemplateDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarableTemplateDecl(D);
 
   if (D->isFirstDecl())
     AddTemplateSpecializations(D);
   Code = serialization::DECL_CLASS_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitClassTemplateSpecializationDecl(
                                            ClassTemplateSpecializationDecl *D) {
+  static_assert(sizeof(ClassTemplateSpecializationDecl) == 184,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
 
   VisitCXXRecordDecl(D);
 
   llvm::PointerUnion<ClassTemplateDecl *,
                      ClassTemplatePartialSpecializationDecl *> InstFrom
     = D->getSpecializedTemplateOrPartial();
   if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
if (D->getTypeAsWritten()) {
     Record.AddSourceLocation(D->getTemplateKeywordLoc());
   }
 
   Code = serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl(
                                     ClassTemplatePartialSpecializationDecl *D) {
+  static_assert(sizeof(ClassTemplatePartialSpecializationDecl) == 208,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.AddTemplateParameterList(D->getTemplateParameters());
   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
 
   VisitClassTemplateSpecializationDecl(D);
 
   // These are read/set from/to the first declaration.
   if (D->getPreviousDecl() == nullptr) {
     Record.AddDeclRef(D->getInstantiatedFromMember());
     Record.push_back(D->isMemberSpecialization());
   }
 
   Code = serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitVarTemplateDecl(VarTemplateDecl *D) {
+  static_assert(sizeof(VarTemplateDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarableTemplateDecl(D);
 
   if (D->isFirstDecl())
     AddTemplateSpecializations(D);
   Code = serialization::DECL_VAR_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *D) {
+  static_assert(sizeof(VarTemplateSpecializationDecl) == 152,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
 
   llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
   InstFrom = D->getSpecializedTemplateOrPartial();
   if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
     Record.AddDeclRef(InstFromD);
   } else {
     Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>());
if (D->isCanonicalDecl()) {
     Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
   }
 
   Code = serialization::DECL_VAR_TEMPLATE_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl(
     VarTemplatePartialSpecializationDecl *D) {
+  static_assert(sizeof(VarTemplatePartialSpecializationDecl) == 176,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.AddTemplateParameterList(D->getTemplateParameters());
   Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
 
   VisitVarTemplateSpecializationDecl(D);
 
   // These are read/set from/to the first declaration.
   if (D->getPreviousDecl() == nullptr) {
     Record.AddDeclRef(D->getInstantiatedFromMember());
     Record.push_back(D->isMemberSpecialization());
   }
 
   Code = serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION;
 }
 
 void ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl(
                                     ClassScopeFunctionSpecializationDecl *D) {
+  static_assert(sizeof(ClassScopeFunctionSpecializationDecl) == 56,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddDeclRef(D->getSpecialization());
   Record.push_back(D->hasExplicitTemplateArgs());
   if (D->hasExplicitTemplateArgs())
     Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
   Code = serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION;
 }
 
 
 void ASTDeclWriter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
+  static_assert(sizeof(FunctionTemplateDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarableTemplateDecl(D);
 
   if (D->isFirstDecl())
     AddTemplateSpecializations(D);
   Code = serialization::DECL_FUNCTION_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
+  static_assert(sizeof(TemplateTypeParmDecl) == 80,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.push_back(D->hasTypeConstraint());
   VisitTypeDecl(D);
 
   Record.push_back(D->wasDeclaredWithTypename());
 
   const TypeConstraint *TC = D->getTypeConstraint();
   Record.push_back(TC != nullptr);
   if (TC) {
void ASTDeclWriter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
   Record.push_back(OwnsDefaultArg);
   if (OwnsDefaultArg)
     Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
 
   Code = serialization::DECL_TEMPLATE_TYPE_PARM;
 }
 
 void ASTDeclWriter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
+  static_assert(sizeof(NonTypeTemplateParmDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   // For an expanded parameter pack, record the number of expansion types here
   // so that it's easier for deserialization to allocate the right amount of
   // memory.
   Expr *TypeConstraint = D->getPlaceholderTypeConstraint();
   Record.push_back(!!TypeConstraint);
   if (D->isExpandedParameterPack())
     Record.push_back(D->getNumExpansionTypes());
 
if (D->isExpandedParameterPack()) {
     Record.push_back(OwnsDefaultArg);
     if (OwnsDefaultArg)
       Record.AddStmt(D->getDefaultArgument());
     Code = serialization::DECL_NON_TYPE_TEMPLATE_PARM;
   }
 }
 
 void ASTDeclWriter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
+  static_assert(sizeof(TemplateTemplateParmDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   // For an expanded parameter pack, record the number of expansion types here
   // so that it's easier for deserialization to allocate the right amount of
   // memory.
   if (D->isExpandedParameterPack())
     Record.push_back(D->getNumExpansionTemplateParameters());
 
   VisitTemplateDecl(D);
   // TemplateParmPosition.
if (D->isExpandedParameterPack()) {
     Record.push_back(OwnsDefaultArg);
     if (OwnsDefaultArg)
       Record.AddTemplateArgumentLoc(D->getDefaultArgument());
     Code = serialization::DECL_TEMPLATE_TEMPLATE_PARM;
   }
 }
 
 void ASTDeclWriter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
+  static_assert(sizeof(TypeAliasTemplateDecl) == 88,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitRedeclarableTemplateDecl(D);
   Code = serialization::DECL_TYPE_ALIAS_TEMPLATE;
 }
 
 void ASTDeclWriter::VisitStaticAssertDecl(StaticAssertDecl *D) {
+  static_assert(sizeof(StaticAssertDecl) == 64,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitDecl(D);
   Record.AddStmt(D->getAssertExpr());
   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 &&
+                    sizeof(DeclContext) == 32,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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();
if (MostRecent != First) {
     (void)Writer.GetDeclRef(MostRecent);
   } else {
     // We use the sentinel value 0 to indicate an only declaration.
     Record.push_back(0);
   }
 }
 
 void ASTDeclWriter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
+  static_assert(sizeof(HLSLBufferDecl) == 96,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitNamedDecl(D);
   VisitDeclContext(D);
   Record.push_back(D->isCBuffer());
   Record.AddSourceLocation(D->getLocStart());
   Record.AddSourceLocation(D->getLBraceLoc());
   Record.AddSourceLocation(D->getRBraceLoc());
 
   Code = serialization::DECL_HLSL_BUFFER;
 }
 
 void ASTDeclWriter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
+  static_assert(sizeof(OMPThreadPrivateDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.writeOMPChildren(D->Data);
   VisitDecl(D);
   Code = serialization::DECL_OMP_THREADPRIVATE;
 }
 
 void ASTDeclWriter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
+  static_assert(sizeof(OMPAllocateDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.writeOMPChildren(D->Data);
   VisitDecl(D);
   Code = serialization::DECL_OMP_ALLOCATE;
 }
 
 void ASTDeclWriter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
+  static_assert(sizeof(OMPRequiresDecl) == 48,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.writeOMPChildren(D->Data);
   VisitDecl(D);
   Code = serialization::DECL_OMP_REQUIRES;
 }
 
 void ASTDeclWriter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
+  static_assert(DeclContext::NumOMPDeclareReductionDeclBits == 2 &&
+                    sizeof(OMPDeclareReductionDecl) == 144,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   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());
   Record.push_back(D->getInitializerKind());
   Record.AddDeclRef(D->getPrevDeclInScope());
   Code = serialization::DECL_OMP_DECLARE_REDUCTION;
 }
 
 void ASTDeclWriter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
+  static_assert(sizeof(OMPDeclareMapperDecl) == 120,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   Record.writeOMPChildren(D->Data);
   VisitValueDecl(D);
   Record.AddDeclarationName(D->getVarName());
   Record.AddDeclRef(D->getPrevDeclInScope());
   Code = serialization::DECL_OMP_DECLARE_MAPPER;
 }
 
 void ASTDeclWriter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
+  static_assert(sizeof(OMPCapturedExprDecl) == 104,
+                "You need to update the serializer after you change the fields "
+                "of Decls.");
+
   VisitVarDecl(D);
   Code = serialization::DECL_OMP_CAPTUREDEXPR;
 }
 
 //===----------------------------------------------------------------------===//
 // ASTWriter Implementation
 //===----------------------------------------------------------------------===//