1 //===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- 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 defines the ASTImporter class which imports AST nodes from one
11 //  context into another context.
12 //
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTImporter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTDiagnostic.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/AST/TypeVisitor.h"
22 #include "clang/Basic/FileManager.h"
23 #include "clang/Basic/SourceManager.h"
24 #include "llvm/Support/MemoryBuffer.h"
25 #include <deque>
26 
27 namespace clang {
28   class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
29                           public DeclVisitor<ASTNodeImporter, Decl *>,
30                           public StmtVisitor<ASTNodeImporter, Stmt *> {
31     ASTImporter &Importer;
32 
33   public:
34     explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
35 
36     using TypeVisitor<ASTNodeImporter, QualType>::Visit;
37     using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
38     using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
39 
40     // Importing types
41     QualType VisitType(const Type *T);
42     QualType VisitAtomicType(const AtomicType *T);
43     QualType VisitBuiltinType(const BuiltinType *T);
44     QualType VisitDecayedType(const DecayedType *T);
45     QualType VisitComplexType(const ComplexType *T);
46     QualType VisitPointerType(const PointerType *T);
47     QualType VisitBlockPointerType(const BlockPointerType *T);
48     QualType VisitLValueReferenceType(const LValueReferenceType *T);
49     QualType VisitRValueReferenceType(const RValueReferenceType *T);
50     QualType VisitMemberPointerType(const MemberPointerType *T);
51     QualType VisitConstantArrayType(const ConstantArrayType *T);
52     QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
53     QualType VisitVariableArrayType(const VariableArrayType *T);
54     // FIXME: DependentSizedArrayType
55     // FIXME: DependentSizedExtVectorType
56     QualType VisitVectorType(const VectorType *T);
57     QualType VisitExtVectorType(const ExtVectorType *T);
58     QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
59     QualType VisitFunctionProtoType(const FunctionProtoType *T);
60     // FIXME: UnresolvedUsingType
61     QualType VisitParenType(const ParenType *T);
62     QualType VisitTypedefType(const TypedefType *T);
63     QualType VisitTypeOfExprType(const TypeOfExprType *T);
64     // FIXME: DependentTypeOfExprType
65     QualType VisitTypeOfType(const TypeOfType *T);
66     QualType VisitDecltypeType(const DecltypeType *T);
67     QualType VisitUnaryTransformType(const UnaryTransformType *T);
68     QualType VisitAutoType(const AutoType *T);
69     QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
70     // FIXME: DependentDecltypeType
71     QualType VisitRecordType(const RecordType *T);
72     QualType VisitEnumType(const EnumType *T);
73     QualType VisitAttributedType(const AttributedType *T);
74     QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
75     QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
76     QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
77     QualType VisitElaboratedType(const ElaboratedType *T);
78     // FIXME: DependentNameType
79     // FIXME: DependentTemplateSpecializationType
80     QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
81     QualType VisitObjCObjectType(const ObjCObjectType *T);
82     QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
83 
84     // Importing declarations
85     bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
86                          DeclContext *&LexicalDC, DeclarationName &Name,
87                          NamedDecl *&ToD, SourceLocation &Loc);
88     void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
89     void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
90                                   DeclarationNameInfo& To);
91     void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
92 
93     bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
94 
95     typedef DesignatedInitExpr::Designator Designator;
96     Designator ImportDesignator(const Designator &D);
97 
98 
99     /// \brief What we should import from the definition.
100     enum ImportDefinitionKind {
101       /// \brief Import the default subset of the definition, which might be
102       /// nothing (if minimal import is set) or might be everything (if minimal
103       /// import is not set).
104       IDK_Default,
105       /// \brief Import everything.
106       IDK_Everything,
107       /// \brief Import only the bare bones needed to establish a valid
108       /// DeclContext.
109       IDK_Basic
110     };
111 
112     bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
113       return IDK == IDK_Everything ||
114              (IDK == IDK_Default && !Importer.isMinimalImport());
115     }
116 
117     bool ImportDefinition(RecordDecl *From, RecordDecl *To,
118                           ImportDefinitionKind Kind = IDK_Default);
119     bool ImportDefinition(VarDecl *From, VarDecl *To,
120                           ImportDefinitionKind Kind = IDK_Default);
121     bool ImportDefinition(EnumDecl *From, EnumDecl *To,
122                           ImportDefinitionKind Kind = IDK_Default);
123     bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
124                           ImportDefinitionKind Kind = IDK_Default);
125     bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
126                           ImportDefinitionKind Kind = IDK_Default);
127     TemplateParameterList *ImportTemplateParameterList(
128                                                  TemplateParameterList *Params);
129     TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
130     TemplateArgumentLoc ImportTemplateArgumentLoc(
131         const TemplateArgumentLoc &TALoc, bool &Error);
132     bool ImportTemplateArguments(const TemplateArgument *FromArgs,
133                                  unsigned NumFromArgs,
134                                SmallVectorImpl<TemplateArgument> &ToArgs);
135     bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
136                            bool Complain = true);
137     bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
138                            bool Complain = true);
139     bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
140     bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
141     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
142     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
143     Decl *VisitDecl(Decl *D);
144     Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
145     Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
146     Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
147     Decl *VisitNamespaceDecl(NamespaceDecl *D);
148     Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
149     Decl *VisitTypedefDecl(TypedefDecl *D);
150     Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
151     Decl *VisitLabelDecl(LabelDecl *D);
152     Decl *VisitEnumDecl(EnumDecl *D);
153     Decl *VisitRecordDecl(RecordDecl *D);
154     Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
155     Decl *VisitFunctionDecl(FunctionDecl *D);
156     Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
157     Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
158     Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
159     Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
160     Decl *VisitFieldDecl(FieldDecl *D);
161     Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
162     Decl *VisitFriendDecl(FriendDecl *D);
163     Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
164     Decl *VisitVarDecl(VarDecl *D);
165     Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
166     Decl *VisitParmVarDecl(ParmVarDecl *D);
167     Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
168     Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
169     Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
170     Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
171     Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
172 
173     ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
174     Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
175     Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
176     Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
177     Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
178     Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
179     Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
180     Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
181     Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
182     Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
183     Decl *VisitClassTemplateSpecializationDecl(
184                                             ClassTemplateSpecializationDecl *D);
185     Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
186     Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
187 
188     // Importing statements
189     DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
190 
191     Stmt *VisitStmt(Stmt *S);
192     Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
193     Stmt *VisitDeclStmt(DeclStmt *S);
194     Stmt *VisitNullStmt(NullStmt *S);
195     Stmt *VisitCompoundStmt(CompoundStmt *S);
196     Stmt *VisitCaseStmt(CaseStmt *S);
197     Stmt *VisitDefaultStmt(DefaultStmt *S);
198     Stmt *VisitLabelStmt(LabelStmt *S);
199     Stmt *VisitAttributedStmt(AttributedStmt *S);
200     Stmt *VisitIfStmt(IfStmt *S);
201     Stmt *VisitSwitchStmt(SwitchStmt *S);
202     Stmt *VisitWhileStmt(WhileStmt *S);
203     Stmt *VisitDoStmt(DoStmt *S);
204     Stmt *VisitForStmt(ForStmt *S);
205     Stmt *VisitGotoStmt(GotoStmt *S);
206     Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
207     Stmt *VisitContinueStmt(ContinueStmt *S);
208     Stmt *VisitBreakStmt(BreakStmt *S);
209     Stmt *VisitReturnStmt(ReturnStmt *S);
210     // FIXME: MSAsmStmt
211     // FIXME: SEHExceptStmt
212     // FIXME: SEHFinallyStmt
213     // FIXME: SEHTryStmt
214     // FIXME: SEHLeaveStmt
215     // FIXME: CapturedStmt
216     Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
217     Stmt *VisitCXXTryStmt(CXXTryStmt *S);
218     Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
219     // FIXME: MSDependentExistsStmt
220     Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
221     Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
222     Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
223     Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
224     Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
225     Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
226     Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
227 
228     // Importing expressions
229     Expr *VisitExpr(Expr *E);
230     Expr *VisitVAArgExpr(VAArgExpr *E);
231     Expr *VisitGNUNullExpr(GNUNullExpr *E);
232     Expr *VisitPredefinedExpr(PredefinedExpr *E);
233     Expr *VisitDeclRefExpr(DeclRefExpr *E);
234     Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
235     Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
236     Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
237     Expr *VisitIntegerLiteral(IntegerLiteral *E);
238     Expr *VisitFloatingLiteral(FloatingLiteral *E);
239     Expr *VisitCharacterLiteral(CharacterLiteral *E);
240     Expr *VisitStringLiteral(StringLiteral *E);
241     Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
242     Expr *VisitAtomicExpr(AtomicExpr *E);
243     Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
244     Expr *VisitParenExpr(ParenExpr *E);
245     Expr *VisitParenListExpr(ParenListExpr *E);
246     Expr *VisitStmtExpr(StmtExpr *E);
247     Expr *VisitUnaryOperator(UnaryOperator *E);
248     Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
249     Expr *VisitBinaryOperator(BinaryOperator *E);
250     Expr *VisitConditionalOperator(ConditionalOperator *E);
251     Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
252     Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
253     Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
254     Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
255     Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
256     Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
257     Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
258     Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
259     Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
260     Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
261     Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
262     Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
263     Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
264     Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
265     Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
266     Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
267     Expr *VisitCXXNewExpr(CXXNewExpr *CE);
268     Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
269     Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
270     Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
271     Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
272     Expr *VisitCXXThisExpr(CXXThisExpr *E);
273     Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
274     Expr *VisitMemberExpr(MemberExpr *E);
275     Expr *VisitCallExpr(CallExpr *E);
276     Expr *VisitInitListExpr(InitListExpr *E);
277     Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
278     Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
279     Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
280     Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
281     Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
282 
283 
284     template<typename IIter, typename OIter>
285     void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
286       typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
287       ASTImporter &ImporterRef = Importer;
288       std::transform(Ibegin, Iend, Obegin,
289                      [&ImporterRef](ItemT From) -> ItemT {
290                        return ImporterRef.Import(From);
291                      });
292     }
293 
294     template<typename IIter, typename OIter>
295     bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
296       typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
297       ASTImporter &ImporterRef = Importer;
298       bool Failed = false;
299       std::transform(Ibegin, Iend, Obegin,
300                      [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
301                        ItemT *To = cast_or_null<ItemT>(
302                              ImporterRef.Import(From));
303                        if (!To && From)
304                          Failed = true;
305                        return To;
306                      });
307       return Failed;
308     }
309 
310     template<typename InContainerTy, typename OutContainerTy>
311     bool ImportContainerChecked(const InContainerTy &InContainer,
312                                 OutContainerTy &OutContainer) {
313       return ImportArrayChecked(InContainer.begin(), InContainer.end(),
314                                 OutContainer.begin());
315     }
316 
317     template<typename InContainerTy, typename OIter>
318     bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
319       return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
320     }
321   };
322 }
323 
324 using namespace clang;
325 
326 //----------------------------------------------------------------------------
327 // Structural Equivalence
328 //----------------------------------------------------------------------------
329 
330 namespace {
331   struct StructuralEquivalenceContext {
332     /// \brief AST contexts for which we are checking structural equivalence.
333     ASTContext &C1, &C2;
334 
335     /// \brief The set of "tentative" equivalences between two canonical
336     /// declarations, mapping from a declaration in the first context to the
337     /// declaration in the second context that we believe to be equivalent.
338     llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
339 
340     /// \brief Queue of declarations in the first context whose equivalence
341     /// with a declaration in the second context still needs to be verified.
342     std::deque<Decl *> DeclsToCheck;
343 
344     /// \brief Declaration (from, to) pairs that are known not to be equivalent
345     /// (which we have already complained about).
346     llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
347 
348     /// \brief Whether we're being strict about the spelling of types when
349     /// unifying two types.
350     bool StrictTypeSpelling;
351 
352     /// \brief Whether to complain about failures.
353     bool Complain;
354 
355     /// \brief \c true if the last diagnostic came from C2.
356     bool LastDiagFromC2;
357 
358     StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
359                llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
360                                  bool StrictTypeSpelling = false,
361                                  bool Complain = true)
362       : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
363         StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
364         LastDiagFromC2(false) {}
365 
366     /// \brief Determine whether the two declarations are structurally
367     /// equivalent.
368     bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
369 
370     /// \brief Determine whether the two types are structurally equivalent.
371     bool IsStructurallyEquivalent(QualType T1, QualType T2);
372 
373   private:
374     /// \brief Finish checking all of the structural equivalences.
375     ///
376     /// \returns true if an error occurred, false otherwise.
377     bool Finish();
378 
379   public:
380     DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
381       assert(Complain && "Not allowed to complain");
382       if (LastDiagFromC2)
383         C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
384       LastDiagFromC2 = false;
385       return C1.getDiagnostics().Report(Loc, DiagID);
386     }
387 
388     DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
389       assert(Complain && "Not allowed to complain");
390       if (!LastDiagFromC2)
391         C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
392       LastDiagFromC2 = true;
393       return C2.getDiagnostics().Report(Loc, DiagID);
394     }
395   };
396 }
397 
398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
399                                      QualType T1, QualType T2);
400 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
401                                      Decl *D1, Decl *D2);
402 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
403                                      const TemplateArgument &Arg1,
404                                      const TemplateArgument &Arg2);
405 
406 /// \brief Determine structural equivalence of two expressions.
407 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
408                                      Expr *E1, Expr *E2) {
409   if (!E1 || !E2)
410     return E1 == E2;
411 
412   // FIXME: Actually perform a structural comparison!
413   return true;
414 }
415 
416 /// \brief Determine whether two identifiers are equivalent.
417 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
418                                      const IdentifierInfo *Name2) {
419   if (!Name1 || !Name2)
420     return Name1 == Name2;
421 
422   return Name1->getName() == Name2->getName();
423 }
424 
425 /// \brief Determine whether two nested-name-specifiers are equivalent.
426 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
427                                      NestedNameSpecifier *NNS1,
428                                      NestedNameSpecifier *NNS2) {
429   if (NNS1->getKind() != NNS2->getKind())
430     return false;
431 
432   NestedNameSpecifier *Prefix1 = NNS1->getPrefix(),
433       *Prefix2 = NNS2->getPrefix();
434   if ((bool)Prefix1 != (bool)Prefix2)
435     return false;
436 
437   if (Prefix1)
438     if (!IsStructurallyEquivalent(Context, Prefix1, Prefix2))
439       return false;
440 
441   switch (NNS1->getKind()) {
442   case NestedNameSpecifier::Identifier:
443     return IsStructurallyEquivalent(NNS1->getAsIdentifier(),
444                                     NNS2->getAsIdentifier());
445   case NestedNameSpecifier::Namespace:
446     return IsStructurallyEquivalent(Context, NNS1->getAsNamespace(),
447                                     NNS2->getAsNamespace());
448   case NestedNameSpecifier::NamespaceAlias:
449     return IsStructurallyEquivalent(Context, NNS1->getAsNamespaceAlias(),
450                                     NNS2->getAsNamespaceAlias());
451   case NestedNameSpecifier::TypeSpec:
452   case NestedNameSpecifier::TypeSpecWithTemplate:
453     return IsStructurallyEquivalent(Context, QualType(NNS1->getAsType(), 0),
454                                     QualType(NNS2->getAsType(), 0));
455   case NestedNameSpecifier::Global:
456     return true;
457   case NestedNameSpecifier::Super:
458     return IsStructurallyEquivalent(Context, NNS1->getAsRecordDecl(),
459                                     NNS2->getAsRecordDecl());
460   }
461   return false;
462 }
463 
464 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
465                                      const TemplateName &N1,
466                                      const TemplateName &N2) {
467   if (N1.getKind() != N2.getKind())
468     return false;
469   switch (N1.getKind()) {
470   case TemplateName::Template:
471     return IsStructurallyEquivalent(Context, N1.getAsTemplateDecl(),
472                                     N2.getAsTemplateDecl());
473 
474   case TemplateName::OverloadedTemplate: {
475     OverloadedTemplateStorage *OS1 = N1.getAsOverloadedTemplate(),
476         *OS2 = N2.getAsOverloadedTemplate();
477     OverloadedTemplateStorage::iterator I1 = OS1->begin(), I2 = OS2->begin(),
478         E1 = OS1->end(), E2 = OS2->end();
479     for (; I1 != E1 && I2 != E2; ++I1, ++I2)
480       if (!IsStructurallyEquivalent(Context, *I1, *I2))
481         return false;
482     return I1 == E1 && I2 == E2;
483   }
484 
485   case TemplateName::QualifiedTemplate: {
486     QualifiedTemplateName *QN1 = N1.getAsQualifiedTemplateName(),
487         *QN2 = N2.getAsQualifiedTemplateName();
488     return IsStructurallyEquivalent(Context, QN1->getDecl(), QN2->getDecl()) &&
489         IsStructurallyEquivalent(Context, QN1->getQualifier(),
490                                  QN2->getQualifier());
491   }
492 
493   case TemplateName::DependentTemplate: {
494       DependentTemplateName *DN1 = N1.getAsDependentTemplateName(),
495           *DN2 = N2.getAsDependentTemplateName();
496       if (!IsStructurallyEquivalent(Context, DN1->getQualifier(),
497                                     DN2->getQualifier()))
498         return false;
499       if (DN1->isIdentifier() && DN2->isIdentifier())
500         return IsStructurallyEquivalent(DN1->getIdentifier(),
501                                         DN2->getIdentifier());
502       else if (DN1->isOverloadedOperator() && DN2->isOverloadedOperator())
503         return DN1->getOperator() == DN2->getOperator();
504       return false;
505   }
506 
507   case TemplateName::SubstTemplateTemplateParm: {
508     SubstTemplateTemplateParmStorage *TS1 = N1.getAsSubstTemplateTemplateParm(),
509         *TS2 = N2.getAsSubstTemplateTemplateParm();
510     return IsStructurallyEquivalent(Context, TS1->getParameter(),
511                                     TS2->getParameter()) &&
512         IsStructurallyEquivalent(Context, TS1->getReplacement(),
513                                  TS2->getReplacement());
514     }
515   case TemplateName::SubstTemplateTemplateParmPack: {
516     SubstTemplateTemplateParmPackStorage
517         *P1 = N1.getAsSubstTemplateTemplateParmPack(),
518         *P2 = N2.getAsSubstTemplateTemplateParmPack();
519     return IsStructurallyEquivalent(Context, P1->getArgumentPack(),
520                                     P2->getArgumentPack()) &&
521         IsStructurallyEquivalent(Context, P1->getParameterPack(),
522                                  P2->getParameterPack());
523   }
524   }
525   return false;
526 }
527 
528 /// \brief Determine whether two template arguments are equivalent.
529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
530                                      const TemplateArgument &Arg1,
531                                      const TemplateArgument &Arg2) {
532   if (Arg1.getKind() != Arg2.getKind())
533     return false;
534 
535   switch (Arg1.getKind()) {
536   case TemplateArgument::Null:
537     return true;
538 
539   case TemplateArgument::Type:
540     return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
541 
542   case TemplateArgument::Integral:
543     if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
544                                           Arg2.getIntegralType()))
545       return false;
546 
547     return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
548 
549   case TemplateArgument::Declaration:
550     return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
551 
552   case TemplateArgument::NullPtr:
553     return true; // FIXME: Is this correct?
554 
555   case TemplateArgument::Template:
556     return IsStructurallyEquivalent(Context,
557                                     Arg1.getAsTemplate(),
558                                     Arg2.getAsTemplate());
559 
560   case TemplateArgument::TemplateExpansion:
561     return IsStructurallyEquivalent(Context,
562                                     Arg1.getAsTemplateOrTemplatePattern(),
563                                     Arg2.getAsTemplateOrTemplatePattern());
564 
565   case TemplateArgument::Expression:
566     return IsStructurallyEquivalent(Context,
567                                     Arg1.getAsExpr(), Arg2.getAsExpr());
568 
569   case TemplateArgument::Pack:
570     if (Arg1.pack_size() != Arg2.pack_size())
571       return false;
572 
573     for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
574       if (!IsStructurallyEquivalent(Context,
575                                     Arg1.pack_begin()[I],
576                                     Arg2.pack_begin()[I]))
577         return false;
578 
579     return true;
580   }
581 
582   llvm_unreachable("Invalid template argument kind");
583 }
584 
585 /// \brief Determine structural equivalence for the common part of array
586 /// types.
587 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
588                                           const ArrayType *Array1,
589                                           const ArrayType *Array2) {
590   if (!IsStructurallyEquivalent(Context,
591                                 Array1->getElementType(),
592                                 Array2->getElementType()))
593     return false;
594   if (Array1->getSizeModifier() != Array2->getSizeModifier())
595     return false;
596   if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
597     return false;
598 
599   return true;
600 }
601 
602 /// \brief Determine structural equivalence of two types.
603 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
604                                      QualType T1, QualType T2) {
605   if (T1.isNull() || T2.isNull())
606     return T1.isNull() && T2.isNull();
607 
608   if (!Context.StrictTypeSpelling) {
609     // We aren't being strict about token-to-token equivalence of types,
610     // so map down to the canonical type.
611     T1 = Context.C1.getCanonicalType(T1);
612     T2 = Context.C2.getCanonicalType(T2);
613   }
614 
615   if (T1.getQualifiers() != T2.getQualifiers())
616     return false;
617 
618   Type::TypeClass TC = T1->getTypeClass();
619 
620   if (T1->getTypeClass() != T2->getTypeClass()) {
621     // Compare function types with prototypes vs. without prototypes as if
622     // both did not have prototypes.
623     if (T1->getTypeClass() == Type::FunctionProto &&
624         T2->getTypeClass() == Type::FunctionNoProto)
625       TC = Type::FunctionNoProto;
626     else if (T1->getTypeClass() == Type::FunctionNoProto &&
627              T2->getTypeClass() == Type::FunctionProto)
628       TC = Type::FunctionNoProto;
629     else
630       return false;
631   }
632 
633   switch (TC) {
634   case Type::Builtin:
635     // FIXME: Deal with Char_S/Char_U.
636     if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
637       return false;
638     break;
639 
640   case Type::Complex:
641     if (!IsStructurallyEquivalent(Context,
642                                   cast<ComplexType>(T1)->getElementType(),
643                                   cast<ComplexType>(T2)->getElementType()))
644       return false;
645     break;
646 
647   case Type::Adjusted:
648   case Type::Decayed:
649     if (!IsStructurallyEquivalent(Context,
650                                   cast<AdjustedType>(T1)->getOriginalType(),
651                                   cast<AdjustedType>(T2)->getOriginalType()))
652       return false;
653     break;
654 
655   case Type::Pointer:
656     if (!IsStructurallyEquivalent(Context,
657                                   cast<PointerType>(T1)->getPointeeType(),
658                                   cast<PointerType>(T2)->getPointeeType()))
659       return false;
660     break;
661 
662   case Type::BlockPointer:
663     if (!IsStructurallyEquivalent(Context,
664                                   cast<BlockPointerType>(T1)->getPointeeType(),
665                                   cast<BlockPointerType>(T2)->getPointeeType()))
666       return false;
667     break;
668 
669   case Type::LValueReference:
670   case Type::RValueReference: {
671     const ReferenceType *Ref1 = cast<ReferenceType>(T1);
672     const ReferenceType *Ref2 = cast<ReferenceType>(T2);
673     if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
674       return false;
675     if (Ref1->isInnerRef() != Ref2->isInnerRef())
676       return false;
677     if (!IsStructurallyEquivalent(Context,
678                                   Ref1->getPointeeTypeAsWritten(),
679                                   Ref2->getPointeeTypeAsWritten()))
680       return false;
681     break;
682   }
683 
684   case Type::MemberPointer: {
685     const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
686     const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
687     if (!IsStructurallyEquivalent(Context,
688                                   MemPtr1->getPointeeType(),
689                                   MemPtr2->getPointeeType()))
690       return false;
691     if (!IsStructurallyEquivalent(Context,
692                                   QualType(MemPtr1->getClass(), 0),
693                                   QualType(MemPtr2->getClass(), 0)))
694       return false;
695     break;
696   }
697 
698   case Type::ConstantArray: {
699     const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
700     const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
701     if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
702       return false;
703 
704     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
705       return false;
706     break;
707   }
708 
709   case Type::IncompleteArray:
710     if (!IsArrayStructurallyEquivalent(Context,
711                                        cast<ArrayType>(T1),
712                                        cast<ArrayType>(T2)))
713       return false;
714     break;
715 
716   case Type::VariableArray: {
717     const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
718     const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
719     if (!IsStructurallyEquivalent(Context,
720                                   Array1->getSizeExpr(), Array2->getSizeExpr()))
721       return false;
722 
723     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
724       return false;
725 
726     break;
727   }
728 
729   case Type::DependentSizedArray: {
730     const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
731     const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
732     if (!IsStructurallyEquivalent(Context,
733                                   Array1->getSizeExpr(), Array2->getSizeExpr()))
734       return false;
735 
736     if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
737       return false;
738 
739     break;
740   }
741 
742   case Type::DependentSizedExtVector: {
743     const DependentSizedExtVectorType *Vec1
744       = cast<DependentSizedExtVectorType>(T1);
745     const DependentSizedExtVectorType *Vec2
746       = cast<DependentSizedExtVectorType>(T2);
747     if (!IsStructurallyEquivalent(Context,
748                                   Vec1->getSizeExpr(), Vec2->getSizeExpr()))
749       return false;
750     if (!IsStructurallyEquivalent(Context,
751                                   Vec1->getElementType(),
752                                   Vec2->getElementType()))
753       return false;
754     break;
755   }
756 
757   case Type::Vector:
758   case Type::ExtVector: {
759     const VectorType *Vec1 = cast<VectorType>(T1);
760     const VectorType *Vec2 = cast<VectorType>(T2);
761     if (!IsStructurallyEquivalent(Context,
762                                   Vec1->getElementType(),
763                                   Vec2->getElementType()))
764       return false;
765     if (Vec1->getNumElements() != Vec2->getNumElements())
766       return false;
767     if (Vec1->getVectorKind() != Vec2->getVectorKind())
768       return false;
769     break;
770   }
771 
772   case Type::FunctionProto: {
773     const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
774     const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
775     if (Proto1->getNumParams() != Proto2->getNumParams())
776       return false;
777     for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
778       if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
779                                     Proto2->getParamType(I)))
780         return false;
781     }
782     if (Proto1->isVariadic() != Proto2->isVariadic())
783       return false;
784     if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
785       return false;
786     if (Proto1->getExceptionSpecType() == EST_Dynamic) {
787       if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
788         return false;
789       for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
790         if (!IsStructurallyEquivalent(Context,
791                                       Proto1->getExceptionType(I),
792                                       Proto2->getExceptionType(I)))
793           return false;
794       }
795     } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
796       if (!IsStructurallyEquivalent(Context,
797                                     Proto1->getNoexceptExpr(),
798                                     Proto2->getNoexceptExpr()))
799         return false;
800     }
801     if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
802       return false;
803 
804     // Fall through to check the bits common with FunctionNoProtoType.
805   }
806 
807   case Type::FunctionNoProto: {
808     const FunctionType *Function1 = cast<FunctionType>(T1);
809     const FunctionType *Function2 = cast<FunctionType>(T2);
810     if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
811                                   Function2->getReturnType()))
812       return false;
813     if (Function1->getExtInfo() != Function2->getExtInfo())
814       return false;
815     break;
816   }
817 
818   case Type::UnresolvedUsing:
819     if (!IsStructurallyEquivalent(Context,
820                                   cast<UnresolvedUsingType>(T1)->getDecl(),
821                                   cast<UnresolvedUsingType>(T2)->getDecl()))
822       return false;
823 
824     break;
825 
826   case Type::Attributed:
827     if (!IsStructurallyEquivalent(Context,
828                                   cast<AttributedType>(T1)->getModifiedType(),
829                                   cast<AttributedType>(T2)->getModifiedType()))
830       return false;
831     if (!IsStructurallyEquivalent(Context,
832                                 cast<AttributedType>(T1)->getEquivalentType(),
833                                 cast<AttributedType>(T2)->getEquivalentType()))
834       return false;
835     break;
836 
837   case Type::Paren:
838     if (!IsStructurallyEquivalent(Context,
839                                   cast<ParenType>(T1)->getInnerType(),
840                                   cast<ParenType>(T2)->getInnerType()))
841       return false;
842     break;
843 
844   case Type::Typedef:
845     if (!IsStructurallyEquivalent(Context,
846                                   cast<TypedefType>(T1)->getDecl(),
847                                   cast<TypedefType>(T2)->getDecl()))
848       return false;
849     break;
850 
851   case Type::TypeOfExpr:
852     if (!IsStructurallyEquivalent(Context,
853                                 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
854                                 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
855       return false;
856     break;
857 
858   case Type::TypeOf:
859     if (!IsStructurallyEquivalent(Context,
860                                   cast<TypeOfType>(T1)->getUnderlyingType(),
861                                   cast<TypeOfType>(T2)->getUnderlyingType()))
862       return false;
863     break;
864 
865   case Type::UnaryTransform:
866     if (!IsStructurallyEquivalent(Context,
867                              cast<UnaryTransformType>(T1)->getUnderlyingType(),
868                              cast<UnaryTransformType>(T1)->getUnderlyingType()))
869       return false;
870     break;
871 
872   case Type::Decltype:
873     if (!IsStructurallyEquivalent(Context,
874                                   cast<DecltypeType>(T1)->getUnderlyingExpr(),
875                                   cast<DecltypeType>(T2)->getUnderlyingExpr()))
876       return false;
877     break;
878 
879   case Type::Auto:
880     if (!IsStructurallyEquivalent(Context,
881                                   cast<AutoType>(T1)->getDeducedType(),
882                                   cast<AutoType>(T2)->getDeducedType()))
883       return false;
884     break;
885 
886   case Type::DeducedTemplateSpecialization: {
887     auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
888     auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
889     if (!IsStructurallyEquivalent(Context,
890                                   DT1->getTemplateName(),
891                                   DT2->getTemplateName()))
892       return false;
893     if (!IsStructurallyEquivalent(Context,
894                                   DT1->getDeducedType(),
895                                   DT2->getDeducedType()))
896       return false;
897     break;
898   }
899 
900   case Type::Record:
901   case Type::Enum:
902     if (!IsStructurallyEquivalent(Context,
903                                   cast<TagType>(T1)->getDecl(),
904                                   cast<TagType>(T2)->getDecl()))
905       return false;
906     break;
907 
908   case Type::TemplateTypeParm: {
909     const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
910     const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
911     if (Parm1->getDepth() != Parm2->getDepth())
912       return false;
913     if (Parm1->getIndex() != Parm2->getIndex())
914       return false;
915     if (Parm1->isParameterPack() != Parm2->isParameterPack())
916       return false;
917 
918     // Names of template type parameters are never significant.
919     break;
920   }
921 
922   case Type::SubstTemplateTypeParm: {
923     const SubstTemplateTypeParmType *Subst1
924       = cast<SubstTemplateTypeParmType>(T1);
925     const SubstTemplateTypeParmType *Subst2
926       = cast<SubstTemplateTypeParmType>(T2);
927     if (!IsStructurallyEquivalent(Context,
928                                   QualType(Subst1->getReplacedParameter(), 0),
929                                   QualType(Subst2->getReplacedParameter(), 0)))
930       return false;
931     if (!IsStructurallyEquivalent(Context,
932                                   Subst1->getReplacementType(),
933                                   Subst2->getReplacementType()))
934       return false;
935     break;
936   }
937 
938   case Type::SubstTemplateTypeParmPack: {
939     const SubstTemplateTypeParmPackType *Subst1
940       = cast<SubstTemplateTypeParmPackType>(T1);
941     const SubstTemplateTypeParmPackType *Subst2
942       = cast<SubstTemplateTypeParmPackType>(T2);
943     if (!IsStructurallyEquivalent(Context,
944                                   QualType(Subst1->getReplacedParameter(), 0),
945                                   QualType(Subst2->getReplacedParameter(), 0)))
946       return false;
947     if (!IsStructurallyEquivalent(Context,
948                                   Subst1->getArgumentPack(),
949                                   Subst2->getArgumentPack()))
950       return false;
951     break;
952   }
953   case Type::TemplateSpecialization: {
954     const TemplateSpecializationType *Spec1
955       = cast<TemplateSpecializationType>(T1);
956     const TemplateSpecializationType *Spec2
957       = cast<TemplateSpecializationType>(T2);
958     if (!IsStructurallyEquivalent(Context,
959                                   Spec1->getTemplateName(),
960                                   Spec2->getTemplateName()))
961       return false;
962     if (Spec1->getNumArgs() != Spec2->getNumArgs())
963       return false;
964     for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
965       if (!IsStructurallyEquivalent(Context,
966                                     Spec1->getArg(I), Spec2->getArg(I)))
967         return false;
968     }
969     break;
970   }
971 
972   case Type::Elaborated: {
973     const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
974     const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
975     // CHECKME: what if a keyword is ETK_None or ETK_typename ?
976     if (Elab1->getKeyword() != Elab2->getKeyword())
977       return false;
978     if (!IsStructurallyEquivalent(Context,
979                                   Elab1->getQualifier(),
980                                   Elab2->getQualifier()))
981       return false;
982     if (!IsStructurallyEquivalent(Context,
983                                   Elab1->getNamedType(),
984                                   Elab2->getNamedType()))
985       return false;
986     break;
987   }
988 
989   case Type::InjectedClassName: {
990     const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
991     const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
992     if (!IsStructurallyEquivalent(Context,
993                                   Inj1->getInjectedSpecializationType(),
994                                   Inj2->getInjectedSpecializationType()))
995       return false;
996     break;
997   }
998 
999   case Type::DependentName: {
1000     const DependentNameType *Typename1 = cast<DependentNameType>(T1);
1001     const DependentNameType *Typename2 = cast<DependentNameType>(T2);
1002     if (!IsStructurallyEquivalent(Context,
1003                                   Typename1->getQualifier(),
1004                                   Typename2->getQualifier()))
1005       return false;
1006     if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
1007                                   Typename2->getIdentifier()))
1008       return false;
1009 
1010     break;
1011   }
1012 
1013   case Type::DependentTemplateSpecialization: {
1014     const DependentTemplateSpecializationType *Spec1 =
1015       cast<DependentTemplateSpecializationType>(T1);
1016     const DependentTemplateSpecializationType *Spec2 =
1017       cast<DependentTemplateSpecializationType>(T2);
1018     if (!IsStructurallyEquivalent(Context,
1019                                   Spec1->getQualifier(),
1020                                   Spec2->getQualifier()))
1021       return false;
1022     if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
1023                                   Spec2->getIdentifier()))
1024       return false;
1025     if (Spec1->getNumArgs() != Spec2->getNumArgs())
1026       return false;
1027     for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
1028       if (!IsStructurallyEquivalent(Context,
1029                                     Spec1->getArg(I), Spec2->getArg(I)))
1030         return false;
1031     }
1032     break;
1033   }
1034 
1035   case Type::PackExpansion:
1036     if (!IsStructurallyEquivalent(Context,
1037                                   cast<PackExpansionType>(T1)->getPattern(),
1038                                   cast<PackExpansionType>(T2)->getPattern()))
1039       return false;
1040     break;
1041 
1042   case Type::ObjCInterface: {
1043     const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
1044     const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
1045     if (!IsStructurallyEquivalent(Context,
1046                                   Iface1->getDecl(), Iface2->getDecl()))
1047       return false;
1048     break;
1049   }
1050 
1051   case Type::ObjCTypeParam: {
1052     const ObjCTypeParamType *Obj1 = cast<ObjCTypeParamType>(T1);
1053     const ObjCTypeParamType *Obj2 = cast<ObjCTypeParamType>(T2);
1054     if (!IsStructurallyEquivalent(Context, Obj1->getDecl(),
1055                                   Obj2->getDecl()))
1056       return false;
1057 
1058     if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1059       return false;
1060     for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1061       if (!IsStructurallyEquivalent(Context,
1062                                     Obj1->getProtocol(I),
1063                                     Obj2->getProtocol(I)))
1064         return false;
1065     }
1066     break;
1067   }
1068   case Type::ObjCObject: {
1069     const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
1070     const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
1071     if (!IsStructurallyEquivalent(Context,
1072                                   Obj1->getBaseType(),
1073                                   Obj2->getBaseType()))
1074       return false;
1075     if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
1076       return false;
1077     for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
1078       if (!IsStructurallyEquivalent(Context,
1079                                     Obj1->getProtocol(I),
1080                                     Obj2->getProtocol(I)))
1081         return false;
1082     }
1083     break;
1084   }
1085 
1086   case Type::ObjCObjectPointer: {
1087     const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
1088     const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
1089     if (!IsStructurallyEquivalent(Context,
1090                                   Ptr1->getPointeeType(),
1091                                   Ptr2->getPointeeType()))
1092       return false;
1093     break;
1094   }
1095 
1096   case Type::Atomic: {
1097     if (!IsStructurallyEquivalent(Context,
1098                                   cast<AtomicType>(T1)->getValueType(),
1099                                   cast<AtomicType>(T2)->getValueType()))
1100       return false;
1101     break;
1102   }
1103 
1104   case Type::Pipe: {
1105     if (!IsStructurallyEquivalent(Context,
1106                                   cast<PipeType>(T1)->getElementType(),
1107                                   cast<PipeType>(T2)->getElementType()))
1108       return false;
1109     break;
1110   }
1111 
1112   } // end switch
1113 
1114   return true;
1115 }
1116 
1117 /// \brief Determine structural equivalence of two fields.
1118 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1119                                      FieldDecl *Field1, FieldDecl *Field2) {
1120   RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
1121 
1122   // For anonymous structs/unions, match up the anonymous struct/union type
1123   // declarations directly, so that we don't go off searching for anonymous
1124   // types
1125   if (Field1->isAnonymousStructOrUnion() &&
1126       Field2->isAnonymousStructOrUnion()) {
1127     RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
1128     RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
1129     return IsStructurallyEquivalent(Context, D1, D2);
1130   }
1131 
1132   // Check for equivalent field names.
1133   IdentifierInfo *Name1 = Field1->getIdentifier();
1134   IdentifierInfo *Name2 = Field2->getIdentifier();
1135   if (!::IsStructurallyEquivalent(Name1, Name2))
1136     return false;
1137 
1138   if (!IsStructurallyEquivalent(Context,
1139                                 Field1->getType(), Field2->getType())) {
1140     if (Context.Complain) {
1141       Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1142         << Context.C2.getTypeDeclType(Owner2);
1143       Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1144         << Field2->getDeclName() << Field2->getType();
1145       Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1146         << Field1->getDeclName() << Field1->getType();
1147     }
1148     return false;
1149   }
1150 
1151   if (Field1->isBitField() != Field2->isBitField()) {
1152     if (Context.Complain) {
1153       Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1154         << Context.C2.getTypeDeclType(Owner2);
1155       if (Field1->isBitField()) {
1156         Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1157         << Field1->getDeclName() << Field1->getType()
1158         << Field1->getBitWidthValue(Context.C1);
1159         Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
1160         << Field2->getDeclName();
1161       } else {
1162         Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1163         << Field2->getDeclName() << Field2->getType()
1164         << Field2->getBitWidthValue(Context.C2);
1165         Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
1166         << Field1->getDeclName();
1167       }
1168     }
1169     return false;
1170   }
1171 
1172   if (Field1->isBitField()) {
1173     // Make sure that the bit-fields are the same length.
1174     unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
1175     unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
1176 
1177     if (Bits1 != Bits2) {
1178       if (Context.Complain) {
1179         Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1180           << Context.C2.getTypeDeclType(Owner2);
1181         Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1182           << Field2->getDeclName() << Field2->getType() << Bits2;
1183         Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1184           << Field1->getDeclName() << Field1->getType() << Bits1;
1185       }
1186       return false;
1187     }
1188   }
1189 
1190   return true;
1191 }
1192 
1193 /// \brief Find the index of the given anonymous struct/union within its
1194 /// context.
1195 ///
1196 /// \returns Returns the index of this anonymous struct/union in its context,
1197 /// including the next assigned index (if none of them match). Returns an
1198 /// empty option if the context is not a record, i.e.. if the anonymous
1199 /// struct/union is at namespace or block scope.
1200 static Optional<unsigned> findUntaggedStructOrUnionIndex(RecordDecl *Anon) {
1201   ASTContext &Context = Anon->getASTContext();
1202   QualType AnonTy = Context.getRecordType(Anon);
1203 
1204   RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
1205   if (!Owner)
1206     return None;
1207 
1208   unsigned Index = 0;
1209   for (const auto *D : Owner->noload_decls()) {
1210     const auto *F = dyn_cast<FieldDecl>(D);
1211     if (!F)
1212       continue;
1213 
1214     if (F->isAnonymousStructOrUnion()) {
1215       if (Context.hasSameType(F->getType(), AnonTy))
1216         break;
1217       ++Index;
1218       continue;
1219     }
1220 
1221     // If the field looks like this:
1222     // struct { ... } A;
1223     QualType FieldType = F->getType();
1224     if (const auto *RecType = dyn_cast<RecordType>(FieldType)) {
1225       const RecordDecl *RecDecl = RecType->getDecl();
1226       if (RecDecl->getDeclContext() == Owner &&
1227           !RecDecl->getIdentifier()) {
1228         if (Context.hasSameType(FieldType, AnonTy))
1229           break;
1230         ++Index;
1231         continue;
1232       }
1233     }
1234   }
1235 
1236   return Index;
1237 }
1238 
1239 /// \brief Determine structural equivalence of two records.
1240 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1241                                      RecordDecl *D1, RecordDecl *D2) {
1242   if (D1->isUnion() != D2->isUnion()) {
1243     if (Context.Complain) {
1244       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1245         << Context.C2.getTypeDeclType(D2);
1246       Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
1247         << D1->getDeclName() << (unsigned)D1->getTagKind();
1248     }
1249     return false;
1250   }
1251 
1252   if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
1253     // If both anonymous structs/unions are in a record context, make sure
1254     // they occur in the same location in the context records.
1255     if (Optional<unsigned> Index1 = findUntaggedStructOrUnionIndex(D1)) {
1256       if (Optional<unsigned> Index2 = findUntaggedStructOrUnionIndex(D2)) {
1257         if (*Index1 != *Index2)
1258           return false;
1259       }
1260     }
1261   }
1262 
1263   // If both declarations are class template specializations, we know
1264   // the ODR applies, so check the template and template arguments.
1265   ClassTemplateSpecializationDecl *Spec1
1266     = dyn_cast<ClassTemplateSpecializationDecl>(D1);
1267   ClassTemplateSpecializationDecl *Spec2
1268     = dyn_cast<ClassTemplateSpecializationDecl>(D2);
1269   if (Spec1 && Spec2) {
1270     // Check that the specialized templates are the same.
1271     if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
1272                                   Spec2->getSpecializedTemplate()))
1273       return false;
1274 
1275     // Check that the template arguments are the same.
1276     if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
1277       return false;
1278 
1279     for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
1280       if (!IsStructurallyEquivalent(Context,
1281                                     Spec1->getTemplateArgs().get(I),
1282                                     Spec2->getTemplateArgs().get(I)))
1283         return false;
1284   }
1285   // If one is a class template specialization and the other is not, these
1286   // structures are different.
1287   else if (Spec1 || Spec2)
1288     return false;
1289 
1290   // Compare the definitions of these two records. If either or both are
1291   // incomplete, we assume that they are equivalent.
1292   D1 = D1->getDefinition();
1293   D2 = D2->getDefinition();
1294   if (!D1 || !D2)
1295     return true;
1296 
1297   if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1298     if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1299       if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1300         if (Context.Complain) {
1301           Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1302             << Context.C2.getTypeDeclType(D2);
1303           Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1304             << D2CXX->getNumBases();
1305           Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1306             << D1CXX->getNumBases();
1307         }
1308         return false;
1309       }
1310 
1311       // Check the base classes.
1312       for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1313                                            BaseEnd1 = D1CXX->bases_end(),
1314                                                 Base2 = D2CXX->bases_begin();
1315            Base1 != BaseEnd1;
1316            ++Base1, ++Base2) {
1317         if (!IsStructurallyEquivalent(Context,
1318                                       Base1->getType(), Base2->getType())) {
1319           if (Context.Complain) {
1320             Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1321               << Context.C2.getTypeDeclType(D2);
1322             Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1323               << Base2->getType()
1324               << Base2->getSourceRange();
1325             Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1326               << Base1->getType()
1327               << Base1->getSourceRange();
1328           }
1329           return false;
1330         }
1331 
1332         // Check virtual vs. non-virtual inheritance mismatch.
1333         if (Base1->isVirtual() != Base2->isVirtual()) {
1334           if (Context.Complain) {
1335             Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1336               << Context.C2.getTypeDeclType(D2);
1337             Context.Diag2(Base2->getLocStart(),
1338                           diag::note_odr_virtual_base)
1339               << Base2->isVirtual() << Base2->getSourceRange();
1340             Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1341               << Base1->isVirtual()
1342               << Base1->getSourceRange();
1343           }
1344           return false;
1345         }
1346       }
1347     } else if (D1CXX->getNumBases() > 0) {
1348       if (Context.Complain) {
1349         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1350           << Context.C2.getTypeDeclType(D2);
1351         const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1352         Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1353           << Base1->getType()
1354           << Base1->getSourceRange();
1355         Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1356       }
1357       return false;
1358     }
1359   }
1360 
1361   // Check the fields for consistency.
1362   RecordDecl::field_iterator Field2 = D2->field_begin(),
1363                              Field2End = D2->field_end();
1364   for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1365                                   Field1End = D1->field_end();
1366        Field1 != Field1End;
1367        ++Field1, ++Field2) {
1368     if (Field2 == Field2End) {
1369       if (Context.Complain) {
1370         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1371           << Context.C2.getTypeDeclType(D2);
1372         Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1373           << Field1->getDeclName() << Field1->getType();
1374         Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1375       }
1376       return false;
1377     }
1378 
1379     if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1380       return false;
1381   }
1382 
1383   if (Field2 != Field2End) {
1384     if (Context.Complain) {
1385       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1386         << Context.C2.getTypeDeclType(D2);
1387       Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1388         << Field2->getDeclName() << Field2->getType();
1389       Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1390     }
1391     return false;
1392   }
1393 
1394   return true;
1395 }
1396 
1397 /// \brief Determine structural equivalence of two enums.
1398 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1399                                      EnumDecl *D1, EnumDecl *D2) {
1400   EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1401                              EC2End = D2->enumerator_end();
1402   for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1403                                   EC1End = D1->enumerator_end();
1404        EC1 != EC1End; ++EC1, ++EC2) {
1405     if (EC2 == EC2End) {
1406       if (Context.Complain) {
1407         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1408           << Context.C2.getTypeDeclType(D2);
1409         Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1410           << EC1->getDeclName()
1411           << EC1->getInitVal().toString(10);
1412         Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1413       }
1414       return false;
1415     }
1416 
1417     llvm::APSInt Val1 = EC1->getInitVal();
1418     llvm::APSInt Val2 = EC2->getInitVal();
1419     if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1420         !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1421       if (Context.Complain) {
1422         Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1423           << Context.C2.getTypeDeclType(D2);
1424         Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1425           << EC2->getDeclName()
1426           << EC2->getInitVal().toString(10);
1427         Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1428           << EC1->getDeclName()
1429           << EC1->getInitVal().toString(10);
1430       }
1431       return false;
1432     }
1433   }
1434 
1435   if (EC2 != EC2End) {
1436     if (Context.Complain) {
1437       Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1438         << Context.C2.getTypeDeclType(D2);
1439       Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1440         << EC2->getDeclName()
1441         << EC2->getInitVal().toString(10);
1442       Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1443     }
1444     return false;
1445   }
1446 
1447   return true;
1448 }
1449 
1450 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1451                                      TemplateParameterList *Params1,
1452                                      TemplateParameterList *Params2) {
1453   if (Params1->size() != Params2->size()) {
1454     if (Context.Complain) {
1455       Context.Diag2(Params2->getTemplateLoc(),
1456                     diag::err_odr_different_num_template_parameters)
1457         << Params1->size() << Params2->size();
1458       Context.Diag1(Params1->getTemplateLoc(),
1459                     diag::note_odr_template_parameter_list);
1460     }
1461     return false;
1462   }
1463 
1464   for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1465     if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1466       if (Context.Complain) {
1467         Context.Diag2(Params2->getParam(I)->getLocation(),
1468                       diag::err_odr_different_template_parameter_kind);
1469         Context.Diag1(Params1->getParam(I)->getLocation(),
1470                       diag::note_odr_template_parameter_here);
1471       }
1472       return false;
1473     }
1474 
1475     if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1476                                           Params2->getParam(I))) {
1477 
1478       return false;
1479     }
1480   }
1481 
1482   return true;
1483 }
1484 
1485 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1486                                      TemplateTypeParmDecl *D1,
1487                                      TemplateTypeParmDecl *D2) {
1488   if (D1->isParameterPack() != D2->isParameterPack()) {
1489     if (Context.Complain) {
1490       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1491         << D2->isParameterPack();
1492       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1493         << D1->isParameterPack();
1494     }
1495     return false;
1496   }
1497 
1498   return true;
1499 }
1500 
1501 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1502                                      NonTypeTemplateParmDecl *D1,
1503                                      NonTypeTemplateParmDecl *D2) {
1504   if (D1->isParameterPack() != D2->isParameterPack()) {
1505     if (Context.Complain) {
1506       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1507         << D2->isParameterPack();
1508       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1509         << D1->isParameterPack();
1510     }
1511     return false;
1512   }
1513 
1514   // Check types.
1515   if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1516     if (Context.Complain) {
1517       Context.Diag2(D2->getLocation(),
1518                     diag::err_odr_non_type_parameter_type_inconsistent)
1519         << D2->getType() << D1->getType();
1520       Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1521         << D1->getType();
1522     }
1523     return false;
1524   }
1525 
1526   return true;
1527 }
1528 
1529 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1530                                      TemplateTemplateParmDecl *D1,
1531                                      TemplateTemplateParmDecl *D2) {
1532   if (D1->isParameterPack() != D2->isParameterPack()) {
1533     if (Context.Complain) {
1534       Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1535         << D2->isParameterPack();
1536       Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1537         << D1->isParameterPack();
1538     }
1539     return false;
1540   }
1541 
1542   // Check template parameter lists.
1543   return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1544                                   D2->getTemplateParameters());
1545 }
1546 
1547 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1548                                      ClassTemplateDecl *D1,
1549                                      ClassTemplateDecl *D2) {
1550   // Check template parameters.
1551   if (!IsStructurallyEquivalent(Context,
1552                                 D1->getTemplateParameters(),
1553                                 D2->getTemplateParameters()))
1554     return false;
1555 
1556   // Check the templated declaration.
1557   return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1558                                           D2->getTemplatedDecl());
1559 }
1560 
1561 /// \brief Determine structural equivalence of two declarations.
1562 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1563                                      Decl *D1, Decl *D2) {
1564   // FIXME: Check for known structural equivalences via a callback of some sort.
1565 
1566   // Check whether we already know that these two declarations are not
1567   // structurally equivalent.
1568   if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1569                                                       D2->getCanonicalDecl())))
1570     return false;
1571 
1572   // Determine whether we've already produced a tentative equivalence for D1.
1573   Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1574   if (EquivToD1)
1575     return EquivToD1 == D2->getCanonicalDecl();
1576 
1577   // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1578   EquivToD1 = D2->getCanonicalDecl();
1579   Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1580   return true;
1581 }
1582 
1583 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1584                                                             Decl *D2) {
1585   if (!::IsStructurallyEquivalent(*this, D1, D2))
1586     return false;
1587 
1588   return !Finish();
1589 }
1590 
1591 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1592                                                             QualType T2) {
1593   if (!::IsStructurallyEquivalent(*this, T1, T2))
1594     return false;
1595 
1596   return !Finish();
1597 }
1598 
1599 bool StructuralEquivalenceContext::Finish() {
1600   while (!DeclsToCheck.empty()) {
1601     // Check the next declaration.
1602     Decl *D1 = DeclsToCheck.front();
1603     DeclsToCheck.pop_front();
1604 
1605     Decl *D2 = TentativeEquivalences[D1];
1606     assert(D2 && "Unrecorded tentative equivalence?");
1607 
1608     bool Equivalent = true;
1609 
1610     // FIXME: Switch on all declaration kinds. For now, we're just going to
1611     // check the obvious ones.
1612     if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1613       if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1614         // Check for equivalent structure names.
1615         IdentifierInfo *Name1 = Record1->getIdentifier();
1616         if (!Name1 && Record1->getTypedefNameForAnonDecl())
1617           Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1618         IdentifierInfo *Name2 = Record2->getIdentifier();
1619         if (!Name2 && Record2->getTypedefNameForAnonDecl())
1620           Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1621         if (!::IsStructurallyEquivalent(Name1, Name2) ||
1622             !::IsStructurallyEquivalent(*this, Record1, Record2))
1623           Equivalent = false;
1624       } else {
1625         // Record/non-record mismatch.
1626         Equivalent = false;
1627       }
1628     } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1629       if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1630         // Check for equivalent enum names.
1631         IdentifierInfo *Name1 = Enum1->getIdentifier();
1632         if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1633           Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1634         IdentifierInfo *Name2 = Enum2->getIdentifier();
1635         if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1636           Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1637         if (!::IsStructurallyEquivalent(Name1, Name2) ||
1638             !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1639           Equivalent = false;
1640       } else {
1641         // Enum/non-enum mismatch
1642         Equivalent = false;
1643       }
1644     } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1645       if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1646         if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1647                                         Typedef2->getIdentifier()) ||
1648             !::IsStructurallyEquivalent(*this,
1649                                         Typedef1->getUnderlyingType(),
1650                                         Typedef2->getUnderlyingType()))
1651           Equivalent = false;
1652       } else {
1653         // Typedef/non-typedef mismatch.
1654         Equivalent = false;
1655       }
1656     } else if (ClassTemplateDecl *ClassTemplate1
1657                                            = dyn_cast<ClassTemplateDecl>(D1)) {
1658       if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1659         if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1660                                         ClassTemplate2->getIdentifier()) ||
1661             !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1662           Equivalent = false;
1663       } else {
1664         // Class template/non-class-template mismatch.
1665         Equivalent = false;
1666       }
1667     } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1668       if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1669         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1670           Equivalent = false;
1671       } else {
1672         // Kind mismatch.
1673         Equivalent = false;
1674       }
1675     } else if (NonTypeTemplateParmDecl *NTTP1
1676                                      = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1677       if (NonTypeTemplateParmDecl *NTTP2
1678                                       = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1679         if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1680           Equivalent = false;
1681       } else {
1682         // Kind mismatch.
1683         Equivalent = false;
1684       }
1685     } else if (TemplateTemplateParmDecl *TTP1
1686                                   = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1687       if (TemplateTemplateParmDecl *TTP2
1688                                     = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1689         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1690           Equivalent = false;
1691       } else {
1692         // Kind mismatch.
1693         Equivalent = false;
1694       }
1695     }
1696 
1697     if (!Equivalent) {
1698       // Note that these two declarations are not equivalent (and we already
1699       // know about it).
1700       NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1701                                                D2->getCanonicalDecl()));
1702       return true;
1703     }
1704     // FIXME: Check other declaration kinds!
1705   }
1706 
1707   return false;
1708 }
1709 
1710 //----------------------------------------------------------------------------
1711 // Import Types
1712 //----------------------------------------------------------------------------
1713 
1714 QualType ASTNodeImporter::VisitType(const Type *T) {
1715   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1716     << T->getTypeClassName();
1717   return QualType();
1718 }
1719 
1720 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1721   QualType UnderlyingType = Importer.Import(T->getValueType());
1722   if(UnderlyingType.isNull())
1723     return QualType();
1724 
1725   return Importer.getToContext().getAtomicType(UnderlyingType);
1726 }
1727 
1728 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1729   switch (T->getKind()) {
1730 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1731   case BuiltinType::Id: \
1732     return Importer.getToContext().SingletonId;
1733 #include "clang/Basic/OpenCLImageTypes.def"
1734 #define SHARED_SINGLETON_TYPE(Expansion)
1735 #define BUILTIN_TYPE(Id, SingletonId) \
1736   case BuiltinType::Id: return Importer.getToContext().SingletonId;
1737 #include "clang/AST/BuiltinTypes.def"
1738 
1739   // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1740   // context supports C++.
1741 
1742   // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1743   // context supports ObjC.
1744 
1745   case BuiltinType::Char_U:
1746     // The context we're importing from has an unsigned 'char'. If we're
1747     // importing into a context with a signed 'char', translate to
1748     // 'unsigned char' instead.
1749     if (Importer.getToContext().getLangOpts().CharIsSigned)
1750       return Importer.getToContext().UnsignedCharTy;
1751 
1752     return Importer.getToContext().CharTy;
1753 
1754   case BuiltinType::Char_S:
1755     // The context we're importing from has an unsigned 'char'. If we're
1756     // importing into a context with a signed 'char', translate to
1757     // 'unsigned char' instead.
1758     if (!Importer.getToContext().getLangOpts().CharIsSigned)
1759       return Importer.getToContext().SignedCharTy;
1760 
1761     return Importer.getToContext().CharTy;
1762 
1763   case BuiltinType::WChar_S:
1764   case BuiltinType::WChar_U:
1765     // FIXME: If not in C++, shall we translate to the C equivalent of
1766     // wchar_t?
1767     return Importer.getToContext().WCharTy;
1768   }
1769 
1770   llvm_unreachable("Invalid BuiltinType Kind!");
1771 }
1772 
1773 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1774   QualType OrigT = Importer.Import(T->getOriginalType());
1775   if (OrigT.isNull())
1776     return QualType();
1777 
1778   return Importer.getToContext().getDecayedType(OrigT);
1779 }
1780 
1781 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1782   QualType ToElementType = Importer.Import(T->getElementType());
1783   if (ToElementType.isNull())
1784     return QualType();
1785 
1786   return Importer.getToContext().getComplexType(ToElementType);
1787 }
1788 
1789 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1790   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1791   if (ToPointeeType.isNull())
1792     return QualType();
1793 
1794   return Importer.getToContext().getPointerType(ToPointeeType);
1795 }
1796 
1797 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1798   // FIXME: Check for blocks support in "to" context.
1799   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1800   if (ToPointeeType.isNull())
1801     return QualType();
1802 
1803   return Importer.getToContext().getBlockPointerType(ToPointeeType);
1804 }
1805 
1806 QualType
1807 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1808   // FIXME: Check for C++ support in "to" context.
1809   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1810   if (ToPointeeType.isNull())
1811     return QualType();
1812 
1813   return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1814 }
1815 
1816 QualType
1817 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1818   // FIXME: Check for C++0x support in "to" context.
1819   QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1820   if (ToPointeeType.isNull())
1821     return QualType();
1822 
1823   return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1824 }
1825 
1826 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1827   // FIXME: Check for C++ support in "to" context.
1828   QualType ToPointeeType = Importer.Import(T->getPointeeType());
1829   if (ToPointeeType.isNull())
1830     return QualType();
1831 
1832   QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1833   return Importer.getToContext().getMemberPointerType(ToPointeeType,
1834                                                       ClassType.getTypePtr());
1835 }
1836 
1837 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1838   QualType ToElementType = Importer.Import(T->getElementType());
1839   if (ToElementType.isNull())
1840     return QualType();
1841 
1842   return Importer.getToContext().getConstantArrayType(ToElementType,
1843                                                       T->getSize(),
1844                                                       T->getSizeModifier(),
1845                                                T->getIndexTypeCVRQualifiers());
1846 }
1847 
1848 QualType
1849 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1850   QualType ToElementType = Importer.Import(T->getElementType());
1851   if (ToElementType.isNull())
1852     return QualType();
1853 
1854   return Importer.getToContext().getIncompleteArrayType(ToElementType,
1855                                                         T->getSizeModifier(),
1856                                                 T->getIndexTypeCVRQualifiers());
1857 }
1858 
1859 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1860   QualType ToElementType = Importer.Import(T->getElementType());
1861   if (ToElementType.isNull())
1862     return QualType();
1863 
1864   Expr *Size = Importer.Import(T->getSizeExpr());
1865   if (!Size)
1866     return QualType();
1867 
1868   SourceRange Brackets = Importer.Import(T->getBracketsRange());
1869   return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1870                                                       T->getSizeModifier(),
1871                                                 T->getIndexTypeCVRQualifiers(),
1872                                                       Brackets);
1873 }
1874 
1875 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1876   QualType ToElementType = Importer.Import(T->getElementType());
1877   if (ToElementType.isNull())
1878     return QualType();
1879 
1880   return Importer.getToContext().getVectorType(ToElementType,
1881                                                T->getNumElements(),
1882                                                T->getVectorKind());
1883 }
1884 
1885 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1886   QualType ToElementType = Importer.Import(T->getElementType());
1887   if (ToElementType.isNull())
1888     return QualType();
1889 
1890   return Importer.getToContext().getExtVectorType(ToElementType,
1891                                                   T->getNumElements());
1892 }
1893 
1894 QualType
1895 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1896   // FIXME: What happens if we're importing a function without a prototype
1897   // into C++? Should we make it variadic?
1898   QualType ToResultType = Importer.Import(T->getReturnType());
1899   if (ToResultType.isNull())
1900     return QualType();
1901 
1902   return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1903                                                         T->getExtInfo());
1904 }
1905 
1906 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1907   QualType ToResultType = Importer.Import(T->getReturnType());
1908   if (ToResultType.isNull())
1909     return QualType();
1910 
1911   // Import argument types
1912   SmallVector<QualType, 4> ArgTypes;
1913   for (const auto &A : T->param_types()) {
1914     QualType ArgType = Importer.Import(A);
1915     if (ArgType.isNull())
1916       return QualType();
1917     ArgTypes.push_back(ArgType);
1918   }
1919 
1920   // Import exception types
1921   SmallVector<QualType, 4> ExceptionTypes;
1922   for (const auto &E : T->exceptions()) {
1923     QualType ExceptionType = Importer.Import(E);
1924     if (ExceptionType.isNull())
1925       return QualType();
1926     ExceptionTypes.push_back(ExceptionType);
1927   }
1928 
1929   FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1930   FunctionProtoType::ExtProtoInfo ToEPI;
1931 
1932   ToEPI.ExtInfo = FromEPI.ExtInfo;
1933   ToEPI.Variadic = FromEPI.Variadic;
1934   ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1935   ToEPI.TypeQuals = FromEPI.TypeQuals;
1936   ToEPI.RefQualifier = FromEPI.RefQualifier;
1937   ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1938   ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1939   ToEPI.ExceptionSpec.NoexceptExpr =
1940       Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1941   ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1942       Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1943   ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1944       Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1945 
1946   return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1947 }
1948 
1949 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1950   QualType ToInnerType = Importer.Import(T->getInnerType());
1951   if (ToInnerType.isNull())
1952     return QualType();
1953 
1954   return Importer.getToContext().getParenType(ToInnerType);
1955 }
1956 
1957 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1958   TypedefNameDecl *ToDecl
1959              = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1960   if (!ToDecl)
1961     return QualType();
1962 
1963   return Importer.getToContext().getTypeDeclType(ToDecl);
1964 }
1965 
1966 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1967   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1968   if (!ToExpr)
1969     return QualType();
1970 
1971   return Importer.getToContext().getTypeOfExprType(ToExpr);
1972 }
1973 
1974 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1975   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1976   if (ToUnderlyingType.isNull())
1977     return QualType();
1978 
1979   return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1980 }
1981 
1982 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1983   // FIXME: Make sure that the "to" context supports C++0x!
1984   Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1985   if (!ToExpr)
1986     return QualType();
1987 
1988   QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1989   if (UnderlyingType.isNull())
1990     return QualType();
1991 
1992   return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1993 }
1994 
1995 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1996   QualType ToBaseType = Importer.Import(T->getBaseType());
1997   QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1998   if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1999     return QualType();
2000 
2001   return Importer.getToContext().getUnaryTransformType(ToBaseType,
2002                                                        ToUnderlyingType,
2003                                                        T->getUTTKind());
2004 }
2005 
2006 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
2007   // FIXME: Make sure that the "to" context supports C++11!
2008   QualType FromDeduced = T->getDeducedType();
2009   QualType ToDeduced;
2010   if (!FromDeduced.isNull()) {
2011     ToDeduced = Importer.Import(FromDeduced);
2012     if (ToDeduced.isNull())
2013       return QualType();
2014   }
2015 
2016   return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
2017                                              /*IsDependent*/false);
2018 }
2019 
2020 QualType ASTNodeImporter::VisitInjectedClassNameType(
2021     const InjectedClassNameType *T) {
2022   CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
2023   if (!D)
2024     return QualType();
2025 
2026   QualType InjType = Importer.Import(T->getInjectedSpecializationType());
2027   if (InjType.isNull())
2028     return QualType();
2029 
2030   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
2031   // See comments in InjectedClassNameType definition for details
2032   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
2033   enum {
2034     TypeAlignmentInBits = 4,
2035     TypeAlignment = 1 << TypeAlignmentInBits
2036   };
2037 
2038   return QualType(new (Importer.getToContext(), TypeAlignment)
2039                   InjectedClassNameType(D, InjType), 0);
2040 }
2041 
2042 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
2043   RecordDecl *ToDecl
2044     = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
2045   if (!ToDecl)
2046     return QualType();
2047 
2048   return Importer.getToContext().getTagDeclType(ToDecl);
2049 }
2050 
2051 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
2052   EnumDecl *ToDecl
2053     = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
2054   if (!ToDecl)
2055     return QualType();
2056 
2057   return Importer.getToContext().getTagDeclType(ToDecl);
2058 }
2059 
2060 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
2061   QualType FromModifiedType = T->getModifiedType();
2062   QualType FromEquivalentType = T->getEquivalentType();
2063   QualType ToModifiedType;
2064   QualType ToEquivalentType;
2065 
2066   if (!FromModifiedType.isNull()) {
2067     ToModifiedType = Importer.Import(FromModifiedType);
2068     if (ToModifiedType.isNull())
2069       return QualType();
2070   }
2071   if (!FromEquivalentType.isNull()) {
2072     ToEquivalentType = Importer.Import(FromEquivalentType);
2073     if (ToEquivalentType.isNull())
2074       return QualType();
2075   }
2076 
2077   return Importer.getToContext().getAttributedType(T->getAttrKind(),
2078     ToModifiedType, ToEquivalentType);
2079 }
2080 
2081 
2082 QualType ASTNodeImporter::VisitTemplateTypeParmType(
2083     const TemplateTypeParmType *T) {
2084   TemplateTypeParmDecl *ParmDecl =
2085       cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
2086   if (!ParmDecl && T->getDecl())
2087     return QualType();
2088 
2089   return Importer.getToContext().getTemplateTypeParmType(
2090         T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
2091 }
2092 
2093 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
2094     const SubstTemplateTypeParmType *T) {
2095   const TemplateTypeParmType *Replaced =
2096       cast_or_null<TemplateTypeParmType>(Importer.Import(
2097         QualType(T->getReplacedParameter(), 0)).getTypePtr());
2098   if (!Replaced)
2099     return QualType();
2100 
2101   QualType Replacement = Importer.Import(T->getReplacementType());
2102   if (Replacement.isNull())
2103     return QualType();
2104   Replacement = Replacement.getCanonicalType();
2105 
2106   return Importer.getToContext().getSubstTemplateTypeParmType(
2107         Replaced, Replacement);
2108 }
2109 
2110 QualType ASTNodeImporter::VisitTemplateSpecializationType(
2111                                        const TemplateSpecializationType *T) {
2112   TemplateName ToTemplate = Importer.Import(T->getTemplateName());
2113   if (ToTemplate.isNull())
2114     return QualType();
2115 
2116   SmallVector<TemplateArgument, 2> ToTemplateArgs;
2117   if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
2118     return QualType();
2119 
2120   QualType ToCanonType;
2121   if (!QualType(T, 0).isCanonical()) {
2122     QualType FromCanonType
2123       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
2124     ToCanonType =Importer.Import(FromCanonType);
2125     if (ToCanonType.isNull())
2126       return QualType();
2127   }
2128   return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
2129                                                                ToTemplateArgs,
2130                                                                ToCanonType);
2131 }
2132 
2133 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
2134   NestedNameSpecifier *ToQualifier = nullptr;
2135   // Note: the qualifier in an ElaboratedType is optional.
2136   if (T->getQualifier()) {
2137     ToQualifier = Importer.Import(T->getQualifier());
2138     if (!ToQualifier)
2139       return QualType();
2140   }
2141 
2142   QualType ToNamedType = Importer.Import(T->getNamedType());
2143   if (ToNamedType.isNull())
2144     return QualType();
2145 
2146   return Importer.getToContext().getElaboratedType(T->getKeyword(),
2147                                                    ToQualifier, ToNamedType);
2148 }
2149 
2150 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
2151   ObjCInterfaceDecl *Class
2152     = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
2153   if (!Class)
2154     return QualType();
2155 
2156   return Importer.getToContext().getObjCInterfaceType(Class);
2157 }
2158 
2159 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
2160   QualType ToBaseType = Importer.Import(T->getBaseType());
2161   if (ToBaseType.isNull())
2162     return QualType();
2163 
2164   SmallVector<QualType, 4> TypeArgs;
2165   for (auto TypeArg : T->getTypeArgsAsWritten()) {
2166     QualType ImportedTypeArg = Importer.Import(TypeArg);
2167     if (ImportedTypeArg.isNull())
2168       return QualType();
2169 
2170     TypeArgs.push_back(ImportedTypeArg);
2171   }
2172 
2173   SmallVector<ObjCProtocolDecl *, 4> Protocols;
2174   for (auto *P : T->quals()) {
2175     ObjCProtocolDecl *Protocol
2176       = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
2177     if (!Protocol)
2178       return QualType();
2179     Protocols.push_back(Protocol);
2180   }
2181 
2182   return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
2183                                                    Protocols,
2184                                                    T->isKindOfTypeAsWritten());
2185 }
2186 
2187 QualType
2188 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
2189   QualType ToPointeeType = Importer.Import(T->getPointeeType());
2190   if (ToPointeeType.isNull())
2191     return QualType();
2192 
2193   return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
2194 }
2195 
2196 //----------------------------------------------------------------------------
2197 // Import Declarations
2198 //----------------------------------------------------------------------------
2199 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
2200                                       DeclContext *&LexicalDC,
2201                                       DeclarationName &Name,
2202                                       NamedDecl *&ToD,
2203                                       SourceLocation &Loc) {
2204   // Import the context of this declaration.
2205   DC = Importer.ImportContext(D->getDeclContext());
2206   if (!DC)
2207     return true;
2208 
2209   LexicalDC = DC;
2210   if (D->getDeclContext() != D->getLexicalDeclContext()) {
2211     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
2212     if (!LexicalDC)
2213       return true;
2214   }
2215 
2216   // Import the name of this declaration.
2217   Name = Importer.Import(D->getDeclName());
2218   if (D->getDeclName() && !Name)
2219     return true;
2220 
2221   // Import the location of this declaration.
2222   Loc = Importer.Import(D->getLocation());
2223   ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
2224   return false;
2225 }
2226 
2227 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2228   if (!FromD)
2229     return;
2230 
2231   if (!ToD) {
2232     ToD = Importer.Import(FromD);
2233     if (!ToD)
2234       return;
2235   }
2236 
2237   if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2238     if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
2239       if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
2240         ImportDefinition(FromRecord, ToRecord);
2241       }
2242     }
2243     return;
2244   }
2245 
2246   if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2247     if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
2248       if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2249         ImportDefinition(FromEnum, ToEnum);
2250       }
2251     }
2252     return;
2253   }
2254 }
2255 
2256 void
2257 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
2258                                           DeclarationNameInfo& To) {
2259   // NOTE: To.Name and To.Loc are already imported.
2260   // We only have to import To.LocInfo.
2261   switch (To.getName().getNameKind()) {
2262   case DeclarationName::Identifier:
2263   case DeclarationName::ObjCZeroArgSelector:
2264   case DeclarationName::ObjCOneArgSelector:
2265   case DeclarationName::ObjCMultiArgSelector:
2266   case DeclarationName::CXXUsingDirective:
2267   case DeclarationName::CXXDeductionGuideName:
2268     return;
2269 
2270   case DeclarationName::CXXOperatorName: {
2271     SourceRange Range = From.getCXXOperatorNameRange();
2272     To.setCXXOperatorNameRange(Importer.Import(Range));
2273     return;
2274   }
2275   case DeclarationName::CXXLiteralOperatorName: {
2276     SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
2277     To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
2278     return;
2279   }
2280   case DeclarationName::CXXConstructorName:
2281   case DeclarationName::CXXDestructorName:
2282   case DeclarationName::CXXConversionFunctionName: {
2283     TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
2284     To.setNamedTypeInfo(Importer.Import(FromTInfo));
2285     return;
2286   }
2287   }
2288   llvm_unreachable("Unknown name kind.");
2289 }
2290 
2291 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2292   if (Importer.isMinimalImport() && !ForceImport) {
2293     Importer.ImportContext(FromDC);
2294     return;
2295   }
2296 
2297   for (auto *From : FromDC->decls())
2298     Importer.Import(From);
2299 }
2300 
2301 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
2302                                        ImportDefinitionKind Kind) {
2303   if (To->getDefinition() || To->isBeingDefined()) {
2304     if (Kind == IDK_Everything)
2305       ImportDeclContext(From, /*ForceImport=*/true);
2306 
2307     return false;
2308   }
2309 
2310   To->startDefinition();
2311 
2312   // Add base classes.
2313   if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
2314     CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
2315 
2316     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2317     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2318     ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
2319     ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
2320     ToData.Aggregate = FromData.Aggregate;
2321     ToData.PlainOldData = FromData.PlainOldData;
2322     ToData.Empty = FromData.Empty;
2323     ToData.Polymorphic = FromData.Polymorphic;
2324     ToData.Abstract = FromData.Abstract;
2325     ToData.IsStandardLayout = FromData.IsStandardLayout;
2326     ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
2327     ToData.HasPrivateFields = FromData.HasPrivateFields;
2328     ToData.HasProtectedFields = FromData.HasProtectedFields;
2329     ToData.HasPublicFields = FromData.HasPublicFields;
2330     ToData.HasMutableFields = FromData.HasMutableFields;
2331     ToData.HasVariantMembers = FromData.HasVariantMembers;
2332     ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
2333     ToData.HasInClassInitializer = FromData.HasInClassInitializer;
2334     ToData.HasUninitializedReferenceMember
2335       = FromData.HasUninitializedReferenceMember;
2336     ToData.HasUninitializedFields = FromData.HasUninitializedFields;
2337     ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
2338     ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
2339     ToData.NeedOverloadResolutionForMoveConstructor
2340       = FromData.NeedOverloadResolutionForMoveConstructor;
2341     ToData.NeedOverloadResolutionForMoveAssignment
2342       = FromData.NeedOverloadResolutionForMoveAssignment;
2343     ToData.NeedOverloadResolutionForDestructor
2344       = FromData.NeedOverloadResolutionForDestructor;
2345     ToData.DefaultedMoveConstructorIsDeleted
2346       = FromData.DefaultedMoveConstructorIsDeleted;
2347     ToData.DefaultedMoveAssignmentIsDeleted
2348       = FromData.DefaultedMoveAssignmentIsDeleted;
2349     ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
2350     ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
2351     ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
2352     ToData.HasConstexprNonCopyMoveConstructor
2353       = FromData.HasConstexprNonCopyMoveConstructor;
2354     ToData.HasDefaultedDefaultConstructor
2355       = FromData.HasDefaultedDefaultConstructor;
2356     ToData.DefaultedDefaultConstructorIsConstexpr
2357       = FromData.DefaultedDefaultConstructorIsConstexpr;
2358     ToData.HasConstexprDefaultConstructor
2359       = FromData.HasConstexprDefaultConstructor;
2360     ToData.HasNonLiteralTypeFieldsOrBases
2361       = FromData.HasNonLiteralTypeFieldsOrBases;
2362     // ComputedVisibleConversions not imported.
2363     ToData.UserProvidedDefaultConstructor
2364       = FromData.UserProvidedDefaultConstructor;
2365     ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
2366     ToData.ImplicitCopyConstructorHasConstParam
2367       = FromData.ImplicitCopyConstructorHasConstParam;
2368     ToData.ImplicitCopyAssignmentHasConstParam
2369       = FromData.ImplicitCopyAssignmentHasConstParam;
2370     ToData.HasDeclaredCopyConstructorWithConstParam
2371       = FromData.HasDeclaredCopyConstructorWithConstParam;
2372     ToData.HasDeclaredCopyAssignmentWithConstParam
2373       = FromData.HasDeclaredCopyAssignmentWithConstParam;
2374     ToData.IsLambda = FromData.IsLambda;
2375 
2376     SmallVector<CXXBaseSpecifier *, 4> Bases;
2377     for (const auto &Base1 : FromCXX->bases()) {
2378       QualType T = Importer.Import(Base1.getType());
2379       if (T.isNull())
2380         return true;
2381 
2382       SourceLocation EllipsisLoc;
2383       if (Base1.isPackExpansion())
2384         EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2385 
2386       // Ensure that we have a definition for the base.
2387       ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2388 
2389       Bases.push_back(
2390                     new (Importer.getToContext())
2391                       CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2392                                        Base1.isVirtual(),
2393                                        Base1.isBaseOfClass(),
2394                                        Base1.getAccessSpecifierAsWritten(),
2395                                    Importer.Import(Base1.getTypeSourceInfo()),
2396                                        EllipsisLoc));
2397     }
2398     if (!Bases.empty())
2399       ToCXX->setBases(Bases.data(), Bases.size());
2400   }
2401 
2402   if (shouldForceImportDeclContext(Kind))
2403     ImportDeclContext(From, /*ForceImport=*/true);
2404 
2405   To->completeDefinition();
2406   return false;
2407 }
2408 
2409 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2410                                        ImportDefinitionKind Kind) {
2411   if (To->getAnyInitializer())
2412     return false;
2413 
2414   // FIXME: Can we really import any initializer? Alternatively, we could force
2415   // ourselves to import every declaration of a variable and then only use
2416   // getInit() here.
2417   To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2418 
2419   // FIXME: Other bits to merge?
2420 
2421   return false;
2422 }
2423 
2424 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2425                                        ImportDefinitionKind Kind) {
2426   if (To->getDefinition() || To->isBeingDefined()) {
2427     if (Kind == IDK_Everything)
2428       ImportDeclContext(From, /*ForceImport=*/true);
2429     return false;
2430   }
2431 
2432   To->startDefinition();
2433 
2434   QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2435   if (T.isNull())
2436     return true;
2437 
2438   QualType ToPromotionType = Importer.Import(From->getPromotionType());
2439   if (ToPromotionType.isNull())
2440     return true;
2441 
2442   if (shouldForceImportDeclContext(Kind))
2443     ImportDeclContext(From, /*ForceImport=*/true);
2444 
2445   // FIXME: we might need to merge the number of positive or negative bits
2446   // if the enumerator lists don't match.
2447   To->completeDefinition(T, ToPromotionType,
2448                          From->getNumPositiveBits(),
2449                          From->getNumNegativeBits());
2450   return false;
2451 }
2452 
2453 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2454                                                 TemplateParameterList *Params) {
2455   SmallVector<NamedDecl *, 4> ToParams(Params->size());
2456   if (ImportContainerChecked(*Params, ToParams))
2457     return nullptr;
2458 
2459   Expr *ToRequiresClause;
2460   if (Expr *const R = Params->getRequiresClause()) {
2461     ToRequiresClause = Importer.Import(R);
2462     if (!ToRequiresClause)
2463       return nullptr;
2464   } else {
2465     ToRequiresClause = nullptr;
2466   }
2467 
2468   return TemplateParameterList::Create(Importer.getToContext(),
2469                                        Importer.Import(Params->getTemplateLoc()),
2470                                        Importer.Import(Params->getLAngleLoc()),
2471                                        ToParams,
2472                                        Importer.Import(Params->getRAngleLoc()),
2473                                        ToRequiresClause);
2474 }
2475 
2476 TemplateArgument
2477 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2478   switch (From.getKind()) {
2479   case TemplateArgument::Null:
2480     return TemplateArgument();
2481 
2482   case TemplateArgument::Type: {
2483     QualType ToType = Importer.Import(From.getAsType());
2484     if (ToType.isNull())
2485       return TemplateArgument();
2486     return TemplateArgument(ToType);
2487   }
2488 
2489   case TemplateArgument::Integral: {
2490     QualType ToType = Importer.Import(From.getIntegralType());
2491     if (ToType.isNull())
2492       return TemplateArgument();
2493     return TemplateArgument(From, ToType);
2494   }
2495 
2496   case TemplateArgument::Declaration: {
2497     ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2498     QualType ToType = Importer.Import(From.getParamTypeForDecl());
2499     if (!To || ToType.isNull())
2500       return TemplateArgument();
2501     return TemplateArgument(To, ToType);
2502   }
2503 
2504   case TemplateArgument::NullPtr: {
2505     QualType ToType = Importer.Import(From.getNullPtrType());
2506     if (ToType.isNull())
2507       return TemplateArgument();
2508     return TemplateArgument(ToType, /*isNullPtr*/true);
2509   }
2510 
2511   case TemplateArgument::Template: {
2512     TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2513     if (ToTemplate.isNull())
2514       return TemplateArgument();
2515 
2516     return TemplateArgument(ToTemplate);
2517   }
2518 
2519   case TemplateArgument::TemplateExpansion: {
2520     TemplateName ToTemplate
2521       = Importer.Import(From.getAsTemplateOrTemplatePattern());
2522     if (ToTemplate.isNull())
2523       return TemplateArgument();
2524 
2525     return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2526   }
2527 
2528   case TemplateArgument::Expression:
2529     if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2530       return TemplateArgument(ToExpr);
2531     return TemplateArgument();
2532 
2533   case TemplateArgument::Pack: {
2534     SmallVector<TemplateArgument, 2> ToPack;
2535     ToPack.reserve(From.pack_size());
2536     if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2537       return TemplateArgument();
2538 
2539     return TemplateArgument(
2540         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2541   }
2542   }
2543 
2544   llvm_unreachable("Invalid template argument kind");
2545 }
2546 
2547 TemplateArgumentLoc ASTNodeImporter::ImportTemplateArgumentLoc(
2548     const TemplateArgumentLoc &TALoc, bool &Error) {
2549   Error = false;
2550   TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
2551   TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
2552   TemplateArgumentLocInfo ToInfo;
2553   if (Arg.getKind() == TemplateArgument::Expression) {
2554     Expr *E = Importer.Import(FromInfo.getAsExpr());
2555     ToInfo = TemplateArgumentLocInfo(E);
2556     if (!E)
2557       Error = true;
2558   } else if (Arg.getKind() == TemplateArgument::Type) {
2559     if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
2560       ToInfo = TemplateArgumentLocInfo(TSI);
2561     else
2562       Error = true;
2563   } else {
2564     ToInfo = TemplateArgumentLocInfo(
2565           Importer.Import(FromInfo.getTemplateQualifierLoc()),
2566           Importer.Import(FromInfo.getTemplateNameLoc()),
2567           Importer.Import(FromInfo.getTemplateEllipsisLoc()));
2568   }
2569   return TemplateArgumentLoc(Arg, ToInfo);
2570 }
2571 
2572 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2573                                               unsigned NumFromArgs,
2574                               SmallVectorImpl<TemplateArgument> &ToArgs) {
2575   for (unsigned I = 0; I != NumFromArgs; ++I) {
2576     TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2577     if (To.isNull() && !FromArgs[I].isNull())
2578       return true;
2579 
2580     ToArgs.push_back(To);
2581   }
2582 
2583   return false;
2584 }
2585 
2586 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2587                                         RecordDecl *ToRecord, bool Complain) {
2588   // Eliminate a potential failure point where we attempt to re-import
2589   // something we're trying to import while completing ToRecord.
2590   Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2591   if (ToOrigin) {
2592     RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2593     if (ToOriginRecord)
2594       ToRecord = ToOriginRecord;
2595   }
2596 
2597   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2598                                    ToRecord->getASTContext(),
2599                                    Importer.getNonEquivalentDecls(),
2600                                    false, Complain);
2601   return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2602 }
2603 
2604 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2605                                         bool Complain) {
2606   StructuralEquivalenceContext Ctx(
2607       Importer.getFromContext(), Importer.getToContext(),
2608       Importer.getNonEquivalentDecls(), false, Complain);
2609   return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2610 }
2611 
2612 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2613   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2614                                    Importer.getToContext(),
2615                                    Importer.getNonEquivalentDecls());
2616   return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2617 }
2618 
2619 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2620                                         EnumConstantDecl *ToEC)
2621 {
2622   const llvm::APSInt &FromVal = FromEC->getInitVal();
2623   const llvm::APSInt &ToVal = ToEC->getInitVal();
2624 
2625   return FromVal.isSigned() == ToVal.isSigned() &&
2626          FromVal.getBitWidth() == ToVal.getBitWidth() &&
2627          FromVal == ToVal;
2628 }
2629 
2630 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2631                                         ClassTemplateDecl *To) {
2632   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2633                                    Importer.getToContext(),
2634                                    Importer.getNonEquivalentDecls());
2635   return Ctx.IsStructurallyEquivalent(From, To);
2636 }
2637 
2638 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2639                                         VarTemplateDecl *To) {
2640   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2641                                    Importer.getToContext(),
2642                                    Importer.getNonEquivalentDecls());
2643   return Ctx.IsStructurallyEquivalent(From, To);
2644 }
2645 
2646 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2647   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2648     << D->getDeclKindName();
2649   return nullptr;
2650 }
2651 
2652 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2653   TranslationUnitDecl *ToD =
2654     Importer.getToContext().getTranslationUnitDecl();
2655 
2656   Importer.Imported(D, ToD);
2657 
2658   return ToD;
2659 }
2660 
2661 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2662 
2663   SourceLocation Loc = Importer.Import(D->getLocation());
2664   SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2665 
2666   // Import the context of this declaration.
2667   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2668   if (!DC)
2669     return nullptr;
2670 
2671   AccessSpecDecl *accessSpecDecl
2672     = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2673                              DC, Loc, ColonLoc);
2674 
2675   if (!accessSpecDecl)
2676     return nullptr;
2677 
2678   // Lexical DeclContext and Semantic DeclContext
2679   // is always the same for the accessSpec.
2680   accessSpecDecl->setLexicalDeclContext(DC);
2681   DC->addDeclInternal(accessSpecDecl);
2682 
2683   return accessSpecDecl;
2684 }
2685 
2686 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2687   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2688   if (!DC)
2689     return nullptr;
2690 
2691   DeclContext *LexicalDC = DC;
2692 
2693   // Import the location of this declaration.
2694   SourceLocation Loc = Importer.Import(D->getLocation());
2695 
2696   Expr *AssertExpr = Importer.Import(D->getAssertExpr());
2697   if (!AssertExpr)
2698     return nullptr;
2699 
2700   StringLiteral *FromMsg = D->getMessage();
2701   StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
2702   if (!ToMsg && FromMsg)
2703     return nullptr;
2704 
2705   StaticAssertDecl *ToD = StaticAssertDecl::Create(
2706         Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
2707         Importer.Import(D->getRParenLoc()), D->isFailed());
2708 
2709   ToD->setLexicalDeclContext(LexicalDC);
2710   LexicalDC->addDeclInternal(ToD);
2711   Importer.Imported(D, ToD);
2712   return ToD;
2713 }
2714 
2715 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2716   // Import the major distinguishing characteristics of this namespace.
2717   DeclContext *DC, *LexicalDC;
2718   DeclarationName Name;
2719   SourceLocation Loc;
2720   NamedDecl *ToD;
2721   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2722     return nullptr;
2723   if (ToD)
2724     return ToD;
2725 
2726   NamespaceDecl *MergeWithNamespace = nullptr;
2727   if (!Name) {
2728     // This is an anonymous namespace. Adopt an existing anonymous
2729     // namespace if we can.
2730     // FIXME: Not testable.
2731     if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2732       MergeWithNamespace = TU->getAnonymousNamespace();
2733     else
2734       MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2735   } else {
2736     SmallVector<NamedDecl *, 4> ConflictingDecls;
2737     SmallVector<NamedDecl *, 2> FoundDecls;
2738     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2739     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2740       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2741         continue;
2742 
2743       if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2744         MergeWithNamespace = FoundNS;
2745         ConflictingDecls.clear();
2746         break;
2747       }
2748 
2749       ConflictingDecls.push_back(FoundDecls[I]);
2750     }
2751 
2752     if (!ConflictingDecls.empty()) {
2753       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2754                                          ConflictingDecls.data(),
2755                                          ConflictingDecls.size());
2756     }
2757   }
2758 
2759   // Create the "to" namespace, if needed.
2760   NamespaceDecl *ToNamespace = MergeWithNamespace;
2761   if (!ToNamespace) {
2762     ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2763                                         D->isInline(),
2764                                         Importer.Import(D->getLocStart()),
2765                                         Loc, Name.getAsIdentifierInfo(),
2766                                         /*PrevDecl=*/nullptr);
2767     ToNamespace->setLexicalDeclContext(LexicalDC);
2768     LexicalDC->addDeclInternal(ToNamespace);
2769 
2770     // If this is an anonymous namespace, register it as the anonymous
2771     // namespace within its context.
2772     if (!Name) {
2773       if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2774         TU->setAnonymousNamespace(ToNamespace);
2775       else
2776         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2777     }
2778   }
2779   Importer.Imported(D, ToNamespace);
2780 
2781   ImportDeclContext(D);
2782 
2783   return ToNamespace;
2784 }
2785 
2786 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2787   // Import the major distinguishing characteristics of this typedef.
2788   DeclContext *DC, *LexicalDC;
2789   DeclarationName Name;
2790   SourceLocation Loc;
2791   NamedDecl *ToD;
2792   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2793     return nullptr;
2794   if (ToD)
2795     return ToD;
2796 
2797   // If this typedef is not in block scope, determine whether we've
2798   // seen a typedef with the same name (that we can merge with) or any
2799   // other entity by that name (which name lookup could conflict with).
2800   if (!DC->isFunctionOrMethod()) {
2801     SmallVector<NamedDecl *, 4> ConflictingDecls;
2802     unsigned IDNS = Decl::IDNS_Ordinary;
2803     SmallVector<NamedDecl *, 2> FoundDecls;
2804     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2805     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2806       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2807         continue;
2808       if (TypedefNameDecl *FoundTypedef =
2809             dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2810         if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2811                                             FoundTypedef->getUnderlyingType()))
2812           return Importer.Imported(D, FoundTypedef);
2813       }
2814 
2815       ConflictingDecls.push_back(FoundDecls[I]);
2816     }
2817 
2818     if (!ConflictingDecls.empty()) {
2819       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2820                                          ConflictingDecls.data(),
2821                                          ConflictingDecls.size());
2822       if (!Name)
2823         return nullptr;
2824     }
2825   }
2826 
2827   // Import the underlying type of this typedef;
2828   QualType T = Importer.Import(D->getUnderlyingType());
2829   if (T.isNull())
2830     return nullptr;
2831 
2832   // Create the new typedef node.
2833   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2834   SourceLocation StartL = Importer.Import(D->getLocStart());
2835   TypedefNameDecl *ToTypedef;
2836   if (IsAlias)
2837     ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2838                                       StartL, Loc,
2839                                       Name.getAsIdentifierInfo(),
2840                                       TInfo);
2841   else
2842     ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2843                                     StartL, Loc,
2844                                     Name.getAsIdentifierInfo(),
2845                                     TInfo);
2846 
2847   ToTypedef->setAccess(D->getAccess());
2848   ToTypedef->setLexicalDeclContext(LexicalDC);
2849   Importer.Imported(D, ToTypedef);
2850   LexicalDC->addDeclInternal(ToTypedef);
2851 
2852   return ToTypedef;
2853 }
2854 
2855 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2856   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2857 }
2858 
2859 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2860   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2861 }
2862 
2863 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2864   // Import the major distinguishing characteristics of this label.
2865   DeclContext *DC, *LexicalDC;
2866   DeclarationName Name;
2867   SourceLocation Loc;
2868   NamedDecl *ToD;
2869   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2870     return nullptr;
2871   if (ToD)
2872     return ToD;
2873 
2874   assert(LexicalDC->isFunctionOrMethod());
2875 
2876   LabelDecl *ToLabel = D->isGnuLocal()
2877       ? LabelDecl::Create(Importer.getToContext(),
2878                           DC, Importer.Import(D->getLocation()),
2879                           Name.getAsIdentifierInfo(),
2880                           Importer.Import(D->getLocStart()))
2881       : LabelDecl::Create(Importer.getToContext(),
2882                           DC, Importer.Import(D->getLocation()),
2883                           Name.getAsIdentifierInfo());
2884   Importer.Imported(D, ToLabel);
2885 
2886   LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2887   if (!Label)
2888     return nullptr;
2889 
2890   ToLabel->setStmt(Label);
2891   ToLabel->setLexicalDeclContext(LexicalDC);
2892   LexicalDC->addDeclInternal(ToLabel);
2893   return ToLabel;
2894 }
2895 
2896 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2897   // Import the major distinguishing characteristics of this enum.
2898   DeclContext *DC, *LexicalDC;
2899   DeclarationName Name;
2900   SourceLocation Loc;
2901   NamedDecl *ToD;
2902   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2903     return nullptr;
2904   if (ToD)
2905     return ToD;
2906 
2907   // Figure out what enum name we're looking for.
2908   unsigned IDNS = Decl::IDNS_Tag;
2909   DeclarationName SearchName = Name;
2910   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2911     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2912     IDNS = Decl::IDNS_Ordinary;
2913   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2914     IDNS |= Decl::IDNS_Ordinary;
2915 
2916   // We may already have an enum of the same name; try to find and match it.
2917   if (!DC->isFunctionOrMethod() && SearchName) {
2918     SmallVector<NamedDecl *, 4> ConflictingDecls;
2919     SmallVector<NamedDecl *, 2> FoundDecls;
2920     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2921     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2922       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2923         continue;
2924 
2925       Decl *Found = FoundDecls[I];
2926       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2927         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2928           Found = Tag->getDecl();
2929       }
2930 
2931       if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2932         if (IsStructuralMatch(D, FoundEnum))
2933           return Importer.Imported(D, FoundEnum);
2934       }
2935 
2936       ConflictingDecls.push_back(FoundDecls[I]);
2937     }
2938 
2939     if (!ConflictingDecls.empty()) {
2940       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2941                                          ConflictingDecls.data(),
2942                                          ConflictingDecls.size());
2943     }
2944   }
2945 
2946   // Create the enum declaration.
2947   EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2948                                   Importer.Import(D->getLocStart()),
2949                                   Loc, Name.getAsIdentifierInfo(), nullptr,
2950                                   D->isScoped(), D->isScopedUsingClassTag(),
2951                                   D->isFixed());
2952   // Import the qualifier, if any.
2953   D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2954   D2->setAccess(D->getAccess());
2955   D2->setLexicalDeclContext(LexicalDC);
2956   Importer.Imported(D, D2);
2957   LexicalDC->addDeclInternal(D2);
2958 
2959   // Import the integer type.
2960   QualType ToIntegerType = Importer.Import(D->getIntegerType());
2961   if (ToIntegerType.isNull())
2962     return nullptr;
2963   D2->setIntegerType(ToIntegerType);
2964 
2965   // Import the definition
2966   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2967     return nullptr;
2968 
2969   return D2;
2970 }
2971 
2972 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2973   // If this record has a definition in the translation unit we're coming from,
2974   // but this particular declaration is not that definition, import the
2975   // definition and map to that.
2976   TagDecl *Definition = D->getDefinition();
2977   if (Definition && Definition != D) {
2978     Decl *ImportedDef = Importer.Import(Definition);
2979     if (!ImportedDef)
2980       return nullptr;
2981 
2982     return Importer.Imported(D, ImportedDef);
2983   }
2984 
2985   // Import the major distinguishing characteristics of this record.
2986   DeclContext *DC, *LexicalDC;
2987   DeclarationName Name;
2988   SourceLocation Loc;
2989   NamedDecl *ToD;
2990   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2991     return nullptr;
2992   if (ToD)
2993     return ToD;
2994 
2995   // Figure out what structure name we're looking for.
2996   unsigned IDNS = Decl::IDNS_Tag;
2997   DeclarationName SearchName = Name;
2998   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2999     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
3000     IDNS = Decl::IDNS_Ordinary;
3001   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3002     IDNS |= Decl::IDNS_Ordinary;
3003 
3004   // We may already have a record of the same name; try to find and match it.
3005   RecordDecl *AdoptDecl = nullptr;
3006   if (!DC->isFunctionOrMethod()) {
3007     SmallVector<NamedDecl *, 4> ConflictingDecls;
3008     SmallVector<NamedDecl *, 2> FoundDecls;
3009     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3010     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3011       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3012         continue;
3013 
3014       Decl *Found = FoundDecls[I];
3015       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3016         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3017           Found = Tag->getDecl();
3018       }
3019 
3020       if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3021         if (D->isAnonymousStructOrUnion() &&
3022             FoundRecord->isAnonymousStructOrUnion()) {
3023           // If both anonymous structs/unions are in a record context, make sure
3024           // they occur in the same location in the context records.
3025           if (Optional<unsigned> Index1
3026               = findUntaggedStructOrUnionIndex(D)) {
3027             if (Optional<unsigned> Index2 =
3028                     findUntaggedStructOrUnionIndex(FoundRecord)) {
3029               if (*Index1 != *Index2)
3030                 continue;
3031             }
3032           }
3033         }
3034 
3035         if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
3036           if ((SearchName && !D->isCompleteDefinition())
3037               || (D->isCompleteDefinition() &&
3038                   D->isAnonymousStructOrUnion()
3039                     == FoundDef->isAnonymousStructOrUnion() &&
3040                   IsStructuralMatch(D, FoundDef))) {
3041             // The record types structurally match, or the "from" translation
3042             // unit only had a forward declaration anyway; call it the same
3043             // function.
3044             // FIXME: For C++, we should also merge methods here.
3045             return Importer.Imported(D, FoundDef);
3046           }
3047         } else if (!D->isCompleteDefinition()) {
3048           // We have a forward declaration of this type, so adopt that forward
3049           // declaration rather than building a new one.
3050 
3051           // If one or both can be completed from external storage then try one
3052           // last time to complete and compare them before doing this.
3053 
3054           if (FoundRecord->hasExternalLexicalStorage() &&
3055               !FoundRecord->isCompleteDefinition())
3056             FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
3057           if (D->hasExternalLexicalStorage())
3058             D->getASTContext().getExternalSource()->CompleteType(D);
3059 
3060           if (FoundRecord->isCompleteDefinition() &&
3061               D->isCompleteDefinition() &&
3062               !IsStructuralMatch(D, FoundRecord))
3063             continue;
3064 
3065           AdoptDecl = FoundRecord;
3066           continue;
3067         } else if (!SearchName) {
3068           continue;
3069         }
3070       }
3071 
3072       ConflictingDecls.push_back(FoundDecls[I]);
3073     }
3074 
3075     if (!ConflictingDecls.empty() && SearchName) {
3076       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3077                                          ConflictingDecls.data(),
3078                                          ConflictingDecls.size());
3079     }
3080   }
3081 
3082   // Create the record declaration.
3083   RecordDecl *D2 = AdoptDecl;
3084   SourceLocation StartLoc = Importer.Import(D->getLocStart());
3085   if (!D2) {
3086     CXXRecordDecl *D2CXX = nullptr;
3087     if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
3088       if (DCXX->isLambda()) {
3089         TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
3090         D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
3091                                             DC, TInfo, Loc,
3092                                             DCXX->isDependentLambda(),
3093                                             DCXX->isGenericLambda(),
3094                                             DCXX->getLambdaCaptureDefault());
3095         Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
3096         if (DCXX->getLambdaContextDecl() && !CDecl)
3097           return nullptr;
3098         D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
3099       } else if (DCXX->isInjectedClassName()) {
3100         // We have to be careful to do a similar dance to the one in
3101         // Sema::ActOnStartCXXMemberDeclarations
3102         CXXRecordDecl *const PrevDecl = nullptr;
3103         const bool DelayTypeCreation = true;
3104         D2CXX = CXXRecordDecl::Create(
3105             Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
3106             Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
3107         Importer.getToContext().getTypeDeclType(
3108             D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
3109       } else {
3110         D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
3111                                       D->getTagKind(),
3112                                       DC, StartLoc, Loc,
3113                                       Name.getAsIdentifierInfo());
3114       }
3115       D2 = D2CXX;
3116       D2->setAccess(D->getAccess());
3117     } else {
3118       D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
3119                               DC, StartLoc, Loc, Name.getAsIdentifierInfo());
3120     }
3121 
3122     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3123     D2->setLexicalDeclContext(LexicalDC);
3124     LexicalDC->addDeclInternal(D2);
3125     if (D->isAnonymousStructOrUnion())
3126       D2->setAnonymousStructOrUnion(true);
3127   }
3128 
3129   Importer.Imported(D, D2);
3130 
3131   if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
3132     return nullptr;
3133 
3134   return D2;
3135 }
3136 
3137 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3138   // Import the major distinguishing characteristics of this enumerator.
3139   DeclContext *DC, *LexicalDC;
3140   DeclarationName Name;
3141   SourceLocation Loc;
3142   NamedDecl *ToD;
3143   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3144     return nullptr;
3145   if (ToD)
3146     return ToD;
3147 
3148   QualType T = Importer.Import(D->getType());
3149   if (T.isNull())
3150     return nullptr;
3151 
3152   // Determine whether there are any other declarations with the same name and
3153   // in the same context.
3154   if (!LexicalDC->isFunctionOrMethod()) {
3155     SmallVector<NamedDecl *, 4> ConflictingDecls;
3156     unsigned IDNS = Decl::IDNS_Ordinary;
3157     SmallVector<NamedDecl *, 2> FoundDecls;
3158     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3159     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3160       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3161         continue;
3162 
3163       if (EnumConstantDecl *FoundEnumConstant
3164             = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
3165         if (IsStructuralMatch(D, FoundEnumConstant))
3166           return Importer.Imported(D, FoundEnumConstant);
3167       }
3168 
3169       ConflictingDecls.push_back(FoundDecls[I]);
3170     }
3171 
3172     if (!ConflictingDecls.empty()) {
3173       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3174                                          ConflictingDecls.data(),
3175                                          ConflictingDecls.size());
3176       if (!Name)
3177         return nullptr;
3178     }
3179   }
3180 
3181   Expr *Init = Importer.Import(D->getInitExpr());
3182   if (D->getInitExpr() && !Init)
3183     return nullptr;
3184 
3185   EnumConstantDecl *ToEnumerator
3186     = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3187                                Name.getAsIdentifierInfo(), T,
3188                                Init, D->getInitVal());
3189   ToEnumerator->setAccess(D->getAccess());
3190   ToEnumerator->setLexicalDeclContext(LexicalDC);
3191   Importer.Imported(D, ToEnumerator);
3192   LexicalDC->addDeclInternal(ToEnumerator);
3193   return ToEnumerator;
3194 }
3195 
3196 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3197   // Import the major distinguishing characteristics of this function.
3198   DeclContext *DC, *LexicalDC;
3199   DeclarationName Name;
3200   SourceLocation Loc;
3201   NamedDecl *ToD;
3202   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3203     return nullptr;
3204   if (ToD)
3205     return ToD;
3206 
3207   // Try to find a function in our own ("to") context with the same name, same
3208   // type, and in the same context as the function we're importing.
3209   if (!LexicalDC->isFunctionOrMethod()) {
3210     SmallVector<NamedDecl *, 4> ConflictingDecls;
3211     unsigned IDNS = Decl::IDNS_Ordinary;
3212     SmallVector<NamedDecl *, 2> FoundDecls;
3213     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3214     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3215       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3216         continue;
3217 
3218       if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
3219         if (FoundFunction->hasExternalFormalLinkage() &&
3220             D->hasExternalFormalLinkage()) {
3221           if (Importer.IsStructurallyEquivalent(D->getType(),
3222                                                 FoundFunction->getType())) {
3223             // FIXME: Actually try to merge the body and other attributes.
3224             return Importer.Imported(D, FoundFunction);
3225           }
3226 
3227           // FIXME: Check for overloading more carefully, e.g., by boosting
3228           // Sema::IsOverload out to the AST library.
3229 
3230           // Function overloading is okay in C++.
3231           if (Importer.getToContext().getLangOpts().CPlusPlus)
3232             continue;
3233 
3234           // Complain about inconsistent function types.
3235           Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
3236             << Name << D->getType() << FoundFunction->getType();
3237           Importer.ToDiag(FoundFunction->getLocation(),
3238                           diag::note_odr_value_here)
3239             << FoundFunction->getType();
3240         }
3241       }
3242 
3243       ConflictingDecls.push_back(FoundDecls[I]);
3244     }
3245 
3246     if (!ConflictingDecls.empty()) {
3247       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3248                                          ConflictingDecls.data(),
3249                                          ConflictingDecls.size());
3250       if (!Name)
3251         return nullptr;
3252     }
3253   }
3254 
3255   DeclarationNameInfo NameInfo(Name, Loc);
3256   // Import additional name location/type info.
3257   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3258 
3259   QualType FromTy = D->getType();
3260   bool usedDifferentExceptionSpec = false;
3261 
3262   if (const FunctionProtoType *
3263         FromFPT = D->getType()->getAs<FunctionProtoType>()) {
3264     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3265     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3266     // FunctionDecl that we are importing the FunctionProtoType for.
3267     // To avoid an infinite recursion when importing, create the FunctionDecl
3268     // with a simplified function type and update it afterwards.
3269     if (FromEPI.ExceptionSpec.SourceDecl ||
3270         FromEPI.ExceptionSpec.SourceTemplate ||
3271         FromEPI.ExceptionSpec.NoexceptExpr) {
3272       FunctionProtoType::ExtProtoInfo DefaultEPI;
3273       FromTy = Importer.getFromContext().getFunctionType(
3274           FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
3275       usedDifferentExceptionSpec = true;
3276     }
3277   }
3278 
3279   // Import the type.
3280   QualType T = Importer.Import(FromTy);
3281   if (T.isNull())
3282     return nullptr;
3283 
3284   // Import the function parameters.
3285   SmallVector<ParmVarDecl *, 8> Parameters;
3286   for (auto P : D->parameters()) {
3287     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3288     if (!ToP)
3289       return nullptr;
3290 
3291     Parameters.push_back(ToP);
3292   }
3293 
3294   // Create the imported function.
3295   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3296   FunctionDecl *ToFunction = nullptr;
3297   SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3298   if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3299     ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3300                                             cast<CXXRecordDecl>(DC),
3301                                             InnerLocStart,
3302                                             NameInfo, T, TInfo,
3303                                             FromConstructor->isExplicit(),
3304                                             D->isInlineSpecified(),
3305                                             D->isImplicit(),
3306                                             D->isConstexpr());
3307     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3308       SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
3309       for (CXXCtorInitializer *I : FromConstructor->inits()) {
3310         CXXCtorInitializer *ToI =
3311             cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3312         if (!ToI && I)
3313           return nullptr;
3314         CtorInitializers.push_back(ToI);
3315       }
3316       CXXCtorInitializer **Memory =
3317           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3318       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3319       CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
3320       ToCtor->setCtorInitializers(Memory);
3321       ToCtor->setNumCtorInitializers(NumInitializers);
3322     }
3323   } else if (isa<CXXDestructorDecl>(D)) {
3324     ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3325                                            cast<CXXRecordDecl>(DC),
3326                                            InnerLocStart,
3327                                            NameInfo, T, TInfo,
3328                                            D->isInlineSpecified(),
3329                                            D->isImplicit());
3330   } else if (CXXConversionDecl *FromConversion
3331                                            = dyn_cast<CXXConversionDecl>(D)) {
3332     ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3333                                            cast<CXXRecordDecl>(DC),
3334                                            InnerLocStart,
3335                                            NameInfo, T, TInfo,
3336                                            D->isInlineSpecified(),
3337                                            FromConversion->isExplicit(),
3338                                            D->isConstexpr(),
3339                                            Importer.Import(D->getLocEnd()));
3340   } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3341     ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3342                                        cast<CXXRecordDecl>(DC),
3343                                        InnerLocStart,
3344                                        NameInfo, T, TInfo,
3345                                        Method->getStorageClass(),
3346                                        Method->isInlineSpecified(),
3347                                        D->isConstexpr(),
3348                                        Importer.Import(D->getLocEnd()));
3349   } else {
3350     ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3351                                       InnerLocStart,
3352                                       NameInfo, T, TInfo, D->getStorageClass(),
3353                                       D->isInlineSpecified(),
3354                                       D->hasWrittenPrototype(),
3355                                       D->isConstexpr());
3356   }
3357 
3358   // Import the qualifier, if any.
3359   ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3360   ToFunction->setAccess(D->getAccess());
3361   ToFunction->setLexicalDeclContext(LexicalDC);
3362   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3363   ToFunction->setTrivial(D->isTrivial());
3364   ToFunction->setPure(D->isPure());
3365   Importer.Imported(D, ToFunction);
3366 
3367   // Set the parameters.
3368   for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
3369     Parameters[I]->setOwningFunction(ToFunction);
3370     ToFunction->addDeclInternal(Parameters[I]);
3371   }
3372   ToFunction->setParams(Parameters);
3373 
3374   if (usedDifferentExceptionSpec) {
3375     // Update FunctionProtoType::ExtProtoInfo.
3376     QualType T = Importer.Import(D->getType());
3377     if (T.isNull())
3378       return nullptr;
3379     ToFunction->setType(T);
3380   }
3381 
3382   // Import the body, if any.
3383   if (Stmt *FromBody = D->getBody()) {
3384     if (Stmt *ToBody = Importer.Import(FromBody)) {
3385       ToFunction->setBody(ToBody);
3386     }
3387   }
3388 
3389   // FIXME: Other bits to merge?
3390 
3391   // Add this function to the lexical context.
3392   LexicalDC->addDeclInternal(ToFunction);
3393 
3394   return ToFunction;
3395 }
3396 
3397 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3398   return VisitFunctionDecl(D);
3399 }
3400 
3401 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3402   return VisitCXXMethodDecl(D);
3403 }
3404 
3405 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3406   return VisitCXXMethodDecl(D);
3407 }
3408 
3409 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3410   return VisitCXXMethodDecl(D);
3411 }
3412 
3413 static unsigned getFieldIndex(Decl *F) {
3414   RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
3415   if (!Owner)
3416     return 0;
3417 
3418   unsigned Index = 1;
3419   for (const auto *D : Owner->noload_decls()) {
3420     if (D == F)
3421       return Index;
3422 
3423     if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
3424       ++Index;
3425   }
3426 
3427   return Index;
3428 }
3429 
3430 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3431   // Import the major distinguishing characteristics of a variable.
3432   DeclContext *DC, *LexicalDC;
3433   DeclarationName Name;
3434   SourceLocation Loc;
3435   NamedDecl *ToD;
3436   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3437     return nullptr;
3438   if (ToD)
3439     return ToD;
3440 
3441   // Determine whether we've already imported this field.
3442   SmallVector<NamedDecl *, 2> FoundDecls;
3443   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3444   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3445     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
3446       // For anonymous fields, match up by index.
3447       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3448         continue;
3449 
3450       if (Importer.IsStructurallyEquivalent(D->getType(),
3451                                             FoundField->getType())) {
3452         Importer.Imported(D, FoundField);
3453         return FoundField;
3454       }
3455 
3456       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3457         << Name << D->getType() << FoundField->getType();
3458       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3459         << FoundField->getType();
3460       return nullptr;
3461     }
3462   }
3463 
3464   // Import the type.
3465   QualType T = Importer.Import(D->getType());
3466   if (T.isNull())
3467     return nullptr;
3468 
3469   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3470   Expr *BitWidth = Importer.Import(D->getBitWidth());
3471   if (!BitWidth && D->getBitWidth())
3472     return nullptr;
3473 
3474   FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3475                                          Importer.Import(D->getInnerLocStart()),
3476                                          Loc, Name.getAsIdentifierInfo(),
3477                                          T, TInfo, BitWidth, D->isMutable(),
3478                                          D->getInClassInitStyle());
3479   ToField->setAccess(D->getAccess());
3480   ToField->setLexicalDeclContext(LexicalDC);
3481   if (Expr *FromInitializer = D->getInClassInitializer()) {
3482     Expr *ToInitializer = Importer.Import(FromInitializer);
3483     if (ToInitializer)
3484       ToField->setInClassInitializer(ToInitializer);
3485     else
3486       return nullptr;
3487   }
3488   ToField->setImplicit(D->isImplicit());
3489   Importer.Imported(D, ToField);
3490   LexicalDC->addDeclInternal(ToField);
3491   return ToField;
3492 }
3493 
3494 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3495   // Import the major distinguishing characteristics of a variable.
3496   DeclContext *DC, *LexicalDC;
3497   DeclarationName Name;
3498   SourceLocation Loc;
3499   NamedDecl *ToD;
3500   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3501     return nullptr;
3502   if (ToD)
3503     return ToD;
3504 
3505   // Determine whether we've already imported this field.
3506   SmallVector<NamedDecl *, 2> FoundDecls;
3507   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3508   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3509     if (IndirectFieldDecl *FoundField
3510                                 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3511       // For anonymous indirect fields, match up by index.
3512       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3513         continue;
3514 
3515       if (Importer.IsStructurallyEquivalent(D->getType(),
3516                                             FoundField->getType(),
3517                                             !Name.isEmpty())) {
3518         Importer.Imported(D, FoundField);
3519         return FoundField;
3520       }
3521 
3522       // If there are more anonymous fields to check, continue.
3523       if (!Name && I < N-1)
3524         continue;
3525 
3526       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3527         << Name << D->getType() << FoundField->getType();
3528       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3529         << FoundField->getType();
3530       return nullptr;
3531     }
3532   }
3533 
3534   // Import the type.
3535   QualType T = Importer.Import(D->getType());
3536   if (T.isNull())
3537     return nullptr;
3538 
3539   NamedDecl **NamedChain =
3540     new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3541 
3542   unsigned i = 0;
3543   for (auto *PI : D->chain()) {
3544     Decl *D = Importer.Import(PI);
3545     if (!D)
3546       return nullptr;
3547     NamedChain[i++] = cast<NamedDecl>(D);
3548   }
3549 
3550   IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3551       Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3552       {NamedChain, D->getChainingSize()});
3553 
3554   for (const auto *Attr : D->attrs())
3555     ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3556 
3557   ToIndirectField->setAccess(D->getAccess());
3558   ToIndirectField->setLexicalDeclContext(LexicalDC);
3559   Importer.Imported(D, ToIndirectField);
3560   LexicalDC->addDeclInternal(ToIndirectField);
3561   return ToIndirectField;
3562 }
3563 
3564 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3565   // Import the major distinguishing characteristics of a declaration.
3566   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3567   DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
3568       ? DC : Importer.ImportContext(D->getLexicalDeclContext());
3569   if (!DC || !LexicalDC)
3570     return nullptr;
3571 
3572   // Determine whether we've already imported this decl.
3573   // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
3574   auto *RD = cast<CXXRecordDecl>(DC);
3575   FriendDecl *ImportedFriend = RD->getFirstFriend();
3576   StructuralEquivalenceContext Context(
3577       Importer.getFromContext(), Importer.getToContext(),
3578       Importer.getNonEquivalentDecls(), false, false);
3579 
3580   while (ImportedFriend) {
3581     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3582       if (Context.IsStructurallyEquivalent(D->getFriendDecl(),
3583                                            ImportedFriend->getFriendDecl()))
3584         return Importer.Imported(D, ImportedFriend);
3585 
3586     } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3587       if (Importer.IsStructurallyEquivalent(
3588             D->getFriendType()->getType(),
3589             ImportedFriend->getFriendType()->getType(), true))
3590         return Importer.Imported(D, ImportedFriend);
3591     }
3592     ImportedFriend = ImportedFriend->getNextFriend();
3593   }
3594 
3595   // Not found. Create it.
3596   FriendDecl::FriendUnion ToFU;
3597   if (NamedDecl *FriendD = D->getFriendDecl())
3598     ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3599   else
3600     ToFU = Importer.Import(D->getFriendType());
3601   if (!ToFU)
3602     return nullptr;
3603 
3604   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3605   TemplateParameterList **FromTPLists =
3606       D->getTrailingObjects<TemplateParameterList *>();
3607   for (unsigned I = 0; I < D->NumTPLists; I++) {
3608     TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3609     if (!List)
3610       return nullptr;
3611     ToTPLists[I] = List;
3612   }
3613 
3614   FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC,
3615                                        Importer.Import(D->getLocation()),
3616                                        ToFU, Importer.Import(D->getFriendLoc()),
3617                                        ToTPLists);
3618 
3619   Importer.Imported(D, FrD);
3620   RD->pushFriendDecl(FrD);
3621 
3622   FrD->setAccess(D->getAccess());
3623   FrD->setLexicalDeclContext(LexicalDC);
3624   LexicalDC->addDeclInternal(FrD);
3625   return FrD;
3626 }
3627 
3628 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3629   // Import the major distinguishing characteristics of an ivar.
3630   DeclContext *DC, *LexicalDC;
3631   DeclarationName Name;
3632   SourceLocation Loc;
3633   NamedDecl *ToD;
3634   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3635     return nullptr;
3636   if (ToD)
3637     return ToD;
3638 
3639   // Determine whether we've already imported this ivar
3640   SmallVector<NamedDecl *, 2> FoundDecls;
3641   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3642   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3643     if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3644       if (Importer.IsStructurallyEquivalent(D->getType(),
3645                                             FoundIvar->getType())) {
3646         Importer.Imported(D, FoundIvar);
3647         return FoundIvar;
3648       }
3649 
3650       Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3651         << Name << D->getType() << FoundIvar->getType();
3652       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3653         << FoundIvar->getType();
3654       return nullptr;
3655     }
3656   }
3657 
3658   // Import the type.
3659   QualType T = Importer.Import(D->getType());
3660   if (T.isNull())
3661     return nullptr;
3662 
3663   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3664   Expr *BitWidth = Importer.Import(D->getBitWidth());
3665   if (!BitWidth && D->getBitWidth())
3666     return nullptr;
3667 
3668   ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3669                                               cast<ObjCContainerDecl>(DC),
3670                                        Importer.Import(D->getInnerLocStart()),
3671                                               Loc, Name.getAsIdentifierInfo(),
3672                                               T, TInfo, D->getAccessControl(),
3673                                               BitWidth, D->getSynthesize());
3674   ToIvar->setLexicalDeclContext(LexicalDC);
3675   Importer.Imported(D, ToIvar);
3676   LexicalDC->addDeclInternal(ToIvar);
3677   return ToIvar;
3678 
3679 }
3680 
3681 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3682   // Import the major distinguishing characteristics of a variable.
3683   DeclContext *DC, *LexicalDC;
3684   DeclarationName Name;
3685   SourceLocation Loc;
3686   NamedDecl *ToD;
3687   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3688     return nullptr;
3689   if (ToD)
3690     return ToD;
3691 
3692   // Try to find a variable in our own ("to") context with the same name and
3693   // in the same context as the variable we're importing.
3694   if (D->isFileVarDecl()) {
3695     VarDecl *MergeWithVar = nullptr;
3696     SmallVector<NamedDecl *, 4> ConflictingDecls;
3697     unsigned IDNS = Decl::IDNS_Ordinary;
3698     SmallVector<NamedDecl *, 2> FoundDecls;
3699     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3700     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3701       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3702         continue;
3703 
3704       if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3705         // We have found a variable that we may need to merge with. Check it.
3706         if (FoundVar->hasExternalFormalLinkage() &&
3707             D->hasExternalFormalLinkage()) {
3708           if (Importer.IsStructurallyEquivalent(D->getType(),
3709                                                 FoundVar->getType())) {
3710             MergeWithVar = FoundVar;
3711             break;
3712           }
3713 
3714           const ArrayType *FoundArray
3715             = Importer.getToContext().getAsArrayType(FoundVar->getType());
3716           const ArrayType *TArray
3717             = Importer.getToContext().getAsArrayType(D->getType());
3718           if (FoundArray && TArray) {
3719             if (isa<IncompleteArrayType>(FoundArray) &&
3720                 isa<ConstantArrayType>(TArray)) {
3721               // Import the type.
3722               QualType T = Importer.Import(D->getType());
3723               if (T.isNull())
3724                 return nullptr;
3725 
3726               FoundVar->setType(T);
3727               MergeWithVar = FoundVar;
3728               break;
3729             } else if (isa<IncompleteArrayType>(TArray) &&
3730                        isa<ConstantArrayType>(FoundArray)) {
3731               MergeWithVar = FoundVar;
3732               break;
3733             }
3734           }
3735 
3736           Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3737             << Name << D->getType() << FoundVar->getType();
3738           Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3739             << FoundVar->getType();
3740         }
3741       }
3742 
3743       ConflictingDecls.push_back(FoundDecls[I]);
3744     }
3745 
3746     if (MergeWithVar) {
3747       // An equivalent variable with external linkage has been found. Link
3748       // the two declarations, then merge them.
3749       Importer.Imported(D, MergeWithVar);
3750 
3751       if (VarDecl *DDef = D->getDefinition()) {
3752         if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3753           Importer.ToDiag(ExistingDef->getLocation(),
3754                           diag::err_odr_variable_multiple_def)
3755             << Name;
3756           Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3757         } else {
3758           Expr *Init = Importer.Import(DDef->getInit());
3759           MergeWithVar->setInit(Init);
3760           if (DDef->isInitKnownICE()) {
3761             EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3762             Eval->CheckedICE = true;
3763             Eval->IsICE = DDef->isInitICE();
3764           }
3765         }
3766       }
3767 
3768       return MergeWithVar;
3769     }
3770 
3771     if (!ConflictingDecls.empty()) {
3772       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3773                                          ConflictingDecls.data(),
3774                                          ConflictingDecls.size());
3775       if (!Name)
3776         return nullptr;
3777     }
3778   }
3779 
3780   // Import the type.
3781   QualType T = Importer.Import(D->getType());
3782   if (T.isNull())
3783     return nullptr;
3784 
3785   // Create the imported variable.
3786   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3787   VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3788                                    Importer.Import(D->getInnerLocStart()),
3789                                    Loc, Name.getAsIdentifierInfo(),
3790                                    T, TInfo,
3791                                    D->getStorageClass());
3792   ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3793   ToVar->setAccess(D->getAccess());
3794   ToVar->setLexicalDeclContext(LexicalDC);
3795   Importer.Imported(D, ToVar);
3796   LexicalDC->addDeclInternal(ToVar);
3797 
3798   if (!D->isFileVarDecl() &&
3799       D->isUsed())
3800     ToVar->setIsUsed();
3801 
3802   // Merge the initializer.
3803   if (ImportDefinition(D, ToVar))
3804     return nullptr;
3805 
3806   if (D->isConstexpr())
3807     ToVar->setConstexpr(true);
3808 
3809   return ToVar;
3810 }
3811 
3812 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3813   // Parameters are created in the translation unit's context, then moved
3814   // into the function declaration's context afterward.
3815   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3816 
3817   // Import the name of this declaration.
3818   DeclarationName Name = Importer.Import(D->getDeclName());
3819   if (D->getDeclName() && !Name)
3820     return nullptr;
3821 
3822   // Import the location of this declaration.
3823   SourceLocation Loc = Importer.Import(D->getLocation());
3824 
3825   // Import the parameter's type.
3826   QualType T = Importer.Import(D->getType());
3827   if (T.isNull())
3828     return nullptr;
3829 
3830   // Create the imported parameter.
3831   ImplicitParamDecl *ToParm
3832     = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3833                                 Loc, Name.getAsIdentifierInfo(),
3834                                 T);
3835   return Importer.Imported(D, ToParm);
3836 }
3837 
3838 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3839   // Parameters are created in the translation unit's context, then moved
3840   // into the function declaration's context afterward.
3841   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3842 
3843   // Import the name of this declaration.
3844   DeclarationName Name = Importer.Import(D->getDeclName());
3845   if (D->getDeclName() && !Name)
3846     return nullptr;
3847 
3848   // Import the location of this declaration.
3849   SourceLocation Loc = Importer.Import(D->getLocation());
3850 
3851   // Import the parameter's type.
3852   QualType T = Importer.Import(D->getType());
3853   if (T.isNull())
3854     return nullptr;
3855 
3856   // Create the imported parameter.
3857   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3858   ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3859                                      Importer.Import(D->getInnerLocStart()),
3860                                             Loc, Name.getAsIdentifierInfo(),
3861                                             T, TInfo, D->getStorageClass(),
3862                                             /*FIXME: Default argument*/nullptr);
3863   ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3864 
3865   if (D->isUsed())
3866     ToParm->setIsUsed();
3867 
3868   return Importer.Imported(D, ToParm);
3869 }
3870 
3871 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3872   // Import the major distinguishing characteristics of a method.
3873   DeclContext *DC, *LexicalDC;
3874   DeclarationName Name;
3875   SourceLocation Loc;
3876   NamedDecl *ToD;
3877   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3878     return nullptr;
3879   if (ToD)
3880     return ToD;
3881 
3882   SmallVector<NamedDecl *, 2> FoundDecls;
3883   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3884   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3885     if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3886       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3887         continue;
3888 
3889       // Check return types.
3890       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3891                                              FoundMethod->getReturnType())) {
3892         Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3893             << D->isInstanceMethod() << Name << D->getReturnType()
3894             << FoundMethod->getReturnType();
3895         Importer.ToDiag(FoundMethod->getLocation(),
3896                         diag::note_odr_objc_method_here)
3897           << D->isInstanceMethod() << Name;
3898         return nullptr;
3899       }
3900 
3901       // Check the number of parameters.
3902       if (D->param_size() != FoundMethod->param_size()) {
3903         Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3904           << D->isInstanceMethod() << Name
3905           << D->param_size() << FoundMethod->param_size();
3906         Importer.ToDiag(FoundMethod->getLocation(),
3907                         diag::note_odr_objc_method_here)
3908           << D->isInstanceMethod() << Name;
3909         return nullptr;
3910       }
3911 
3912       // Check parameter types.
3913       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3914              PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3915            P != PEnd; ++P, ++FoundP) {
3916         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3917                                                (*FoundP)->getType())) {
3918           Importer.FromDiag((*P)->getLocation(),
3919                             diag::err_odr_objc_method_param_type_inconsistent)
3920             << D->isInstanceMethod() << Name
3921             << (*P)->getType() << (*FoundP)->getType();
3922           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3923             << (*FoundP)->getType();
3924           return nullptr;
3925         }
3926       }
3927 
3928       // Check variadic/non-variadic.
3929       // Check the number of parameters.
3930       if (D->isVariadic() != FoundMethod->isVariadic()) {
3931         Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3932           << D->isInstanceMethod() << Name;
3933         Importer.ToDiag(FoundMethod->getLocation(),
3934                         diag::note_odr_objc_method_here)
3935           << D->isInstanceMethod() << Name;
3936         return nullptr;
3937       }
3938 
3939       // FIXME: Any other bits we need to merge?
3940       return Importer.Imported(D, FoundMethod);
3941     }
3942   }
3943 
3944   // Import the result type.
3945   QualType ResultTy = Importer.Import(D->getReturnType());
3946   if (ResultTy.isNull())
3947     return nullptr;
3948 
3949   TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3950 
3951   ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3952       Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3953       Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3954       D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3955       D->getImplementationControl(), D->hasRelatedResultType());
3956 
3957   // FIXME: When we decide to merge method definitions, we'll need to
3958   // deal with implicit parameters.
3959 
3960   // Import the parameters
3961   SmallVector<ParmVarDecl *, 5> ToParams;
3962   for (auto *FromP : D->parameters()) {
3963     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3964     if (!ToP)
3965       return nullptr;
3966 
3967     ToParams.push_back(ToP);
3968   }
3969 
3970   // Set the parameters.
3971   for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3972     ToParams[I]->setOwningFunction(ToMethod);
3973     ToMethod->addDeclInternal(ToParams[I]);
3974   }
3975   SmallVector<SourceLocation, 12> SelLocs;
3976   D->getSelectorLocs(SelLocs);
3977   ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3978 
3979   ToMethod->setLexicalDeclContext(LexicalDC);
3980   Importer.Imported(D, ToMethod);
3981   LexicalDC->addDeclInternal(ToMethod);
3982   return ToMethod;
3983 }
3984 
3985 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3986   // Import the major distinguishing characteristics of a category.
3987   DeclContext *DC, *LexicalDC;
3988   DeclarationName Name;
3989   SourceLocation Loc;
3990   NamedDecl *ToD;
3991   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3992     return nullptr;
3993   if (ToD)
3994     return ToD;
3995 
3996   TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3997   if (!BoundInfo)
3998     return nullptr;
3999 
4000   ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
4001                                 Importer.getToContext(), DC,
4002                                 D->getVariance(),
4003                                 Importer.Import(D->getVarianceLoc()),
4004                                 D->getIndex(),
4005                                 Importer.Import(D->getLocation()),
4006                                 Name.getAsIdentifierInfo(),
4007                                 Importer.Import(D->getColonLoc()),
4008                                 BoundInfo);
4009   Importer.Imported(D, Result);
4010   Result->setLexicalDeclContext(LexicalDC);
4011   return Result;
4012 }
4013 
4014 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4015   // Import the major distinguishing characteristics of a category.
4016   DeclContext *DC, *LexicalDC;
4017   DeclarationName Name;
4018   SourceLocation Loc;
4019   NamedDecl *ToD;
4020   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4021     return nullptr;
4022   if (ToD)
4023     return ToD;
4024 
4025   ObjCInterfaceDecl *ToInterface
4026     = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
4027   if (!ToInterface)
4028     return nullptr;
4029 
4030   // Determine if we've already encountered this category.
4031   ObjCCategoryDecl *MergeWithCategory
4032     = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4033   ObjCCategoryDecl *ToCategory = MergeWithCategory;
4034   if (!ToCategory) {
4035     ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
4036                                           Importer.Import(D->getAtStartLoc()),
4037                                           Loc,
4038                                        Importer.Import(D->getCategoryNameLoc()),
4039                                           Name.getAsIdentifierInfo(),
4040                                           ToInterface,
4041                                           /*TypeParamList=*/nullptr,
4042                                        Importer.Import(D->getIvarLBraceLoc()),
4043                                        Importer.Import(D->getIvarRBraceLoc()));
4044     ToCategory->setLexicalDeclContext(LexicalDC);
4045     LexicalDC->addDeclInternal(ToCategory);
4046     Importer.Imported(D, ToCategory);
4047     // Import the type parameter list after calling Imported, to avoid
4048     // loops when bringing in their DeclContext.
4049     ToCategory->setTypeParamList(ImportObjCTypeParamList(
4050                                    D->getTypeParamList()));
4051 
4052     // Import protocols
4053     SmallVector<ObjCProtocolDecl *, 4> Protocols;
4054     SmallVector<SourceLocation, 4> ProtocolLocs;
4055     ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4056       = D->protocol_loc_begin();
4057     for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4058                                           FromProtoEnd = D->protocol_end();
4059          FromProto != FromProtoEnd;
4060          ++FromProto, ++FromProtoLoc) {
4061       ObjCProtocolDecl *ToProto
4062         = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4063       if (!ToProto)
4064         return nullptr;
4065       Protocols.push_back(ToProto);
4066       ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4067     }
4068 
4069     // FIXME: If we're merging, make sure that the protocol list is the same.
4070     ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4071                                 ProtocolLocs.data(), Importer.getToContext());
4072 
4073   } else {
4074     Importer.Imported(D, ToCategory);
4075   }
4076 
4077   // Import all of the members of this category.
4078   ImportDeclContext(D);
4079 
4080   // If we have an implementation, import it as well.
4081   if (D->getImplementation()) {
4082     ObjCCategoryImplDecl *Impl
4083       = cast_or_null<ObjCCategoryImplDecl>(
4084                                        Importer.Import(D->getImplementation()));
4085     if (!Impl)
4086       return nullptr;
4087 
4088     ToCategory->setImplementation(Impl);
4089   }
4090 
4091   return ToCategory;
4092 }
4093 
4094 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
4095                                        ObjCProtocolDecl *To,
4096                                        ImportDefinitionKind Kind) {
4097   if (To->getDefinition()) {
4098     if (shouldForceImportDeclContext(Kind))
4099       ImportDeclContext(From);
4100     return false;
4101   }
4102 
4103   // Start the protocol definition
4104   To->startDefinition();
4105 
4106   // Import protocols
4107   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4108   SmallVector<SourceLocation, 4> ProtocolLocs;
4109   ObjCProtocolDecl::protocol_loc_iterator
4110   FromProtoLoc = From->protocol_loc_begin();
4111   for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4112                                         FromProtoEnd = From->protocol_end();
4113        FromProto != FromProtoEnd;
4114        ++FromProto, ++FromProtoLoc) {
4115     ObjCProtocolDecl *ToProto
4116       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4117     if (!ToProto)
4118       return true;
4119     Protocols.push_back(ToProto);
4120     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4121   }
4122 
4123   // FIXME: If we're merging, make sure that the protocol list is the same.
4124   To->setProtocolList(Protocols.data(), Protocols.size(),
4125                       ProtocolLocs.data(), Importer.getToContext());
4126 
4127   if (shouldForceImportDeclContext(Kind)) {
4128     // Import all of the members of this protocol.
4129     ImportDeclContext(From, /*ForceImport=*/true);
4130   }
4131   return false;
4132 }
4133 
4134 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4135   // If this protocol has a definition in the translation unit we're coming
4136   // from, but this particular declaration is not that definition, import the
4137   // definition and map to that.
4138   ObjCProtocolDecl *Definition = D->getDefinition();
4139   if (Definition && Definition != D) {
4140     Decl *ImportedDef = Importer.Import(Definition);
4141     if (!ImportedDef)
4142       return nullptr;
4143 
4144     return Importer.Imported(D, ImportedDef);
4145   }
4146 
4147   // Import the major distinguishing characteristics of a protocol.
4148   DeclContext *DC, *LexicalDC;
4149   DeclarationName Name;
4150   SourceLocation Loc;
4151   NamedDecl *ToD;
4152   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4153     return nullptr;
4154   if (ToD)
4155     return ToD;
4156 
4157   ObjCProtocolDecl *MergeWithProtocol = nullptr;
4158   SmallVector<NamedDecl *, 2> FoundDecls;
4159   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4160   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4161     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4162       continue;
4163 
4164     if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
4165       break;
4166   }
4167 
4168   ObjCProtocolDecl *ToProto = MergeWithProtocol;
4169   if (!ToProto) {
4170     ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
4171                                        Name.getAsIdentifierInfo(), Loc,
4172                                        Importer.Import(D->getAtStartLoc()),
4173                                        /*PrevDecl=*/nullptr);
4174     ToProto->setLexicalDeclContext(LexicalDC);
4175     LexicalDC->addDeclInternal(ToProto);
4176   }
4177 
4178   Importer.Imported(D, ToProto);
4179 
4180   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
4181     return nullptr;
4182 
4183   return ToProto;
4184 }
4185 
4186 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4187   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4188   DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4189 
4190   SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
4191   SourceLocation LangLoc = Importer.Import(D->getLocation());
4192 
4193   bool HasBraces = D->hasBraces();
4194 
4195   LinkageSpecDecl *ToLinkageSpec =
4196     LinkageSpecDecl::Create(Importer.getToContext(),
4197                             DC,
4198                             ExternLoc,
4199                             LangLoc,
4200                             D->getLanguage(),
4201                             HasBraces);
4202 
4203   if (HasBraces) {
4204     SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
4205     ToLinkageSpec->setRBraceLoc(RBraceLoc);
4206   }
4207 
4208   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4209   LexicalDC->addDeclInternal(ToLinkageSpec);
4210 
4211   Importer.Imported(D, ToLinkageSpec);
4212 
4213   return ToLinkageSpec;
4214 }
4215 
4216 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
4217                                        ObjCInterfaceDecl *To,
4218                                        ImportDefinitionKind Kind) {
4219   if (To->getDefinition()) {
4220     // Check consistency of superclass.
4221     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4222     if (FromSuper) {
4223       FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
4224       if (!FromSuper)
4225         return true;
4226     }
4227 
4228     ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4229     if ((bool)FromSuper != (bool)ToSuper ||
4230         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4231       Importer.ToDiag(To->getLocation(),
4232                       diag::err_odr_objc_superclass_inconsistent)
4233         << To->getDeclName();
4234       if (ToSuper)
4235         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4236           << To->getSuperClass()->getDeclName();
4237       else
4238         Importer.ToDiag(To->getLocation(),
4239                         diag::note_odr_objc_missing_superclass);
4240       if (From->getSuperClass())
4241         Importer.FromDiag(From->getSuperClassLoc(),
4242                           diag::note_odr_objc_superclass)
4243         << From->getSuperClass()->getDeclName();
4244       else
4245         Importer.FromDiag(From->getLocation(),
4246                           diag::note_odr_objc_missing_superclass);
4247     }
4248 
4249     if (shouldForceImportDeclContext(Kind))
4250       ImportDeclContext(From);
4251     return false;
4252   }
4253 
4254   // Start the definition.
4255   To->startDefinition();
4256 
4257   // If this class has a superclass, import it.
4258   if (From->getSuperClass()) {
4259     TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
4260     if (!SuperTInfo)
4261       return true;
4262 
4263     To->setSuperClass(SuperTInfo);
4264   }
4265 
4266   // Import protocols
4267   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4268   SmallVector<SourceLocation, 4> ProtocolLocs;
4269   ObjCInterfaceDecl::protocol_loc_iterator
4270   FromProtoLoc = From->protocol_loc_begin();
4271 
4272   for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4273                                          FromProtoEnd = From->protocol_end();
4274        FromProto != FromProtoEnd;
4275        ++FromProto, ++FromProtoLoc) {
4276     ObjCProtocolDecl *ToProto
4277       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4278     if (!ToProto)
4279       return true;
4280     Protocols.push_back(ToProto);
4281     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4282   }
4283 
4284   // FIXME: If we're merging, make sure that the protocol list is the same.
4285   To->setProtocolList(Protocols.data(), Protocols.size(),
4286                       ProtocolLocs.data(), Importer.getToContext());
4287 
4288   // Import categories. When the categories themselves are imported, they'll
4289   // hook themselves into this interface.
4290   for (auto *Cat : From->known_categories())
4291     Importer.Import(Cat);
4292 
4293   // If we have an @implementation, import it as well.
4294   if (From->getImplementation()) {
4295     ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
4296                                      Importer.Import(From->getImplementation()));
4297     if (!Impl)
4298       return true;
4299 
4300     To->setImplementation(Impl);
4301   }
4302 
4303   if (shouldForceImportDeclContext(Kind)) {
4304     // Import all of the members of this class.
4305     ImportDeclContext(From, /*ForceImport=*/true);
4306   }
4307   return false;
4308 }
4309 
4310 ObjCTypeParamList *
4311 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4312   if (!list)
4313     return nullptr;
4314 
4315   SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4316   for (auto fromTypeParam : *list) {
4317     auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
4318                          Importer.Import(fromTypeParam));
4319     if (!toTypeParam)
4320       return nullptr;
4321 
4322     toTypeParams.push_back(toTypeParam);
4323   }
4324 
4325   return ObjCTypeParamList::create(Importer.getToContext(),
4326                                    Importer.Import(list->getLAngleLoc()),
4327                                    toTypeParams,
4328                                    Importer.Import(list->getRAngleLoc()));
4329 }
4330 
4331 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4332   // If this class has a definition in the translation unit we're coming from,
4333   // but this particular declaration is not that definition, import the
4334   // definition and map to that.
4335   ObjCInterfaceDecl *Definition = D->getDefinition();
4336   if (Definition && Definition != D) {
4337     Decl *ImportedDef = Importer.Import(Definition);
4338     if (!ImportedDef)
4339       return nullptr;
4340 
4341     return Importer.Imported(D, ImportedDef);
4342   }
4343 
4344   // Import the major distinguishing characteristics of an @interface.
4345   DeclContext *DC, *LexicalDC;
4346   DeclarationName Name;
4347   SourceLocation Loc;
4348   NamedDecl *ToD;
4349   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4350     return nullptr;
4351   if (ToD)
4352     return ToD;
4353 
4354   // Look for an existing interface with the same name.
4355   ObjCInterfaceDecl *MergeWithIface = nullptr;
4356   SmallVector<NamedDecl *, 2> FoundDecls;
4357   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4358   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4359     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4360       continue;
4361 
4362     if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
4363       break;
4364   }
4365 
4366   // Create an interface declaration, if one does not already exist.
4367   ObjCInterfaceDecl *ToIface = MergeWithIface;
4368   if (!ToIface) {
4369     ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4370                                         Importer.Import(D->getAtStartLoc()),
4371                                         Name.getAsIdentifierInfo(),
4372                                         /*TypeParamList=*/nullptr,
4373                                         /*PrevDecl=*/nullptr, Loc,
4374                                         D->isImplicitInterfaceDecl());
4375     ToIface->setLexicalDeclContext(LexicalDC);
4376     LexicalDC->addDeclInternal(ToIface);
4377   }
4378   Importer.Imported(D, ToIface);
4379   // Import the type parameter list after calling Imported, to avoid
4380   // loops when bringing in their DeclContext.
4381   ToIface->setTypeParamList(ImportObjCTypeParamList(
4382                               D->getTypeParamListAsWritten()));
4383 
4384   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4385     return nullptr;
4386 
4387   return ToIface;
4388 }
4389 
4390 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4391   ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
4392                                         Importer.Import(D->getCategoryDecl()));
4393   if (!Category)
4394     return nullptr;
4395 
4396   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4397   if (!ToImpl) {
4398     DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4399     if (!DC)
4400       return nullptr;
4401 
4402     SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4403     ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4404                                           Importer.Import(D->getIdentifier()),
4405                                           Category->getClassInterface(),
4406                                           Importer.Import(D->getLocation()),
4407                                           Importer.Import(D->getAtStartLoc()),
4408                                           CategoryNameLoc);
4409 
4410     DeclContext *LexicalDC = DC;
4411     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4412       LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4413       if (!LexicalDC)
4414         return nullptr;
4415 
4416       ToImpl->setLexicalDeclContext(LexicalDC);
4417     }
4418 
4419     LexicalDC->addDeclInternal(ToImpl);
4420     Category->setImplementation(ToImpl);
4421   }
4422 
4423   Importer.Imported(D, ToImpl);
4424   ImportDeclContext(D);
4425   return ToImpl;
4426 }
4427 
4428 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4429   // Find the corresponding interface.
4430   ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
4431                                        Importer.Import(D->getClassInterface()));
4432   if (!Iface)
4433     return nullptr;
4434 
4435   // Import the superclass, if any.
4436   ObjCInterfaceDecl *Super = nullptr;
4437   if (D->getSuperClass()) {
4438     Super = cast_or_null<ObjCInterfaceDecl>(
4439                                           Importer.Import(D->getSuperClass()));
4440     if (!Super)
4441       return nullptr;
4442   }
4443 
4444   ObjCImplementationDecl *Impl = Iface->getImplementation();
4445   if (!Impl) {
4446     // We haven't imported an implementation yet. Create a new @implementation
4447     // now.
4448     Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4449                                   Importer.ImportContext(D->getDeclContext()),
4450                                           Iface, Super,
4451                                           Importer.Import(D->getLocation()),
4452                                           Importer.Import(D->getAtStartLoc()),
4453                                           Importer.Import(D->getSuperClassLoc()),
4454                                           Importer.Import(D->getIvarLBraceLoc()),
4455                                           Importer.Import(D->getIvarRBraceLoc()));
4456 
4457     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4458       DeclContext *LexicalDC
4459         = Importer.ImportContext(D->getLexicalDeclContext());
4460       if (!LexicalDC)
4461         return nullptr;
4462       Impl->setLexicalDeclContext(LexicalDC);
4463     }
4464 
4465     // Associate the implementation with the class it implements.
4466     Iface->setImplementation(Impl);
4467     Importer.Imported(D, Iface->getImplementation());
4468   } else {
4469     Importer.Imported(D, Iface->getImplementation());
4470 
4471     // Verify that the existing @implementation has the same superclass.
4472     if ((Super && !Impl->getSuperClass()) ||
4473         (!Super && Impl->getSuperClass()) ||
4474         (Super && Impl->getSuperClass() &&
4475          !declaresSameEntity(Super->getCanonicalDecl(),
4476                              Impl->getSuperClass()))) {
4477       Importer.ToDiag(Impl->getLocation(),
4478                       diag::err_odr_objc_superclass_inconsistent)
4479         << Iface->getDeclName();
4480       // FIXME: It would be nice to have the location of the superclass
4481       // below.
4482       if (Impl->getSuperClass())
4483         Importer.ToDiag(Impl->getLocation(),
4484                         diag::note_odr_objc_superclass)
4485         << Impl->getSuperClass()->getDeclName();
4486       else
4487         Importer.ToDiag(Impl->getLocation(),
4488                         diag::note_odr_objc_missing_superclass);
4489       if (D->getSuperClass())
4490         Importer.FromDiag(D->getLocation(),
4491                           diag::note_odr_objc_superclass)
4492         << D->getSuperClass()->getDeclName();
4493       else
4494         Importer.FromDiag(D->getLocation(),
4495                           diag::note_odr_objc_missing_superclass);
4496       return nullptr;
4497     }
4498   }
4499 
4500   // Import all of the members of this @implementation.
4501   ImportDeclContext(D);
4502 
4503   return Impl;
4504 }
4505 
4506 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4507   // Import the major distinguishing characteristics of an @property.
4508   DeclContext *DC, *LexicalDC;
4509   DeclarationName Name;
4510   SourceLocation Loc;
4511   NamedDecl *ToD;
4512   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4513     return nullptr;
4514   if (ToD)
4515     return ToD;
4516 
4517   // Check whether we have already imported this property.
4518   SmallVector<NamedDecl *, 2> FoundDecls;
4519   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4520   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4521     if (ObjCPropertyDecl *FoundProp
4522                                 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
4523       // Check property types.
4524       if (!Importer.IsStructurallyEquivalent(D->getType(),
4525                                              FoundProp->getType())) {
4526         Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4527           << Name << D->getType() << FoundProp->getType();
4528         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4529           << FoundProp->getType();
4530         return nullptr;
4531       }
4532 
4533       // FIXME: Check property attributes, getters, setters, etc.?
4534 
4535       // Consider these properties to be equivalent.
4536       Importer.Imported(D, FoundProp);
4537       return FoundProp;
4538     }
4539   }
4540 
4541   // Import the type.
4542   TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4543   if (!TSI)
4544     return nullptr;
4545 
4546   // Create the new property.
4547   ObjCPropertyDecl *ToProperty
4548     = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4549                                Name.getAsIdentifierInfo(),
4550                                Importer.Import(D->getAtLoc()),
4551                                Importer.Import(D->getLParenLoc()),
4552                                Importer.Import(D->getType()),
4553                                TSI,
4554                                D->getPropertyImplementation());
4555   Importer.Imported(D, ToProperty);
4556   ToProperty->setLexicalDeclContext(LexicalDC);
4557   LexicalDC->addDeclInternal(ToProperty);
4558 
4559   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4560   ToProperty->setPropertyAttributesAsWritten(
4561                                       D->getPropertyAttributesAsWritten());
4562   ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4563   ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4564   ToProperty->setGetterMethodDecl(
4565      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4566   ToProperty->setSetterMethodDecl(
4567      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4568   ToProperty->setPropertyIvarDecl(
4569        cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4570   return ToProperty;
4571 }
4572 
4573 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4574   ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4575                                         Importer.Import(D->getPropertyDecl()));
4576   if (!Property)
4577     return nullptr;
4578 
4579   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4580   if (!DC)
4581     return nullptr;
4582 
4583   // Import the lexical declaration context.
4584   DeclContext *LexicalDC = DC;
4585   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4586     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4587     if (!LexicalDC)
4588       return nullptr;
4589   }
4590 
4591   ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4592   if (!InImpl)
4593     return nullptr;
4594 
4595   // Import the ivar (for an @synthesize).
4596   ObjCIvarDecl *Ivar = nullptr;
4597   if (D->getPropertyIvarDecl()) {
4598     Ivar = cast_or_null<ObjCIvarDecl>(
4599                                     Importer.Import(D->getPropertyIvarDecl()));
4600     if (!Ivar)
4601       return nullptr;
4602   }
4603 
4604   ObjCPropertyImplDecl *ToImpl
4605     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4606                                    Property->getQueryKind());
4607   if (!ToImpl) {
4608     ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4609                                           Importer.Import(D->getLocStart()),
4610                                           Importer.Import(D->getLocation()),
4611                                           Property,
4612                                           D->getPropertyImplementation(),
4613                                           Ivar,
4614                                   Importer.Import(D->getPropertyIvarDeclLoc()));
4615     ToImpl->setLexicalDeclContext(LexicalDC);
4616     Importer.Imported(D, ToImpl);
4617     LexicalDC->addDeclInternal(ToImpl);
4618   } else {
4619     // Check that we have the same kind of property implementation (@synthesize
4620     // vs. @dynamic).
4621     if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4622       Importer.ToDiag(ToImpl->getLocation(),
4623                       diag::err_odr_objc_property_impl_kind_inconsistent)
4624         << Property->getDeclName()
4625         << (ToImpl->getPropertyImplementation()
4626                                               == ObjCPropertyImplDecl::Dynamic);
4627       Importer.FromDiag(D->getLocation(),
4628                         diag::note_odr_objc_property_impl_kind)
4629         << D->getPropertyDecl()->getDeclName()
4630         << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4631       return nullptr;
4632     }
4633 
4634     // For @synthesize, check that we have the same
4635     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4636         Ivar != ToImpl->getPropertyIvarDecl()) {
4637       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4638                       diag::err_odr_objc_synthesize_ivar_inconsistent)
4639         << Property->getDeclName()
4640         << ToImpl->getPropertyIvarDecl()->getDeclName()
4641         << Ivar->getDeclName();
4642       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4643                         diag::note_odr_objc_synthesize_ivar_here)
4644         << D->getPropertyIvarDecl()->getDeclName();
4645       return nullptr;
4646     }
4647 
4648     // Merge the existing implementation with the new implementation.
4649     Importer.Imported(D, ToImpl);
4650   }
4651 
4652   return ToImpl;
4653 }
4654 
4655 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4656   // For template arguments, we adopt the translation unit as our declaration
4657   // context. This context will be fixed when the actual template declaration
4658   // is created.
4659 
4660   // FIXME: Import default argument.
4661   return TemplateTypeParmDecl::Create(Importer.getToContext(),
4662                               Importer.getToContext().getTranslationUnitDecl(),
4663                                       Importer.Import(D->getLocStart()),
4664                                       Importer.Import(D->getLocation()),
4665                                       D->getDepth(),
4666                                       D->getIndex(),
4667                                       Importer.Import(D->getIdentifier()),
4668                                       D->wasDeclaredWithTypename(),
4669                                       D->isParameterPack());
4670 }
4671 
4672 Decl *
4673 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4674   // Import the name of this declaration.
4675   DeclarationName Name = Importer.Import(D->getDeclName());
4676   if (D->getDeclName() && !Name)
4677     return nullptr;
4678 
4679   // Import the location of this declaration.
4680   SourceLocation Loc = Importer.Import(D->getLocation());
4681 
4682   // Import the type of this declaration.
4683   QualType T = Importer.Import(D->getType());
4684   if (T.isNull())
4685     return nullptr;
4686 
4687   // Import type-source information.
4688   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4689   if (D->getTypeSourceInfo() && !TInfo)
4690     return nullptr;
4691 
4692   // FIXME: Import default argument.
4693 
4694   return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4695                                Importer.getToContext().getTranslationUnitDecl(),
4696                                          Importer.Import(D->getInnerLocStart()),
4697                                          Loc, D->getDepth(), D->getPosition(),
4698                                          Name.getAsIdentifierInfo(),
4699                                          T, D->isParameterPack(), TInfo);
4700 }
4701 
4702 Decl *
4703 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4704   // Import the name of this declaration.
4705   DeclarationName Name = Importer.Import(D->getDeclName());
4706   if (D->getDeclName() && !Name)
4707     return nullptr;
4708 
4709   // Import the location of this declaration.
4710   SourceLocation Loc = Importer.Import(D->getLocation());
4711 
4712   // Import template parameters.
4713   TemplateParameterList *TemplateParams
4714     = ImportTemplateParameterList(D->getTemplateParameters());
4715   if (!TemplateParams)
4716     return nullptr;
4717 
4718   // FIXME: Import default argument.
4719 
4720   return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4721                               Importer.getToContext().getTranslationUnitDecl(),
4722                                           Loc, D->getDepth(), D->getPosition(),
4723                                           D->isParameterPack(),
4724                                           Name.getAsIdentifierInfo(),
4725                                           TemplateParams);
4726 }
4727 
4728 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4729   // If this record has a definition in the translation unit we're coming from,
4730   // but this particular declaration is not that definition, import the
4731   // definition and map to that.
4732   CXXRecordDecl *Definition
4733     = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4734   if (Definition && Definition != D->getTemplatedDecl()) {
4735     Decl *ImportedDef
4736       = Importer.Import(Definition->getDescribedClassTemplate());
4737     if (!ImportedDef)
4738       return nullptr;
4739 
4740     return Importer.Imported(D, ImportedDef);
4741   }
4742 
4743   // Import the major distinguishing characteristics of this class template.
4744   DeclContext *DC, *LexicalDC;
4745   DeclarationName Name;
4746   SourceLocation Loc;
4747   NamedDecl *ToD;
4748   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4749     return nullptr;
4750   if (ToD)
4751     return ToD;
4752 
4753   // We may already have a template of the same name; try to find and match it.
4754   if (!DC->isFunctionOrMethod()) {
4755     SmallVector<NamedDecl *, 4> ConflictingDecls;
4756     SmallVector<NamedDecl *, 2> FoundDecls;
4757     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4758     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4759       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4760         continue;
4761 
4762       Decl *Found = FoundDecls[I];
4763       if (ClassTemplateDecl *FoundTemplate
4764                                         = dyn_cast<ClassTemplateDecl>(Found)) {
4765         if (IsStructuralMatch(D, FoundTemplate)) {
4766           // The class templates structurally match; call it the same template.
4767           // FIXME: We may be filling in a forward declaration here. Handle
4768           // this case!
4769           Importer.Imported(D->getTemplatedDecl(),
4770                             FoundTemplate->getTemplatedDecl());
4771           return Importer.Imported(D, FoundTemplate);
4772         }
4773       }
4774 
4775       ConflictingDecls.push_back(FoundDecls[I]);
4776     }
4777 
4778     if (!ConflictingDecls.empty()) {
4779       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4780                                          ConflictingDecls.data(),
4781                                          ConflictingDecls.size());
4782     }
4783 
4784     if (!Name)
4785       return nullptr;
4786   }
4787 
4788   CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4789 
4790   // Create the declaration that is being templated.
4791   // Create the declaration that is being templated.
4792   CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
4793         Importer.Import(DTemplated));
4794   if (!D2Templated)
4795     return nullptr;
4796 
4797   // Resolve possible cyclic import.
4798   if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4799     return AlreadyImported;
4800 
4801   // Create the class template declaration itself.
4802   TemplateParameterList *TemplateParams
4803     = ImportTemplateParameterList(D->getTemplateParameters());
4804   if (!TemplateParams)
4805     return nullptr;
4806 
4807   ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4808                                                     Loc, Name, TemplateParams,
4809                                                     D2Templated);
4810   D2Templated->setDescribedClassTemplate(D2);
4811 
4812   D2->setAccess(D->getAccess());
4813   D2->setLexicalDeclContext(LexicalDC);
4814   LexicalDC->addDeclInternal(D2);
4815 
4816   // Note the relationship between the class templates.
4817   Importer.Imported(D, D2);
4818   Importer.Imported(DTemplated, D2Templated);
4819 
4820   if (DTemplated->isCompleteDefinition() &&
4821       !D2Templated->isCompleteDefinition()) {
4822     // FIXME: Import definition!
4823   }
4824 
4825   return D2;
4826 }
4827 
4828 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4829                                           ClassTemplateSpecializationDecl *D) {
4830   // If this record has a definition in the translation unit we're coming from,
4831   // but this particular declaration is not that definition, import the
4832   // definition and map to that.
4833   TagDecl *Definition = D->getDefinition();
4834   if (Definition && Definition != D) {
4835     Decl *ImportedDef = Importer.Import(Definition);
4836     if (!ImportedDef)
4837       return nullptr;
4838 
4839     return Importer.Imported(D, ImportedDef);
4840   }
4841 
4842   ClassTemplateDecl *ClassTemplate
4843     = cast_or_null<ClassTemplateDecl>(Importer.Import(
4844                                                  D->getSpecializedTemplate()));
4845   if (!ClassTemplate)
4846     return nullptr;
4847 
4848   // Import the context of this declaration.
4849   DeclContext *DC = ClassTemplate->getDeclContext();
4850   if (!DC)
4851     return nullptr;
4852 
4853   DeclContext *LexicalDC = DC;
4854   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4855     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4856     if (!LexicalDC)
4857       return nullptr;
4858   }
4859 
4860   // Import the location of this declaration.
4861   SourceLocation StartLoc = Importer.Import(D->getLocStart());
4862   SourceLocation IdLoc = Importer.Import(D->getLocation());
4863 
4864   // Import template arguments.
4865   SmallVector<TemplateArgument, 2> TemplateArgs;
4866   if (ImportTemplateArguments(D->getTemplateArgs().data(),
4867                               D->getTemplateArgs().size(),
4868                               TemplateArgs))
4869     return nullptr;
4870 
4871   // Try to find an existing specialization with these template arguments.
4872   void *InsertPos = nullptr;
4873   ClassTemplateSpecializationDecl *D2
4874     = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4875   if (D2) {
4876     // We already have a class template specialization with these template
4877     // arguments.
4878 
4879     // FIXME: Check for specialization vs. instantiation errors.
4880 
4881     if (RecordDecl *FoundDef = D2->getDefinition()) {
4882       if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4883         // The record types structurally match, or the "from" translation
4884         // unit only had a forward declaration anyway; call it the same
4885         // function.
4886         return Importer.Imported(D, FoundDef);
4887       }
4888     }
4889   } else {
4890     // Create a new specialization.
4891     if (ClassTemplatePartialSpecializationDecl *PartialSpec =
4892         dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4893 
4894       // Import TemplateArgumentListInfo
4895       TemplateArgumentListInfo ToTAInfo;
4896       auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4897       for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) {
4898         bool Error = false;
4899         auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I], Error);
4900         if (Error)
4901           return nullptr;
4902         ToTAInfo.addArgument(ToLoc);
4903       }
4904 
4905       QualType CanonInjType = Importer.Import(
4906             PartialSpec->getInjectedSpecializationType());
4907       if (CanonInjType.isNull())
4908         return nullptr;
4909       CanonInjType = CanonInjType.getCanonicalType();
4910 
4911       TemplateParameterList *ToTPList = ImportTemplateParameterList(
4912             PartialSpec->getTemplateParameters());
4913       if (!ToTPList && PartialSpec->getTemplateParameters())
4914         return nullptr;
4915 
4916       D2 = ClassTemplatePartialSpecializationDecl::Create(
4917             Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc,
4918             ToTPList, ClassTemplate,
4919             llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4920             ToTAInfo, CanonInjType, nullptr);
4921 
4922     } else {
4923       D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4924                                                    D->getTagKind(), DC,
4925                                                    StartLoc, IdLoc,
4926                                                    ClassTemplate,
4927                                                    TemplateArgs,
4928                                                    /*PrevDecl=*/nullptr);
4929     }
4930 
4931     D2->setSpecializationKind(D->getSpecializationKind());
4932 
4933     // Add this specialization to the class template.
4934     ClassTemplate->AddSpecialization(D2, InsertPos);
4935 
4936     // Import the qualifier, if any.
4937     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4938 
4939     Importer.Imported(D, D2);
4940 
4941     if (auto *TSI = D->getTypeAsWritten()) {
4942       TypeSourceInfo *TInfo = Importer.Import(TSI);
4943       if (!TInfo)
4944         return nullptr;
4945       D2->setTypeAsWritten(TInfo);
4946       D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4947       D2->setExternLoc(Importer.Import(D->getExternLoc()));
4948     }
4949 
4950     SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4951     if (POI.isValid())
4952       D2->setPointOfInstantiation(POI);
4953     else if (D->getPointOfInstantiation().isValid())
4954       return nullptr;
4955 
4956     D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4957 
4958     // Add the specialization to this context.
4959     D2->setLexicalDeclContext(LexicalDC);
4960     LexicalDC->addDeclInternal(D2);
4961   }
4962   Importer.Imported(D, D2);
4963   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4964     return nullptr;
4965 
4966   return D2;
4967 }
4968 
4969 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4970   // If this variable has a definition in the translation unit we're coming
4971   // from,
4972   // but this particular declaration is not that definition, import the
4973   // definition and map to that.
4974   VarDecl *Definition =
4975       cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4976   if (Definition && Definition != D->getTemplatedDecl()) {
4977     Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4978     if (!ImportedDef)
4979       return nullptr;
4980 
4981     return Importer.Imported(D, ImportedDef);
4982   }
4983 
4984   // Import the major distinguishing characteristics of this variable template.
4985   DeclContext *DC, *LexicalDC;
4986   DeclarationName Name;
4987   SourceLocation Loc;
4988   NamedDecl *ToD;
4989   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4990     return nullptr;
4991   if (ToD)
4992     return ToD;
4993 
4994   // We may already have a template of the same name; try to find and match it.
4995   assert(!DC->isFunctionOrMethod() &&
4996          "Variable templates cannot be declared at function scope");
4997   SmallVector<NamedDecl *, 4> ConflictingDecls;
4998   SmallVector<NamedDecl *, 2> FoundDecls;
4999   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
5000   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
5001     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5002       continue;
5003 
5004     Decl *Found = FoundDecls[I];
5005     if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
5006       if (IsStructuralMatch(D, FoundTemplate)) {
5007         // The variable templates structurally match; call it the same template.
5008         Importer.Imported(D->getTemplatedDecl(),
5009                           FoundTemplate->getTemplatedDecl());
5010         return Importer.Imported(D, FoundTemplate);
5011       }
5012     }
5013 
5014     ConflictingDecls.push_back(FoundDecls[I]);
5015   }
5016 
5017   if (!ConflictingDecls.empty()) {
5018     Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
5019                                        ConflictingDecls.data(),
5020                                        ConflictingDecls.size());
5021   }
5022 
5023   if (!Name)
5024     return nullptr;
5025 
5026   VarDecl *DTemplated = D->getTemplatedDecl();
5027 
5028   // Import the type.
5029   QualType T = Importer.Import(DTemplated->getType());
5030   if (T.isNull())
5031     return nullptr;
5032 
5033   // Create the declaration that is being templated.
5034   SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
5035   SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
5036   TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
5037   VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
5038                                          IdLoc, Name.getAsIdentifierInfo(), T,
5039                                          TInfo, DTemplated->getStorageClass());
5040   D2Templated->setAccess(DTemplated->getAccess());
5041   D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
5042   D2Templated->setLexicalDeclContext(LexicalDC);
5043 
5044   // Importer.Imported(DTemplated, D2Templated);
5045   // LexicalDC->addDeclInternal(D2Templated);
5046 
5047   // Merge the initializer.
5048   if (ImportDefinition(DTemplated, D2Templated))
5049     return nullptr;
5050 
5051   // Create the variable template declaration itself.
5052   TemplateParameterList *TemplateParams =
5053       ImportTemplateParameterList(D->getTemplateParameters());
5054   if (!TemplateParams)
5055     return nullptr;
5056 
5057   VarTemplateDecl *D2 = VarTemplateDecl::Create(
5058       Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
5059   D2Templated->setDescribedVarTemplate(D2);
5060 
5061   D2->setAccess(D->getAccess());
5062   D2->setLexicalDeclContext(LexicalDC);
5063   LexicalDC->addDeclInternal(D2);
5064 
5065   // Note the relationship between the variable templates.
5066   Importer.Imported(D, D2);
5067   Importer.Imported(DTemplated, D2Templated);
5068 
5069   if (DTemplated->isThisDeclarationADefinition() &&
5070       !D2Templated->isThisDeclarationADefinition()) {
5071     // FIXME: Import definition!
5072   }
5073 
5074   return D2;
5075 }
5076 
5077 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5078     VarTemplateSpecializationDecl *D) {
5079   // If this record has a definition in the translation unit we're coming from,
5080   // but this particular declaration is not that definition, import the
5081   // definition and map to that.
5082   VarDecl *Definition = D->getDefinition();
5083   if (Definition && Definition != D) {
5084     Decl *ImportedDef = Importer.Import(Definition);
5085     if (!ImportedDef)
5086       return nullptr;
5087 
5088     return Importer.Imported(D, ImportedDef);
5089   }
5090 
5091   VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
5092       Importer.Import(D->getSpecializedTemplate()));
5093   if (!VarTemplate)
5094     return nullptr;
5095 
5096   // Import the context of this declaration.
5097   DeclContext *DC = VarTemplate->getDeclContext();
5098   if (!DC)
5099     return nullptr;
5100 
5101   DeclContext *LexicalDC = DC;
5102   if (D->getDeclContext() != D->getLexicalDeclContext()) {
5103     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
5104     if (!LexicalDC)
5105       return nullptr;
5106   }
5107 
5108   // Import the location of this declaration.
5109   SourceLocation StartLoc = Importer.Import(D->getLocStart());
5110   SourceLocation IdLoc = Importer.Import(D->getLocation());
5111 
5112   // Import template arguments.
5113   SmallVector<TemplateArgument, 2> TemplateArgs;
5114   if (ImportTemplateArguments(D->getTemplateArgs().data(),
5115                               D->getTemplateArgs().size(), TemplateArgs))
5116     return nullptr;
5117 
5118   // Try to find an existing specialization with these template arguments.
5119   void *InsertPos = nullptr;
5120   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5121       TemplateArgs, InsertPos);
5122   if (D2) {
5123     // We already have a variable template specialization with these template
5124     // arguments.
5125 
5126     // FIXME: Check for specialization vs. instantiation errors.
5127 
5128     if (VarDecl *FoundDef = D2->getDefinition()) {
5129       if (!D->isThisDeclarationADefinition() ||
5130           IsStructuralMatch(D, FoundDef)) {
5131         // The record types structurally match, or the "from" translation
5132         // unit only had a forward declaration anyway; call it the same
5133         // variable.
5134         return Importer.Imported(D, FoundDef);
5135       }
5136     }
5137   } else {
5138 
5139     // Import the type.
5140     QualType T = Importer.Import(D->getType());
5141     if (T.isNull())
5142       return nullptr;
5143     TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
5144 
5145     // Create a new specialization.
5146     D2 = VarTemplateSpecializationDecl::Create(
5147         Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
5148         D->getStorageClass(), TemplateArgs);
5149     D2->setSpecializationKind(D->getSpecializationKind());
5150     D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
5151 
5152     // Add this specialization to the class template.
5153     VarTemplate->AddSpecialization(D2, InsertPos);
5154 
5155     // Import the qualifier, if any.
5156     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
5157 
5158     // Add the specialization to this context.
5159     D2->setLexicalDeclContext(LexicalDC);
5160     LexicalDC->addDeclInternal(D2);
5161   }
5162   Importer.Imported(D, D2);
5163 
5164   if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
5165     return nullptr;
5166 
5167   return D2;
5168 }
5169 
5170 //----------------------------------------------------------------------------
5171 // Import Statements
5172 //----------------------------------------------------------------------------
5173 
5174 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
5175   if (DG.isNull())
5176     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
5177   size_t NumDecls = DG.end() - DG.begin();
5178   SmallVector<Decl *, 1> ToDecls(NumDecls);
5179   auto &_Importer = this->Importer;
5180   std::transform(DG.begin(), DG.end(), ToDecls.begin(),
5181     [&_Importer](Decl *D) -> Decl * {
5182       return _Importer.Import(D);
5183     });
5184   return DeclGroupRef::Create(Importer.getToContext(),
5185                               ToDecls.begin(),
5186                               NumDecls);
5187 }
5188 
5189  Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
5190    Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
5191      << S->getStmtClassName();
5192    return nullptr;
5193  }
5194 
5195 
5196 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5197   SmallVector<IdentifierInfo *, 4> Names;
5198   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5199     IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
5200     if (!ToII)
5201       return nullptr;
5202     Names.push_back(ToII);
5203   }
5204   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5205     IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
5206     if (!ToII)
5207       return nullptr;
5208     Names.push_back(ToII);
5209   }
5210 
5211   SmallVector<StringLiteral *, 4> Clobbers;
5212   for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
5213     StringLiteral *Clobber = cast_or_null<StringLiteral>(
5214           Importer.Import(S->getClobberStringLiteral(I)));
5215     if (!Clobber)
5216       return nullptr;
5217     Clobbers.push_back(Clobber);
5218   }
5219 
5220   SmallVector<StringLiteral *, 4> Constraints;
5221   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5222     StringLiteral *Output = cast_or_null<StringLiteral>(
5223           Importer.Import(S->getOutputConstraintLiteral(I)));
5224     if (!Output)
5225       return nullptr;
5226     Constraints.push_back(Output);
5227   }
5228 
5229   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5230     StringLiteral *Input = cast_or_null<StringLiteral>(
5231           Importer.Import(S->getInputConstraintLiteral(I)));
5232     if (!Input)
5233       return nullptr;
5234     Constraints.push_back(Input);
5235   }
5236 
5237   SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
5238   if (ImportContainerChecked(S->outputs(), Exprs))
5239     return nullptr;
5240 
5241   if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
5242     return nullptr;
5243 
5244   StringLiteral *AsmStr = cast_or_null<StringLiteral>(
5245         Importer.Import(S->getAsmString()));
5246   if (!AsmStr)
5247     return nullptr;
5248 
5249   return new (Importer.getToContext()) GCCAsmStmt(
5250         Importer.getToContext(),
5251         Importer.Import(S->getAsmLoc()),
5252         S->isSimple(),
5253         S->isVolatile(),
5254         S->getNumOutputs(),
5255         S->getNumInputs(),
5256         Names.data(),
5257         Constraints.data(),
5258         Exprs.data(),
5259         AsmStr,
5260         S->getNumClobbers(),
5261         Clobbers.data(),
5262         Importer.Import(S->getRParenLoc()));
5263 }
5264 
5265 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
5266   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
5267   for (Decl *ToD : ToDG) {
5268     if (!ToD)
5269       return nullptr;
5270   }
5271   SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
5272   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5273   return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5274 }
5275 
5276 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5277   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5278   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5279                                                 S->hasLeadingEmptyMacro());
5280 }
5281 
5282 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5283   llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
5284 
5285   if (ImportContainerChecked(S->body(), ToStmts))
5286     return nullptr;
5287 
5288   SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5289   SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5290   return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
5291                                                     ToStmts,
5292                                                     ToLBraceLoc, ToRBraceLoc);
5293 }
5294 
5295 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5296   Expr *ToLHS = Importer.Import(S->getLHS());
5297   if (!ToLHS)
5298     return nullptr;
5299   Expr *ToRHS = Importer.Import(S->getRHS());
5300   if (!ToRHS && S->getRHS())
5301     return nullptr;
5302   SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5303   SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5304   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5305   return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
5306                                                 ToCaseLoc, ToEllipsisLoc,
5307                                                 ToColonLoc);
5308 }
5309 
5310 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5311   SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5312   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5313   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5314   if (!ToSubStmt && S->getSubStmt())
5315     return nullptr;
5316   return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5317                                                    ToSubStmt);
5318 }
5319 
5320 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5321   SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5322   LabelDecl *ToLabelDecl =
5323     cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5324   if (!ToLabelDecl && S->getDecl())
5325     return nullptr;
5326   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5327   if (!ToSubStmt && S->getSubStmt())
5328     return nullptr;
5329   return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5330                                                  ToSubStmt);
5331 }
5332 
5333 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5334   SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5335   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5336   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5337   ASTContext &_ToContext = Importer.getToContext();
5338   std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
5339     [&_ToContext](const Attr *A) -> const Attr * {
5340       return A->clone(_ToContext);
5341     });
5342   for (const Attr *ToA : ToAttrs) {
5343     if (!ToA)
5344       return nullptr;
5345   }
5346   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5347   if (!ToSubStmt && S->getSubStmt())
5348     return nullptr;
5349   return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5350                                 ToAttrs, ToSubStmt);
5351 }
5352 
5353 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5354   SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5355   Stmt *ToInit = Importer.Import(S->getInit());
5356   if (!ToInit && S->getInit())
5357     return nullptr;
5358   VarDecl *ToConditionVariable = nullptr;
5359   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5360     ToConditionVariable =
5361       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5362     if (!ToConditionVariable)
5363       return nullptr;
5364   }
5365   Expr *ToCondition = Importer.Import(S->getCond());
5366   if (!ToCondition && S->getCond())
5367     return nullptr;
5368   Stmt *ToThenStmt = Importer.Import(S->getThen());
5369   if (!ToThenStmt && S->getThen())
5370     return nullptr;
5371   SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5372   Stmt *ToElseStmt = Importer.Import(S->getElse());
5373   if (!ToElseStmt && S->getElse())
5374     return nullptr;
5375   return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5376                                               ToIfLoc, S->isConstexpr(),
5377                                               ToInit,
5378                                               ToConditionVariable,
5379                                               ToCondition, ToThenStmt,
5380                                               ToElseLoc, ToElseStmt);
5381 }
5382 
5383 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5384   Stmt *ToInit = Importer.Import(S->getInit());
5385   if (!ToInit && S->getInit())
5386     return nullptr;
5387   VarDecl *ToConditionVariable = nullptr;
5388   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5389     ToConditionVariable =
5390       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5391     if (!ToConditionVariable)
5392       return nullptr;
5393   }
5394   Expr *ToCondition = Importer.Import(S->getCond());
5395   if (!ToCondition && S->getCond())
5396     return nullptr;
5397   SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
5398                          Importer.getToContext(), ToInit,
5399                          ToConditionVariable, ToCondition);
5400   Stmt *ToBody = Importer.Import(S->getBody());
5401   if (!ToBody && S->getBody())
5402     return nullptr;
5403   ToStmt->setBody(ToBody);
5404   ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5405   // Now we have to re-chain the cases.
5406   SwitchCase *LastChainedSwitchCase = nullptr;
5407   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5408        SC = SC->getNextSwitchCase()) {
5409     SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5410     if (!ToSC)
5411       return nullptr;
5412     if (LastChainedSwitchCase)
5413       LastChainedSwitchCase->setNextSwitchCase(ToSC);
5414     else
5415       ToStmt->setSwitchCaseList(ToSC);
5416     LastChainedSwitchCase = ToSC;
5417   }
5418   return ToStmt;
5419 }
5420 
5421 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5422   VarDecl *ToConditionVariable = nullptr;
5423   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5424     ToConditionVariable =
5425       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5426     if (!ToConditionVariable)
5427       return nullptr;
5428   }
5429   Expr *ToCondition = Importer.Import(S->getCond());
5430   if (!ToCondition && S->getCond())
5431     return nullptr;
5432   Stmt *ToBody = Importer.Import(S->getBody());
5433   if (!ToBody && S->getBody())
5434     return nullptr;
5435   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5436   return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5437                                                  ToConditionVariable,
5438                                                  ToCondition, ToBody,
5439                                                  ToWhileLoc);
5440 }
5441 
5442 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5443   Stmt *ToBody = Importer.Import(S->getBody());
5444   if (!ToBody && S->getBody())
5445     return nullptr;
5446   Expr *ToCondition = Importer.Import(S->getCond());
5447   if (!ToCondition && S->getCond())
5448     return nullptr;
5449   SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5450   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5451   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5452   return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5453                                               ToDoLoc, ToWhileLoc,
5454                                               ToRParenLoc);
5455 }
5456 
5457 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5458   Stmt *ToInit = Importer.Import(S->getInit());
5459   if (!ToInit && S->getInit())
5460     return nullptr;
5461   Expr *ToCondition = Importer.Import(S->getCond());
5462   if (!ToCondition && S->getCond())
5463     return nullptr;
5464   VarDecl *ToConditionVariable = nullptr;
5465   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5466     ToConditionVariable =
5467       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5468     if (!ToConditionVariable)
5469       return nullptr;
5470   }
5471   Expr *ToInc = Importer.Import(S->getInc());
5472   if (!ToInc && S->getInc())
5473     return nullptr;
5474   Stmt *ToBody = Importer.Import(S->getBody());
5475   if (!ToBody && S->getBody())
5476     return nullptr;
5477   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5478   SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5479   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5480   return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5481                                                ToInit, ToCondition,
5482                                                ToConditionVariable,
5483                                                ToInc, ToBody,
5484                                                ToForLoc, ToLParenLoc,
5485                                                ToRParenLoc);
5486 }
5487 
5488 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5489   LabelDecl *ToLabel = nullptr;
5490   if (LabelDecl *FromLabel = S->getLabel()) {
5491     ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5492     if (!ToLabel)
5493       return nullptr;
5494   }
5495   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5496   SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5497   return new (Importer.getToContext()) GotoStmt(ToLabel,
5498                                                 ToGotoLoc, ToLabelLoc);
5499 }
5500 
5501 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5502   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5503   SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5504   Expr *ToTarget = Importer.Import(S->getTarget());
5505   if (!ToTarget && S->getTarget())
5506     return nullptr;
5507   return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5508                                                         ToTarget);
5509 }
5510 
5511 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5512   SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5513   return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5514 }
5515 
5516 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5517   SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5518   return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5519 }
5520 
5521 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5522   SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5523   Expr *ToRetExpr = Importer.Import(S->getRetValue());
5524   if (!ToRetExpr && S->getRetValue())
5525     return nullptr;
5526   VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
5527   VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5528   if (!ToNRVOCandidate && NRVOCandidate)
5529     return nullptr;
5530   return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5531                                                   ToNRVOCandidate);
5532 }
5533 
5534 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5535   SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5536   VarDecl *ToExceptionDecl = nullptr;
5537   if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5538     ToExceptionDecl =
5539       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5540     if (!ToExceptionDecl)
5541       return nullptr;
5542   }
5543   Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5544   if (!ToHandlerBlock && S->getHandlerBlock())
5545     return nullptr;
5546   return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5547                                                     ToExceptionDecl,
5548                                                     ToHandlerBlock);
5549 }
5550 
5551 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5552   SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5553   Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5554   if (!ToTryBlock && S->getTryBlock())
5555     return nullptr;
5556   SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5557   for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5558     CXXCatchStmt *FromHandler = S->getHandler(HI);
5559     if (Stmt *ToHandler = Importer.Import(FromHandler))
5560       ToHandlers[HI] = ToHandler;
5561     else
5562       return nullptr;
5563   }
5564   return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5565                             ToHandlers);
5566 }
5567 
5568 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5569   DeclStmt *ToRange =
5570     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5571   if (!ToRange && S->getRangeStmt())
5572     return nullptr;
5573   DeclStmt *ToBegin =
5574     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5575   if (!ToBegin && S->getBeginStmt())
5576     return nullptr;
5577   DeclStmt *ToEnd =
5578     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5579   if (!ToEnd && S->getEndStmt())
5580     return nullptr;
5581   Expr *ToCond = Importer.Import(S->getCond());
5582   if (!ToCond && S->getCond())
5583     return nullptr;
5584   Expr *ToInc = Importer.Import(S->getInc());
5585   if (!ToInc && S->getInc())
5586     return nullptr;
5587   DeclStmt *ToLoopVar =
5588     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5589   if (!ToLoopVar && S->getLoopVarStmt())
5590     return nullptr;
5591   Stmt *ToBody = Importer.Import(S->getBody());
5592   if (!ToBody && S->getBody())
5593     return nullptr;
5594   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5595   SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5596   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5597   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5598   return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5599                                                        ToCond, ToInc,
5600                                                        ToLoopVar, ToBody,
5601                                                        ToForLoc, ToCoawaitLoc,
5602                                                        ToColonLoc, ToRParenLoc);
5603 }
5604 
5605 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5606   Stmt *ToElem = Importer.Import(S->getElement());
5607   if (!ToElem && S->getElement())
5608     return nullptr;
5609   Expr *ToCollect = Importer.Import(S->getCollection());
5610   if (!ToCollect && S->getCollection())
5611     return nullptr;
5612   Stmt *ToBody = Importer.Import(S->getBody());
5613   if (!ToBody && S->getBody())
5614     return nullptr;
5615   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5616   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5617   return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5618                                                              ToCollect,
5619                                                              ToBody, ToForLoc,
5620                                                              ToRParenLoc);
5621 }
5622 
5623 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5624   SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5625   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5626   VarDecl *ToExceptionDecl = nullptr;
5627   if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5628     ToExceptionDecl =
5629       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5630     if (!ToExceptionDecl)
5631       return nullptr;
5632   }
5633   Stmt *ToBody = Importer.Import(S->getCatchBody());
5634   if (!ToBody && S->getCatchBody())
5635     return nullptr;
5636   return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5637                                                        ToRParenLoc,
5638                                                        ToExceptionDecl,
5639                                                        ToBody);
5640 }
5641 
5642 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5643   SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5644   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5645   if (!ToAtFinallyStmt && S->getFinallyBody())
5646     return nullptr;
5647   return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5648                                                          ToAtFinallyStmt);
5649 }
5650 
5651 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5652   SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5653   Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5654   if (!ToAtTryStmt && S->getTryBody())
5655     return nullptr;
5656   SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5657   for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5658     ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5659     if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5660       ToCatchStmts[CI] = ToCatchStmt;
5661     else
5662       return nullptr;
5663   }
5664   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5665   if (!ToAtFinallyStmt && S->getFinallyStmt())
5666     return nullptr;
5667   return ObjCAtTryStmt::Create(Importer.getToContext(),
5668                                ToAtTryLoc, ToAtTryStmt,
5669                                ToCatchStmts.begin(), ToCatchStmts.size(),
5670                                ToAtFinallyStmt);
5671 }
5672 
5673 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5674   (ObjCAtSynchronizedStmt *S) {
5675   SourceLocation ToAtSynchronizedLoc =
5676     Importer.Import(S->getAtSynchronizedLoc());
5677   Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5678   if (!ToSynchExpr && S->getSynchExpr())
5679     return nullptr;
5680   Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5681   if (!ToSynchBody && S->getSynchBody())
5682     return nullptr;
5683   return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5684     ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5685 }
5686 
5687 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5688   SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5689   Expr *ToThrow = Importer.Import(S->getThrowExpr());
5690   if (!ToThrow && S->getThrowExpr())
5691     return nullptr;
5692   return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5693 }
5694 
5695 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5696   (ObjCAutoreleasePoolStmt *S) {
5697   SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5698   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5699   if (!ToSubStmt && S->getSubStmt())
5700     return nullptr;
5701   return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5702                                                                ToSubStmt);
5703 }
5704 
5705 //----------------------------------------------------------------------------
5706 // Import Expressions
5707 //----------------------------------------------------------------------------
5708 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5709   Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5710     << E->getStmtClassName();
5711   return nullptr;
5712 }
5713 
5714 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5715   QualType T = Importer.Import(E->getType());
5716   if (T.isNull())
5717     return nullptr;
5718 
5719   Expr *SubExpr = Importer.Import(E->getSubExpr());
5720   if (!SubExpr && E->getSubExpr())
5721     return nullptr;
5722 
5723   TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5724   if (!TInfo)
5725     return nullptr;
5726 
5727   return new (Importer.getToContext()) VAArgExpr(
5728         Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5729         Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5730 }
5731 
5732 
5733 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5734   QualType T = Importer.Import(E->getType());
5735   if (T.isNull())
5736     return nullptr;
5737 
5738   return new (Importer.getToContext()) GNUNullExpr(
5739         T, Importer.Import(E->getLocStart()));
5740 }
5741 
5742 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5743   QualType T = Importer.Import(E->getType());
5744   if (T.isNull())
5745     return nullptr;
5746 
5747   StringLiteral *SL = cast_or_null<StringLiteral>(
5748         Importer.Import(E->getFunctionName()));
5749   if (!SL && E->getFunctionName())
5750     return nullptr;
5751 
5752   return new (Importer.getToContext()) PredefinedExpr(
5753         Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5754 }
5755 
5756 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5757   ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5758   if (!ToD)
5759     return nullptr;
5760 
5761   NamedDecl *FoundD = nullptr;
5762   if (E->getDecl() != E->getFoundDecl()) {
5763     FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5764     if (!FoundD)
5765       return nullptr;
5766   }
5767 
5768   QualType T = Importer.Import(E->getType());
5769   if (T.isNull())
5770     return nullptr;
5771 
5772 
5773   TemplateArgumentListInfo ToTAInfo;
5774   TemplateArgumentListInfo *ResInfo = nullptr;
5775   if (E->hasExplicitTemplateArgs()) {
5776     for (const auto &FromLoc : E->template_arguments()) {
5777       bool Error = false;
5778       TemplateArgumentLoc ToTALoc = ImportTemplateArgumentLoc(FromLoc, Error);
5779       if (Error)
5780         return nullptr;
5781       ToTAInfo.addArgument(ToTALoc);
5782     }
5783     ResInfo = &ToTAInfo;
5784   }
5785 
5786   DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5787                                          Importer.Import(E->getQualifierLoc()),
5788                                    Importer.Import(E->getTemplateKeywordLoc()),
5789                                          ToD,
5790                                         E->refersToEnclosingVariableOrCapture(),
5791                                          Importer.Import(E->getLocation()),
5792                                          T, E->getValueKind(),
5793                                          FoundD, ResInfo);
5794   if (E->hadMultipleCandidates())
5795     DRE->setHadMultipleCandidates(true);
5796   return DRE;
5797 }
5798 
5799 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5800   QualType T = Importer.Import(E->getType());
5801   if (T.isNull())
5802     return nullptr;
5803 
5804   return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5805 }
5806 
5807 ASTNodeImporter::Designator
5808 ASTNodeImporter::ImportDesignator(const Designator &D) {
5809   if (D.isFieldDesignator()) {
5810     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5811     // Caller checks for import error
5812     return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5813                       Importer.Import(D.getFieldLoc()));
5814   }
5815   if (D.isArrayDesignator())
5816     return Designator(D.getFirstExprIndex(),
5817                       Importer.Import(D.getLBracketLoc()),
5818                       Importer.Import(D.getRBracketLoc()));
5819 
5820   assert(D.isArrayRangeDesignator());
5821   return Designator(D.getFirstExprIndex(),
5822                     Importer.Import(D.getLBracketLoc()),
5823                     Importer.Import(D.getEllipsisLoc()),
5824                     Importer.Import(D.getRBracketLoc()));
5825 }
5826 
5827 
5828 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5829   Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5830   if (!Init)
5831     return nullptr;
5832 
5833   SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5834   // List elements from the second, the first is Init itself
5835   for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5836     if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5837       IndexExprs[I - 1] = Arg;
5838     else
5839       return nullptr;
5840   }
5841 
5842   SmallVector<Designator, 4> Designators(DIE->size());
5843   llvm::transform(DIE->designators(), Designators.begin(),
5844                   [this](const Designator &D) -> Designator {
5845                     return ImportDesignator(D);
5846                   });
5847 
5848   for (const Designator &D : DIE->designators())
5849     if (D.isFieldDesignator() && !D.getFieldName())
5850       return nullptr;
5851 
5852   return DesignatedInitExpr::Create(
5853         Importer.getToContext(), Designators,
5854         IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5855         DIE->usesGNUSyntax(), Init);
5856 }
5857 
5858 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5859   QualType T = Importer.Import(E->getType());
5860   if (T.isNull())
5861     return nullptr;
5862 
5863   return new (Importer.getToContext())
5864       CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5865 }
5866 
5867 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5868   QualType T = Importer.Import(E->getType());
5869   if (T.isNull())
5870     return nullptr;
5871 
5872   return IntegerLiteral::Create(Importer.getToContext(),
5873                                 E->getValue(), T,
5874                                 Importer.Import(E->getLocation()));
5875 }
5876 
5877 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5878   QualType T = Importer.Import(E->getType());
5879   if (T.isNull())
5880     return nullptr;
5881 
5882   return FloatingLiteral::Create(Importer.getToContext(),
5883                                 E->getValue(), E->isExact(), T,
5884                                 Importer.Import(E->getLocation()));
5885 }
5886 
5887 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5888   QualType T = Importer.Import(E->getType());
5889   if (T.isNull())
5890     return nullptr;
5891 
5892   return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5893                                                         E->getKind(), T,
5894                                           Importer.Import(E->getLocation()));
5895 }
5896 
5897 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5898   QualType T = Importer.Import(E->getType());
5899   if (T.isNull())
5900     return nullptr;
5901 
5902   SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5903   ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5904 
5905   return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5906                                E->getKind(), E->isPascal(), T,
5907                                Locations.data(), Locations.size());
5908 }
5909 
5910 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5911   QualType T = Importer.Import(E->getType());
5912   if (T.isNull())
5913     return nullptr;
5914 
5915   TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5916   if (!TInfo)
5917     return nullptr;
5918 
5919   Expr *Init = Importer.Import(E->getInitializer());
5920   if (!Init)
5921     return nullptr;
5922 
5923   return new (Importer.getToContext()) CompoundLiteralExpr(
5924         Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5925         Init, E->isFileScope());
5926 }
5927 
5928 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5929   QualType T = Importer.Import(E->getType());
5930   if (T.isNull())
5931     return nullptr;
5932 
5933   SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5934   if (ImportArrayChecked(
5935         E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5936         Exprs.begin()))
5937     return nullptr;
5938 
5939   return new (Importer.getToContext()) AtomicExpr(
5940         Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5941         Importer.Import(E->getRParenLoc()));
5942 }
5943 
5944 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5945   QualType T = Importer.Import(E->getType());
5946   if (T.isNull())
5947     return nullptr;
5948 
5949   LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5950   if (!ToLabel)
5951     return nullptr;
5952 
5953   return new (Importer.getToContext()) AddrLabelExpr(
5954         Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5955         ToLabel, T);
5956 }
5957 
5958 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5959   Expr *SubExpr = Importer.Import(E->getSubExpr());
5960   if (!SubExpr)
5961     return nullptr;
5962 
5963   return new (Importer.getToContext())
5964                                   ParenExpr(Importer.Import(E->getLParen()),
5965                                             Importer.Import(E->getRParen()),
5966                                             SubExpr);
5967 }
5968 
5969 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5970   SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5971   if (ImportContainerChecked(E->exprs(), Exprs))
5972     return nullptr;
5973 
5974   return new (Importer.getToContext()) ParenListExpr(
5975         Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5976         Exprs, Importer.Import(E->getLParenLoc()));
5977 }
5978 
5979 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5980   QualType T = Importer.Import(E->getType());
5981   if (T.isNull())
5982     return nullptr;
5983 
5984   CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
5985         Importer.Import(E->getSubStmt()));
5986   if (!ToSubStmt && E->getSubStmt())
5987     return nullptr;
5988 
5989   return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5990         Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5991 }
5992 
5993 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5994   QualType T = Importer.Import(E->getType());
5995   if (T.isNull())
5996     return nullptr;
5997 
5998   Expr *SubExpr = Importer.Import(E->getSubExpr());
5999   if (!SubExpr)
6000     return nullptr;
6001 
6002   return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
6003                                                      T, E->getValueKind(),
6004                                                      E->getObjectKind(),
6005                                          Importer.Import(E->getOperatorLoc()));
6006 }
6007 
6008 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
6009                                             UnaryExprOrTypeTraitExpr *E) {
6010   QualType ResultType = Importer.Import(E->getType());
6011 
6012   if (E->isArgumentType()) {
6013     TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
6014     if (!TInfo)
6015       return nullptr;
6016 
6017     return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6018                                            TInfo, ResultType,
6019                                            Importer.Import(E->getOperatorLoc()),
6020                                            Importer.Import(E->getRParenLoc()));
6021   }
6022 
6023   Expr *SubExpr = Importer.Import(E->getArgumentExpr());
6024   if (!SubExpr)
6025     return nullptr;
6026 
6027   return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6028                                           SubExpr, ResultType,
6029                                           Importer.Import(E->getOperatorLoc()),
6030                                           Importer.Import(E->getRParenLoc()));
6031 }
6032 
6033 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6034   QualType T = Importer.Import(E->getType());
6035   if (T.isNull())
6036     return nullptr;
6037 
6038   Expr *LHS = Importer.Import(E->getLHS());
6039   if (!LHS)
6040     return nullptr;
6041 
6042   Expr *RHS = Importer.Import(E->getRHS());
6043   if (!RHS)
6044     return nullptr;
6045 
6046   return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
6047                                                       T, E->getValueKind(),
6048                                                       E->getObjectKind(),
6049                                            Importer.Import(E->getOperatorLoc()),
6050                                                       E->isFPContractable());
6051 }
6052 
6053 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6054   QualType T = Importer.Import(E->getType());
6055   if (T.isNull())
6056     return nullptr;
6057 
6058   Expr *ToLHS = Importer.Import(E->getLHS());
6059   if (!ToLHS)
6060     return nullptr;
6061 
6062   Expr *ToRHS = Importer.Import(E->getRHS());
6063   if (!ToRHS)
6064     return nullptr;
6065 
6066   Expr *ToCond = Importer.Import(E->getCond());
6067   if (!ToCond)
6068     return nullptr;
6069 
6070   return new (Importer.getToContext()) ConditionalOperator(
6071         ToCond, Importer.Import(E->getQuestionLoc()),
6072         ToLHS, Importer.Import(E->getColonLoc()),
6073         ToRHS, T, E->getValueKind(), E->getObjectKind());
6074 }
6075 
6076 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
6077     BinaryConditionalOperator *E) {
6078   QualType T = Importer.Import(E->getType());
6079   if (T.isNull())
6080     return nullptr;
6081 
6082   Expr *Common = Importer.Import(E->getCommon());
6083   if (!Common)
6084     return nullptr;
6085 
6086   Expr *Cond = Importer.Import(E->getCond());
6087   if (!Cond)
6088     return nullptr;
6089 
6090   OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
6091         Importer.Import(E->getOpaqueValue()));
6092   if (!OpaqueValue)
6093     return nullptr;
6094 
6095   Expr *TrueExpr = Importer.Import(E->getTrueExpr());
6096   if (!TrueExpr)
6097     return nullptr;
6098 
6099   Expr *FalseExpr = Importer.Import(E->getFalseExpr());
6100   if (!FalseExpr)
6101     return nullptr;
6102 
6103   return new (Importer.getToContext()) BinaryConditionalOperator(
6104         Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
6105         Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
6106         T, E->getValueKind(), E->getObjectKind());
6107 }
6108 
6109 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
6110   QualType T = Importer.Import(E->getType());
6111   if (T.isNull())
6112     return nullptr;
6113 
6114   TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
6115   if (!ToQueried)
6116     return nullptr;
6117 
6118   Expr *Dim = Importer.Import(E->getDimensionExpression());
6119   if (!Dim && E->getDimensionExpression())
6120     return nullptr;
6121 
6122   return new (Importer.getToContext()) ArrayTypeTraitExpr(
6123         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6124         E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
6125 }
6126 
6127 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
6128   QualType T = Importer.Import(E->getType());
6129   if (T.isNull())
6130     return nullptr;
6131 
6132   Expr *ToQueried = Importer.Import(E->getQueriedExpression());
6133   if (!ToQueried)
6134     return nullptr;
6135 
6136   return new (Importer.getToContext()) ExpressionTraitExpr(
6137         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6138         E->getValue(), Importer.Import(E->getLocEnd()), T);
6139 }
6140 
6141 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
6142   QualType T = Importer.Import(E->getType());
6143   if (T.isNull())
6144     return nullptr;
6145 
6146   Expr *SourceExpr = Importer.Import(E->getSourceExpr());
6147   if (!SourceExpr && E->getSourceExpr())
6148     return nullptr;
6149 
6150   return new (Importer.getToContext()) OpaqueValueExpr(
6151         Importer.Import(E->getLocation()), T, E->getValueKind(),
6152         E->getObjectKind(), SourceExpr);
6153 }
6154 
6155 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
6156   QualType T = Importer.Import(E->getType());
6157   if (T.isNull())
6158     return nullptr;
6159 
6160   Expr *ToLHS = Importer.Import(E->getLHS());
6161   if (!ToLHS)
6162     return nullptr;
6163 
6164   Expr *ToRHS = Importer.Import(E->getRHS());
6165   if (!ToRHS)
6166     return nullptr;
6167 
6168   return new (Importer.getToContext()) ArraySubscriptExpr(
6169         ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
6170         Importer.Import(E->getRBracketLoc()));
6171 }
6172 
6173 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
6174   QualType T = Importer.Import(E->getType());
6175   if (T.isNull())
6176     return nullptr;
6177 
6178   QualType CompLHSType = Importer.Import(E->getComputationLHSType());
6179   if (CompLHSType.isNull())
6180     return nullptr;
6181 
6182   QualType CompResultType = Importer.Import(E->getComputationResultType());
6183   if (CompResultType.isNull())
6184     return nullptr;
6185 
6186   Expr *LHS = Importer.Import(E->getLHS());
6187   if (!LHS)
6188     return nullptr;
6189 
6190   Expr *RHS = Importer.Import(E->getRHS());
6191   if (!RHS)
6192     return nullptr;
6193 
6194   return new (Importer.getToContext())
6195                         CompoundAssignOperator(LHS, RHS, E->getOpcode(),
6196                                                T, E->getValueKind(),
6197                                                E->getObjectKind(),
6198                                                CompLHSType, CompResultType,
6199                                            Importer.Import(E->getOperatorLoc()),
6200                                                E->isFPContractable());
6201 }
6202 
6203 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
6204   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
6205     if (CXXBaseSpecifier *Spec = Importer.Import(*I))
6206       Path.push_back(Spec);
6207     else
6208       return true;
6209   }
6210   return false;
6211 }
6212 
6213 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
6214   QualType T = Importer.Import(E->getType());
6215   if (T.isNull())
6216     return nullptr;
6217 
6218   Expr *SubExpr = Importer.Import(E->getSubExpr());
6219   if (!SubExpr)
6220     return nullptr;
6221 
6222   CXXCastPath BasePath;
6223   if (ImportCastPath(E, BasePath))
6224     return nullptr;
6225 
6226   return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
6227                                   SubExpr, &BasePath, E->getValueKind());
6228 }
6229 
6230 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
6231   QualType T = Importer.Import(E->getType());
6232   if (T.isNull())
6233     return nullptr;
6234 
6235   Expr *SubExpr = Importer.Import(E->getSubExpr());
6236   if (!SubExpr)
6237     return nullptr;
6238 
6239   TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
6240   if (!TInfo && E->getTypeInfoAsWritten())
6241     return nullptr;
6242 
6243   CXXCastPath BasePath;
6244   if (ImportCastPath(E, BasePath))
6245     return nullptr;
6246 
6247   switch (E->getStmtClass()) {
6248   case Stmt::CStyleCastExprClass: {
6249     CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
6250     return CStyleCastExpr::Create(Importer.getToContext(), T,
6251                                   E->getValueKind(), E->getCastKind(),
6252                                   SubExpr, &BasePath, TInfo,
6253                                   Importer.Import(CCE->getLParenLoc()),
6254                                   Importer.Import(CCE->getRParenLoc()));
6255   }
6256 
6257   case Stmt::CXXFunctionalCastExprClass: {
6258     CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
6259     return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
6260                                          E->getValueKind(), TInfo,
6261                                          E->getCastKind(), SubExpr, &BasePath,
6262                                          Importer.Import(FCE->getLParenLoc()),
6263                                          Importer.Import(FCE->getRParenLoc()));
6264   }
6265 
6266   case Stmt::ObjCBridgedCastExprClass: {
6267       ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
6268       return new (Importer.getToContext()) ObjCBridgedCastExpr(
6269             Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
6270             E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
6271             TInfo, SubExpr);
6272   }
6273   default:
6274     break; // just fall through
6275   }
6276 
6277   CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
6278   SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
6279       RParenLoc = Importer.Import(Named->getRParenLoc());
6280   SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
6281 
6282   switch (E->getStmtClass()) {
6283   case Stmt::CXXStaticCastExprClass:
6284     return CXXStaticCastExpr::Create(Importer.getToContext(), T,
6285                                      E->getValueKind(), E->getCastKind(),
6286                                      SubExpr, &BasePath, TInfo,
6287                                      ExprLoc, RParenLoc, Brackets);
6288 
6289   case Stmt::CXXDynamicCastExprClass:
6290     return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6291                                       E->getValueKind(), E->getCastKind(),
6292                                       SubExpr, &BasePath, TInfo,
6293                                       ExprLoc, RParenLoc, Brackets);
6294 
6295   case Stmt::CXXReinterpretCastExprClass:
6296     return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6297                                           E->getValueKind(), E->getCastKind(),
6298                                           SubExpr, &BasePath, TInfo,
6299                                           ExprLoc, RParenLoc, Brackets);
6300 
6301   case Stmt::CXXConstCastExprClass:
6302     return CXXConstCastExpr::Create(Importer.getToContext(), T,
6303                                     E->getValueKind(), SubExpr, TInfo, ExprLoc,
6304                                     RParenLoc, Brackets);
6305   default:
6306     llvm_unreachable("Cast expression of unsupported type!");
6307     return nullptr;
6308   }
6309 }
6310 
6311 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6312   QualType T = Importer.Import(OE->getType());
6313   if (T.isNull())
6314     return nullptr;
6315 
6316   SmallVector<OffsetOfNode, 4> Nodes;
6317   for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6318     const OffsetOfNode &Node = OE->getComponent(I);
6319 
6320     switch (Node.getKind()) {
6321     case OffsetOfNode::Array:
6322       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6323                                    Node.getArrayExprIndex(),
6324                                    Importer.Import(Node.getLocEnd())));
6325       break;
6326 
6327     case OffsetOfNode::Base: {
6328       CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6329       if (!BS && Node.getBase())
6330         return nullptr;
6331       Nodes.push_back(OffsetOfNode(BS));
6332       break;
6333     }
6334     case OffsetOfNode::Field: {
6335       FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6336       if (!FD)
6337         return nullptr;
6338       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6339                                    Importer.Import(Node.getLocEnd())));
6340       break;
6341     }
6342     case OffsetOfNode::Identifier: {
6343       IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6344       if (!ToII)
6345         return nullptr;
6346       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6347                                    Importer.Import(Node.getLocEnd())));
6348       break;
6349     }
6350     }
6351   }
6352 
6353   SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6354   for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6355     Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6356     if (!ToIndexExpr)
6357       return nullptr;
6358     Exprs[I] = ToIndexExpr;
6359   }
6360 
6361   TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6362   if (!TInfo && OE->getTypeSourceInfo())
6363     return nullptr;
6364 
6365   return OffsetOfExpr::Create(Importer.getToContext(), T,
6366                               Importer.Import(OE->getOperatorLoc()),
6367                               TInfo, Nodes, Exprs,
6368                               Importer.Import(OE->getRParenLoc()));
6369 }
6370 
6371 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6372   QualType T = Importer.Import(E->getType());
6373   if (T.isNull())
6374     return nullptr;
6375 
6376   Expr *Operand = Importer.Import(E->getOperand());
6377   if (!Operand)
6378     return nullptr;
6379 
6380   CanThrowResult CanThrow;
6381   if (E->isValueDependent())
6382     CanThrow = CT_Dependent;
6383   else
6384     CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6385 
6386   return new (Importer.getToContext()) CXXNoexceptExpr(
6387         T, Operand, CanThrow,
6388         Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6389 }
6390 
6391 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6392   QualType T = Importer.Import(E->getType());
6393   if (T.isNull())
6394     return nullptr;
6395 
6396   Expr *SubExpr = Importer.Import(E->getSubExpr());
6397   if (!SubExpr && E->getSubExpr())
6398     return nullptr;
6399 
6400   return new (Importer.getToContext()) CXXThrowExpr(
6401         SubExpr, T, Importer.Import(E->getThrowLoc()),
6402         E->isThrownVariableInScope());
6403 }
6404 
6405 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6406   ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
6407         Importer.Import(E->getParam()));
6408   if (!Param)
6409     return nullptr;
6410 
6411   return CXXDefaultArgExpr::Create(
6412         Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6413 }
6414 
6415 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6416   QualType T = Importer.Import(E->getType());
6417   if (T.isNull())
6418     return nullptr;
6419 
6420   TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6421   if (!TypeInfo)
6422     return nullptr;
6423 
6424   return new (Importer.getToContext()) CXXScalarValueInitExpr(
6425         T, TypeInfo, Importer.Import(E->getRParenLoc()));
6426 }
6427 
6428 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6429   Expr *SubExpr = Importer.Import(E->getSubExpr());
6430   if (!SubExpr)
6431     return nullptr;
6432 
6433   auto *Dtor = cast_or_null<CXXDestructorDecl>(
6434         Importer.Import(const_cast<CXXDestructorDecl *>(
6435                           E->getTemporary()->getDestructor())));
6436   if (!Dtor)
6437     return nullptr;
6438 
6439   ASTContext &ToCtx = Importer.getToContext();
6440   CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6441   return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6442 }
6443 
6444 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6445   QualType T = Importer.Import(CE->getType());
6446   if (T.isNull())
6447     return nullptr;
6448 
6449   SmallVector<Expr *, 8> Args(CE->getNumArgs());
6450   if (ImportContainerChecked(CE->arguments(), Args))
6451     return nullptr;
6452 
6453   auto *Ctor = cast_or_null<CXXConstructorDecl>(
6454         Importer.Import(CE->getConstructor()));
6455   if (!Ctor)
6456     return nullptr;
6457 
6458   return CXXTemporaryObjectExpr::Create(
6459         Importer.getToContext(), T,
6460         Importer.Import(CE->getLocStart()),
6461         Ctor,
6462         CE->isElidable(),
6463         Args,
6464         CE->hadMultipleCandidates(),
6465         CE->isListInitialization(),
6466         CE->isStdInitListInitialization(),
6467         CE->requiresZeroInitialization(),
6468         CE->getConstructionKind(),
6469         Importer.Import(CE->getParenOrBraceRange()));
6470 }
6471 
6472 Expr *
6473 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6474   QualType T = Importer.Import(E->getType());
6475   if (T.isNull())
6476     return nullptr;
6477 
6478   Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6479   if (!TempE)
6480     return nullptr;
6481 
6482   ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
6483         Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6484   if (!ExtendedBy && E->getExtendingDecl())
6485     return nullptr;
6486 
6487   auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
6488         T, TempE, E->isBoundToLvalueReference());
6489 
6490   // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6491   ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6492   return ToMTE;
6493 }
6494 
6495 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6496   QualType T = Importer.Import(CE->getType());
6497   if (T.isNull())
6498     return nullptr;
6499 
6500   SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6501   if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6502     return nullptr;
6503 
6504   FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
6505         Importer.Import(CE->getOperatorNew()));
6506   if (!OperatorNewDecl && CE->getOperatorNew())
6507     return nullptr;
6508 
6509   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6510         Importer.Import(CE->getOperatorDelete()));
6511   if (!OperatorDeleteDecl && CE->getOperatorDelete())
6512     return nullptr;
6513 
6514   Expr *ToInit = Importer.Import(CE->getInitializer());
6515   if (!ToInit && CE->getInitializer())
6516     return nullptr;
6517 
6518   TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6519   if (!TInfo)
6520     return nullptr;
6521 
6522   Expr *ToArrSize = Importer.Import(CE->getArraySize());
6523   if (!ToArrSize && CE->getArraySize())
6524     return nullptr;
6525 
6526   return new (Importer.getToContext()) CXXNewExpr(
6527         Importer.getToContext(),
6528         CE->isGlobalNew(),
6529         OperatorNewDecl, OperatorDeleteDecl,
6530         CE->passAlignment(),
6531         CE->doesUsualArrayDeleteWantSize(),
6532         PlacementArgs,
6533         Importer.Import(CE->getTypeIdParens()),
6534         ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6535         Importer.Import(CE->getSourceRange()),
6536         Importer.Import(CE->getDirectInitRange()));
6537 }
6538 
6539 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6540   QualType T = Importer.Import(E->getType());
6541   if (T.isNull())
6542     return nullptr;
6543 
6544   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6545         Importer.Import(E->getOperatorDelete()));
6546   if (!OperatorDeleteDecl && E->getOperatorDelete())
6547     return nullptr;
6548 
6549   Expr *ToArg = Importer.Import(E->getArgument());
6550   if (!ToArg && E->getArgument())
6551     return nullptr;
6552 
6553   return new (Importer.getToContext()) CXXDeleteExpr(
6554         T, E->isGlobalDelete(),
6555         E->isArrayForm(),
6556         E->isArrayFormAsWritten(),
6557         E->doesUsualArrayDeleteWantSize(),
6558         OperatorDeleteDecl,
6559         ToArg,
6560         Importer.Import(E->getLocStart()));
6561 }
6562 
6563 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6564   QualType T = Importer.Import(E->getType());
6565   if (T.isNull())
6566     return nullptr;
6567 
6568   CXXConstructorDecl *ToCCD =
6569     dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6570   if (!ToCCD)
6571     return nullptr;
6572 
6573   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6574   if (ImportContainerChecked(E->arguments(), ToArgs))
6575     return nullptr;
6576 
6577   return CXXConstructExpr::Create(Importer.getToContext(), T,
6578                                   Importer.Import(E->getLocation()),
6579                                   ToCCD, E->isElidable(),
6580                                   ToArgs, E->hadMultipleCandidates(),
6581                                   E->isListInitialization(),
6582                                   E->isStdInitListInitialization(),
6583                                   E->requiresZeroInitialization(),
6584                                   E->getConstructionKind(),
6585                                   Importer.Import(E->getParenOrBraceRange()));
6586 }
6587 
6588 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6589   Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6590   if (!SubExpr && EWC->getSubExpr())
6591     return nullptr;
6592 
6593   SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6594   for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6595     if (ExprWithCleanups::CleanupObject Obj =
6596         cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6597       Objs[I] = Obj;
6598     else
6599       return nullptr;
6600 
6601   return ExprWithCleanups::Create(Importer.getToContext(),
6602                                   SubExpr, EWC->cleanupsHaveSideEffects(),
6603                                   Objs);
6604 }
6605 
6606 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6607   QualType T = Importer.Import(E->getType());
6608   if (T.isNull())
6609     return nullptr;
6610 
6611   Expr *ToFn = Importer.Import(E->getCallee());
6612   if (!ToFn)
6613     return nullptr;
6614 
6615   SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6616   if (ImportContainerChecked(E->arguments(), ToArgs))
6617     return nullptr;
6618 
6619   return new (Importer.getToContext()) CXXMemberCallExpr(
6620         Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6621         Importer.Import(E->getRParenLoc()));
6622 }
6623 
6624 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6625   QualType T = Importer.Import(E->getType());
6626   if (T.isNull())
6627     return nullptr;
6628 
6629   return new (Importer.getToContext())
6630   CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6631 }
6632 
6633 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6634   QualType T = Importer.Import(E->getType());
6635   if (T.isNull())
6636     return nullptr;
6637 
6638   return new (Importer.getToContext())
6639   CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6640 }
6641 
6642 
6643 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6644   QualType T = Importer.Import(E->getType());
6645   if (T.isNull())
6646     return nullptr;
6647 
6648   Expr *ToBase = Importer.Import(E->getBase());
6649   if (!ToBase && E->getBase())
6650     return nullptr;
6651 
6652   ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6653   if (!ToMember && E->getMemberDecl())
6654     return nullptr;
6655 
6656   DeclAccessPair ToFoundDecl = DeclAccessPair::make(
6657     dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
6658     E->getFoundDecl().getAccess());
6659 
6660   DeclarationNameInfo ToMemberNameInfo(
6661     Importer.Import(E->getMemberNameInfo().getName()),
6662     Importer.Import(E->getMemberNameInfo().getLoc()));
6663 
6664   if (E->hasExplicitTemplateArgs()) {
6665     return nullptr; // FIXME: handle template arguments
6666   }
6667 
6668   return MemberExpr::Create(Importer.getToContext(), ToBase,
6669                             E->isArrow(),
6670                             Importer.Import(E->getOperatorLoc()),
6671                             Importer.Import(E->getQualifierLoc()),
6672                             Importer.Import(E->getTemplateKeywordLoc()),
6673                             ToMember, ToFoundDecl, ToMemberNameInfo,
6674                             nullptr, T, E->getValueKind(),
6675                             E->getObjectKind());
6676 }
6677 
6678 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6679   QualType T = Importer.Import(E->getType());
6680   if (T.isNull())
6681     return nullptr;
6682 
6683   Expr *ToCallee = Importer.Import(E->getCallee());
6684   if (!ToCallee && E->getCallee())
6685     return nullptr;
6686 
6687   unsigned NumArgs = E->getNumArgs();
6688 
6689   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
6690 
6691   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
6692     Expr *FromArg = E->getArg(ai);
6693     Expr *ToArg = Importer.Import(FromArg);
6694     if (!ToArg)
6695       return nullptr;
6696     ToArgs[ai] = ToArg;
6697   }
6698 
6699   Expr **ToArgs_Copied = new (Importer.getToContext())
6700     Expr*[NumArgs];
6701 
6702   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6703     ToArgs_Copied[ai] = ToArgs[ai];
6704 
6705   return new (Importer.getToContext())
6706     CallExpr(Importer.getToContext(), ToCallee,
6707              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6708              Importer.Import(E->getRParenLoc()));
6709 }
6710 
6711 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6712   QualType T = Importer.Import(ILE->getType());
6713   if (T.isNull())
6714     return nullptr;
6715 
6716   llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6717   if (ImportContainerChecked(ILE->inits(), Exprs))
6718     return nullptr;
6719 
6720   ASTContext &ToCtx = Importer.getToContext();
6721   InitListExpr *To = new (ToCtx) InitListExpr(
6722         ToCtx, Importer.Import(ILE->getLBraceLoc()),
6723         Exprs, Importer.Import(ILE->getLBraceLoc()));
6724   To->setType(T);
6725 
6726   if (ILE->hasArrayFiller()) {
6727     Expr *Filler = Importer.Import(ILE->getArrayFiller());
6728     if (!Filler)
6729       return nullptr;
6730     To->setArrayFiller(Filler);
6731   }
6732 
6733   if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6734     FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6735     if (!ToFD)
6736       return nullptr;
6737     To->setInitializedFieldInUnion(ToFD);
6738   }
6739 
6740   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6741     InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
6742           Importer.Import(SyntForm));
6743     if (!ToSyntForm)
6744       return nullptr;
6745     To->setSyntacticForm(ToSyntForm);
6746   }
6747 
6748   To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6749   To->setValueDependent(ILE->isValueDependent());
6750   To->setInstantiationDependent(ILE->isInstantiationDependent());
6751 
6752   return To;
6753 }
6754 
6755 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6756   QualType ToType = Importer.Import(E->getType());
6757   if (ToType.isNull())
6758     return nullptr;
6759 
6760   Expr *ToCommon = Importer.Import(E->getCommonExpr());
6761   if (!ToCommon && E->getCommonExpr())
6762     return nullptr;
6763 
6764   Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6765   if (!ToSubExpr && E->getSubExpr())
6766     return nullptr;
6767 
6768   return new (Importer.getToContext())
6769       ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6770 }
6771 
6772 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6773   QualType ToType = Importer.Import(E->getType());
6774   if (ToType.isNull())
6775     return nullptr;
6776   return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6777 }
6778 
6779 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
6780   FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
6781       Importer.Import(DIE->getField()));
6782   if (!ToField && DIE->getField())
6783     return nullptr;
6784 
6785   return CXXDefaultInitExpr::Create(
6786       Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6787 }
6788 
6789 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6790   QualType ToType = Importer.Import(E->getType());
6791   if (ToType.isNull() && !E->getType().isNull())
6792     return nullptr;
6793   ExprValueKind VK = E->getValueKind();
6794   CastKind CK = E->getCastKind();
6795   Expr *ToOp = Importer.Import(E->getSubExpr());
6796   if (!ToOp && E->getSubExpr())
6797     return nullptr;
6798   CXXCastPath BasePath;
6799   if (ImportCastPath(E, BasePath))
6800     return nullptr;
6801   TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6802   SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6803   SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6804   SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6805 
6806   if (isa<CXXStaticCastExpr>(E)) {
6807     return CXXStaticCastExpr::Create(
6808         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6809         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6810   } else if (isa<CXXDynamicCastExpr>(E)) {
6811     return CXXDynamicCastExpr::Create(
6812         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6813         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6814   } else if (isa<CXXReinterpretCastExpr>(E)) {
6815     return CXXReinterpretCastExpr::Create(
6816         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6817         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6818   } else {
6819     return nullptr;
6820   }
6821 }
6822 
6823 
6824 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6825     SubstNonTypeTemplateParmExpr *E) {
6826   QualType T = Importer.Import(E->getType());
6827   if (T.isNull())
6828     return nullptr;
6829 
6830   NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
6831         Importer.Import(E->getParameter()));
6832   if (!Param)
6833     return nullptr;
6834 
6835   Expr *Replacement = Importer.Import(E->getReplacement());
6836   if (!Replacement)
6837     return nullptr;
6838 
6839   return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6840         T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6841         Replacement);
6842 }
6843 
6844 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6845                          ASTContext &FromContext, FileManager &FromFileManager,
6846                          bool MinimalImport)
6847   : ToContext(ToContext), FromContext(FromContext),
6848     ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6849     Minimal(MinimalImport), LastDiagFromFrom(false)
6850 {
6851   ImportedDecls[FromContext.getTranslationUnitDecl()]
6852     = ToContext.getTranslationUnitDecl();
6853 }
6854 
6855 ASTImporter::~ASTImporter() { }
6856 
6857 QualType ASTImporter::Import(QualType FromT) {
6858   if (FromT.isNull())
6859     return QualType();
6860 
6861   const Type *fromTy = FromT.getTypePtr();
6862 
6863   // Check whether we've already imported this type.
6864   llvm::DenseMap<const Type *, const Type *>::iterator Pos
6865     = ImportedTypes.find(fromTy);
6866   if (Pos != ImportedTypes.end())
6867     return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6868 
6869   // Import the type
6870   ASTNodeImporter Importer(*this);
6871   QualType ToT = Importer.Visit(fromTy);
6872   if (ToT.isNull())
6873     return ToT;
6874 
6875   // Record the imported type.
6876   ImportedTypes[fromTy] = ToT.getTypePtr();
6877 
6878   return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6879 }
6880 
6881 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6882   if (!FromTSI)
6883     return FromTSI;
6884 
6885   // FIXME: For now we just create a "trivial" type source info based
6886   // on the type and a single location. Implement a real version of this.
6887   QualType T = Import(FromTSI->getType());
6888   if (T.isNull())
6889     return nullptr;
6890 
6891   return ToContext.getTrivialTypeSourceInfo(T,
6892            Import(FromTSI->getTypeLoc().getLocStart()));
6893 }
6894 
6895 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6896   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6897   if (Pos != ImportedDecls.end()) {
6898     Decl *ToD = Pos->second;
6899     ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6900     return ToD;
6901   } else {
6902     return nullptr;
6903   }
6904 }
6905 
6906 Decl *ASTImporter::Import(Decl *FromD) {
6907   if (!FromD)
6908     return nullptr;
6909 
6910   ASTNodeImporter Importer(*this);
6911 
6912   // Check whether we've already imported this declaration.
6913   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6914   if (Pos != ImportedDecls.end()) {
6915     Decl *ToD = Pos->second;
6916     Importer.ImportDefinitionIfNeeded(FromD, ToD);
6917     return ToD;
6918   }
6919 
6920   // Import the type
6921   Decl *ToD = Importer.Visit(FromD);
6922   if (!ToD)
6923     return nullptr;
6924 
6925   // Record the imported declaration.
6926   ImportedDecls[FromD] = ToD;
6927 
6928   if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6929     // Keep track of anonymous tags that have an associated typedef.
6930     if (FromTag->getTypedefNameForAnonDecl())
6931       AnonTagsWithPendingTypedefs.push_back(FromTag);
6932   } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6933     // When we've finished transforming a typedef, see whether it was the
6934     // typedef for an anonymous tag.
6935     for (SmallVectorImpl<TagDecl *>::iterator
6936                FromTag = AnonTagsWithPendingTypedefs.begin(),
6937             FromTagEnd = AnonTagsWithPendingTypedefs.end();
6938          FromTag != FromTagEnd; ++FromTag) {
6939       if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6940         if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6941           // We found the typedef for an anonymous tag; link them.
6942           ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6943           AnonTagsWithPendingTypedefs.erase(FromTag);
6944           break;
6945         }
6946       }
6947     }
6948   }
6949 
6950   return ToD;
6951 }
6952 
6953 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6954   if (!FromDC)
6955     return FromDC;
6956 
6957   DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6958   if (!ToDC)
6959     return nullptr;
6960 
6961   // When we're using a record/enum/Objective-C class/protocol as a context, we
6962   // need it to have a definition.
6963   if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6964     RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6965     if (ToRecord->isCompleteDefinition()) {
6966       // Do nothing.
6967     } else if (FromRecord->isCompleteDefinition()) {
6968       ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6969                                               ASTNodeImporter::IDK_Basic);
6970     } else {
6971       CompleteDecl(ToRecord);
6972     }
6973   } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
6974     EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
6975     if (ToEnum->isCompleteDefinition()) {
6976       // Do nothing.
6977     } else if (FromEnum->isCompleteDefinition()) {
6978       ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
6979                                               ASTNodeImporter::IDK_Basic);
6980     } else {
6981       CompleteDecl(ToEnum);
6982     }
6983   } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
6984     ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
6985     if (ToClass->getDefinition()) {
6986       // Do nothing.
6987     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
6988       ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
6989                                               ASTNodeImporter::IDK_Basic);
6990     } else {
6991       CompleteDecl(ToClass);
6992     }
6993   } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
6994     ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
6995     if (ToProto->getDefinition()) {
6996       // Do nothing.
6997     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
6998       ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
6999                                               ASTNodeImporter::IDK_Basic);
7000     } else {
7001       CompleteDecl(ToProto);
7002     }
7003   }
7004 
7005   return ToDC;
7006 }
7007 
7008 Expr *ASTImporter::Import(Expr *FromE) {
7009   if (!FromE)
7010     return nullptr;
7011 
7012   return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7013 }
7014 
7015 Stmt *ASTImporter::Import(Stmt *FromS) {
7016   if (!FromS)
7017     return nullptr;
7018 
7019   // Check whether we've already imported this declaration.
7020   llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7021   if (Pos != ImportedStmts.end())
7022     return Pos->second;
7023 
7024   // Import the type
7025   ASTNodeImporter Importer(*this);
7026   Stmt *ToS = Importer.Visit(FromS);
7027   if (!ToS)
7028     return nullptr;
7029 
7030   // Record the imported declaration.
7031   ImportedStmts[FromS] = ToS;
7032   return ToS;
7033 }
7034 
7035 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7036   if (!FromNNS)
7037     return nullptr;
7038 
7039   NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7040 
7041   switch (FromNNS->getKind()) {
7042   case NestedNameSpecifier::Identifier:
7043     if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7044       return NestedNameSpecifier::Create(ToContext, prefix, II);
7045     }
7046     return nullptr;
7047 
7048   case NestedNameSpecifier::Namespace:
7049     if (NamespaceDecl *NS =
7050           cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7051       return NestedNameSpecifier::Create(ToContext, prefix, NS);
7052     }
7053     return nullptr;
7054 
7055   case NestedNameSpecifier::NamespaceAlias:
7056     if (NamespaceAliasDecl *NSAD =
7057           cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7058       return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7059     }
7060     return nullptr;
7061 
7062   case NestedNameSpecifier::Global:
7063     return NestedNameSpecifier::GlobalSpecifier(ToContext);
7064 
7065   case NestedNameSpecifier::Super:
7066     if (CXXRecordDecl *RD =
7067             cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7068       return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7069     }
7070     return nullptr;
7071 
7072   case NestedNameSpecifier::TypeSpec:
7073   case NestedNameSpecifier::TypeSpecWithTemplate: {
7074       QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7075       if (!T.isNull()) {
7076         bool bTemplate = FromNNS->getKind() ==
7077                          NestedNameSpecifier::TypeSpecWithTemplate;
7078         return NestedNameSpecifier::Create(ToContext, prefix,
7079                                            bTemplate, T.getTypePtr());
7080       }
7081     }
7082       return nullptr;
7083   }
7084 
7085   llvm_unreachable("Invalid nested name specifier kind");
7086 }
7087 
7088 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
7089   // Copied from NestedNameSpecifier mostly.
7090   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7091   NestedNameSpecifierLoc NNS = FromNNS;
7092 
7093   // Push each of the nested-name-specifiers's onto a stack for
7094   // serialization in reverse order.
7095   while (NNS) {
7096     NestedNames.push_back(NNS);
7097     NNS = NNS.getPrefix();
7098   }
7099 
7100   NestedNameSpecifierLocBuilder Builder;
7101 
7102   while (!NestedNames.empty()) {
7103     NNS = NestedNames.pop_back_val();
7104     NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7105     if (!Spec)
7106       return NestedNameSpecifierLoc();
7107 
7108     NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7109     switch (Kind) {
7110     case NestedNameSpecifier::Identifier:
7111       Builder.Extend(getToContext(),
7112                      Spec->getAsIdentifier(),
7113                      Import(NNS.getLocalBeginLoc()),
7114                      Import(NNS.getLocalEndLoc()));
7115       break;
7116 
7117     case NestedNameSpecifier::Namespace:
7118       Builder.Extend(getToContext(),
7119                      Spec->getAsNamespace(),
7120                      Import(NNS.getLocalBeginLoc()),
7121                      Import(NNS.getLocalEndLoc()));
7122       break;
7123 
7124     case NestedNameSpecifier::NamespaceAlias:
7125       Builder.Extend(getToContext(),
7126                      Spec->getAsNamespaceAlias(),
7127                      Import(NNS.getLocalBeginLoc()),
7128                      Import(NNS.getLocalEndLoc()));
7129       break;
7130 
7131     case NestedNameSpecifier::TypeSpec:
7132     case NestedNameSpecifier::TypeSpecWithTemplate: {
7133       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7134             QualType(Spec->getAsType(), 0));
7135       Builder.Extend(getToContext(),
7136                      Import(NNS.getLocalBeginLoc()),
7137                      TSI->getTypeLoc(),
7138                      Import(NNS.getLocalEndLoc()));
7139       break;
7140     }
7141 
7142     case NestedNameSpecifier::Global:
7143       Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7144       break;
7145 
7146     case NestedNameSpecifier::Super: {
7147       SourceRange ToRange = Import(NNS.getSourceRange());
7148       Builder.MakeSuper(getToContext(),
7149                         Spec->getAsRecordDecl(),
7150                         ToRange.getBegin(),
7151                         ToRange.getEnd());
7152     }
7153   }
7154   }
7155 
7156   return Builder.getWithLocInContext(getToContext());
7157 }
7158 
7159 TemplateName ASTImporter::Import(TemplateName From) {
7160   switch (From.getKind()) {
7161   case TemplateName::Template:
7162     if (TemplateDecl *ToTemplate
7163                 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7164       return TemplateName(ToTemplate);
7165 
7166     return TemplateName();
7167 
7168   case TemplateName::OverloadedTemplate: {
7169     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7170     UnresolvedSet<2> ToTemplates;
7171     for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
7172                                              E = FromStorage->end();
7173          I != E; ++I) {
7174       if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
7175         ToTemplates.addDecl(To);
7176       else
7177         return TemplateName();
7178     }
7179     return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7180                                                ToTemplates.end());
7181   }
7182 
7183   case TemplateName::QualifiedTemplate: {
7184     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7185     NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7186     if (!Qualifier)
7187       return TemplateName();
7188 
7189     if (TemplateDecl *ToTemplate
7190         = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7191       return ToContext.getQualifiedTemplateName(Qualifier,
7192                                                 QTN->hasTemplateKeyword(),
7193                                                 ToTemplate);
7194 
7195     return TemplateName();
7196   }
7197 
7198   case TemplateName::DependentTemplate: {
7199     DependentTemplateName *DTN = From.getAsDependentTemplateName();
7200     NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7201     if (!Qualifier)
7202       return TemplateName();
7203 
7204     if (DTN->isIdentifier()) {
7205       return ToContext.getDependentTemplateName(Qualifier,
7206                                                 Import(DTN->getIdentifier()));
7207     }
7208 
7209     return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7210   }
7211 
7212   case TemplateName::SubstTemplateTemplateParm: {
7213     SubstTemplateTemplateParmStorage *subst
7214       = From.getAsSubstTemplateTemplateParm();
7215     TemplateTemplateParmDecl *param
7216       = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7217     if (!param)
7218       return TemplateName();
7219 
7220     TemplateName replacement = Import(subst->getReplacement());
7221     if (replacement.isNull()) return TemplateName();
7222 
7223     return ToContext.getSubstTemplateTemplateParm(param, replacement);
7224   }
7225 
7226   case TemplateName::SubstTemplateTemplateParmPack: {
7227     SubstTemplateTemplateParmPackStorage *SubstPack
7228       = From.getAsSubstTemplateTemplateParmPack();
7229     TemplateTemplateParmDecl *Param
7230       = cast_or_null<TemplateTemplateParmDecl>(
7231                                         Import(SubstPack->getParameterPack()));
7232     if (!Param)
7233       return TemplateName();
7234 
7235     ASTNodeImporter Importer(*this);
7236     TemplateArgument ArgPack
7237       = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7238     if (ArgPack.isNull())
7239       return TemplateName();
7240 
7241     return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7242   }
7243   }
7244 
7245   llvm_unreachable("Invalid template name kind");
7246 }
7247 
7248 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7249   if (FromLoc.isInvalid())
7250     return SourceLocation();
7251 
7252   SourceManager &FromSM = FromContext.getSourceManager();
7253 
7254   // For now, map everything down to its file location, so that we
7255   // don't have to import macro expansions.
7256   // FIXME: Import macro expansions!
7257   FromLoc = FromSM.getFileLoc(FromLoc);
7258   std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7259   SourceManager &ToSM = ToContext.getSourceManager();
7260   FileID ToFileID = Import(Decomposed.first);
7261   if (ToFileID.isInvalid())
7262     return SourceLocation();
7263   SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
7264                            .getLocWithOffset(Decomposed.second);
7265   return ret;
7266 }
7267 
7268 SourceRange ASTImporter::Import(SourceRange FromRange) {
7269   return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7270 }
7271 
7272 FileID ASTImporter::Import(FileID FromID) {
7273   llvm::DenseMap<FileID, FileID>::iterator Pos
7274     = ImportedFileIDs.find(FromID);
7275   if (Pos != ImportedFileIDs.end())
7276     return Pos->second;
7277 
7278   SourceManager &FromSM = FromContext.getSourceManager();
7279   SourceManager &ToSM = ToContext.getSourceManager();
7280   const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7281   assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
7282 
7283   // Include location of this file.
7284   SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7285 
7286   // Map the FileID for to the "to" source manager.
7287   FileID ToID;
7288   const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7289   if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7290     // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7291     // disk again
7292     // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7293     // than mmap the files several times.
7294     const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
7295     if (!Entry)
7296       return FileID();
7297     ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7298                              FromSLoc.getFile().getFileCharacteristic());
7299   } else {
7300     // FIXME: We want to re-use the existing MemoryBuffer!
7301     const llvm::MemoryBuffer *
7302         FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7303     std::unique_ptr<llvm::MemoryBuffer> ToBuf
7304       = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7305                                              FromBuf->getBufferIdentifier());
7306     ToID = ToSM.createFileID(std::move(ToBuf),
7307                              FromSLoc.getFile().getFileCharacteristic());
7308   }
7309 
7310 
7311   ImportedFileIDs[FromID] = ToID;
7312   return ToID;
7313 }
7314 
7315 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7316   Expr *ToExpr = Import(From->getInit());
7317   if (!ToExpr && From->getInit())
7318     return nullptr;
7319 
7320   if (From->isBaseInitializer()) {
7321     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7322     if (!ToTInfo && From->getTypeSourceInfo())
7323       return nullptr;
7324 
7325     return new (ToContext) CXXCtorInitializer(
7326         ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7327         ToExpr, Import(From->getRParenLoc()),
7328         From->isPackExpansion() ? Import(From->getEllipsisLoc())
7329                                 : SourceLocation());
7330   } else if (From->isMemberInitializer()) {
7331     FieldDecl *ToField =
7332         llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
7333     if (!ToField && From->getMember())
7334       return nullptr;
7335 
7336     return new (ToContext) CXXCtorInitializer(
7337         ToContext, ToField, Import(From->getMemberLocation()),
7338         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7339   } else if (From->isIndirectMemberInitializer()) {
7340     IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
7341         Import(From->getIndirectMember()));
7342     if (!ToIField && From->getIndirectMember())
7343       return nullptr;
7344 
7345     return new (ToContext) CXXCtorInitializer(
7346         ToContext, ToIField, Import(From->getMemberLocation()),
7347         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7348   } else if (From->isDelegatingInitializer()) {
7349     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7350     if (!ToTInfo && From->getTypeSourceInfo())
7351       return nullptr;
7352 
7353     return new (ToContext)
7354         CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7355                            ToExpr, Import(From->getRParenLoc()));
7356   } else {
7357     return nullptr;
7358   }
7359 }
7360 
7361 
7362 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7363   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7364   if (Pos != ImportedCXXBaseSpecifiers.end())
7365     return Pos->second;
7366 
7367   CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7368         Import(BaseSpec->getSourceRange()),
7369         BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7370         BaseSpec->getAccessSpecifierAsWritten(),
7371         Import(BaseSpec->getTypeSourceInfo()),
7372         Import(BaseSpec->getEllipsisLoc()));
7373   ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7374   return Imported;
7375 }
7376 
7377 void ASTImporter::ImportDefinition(Decl *From) {
7378   Decl *To = Import(From);
7379   if (!To)
7380     return;
7381 
7382   if (DeclContext *FromDC = cast<DeclContext>(From)) {
7383     ASTNodeImporter Importer(*this);
7384 
7385     if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
7386       if (!ToRecord->getDefinition()) {
7387         Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7388                                   ASTNodeImporter::IDK_Everything);
7389         return;
7390       }
7391     }
7392 
7393     if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
7394       if (!ToEnum->getDefinition()) {
7395         Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7396                                   ASTNodeImporter::IDK_Everything);
7397         return;
7398       }
7399     }
7400 
7401     if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7402       if (!ToIFace->getDefinition()) {
7403         Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7404                                   ASTNodeImporter::IDK_Everything);
7405         return;
7406       }
7407     }
7408 
7409     if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7410       if (!ToProto->getDefinition()) {
7411         Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7412                                   ASTNodeImporter::IDK_Everything);
7413         return;
7414       }
7415     }
7416 
7417     Importer.ImportDeclContext(FromDC, true);
7418   }
7419 }
7420 
7421 DeclarationName ASTImporter::Import(DeclarationName FromName) {
7422   if (!FromName)
7423     return DeclarationName();
7424 
7425   switch (FromName.getNameKind()) {
7426   case DeclarationName::Identifier:
7427     return Import(FromName.getAsIdentifierInfo());
7428 
7429   case DeclarationName::ObjCZeroArgSelector:
7430   case DeclarationName::ObjCOneArgSelector:
7431   case DeclarationName::ObjCMultiArgSelector:
7432     return Import(FromName.getObjCSelector());
7433 
7434   case DeclarationName::CXXConstructorName: {
7435     QualType T = Import(FromName.getCXXNameType());
7436     if (T.isNull())
7437       return DeclarationName();
7438 
7439     return ToContext.DeclarationNames.getCXXConstructorName(
7440                                                ToContext.getCanonicalType(T));
7441   }
7442 
7443   case DeclarationName::CXXDestructorName: {
7444     QualType T = Import(FromName.getCXXNameType());
7445     if (T.isNull())
7446       return DeclarationName();
7447 
7448     return ToContext.DeclarationNames.getCXXDestructorName(
7449                                                ToContext.getCanonicalType(T));
7450   }
7451 
7452   case DeclarationName::CXXDeductionGuideName: {
7453     TemplateDecl *Template = cast_or_null<TemplateDecl>(
7454         Import(FromName.getCXXDeductionGuideTemplate()));
7455     if (!Template)
7456       return DeclarationName();
7457     return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7458   }
7459 
7460   case DeclarationName::CXXConversionFunctionName: {
7461     QualType T = Import(FromName.getCXXNameType());
7462     if (T.isNull())
7463       return DeclarationName();
7464 
7465     return ToContext.DeclarationNames.getCXXConversionFunctionName(
7466                                                ToContext.getCanonicalType(T));
7467   }
7468 
7469   case DeclarationName::CXXOperatorName:
7470     return ToContext.DeclarationNames.getCXXOperatorName(
7471                                           FromName.getCXXOverloadedOperator());
7472 
7473   case DeclarationName::CXXLiteralOperatorName:
7474     return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7475                                    Import(FromName.getCXXLiteralIdentifier()));
7476 
7477   case DeclarationName::CXXUsingDirective:
7478     // FIXME: STATICS!
7479     return DeclarationName::getUsingDirectiveName();
7480   }
7481 
7482   llvm_unreachable("Invalid DeclarationName Kind!");
7483 }
7484 
7485 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
7486   if (!FromId)
7487     return nullptr;
7488 
7489   IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7490 
7491   if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7492     ToId->setBuiltinID(FromId->getBuiltinID());
7493 
7494   return ToId;
7495 }
7496 
7497 Selector ASTImporter::Import(Selector FromSel) {
7498   if (FromSel.isNull())
7499     return Selector();
7500 
7501   SmallVector<IdentifierInfo *, 4> Idents;
7502   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7503   for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7504     Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7505   return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7506 }
7507 
7508 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7509                                                 DeclContext *DC,
7510                                                 unsigned IDNS,
7511                                                 NamedDecl **Decls,
7512                                                 unsigned NumDecls) {
7513   return Name;
7514 }
7515 
7516 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
7517   if (LastDiagFromFrom)
7518     ToContext.getDiagnostics().notePriorDiagnosticFrom(
7519       FromContext.getDiagnostics());
7520   LastDiagFromFrom = false;
7521   return ToContext.getDiagnostics().Report(Loc, DiagID);
7522 }
7523 
7524 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
7525   if (!LastDiagFromFrom)
7526     FromContext.getDiagnostics().notePriorDiagnosticFrom(
7527       ToContext.getDiagnostics());
7528   LastDiagFromFrom = true;
7529   return FromContext.getDiagnostics().Report(Loc, DiagID);
7530 }
7531 
7532 void ASTImporter::CompleteDecl (Decl *D) {
7533   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7534     if (!ID->getDefinition())
7535       ID->startDefinition();
7536   }
7537   else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7538     if (!PD->getDefinition())
7539       PD->startDefinition();
7540   }
7541   else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
7542     if (!TD->getDefinition() && !TD->isBeingDefined()) {
7543       TD->startDefinition();
7544       TD->setCompleteDefinition(true);
7545     }
7546   }
7547   else {
7548     assert (0 && "CompleteDecl called on a Decl that can't be completed");
7549   }
7550 }
7551 
7552 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
7553   if (From->hasAttrs()) {
7554     for (Attr *FromAttr : From->getAttrs())
7555       To->addAttr(FromAttr->clone(To->getASTContext()));
7556   }
7557   if (From->isUsed()) {
7558     To->setIsUsed();
7559   }
7560   if (From->isImplicit()) {
7561     To->setImplicit();
7562   }
7563   ImportedDecls[From] = To;
7564   return To;
7565 }
7566 
7567 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7568                                            bool Complain) {
7569   llvm::DenseMap<const Type *, const Type *>::iterator Pos
7570    = ImportedTypes.find(From.getTypePtr());
7571   if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7572     return true;
7573 
7574   StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7575                                    false, Complain);
7576   return Ctx.IsStructurallyEquivalent(From, To);
7577 }
7578