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