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