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