1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Serialization/ASTReader.h"
16 #include "ASTCommon.h"
17 #include "ASTReaderInternals.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclGroup.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/Sema/IdentifierResolver.h"
26 #include "clang/Sema/Sema.h"
27 #include "clang/Sema/SemaDiagnostic.h"
28 #include "llvm/Support/SaveAndRestore.h"
29 using namespace clang;
30 using namespace clang::serialization;
31 
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
35 
36 namespace clang {
37   class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38     ASTReader &Reader;
39     ModuleFile &F;
40     const DeclID ThisDeclID;
41     const unsigned RawLocation;
42     typedef ASTReader::RecordData RecordData;
43     const RecordData &Record;
44     unsigned &Idx;
45     TypeID TypeIDForTypeDecl;
46     unsigned AnonymousDeclNumber;
47     GlobalDeclID NamedDeclForTagDecl;
48     IdentifierInfo *TypedefNameForLinkage;
49 
50     bool HasPendingBody;
51 
52     uint64_t GetCurrentCursorOffset();
53 
54     SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
55       return Reader.ReadSourceLocation(F, R, I);
56     }
57 
58     SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
59       return Reader.ReadSourceRange(F, R, I);
60     }
61 
62     TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
63       return Reader.GetTypeSourceInfo(F, R, I);
64     }
65 
66     serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
67       return Reader.ReadDeclID(F, R, I);
68     }
69 
70     Decl *ReadDecl(const RecordData &R, unsigned &I) {
71       return Reader.ReadDecl(F, R, I);
72     }
73 
74     template<typename T>
75     T *ReadDeclAs(const RecordData &R, unsigned &I) {
76       return Reader.ReadDeclAs<T>(F, R, I);
77     }
78 
79     void ReadQualifierInfo(QualifierInfo &Info,
80                            const RecordData &R, unsigned &I) {
81       Reader.ReadQualifierInfo(F, Info, R, I);
82     }
83 
84     void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
85                                 const RecordData &R, unsigned &I) {
86       Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
87     }
88 
89     void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
90                                 const RecordData &R, unsigned &I) {
91       Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
92     }
93 
94     serialization::SubmoduleID readSubmoduleID(const RecordData &R,
95                                                unsigned &I) {
96       if (I >= R.size())
97         return 0;
98 
99       return Reader.getGlobalSubmoduleID(F, R[I++]);
100     }
101 
102     Module *readModule(const RecordData &R, unsigned &I) {
103       return Reader.getSubmodule(readSubmoduleID(R, I));
104     }
105 
106     void ReadCXXRecordDefinition(CXXRecordDecl *D);
107     void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
108                                const RecordData &R, unsigned &I);
109     void MergeDefinitionData(CXXRecordDecl *D,
110                              struct CXXRecordDecl::DefinitionData &NewDD);
111 
112     static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
113                                                  DeclContext *DC,
114                                                  unsigned Index);
115     static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
116                                            unsigned Index, NamedDecl *D);
117 
118     /// \brief RAII class used to capture the first ID within a redeclaration
119     /// chain and to introduce it into the list of pending redeclaration chains
120     /// on destruction.
121     ///
122     /// The caller can choose not to introduce this ID into the list of pending
123     /// redeclaration chains by calling \c suppress().
124     class RedeclarableResult {
125       ASTReader &Reader;
126       GlobalDeclID FirstID;
127       mutable bool Owning;
128       Decl::Kind DeclKind;
129 
130       void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
131 
132     public:
133       RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID,
134                          Decl::Kind DeclKind)
135         : Reader(Reader), FirstID(FirstID), Owning(true), DeclKind(DeclKind) { }
136 
137       RedeclarableResult(const RedeclarableResult &Other)
138         : Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning) ,
139           DeclKind(Other.DeclKind)
140       {
141         Other.Owning = false;
142       }
143 
144       ~RedeclarableResult() {
145         if (FirstID && Owning && isRedeclarableDeclKind(DeclKind) &&
146             Reader.PendingDeclChainsKnown.insert(FirstID))
147           Reader.PendingDeclChains.push_back(FirstID);
148       }
149 
150       /// \brief Retrieve the first ID.
151       GlobalDeclID getFirstID() const { return FirstID; }
152 
153       /// \brief Do not introduce this declaration ID into the set of pending
154       /// declaration chains.
155       void suppress() {
156         Owning = false;
157       }
158     };
159 
160     /// \brief Class used to capture the result of searching for an existing
161     /// declaration of a specific kind and name, along with the ability
162     /// to update the place where this result was found (the declaration
163     /// chain hanging off an identifier or the DeclContext we searched in)
164     /// if requested.
165     class FindExistingResult {
166       ASTReader &Reader;
167       NamedDecl *New;
168       NamedDecl *Existing;
169       mutable bool AddResult;
170 
171       unsigned AnonymousDeclNumber;
172       IdentifierInfo *TypedefNameForLinkage;
173 
174       void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
175 
176     public:
177       FindExistingResult(ASTReader &Reader)
178           : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
179             AnonymousDeclNumber(0), TypedefNameForLinkage(0) {}
180 
181       FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
182                          unsigned AnonymousDeclNumber,
183                          IdentifierInfo *TypedefNameForLinkage)
184           : Reader(Reader), New(New), Existing(Existing), AddResult(true),
185             AnonymousDeclNumber(AnonymousDeclNumber),
186             TypedefNameForLinkage(TypedefNameForLinkage) {}
187 
188       FindExistingResult(const FindExistingResult &Other)
189           : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
190             AddResult(Other.AddResult),
191             AnonymousDeclNumber(Other.AnonymousDeclNumber),
192             TypedefNameForLinkage(Other.TypedefNameForLinkage) {
193         Other.AddResult = false;
194       }
195 
196       ~FindExistingResult();
197 
198       /// \brief Suppress the addition of this result into the known set of
199       /// names.
200       void suppress() { AddResult = false; }
201 
202       operator NamedDecl*() const { return Existing; }
203 
204       template<typename T>
205       operator T*() const { return dyn_cast_or_null<T>(Existing); }
206     };
207 
208     FindExistingResult findExisting(NamedDecl *D);
209 
210   public:
211     ASTDeclReader(ASTReader &Reader, ModuleFile &F, DeclID thisDeclID,
212                   unsigned RawLocation, const RecordData &Record, unsigned &Idx)
213         : Reader(Reader), F(F), ThisDeclID(thisDeclID),
214           RawLocation(RawLocation), Record(Record), Idx(Idx),
215           TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
216           TypedefNameForLinkage(nullptr), HasPendingBody(false) {}
217 
218     template <typename DeclT>
219     static void attachPreviousDeclImpl(ASTReader &Reader,
220                                        Redeclarable<DeclT> *D, Decl *Previous);
221     static void attachPreviousDeclImpl(ASTReader &Reader, ...);
222     static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous);
223 
224     template <typename DeclT>
225     static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
226     static void attachLatestDeclImpl(...);
227     static void attachLatestDecl(Decl *D, Decl *latest);
228 
229     template <typename DeclT>
230     static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
231     static void markIncompleteDeclChainImpl(...);
232 
233     /// \brief Determine whether this declaration has a pending body.
234     bool hasPendingBody() const { return HasPendingBody; }
235 
236     void Visit(Decl *D);
237 
238     void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
239                     const RecordData &Record);
240 
241     static void setNextObjCCategory(ObjCCategoryDecl *Cat,
242                                     ObjCCategoryDecl *Next) {
243       Cat->NextClassCategory = Next;
244     }
245 
246     void VisitDecl(Decl *D);
247     void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
248     void VisitNamedDecl(NamedDecl *ND);
249     void VisitLabelDecl(LabelDecl *LD);
250     void VisitNamespaceDecl(NamespaceDecl *D);
251     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
252     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
253     void VisitTypeDecl(TypeDecl *TD);
254     RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
255     void VisitTypedefDecl(TypedefDecl *TD);
256     void VisitTypeAliasDecl(TypeAliasDecl *TD);
257     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
258     RedeclarableResult VisitTagDecl(TagDecl *TD);
259     void VisitEnumDecl(EnumDecl *ED);
260     RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
261     void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
262     RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
263     void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
264     RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
265                                             ClassTemplateSpecializationDecl *D);
266     void VisitClassTemplateSpecializationDecl(
267         ClassTemplateSpecializationDecl *D) {
268       VisitClassTemplateSpecializationDeclImpl(D);
269     }
270     void VisitClassTemplatePartialSpecializationDecl(
271                                      ClassTemplatePartialSpecializationDecl *D);
272     void VisitClassScopeFunctionSpecializationDecl(
273                                        ClassScopeFunctionSpecializationDecl *D);
274     RedeclarableResult
275     VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
276     void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
277       VisitVarTemplateSpecializationDeclImpl(D);
278     }
279     void VisitVarTemplatePartialSpecializationDecl(
280         VarTemplatePartialSpecializationDecl *D);
281     void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
282     void VisitValueDecl(ValueDecl *VD);
283     void VisitEnumConstantDecl(EnumConstantDecl *ECD);
284     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
285     void VisitDeclaratorDecl(DeclaratorDecl *DD);
286     void VisitFunctionDecl(FunctionDecl *FD);
287     void VisitCXXMethodDecl(CXXMethodDecl *D);
288     void VisitCXXConstructorDecl(CXXConstructorDecl *D);
289     void VisitCXXDestructorDecl(CXXDestructorDecl *D);
290     void VisitCXXConversionDecl(CXXConversionDecl *D);
291     void VisitFieldDecl(FieldDecl *FD);
292     void VisitMSPropertyDecl(MSPropertyDecl *FD);
293     void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
294     RedeclarableResult VisitVarDeclImpl(VarDecl *D);
295     void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
296     void VisitImplicitParamDecl(ImplicitParamDecl *PD);
297     void VisitParmVarDecl(ParmVarDecl *PD);
298     void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
299     DeclID VisitTemplateDecl(TemplateDecl *D);
300     RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
301     void VisitClassTemplateDecl(ClassTemplateDecl *D);
302     void VisitVarTemplateDecl(VarTemplateDecl *D);
303     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
304     void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
305     void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
306     void VisitUsingDecl(UsingDecl *D);
307     void VisitUsingShadowDecl(UsingShadowDecl *D);
308     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
309     void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
310     void VisitImportDecl(ImportDecl *D);
311     void VisitAccessSpecDecl(AccessSpecDecl *D);
312     void VisitFriendDecl(FriendDecl *D);
313     void VisitFriendTemplateDecl(FriendTemplateDecl *D);
314     void VisitStaticAssertDecl(StaticAssertDecl *D);
315     void VisitBlockDecl(BlockDecl *BD);
316     void VisitCapturedDecl(CapturedDecl *CD);
317     void VisitEmptyDecl(EmptyDecl *D);
318 
319     std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
320 
321     template<typename T>
322     RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
323 
324     template<typename T>
325     void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
326                            DeclID TemplatePatternID = 0);
327 
328     template<typename T>
329     void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
330                            RedeclarableResult &Redecl,
331                            DeclID TemplatePatternID = 0);
332 
333     template<typename T>
334     void mergeMergeable(Mergeable<T> *D);
335 
336     void mergeTemplatePattern(RedeclarableTemplateDecl *D,
337                               RedeclarableTemplateDecl *Existing,
338                               DeclID DsID);
339 
340     // FIXME: Reorder according to DeclNodes.td?
341     void VisitObjCMethodDecl(ObjCMethodDecl *D);
342     void VisitObjCContainerDecl(ObjCContainerDecl *D);
343     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
344     void VisitObjCIvarDecl(ObjCIvarDecl *D);
345     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
346     void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
347     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
348     void VisitObjCImplDecl(ObjCImplDecl *D);
349     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
350     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
351     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
352     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
353     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
354     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
355   };
356 }
357 
358 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
359   return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
360 }
361 
362 void ASTDeclReader::Visit(Decl *D) {
363   DeclVisitor<ASTDeclReader, void>::Visit(D);
364 
365   if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
366     if (DD->DeclInfo) {
367       DeclaratorDecl::ExtInfo *Info =
368           DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
369       Info->TInfo =
370           GetTypeSourceInfo(Record, Idx);
371     }
372     else {
373       DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
374     }
375   }
376 
377   if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
378     // We have a fully initialized TypeDecl. Read its type now.
379     TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
380 
381     // If this is a tag declaration with a typedef name for linkage, it's safe
382     // to load that typedef now.
383     if (NamedDeclForTagDecl)
384       cast<TagDecl>(D)->NamedDeclOrQualifier =
385           cast<NamedDecl>(Reader.GetDecl(NamedDeclForTagDecl));
386   } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
387     // if we have a fully initialized TypeDecl, we can safely read its type now.
388     ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
389   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
390     // FunctionDecl's body was written last after all other Stmts/Exprs.
391     // We only read it if FD doesn't already have a body (e.g., from another
392     // module).
393     // FIXME: Also consider = default and = delete.
394     // FIXME: Can we diagnose ODR violations somehow?
395     if (Record[Idx++]) {
396       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
397       HasPendingBody = true;
398     }
399   }
400 }
401 
402 void ASTDeclReader::VisitDecl(Decl *D) {
403   if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
404       isa<ParmVarDecl>(D)) {
405     // We don't want to deserialize the DeclContext of a template
406     // parameter or of a parameter of a function template immediately.   These
407     // entities might be used in the formulation of its DeclContext (for
408     // example, a function parameter can be used in decltype() in trailing
409     // return type of the function).  Use the translation unit DeclContext as a
410     // placeholder.
411     GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
412     GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
413     Reader.addPendingDeclContextInfo(D,
414                                      SemaDCIDForTemplateParmDecl,
415                                      LexicalDCIDForTemplateParmDecl);
416     D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
417   } else {
418     DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
419     DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
420     DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
421     // Avoid calling setLexicalDeclContext() directly because it uses
422     // Decl::getASTContext() internally which is unsafe during derialization.
423     D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
424                            Reader.getContext());
425   }
426   D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
427   D->setInvalidDecl(Record[Idx++]);
428   if (Record[Idx++]) { // hasAttrs
429     AttrVec Attrs;
430     Reader.ReadAttributes(F, Attrs, Record, Idx);
431     // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
432     // internally which is unsafe during derialization.
433     D->setAttrsImpl(Attrs, Reader.getContext());
434   }
435   D->setImplicit(Record[Idx++]);
436   D->Used = Record[Idx++];
437   D->setReferenced(Record[Idx++]);
438   D->setTopLevelDeclInObjCContainer(Record[Idx++]);
439   D->setAccess((AccessSpecifier)Record[Idx++]);
440   D->FromASTFile = true;
441   D->setModulePrivate(Record[Idx++]);
442   D->Hidden = D->isModulePrivate();
443 
444   // Determine whether this declaration is part of a (sub)module. If so, it
445   // may not yet be visible.
446   if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
447     // Store the owning submodule ID in the declaration.
448     D->setOwningModuleID(SubmoduleID);
449 
450     // Module-private declarations are never visible, so there is no work to do.
451     if (!D->isModulePrivate()) {
452       if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
453         if (Owner->NameVisibility != Module::AllVisible) {
454           // The owning module is not visible. Mark this declaration as hidden.
455           D->Hidden = true;
456 
457           // Note that this declaration was hidden because its owning module is
458           // not yet visible.
459           Reader.HiddenNamesMap[Owner].HiddenDecls.push_back(D);
460         }
461       }
462     }
463   }
464 }
465 
466 void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
467   llvm_unreachable("Translation units are not serialized");
468 }
469 
470 void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
471   VisitDecl(ND);
472   ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
473   if (needsAnonymousDeclarationNumber(ND))
474     AnonymousDeclNumber = Record[Idx++];
475 }
476 
477 void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
478   VisitNamedDecl(TD);
479   TD->setLocStart(ReadSourceLocation(Record, Idx));
480   // Delay type reading until after we have fully initialized the decl.
481   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
482 }
483 
484 ASTDeclReader::RedeclarableResult
485 ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
486   RedeclarableResult Redecl = VisitRedeclarable(TD);
487   VisitTypeDecl(TD);
488   TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
489   if (Record[Idx++]) { // isModed
490     QualType modedT = Reader.readType(F, Record, Idx);
491     TD->setModedTypeSourceInfo(TInfo, modedT);
492   } else
493     TD->setTypeSourceInfo(TInfo);
494   return Redecl;
495 }
496 
497 void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
498   RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
499   mergeRedeclarable(TD, Redecl);
500 }
501 
502 void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
503   RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
504   if (auto *Template = ReadDeclAs<TypeAliasTemplateDecl>(Record, Idx))
505     // Merged when we merge the template.
506     TD->setDescribedAliasTemplate(Template);
507   else
508     mergeRedeclarable(TD, Redecl);
509 }
510 
511 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
512   RedeclarableResult Redecl = VisitRedeclarable(TD);
513   VisitTypeDecl(TD);
514 
515   TD->IdentifierNamespace = Record[Idx++];
516   TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
517   if (!isa<CXXRecordDecl>(TD))
518     TD->setCompleteDefinition(Record[Idx++]);
519   TD->setEmbeddedInDeclarator(Record[Idx++]);
520   TD->setFreeStanding(Record[Idx++]);
521   TD->setCompleteDefinitionRequired(Record[Idx++]);
522   TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
523 
524   switch (Record[Idx++]) {
525   case 0:
526     break;
527   case 1: { // ExtInfo
528     TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
529     ReadQualifierInfo(*Info, Record, Idx);
530     TD->NamedDeclOrQualifier = Info;
531     break;
532   }
533   case 2: // TypedefNameForAnonDecl
534     NamedDeclForTagDecl = ReadDeclID(Record, Idx);
535     TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
536     break;
537   case 3: // DeclaratorForAnonDecl
538     TD->NamedDeclOrQualifier = ReadDeclAs<NamedDecl>(Record, Idx);
539     break;
540   default:
541     llvm_unreachable("unexpected tag info kind");
542   }
543 
544   if (!isa<CXXRecordDecl>(TD))
545     mergeRedeclarable(TD, Redecl);
546   return Redecl;
547 }
548 
549 void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
550   VisitTagDecl(ED);
551   if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
552     ED->setIntegerTypeSourceInfo(TI);
553   else
554     ED->setIntegerType(Reader.readType(F, Record, Idx));
555   ED->setPromotionType(Reader.readType(F, Record, Idx));
556   ED->setNumPositiveBits(Record[Idx++]);
557   ED->setNumNegativeBits(Record[Idx++]);
558   ED->IsScoped = Record[Idx++];
559   ED->IsScopedUsingClassTag = Record[Idx++];
560   ED->IsFixed = Record[Idx++];
561 
562   // If this is a definition subject to the ODR, and we already have a
563   // definition, merge this one into it.
564   if (ED->IsCompleteDefinition &&
565       Reader.getContext().getLangOpts().Modules &&
566       Reader.getContext().getLangOpts().CPlusPlus) {
567     if (EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]) {
568       Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
569       ED->IsCompleteDefinition = false;
570     } else {
571       OldDef = ED;
572     }
573   }
574 
575   if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
576     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
577     SourceLocation POI = ReadSourceLocation(Record, Idx);
578     ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
579     ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
580   }
581 }
582 
583 ASTDeclReader::RedeclarableResult
584 ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
585   RedeclarableResult Redecl = VisitTagDecl(RD);
586   RD->setHasFlexibleArrayMember(Record[Idx++]);
587   RD->setAnonymousStructOrUnion(Record[Idx++]);
588   RD->setHasObjectMember(Record[Idx++]);
589   RD->setHasVolatileMember(Record[Idx++]);
590   return Redecl;
591 }
592 
593 void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
594   VisitNamedDecl(VD);
595   VD->setType(Reader.readType(F, Record, Idx));
596 }
597 
598 void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
599   VisitValueDecl(ECD);
600   if (Record[Idx++])
601     ECD->setInitExpr(Reader.ReadExpr(F));
602   ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
603   mergeMergeable(ECD);
604 }
605 
606 void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
607   VisitValueDecl(DD);
608   DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
609   if (Record[Idx++]) { // hasExtInfo
610     DeclaratorDecl::ExtInfo *Info
611         = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
612     ReadQualifierInfo(*Info, Record, Idx);
613     DD->DeclInfo = Info;
614   }
615 }
616 
617 void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
618   RedeclarableResult Redecl = VisitRedeclarable(FD);
619   VisitDeclaratorDecl(FD);
620 
621   ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
622   FD->IdentifierNamespace = Record[Idx++];
623 
624   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
625   // after everything else is read.
626 
627   FD->SClass = (StorageClass)Record[Idx++];
628   FD->IsInline = Record[Idx++];
629   FD->IsInlineSpecified = Record[Idx++];
630   FD->IsVirtualAsWritten = Record[Idx++];
631   FD->IsPure = Record[Idx++];
632   FD->HasInheritedPrototype = Record[Idx++];
633   FD->HasWrittenPrototype = Record[Idx++];
634   FD->IsDeleted = Record[Idx++];
635   FD->IsTrivial = Record[Idx++];
636   FD->IsDefaulted = Record[Idx++];
637   FD->IsExplicitlyDefaulted = Record[Idx++];
638   FD->HasImplicitReturnZero = Record[Idx++];
639   FD->IsConstexpr = Record[Idx++];
640   FD->HasSkippedBody = Record[Idx++];
641   FD->IsLateTemplateParsed = Record[Idx++];
642   FD->setCachedLinkage(Linkage(Record[Idx++]));
643   FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
644 
645   switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
646   case FunctionDecl::TK_NonTemplate:
647     mergeRedeclarable(FD, Redecl);
648     break;
649   case FunctionDecl::TK_FunctionTemplate:
650     // Merged when we merge the template.
651     FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
652                                                                       Idx));
653     break;
654   case FunctionDecl::TK_MemberSpecialization: {
655     FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
656     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
657     SourceLocation POI = ReadSourceLocation(Record, Idx);
658     FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
659     FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
660     mergeRedeclarable(FD, Redecl);
661     break;
662   }
663   case FunctionDecl::TK_FunctionTemplateSpecialization: {
664     FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
665                                                                       Idx);
666     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
667 
668     // Template arguments.
669     SmallVector<TemplateArgument, 8> TemplArgs;
670     Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
671 
672     // Template args as written.
673     SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
674     SourceLocation LAngleLoc, RAngleLoc;
675     bool HasTemplateArgumentsAsWritten = Record[Idx++];
676     if (HasTemplateArgumentsAsWritten) {
677       unsigned NumTemplateArgLocs = Record[Idx++];
678       TemplArgLocs.reserve(NumTemplateArgLocs);
679       for (unsigned i=0; i != NumTemplateArgLocs; ++i)
680         TemplArgLocs.push_back(
681             Reader.ReadTemplateArgumentLoc(F, Record, Idx));
682 
683       LAngleLoc = ReadSourceLocation(Record, Idx);
684       RAngleLoc = ReadSourceLocation(Record, Idx);
685     }
686 
687     SourceLocation POI = ReadSourceLocation(Record, Idx);
688 
689     ASTContext &C = Reader.getContext();
690     TemplateArgumentList *TemplArgList
691       = TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
692     TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
693     for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
694       TemplArgsInfo.addArgument(TemplArgLocs[i]);
695     FunctionTemplateSpecializationInfo *FTInfo
696         = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
697                                                      TemplArgList,
698                              HasTemplateArgumentsAsWritten ? &TemplArgsInfo
699                                                            : nullptr,
700                                                      POI);
701     FD->TemplateOrSpecialization = FTInfo;
702 
703     if (FD->isCanonicalDecl()) { // if canonical add to template's set.
704       // The template that contains the specializations set. It's not safe to
705       // use getCanonicalDecl on Template since it may still be initializing.
706       FunctionTemplateDecl *CanonTemplate
707         = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
708       // Get the InsertPos by FindNodeOrInsertPos() instead of calling
709       // InsertNode(FTInfo) directly to avoid the getASTContext() call in
710       // FunctionTemplateSpecializationInfo's Profile().
711       // We avoid getASTContext because a decl in the parent hierarchy may
712       // be initializing.
713       llvm::FoldingSetNodeID ID;
714       FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
715       void *InsertPos = nullptr;
716       FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
717       CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
718       if (InsertPos)
719         CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
720       else {
721         assert(Reader.getContext().getLangOpts().Modules &&
722                "already deserialized this template specialization");
723         // FIXME: This specialization is a redeclaration of one from another
724         // module. Merge it.
725       }
726     }
727     break;
728   }
729   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
730     // Templates.
731     UnresolvedSet<8> TemplDecls;
732     unsigned NumTemplates = Record[Idx++];
733     while (NumTemplates--)
734       TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
735 
736     // Templates args.
737     TemplateArgumentListInfo TemplArgs;
738     unsigned NumArgs = Record[Idx++];
739     while (NumArgs--)
740       TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
741     TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
742     TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
743 
744     FD->setDependentTemplateSpecialization(Reader.getContext(),
745                                            TemplDecls, TemplArgs);
746 
747     // FIXME: Merging.
748     break;
749   }
750   }
751 
752   // Read in the parameters.
753   unsigned NumParams = Record[Idx++];
754   SmallVector<ParmVarDecl *, 16> Params;
755   Params.reserve(NumParams);
756   for (unsigned I = 0; I != NumParams; ++I)
757     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
758   FD->setParams(Reader.getContext(), Params);
759 }
760 
761 void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
762   VisitNamedDecl(MD);
763   if (Record[Idx++]) {
764     // Load the body on-demand. Most clients won't care, because method
765     // definitions rarely show up in headers.
766     Reader.PendingBodies[MD] = GetCurrentCursorOffset();
767     HasPendingBody = true;
768     MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
769     MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
770   }
771   MD->setInstanceMethod(Record[Idx++]);
772   MD->setVariadic(Record[Idx++]);
773   MD->setPropertyAccessor(Record[Idx++]);
774   MD->setDefined(Record[Idx++]);
775   MD->IsOverriding = Record[Idx++];
776   MD->HasSkippedBody = Record[Idx++];
777 
778   MD->IsRedeclaration = Record[Idx++];
779   MD->HasRedeclaration = Record[Idx++];
780   if (MD->HasRedeclaration)
781     Reader.getContext().setObjCMethodRedeclaration(MD,
782                                        ReadDeclAs<ObjCMethodDecl>(Record, Idx));
783 
784   MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
785   MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
786   MD->SetRelatedResultType(Record[Idx++]);
787   MD->setReturnType(Reader.readType(F, Record, Idx));
788   MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
789   MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
790   unsigned NumParams = Record[Idx++];
791   SmallVector<ParmVarDecl *, 16> Params;
792   Params.reserve(NumParams);
793   for (unsigned I = 0; I != NumParams; ++I)
794     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
795 
796   MD->SelLocsKind = Record[Idx++];
797   unsigned NumStoredSelLocs = Record[Idx++];
798   SmallVector<SourceLocation, 16> SelLocs;
799   SelLocs.reserve(NumStoredSelLocs);
800   for (unsigned i = 0; i != NumStoredSelLocs; ++i)
801     SelLocs.push_back(ReadSourceLocation(Record, Idx));
802 
803   MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
804 }
805 
806 void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
807   VisitNamedDecl(CD);
808   CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
809   CD->setAtEndRange(ReadSourceRange(Record, Idx));
810 }
811 
812 void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
813   RedeclarableResult Redecl = VisitRedeclarable(ID);
814   VisitObjCContainerDecl(ID);
815   TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
816   mergeRedeclarable(ID, Redecl);
817 
818   if (Record[Idx++]) {
819     // Read the definition.
820     ID->allocateDefinitionData();
821 
822     // Set the definition data of the canonical declaration, so other
823     // redeclarations will see it.
824     ID->getCanonicalDecl()->Data = ID->Data;
825 
826     ObjCInterfaceDecl::DefinitionData &Data = ID->data();
827 
828     // Read the superclass.
829     Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
830     Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
831 
832     Data.EndLoc = ReadSourceLocation(Record, Idx);
833     Data.HasDesignatedInitializers = Record[Idx++];
834 
835     // Read the directly referenced protocols and their SourceLocations.
836     unsigned NumProtocols = Record[Idx++];
837     SmallVector<ObjCProtocolDecl *, 16> Protocols;
838     Protocols.reserve(NumProtocols);
839     for (unsigned I = 0; I != NumProtocols; ++I)
840       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
841     SmallVector<SourceLocation, 16> ProtoLocs;
842     ProtoLocs.reserve(NumProtocols);
843     for (unsigned I = 0; I != NumProtocols; ++I)
844       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
845     ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
846                         Reader.getContext());
847 
848     // Read the transitive closure of protocols referenced by this class.
849     NumProtocols = Record[Idx++];
850     Protocols.clear();
851     Protocols.reserve(NumProtocols);
852     for (unsigned I = 0; I != NumProtocols; ++I)
853       Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
854     ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
855                                           Reader.getContext());
856 
857     // We will rebuild this list lazily.
858     ID->setIvarList(nullptr);
859 
860     // Note that we have deserialized a definition.
861     Reader.PendingDefinitions.insert(ID);
862 
863     // Note that we've loaded this Objective-C class.
864     Reader.ObjCClassesLoaded.push_back(ID);
865   } else {
866     ID->Data = ID->getCanonicalDecl()->Data;
867   }
868 }
869 
870 void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
871   VisitFieldDecl(IVD);
872   IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
873   // This field will be built lazily.
874   IVD->setNextIvar(nullptr);
875   bool synth = Record[Idx++];
876   IVD->setSynthesize(synth);
877 }
878 
879 void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
880   RedeclarableResult Redecl = VisitRedeclarable(PD);
881   VisitObjCContainerDecl(PD);
882   mergeRedeclarable(PD, Redecl);
883 
884   if (Record[Idx++]) {
885     // Read the definition.
886     PD->allocateDefinitionData();
887 
888     // Set the definition data of the canonical declaration, so other
889     // redeclarations will see it.
890     PD->getCanonicalDecl()->Data = PD->Data;
891 
892     unsigned NumProtoRefs = Record[Idx++];
893     SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
894     ProtoRefs.reserve(NumProtoRefs);
895     for (unsigned I = 0; I != NumProtoRefs; ++I)
896       ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
897     SmallVector<SourceLocation, 16> ProtoLocs;
898     ProtoLocs.reserve(NumProtoRefs);
899     for (unsigned I = 0; I != NumProtoRefs; ++I)
900       ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
901     PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
902                         Reader.getContext());
903 
904     // Note that we have deserialized a definition.
905     Reader.PendingDefinitions.insert(PD);
906   } else {
907     PD->Data = PD->getCanonicalDecl()->Data;
908   }
909 }
910 
911 void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
912   VisitFieldDecl(FD);
913 }
914 
915 void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
916   VisitObjCContainerDecl(CD);
917   CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
918   CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
919   CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
920 
921   // Note that this category has been deserialized. We do this before
922   // deserializing the interface declaration, so that it will consider this
923   /// category.
924   Reader.CategoriesDeserialized.insert(CD);
925 
926   CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
927   unsigned NumProtoRefs = Record[Idx++];
928   SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
929   ProtoRefs.reserve(NumProtoRefs);
930   for (unsigned I = 0; I != NumProtoRefs; ++I)
931     ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
932   SmallVector<SourceLocation, 16> ProtoLocs;
933   ProtoLocs.reserve(NumProtoRefs);
934   for (unsigned I = 0; I != NumProtoRefs; ++I)
935     ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
936   CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
937                       Reader.getContext());
938 }
939 
940 void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
941   VisitNamedDecl(CAD);
942   CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
943 }
944 
945 void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
946   VisitNamedDecl(D);
947   D->setAtLoc(ReadSourceLocation(Record, Idx));
948   D->setLParenLoc(ReadSourceLocation(Record, Idx));
949   D->setType(GetTypeSourceInfo(Record, Idx));
950   // FIXME: stable encoding
951   D->setPropertyAttributes(
952                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
953   D->setPropertyAttributesAsWritten(
954                       (ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
955   // FIXME: stable encoding
956   D->setPropertyImplementation(
957                             (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
958   D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
959   D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
960   D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
961   D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
962   D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
963 }
964 
965 void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
966   VisitObjCContainerDecl(D);
967   D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
968 }
969 
970 void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
971   VisitObjCImplDecl(D);
972   D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
973   D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
974 }
975 
976 void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
977   VisitObjCImplDecl(D);
978   D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
979   D->SuperLoc = ReadSourceLocation(Record, Idx);
980   D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
981   D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
982   D->setHasNonZeroConstructors(Record[Idx++]);
983   D->setHasDestructors(Record[Idx++]);
984   std::tie(D->IvarInitializers, D->NumIvarInitializers) =
985       Reader.ReadCXXCtorInitializers(F, Record, Idx);
986 }
987 
988 
989 void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
990   VisitDecl(D);
991   D->setAtLoc(ReadSourceLocation(Record, Idx));
992   D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
993   D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
994   D->IvarLoc = ReadSourceLocation(Record, Idx);
995   D->setGetterCXXConstructor(Reader.ReadExpr(F));
996   D->setSetterCXXAssignment(Reader.ReadExpr(F));
997 }
998 
999 void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
1000   VisitDeclaratorDecl(FD);
1001   FD->Mutable = Record[Idx++];
1002   if (int BitWidthOrInitializer = Record[Idx++]) {
1003     FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
1004     if (FD->getDeclContext()->isRecord() && FD->getParent()->isLambda()) {
1005       // Read captured variable length array.
1006       FD->InitializerOrBitWidth.setPointer(
1007           Reader.readType(F, Record, Idx).getAsOpaquePtr());
1008     } else {
1009       FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
1010     }
1011   }
1012   if (!FD->getDeclName()) {
1013     if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
1014       Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
1015   }
1016   mergeMergeable(FD);
1017 }
1018 
1019 void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
1020   VisitDeclaratorDecl(PD);
1021   PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1022   PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1023 }
1024 
1025 void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
1026   VisitValueDecl(FD);
1027 
1028   FD->ChainingSize = Record[Idx++];
1029   assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1030   FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1031 
1032   for (unsigned I = 0; I != FD->ChainingSize; ++I)
1033     FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
1034 }
1035 
1036 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1037   RedeclarableResult Redecl = VisitRedeclarable(VD);
1038   VisitDeclaratorDecl(VD);
1039 
1040   VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
1041   VD->VarDeclBits.TSCSpec = Record[Idx++];
1042   VD->VarDeclBits.InitStyle = Record[Idx++];
1043   VD->VarDeclBits.ExceptionVar = Record[Idx++];
1044   VD->VarDeclBits.NRVOVariable = Record[Idx++];
1045   VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
1046   VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
1047   VD->VarDeclBits.IsConstexpr = Record[Idx++];
1048   VD->VarDeclBits.IsInitCapture = Record[Idx++];
1049   VD->VarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
1050   Linkage VarLinkage = Linkage(Record[Idx++]);
1051   VD->setCachedLinkage(VarLinkage);
1052 
1053   // Reconstruct the one piece of the IdentifierNamespace that we need.
1054   if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
1055       VD->getLexicalDeclContext()->isFunctionOrMethod())
1056     VD->setLocalExternDecl();
1057 
1058   if (uint64_t Val = Record[Idx++]) {
1059     VD->setInit(Reader.ReadExpr(F));
1060     if (Val > 1) {
1061       EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1062       Eval->CheckedICE = true;
1063       Eval->IsICE = Val == 3;
1064     }
1065   }
1066 
1067   enum VarKind {
1068     VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1069   };
1070   switch ((VarKind)Record[Idx++]) {
1071   case VarNotTemplate:
1072     // Only true variables (not parameters or implicit parameters) can be merged
1073     if (VD->getKind() != Decl::ParmVar && VD->getKind() != Decl::ImplicitParam &&
1074         !isa<VarTemplateSpecializationDecl>(VD))
1075       mergeRedeclarable(VD, Redecl);
1076     break;
1077   case VarTemplate:
1078     // Merged when we merge the template.
1079     VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1080     break;
1081   case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1082     VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
1083     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1084     SourceLocation POI = ReadSourceLocation(Record, Idx);
1085     Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1086     mergeRedeclarable(VD, Redecl);
1087     break;
1088   }
1089   }
1090 
1091   return Redecl;
1092 }
1093 
1094 void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
1095   VisitVarDecl(PD);
1096 }
1097 
1098 void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
1099   VisitVarDecl(PD);
1100   unsigned isObjCMethodParam = Record[Idx++];
1101   unsigned scopeDepth = Record[Idx++];
1102   unsigned scopeIndex = Record[Idx++];
1103   unsigned declQualifier = Record[Idx++];
1104   if (isObjCMethodParam) {
1105     assert(scopeDepth == 0);
1106     PD->setObjCMethodScopeInfo(scopeIndex);
1107     PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1108   } else {
1109     PD->setScopeInfo(scopeDepth, scopeIndex);
1110   }
1111   PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1112   PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1113   if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1114     PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1115 
1116   // FIXME: If this is a redeclaration of a function from another module, handle
1117   // inheritance of default arguments.
1118 }
1119 
1120 void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
1121   VisitDecl(AD);
1122   AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1123   AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1124 }
1125 
1126 void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
1127   VisitDecl(BD);
1128   BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
1129   BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
1130   unsigned NumParams = Record[Idx++];
1131   SmallVector<ParmVarDecl *, 16> Params;
1132   Params.reserve(NumParams);
1133   for (unsigned I = 0; I != NumParams; ++I)
1134     Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
1135   BD->setParams(Params);
1136 
1137   BD->setIsVariadic(Record[Idx++]);
1138   BD->setBlockMissingReturnType(Record[Idx++]);
1139   BD->setIsConversionFromLambda(Record[Idx++]);
1140 
1141   bool capturesCXXThis = Record[Idx++];
1142   unsigned numCaptures = Record[Idx++];
1143   SmallVector<BlockDecl::Capture, 16> captures;
1144   captures.reserve(numCaptures);
1145   for (unsigned i = 0; i != numCaptures; ++i) {
1146     VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
1147     unsigned flags = Record[Idx++];
1148     bool byRef = (flags & 1);
1149     bool nested = (flags & 2);
1150     Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
1151 
1152     captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1153   }
1154   BD->setCaptures(Reader.getContext(), captures.begin(),
1155                   captures.end(), capturesCXXThis);
1156 }
1157 
1158 void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
1159   VisitDecl(CD);
1160   unsigned ContextParamPos = Record[Idx++];
1161   CD->setNothrow(Record[Idx++] != 0);
1162   // Body is set by VisitCapturedStmt.
1163   for (unsigned I = 0; I < CD->NumParams; ++I) {
1164     if (I != ContextParamPos)
1165       CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1166     else
1167       CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1168   }
1169 }
1170 
1171 void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1172   VisitDecl(D);
1173   D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1174   D->setExternLoc(ReadSourceLocation(Record, Idx));
1175   D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1176 }
1177 
1178 void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
1179   VisitNamedDecl(D);
1180   D->setLocStart(ReadSourceLocation(Record, Idx));
1181 }
1182 
1183 
1184 void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
1185   RedeclarableResult Redecl = VisitRedeclarable(D);
1186   VisitNamedDecl(D);
1187   D->setInline(Record[Idx++]);
1188   D->LocStart = ReadSourceLocation(Record, Idx);
1189   D->RBraceLoc = ReadSourceLocation(Record, Idx);
1190 
1191   if (Redecl.getFirstID() == ThisDeclID) {
1192     // Each module has its own anonymous namespace, which is disjoint from
1193     // any other module's anonymous namespaces, so don't attach the anonymous
1194     // namespace at all.
1195     NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
1196     if (F.Kind != MK_Module)
1197       D->setAnonymousNamespace(Anon);
1198   } else {
1199     // Link this namespace back to the first declaration, which has already
1200     // been deserialized.
1201     D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1202   }
1203 
1204   mergeRedeclarable(D, Redecl);
1205 }
1206 
1207 void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1208   RedeclarableResult Redecl = VisitRedeclarable(D);
1209   VisitNamedDecl(D);
1210   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1211   D->IdentLoc = ReadSourceLocation(Record, Idx);
1212   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1213   D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1214   mergeRedeclarable(D, Redecl);
1215 }
1216 
1217 void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
1218   VisitNamedDecl(D);
1219   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1220   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1221   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1222   D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1223   D->setTypename(Record[Idx++]);
1224   if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1225     Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1226 }
1227 
1228 void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
1229   RedeclarableResult Redecl = VisitRedeclarable(D);
1230   VisitNamedDecl(D);
1231   D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1232   D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1233   UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1234   if (Pattern)
1235     Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1236   mergeRedeclarable(D, Redecl);
1237 }
1238 
1239 void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1240   VisitNamedDecl(D);
1241   D->UsingLoc = ReadSourceLocation(Record, Idx);
1242   D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1243   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1244   D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1245   D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1246 }
1247 
1248 void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1249   VisitValueDecl(D);
1250   D->setUsingLoc(ReadSourceLocation(Record, Idx));
1251   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1252   ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1253 }
1254 
1255 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
1256                                                UnresolvedUsingTypenameDecl *D) {
1257   VisitTypeDecl(D);
1258   D->TypenameLocation = ReadSourceLocation(Record, Idx);
1259   D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1260 }
1261 
1262 void ASTDeclReader::ReadCXXDefinitionData(
1263                                    struct CXXRecordDecl::DefinitionData &Data,
1264                                    const RecordData &Record, unsigned &Idx) {
1265   // Note: the caller has deserialized the IsLambda bit already.
1266   Data.UserDeclaredConstructor = Record[Idx++];
1267   Data.UserDeclaredSpecialMembers = Record[Idx++];
1268   Data.Aggregate = Record[Idx++];
1269   Data.PlainOldData = Record[Idx++];
1270   Data.Empty = Record[Idx++];
1271   Data.Polymorphic = Record[Idx++];
1272   Data.Abstract = Record[Idx++];
1273   Data.IsStandardLayout = Record[Idx++];
1274   Data.HasNoNonEmptyBases = Record[Idx++];
1275   Data.HasPrivateFields = Record[Idx++];
1276   Data.HasProtectedFields = Record[Idx++];
1277   Data.HasPublicFields = Record[Idx++];
1278   Data.HasMutableFields = Record[Idx++];
1279   Data.HasVariantMembers = Record[Idx++];
1280   Data.HasOnlyCMembers = Record[Idx++];
1281   Data.HasInClassInitializer = Record[Idx++];
1282   Data.HasUninitializedReferenceMember = Record[Idx++];
1283   Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
1284   Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
1285   Data.NeedOverloadResolutionForDestructor = Record[Idx++];
1286   Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
1287   Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
1288   Data.DefaultedDestructorIsDeleted = Record[Idx++];
1289   Data.HasTrivialSpecialMembers = Record[Idx++];
1290   Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
1291   Data.HasIrrelevantDestructor = Record[Idx++];
1292   Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1293   Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1294   Data.HasConstexprDefaultConstructor = Record[Idx++];
1295   Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1296   Data.ComputedVisibleConversions = Record[Idx++];
1297   Data.UserProvidedDefaultConstructor = Record[Idx++];
1298   Data.DeclaredSpecialMembers = Record[Idx++];
1299   Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
1300   Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
1301   Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
1302   Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
1303 
1304   Data.NumBases = Record[Idx++];
1305   if (Data.NumBases)
1306     Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1307   Data.NumVBases = Record[Idx++];
1308   if (Data.NumVBases)
1309     Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
1310 
1311   Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1312   Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1313   assert(Data.Definition && "Data.Definition should be already set!");
1314   Data.FirstFriend = ReadDeclID(Record, Idx);
1315 
1316   if (Data.IsLambda) {
1317     typedef LambdaCapture Capture;
1318     CXXRecordDecl::LambdaDefinitionData &Lambda
1319       = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1320     Lambda.Dependent = Record[Idx++];
1321     Lambda.IsGenericLambda = Record[Idx++];
1322     Lambda.CaptureDefault = Record[Idx++];
1323     Lambda.NumCaptures = Record[Idx++];
1324     Lambda.NumExplicitCaptures = Record[Idx++];
1325     Lambda.ManglingNumber = Record[Idx++];
1326     Lambda.ContextDecl = ReadDecl(Record, Idx);
1327     Lambda.Captures
1328       = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1329     Capture *ToCapture = Lambda.Captures;
1330     Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1331     for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1332       SourceLocation Loc = ReadSourceLocation(Record, Idx);
1333       bool IsImplicit = Record[Idx++];
1334       LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1335       switch (Kind) {
1336       case LCK_This:
1337       case LCK_VLAType:
1338         *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1339         break;
1340       case LCK_ByCopy:
1341       case LCK_ByRef:
1342         VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1343         SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1344         *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1345         break;
1346       }
1347     }
1348   }
1349 }
1350 
1351 void ASTDeclReader::MergeDefinitionData(
1352     CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &MergeDD) {
1353   assert(D->DefinitionData.getNotUpdated() &&
1354          "merging class definition into non-definition");
1355   auto &DD = *D->DefinitionData.getNotUpdated();
1356 
1357   // If the new definition has new special members, let the name lookup
1358   // code know that it needs to look in the new definition too.
1359   //
1360   // FIXME: We only need to do this if the merged definition declares members
1361   // that this definition did not declare, or if it defines members that this
1362   // definition did not define.
1363   if (MergeDD.DeclaredSpecialMembers && DD.Definition != MergeDD.Definition) {
1364     Reader.MergedLookups[DD.Definition].push_back(MergeDD.Definition);
1365     DD.Definition->setHasExternalVisibleStorage();
1366   }
1367 
1368   // FIXME: Move this out into a .def file?
1369   // FIXME: Issue a diagnostic on a mismatched MATCH_FIELD, rather than
1370   // asserting; this can happen in the case of an ODR violation.
1371   bool DetectedOdrViolation = false;
1372 #define OR_FIELD(Field) DD.Field |= MergeDD.Field;
1373 #define MATCH_FIELD(Field) \
1374     DetectedOdrViolation |= DD.Field != MergeDD.Field; \
1375     OR_FIELD(Field)
1376   MATCH_FIELD(UserDeclaredConstructor)
1377   MATCH_FIELD(UserDeclaredSpecialMembers)
1378   MATCH_FIELD(Aggregate)
1379   MATCH_FIELD(PlainOldData)
1380   MATCH_FIELD(Empty)
1381   MATCH_FIELD(Polymorphic)
1382   MATCH_FIELD(Abstract)
1383   MATCH_FIELD(IsStandardLayout)
1384   MATCH_FIELD(HasNoNonEmptyBases)
1385   MATCH_FIELD(HasPrivateFields)
1386   MATCH_FIELD(HasProtectedFields)
1387   MATCH_FIELD(HasPublicFields)
1388   MATCH_FIELD(HasMutableFields)
1389   MATCH_FIELD(HasVariantMembers)
1390   MATCH_FIELD(HasOnlyCMembers)
1391   MATCH_FIELD(HasInClassInitializer)
1392   MATCH_FIELD(HasUninitializedReferenceMember)
1393   MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
1394   MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
1395   MATCH_FIELD(NeedOverloadResolutionForDestructor)
1396   MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
1397   MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
1398   MATCH_FIELD(DefaultedDestructorIsDeleted)
1399   OR_FIELD(HasTrivialSpecialMembers)
1400   OR_FIELD(DeclaredNonTrivialSpecialMembers)
1401   MATCH_FIELD(HasIrrelevantDestructor)
1402   OR_FIELD(HasConstexprNonCopyMoveConstructor)
1403   MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
1404   OR_FIELD(HasConstexprDefaultConstructor)
1405   MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
1406   // ComputedVisibleConversions is handled below.
1407   MATCH_FIELD(UserProvidedDefaultConstructor)
1408   OR_FIELD(DeclaredSpecialMembers)
1409   MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
1410   MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
1411   OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
1412   OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
1413   MATCH_FIELD(IsLambda)
1414 #undef OR_FIELD
1415 #undef MATCH_FIELD
1416 
1417   if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
1418     DetectedOdrViolation = true;
1419   // FIXME: Issue a diagnostic if the base classes don't match when we come
1420   // to lazily load them.
1421 
1422   // FIXME: Issue a diagnostic if the list of conversion functions doesn't
1423   // match when we come to lazily load them.
1424   if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
1425     DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1426     DD.ComputedVisibleConversions = true;
1427   }
1428 
1429   // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1430   // lazily load it.
1431 
1432   if (DD.IsLambda) {
1433     // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1434     // when they occur within the body of a function template specialization).
1435   }
1436 
1437   if (DetectedOdrViolation)
1438     Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1439 }
1440 
1441 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D) {
1442   struct CXXRecordDecl::DefinitionData *DD;
1443   ASTContext &C = Reader.getContext();
1444 
1445   // Determine whether this is a lambda closure type, so that we can
1446   // allocate the appropriate DefinitionData structure.
1447   bool IsLambda = Record[Idx++];
1448   if (IsLambda)
1449     DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1450                                                      LCD_None);
1451   else
1452     DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1453 
1454   ReadCXXDefinitionData(*DD, Record, Idx);
1455 
1456   // If we're reading an update record, we might already have a definition for
1457   // this record. If so, just merge into it.
1458   if (D->DefinitionData.getNotUpdated()) {
1459     MergeDefinitionData(D, *DD);
1460     return;
1461   }
1462 
1463   // Propagate the DefinitionData pointer to the canonical declaration, so
1464   // that all other deserialized declarations will see it.
1465   CXXRecordDecl *Canon = D->getCanonicalDecl();
1466   if (Canon == D) {
1467     D->DefinitionData = DD;
1468     D->IsCompleteDefinition = true;
1469   } else if (auto *CanonDD = Canon->DefinitionData.getNotUpdated()) {
1470     // We have already deserialized a definition of this record. This
1471     // definition is no longer really a definition. Note that the pre-existing
1472     // definition is the *real* definition.
1473     Reader.MergedDeclContexts.insert(
1474         std::make_pair(D, CanonDD->Definition));
1475     D->DefinitionData = Canon->DefinitionData;
1476     D->IsCompleteDefinition = false;
1477     MergeDefinitionData(D, *DD);
1478   } else {
1479     Canon->DefinitionData = DD;
1480     D->DefinitionData = Canon->DefinitionData;
1481     D->IsCompleteDefinition = true;
1482 
1483     // Note that we have deserialized a definition. Any declarations
1484     // deserialized before this one will be be given the DefinitionData
1485     // pointer at the end.
1486     Reader.PendingDefinitions.insert(D);
1487   }
1488 }
1489 
1490 ASTDeclReader::RedeclarableResult
1491 ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
1492   RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1493 
1494   ASTContext &C = Reader.getContext();
1495 
1496   enum CXXRecKind {
1497     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1498   };
1499   switch ((CXXRecKind)Record[Idx++]) {
1500   case CXXRecNotTemplate:
1501     // Merged when we merge the folding set entry in the primary template.
1502     if (!isa<ClassTemplateSpecializationDecl>(D))
1503       mergeRedeclarable(D, Redecl);
1504     break;
1505   case CXXRecTemplate: {
1506     // Merged when we merge the template.
1507     ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1508     D->TemplateOrInstantiation = Template;
1509     if (!Template->getTemplatedDecl()) {
1510       // We've not actually loaded the ClassTemplateDecl yet, because we're
1511       // currently being loaded as its pattern. Rely on it to set up our
1512       // TypeForDecl (see VisitClassTemplateDecl).
1513       //
1514       // Beware: we do not yet know our canonical declaration, and may still
1515       // get merged once the surrounding class template has got off the ground.
1516       TypeIDForTypeDecl = 0;
1517     }
1518     break;
1519   }
1520   case CXXRecMemberSpecialization: {
1521     CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1522     TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
1523     SourceLocation POI = ReadSourceLocation(Record, Idx);
1524     MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1525     MSI->setPointOfInstantiation(POI);
1526     D->TemplateOrInstantiation = MSI;
1527     mergeRedeclarable(D, Redecl);
1528     break;
1529   }
1530   }
1531 
1532   bool WasDefinition = Record[Idx++];
1533   if (WasDefinition)
1534     ReadCXXRecordDefinition(D);
1535   else
1536     // Propagate DefinitionData pointer from the canonical declaration.
1537     D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1538 
1539   // Lazily load the key function to avoid deserializing every method so we can
1540   // compute it.
1541   if (WasDefinition) {
1542     DeclID KeyFn = ReadDeclID(Record, Idx);
1543     if (KeyFn && D->IsCompleteDefinition)
1544       // FIXME: This is wrong for the ARM ABI, where some other module may have
1545       // made this function no longer be a key function. We need an update
1546       // record or similar for that case.
1547       C.KeyFunctions[D] = KeyFn;
1548   }
1549 
1550   return Redecl;
1551 }
1552 
1553 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
1554   VisitFunctionDecl(D);
1555 
1556   unsigned NumOverridenMethods = Record[Idx++];
1557   if (D->isCanonicalDecl()) {
1558     while (NumOverridenMethods--) {
1559       // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1560       // MD may be initializing.
1561       if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1562         Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
1563     }
1564   } else {
1565     // We don't care about which declarations this used to override; we get
1566     // the relevant information from the canonical declaration.
1567     Idx += NumOverridenMethods;
1568   }
1569 }
1570 
1571 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
1572   VisitCXXMethodDecl(D);
1573 
1574   if (auto *CD = ReadDeclAs<CXXConstructorDecl>(Record, Idx))
1575     D->setInheritedConstructor(CD);
1576   D->IsExplicitSpecified = Record[Idx++];
1577   // FIXME: We should defer loading this until we need the constructor's body.
1578   std::tie(D->CtorInitializers, D->NumCtorInitializers) =
1579       Reader.ReadCXXCtorInitializers(F, Record, Idx);
1580 }
1581 
1582 void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
1583   VisitCXXMethodDecl(D);
1584 
1585   D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
1586 }
1587 
1588 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
1589   VisitCXXMethodDecl(D);
1590   D->IsExplicitSpecified = Record[Idx++];
1591 }
1592 
1593 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
1594   VisitDecl(D);
1595   D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1596   D->ImportedAndComplete.setInt(Record[Idx++]);
1597   SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
1598   for (unsigned I = 0, N = Record.back(); I != N; ++I)
1599     StoredLocs[I] = ReadSourceLocation(Record, Idx);
1600   ++Idx; // The number of stored source locations.
1601 }
1602 
1603 void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
1604   VisitDecl(D);
1605   D->setColonLoc(ReadSourceLocation(Record, Idx));
1606 }
1607 
1608 void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
1609   VisitDecl(D);
1610   if (Record[Idx++]) // hasFriendDecl
1611     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1612   else
1613     D->Friend = GetTypeSourceInfo(Record, Idx);
1614   for (unsigned i = 0; i != D->NumTPLists; ++i)
1615     D->getTPLists()[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1616   D->NextFriend = ReadDeclID(Record, Idx);
1617   D->UnsupportedFriend = (Record[Idx++] != 0);
1618   D->FriendLoc = ReadSourceLocation(Record, Idx);
1619 }
1620 
1621 void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
1622   VisitDecl(D);
1623   unsigned NumParams = Record[Idx++];
1624   D->NumParams = NumParams;
1625   D->Params = new TemplateParameterList*[NumParams];
1626   for (unsigned i = 0; i != NumParams; ++i)
1627     D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1628   if (Record[Idx++]) // HasFriendDecl
1629     D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1630   else
1631     D->Friend = GetTypeSourceInfo(Record, Idx);
1632   D->FriendLoc = ReadSourceLocation(Record, Idx);
1633 }
1634 
1635 DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
1636   VisitNamedDecl(D);
1637 
1638   DeclID PatternID = ReadDeclID(Record, Idx);
1639   NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
1640   TemplateParameterList* TemplateParams
1641       = Reader.ReadTemplateParameterList(F, Record, Idx);
1642   D->init(TemplatedDecl, TemplateParams);
1643 
1644   // FIXME: If this is a redeclaration of a template from another module, handle
1645   // inheritance of default template arguments.
1646 
1647   return PatternID;
1648 }
1649 
1650 ASTDeclReader::RedeclarableResult
1651 ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
1652   RedeclarableResult Redecl = VisitRedeclarable(D);
1653 
1654   // Make sure we've allocated the Common pointer first. We do this before
1655   // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1656   RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
1657   if (!CanonD->Common) {
1658     CanonD->Common = CanonD->newCommon(Reader.getContext());
1659     Reader.PendingDefinitions.insert(CanonD);
1660   }
1661   D->Common = CanonD->Common;
1662 
1663   // If this is the first declaration of the template, fill in the information
1664   // for the 'common' pointer.
1665   if (ThisDeclID == Redecl.getFirstID()) {
1666     if (RedeclarableTemplateDecl *RTD
1667           = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1668       assert(RTD->getKind() == D->getKind() &&
1669              "InstantiatedFromMemberTemplate kind mismatch");
1670       D->setInstantiatedFromMemberTemplate(RTD);
1671       if (Record[Idx++])
1672         D->setMemberSpecialization();
1673     }
1674   }
1675 
1676   DeclID PatternID = VisitTemplateDecl(D);
1677   D->IdentifierNamespace = Record[Idx++];
1678 
1679   mergeRedeclarable(D, Redecl, PatternID);
1680 
1681   // If we merged the template with a prior declaration chain, merge the common
1682   // pointer.
1683   // FIXME: Actually merge here, don't just overwrite.
1684   D->Common = D->getCanonicalDecl()->Common;
1685 
1686   return Redecl;
1687 }
1688 
1689 void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1690   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1691 
1692   if (ThisDeclID == Redecl.getFirstID()) {
1693     // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1694     // the specializations.
1695     SmallVector<serialization::DeclID, 2> SpecIDs;
1696     SpecIDs.push_back(0);
1697 
1698     // Specializations.
1699     unsigned Size = Record[Idx++];
1700     SpecIDs[0] += Size;
1701     for (unsigned I = 0; I != Size; ++I)
1702       SpecIDs.push_back(ReadDeclID(Record, Idx));
1703 
1704     // Partial specializations.
1705     Size = Record[Idx++];
1706     SpecIDs[0] += Size;
1707     for (unsigned I = 0; I != Size; ++I)
1708       SpecIDs.push_back(ReadDeclID(Record, Idx));
1709 
1710     ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1711     if (SpecIDs[0]) {
1712       typedef serialization::DeclID DeclID;
1713 
1714       // FIXME: Append specializations!
1715       CommonPtr->LazySpecializations
1716         = new (Reader.getContext()) DeclID [SpecIDs.size()];
1717       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1718              SpecIDs.size() * sizeof(DeclID));
1719     }
1720   }
1721 
1722   if (D->getTemplatedDecl()->TemplateOrInstantiation) {
1723     // We were loaded before our templated declaration was. We've not set up
1724     // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
1725     // it now.
1726     Reader.Context.getInjectedClassNameType(
1727         D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
1728   }
1729 }
1730 
1731 /// TODO: Unify with ClassTemplateDecl version?
1732 ///       May require unifying ClassTemplateDecl and
1733 ///        VarTemplateDecl beyond TemplateDecl...
1734 void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
1735   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1736 
1737   if (ThisDeclID == Redecl.getFirstID()) {
1738     // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
1739     // the specializations.
1740     SmallVector<serialization::DeclID, 2> SpecIDs;
1741     SpecIDs.push_back(0);
1742 
1743     // Specializations.
1744     unsigned Size = Record[Idx++];
1745     SpecIDs[0] += Size;
1746     for (unsigned I = 0; I != Size; ++I)
1747       SpecIDs.push_back(ReadDeclID(Record, Idx));
1748 
1749     // Partial specializations.
1750     Size = Record[Idx++];
1751     SpecIDs[0] += Size;
1752     for (unsigned I = 0; I != Size; ++I)
1753       SpecIDs.push_back(ReadDeclID(Record, Idx));
1754 
1755     VarTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1756     if (SpecIDs[0]) {
1757       typedef serialization::DeclID DeclID;
1758 
1759       // FIXME: Append specializations!
1760       CommonPtr->LazySpecializations =
1761           new (Reader.getContext()) DeclID[SpecIDs.size()];
1762       memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
1763              SpecIDs.size() * sizeof(DeclID));
1764     }
1765   }
1766 }
1767 
1768 ASTDeclReader::RedeclarableResult
1769 ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
1770     ClassTemplateSpecializationDecl *D) {
1771   RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1772 
1773   ASTContext &C = Reader.getContext();
1774   if (Decl *InstD = ReadDecl(Record, Idx)) {
1775     if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1776       D->SpecializedTemplate = CTD;
1777     } else {
1778       SmallVector<TemplateArgument, 8> TemplArgs;
1779       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1780       TemplateArgumentList *ArgList
1781         = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1782                                            TemplArgs.size());
1783       ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1784           = new (C) ClassTemplateSpecializationDecl::
1785                                              SpecializedPartialSpecialization();
1786       PS->PartialSpecialization
1787           = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1788       PS->TemplateArgs = ArgList;
1789       D->SpecializedTemplate = PS;
1790     }
1791   }
1792 
1793   SmallVector<TemplateArgument, 8> TemplArgs;
1794   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1795   D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
1796                                                      TemplArgs.size());
1797   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1798   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1799 
1800   bool writtenAsCanonicalDecl = Record[Idx++];
1801   if (writtenAsCanonicalDecl) {
1802     ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
1803     if (D->isCanonicalDecl()) { // It's kept in the folding set.
1804       // Set this as, or find, the canonical declaration for this specialization
1805       ClassTemplateSpecializationDecl *CanonSpec;
1806       if (ClassTemplatePartialSpecializationDecl *Partial =
1807               dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
1808         CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
1809             .GetOrInsertNode(Partial);
1810       } else {
1811         CanonSpec =
1812             CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1813       }
1814       // If there was already a canonical specialization, merge into it.
1815       if (CanonSpec != D) {
1816         mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
1817 
1818         // This declaration might be a definition. Merge with any existing
1819         // definition.
1820         if (auto *DDD = D->DefinitionData.getNotUpdated()) {
1821           if (auto *CanonDD = CanonSpec->DefinitionData.getNotUpdated()) {
1822             MergeDefinitionData(CanonSpec, *DDD);
1823             Reader.PendingDefinitions.erase(D);
1824             Reader.MergedDeclContexts.insert(
1825                 std::make_pair(D, CanonDD->Definition));
1826             D->IsCompleteDefinition = false;
1827           } else {
1828             CanonSpec->DefinitionData = D->DefinitionData;
1829           }
1830         }
1831         D->DefinitionData = CanonSpec->DefinitionData;
1832       }
1833     }
1834   }
1835 
1836   // Explicit info.
1837   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1838     ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
1839         = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
1840     ExplicitInfo->TypeAsWritten = TyInfo;
1841     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1842     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1843     D->ExplicitInfo = ExplicitInfo;
1844   }
1845 
1846   return Redecl;
1847 }
1848 
1849 void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
1850                                     ClassTemplatePartialSpecializationDecl *D) {
1851   RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
1852 
1853   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1854   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1855 
1856   // These are read/set from/to the first declaration.
1857   if (ThisDeclID == Redecl.getFirstID()) {
1858     D->InstantiatedFromMember.setPointer(
1859       ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
1860     D->InstantiatedFromMember.setInt(Record[Idx++]);
1861   }
1862 }
1863 
1864 void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
1865                                     ClassScopeFunctionSpecializationDecl *D) {
1866   VisitDecl(D);
1867   D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
1868 }
1869 
1870 void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1871   RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1872 
1873   if (ThisDeclID == Redecl.getFirstID()) {
1874     // This FunctionTemplateDecl owns a CommonPtr; read it.
1875 
1876     // Read the function specialization declaration IDs. The specializations
1877     // themselves will be loaded if they're needed.
1878     if (unsigned NumSpecs = Record[Idx++]) {
1879       // FIXME: Append specializations!
1880       FunctionTemplateDecl::Common *CommonPtr = D->getCommonPtr();
1881       CommonPtr->LazySpecializations = new (Reader.getContext())
1882           serialization::DeclID[NumSpecs + 1];
1883       CommonPtr->LazySpecializations[0] = NumSpecs;
1884       for (unsigned I = 0; I != NumSpecs; ++I)
1885         CommonPtr->LazySpecializations[I + 1] = ReadDeclID(Record, Idx);
1886     }
1887   }
1888 }
1889 
1890 /// TODO: Unify with ClassTemplateSpecializationDecl version?
1891 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
1892 ///        VarTemplate(Partial)SpecializationDecl with a new data
1893 ///        structure Template(Partial)SpecializationDecl, and
1894 ///        using Template(Partial)SpecializationDecl as input type.
1895 ASTDeclReader::RedeclarableResult
1896 ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
1897     VarTemplateSpecializationDecl *D) {
1898   RedeclarableResult Redecl = VisitVarDeclImpl(D);
1899 
1900   ASTContext &C = Reader.getContext();
1901   if (Decl *InstD = ReadDecl(Record, Idx)) {
1902     if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
1903       D->SpecializedTemplate = VTD;
1904     } else {
1905       SmallVector<TemplateArgument, 8> TemplArgs;
1906       Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1907       TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
1908           C, TemplArgs.data(), TemplArgs.size());
1909       VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
1910           new (C)
1911           VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
1912       PS->PartialSpecialization =
1913           cast<VarTemplatePartialSpecializationDecl>(InstD);
1914       PS->TemplateArgs = ArgList;
1915       D->SpecializedTemplate = PS;
1916     }
1917   }
1918 
1919   // Explicit info.
1920   if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
1921     VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
1922         new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
1923     ExplicitInfo->TypeAsWritten = TyInfo;
1924     ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
1925     ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
1926     D->ExplicitInfo = ExplicitInfo;
1927   }
1928 
1929   SmallVector<TemplateArgument, 8> TemplArgs;
1930   Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1931   D->TemplateArgs =
1932       TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
1933   D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1934   D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
1935 
1936   bool writtenAsCanonicalDecl = Record[Idx++];
1937   if (writtenAsCanonicalDecl) {
1938     VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
1939     if (D->isCanonicalDecl()) { // It's kept in the folding set.
1940       if (VarTemplatePartialSpecializationDecl *Partial =
1941               dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
1942         CanonPattern->getCommonPtr()->PartialSpecializations
1943             .GetOrInsertNode(Partial);
1944       } else {
1945         CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
1946       }
1947     }
1948   }
1949 
1950   return Redecl;
1951 }
1952 
1953 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
1954 ///       May require unifying ClassTemplate(Partial)SpecializationDecl and
1955 ///        VarTemplate(Partial)SpecializationDecl with a new data
1956 ///        structure Template(Partial)SpecializationDecl, and
1957 ///        using Template(Partial)SpecializationDecl as input type.
1958 void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
1959     VarTemplatePartialSpecializationDecl *D) {
1960   RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
1961 
1962   D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
1963   D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
1964 
1965   // These are read/set from/to the first declaration.
1966   if (ThisDeclID == Redecl.getFirstID()) {
1967     D->InstantiatedFromMember.setPointer(
1968         ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
1969     D->InstantiatedFromMember.setInt(Record[Idx++]);
1970   }
1971 }
1972 
1973 void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
1974   VisitTypeDecl(D);
1975 
1976   D->setDeclaredWithTypename(Record[Idx++]);
1977 
1978   bool Inherited = Record[Idx++];
1979   TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
1980   D->setDefaultArgument(DefArg, Inherited);
1981 }
1982 
1983 void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
1984   VisitDeclaratorDecl(D);
1985   // TemplateParmPosition.
1986   D->setDepth(Record[Idx++]);
1987   D->setPosition(Record[Idx++]);
1988   if (D->isExpandedParameterPack()) {
1989     void **Data = reinterpret_cast<void **>(D + 1);
1990     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1991       Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
1992       Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
1993     }
1994   } else {
1995     // Rest of NonTypeTemplateParmDecl.
1996     D->ParameterPack = Record[Idx++];
1997     if (Record[Idx++]) {
1998       Expr *DefArg = Reader.ReadExpr(F);
1999       bool Inherited = Record[Idx++];
2000       D->setDefaultArgument(DefArg, Inherited);
2001    }
2002   }
2003 }
2004 
2005 void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
2006   VisitTemplateDecl(D);
2007   // TemplateParmPosition.
2008   D->setDepth(Record[Idx++]);
2009   D->setPosition(Record[Idx++]);
2010   if (D->isExpandedParameterPack()) {
2011     void **Data = reinterpret_cast<void **>(D + 1);
2012     for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2013          I != N; ++I)
2014       Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
2015   } else {
2016     // Rest of TemplateTemplateParmDecl.
2017     TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
2018     bool IsInherited = Record[Idx++];
2019     D->setDefaultArgument(Arg, IsInherited);
2020     D->ParameterPack = Record[Idx++];
2021   }
2022 }
2023 
2024 void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2025   VisitRedeclarableTemplateDecl(D);
2026 }
2027 
2028 void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
2029   VisitDecl(D);
2030   D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
2031   D->AssertExprAndFailed.setInt(Record[Idx++]);
2032   D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
2033   D->RParenLoc = ReadSourceLocation(Record, Idx);
2034 }
2035 
2036 void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
2037   VisitDecl(D);
2038 }
2039 
2040 std::pair<uint64_t, uint64_t>
2041 ASTDeclReader::VisitDeclContext(DeclContext *DC) {
2042   uint64_t LexicalOffset = Record[Idx++];
2043   uint64_t VisibleOffset = Record[Idx++];
2044   return std::make_pair(LexicalOffset, VisibleOffset);
2045 }
2046 
2047 template <typename T>
2048 ASTDeclReader::RedeclarableResult
2049 ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
2050   DeclID FirstDeclID = ReadDeclID(Record, Idx);
2051 
2052   // 0 indicates that this declaration was the only declaration of its entity,
2053   // and is used for space optimization.
2054   if (FirstDeclID == 0)
2055     FirstDeclID = ThisDeclID;
2056 
2057   T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
2058   if (FirstDecl != D) {
2059     // We delay loading of the redeclaration chain to avoid deeply nested calls.
2060     // We temporarily set the first (canonical) declaration as the previous one
2061     // which is the one that matters and mark the real previous DeclID to be
2062     // loaded & attached later on.
2063     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2064   }
2065 
2066   // Note that this declaration has been deserialized.
2067   Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
2068 
2069   // The result structure takes care to note that we need to load the
2070   // other declaration chains for this ID.
2071   return RedeclarableResult(Reader, FirstDeclID,
2072                             static_cast<T *>(D)->getKind());
2073 }
2074 
2075 /// \brief Attempts to merge the given declaration (D) with another declaration
2076 /// of the same entity.
2077 template<typename T>
2078 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
2079                                       RedeclarableResult &Redecl,
2080                                       DeclID TemplatePatternID) {
2081   T *D = static_cast<T*>(DBase);
2082   T *DCanon = D->getCanonicalDecl();
2083   if (D != DCanon &&
2084       // IDs < NUM_PREDEF_DECL_IDS are not loaded from an AST file.
2085       Redecl.getFirstID() >= NUM_PREDEF_DECL_IDS &&
2086       (!Reader.getContext().getLangOpts().Modules ||
2087        Reader.getOwningModuleFile(DCanon) == Reader.getOwningModuleFile(D))) {
2088     // All redeclarations between this declaration and its originally-canonical
2089     // declaration get pulled in when we load DCanon; we don't need to
2090     // perform any more merging now.
2091     Redecl.suppress();
2092   }
2093 
2094   // If modules are not available, there is no reason to perform this merge.
2095   if (!Reader.getContext().getLangOpts().Modules)
2096     return;
2097 
2098   if (FindExistingResult ExistingRes = findExisting(D))
2099     if (T *Existing = ExistingRes)
2100       mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
2101 }
2102 
2103 /// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
2104 /// We use this to put code in a template that will only be valid for certain
2105 /// instantiations.
2106 template<typename T> static T assert_cast(T t) { return t; }
2107 template<typename T> static T assert_cast(...) {
2108   llvm_unreachable("bad assert_cast");
2109 }
2110 
2111 /// \brief Merge together the pattern declarations from two template
2112 /// declarations.
2113 void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
2114                                          RedeclarableTemplateDecl *Existing,
2115                                          DeclID DsID) {
2116   auto *DPattern = D->getTemplatedDecl();
2117   auto *ExistingPattern = Existing->getTemplatedDecl();
2118   RedeclarableResult Result(Reader, DPattern->getCanonicalDecl()->getGlobalID(),
2119                             DPattern->getKind());
2120   if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2121     // Merge with any existing definition.
2122     // FIXME: This is duplicated in several places. Refactor.
2123     auto *ExistingClass =
2124         cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2125     if (auto *DDD = DClass->DefinitionData.getNotUpdated()) {
2126       if (auto *ExistingDD = ExistingClass->DefinitionData.getNotUpdated()) {
2127         MergeDefinitionData(ExistingClass, *DDD);
2128         Reader.PendingDefinitions.erase(DClass);
2129         Reader.MergedDeclContexts.insert(
2130             std::make_pair(DClass, ExistingDD->Definition));
2131         DClass->IsCompleteDefinition = false;
2132       } else {
2133         ExistingClass->DefinitionData = DClass->DefinitionData;
2134       }
2135     }
2136     DClass->DefinitionData = ExistingClass->DefinitionData;
2137 
2138     return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2139                              Result);
2140   }
2141   if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2142     return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2143                              Result);
2144   if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2145     return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2146   if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
2147     return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
2148                              Result);
2149   llvm_unreachable("merged an unknown kind of redeclarable template");
2150 }
2151 
2152 /// \brief Attempts to merge the given declaration (D) with another declaration
2153 /// of the same entity.
2154 template<typename T>
2155 void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
2156                                       RedeclarableResult &Redecl,
2157                                       DeclID TemplatePatternID) {
2158   T *D = static_cast<T*>(DBase);
2159   T *ExistingCanon = Existing->getCanonicalDecl();
2160   T *DCanon = D->getCanonicalDecl();
2161   if (ExistingCanon != DCanon) {
2162     assert(DCanon->getGlobalID() == Redecl.getFirstID());
2163 
2164     // Have our redeclaration link point back at the canonical declaration
2165     // of the existing declaration, so that this declaration has the
2166     // appropriate canonical declaration.
2167     D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2168 
2169     // When we merge a namespace, update its pointer to the first namespace.
2170     if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
2171       Namespace->AnonOrFirstNamespaceAndInline.setPointer(
2172           assert_cast<NamespaceDecl*>(ExistingCanon));
2173 
2174     // When we merge a template, merge its pattern.
2175     if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2176       mergeTemplatePattern(
2177           DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
2178           TemplatePatternID);
2179 
2180     // If this declaration was the canonical declaration, make a note of
2181     // that. We accept the linear algorithm here because the number of
2182     // unique canonical declarations of an entity should always be tiny.
2183     if (DCanon == D) {
2184       SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
2185       if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
2186             == Merged.end())
2187         Merged.push_back(Redecl.getFirstID());
2188     }
2189   }
2190 }
2191 
2192 /// \brief Attempts to merge the given declaration (D) with another declaration
2193 /// of the same entity, for the case where the entity is not actually
2194 /// redeclarable. This happens, for instance, when merging the fields of
2195 /// identical class definitions from two different modules.
2196 template<typename T>
2197 void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
2198   // If modules are not available, there is no reason to perform this merge.
2199   if (!Reader.getContext().getLangOpts().Modules)
2200     return;
2201 
2202   // ODR-based merging is only performed in C++. In C, identically-named things
2203   // in different translation units are not redeclarations (but may still have
2204   // compatible types).
2205   if (!Reader.getContext().getLangOpts().CPlusPlus)
2206     return;
2207 
2208   if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
2209     if (T *Existing = ExistingRes)
2210       Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
2211                                           Existing->getCanonicalDecl());
2212 }
2213 
2214 void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
2215   VisitDecl(D);
2216   unsigned NumVars = D->varlist_size();
2217   SmallVector<Expr *, 16> Vars;
2218   Vars.reserve(NumVars);
2219   for (unsigned i = 0; i != NumVars; ++i) {
2220     Vars.push_back(Reader.ReadExpr(F));
2221   }
2222   D->setVars(Vars);
2223 }
2224 
2225 //===----------------------------------------------------------------------===//
2226 // Attribute Reading
2227 //===----------------------------------------------------------------------===//
2228 
2229 /// \brief Reads attributes from the current stream position.
2230 void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
2231                                const RecordData &Record, unsigned &Idx) {
2232   for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
2233     Attr *New = nullptr;
2234     attr::Kind Kind = (attr::Kind)Record[Idx++];
2235     SourceRange Range = ReadSourceRange(F, Record, Idx);
2236 
2237 #include "clang/Serialization/AttrPCHRead.inc"
2238 
2239     assert(New && "Unable to decode attribute?");
2240     Attrs.push_back(New);
2241   }
2242 }
2243 
2244 //===----------------------------------------------------------------------===//
2245 // ASTReader Implementation
2246 //===----------------------------------------------------------------------===//
2247 
2248 /// \brief Note that we have loaded the declaration with the given
2249 /// Index.
2250 ///
2251 /// This routine notes that this declaration has already been loaded,
2252 /// so that future GetDecl calls will return this declaration rather
2253 /// than trying to load a new declaration.
2254 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2255   assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2256   DeclsLoaded[Index] = D;
2257 }
2258 
2259 
2260 /// \brief Determine whether the consumer will be interested in seeing
2261 /// this declaration (via HandleTopLevelDecl).
2262 ///
2263 /// This routine should return true for anything that might affect
2264 /// code generation, e.g., inline function definitions, Objective-C
2265 /// declarations with metadata, etc.
2266 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2267   // An ObjCMethodDecl is never considered as "interesting" because its
2268   // implementation container always is.
2269 
2270   if (isa<FileScopeAsmDecl>(D) ||
2271       isa<ObjCProtocolDecl>(D) ||
2272       isa<ObjCImplDecl>(D) ||
2273       isa<ImportDecl>(D))
2274     return true;
2275   if (VarDecl *Var = dyn_cast<VarDecl>(D))
2276     return Var->isFileVarDecl() &&
2277            Var->isThisDeclarationADefinition() == VarDecl::Definition;
2278   if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
2279     return Func->doesThisDeclarationHaveABody() || HasBody;
2280 
2281   return false;
2282 }
2283 
2284 /// \brief Get the correct cursor and offset for loading a declaration.
2285 ASTReader::RecordLocation
2286 ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
2287   // See if there's an override.
2288   DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
2289   if (It != ReplacedDecls.end()) {
2290     RawLocation = It->second.RawLoc;
2291     return RecordLocation(It->second.Mod, It->second.Offset);
2292   }
2293 
2294   GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
2295   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
2296   ModuleFile *M = I->second;
2297   const DeclOffset &
2298     DOffs =  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
2299   RawLocation = DOffs.Loc;
2300   return RecordLocation(M, DOffs.BitOffset);
2301 }
2302 
2303 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2304   ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
2305     = GlobalBitOffsetsMap.find(GlobalOffset);
2306 
2307   assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2308   return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2309 }
2310 
2311 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2312   return LocalOffset + M.GlobalBitOffset;
2313 }
2314 
2315 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2316                                         const TemplateParameterList *Y);
2317 
2318 /// \brief Determine whether two template parameters are similar enough
2319 /// that they may be used in declarations of the same template.
2320 static bool isSameTemplateParameter(const NamedDecl *X,
2321                                     const NamedDecl *Y) {
2322   if (X->getKind() != Y->getKind())
2323     return false;
2324 
2325   if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2326     const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2327     return TX->isParameterPack() == TY->isParameterPack();
2328   }
2329 
2330   if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
2331     const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
2332     return TX->isParameterPack() == TY->isParameterPack() &&
2333            TX->getASTContext().hasSameType(TX->getType(), TY->getType());
2334   }
2335 
2336   const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
2337   const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
2338   return TX->isParameterPack() == TY->isParameterPack() &&
2339          isSameTemplateParameterList(TX->getTemplateParameters(),
2340                                      TY->getTemplateParameters());
2341 }
2342 
2343 /// \brief Determine whether two template parameter lists are similar enough
2344 /// that they may be used in declarations of the same template.
2345 static bool isSameTemplateParameterList(const TemplateParameterList *X,
2346                                         const TemplateParameterList *Y) {
2347   if (X->size() != Y->size())
2348     return false;
2349 
2350   for (unsigned I = 0, N = X->size(); I != N; ++I)
2351     if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2352       return false;
2353 
2354   return true;
2355 }
2356 
2357 /// \brief Determine whether the two declarations refer to the same entity.
2358 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2359   assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2360 
2361   if (X == Y)
2362     return true;
2363 
2364   // Must be in the same context.
2365   if (!X->getDeclContext()->getRedeclContext()->Equals(
2366          Y->getDeclContext()->getRedeclContext()))
2367     return false;
2368 
2369   // Two typedefs refer to the same entity if they have the same underlying
2370   // type.
2371   if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
2372     if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
2373       return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
2374                                             TypedefY->getUnderlyingType());
2375 
2376   // Must have the same kind.
2377   if (X->getKind() != Y->getKind())
2378     return false;
2379 
2380   // Objective-C classes and protocols with the same name always match.
2381   if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2382     return true;
2383 
2384   if (isa<ClassTemplateSpecializationDecl>(X)) {
2385     // No need to handle these here: we merge them when adding them to the
2386     // template.
2387     return false;
2388   }
2389 
2390   // Compatible tags match.
2391   if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
2392     TagDecl *TagY = cast<TagDecl>(Y);
2393     return (TagX->getTagKind() == TagY->getTagKind()) ||
2394       ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
2395         TagX->getTagKind() == TTK_Interface) &&
2396        (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
2397         TagY->getTagKind() == TTK_Interface));
2398   }
2399 
2400   // Functions with the same type and linkage match.
2401   // FIXME: This needs to cope with merging of prototyped/non-prototyped
2402   // functions, etc.
2403   if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
2404     FunctionDecl *FuncY = cast<FunctionDecl>(Y);
2405     return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2406       FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2407   }
2408 
2409   // Variables with the same type and linkage match.
2410   if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
2411     VarDecl *VarY = cast<VarDecl>(Y);
2412     return (VarX->getLinkageInternal() == VarY->getLinkageInternal()) &&
2413       VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
2414   }
2415 
2416   // Namespaces with the same name and inlinedness match.
2417   if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
2418     NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
2419     return NamespaceX->isInline() == NamespaceY->isInline();
2420   }
2421 
2422   // Identical template names and kinds match if their template parameter lists
2423   // and patterns match.
2424   if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
2425     TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
2426     return isSameEntity(TemplateX->getTemplatedDecl(),
2427                         TemplateY->getTemplatedDecl()) &&
2428            isSameTemplateParameterList(TemplateX->getTemplateParameters(),
2429                                        TemplateY->getTemplateParameters());
2430   }
2431 
2432   // Fields with the same name and the same type match.
2433   if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
2434     FieldDecl *FDY = cast<FieldDecl>(Y);
2435     // FIXME: Also check the bitwidth is odr-equivalent, if any.
2436     return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
2437   }
2438 
2439   // Enumerators with the same name match.
2440   if (isa<EnumConstantDecl>(X))
2441     // FIXME: Also check the value is odr-equivalent.
2442     return true;
2443 
2444   // Using shadow declarations with the same target match.
2445   if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
2446     UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
2447     return USX->getTargetDecl() == USY->getTargetDecl();
2448   }
2449 
2450   // Namespace alias definitions with the same target match.
2451   if (auto *NAX = dyn_cast<NamespaceAliasDecl>(X)) {
2452     auto *NAY = cast<NamespaceAliasDecl>(Y);
2453     return NAX->getNamespace()->Equals(NAY->getNamespace());
2454   }
2455 
2456   // FIXME: Many other cases to implement.
2457   return false;
2458 }
2459 
2460 /// Find the context in which we should search for previous declarations when
2461 /// looking for declarations to merge.
2462 static DeclContext *getPrimaryContextForMerging(DeclContext *DC) {
2463   if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2464     return ND->getOriginalNamespace();
2465 
2466   // There is one tricky case here: if DC is a class with no definition, then
2467   // we're merging a declaration whose definition is added by an update record,
2468   // but we've not yet loaded that update record. In this case, we use the
2469   // canonical declaration for merging until we get a real definition.
2470   // FIXME: When we add a definition, we may need to move the partial lookup
2471   // information from the canonical declaration onto the chosen definition.
2472   if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
2473     return RD->getPrimaryContext();
2474 
2475   if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2476     return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2477                                                       : nullptr;
2478 
2479   return nullptr;
2480 }
2481 
2482 ASTDeclReader::FindExistingResult::~FindExistingResult() {
2483   if (!AddResult || Existing)
2484     return;
2485 
2486   DeclarationName Name = New->getDeclName();
2487   DeclContext *DC = New->getDeclContext()->getRedeclContext();
2488   if (TypedefNameForLinkage) {
2489     Reader.ImportedTypedefNamesForLinkage.insert(
2490         std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
2491   } else if (!Name) {
2492     assert(needsAnonymousDeclarationNumber(New));
2493     setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
2494                                AnonymousDeclNumber, New);
2495   } else if (DC->isTranslationUnit() && Reader.SemaObj) {
2496     Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, Name);
2497   } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2498     // Add the declaration to its redeclaration context so later merging
2499     // lookups will find it.
2500     MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
2501   }
2502 }
2503 
2504 /// Find the declaration that should be merged into, given the declaration found
2505 /// by name lookup. If we're merging an anonymous declaration within a typedef,
2506 /// we need a matching typedef, and we merge with the type inside it.
2507 static NamedDecl *getDeclForMerging(NamedDecl *Found,
2508                                     bool IsTypedefNameForLinkage) {
2509   if (!IsTypedefNameForLinkage)
2510     return Found;
2511 
2512   // If we found a typedef declaration that gives a name to some other
2513   // declaration, then we want that inner declaration. Declarations from
2514   // AST files are handled via ImportedTypedefNamesForLinkage.
2515   if (Found->isFromASTFile()) return 0;
2516   if (auto *TND = dyn_cast<TypedefNameDecl>(Found)) {
2517     if (auto *TT = TND->getTypeSourceInfo()->getType()->getAs<TagType>())
2518       if (TT->getDecl()->getTypedefNameForAnonDecl() == TND)
2519         return TT->getDecl();
2520   }
2521 
2522   return 0;
2523 }
2524 
2525 NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
2526                                                      DeclContext *DC,
2527                                                      unsigned Index) {
2528   // If the lexical context has been merged, look into the now-canonical
2529   // definition.
2530   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2531     DC = Merged;
2532 
2533   // If we've seen this before, return the canonical declaration.
2534   auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2535   if (Index < Previous.size() && Previous[Index])
2536     return Previous[Index];
2537 
2538   // If this is the first time, but we have parsed a declaration of the context,
2539   // build the anonymous declaration list from the parsed declaration.
2540   if (!cast<Decl>(DC)->isFromASTFile()) {
2541     unsigned Index = 0;
2542     for (Decl *LexicalD : DC->decls()) {
2543       auto *ND = dyn_cast<NamedDecl>(LexicalD);
2544       if (!ND || !needsAnonymousDeclarationNumber(ND))
2545         continue;
2546       if (Previous.size() == Index)
2547         Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
2548       else
2549         Previous[Index] = cast<NamedDecl>(ND->getCanonicalDecl());
2550       ++Index;
2551     }
2552   }
2553 
2554   return Index < Previous.size() ? Previous[Index] : nullptr;
2555 }
2556 
2557 void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
2558                                                DeclContext *DC, unsigned Index,
2559                                                NamedDecl *D) {
2560   if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2561     DC = Merged;
2562 
2563   auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2564   if (Index >= Previous.size())
2565     Previous.resize(Index + 1);
2566   if (!Previous[Index])
2567     Previous[Index] = D;
2568 }
2569 
2570 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2571   DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
2572                                                : D->getDeclName();
2573 
2574   if (!Name && !needsAnonymousDeclarationNumber(D)) {
2575     // Don't bother trying to find unnamed declarations that are in
2576     // unmergeable contexts.
2577     FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
2578                               AnonymousDeclNumber, TypedefNameForLinkage);
2579     // FIXME: We may still need to pull in the redeclaration chain; there can
2580     // be redeclarations via 'decltype'.
2581     Result.suppress();
2582     return Result;
2583   }
2584 
2585   // FIXME: Bail out for non-canonical declarations. We will have performed any
2586   // necessary merging already.
2587 
2588   DeclContext *DC = D->getDeclContext()->getRedeclContext();
2589   if (TypedefNameForLinkage) {
2590     auto It = Reader.ImportedTypedefNamesForLinkage.find(
2591         std::make_pair(DC, TypedefNameForLinkage));
2592     if (It != Reader.ImportedTypedefNamesForLinkage.end())
2593       if (isSameEntity(It->second, D))
2594         return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
2595                                   TypedefNameForLinkage);
2596     // Go on to check in other places in case an existing typedef name
2597     // was not imported.
2598   }
2599 
2600   if (!Name) {
2601     // This is an anonymous declaration that we may need to merge. Look it up
2602     // in its context by number.
2603     assert(needsAnonymousDeclarationNumber(D));
2604     if (auto *Existing = getAnonymousDeclForMerging(
2605             Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
2606       if (isSameEntity(Existing, D))
2607         return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2608                                   TypedefNameForLinkage);
2609   } else if (DC->isTranslationUnit() && Reader.SemaObj) {
2610     IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
2611 
2612     // Temporarily consider the identifier to be up-to-date. We don't want to
2613     // cause additional lookups here.
2614     class UpToDateIdentifierRAII {
2615       IdentifierInfo *II;
2616       bool WasOutToDate;
2617 
2618     public:
2619       explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2620         : II(II), WasOutToDate(false)
2621       {
2622         if (II) {
2623           WasOutToDate = II->isOutOfDate();
2624           if (WasOutToDate)
2625             II->setOutOfDate(false);
2626         }
2627       }
2628 
2629       ~UpToDateIdentifierRAII() {
2630         if (WasOutToDate)
2631           II->setOutOfDate(true);
2632       }
2633     } UpToDate(Name.getAsIdentifierInfo());
2634 
2635     for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2636                                    IEnd = IdResolver.end();
2637          I != IEnd; ++I) {
2638       if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2639         if (isSameEntity(Existing, D))
2640           return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2641                                     TypedefNameForLinkage);
2642     }
2643   } else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
2644     DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
2645     for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
2646       if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2647         if (isSameEntity(Existing, D))
2648           return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2649                                     TypedefNameForLinkage);
2650     }
2651   } else {
2652     // Not in a mergeable context.
2653     return FindExistingResult(Reader);
2654   }
2655 
2656   // If this declaration is from a merged context, make a note that we need to
2657   // check that the canonical definition of that context contains the decl.
2658   //
2659   // FIXME: We should do something similar if we merge two definitions of the
2660   // same template specialization into the same CXXRecordDecl.
2661   auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
2662   if (MergedDCIt != Reader.MergedDeclContexts.end() &&
2663       MergedDCIt->second == D->getDeclContext())
2664     Reader.PendingOdrMergeChecks.push_back(D);
2665 
2666   return FindExistingResult(Reader, D, /*Existing=*/nullptr,
2667                             AnonymousDeclNumber, TypedefNameForLinkage);
2668 }
2669 
2670 template<typename DeclT>
2671 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
2672                                            Redeclarable<DeclT> *D,
2673                                            Decl *Previous) {
2674   D->RedeclLink.setPrevious(cast<DeclT>(Previous));
2675 }
2676 namespace clang {
2677 template<>
2678 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
2679                                            Redeclarable<FunctionDecl> *D,
2680                                            Decl *Previous) {
2681   FunctionDecl *FD = static_cast<FunctionDecl*>(D);
2682   FunctionDecl *PrevFD = cast<FunctionDecl>(Previous);
2683 
2684   FD->RedeclLink.setPrevious(PrevFD);
2685 
2686   // If the previous declaration is an inline function declaration, then this
2687   // declaration is too.
2688   if (PrevFD->IsInline != FD->IsInline) {
2689     // FIXME: [dcl.fct.spec]p4:
2690     //   If a function with external linkage is declared inline in one
2691     //   translation unit, it shall be declared inline in all translation
2692     //   units in which it appears.
2693     //
2694     // Be careful of this case:
2695     //
2696     // module A:
2697     //   template<typename T> struct X { void f(); };
2698     //   template<typename T> inline void X<T>::f() {}
2699     //
2700     // module B instantiates the declaration of X<int>::f
2701     // module C instantiates the definition of X<int>::f
2702     //
2703     // If module B and C are merged, we do not have a violation of this rule.
2704     FD->IsInline = true;
2705   }
2706 
2707   // If this declaration has an unresolved exception specification but the
2708   // previous declaration had a resolved one, resolve the exception
2709   // specification now.
2710   auto *FPT = FD->getType()->getAs<FunctionProtoType>();
2711   auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
2712   if (FPT && PrevFPT &&
2713       isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
2714       !isUnresolvedExceptionSpec(PrevFPT->getExceptionSpecType())) {
2715     FunctionProtoType::ExtProtoInfo EPI = PrevFPT->getExtProtoInfo();
2716     FD->setType(Reader.Context.getFunctionType(
2717         FPT->getReturnType(), FPT->getParamTypes(),
2718         FPT->getExtProtoInfo().withExceptionSpec(EPI.ExceptionSpec)));
2719   }
2720 }
2721 }
2722 void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
2723   llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
2724 }
2725 
2726 void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
2727                                        Decl *Previous) {
2728   assert(D && Previous);
2729 
2730   switch (D->getKind()) {
2731 #define ABSTRACT_DECL(TYPE)
2732 #define DECL(TYPE, BASE)                                           \
2733   case Decl::TYPE:                                                 \
2734     attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous); \
2735     break;
2736 #include "clang/AST/DeclNodes.inc"
2737   }
2738 
2739   // If the declaration was visible in one module, a redeclaration of it in
2740   // another module remains visible even if it wouldn't be visible by itself.
2741   //
2742   // FIXME: In this case, the declaration should only be visible if a module
2743   //        that makes it visible has been imported.
2744   D->IdentifierNamespace |=
2745       Previous->IdentifierNamespace &
2746       (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
2747 
2748   // If the previous declaration is marked as used, then this declaration should
2749   // be too.
2750   if (Previous->Used)
2751     D->Used = true;
2752 }
2753 
2754 template<typename DeclT>
2755 void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
2756   D->RedeclLink.setLatest(cast<DeclT>(Latest));
2757 }
2758 void ASTDeclReader::attachLatestDeclImpl(...) {
2759   llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
2760 }
2761 
2762 void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
2763   assert(D && Latest);
2764 
2765   switch (D->getKind()) {
2766 #define ABSTRACT_DECL(TYPE)
2767 #define DECL(TYPE, BASE)                                  \
2768   case Decl::TYPE:                                        \
2769     attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
2770     break;
2771 #include "clang/AST/DeclNodes.inc"
2772   }
2773 }
2774 
2775 template<typename DeclT>
2776 void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
2777   D->RedeclLink.markIncomplete();
2778 }
2779 void ASTDeclReader::markIncompleteDeclChainImpl(...) {
2780   llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
2781 }
2782 
2783 void ASTReader::markIncompleteDeclChain(Decl *D) {
2784   switch (D->getKind()) {
2785 #define ABSTRACT_DECL(TYPE)
2786 #define DECL(TYPE, BASE)                                             \
2787   case Decl::TYPE:                                                   \
2788     ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
2789     break;
2790 #include "clang/AST/DeclNodes.inc"
2791   }
2792 }
2793 
2794 ASTReader::MergedDeclsMap::iterator
2795 ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
2796   // If we don't have any stored merged declarations, just look in the
2797   // merged declarations set.
2798   StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
2799   if (StoredPos == StoredMergedDecls.end())
2800     return MergedDecls.find(Canon);
2801 
2802   // Append the stored merged declarations to the merged declarations set.
2803   MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
2804   if (Pos == MergedDecls.end())
2805     Pos = MergedDecls.insert(std::make_pair(Canon,
2806                                             SmallVector<DeclID, 2>())).first;
2807   Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
2808   StoredMergedDecls.erase(StoredPos);
2809 
2810   // Sort and uniquify the set of merged declarations.
2811   llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
2812   Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
2813                     Pos->second.end());
2814   return Pos;
2815 }
2816 
2817 /// \brief Read the declaration at the given offset from the AST file.
2818 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
2819   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
2820   unsigned RawLocation = 0;
2821   RecordLocation Loc = DeclCursorForID(ID, RawLocation);
2822   llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
2823   // Keep track of where we are in the stream, then jump back there
2824   // after reading this declaration.
2825   SavedStreamPosition SavedPosition(DeclsCursor);
2826 
2827   ReadingKindTracker ReadingKind(Read_Decl, *this);
2828 
2829   // Note that we are loading a declaration record.
2830   Deserializing ADecl(this);
2831 
2832   DeclsCursor.JumpToBit(Loc.Offset);
2833   RecordData Record;
2834   unsigned Code = DeclsCursor.ReadCode();
2835   unsigned Idx = 0;
2836   ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
2837 
2838   Decl *D = nullptr;
2839   switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
2840   case DECL_CONTEXT_LEXICAL:
2841   case DECL_CONTEXT_VISIBLE:
2842     llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
2843   case DECL_TYPEDEF:
2844     D = TypedefDecl::CreateDeserialized(Context, ID);
2845     break;
2846   case DECL_TYPEALIAS:
2847     D = TypeAliasDecl::CreateDeserialized(Context, ID);
2848     break;
2849   case DECL_ENUM:
2850     D = EnumDecl::CreateDeserialized(Context, ID);
2851     break;
2852   case DECL_RECORD:
2853     D = RecordDecl::CreateDeserialized(Context, ID);
2854     break;
2855   case DECL_ENUM_CONSTANT:
2856     D = EnumConstantDecl::CreateDeserialized(Context, ID);
2857     break;
2858   case DECL_FUNCTION:
2859     D = FunctionDecl::CreateDeserialized(Context, ID);
2860     break;
2861   case DECL_LINKAGE_SPEC:
2862     D = LinkageSpecDecl::CreateDeserialized(Context, ID);
2863     break;
2864   case DECL_LABEL:
2865     D = LabelDecl::CreateDeserialized(Context, ID);
2866     break;
2867   case DECL_NAMESPACE:
2868     D = NamespaceDecl::CreateDeserialized(Context, ID);
2869     break;
2870   case DECL_NAMESPACE_ALIAS:
2871     D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
2872     break;
2873   case DECL_USING:
2874     D = UsingDecl::CreateDeserialized(Context, ID);
2875     break;
2876   case DECL_USING_SHADOW:
2877     D = UsingShadowDecl::CreateDeserialized(Context, ID);
2878     break;
2879   case DECL_USING_DIRECTIVE:
2880     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
2881     break;
2882   case DECL_UNRESOLVED_USING_VALUE:
2883     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
2884     break;
2885   case DECL_UNRESOLVED_USING_TYPENAME:
2886     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
2887     break;
2888   case DECL_CXX_RECORD:
2889     D = CXXRecordDecl::CreateDeserialized(Context, ID);
2890     break;
2891   case DECL_CXX_METHOD:
2892     D = CXXMethodDecl::CreateDeserialized(Context, ID);
2893     break;
2894   case DECL_CXX_CONSTRUCTOR:
2895     D = CXXConstructorDecl::CreateDeserialized(Context, ID);
2896     break;
2897   case DECL_CXX_DESTRUCTOR:
2898     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
2899     break;
2900   case DECL_CXX_CONVERSION:
2901     D = CXXConversionDecl::CreateDeserialized(Context, ID);
2902     break;
2903   case DECL_ACCESS_SPEC:
2904     D = AccessSpecDecl::CreateDeserialized(Context, ID);
2905     break;
2906   case DECL_FRIEND:
2907     D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2908     break;
2909   case DECL_FRIEND_TEMPLATE:
2910     D = FriendTemplateDecl::CreateDeserialized(Context, ID);
2911     break;
2912   case DECL_CLASS_TEMPLATE:
2913     D = ClassTemplateDecl::CreateDeserialized(Context, ID);
2914     break;
2915   case DECL_CLASS_TEMPLATE_SPECIALIZATION:
2916     D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2917     break;
2918   case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
2919     D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2920     break;
2921   case DECL_VAR_TEMPLATE:
2922     D = VarTemplateDecl::CreateDeserialized(Context, ID);
2923     break;
2924   case DECL_VAR_TEMPLATE_SPECIALIZATION:
2925     D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
2926     break;
2927   case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
2928     D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
2929     break;
2930   case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
2931     D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
2932     break;
2933   case DECL_FUNCTION_TEMPLATE:
2934     D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
2935     break;
2936   case DECL_TEMPLATE_TYPE_PARM:
2937     D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
2938     break;
2939   case DECL_NON_TYPE_TEMPLATE_PARM:
2940     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
2941     break;
2942   case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
2943     D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
2944     break;
2945   case DECL_TEMPLATE_TEMPLATE_PARM:
2946     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
2947     break;
2948   case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
2949     D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
2950                                                      Record[Idx++]);
2951     break;
2952   case DECL_TYPE_ALIAS_TEMPLATE:
2953     D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
2954     break;
2955   case DECL_STATIC_ASSERT:
2956     D = StaticAssertDecl::CreateDeserialized(Context, ID);
2957     break;
2958   case DECL_OBJC_METHOD:
2959     D = ObjCMethodDecl::CreateDeserialized(Context, ID);
2960     break;
2961   case DECL_OBJC_INTERFACE:
2962     D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
2963     break;
2964   case DECL_OBJC_IVAR:
2965     D = ObjCIvarDecl::CreateDeserialized(Context, ID);
2966     break;
2967   case DECL_OBJC_PROTOCOL:
2968     D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
2969     break;
2970   case DECL_OBJC_AT_DEFS_FIELD:
2971     D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
2972     break;
2973   case DECL_OBJC_CATEGORY:
2974     D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
2975     break;
2976   case DECL_OBJC_CATEGORY_IMPL:
2977     D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
2978     break;
2979   case DECL_OBJC_IMPLEMENTATION:
2980     D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
2981     break;
2982   case DECL_OBJC_COMPATIBLE_ALIAS:
2983     D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
2984     break;
2985   case DECL_OBJC_PROPERTY:
2986     D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
2987     break;
2988   case DECL_OBJC_PROPERTY_IMPL:
2989     D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
2990     break;
2991   case DECL_FIELD:
2992     D = FieldDecl::CreateDeserialized(Context, ID);
2993     break;
2994   case DECL_INDIRECTFIELD:
2995     D = IndirectFieldDecl::CreateDeserialized(Context, ID);
2996     break;
2997   case DECL_VAR:
2998     D = VarDecl::CreateDeserialized(Context, ID);
2999     break;
3000   case DECL_IMPLICIT_PARAM:
3001     D = ImplicitParamDecl::CreateDeserialized(Context, ID);
3002     break;
3003   case DECL_PARM_VAR:
3004     D = ParmVarDecl::CreateDeserialized(Context, ID);
3005     break;
3006   case DECL_FILE_SCOPE_ASM:
3007     D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
3008     break;
3009   case DECL_BLOCK:
3010     D = BlockDecl::CreateDeserialized(Context, ID);
3011     break;
3012   case DECL_MS_PROPERTY:
3013     D = MSPropertyDecl::CreateDeserialized(Context, ID);
3014     break;
3015   case DECL_CAPTURED:
3016     D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3017     break;
3018   case DECL_CXX_BASE_SPECIFIERS:
3019     Error("attempt to read a C++ base-specifier record as a declaration");
3020     return nullptr;
3021   case DECL_IMPORT:
3022     // Note: last entry of the ImportDecl record is the number of stored source
3023     // locations.
3024     D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
3025     break;
3026   case DECL_OMP_THREADPRIVATE:
3027     D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3028     break;
3029   case DECL_EMPTY:
3030     D = EmptyDecl::CreateDeserialized(Context, ID);
3031     break;
3032   }
3033 
3034   assert(D && "Unknown declaration reading AST file");
3035   LoadedDecl(Index, D);
3036   // Set the DeclContext before doing any deserialization, to make sure internal
3037   // calls to Decl::getASTContext() by Decl's methods will find the
3038   // TranslationUnitDecl without crashing.
3039   D->setDeclContext(Context.getTranslationUnitDecl());
3040   Reader.Visit(D);
3041 
3042   // If this declaration is also a declaration context, get the
3043   // offsets for its tables of lexical and visible declarations.
3044   if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
3045     // FIXME: This should really be
3046     //     DeclContext *LookupDC = DC->getPrimaryContext();
3047     // but that can walk the redeclaration chain, which might not work yet.
3048     DeclContext *LookupDC = DC;
3049     if (isa<NamespaceDecl>(DC))
3050       LookupDC = DC->getPrimaryContext();
3051     std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
3052     if (Offsets.first || Offsets.second) {
3053       if (Offsets.first != 0)
3054         DC->setHasExternalLexicalStorage(true);
3055       if (Offsets.second != 0)
3056         LookupDC->setHasExternalVisibleStorage(true);
3057       if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
3058                                  Loc.F->DeclContextInfos[DC]))
3059         return nullptr;
3060     }
3061 
3062     // Now add the pending visible updates for this decl context, if it has any.
3063     DeclContextVisibleUpdatesPending::iterator I =
3064         PendingVisibleUpdates.find(ID);
3065     if (I != PendingVisibleUpdates.end()) {
3066       // There are updates. This means the context has external visible
3067       // storage, even if the original stored version didn't.
3068       LookupDC->setHasExternalVisibleStorage(true);
3069       for (const auto &Update : I->second) {
3070         DeclContextInfo &Info = Update.second->DeclContextInfos[DC];
3071         delete Info.NameLookupTableData;
3072         Info.NameLookupTableData = Update.first;
3073       }
3074       PendingVisibleUpdates.erase(I);
3075     }
3076   }
3077   assert(Idx == Record.size());
3078 
3079   // Load any relevant update records.
3080   PendingUpdateRecords.push_back(std::make_pair(ID, D));
3081 
3082   // Load the categories after recursive loading is finished.
3083   if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
3084     if (Class->isThisDeclarationADefinition())
3085       loadObjCCategories(ID, Class);
3086 
3087   // If we have deserialized a declaration that has a definition the
3088   // AST consumer might need to know about, queue it.
3089   // We don't pass it to the consumer immediately because we may be in recursive
3090   // loading, and some declarations may still be initializing.
3091   if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
3092     InterestingDecls.push_back(D);
3093 
3094   return D;
3095 }
3096 
3097 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
3098   // The declaration may have been modified by files later in the chain.
3099   // If this is the case, read the record containing the updates from each file
3100   // and pass it to ASTDeclReader to make the modifications.
3101   DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
3102   if (UpdI != DeclUpdateOffsets.end()) {
3103     FileOffsetsTy &UpdateOffsets = UpdI->second;
3104     bool WasInteresting = isConsumerInterestedIn(D, false);
3105     for (FileOffsetsTy::iterator
3106          I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
3107       ModuleFile *F = I->first;
3108       uint64_t Offset = I->second;
3109       llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3110       SavedStreamPosition SavedPosition(Cursor);
3111       Cursor.JumpToBit(Offset);
3112       RecordData Record;
3113       unsigned Code = Cursor.ReadCode();
3114       unsigned RecCode = Cursor.readRecord(Code, Record);
3115       (void)RecCode;
3116       assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
3117 
3118       unsigned Idx = 0;
3119       ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
3120       Reader.UpdateDecl(D, *F, Record);
3121 
3122       // We might have made this declaration interesting. If so, remember that
3123       // we need to hand it off to the consumer.
3124       if (!WasInteresting &&
3125           isConsumerInterestedIn(D, Reader.hasPendingBody())) {
3126         InterestingDecls.push_back(D);
3127         WasInteresting = true;
3128       }
3129     }
3130   }
3131 }
3132 
3133 namespace {
3134   /// \brief Module visitor class that finds all of the redeclarations of a
3135   ///
3136   class RedeclChainVisitor {
3137     ASTReader &Reader;
3138     SmallVectorImpl<DeclID> &SearchDecls;
3139     llvm::SmallPtrSetImpl<Decl *> &Deserialized;
3140     GlobalDeclID CanonID;
3141     SmallVector<Decl *, 4> Chain;
3142 
3143   public:
3144     RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
3145                        llvm::SmallPtrSetImpl<Decl *> &Deserialized,
3146                        GlobalDeclID CanonID)
3147       : Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
3148         CanonID(CanonID) {
3149       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
3150         addToChain(Reader.GetDecl(SearchDecls[I]));
3151     }
3152 
3153     static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
3154       if (Preorder)
3155         return false;
3156 
3157       return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
3158     }
3159 
3160     void addToChain(Decl *D) {
3161       if (!D)
3162         return;
3163 
3164       if (Deserialized.erase(D))
3165         Chain.push_back(D);
3166     }
3167 
3168     void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
3169       // Map global ID of the first declaration down to the local ID
3170       // used in this module file.
3171       DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
3172       if (!ID)
3173         return;
3174 
3175       // Perform a binary search to find the local redeclarations for this
3176       // declaration (if any).
3177       const LocalRedeclarationsInfo Compare = { ID, 0 };
3178       const LocalRedeclarationsInfo *Result
3179         = std::lower_bound(M.RedeclarationsMap,
3180                            M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
3181                            Compare);
3182       if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
3183           Result->FirstID != ID) {
3184         // If we have a previously-canonical singleton declaration that was
3185         // merged into another redeclaration chain, create a trivial chain
3186         // for this single declaration so that it will get wired into the
3187         // complete redeclaration chain.
3188         if (GlobalID != CanonID &&
3189             GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
3190             GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
3191           addToChain(Reader.GetDecl(GlobalID));
3192         }
3193 
3194         return;
3195       }
3196 
3197       // Dig out all of the redeclarations.
3198       unsigned Offset = Result->Offset;
3199       unsigned N = M.RedeclarationChains[Offset];
3200       M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
3201       for (unsigned I = 0; I != N; ++I)
3202         addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
3203     }
3204 
3205     bool visit(ModuleFile &M) {
3206       // Visit each of the declarations.
3207       for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
3208         searchForID(M, SearchDecls[I]);
3209       // FIXME: If none of the SearchDecls had local IDs in this module, can
3210       // we avoid searching any ancestor module files?
3211       return false;
3212     }
3213 
3214     ArrayRef<Decl *> getChain() const {
3215       return Chain;
3216     }
3217   };
3218 }
3219 
3220 void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
3221   Decl *D = GetDecl(ID);
3222   Decl *CanonDecl = D->getCanonicalDecl();
3223 
3224   // Determine the set of declaration IDs we'll be searching for.
3225   SmallVector<DeclID, 1> SearchDecls;
3226   GlobalDeclID CanonID = 0;
3227   if (D == CanonDecl) {
3228     SearchDecls.push_back(ID); // Always first.
3229     CanonID = ID;
3230   }
3231   MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
3232   if (MergedPos != MergedDecls.end())
3233     SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
3234 
3235   // Build up the list of redeclarations.
3236   RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
3237   ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
3238 
3239   // Retrieve the chains.
3240   ArrayRef<Decl *> Chain = Visitor.getChain();
3241   if (Chain.empty())
3242     return;
3243 
3244   // Hook up the chains.
3245   Decl *MostRecent = CanonDecl->getMostRecentDecl();
3246   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3247     if (Chain[I] == CanonDecl)
3248       continue;
3249 
3250     ASTDeclReader::attachPreviousDecl(*this, Chain[I], MostRecent);
3251     MostRecent = Chain[I];
3252   }
3253 
3254   ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3255 }
3256 
3257 namespace {
3258   /// \brief Given an ObjC interface, goes through the modules and links to the
3259   /// interface all the categories for it.
3260   class ObjCCategoriesVisitor {
3261     ASTReader &Reader;
3262     serialization::GlobalDeclID InterfaceID;
3263     ObjCInterfaceDecl *Interface;
3264     llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
3265     unsigned PreviousGeneration;
3266     ObjCCategoryDecl *Tail;
3267     llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3268 
3269     void add(ObjCCategoryDecl *Cat) {
3270       // Only process each category once.
3271       if (!Deserialized.erase(Cat))
3272         return;
3273 
3274       // Check for duplicate categories.
3275       if (Cat->getDeclName()) {
3276         ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3277         if (Existing &&
3278             Reader.getOwningModuleFile(Existing)
3279                                           != Reader.getOwningModuleFile(Cat)) {
3280           // FIXME: We should not warn for duplicates in diamond:
3281           //
3282           //   MT     //
3283           //  /  \    //
3284           // ML  MR   //
3285           //  \  /    //
3286           //   MB     //
3287           //
3288           // If there are duplicates in ML/MR, there will be warning when
3289           // creating MB *and* when importing MB. We should not warn when
3290           // importing.
3291           Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3292             << Interface->getDeclName() << Cat->getDeclName();
3293           Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3294         } else if (!Existing) {
3295           // Record this category.
3296           Existing = Cat;
3297         }
3298       }
3299 
3300       // Add this category to the end of the chain.
3301       if (Tail)
3302         ASTDeclReader::setNextObjCCategory(Tail, Cat);
3303       else
3304         Interface->setCategoryListRaw(Cat);
3305       Tail = Cat;
3306     }
3307 
3308   public:
3309     ObjCCategoriesVisitor(ASTReader &Reader,
3310                           serialization::GlobalDeclID InterfaceID,
3311                           ObjCInterfaceDecl *Interface,
3312                         llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
3313                           unsigned PreviousGeneration)
3314       : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3315         Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3316         Tail(nullptr)
3317     {
3318       // Populate the name -> category map with the set of known categories.
3319       for (auto *Cat : Interface->known_categories()) {
3320         if (Cat->getDeclName())
3321           NameCategoryMap[Cat->getDeclName()] = Cat;
3322 
3323         // Keep track of the tail of the category list.
3324         Tail = Cat;
3325       }
3326     }
3327 
3328     static bool visit(ModuleFile &M, void *UserData) {
3329       return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
3330     }
3331 
3332     bool visit(ModuleFile &M) {
3333       // If we've loaded all of the category information we care about from
3334       // this module file, we're done.
3335       if (M.Generation <= PreviousGeneration)
3336         return true;
3337 
3338       // Map global ID of the definition down to the local ID used in this
3339       // module file. If there is no such mapping, we'll find nothing here
3340       // (or in any module it imports).
3341       DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3342       if (!LocalID)
3343         return true;
3344 
3345       // Perform a binary search to find the local redeclarations for this
3346       // declaration (if any).
3347       const ObjCCategoriesInfo Compare = { LocalID, 0 };
3348       const ObjCCategoriesInfo *Result
3349         = std::lower_bound(M.ObjCCategoriesMap,
3350                            M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
3351                            Compare);
3352       if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3353           Result->DefinitionID != LocalID) {
3354         // We didn't find anything. If the class definition is in this module
3355         // file, then the module files it depends on cannot have any categories,
3356         // so suppress further lookup.
3357         return Reader.isDeclIDFromModule(InterfaceID, M);
3358       }
3359 
3360       // We found something. Dig out all of the categories.
3361       unsigned Offset = Result->Offset;
3362       unsigned N = M.ObjCCategories[Offset];
3363       M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3364       for (unsigned I = 0; I != N; ++I)
3365         add(cast_or_null<ObjCCategoryDecl>(
3366               Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3367       return true;
3368     }
3369   };
3370 }
3371 
3372 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3373                                    ObjCInterfaceDecl *D,
3374                                    unsigned PreviousGeneration) {
3375   ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3376                                 PreviousGeneration);
3377   ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
3378 }
3379 
3380 namespace {
3381 /// Iterator over the redeclarations of a declaration that have already
3382 /// been merged into the same redeclaration chain.
3383 template<typename DeclT>
3384 class MergedRedeclIterator {
3385   DeclT *Start, *Canonical, *Current;
3386 public:
3387   MergedRedeclIterator() : Current(nullptr) {}
3388   MergedRedeclIterator(DeclT *Start)
3389       : Start(Start), Canonical(nullptr), Current(Start) {}
3390 
3391   DeclT *operator*() { return Current; }
3392 
3393   MergedRedeclIterator &operator++() {
3394     if (Current->isFirstDecl()) {
3395       Canonical = Current;
3396       Current = Current->getMostRecentDecl();
3397     } else
3398       Current = Current->getPreviousDecl();
3399 
3400     // If we started in the merged portion, we'll reach our start position
3401     // eventually. Otherwise, we'll never reach it, but the second declaration
3402     // we reached was the canonical declaration, so stop when we see that one
3403     // again.
3404     if (Current == Start || Current == Canonical)
3405       Current = nullptr;
3406     return *this;
3407   }
3408 
3409   friend bool operator!=(const MergedRedeclIterator &A,
3410                          const MergedRedeclIterator &B) {
3411     return A.Current != B.Current;
3412   }
3413 };
3414 }
3415 template<typename DeclT>
3416 llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
3417   return llvm::iterator_range<MergedRedeclIterator<DeclT>>(
3418       MergedRedeclIterator<DeclT>(D),
3419       MergedRedeclIterator<DeclT>());
3420 }
3421 
3422 template<typename DeclT, typename Fn>
3423 static void forAllLaterRedecls(DeclT *D, Fn F) {
3424   F(D);
3425 
3426   // Check whether we've already merged D into its redeclaration chain.
3427   // MostRecent may or may not be nullptr if D has not been merged. If
3428   // not, walk the merged redecl chain and see if it's there.
3429   auto *MostRecent = D->getMostRecentDecl();
3430   bool Found = false;
3431   for (auto *Redecl = MostRecent; Redecl && !Found;
3432        Redecl = Redecl->getPreviousDecl())
3433     Found = (Redecl == D);
3434 
3435   // If this declaration is merged, apply the functor to all later decls.
3436   if (Found) {
3437     for (auto *Redecl = MostRecent; Redecl != D;
3438          Redecl = Redecl->getPreviousDecl())
3439       F(Redecl);
3440   }
3441 }
3442 
3443 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3444                                const RecordData &Record) {
3445   while (Idx < Record.size()) {
3446     switch ((DeclUpdateKind)Record[Idx++]) {
3447     case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
3448       // FIXME: If we also have an update record for instantiating the
3449       // definition of D, we need that to happen before we get here.
3450       Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3451       assert(MD && "couldn't read decl from update record");
3452       // FIXME: We should call addHiddenDecl instead, to add the member
3453       // to its DeclContext.
3454       cast<CXXRecordDecl>(D)->addedMember(MD);
3455       break;
3456     }
3457 
3458     case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
3459       // It will be added to the template's specializations set when loaded.
3460       (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3461       break;
3462 
3463     case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
3464       NamespaceDecl *Anon
3465         = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3466 
3467       // Each module has its own anonymous namespace, which is disjoint from
3468       // any other module's anonymous namespaces, so don't attach the anonymous
3469       // namespace at all.
3470       if (ModuleFile.Kind != MK_Module) {
3471         if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3472           TU->setAnonymousNamespace(Anon);
3473         else
3474           cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3475       }
3476       break;
3477     }
3478 
3479     case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
3480       cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3481           Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3482       break;
3483 
3484     case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
3485       FunctionDecl *FD = cast<FunctionDecl>(D);
3486       if (Reader.PendingBodies[FD]) {
3487         // FIXME: Maybe check for ODR violations.
3488         // It's safe to stop now because this update record is always last.
3489         return;
3490       }
3491 
3492       if (Record[Idx++]) {
3493         // Maintain AST consistency: any later redeclarations of this function
3494         // are inline if this one is. (We might have merged another declaration
3495         // into this one.)
3496         forAllLaterRedecls(FD, [](FunctionDecl *FD) {
3497           FD->setImplicitlyInline();
3498         });
3499       }
3500       FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3501       if (auto *CD = dyn_cast<CXXConstructorDecl>(FD))
3502         std::tie(CD->CtorInitializers, CD->NumCtorInitializers) =
3503             Reader.ReadCXXCtorInitializers(ModuleFile, Record, Idx);
3504       if (auto *DD = dyn_cast<CXXDestructorDecl>(FD))
3505         // FIXME: Check consistency.
3506         DD->setOperatorDelete(Reader.ReadDeclAs<FunctionDecl>(ModuleFile,
3507                                                               Record, Idx));
3508       // Store the offset of the body so we can lazily load it later.
3509       Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3510       HasPendingBody = true;
3511       assert(Idx == Record.size() && "lazy body must be last");
3512       break;
3513     }
3514 
3515     case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
3516       auto *RD = cast<CXXRecordDecl>(D);
3517       bool HadDefinition = RD->getDefinition();
3518       ReadCXXRecordDefinition(RD);
3519       // Visible update is handled separately.
3520       uint64_t LexicalOffset = Record[Idx++];
3521       if (!HadDefinition && LexicalOffset) {
3522         RD->setHasExternalLexicalStorage(true);
3523         Reader.ReadDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3524                                           std::make_pair(LexicalOffset, 0),
3525                                           ModuleFile.DeclContextInfos[RD]);
3526         Reader.PendingDefinitions.insert(RD);
3527       }
3528 
3529       auto TSK = (TemplateSpecializationKind)Record[Idx++];
3530       SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3531       if (MemberSpecializationInfo *MSInfo =
3532               RD->getMemberSpecializationInfo()) {
3533         MSInfo->setTemplateSpecializationKind(TSK);
3534         MSInfo->setPointOfInstantiation(POI);
3535       } else {
3536         ClassTemplateSpecializationDecl *Spec =
3537             cast<ClassTemplateSpecializationDecl>(RD);
3538         Spec->setTemplateSpecializationKind(TSK);
3539         Spec->setPointOfInstantiation(POI);
3540 
3541         if (Record[Idx++]) {
3542           auto PartialSpec =
3543               ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3544           SmallVector<TemplateArgument, 8> TemplArgs;
3545           Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3546           auto *TemplArgList = TemplateArgumentList::CreateCopy(
3547               Reader.getContext(), TemplArgs.data(), TemplArgs.size());
3548 
3549           // FIXME: If we already have a partial specialization set,
3550           // check that it matches.
3551           if (!Spec->getSpecializedTemplateOrPartial()
3552                    .is<ClassTemplatePartialSpecializationDecl *>())
3553             Spec->setInstantiationOf(PartialSpec, TemplArgList);
3554         }
3555       }
3556 
3557       RD->setTagKind((TagTypeKind)Record[Idx++]);
3558       RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3559       RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3560       RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3561 
3562       if (Record[Idx++]) {
3563         AttrVec Attrs;
3564         Reader.ReadAttributes(F, Attrs, Record, Idx);
3565         D->setAttrsImpl(Attrs, Reader.getContext());
3566       }
3567       break;
3568     }
3569 
3570     case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
3571       // FIXME: This doesn't send the right notifications if there are
3572       // ASTMutationListeners other than an ASTWriter.
3573       FunctionProtoType::ExceptionSpecInfo ESI;
3574       SmallVector<QualType, 8> ExceptionStorage;
3575       Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
3576       for (auto *Redecl : merged_redecls(D)) {
3577         auto *FD = cast<FunctionDecl>(Redecl);
3578         auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3579         if (!isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
3580           // AST invariant: if any exception spec in the redecl chain is
3581           // resolved, all are resolved. We don't need to go any further.
3582           // FIXME: If the exception spec is resolved, check that it matches.
3583           break;
3584         }
3585         FD->setType(Reader.Context.getFunctionType(
3586             FPT->getReturnType(), FPT->getParamTypes(),
3587             FPT->getExtProtoInfo().withExceptionSpec(ESI)));
3588       }
3589       break;
3590     }
3591 
3592     case UPD_CXX_DEDUCED_RETURN_TYPE: {
3593       // FIXME: Also do this when merging redecls.
3594       QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
3595       for (auto *Redecl : merged_redecls(D)) {
3596         // FIXME: If the return type is already deduced, check that it matches.
3597         FunctionDecl *FD = cast<FunctionDecl>(Redecl);
3598         Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
3599       }
3600       break;
3601     }
3602 
3603     case UPD_DECL_MARKED_USED: {
3604       // FIXME: This doesn't send the right notifications if there are
3605       // ASTMutationListeners other than an ASTWriter.
3606 
3607       // Maintain AST consistency: any later redeclarations are used too.
3608       forAllLaterRedecls(D, [](Decl *D) { D->Used = true; });
3609       break;
3610     }
3611 
3612     case UPD_MANGLING_NUMBER:
3613       Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3614       break;
3615 
3616     case UPD_STATIC_LOCAL_NUMBER:
3617       Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
3618       break;
3619     }
3620   }
3621 }
3622