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.ImplicitCopyConstructorCanHaveConstParamForVBase
2367       = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
2368     ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
2369       = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
2370     ToData.ImplicitCopyAssignmentHasConstParam
2371       = FromData.ImplicitCopyAssignmentHasConstParam;
2372     ToData.HasDeclaredCopyConstructorWithConstParam
2373       = FromData.HasDeclaredCopyConstructorWithConstParam;
2374     ToData.HasDeclaredCopyAssignmentWithConstParam
2375       = FromData.HasDeclaredCopyAssignmentWithConstParam;
2376     ToData.IsLambda = FromData.IsLambda;
2377 
2378     SmallVector<CXXBaseSpecifier *, 4> Bases;
2379     for (const auto &Base1 : FromCXX->bases()) {
2380       QualType T = Importer.Import(Base1.getType());
2381       if (T.isNull())
2382         return true;
2383 
2384       SourceLocation EllipsisLoc;
2385       if (Base1.isPackExpansion())
2386         EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2387 
2388       // Ensure that we have a definition for the base.
2389       ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2390 
2391       Bases.push_back(
2392                     new (Importer.getToContext())
2393                       CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2394                                        Base1.isVirtual(),
2395                                        Base1.isBaseOfClass(),
2396                                        Base1.getAccessSpecifierAsWritten(),
2397                                    Importer.Import(Base1.getTypeSourceInfo()),
2398                                        EllipsisLoc));
2399     }
2400     if (!Bases.empty())
2401       ToCXX->setBases(Bases.data(), Bases.size());
2402   }
2403 
2404   if (shouldForceImportDeclContext(Kind))
2405     ImportDeclContext(From, /*ForceImport=*/true);
2406 
2407   To->completeDefinition();
2408   return false;
2409 }
2410 
2411 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2412                                        ImportDefinitionKind Kind) {
2413   if (To->getAnyInitializer())
2414     return false;
2415 
2416   // FIXME: Can we really import any initializer? Alternatively, we could force
2417   // ourselves to import every declaration of a variable and then only use
2418   // getInit() here.
2419   To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2420 
2421   // FIXME: Other bits to merge?
2422 
2423   return false;
2424 }
2425 
2426 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2427                                        ImportDefinitionKind Kind) {
2428   if (To->getDefinition() || To->isBeingDefined()) {
2429     if (Kind == IDK_Everything)
2430       ImportDeclContext(From, /*ForceImport=*/true);
2431     return false;
2432   }
2433 
2434   To->startDefinition();
2435 
2436   QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2437   if (T.isNull())
2438     return true;
2439 
2440   QualType ToPromotionType = Importer.Import(From->getPromotionType());
2441   if (ToPromotionType.isNull())
2442     return true;
2443 
2444   if (shouldForceImportDeclContext(Kind))
2445     ImportDeclContext(From, /*ForceImport=*/true);
2446 
2447   // FIXME: we might need to merge the number of positive or negative bits
2448   // if the enumerator lists don't match.
2449   To->completeDefinition(T, ToPromotionType,
2450                          From->getNumPositiveBits(),
2451                          From->getNumNegativeBits());
2452   return false;
2453 }
2454 
2455 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2456                                                 TemplateParameterList *Params) {
2457   SmallVector<NamedDecl *, 4> ToParams(Params->size());
2458   if (ImportContainerChecked(*Params, ToParams))
2459     return nullptr;
2460 
2461   Expr *ToRequiresClause;
2462   if (Expr *const R = Params->getRequiresClause()) {
2463     ToRequiresClause = Importer.Import(R);
2464     if (!ToRequiresClause)
2465       return nullptr;
2466   } else {
2467     ToRequiresClause = nullptr;
2468   }
2469 
2470   return TemplateParameterList::Create(Importer.getToContext(),
2471                                        Importer.Import(Params->getTemplateLoc()),
2472                                        Importer.Import(Params->getLAngleLoc()),
2473                                        ToParams,
2474                                        Importer.Import(Params->getRAngleLoc()),
2475                                        ToRequiresClause);
2476 }
2477 
2478 TemplateArgument
2479 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2480   switch (From.getKind()) {
2481   case TemplateArgument::Null:
2482     return TemplateArgument();
2483 
2484   case TemplateArgument::Type: {
2485     QualType ToType = Importer.Import(From.getAsType());
2486     if (ToType.isNull())
2487       return TemplateArgument();
2488     return TemplateArgument(ToType);
2489   }
2490 
2491   case TemplateArgument::Integral: {
2492     QualType ToType = Importer.Import(From.getIntegralType());
2493     if (ToType.isNull())
2494       return TemplateArgument();
2495     return TemplateArgument(From, ToType);
2496   }
2497 
2498   case TemplateArgument::Declaration: {
2499     ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2500     QualType ToType = Importer.Import(From.getParamTypeForDecl());
2501     if (!To || ToType.isNull())
2502       return TemplateArgument();
2503     return TemplateArgument(To, ToType);
2504   }
2505 
2506   case TemplateArgument::NullPtr: {
2507     QualType ToType = Importer.Import(From.getNullPtrType());
2508     if (ToType.isNull())
2509       return TemplateArgument();
2510     return TemplateArgument(ToType, /*isNullPtr*/true);
2511   }
2512 
2513   case TemplateArgument::Template: {
2514     TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2515     if (ToTemplate.isNull())
2516       return TemplateArgument();
2517 
2518     return TemplateArgument(ToTemplate);
2519   }
2520 
2521   case TemplateArgument::TemplateExpansion: {
2522     TemplateName ToTemplate
2523       = Importer.Import(From.getAsTemplateOrTemplatePattern());
2524     if (ToTemplate.isNull())
2525       return TemplateArgument();
2526 
2527     return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2528   }
2529 
2530   case TemplateArgument::Expression:
2531     if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2532       return TemplateArgument(ToExpr);
2533     return TemplateArgument();
2534 
2535   case TemplateArgument::Pack: {
2536     SmallVector<TemplateArgument, 2> ToPack;
2537     ToPack.reserve(From.pack_size());
2538     if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2539       return TemplateArgument();
2540 
2541     return TemplateArgument(
2542         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2543   }
2544   }
2545 
2546   llvm_unreachable("Invalid template argument kind");
2547 }
2548 
2549 TemplateArgumentLoc ASTNodeImporter::ImportTemplateArgumentLoc(
2550     const TemplateArgumentLoc &TALoc, bool &Error) {
2551   Error = false;
2552   TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
2553   TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
2554   TemplateArgumentLocInfo ToInfo;
2555   if (Arg.getKind() == TemplateArgument::Expression) {
2556     Expr *E = Importer.Import(FromInfo.getAsExpr());
2557     ToInfo = TemplateArgumentLocInfo(E);
2558     if (!E)
2559       Error = true;
2560   } else if (Arg.getKind() == TemplateArgument::Type) {
2561     if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
2562       ToInfo = TemplateArgumentLocInfo(TSI);
2563     else
2564       Error = true;
2565   } else {
2566     ToInfo = TemplateArgumentLocInfo(
2567           Importer.Import(FromInfo.getTemplateQualifierLoc()),
2568           Importer.Import(FromInfo.getTemplateNameLoc()),
2569           Importer.Import(FromInfo.getTemplateEllipsisLoc()));
2570   }
2571   return TemplateArgumentLoc(Arg, ToInfo);
2572 }
2573 
2574 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2575                                               unsigned NumFromArgs,
2576                               SmallVectorImpl<TemplateArgument> &ToArgs) {
2577   for (unsigned I = 0; I != NumFromArgs; ++I) {
2578     TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2579     if (To.isNull() && !FromArgs[I].isNull())
2580       return true;
2581 
2582     ToArgs.push_back(To);
2583   }
2584 
2585   return false;
2586 }
2587 
2588 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2589                                         RecordDecl *ToRecord, bool Complain) {
2590   // Eliminate a potential failure point where we attempt to re-import
2591   // something we're trying to import while completing ToRecord.
2592   Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2593   if (ToOrigin) {
2594     RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2595     if (ToOriginRecord)
2596       ToRecord = ToOriginRecord;
2597   }
2598 
2599   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2600                                    ToRecord->getASTContext(),
2601                                    Importer.getNonEquivalentDecls(),
2602                                    false, Complain);
2603   return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2604 }
2605 
2606 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2607                                         bool Complain) {
2608   StructuralEquivalenceContext Ctx(
2609       Importer.getFromContext(), Importer.getToContext(),
2610       Importer.getNonEquivalentDecls(), false, Complain);
2611   return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2612 }
2613 
2614 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2615   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2616                                    Importer.getToContext(),
2617                                    Importer.getNonEquivalentDecls());
2618   return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2619 }
2620 
2621 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2622                                         EnumConstantDecl *ToEC)
2623 {
2624   const llvm::APSInt &FromVal = FromEC->getInitVal();
2625   const llvm::APSInt &ToVal = ToEC->getInitVal();
2626 
2627   return FromVal.isSigned() == ToVal.isSigned() &&
2628          FromVal.getBitWidth() == ToVal.getBitWidth() &&
2629          FromVal == ToVal;
2630 }
2631 
2632 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2633                                         ClassTemplateDecl *To) {
2634   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2635                                    Importer.getToContext(),
2636                                    Importer.getNonEquivalentDecls());
2637   return Ctx.IsStructurallyEquivalent(From, To);
2638 }
2639 
2640 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2641                                         VarTemplateDecl *To) {
2642   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2643                                    Importer.getToContext(),
2644                                    Importer.getNonEquivalentDecls());
2645   return Ctx.IsStructurallyEquivalent(From, To);
2646 }
2647 
2648 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2649   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2650     << D->getDeclKindName();
2651   return nullptr;
2652 }
2653 
2654 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2655   TranslationUnitDecl *ToD =
2656     Importer.getToContext().getTranslationUnitDecl();
2657 
2658   Importer.Imported(D, ToD);
2659 
2660   return ToD;
2661 }
2662 
2663 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2664 
2665   SourceLocation Loc = Importer.Import(D->getLocation());
2666   SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2667 
2668   // Import the context of this declaration.
2669   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2670   if (!DC)
2671     return nullptr;
2672 
2673   AccessSpecDecl *accessSpecDecl
2674     = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2675                              DC, Loc, ColonLoc);
2676 
2677   if (!accessSpecDecl)
2678     return nullptr;
2679 
2680   // Lexical DeclContext and Semantic DeclContext
2681   // is always the same for the accessSpec.
2682   accessSpecDecl->setLexicalDeclContext(DC);
2683   DC->addDeclInternal(accessSpecDecl);
2684 
2685   return accessSpecDecl;
2686 }
2687 
2688 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2689   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2690   if (!DC)
2691     return nullptr;
2692 
2693   DeclContext *LexicalDC = DC;
2694 
2695   // Import the location of this declaration.
2696   SourceLocation Loc = Importer.Import(D->getLocation());
2697 
2698   Expr *AssertExpr = Importer.Import(D->getAssertExpr());
2699   if (!AssertExpr)
2700     return nullptr;
2701 
2702   StringLiteral *FromMsg = D->getMessage();
2703   StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
2704   if (!ToMsg && FromMsg)
2705     return nullptr;
2706 
2707   StaticAssertDecl *ToD = StaticAssertDecl::Create(
2708         Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
2709         Importer.Import(D->getRParenLoc()), D->isFailed());
2710 
2711   ToD->setLexicalDeclContext(LexicalDC);
2712   LexicalDC->addDeclInternal(ToD);
2713   Importer.Imported(D, ToD);
2714   return ToD;
2715 }
2716 
2717 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2718   // Import the major distinguishing characteristics of this namespace.
2719   DeclContext *DC, *LexicalDC;
2720   DeclarationName Name;
2721   SourceLocation Loc;
2722   NamedDecl *ToD;
2723   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2724     return nullptr;
2725   if (ToD)
2726     return ToD;
2727 
2728   NamespaceDecl *MergeWithNamespace = nullptr;
2729   if (!Name) {
2730     // This is an anonymous namespace. Adopt an existing anonymous
2731     // namespace if we can.
2732     // FIXME: Not testable.
2733     if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2734       MergeWithNamespace = TU->getAnonymousNamespace();
2735     else
2736       MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2737   } else {
2738     SmallVector<NamedDecl *, 4> ConflictingDecls;
2739     SmallVector<NamedDecl *, 2> FoundDecls;
2740     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2741     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2742       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2743         continue;
2744 
2745       if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2746         MergeWithNamespace = FoundNS;
2747         ConflictingDecls.clear();
2748         break;
2749       }
2750 
2751       ConflictingDecls.push_back(FoundDecls[I]);
2752     }
2753 
2754     if (!ConflictingDecls.empty()) {
2755       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2756                                          ConflictingDecls.data(),
2757                                          ConflictingDecls.size());
2758     }
2759   }
2760 
2761   // Create the "to" namespace, if needed.
2762   NamespaceDecl *ToNamespace = MergeWithNamespace;
2763   if (!ToNamespace) {
2764     ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2765                                         D->isInline(),
2766                                         Importer.Import(D->getLocStart()),
2767                                         Loc, Name.getAsIdentifierInfo(),
2768                                         /*PrevDecl=*/nullptr);
2769     ToNamespace->setLexicalDeclContext(LexicalDC);
2770     LexicalDC->addDeclInternal(ToNamespace);
2771 
2772     // If this is an anonymous namespace, register it as the anonymous
2773     // namespace within its context.
2774     if (!Name) {
2775       if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2776         TU->setAnonymousNamespace(ToNamespace);
2777       else
2778         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2779     }
2780   }
2781   Importer.Imported(D, ToNamespace);
2782 
2783   ImportDeclContext(D);
2784 
2785   return ToNamespace;
2786 }
2787 
2788 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2789   // Import the major distinguishing characteristics of this typedef.
2790   DeclContext *DC, *LexicalDC;
2791   DeclarationName Name;
2792   SourceLocation Loc;
2793   NamedDecl *ToD;
2794   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2795     return nullptr;
2796   if (ToD)
2797     return ToD;
2798 
2799   // If this typedef is not in block scope, determine whether we've
2800   // seen a typedef with the same name (that we can merge with) or any
2801   // other entity by that name (which name lookup could conflict with).
2802   if (!DC->isFunctionOrMethod()) {
2803     SmallVector<NamedDecl *, 4> ConflictingDecls;
2804     unsigned IDNS = Decl::IDNS_Ordinary;
2805     SmallVector<NamedDecl *, 2> FoundDecls;
2806     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2807     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2808       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2809         continue;
2810       if (TypedefNameDecl *FoundTypedef =
2811             dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2812         if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2813                                             FoundTypedef->getUnderlyingType()))
2814           return Importer.Imported(D, FoundTypedef);
2815       }
2816 
2817       ConflictingDecls.push_back(FoundDecls[I]);
2818     }
2819 
2820     if (!ConflictingDecls.empty()) {
2821       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2822                                          ConflictingDecls.data(),
2823                                          ConflictingDecls.size());
2824       if (!Name)
2825         return nullptr;
2826     }
2827   }
2828 
2829   // Import the underlying type of this typedef;
2830   QualType T = Importer.Import(D->getUnderlyingType());
2831   if (T.isNull())
2832     return nullptr;
2833 
2834   // Create the new typedef node.
2835   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2836   SourceLocation StartL = Importer.Import(D->getLocStart());
2837   TypedefNameDecl *ToTypedef;
2838   if (IsAlias)
2839     ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2840                                       StartL, Loc,
2841                                       Name.getAsIdentifierInfo(),
2842                                       TInfo);
2843   else
2844     ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2845                                     StartL, Loc,
2846                                     Name.getAsIdentifierInfo(),
2847                                     TInfo);
2848 
2849   ToTypedef->setAccess(D->getAccess());
2850   ToTypedef->setLexicalDeclContext(LexicalDC);
2851   Importer.Imported(D, ToTypedef);
2852   LexicalDC->addDeclInternal(ToTypedef);
2853 
2854   return ToTypedef;
2855 }
2856 
2857 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2858   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2859 }
2860 
2861 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2862   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2863 }
2864 
2865 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2866   // Import the major distinguishing characteristics of this label.
2867   DeclContext *DC, *LexicalDC;
2868   DeclarationName Name;
2869   SourceLocation Loc;
2870   NamedDecl *ToD;
2871   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2872     return nullptr;
2873   if (ToD)
2874     return ToD;
2875 
2876   assert(LexicalDC->isFunctionOrMethod());
2877 
2878   LabelDecl *ToLabel = D->isGnuLocal()
2879       ? LabelDecl::Create(Importer.getToContext(),
2880                           DC, Importer.Import(D->getLocation()),
2881                           Name.getAsIdentifierInfo(),
2882                           Importer.Import(D->getLocStart()))
2883       : LabelDecl::Create(Importer.getToContext(),
2884                           DC, Importer.Import(D->getLocation()),
2885                           Name.getAsIdentifierInfo());
2886   Importer.Imported(D, ToLabel);
2887 
2888   LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2889   if (!Label)
2890     return nullptr;
2891 
2892   ToLabel->setStmt(Label);
2893   ToLabel->setLexicalDeclContext(LexicalDC);
2894   LexicalDC->addDeclInternal(ToLabel);
2895   return ToLabel;
2896 }
2897 
2898 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2899   // Import the major distinguishing characteristics of this enum.
2900   DeclContext *DC, *LexicalDC;
2901   DeclarationName Name;
2902   SourceLocation Loc;
2903   NamedDecl *ToD;
2904   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2905     return nullptr;
2906   if (ToD)
2907     return ToD;
2908 
2909   // Figure out what enum name we're looking for.
2910   unsigned IDNS = Decl::IDNS_Tag;
2911   DeclarationName SearchName = Name;
2912   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2913     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2914     IDNS = Decl::IDNS_Ordinary;
2915   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2916     IDNS |= Decl::IDNS_Ordinary;
2917 
2918   // We may already have an enum of the same name; try to find and match it.
2919   if (!DC->isFunctionOrMethod() && SearchName) {
2920     SmallVector<NamedDecl *, 4> ConflictingDecls;
2921     SmallVector<NamedDecl *, 2> FoundDecls;
2922     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2923     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2924       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2925         continue;
2926 
2927       Decl *Found = FoundDecls[I];
2928       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2929         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2930           Found = Tag->getDecl();
2931       }
2932 
2933       if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2934         if (IsStructuralMatch(D, FoundEnum))
2935           return Importer.Imported(D, FoundEnum);
2936       }
2937 
2938       ConflictingDecls.push_back(FoundDecls[I]);
2939     }
2940 
2941     if (!ConflictingDecls.empty()) {
2942       Name = Importer.HandleNameConflict(Name, DC, IDNS,
2943                                          ConflictingDecls.data(),
2944                                          ConflictingDecls.size());
2945     }
2946   }
2947 
2948   // Create the enum declaration.
2949   EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2950                                   Importer.Import(D->getLocStart()),
2951                                   Loc, Name.getAsIdentifierInfo(), nullptr,
2952                                   D->isScoped(), D->isScopedUsingClassTag(),
2953                                   D->isFixed());
2954   // Import the qualifier, if any.
2955   D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2956   D2->setAccess(D->getAccess());
2957   D2->setLexicalDeclContext(LexicalDC);
2958   Importer.Imported(D, D2);
2959   LexicalDC->addDeclInternal(D2);
2960 
2961   // Import the integer type.
2962   QualType ToIntegerType = Importer.Import(D->getIntegerType());
2963   if (ToIntegerType.isNull())
2964     return nullptr;
2965   D2->setIntegerType(ToIntegerType);
2966 
2967   // Import the definition
2968   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2969     return nullptr;
2970 
2971   return D2;
2972 }
2973 
2974 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2975   // If this record has a definition in the translation unit we're coming from,
2976   // but this particular declaration is not that definition, import the
2977   // definition and map to that.
2978   TagDecl *Definition = D->getDefinition();
2979   if (Definition && Definition != D) {
2980     Decl *ImportedDef = Importer.Import(Definition);
2981     if (!ImportedDef)
2982       return nullptr;
2983 
2984     return Importer.Imported(D, ImportedDef);
2985   }
2986 
2987   // Import the major distinguishing characteristics of this record.
2988   DeclContext *DC, *LexicalDC;
2989   DeclarationName Name;
2990   SourceLocation Loc;
2991   NamedDecl *ToD;
2992   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2993     return nullptr;
2994   if (ToD)
2995     return ToD;
2996 
2997   // Figure out what structure name we're looking for.
2998   unsigned IDNS = Decl::IDNS_Tag;
2999   DeclarationName SearchName = Name;
3000   if (!SearchName && D->getTypedefNameForAnonDecl()) {
3001     SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
3002     IDNS = Decl::IDNS_Ordinary;
3003   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3004     IDNS |= Decl::IDNS_Ordinary;
3005 
3006   // We may already have a record of the same name; try to find and match it.
3007   RecordDecl *AdoptDecl = nullptr;
3008   if (!DC->isFunctionOrMethod()) {
3009     SmallVector<NamedDecl *, 4> ConflictingDecls;
3010     SmallVector<NamedDecl *, 2> FoundDecls;
3011     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3012     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3013       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3014         continue;
3015 
3016       Decl *Found = FoundDecls[I];
3017       if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
3018         if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3019           Found = Tag->getDecl();
3020       }
3021 
3022       if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
3023         if (D->isAnonymousStructOrUnion() &&
3024             FoundRecord->isAnonymousStructOrUnion()) {
3025           // If both anonymous structs/unions are in a record context, make sure
3026           // they occur in the same location in the context records.
3027           if (Optional<unsigned> Index1
3028               = findUntaggedStructOrUnionIndex(D)) {
3029             if (Optional<unsigned> Index2 =
3030                     findUntaggedStructOrUnionIndex(FoundRecord)) {
3031               if (*Index1 != *Index2)
3032                 continue;
3033             }
3034           }
3035         }
3036 
3037         if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
3038           if ((SearchName && !D->isCompleteDefinition())
3039               || (D->isCompleteDefinition() &&
3040                   D->isAnonymousStructOrUnion()
3041                     == FoundDef->isAnonymousStructOrUnion() &&
3042                   IsStructuralMatch(D, FoundDef))) {
3043             // The record types structurally match, or the "from" translation
3044             // unit only had a forward declaration anyway; call it the same
3045             // function.
3046             // FIXME: For C++, we should also merge methods here.
3047             return Importer.Imported(D, FoundDef);
3048           }
3049         } else if (!D->isCompleteDefinition()) {
3050           // We have a forward declaration of this type, so adopt that forward
3051           // declaration rather than building a new one.
3052 
3053           // If one or both can be completed from external storage then try one
3054           // last time to complete and compare them before doing this.
3055 
3056           if (FoundRecord->hasExternalLexicalStorage() &&
3057               !FoundRecord->isCompleteDefinition())
3058             FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
3059           if (D->hasExternalLexicalStorage())
3060             D->getASTContext().getExternalSource()->CompleteType(D);
3061 
3062           if (FoundRecord->isCompleteDefinition() &&
3063               D->isCompleteDefinition() &&
3064               !IsStructuralMatch(D, FoundRecord))
3065             continue;
3066 
3067           AdoptDecl = FoundRecord;
3068           continue;
3069         } else if (!SearchName) {
3070           continue;
3071         }
3072       }
3073 
3074       ConflictingDecls.push_back(FoundDecls[I]);
3075     }
3076 
3077     if (!ConflictingDecls.empty() && SearchName) {
3078       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3079                                          ConflictingDecls.data(),
3080                                          ConflictingDecls.size());
3081     }
3082   }
3083 
3084   // Create the record declaration.
3085   RecordDecl *D2 = AdoptDecl;
3086   SourceLocation StartLoc = Importer.Import(D->getLocStart());
3087   if (!D2) {
3088     CXXRecordDecl *D2CXX = nullptr;
3089     if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
3090       if (DCXX->isLambda()) {
3091         TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
3092         D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
3093                                             DC, TInfo, Loc,
3094                                             DCXX->isDependentLambda(),
3095                                             DCXX->isGenericLambda(),
3096                                             DCXX->getLambdaCaptureDefault());
3097         Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
3098         if (DCXX->getLambdaContextDecl() && !CDecl)
3099           return nullptr;
3100         D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
3101       } else if (DCXX->isInjectedClassName()) {
3102         // We have to be careful to do a similar dance to the one in
3103         // Sema::ActOnStartCXXMemberDeclarations
3104         CXXRecordDecl *const PrevDecl = nullptr;
3105         const bool DelayTypeCreation = true;
3106         D2CXX = CXXRecordDecl::Create(
3107             Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
3108             Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
3109         Importer.getToContext().getTypeDeclType(
3110             D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
3111       } else {
3112         D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
3113                                       D->getTagKind(),
3114                                       DC, StartLoc, Loc,
3115                                       Name.getAsIdentifierInfo());
3116       }
3117       D2 = D2CXX;
3118       D2->setAccess(D->getAccess());
3119     } else {
3120       D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
3121                               DC, StartLoc, Loc, Name.getAsIdentifierInfo());
3122     }
3123 
3124     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3125     D2->setLexicalDeclContext(LexicalDC);
3126     LexicalDC->addDeclInternal(D2);
3127     if (D->isAnonymousStructOrUnion())
3128       D2->setAnonymousStructOrUnion(true);
3129   }
3130 
3131   Importer.Imported(D, D2);
3132 
3133   if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
3134     return nullptr;
3135 
3136   return D2;
3137 }
3138 
3139 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3140   // Import the major distinguishing characteristics of this enumerator.
3141   DeclContext *DC, *LexicalDC;
3142   DeclarationName Name;
3143   SourceLocation Loc;
3144   NamedDecl *ToD;
3145   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3146     return nullptr;
3147   if (ToD)
3148     return ToD;
3149 
3150   QualType T = Importer.Import(D->getType());
3151   if (T.isNull())
3152     return nullptr;
3153 
3154   // Determine whether there are any other declarations with the same name and
3155   // in the same context.
3156   if (!LexicalDC->isFunctionOrMethod()) {
3157     SmallVector<NamedDecl *, 4> ConflictingDecls;
3158     unsigned IDNS = Decl::IDNS_Ordinary;
3159     SmallVector<NamedDecl *, 2> FoundDecls;
3160     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3161     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3162       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3163         continue;
3164 
3165       if (EnumConstantDecl *FoundEnumConstant
3166             = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
3167         if (IsStructuralMatch(D, FoundEnumConstant))
3168           return Importer.Imported(D, FoundEnumConstant);
3169       }
3170 
3171       ConflictingDecls.push_back(FoundDecls[I]);
3172     }
3173 
3174     if (!ConflictingDecls.empty()) {
3175       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3176                                          ConflictingDecls.data(),
3177                                          ConflictingDecls.size());
3178       if (!Name)
3179         return nullptr;
3180     }
3181   }
3182 
3183   Expr *Init = Importer.Import(D->getInitExpr());
3184   if (D->getInitExpr() && !Init)
3185     return nullptr;
3186 
3187   EnumConstantDecl *ToEnumerator
3188     = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3189                                Name.getAsIdentifierInfo(), T,
3190                                Init, D->getInitVal());
3191   ToEnumerator->setAccess(D->getAccess());
3192   ToEnumerator->setLexicalDeclContext(LexicalDC);
3193   Importer.Imported(D, ToEnumerator);
3194   LexicalDC->addDeclInternal(ToEnumerator);
3195   return ToEnumerator;
3196 }
3197 
3198 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3199   // Import the major distinguishing characteristics of this function.
3200   DeclContext *DC, *LexicalDC;
3201   DeclarationName Name;
3202   SourceLocation Loc;
3203   NamedDecl *ToD;
3204   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3205     return nullptr;
3206   if (ToD)
3207     return ToD;
3208 
3209   // Try to find a function in our own ("to") context with the same name, same
3210   // type, and in the same context as the function we're importing.
3211   if (!LexicalDC->isFunctionOrMethod()) {
3212     SmallVector<NamedDecl *, 4> ConflictingDecls;
3213     unsigned IDNS = Decl::IDNS_Ordinary;
3214     SmallVector<NamedDecl *, 2> FoundDecls;
3215     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3216     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3217       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3218         continue;
3219 
3220       if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
3221         if (FoundFunction->hasExternalFormalLinkage() &&
3222             D->hasExternalFormalLinkage()) {
3223           if (Importer.IsStructurallyEquivalent(D->getType(),
3224                                                 FoundFunction->getType())) {
3225             // FIXME: Actually try to merge the body and other attributes.
3226             return Importer.Imported(D, FoundFunction);
3227           }
3228 
3229           // FIXME: Check for overloading more carefully, e.g., by boosting
3230           // Sema::IsOverload out to the AST library.
3231 
3232           // Function overloading is okay in C++.
3233           if (Importer.getToContext().getLangOpts().CPlusPlus)
3234             continue;
3235 
3236           // Complain about inconsistent function types.
3237           Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
3238             << Name << D->getType() << FoundFunction->getType();
3239           Importer.ToDiag(FoundFunction->getLocation(),
3240                           diag::note_odr_value_here)
3241             << FoundFunction->getType();
3242         }
3243       }
3244 
3245       ConflictingDecls.push_back(FoundDecls[I]);
3246     }
3247 
3248     if (!ConflictingDecls.empty()) {
3249       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3250                                          ConflictingDecls.data(),
3251                                          ConflictingDecls.size());
3252       if (!Name)
3253         return nullptr;
3254     }
3255   }
3256 
3257   DeclarationNameInfo NameInfo(Name, Loc);
3258   // Import additional name location/type info.
3259   ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3260 
3261   QualType FromTy = D->getType();
3262   bool usedDifferentExceptionSpec = false;
3263 
3264   if (const FunctionProtoType *
3265         FromFPT = D->getType()->getAs<FunctionProtoType>()) {
3266     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3267     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3268     // FunctionDecl that we are importing the FunctionProtoType for.
3269     // To avoid an infinite recursion when importing, create the FunctionDecl
3270     // with a simplified function type and update it afterwards.
3271     if (FromEPI.ExceptionSpec.SourceDecl ||
3272         FromEPI.ExceptionSpec.SourceTemplate ||
3273         FromEPI.ExceptionSpec.NoexceptExpr) {
3274       FunctionProtoType::ExtProtoInfo DefaultEPI;
3275       FromTy = Importer.getFromContext().getFunctionType(
3276           FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
3277       usedDifferentExceptionSpec = true;
3278     }
3279   }
3280 
3281   // Import the type.
3282   QualType T = Importer.Import(FromTy);
3283   if (T.isNull())
3284     return nullptr;
3285 
3286   // Import the function parameters.
3287   SmallVector<ParmVarDecl *, 8> Parameters;
3288   for (auto P : D->parameters()) {
3289     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3290     if (!ToP)
3291       return nullptr;
3292 
3293     Parameters.push_back(ToP);
3294   }
3295 
3296   // Create the imported function.
3297   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3298   FunctionDecl *ToFunction = nullptr;
3299   SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3300   if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3301     ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3302                                             cast<CXXRecordDecl>(DC),
3303                                             InnerLocStart,
3304                                             NameInfo, T, TInfo,
3305                                             FromConstructor->isExplicit(),
3306                                             D->isInlineSpecified(),
3307                                             D->isImplicit(),
3308                                             D->isConstexpr());
3309     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3310       SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
3311       for (CXXCtorInitializer *I : FromConstructor->inits()) {
3312         CXXCtorInitializer *ToI =
3313             cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3314         if (!ToI && I)
3315           return nullptr;
3316         CtorInitializers.push_back(ToI);
3317       }
3318       CXXCtorInitializer **Memory =
3319           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3320       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3321       CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
3322       ToCtor->setCtorInitializers(Memory);
3323       ToCtor->setNumCtorInitializers(NumInitializers);
3324     }
3325   } else if (isa<CXXDestructorDecl>(D)) {
3326     ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3327                                            cast<CXXRecordDecl>(DC),
3328                                            InnerLocStart,
3329                                            NameInfo, T, TInfo,
3330                                            D->isInlineSpecified(),
3331                                            D->isImplicit());
3332   } else if (CXXConversionDecl *FromConversion
3333                                            = dyn_cast<CXXConversionDecl>(D)) {
3334     ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3335                                            cast<CXXRecordDecl>(DC),
3336                                            InnerLocStart,
3337                                            NameInfo, T, TInfo,
3338                                            D->isInlineSpecified(),
3339                                            FromConversion->isExplicit(),
3340                                            D->isConstexpr(),
3341                                            Importer.Import(D->getLocEnd()));
3342   } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3343     ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3344                                        cast<CXXRecordDecl>(DC),
3345                                        InnerLocStart,
3346                                        NameInfo, T, TInfo,
3347                                        Method->getStorageClass(),
3348                                        Method->isInlineSpecified(),
3349                                        D->isConstexpr(),
3350                                        Importer.Import(D->getLocEnd()));
3351   } else {
3352     ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3353                                       InnerLocStart,
3354                                       NameInfo, T, TInfo, D->getStorageClass(),
3355                                       D->isInlineSpecified(),
3356                                       D->hasWrittenPrototype(),
3357                                       D->isConstexpr());
3358   }
3359 
3360   // Import the qualifier, if any.
3361   ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3362   ToFunction->setAccess(D->getAccess());
3363   ToFunction->setLexicalDeclContext(LexicalDC);
3364   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3365   ToFunction->setTrivial(D->isTrivial());
3366   ToFunction->setPure(D->isPure());
3367   Importer.Imported(D, ToFunction);
3368 
3369   // Set the parameters.
3370   for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
3371     Parameters[I]->setOwningFunction(ToFunction);
3372     ToFunction->addDeclInternal(Parameters[I]);
3373   }
3374   ToFunction->setParams(Parameters);
3375 
3376   if (usedDifferentExceptionSpec) {
3377     // Update FunctionProtoType::ExtProtoInfo.
3378     QualType T = Importer.Import(D->getType());
3379     if (T.isNull())
3380       return nullptr;
3381     ToFunction->setType(T);
3382   }
3383 
3384   // Import the body, if any.
3385   if (Stmt *FromBody = D->getBody()) {
3386     if (Stmt *ToBody = Importer.Import(FromBody)) {
3387       ToFunction->setBody(ToBody);
3388     }
3389   }
3390 
3391   // FIXME: Other bits to merge?
3392 
3393   // Add this function to the lexical context.
3394   LexicalDC->addDeclInternal(ToFunction);
3395 
3396   return ToFunction;
3397 }
3398 
3399 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3400   return VisitFunctionDecl(D);
3401 }
3402 
3403 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3404   return VisitCXXMethodDecl(D);
3405 }
3406 
3407 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3408   return VisitCXXMethodDecl(D);
3409 }
3410 
3411 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3412   return VisitCXXMethodDecl(D);
3413 }
3414 
3415 static unsigned getFieldIndex(Decl *F) {
3416   RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
3417   if (!Owner)
3418     return 0;
3419 
3420   unsigned Index = 1;
3421   for (const auto *D : Owner->noload_decls()) {
3422     if (D == F)
3423       return Index;
3424 
3425     if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
3426       ++Index;
3427   }
3428 
3429   return Index;
3430 }
3431 
3432 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3433   // Import the major distinguishing characteristics of a variable.
3434   DeclContext *DC, *LexicalDC;
3435   DeclarationName Name;
3436   SourceLocation Loc;
3437   NamedDecl *ToD;
3438   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3439     return nullptr;
3440   if (ToD)
3441     return ToD;
3442 
3443   // Determine whether we've already imported this field.
3444   SmallVector<NamedDecl *, 2> FoundDecls;
3445   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3446   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3447     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
3448       // For anonymous fields, match up by index.
3449       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3450         continue;
3451 
3452       if (Importer.IsStructurallyEquivalent(D->getType(),
3453                                             FoundField->getType())) {
3454         Importer.Imported(D, FoundField);
3455         return FoundField;
3456       }
3457 
3458       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3459         << Name << D->getType() << FoundField->getType();
3460       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3461         << FoundField->getType();
3462       return nullptr;
3463     }
3464   }
3465 
3466   // Import the type.
3467   QualType T = Importer.Import(D->getType());
3468   if (T.isNull())
3469     return nullptr;
3470 
3471   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3472   Expr *BitWidth = Importer.Import(D->getBitWidth());
3473   if (!BitWidth && D->getBitWidth())
3474     return nullptr;
3475 
3476   FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3477                                          Importer.Import(D->getInnerLocStart()),
3478                                          Loc, Name.getAsIdentifierInfo(),
3479                                          T, TInfo, BitWidth, D->isMutable(),
3480                                          D->getInClassInitStyle());
3481   ToField->setAccess(D->getAccess());
3482   ToField->setLexicalDeclContext(LexicalDC);
3483   if (Expr *FromInitializer = D->getInClassInitializer()) {
3484     Expr *ToInitializer = Importer.Import(FromInitializer);
3485     if (ToInitializer)
3486       ToField->setInClassInitializer(ToInitializer);
3487     else
3488       return nullptr;
3489   }
3490   ToField->setImplicit(D->isImplicit());
3491   Importer.Imported(D, ToField);
3492   LexicalDC->addDeclInternal(ToField);
3493   return ToField;
3494 }
3495 
3496 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3497   // Import the major distinguishing characteristics of a variable.
3498   DeclContext *DC, *LexicalDC;
3499   DeclarationName Name;
3500   SourceLocation Loc;
3501   NamedDecl *ToD;
3502   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3503     return nullptr;
3504   if (ToD)
3505     return ToD;
3506 
3507   // Determine whether we've already imported this field.
3508   SmallVector<NamedDecl *, 2> FoundDecls;
3509   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3510   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3511     if (IndirectFieldDecl *FoundField
3512                                 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3513       // For anonymous indirect fields, match up by index.
3514       if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3515         continue;
3516 
3517       if (Importer.IsStructurallyEquivalent(D->getType(),
3518                                             FoundField->getType(),
3519                                             !Name.isEmpty())) {
3520         Importer.Imported(D, FoundField);
3521         return FoundField;
3522       }
3523 
3524       // If there are more anonymous fields to check, continue.
3525       if (!Name && I < N-1)
3526         continue;
3527 
3528       Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3529         << Name << D->getType() << FoundField->getType();
3530       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3531         << FoundField->getType();
3532       return nullptr;
3533     }
3534   }
3535 
3536   // Import the type.
3537   QualType T = Importer.Import(D->getType());
3538   if (T.isNull())
3539     return nullptr;
3540 
3541   NamedDecl **NamedChain =
3542     new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3543 
3544   unsigned i = 0;
3545   for (auto *PI : D->chain()) {
3546     Decl *D = Importer.Import(PI);
3547     if (!D)
3548       return nullptr;
3549     NamedChain[i++] = cast<NamedDecl>(D);
3550   }
3551 
3552   IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3553       Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3554       {NamedChain, D->getChainingSize()});
3555 
3556   for (const auto *Attr : D->attrs())
3557     ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3558 
3559   ToIndirectField->setAccess(D->getAccess());
3560   ToIndirectField->setLexicalDeclContext(LexicalDC);
3561   Importer.Imported(D, ToIndirectField);
3562   LexicalDC->addDeclInternal(ToIndirectField);
3563   return ToIndirectField;
3564 }
3565 
3566 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3567   // Import the major distinguishing characteristics of a declaration.
3568   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3569   DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
3570       ? DC : Importer.ImportContext(D->getLexicalDeclContext());
3571   if (!DC || !LexicalDC)
3572     return nullptr;
3573 
3574   // Determine whether we've already imported this decl.
3575   // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
3576   auto *RD = cast<CXXRecordDecl>(DC);
3577   FriendDecl *ImportedFriend = RD->getFirstFriend();
3578   StructuralEquivalenceContext Context(
3579       Importer.getFromContext(), Importer.getToContext(),
3580       Importer.getNonEquivalentDecls(), false, false);
3581 
3582   while (ImportedFriend) {
3583     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3584       if (Context.IsStructurallyEquivalent(D->getFriendDecl(),
3585                                            ImportedFriend->getFriendDecl()))
3586         return Importer.Imported(D, ImportedFriend);
3587 
3588     } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3589       if (Importer.IsStructurallyEquivalent(
3590             D->getFriendType()->getType(),
3591             ImportedFriend->getFriendType()->getType(), true))
3592         return Importer.Imported(D, ImportedFriend);
3593     }
3594     ImportedFriend = ImportedFriend->getNextFriend();
3595   }
3596 
3597   // Not found. Create it.
3598   FriendDecl::FriendUnion ToFU;
3599   if (NamedDecl *FriendD = D->getFriendDecl())
3600     ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3601   else
3602     ToFU = Importer.Import(D->getFriendType());
3603   if (!ToFU)
3604     return nullptr;
3605 
3606   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3607   TemplateParameterList **FromTPLists =
3608       D->getTrailingObjects<TemplateParameterList *>();
3609   for (unsigned I = 0; I < D->NumTPLists; I++) {
3610     TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3611     if (!List)
3612       return nullptr;
3613     ToTPLists[I] = List;
3614   }
3615 
3616   FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC,
3617                                        Importer.Import(D->getLocation()),
3618                                        ToFU, Importer.Import(D->getFriendLoc()),
3619                                        ToTPLists);
3620 
3621   Importer.Imported(D, FrD);
3622   RD->pushFriendDecl(FrD);
3623 
3624   FrD->setAccess(D->getAccess());
3625   FrD->setLexicalDeclContext(LexicalDC);
3626   LexicalDC->addDeclInternal(FrD);
3627   return FrD;
3628 }
3629 
3630 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3631   // Import the major distinguishing characteristics of an ivar.
3632   DeclContext *DC, *LexicalDC;
3633   DeclarationName Name;
3634   SourceLocation Loc;
3635   NamedDecl *ToD;
3636   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3637     return nullptr;
3638   if (ToD)
3639     return ToD;
3640 
3641   // Determine whether we've already imported this ivar
3642   SmallVector<NamedDecl *, 2> FoundDecls;
3643   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3644   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3645     if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3646       if (Importer.IsStructurallyEquivalent(D->getType(),
3647                                             FoundIvar->getType())) {
3648         Importer.Imported(D, FoundIvar);
3649         return FoundIvar;
3650       }
3651 
3652       Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3653         << Name << D->getType() << FoundIvar->getType();
3654       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3655         << FoundIvar->getType();
3656       return nullptr;
3657     }
3658   }
3659 
3660   // Import the type.
3661   QualType T = Importer.Import(D->getType());
3662   if (T.isNull())
3663     return nullptr;
3664 
3665   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3666   Expr *BitWidth = Importer.Import(D->getBitWidth());
3667   if (!BitWidth && D->getBitWidth())
3668     return nullptr;
3669 
3670   ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3671                                               cast<ObjCContainerDecl>(DC),
3672                                        Importer.Import(D->getInnerLocStart()),
3673                                               Loc, Name.getAsIdentifierInfo(),
3674                                               T, TInfo, D->getAccessControl(),
3675                                               BitWidth, D->getSynthesize());
3676   ToIvar->setLexicalDeclContext(LexicalDC);
3677   Importer.Imported(D, ToIvar);
3678   LexicalDC->addDeclInternal(ToIvar);
3679   return ToIvar;
3680 
3681 }
3682 
3683 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3684   // Import the major distinguishing characteristics of a variable.
3685   DeclContext *DC, *LexicalDC;
3686   DeclarationName Name;
3687   SourceLocation Loc;
3688   NamedDecl *ToD;
3689   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3690     return nullptr;
3691   if (ToD)
3692     return ToD;
3693 
3694   // Try to find a variable in our own ("to") context with the same name and
3695   // in the same context as the variable we're importing.
3696   if (D->isFileVarDecl()) {
3697     VarDecl *MergeWithVar = nullptr;
3698     SmallVector<NamedDecl *, 4> ConflictingDecls;
3699     unsigned IDNS = Decl::IDNS_Ordinary;
3700     SmallVector<NamedDecl *, 2> FoundDecls;
3701     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3702     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3703       if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3704         continue;
3705 
3706       if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3707         // We have found a variable that we may need to merge with. Check it.
3708         if (FoundVar->hasExternalFormalLinkage() &&
3709             D->hasExternalFormalLinkage()) {
3710           if (Importer.IsStructurallyEquivalent(D->getType(),
3711                                                 FoundVar->getType())) {
3712             MergeWithVar = FoundVar;
3713             break;
3714           }
3715 
3716           const ArrayType *FoundArray
3717             = Importer.getToContext().getAsArrayType(FoundVar->getType());
3718           const ArrayType *TArray
3719             = Importer.getToContext().getAsArrayType(D->getType());
3720           if (FoundArray && TArray) {
3721             if (isa<IncompleteArrayType>(FoundArray) &&
3722                 isa<ConstantArrayType>(TArray)) {
3723               // Import the type.
3724               QualType T = Importer.Import(D->getType());
3725               if (T.isNull())
3726                 return nullptr;
3727 
3728               FoundVar->setType(T);
3729               MergeWithVar = FoundVar;
3730               break;
3731             } else if (isa<IncompleteArrayType>(TArray) &&
3732                        isa<ConstantArrayType>(FoundArray)) {
3733               MergeWithVar = FoundVar;
3734               break;
3735             }
3736           }
3737 
3738           Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3739             << Name << D->getType() << FoundVar->getType();
3740           Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3741             << FoundVar->getType();
3742         }
3743       }
3744 
3745       ConflictingDecls.push_back(FoundDecls[I]);
3746     }
3747 
3748     if (MergeWithVar) {
3749       // An equivalent variable with external linkage has been found. Link
3750       // the two declarations, then merge them.
3751       Importer.Imported(D, MergeWithVar);
3752 
3753       if (VarDecl *DDef = D->getDefinition()) {
3754         if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3755           Importer.ToDiag(ExistingDef->getLocation(),
3756                           diag::err_odr_variable_multiple_def)
3757             << Name;
3758           Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3759         } else {
3760           Expr *Init = Importer.Import(DDef->getInit());
3761           MergeWithVar->setInit(Init);
3762           if (DDef->isInitKnownICE()) {
3763             EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3764             Eval->CheckedICE = true;
3765             Eval->IsICE = DDef->isInitICE();
3766           }
3767         }
3768       }
3769 
3770       return MergeWithVar;
3771     }
3772 
3773     if (!ConflictingDecls.empty()) {
3774       Name = Importer.HandleNameConflict(Name, DC, IDNS,
3775                                          ConflictingDecls.data(),
3776                                          ConflictingDecls.size());
3777       if (!Name)
3778         return nullptr;
3779     }
3780   }
3781 
3782   // Import the type.
3783   QualType T = Importer.Import(D->getType());
3784   if (T.isNull())
3785     return nullptr;
3786 
3787   // Create the imported variable.
3788   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3789   VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3790                                    Importer.Import(D->getInnerLocStart()),
3791                                    Loc, Name.getAsIdentifierInfo(),
3792                                    T, TInfo,
3793                                    D->getStorageClass());
3794   ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3795   ToVar->setAccess(D->getAccess());
3796   ToVar->setLexicalDeclContext(LexicalDC);
3797   Importer.Imported(D, ToVar);
3798   LexicalDC->addDeclInternal(ToVar);
3799 
3800   if (!D->isFileVarDecl() &&
3801       D->isUsed())
3802     ToVar->setIsUsed();
3803 
3804   // Merge the initializer.
3805   if (ImportDefinition(D, ToVar))
3806     return nullptr;
3807 
3808   if (D->isConstexpr())
3809     ToVar->setConstexpr(true);
3810 
3811   return ToVar;
3812 }
3813 
3814 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3815   // Parameters are created in the translation unit's context, then moved
3816   // into the function declaration's context afterward.
3817   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3818 
3819   // Import the name of this declaration.
3820   DeclarationName Name = Importer.Import(D->getDeclName());
3821   if (D->getDeclName() && !Name)
3822     return nullptr;
3823 
3824   // Import the location of this declaration.
3825   SourceLocation Loc = Importer.Import(D->getLocation());
3826 
3827   // Import the parameter's type.
3828   QualType T = Importer.Import(D->getType());
3829   if (T.isNull())
3830     return nullptr;
3831 
3832   // Create the imported parameter.
3833   ImplicitParamDecl *ToParm
3834     = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3835                                 Loc, Name.getAsIdentifierInfo(),
3836                                 T);
3837   return Importer.Imported(D, ToParm);
3838 }
3839 
3840 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3841   // Parameters are created in the translation unit's context, then moved
3842   // into the function declaration's context afterward.
3843   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3844 
3845   // Import the name of this declaration.
3846   DeclarationName Name = Importer.Import(D->getDeclName());
3847   if (D->getDeclName() && !Name)
3848     return nullptr;
3849 
3850   // Import the location of this declaration.
3851   SourceLocation Loc = Importer.Import(D->getLocation());
3852 
3853   // Import the parameter's type.
3854   QualType T = Importer.Import(D->getType());
3855   if (T.isNull())
3856     return nullptr;
3857 
3858   // Create the imported parameter.
3859   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3860   ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3861                                      Importer.Import(D->getInnerLocStart()),
3862                                             Loc, Name.getAsIdentifierInfo(),
3863                                             T, TInfo, D->getStorageClass(),
3864                                             /*DefaultArg*/ nullptr);
3865 
3866   // Set the default argument.
3867   ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3868   ToParm->setKNRPromoted(D->isKNRPromoted());
3869 
3870   Expr *ToDefArg = nullptr;
3871   Expr *FromDefArg = nullptr;
3872   if (D->hasUninstantiatedDefaultArg()) {
3873     FromDefArg = D->getUninstantiatedDefaultArg();
3874     ToDefArg = Importer.Import(FromDefArg);
3875     ToParm->setUninstantiatedDefaultArg(ToDefArg);
3876   } else if (D->hasUnparsedDefaultArg()) {
3877     ToParm->setUnparsedDefaultArg();
3878   } else if (D->hasDefaultArg()) {
3879     FromDefArg = D->getDefaultArg();
3880     ToDefArg = Importer.Import(FromDefArg);
3881     ToParm->setDefaultArg(ToDefArg);
3882   }
3883   if (FromDefArg && !ToDefArg)
3884     return nullptr;
3885 
3886   if (D->isUsed())
3887     ToParm->setIsUsed();
3888 
3889   return Importer.Imported(D, ToParm);
3890 }
3891 
3892 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3893   // Import the major distinguishing characteristics of a method.
3894   DeclContext *DC, *LexicalDC;
3895   DeclarationName Name;
3896   SourceLocation Loc;
3897   NamedDecl *ToD;
3898   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3899     return nullptr;
3900   if (ToD)
3901     return ToD;
3902 
3903   SmallVector<NamedDecl *, 2> FoundDecls;
3904   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3905   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3906     if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3907       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3908         continue;
3909 
3910       // Check return types.
3911       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3912                                              FoundMethod->getReturnType())) {
3913         Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3914             << D->isInstanceMethod() << Name << D->getReturnType()
3915             << FoundMethod->getReturnType();
3916         Importer.ToDiag(FoundMethod->getLocation(),
3917                         diag::note_odr_objc_method_here)
3918           << D->isInstanceMethod() << Name;
3919         return nullptr;
3920       }
3921 
3922       // Check the number of parameters.
3923       if (D->param_size() != FoundMethod->param_size()) {
3924         Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3925           << D->isInstanceMethod() << Name
3926           << D->param_size() << FoundMethod->param_size();
3927         Importer.ToDiag(FoundMethod->getLocation(),
3928                         diag::note_odr_objc_method_here)
3929           << D->isInstanceMethod() << Name;
3930         return nullptr;
3931       }
3932 
3933       // Check parameter types.
3934       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3935              PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3936            P != PEnd; ++P, ++FoundP) {
3937         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3938                                                (*FoundP)->getType())) {
3939           Importer.FromDiag((*P)->getLocation(),
3940                             diag::err_odr_objc_method_param_type_inconsistent)
3941             << D->isInstanceMethod() << Name
3942             << (*P)->getType() << (*FoundP)->getType();
3943           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3944             << (*FoundP)->getType();
3945           return nullptr;
3946         }
3947       }
3948 
3949       // Check variadic/non-variadic.
3950       // Check the number of parameters.
3951       if (D->isVariadic() != FoundMethod->isVariadic()) {
3952         Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3953           << D->isInstanceMethod() << Name;
3954         Importer.ToDiag(FoundMethod->getLocation(),
3955                         diag::note_odr_objc_method_here)
3956           << D->isInstanceMethod() << Name;
3957         return nullptr;
3958       }
3959 
3960       // FIXME: Any other bits we need to merge?
3961       return Importer.Imported(D, FoundMethod);
3962     }
3963   }
3964 
3965   // Import the result type.
3966   QualType ResultTy = Importer.Import(D->getReturnType());
3967   if (ResultTy.isNull())
3968     return nullptr;
3969 
3970   TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3971 
3972   ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3973       Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3974       Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3975       D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3976       D->getImplementationControl(), D->hasRelatedResultType());
3977 
3978   // FIXME: When we decide to merge method definitions, we'll need to
3979   // deal with implicit parameters.
3980 
3981   // Import the parameters
3982   SmallVector<ParmVarDecl *, 5> ToParams;
3983   for (auto *FromP : D->parameters()) {
3984     ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3985     if (!ToP)
3986       return nullptr;
3987 
3988     ToParams.push_back(ToP);
3989   }
3990 
3991   // Set the parameters.
3992   for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3993     ToParams[I]->setOwningFunction(ToMethod);
3994     ToMethod->addDeclInternal(ToParams[I]);
3995   }
3996   SmallVector<SourceLocation, 12> SelLocs;
3997   D->getSelectorLocs(SelLocs);
3998   ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3999 
4000   ToMethod->setLexicalDeclContext(LexicalDC);
4001   Importer.Imported(D, ToMethod);
4002   LexicalDC->addDeclInternal(ToMethod);
4003   return ToMethod;
4004 }
4005 
4006 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4007   // Import the major distinguishing characteristics of a category.
4008   DeclContext *DC, *LexicalDC;
4009   DeclarationName Name;
4010   SourceLocation Loc;
4011   NamedDecl *ToD;
4012   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4013     return nullptr;
4014   if (ToD)
4015     return ToD;
4016 
4017   TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
4018   if (!BoundInfo)
4019     return nullptr;
4020 
4021   ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
4022                                 Importer.getToContext(), DC,
4023                                 D->getVariance(),
4024                                 Importer.Import(D->getVarianceLoc()),
4025                                 D->getIndex(),
4026                                 Importer.Import(D->getLocation()),
4027                                 Name.getAsIdentifierInfo(),
4028                                 Importer.Import(D->getColonLoc()),
4029                                 BoundInfo);
4030   Importer.Imported(D, Result);
4031   Result->setLexicalDeclContext(LexicalDC);
4032   return Result;
4033 }
4034 
4035 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4036   // Import the major distinguishing characteristics of a category.
4037   DeclContext *DC, *LexicalDC;
4038   DeclarationName Name;
4039   SourceLocation Loc;
4040   NamedDecl *ToD;
4041   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4042     return nullptr;
4043   if (ToD)
4044     return ToD;
4045 
4046   ObjCInterfaceDecl *ToInterface
4047     = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
4048   if (!ToInterface)
4049     return nullptr;
4050 
4051   // Determine if we've already encountered this category.
4052   ObjCCategoryDecl *MergeWithCategory
4053     = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4054   ObjCCategoryDecl *ToCategory = MergeWithCategory;
4055   if (!ToCategory) {
4056     ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
4057                                           Importer.Import(D->getAtStartLoc()),
4058                                           Loc,
4059                                        Importer.Import(D->getCategoryNameLoc()),
4060                                           Name.getAsIdentifierInfo(),
4061                                           ToInterface,
4062                                           /*TypeParamList=*/nullptr,
4063                                        Importer.Import(D->getIvarLBraceLoc()),
4064                                        Importer.Import(D->getIvarRBraceLoc()));
4065     ToCategory->setLexicalDeclContext(LexicalDC);
4066     LexicalDC->addDeclInternal(ToCategory);
4067     Importer.Imported(D, ToCategory);
4068     // Import the type parameter list after calling Imported, to avoid
4069     // loops when bringing in their DeclContext.
4070     ToCategory->setTypeParamList(ImportObjCTypeParamList(
4071                                    D->getTypeParamList()));
4072 
4073     // Import protocols
4074     SmallVector<ObjCProtocolDecl *, 4> Protocols;
4075     SmallVector<SourceLocation, 4> ProtocolLocs;
4076     ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4077       = D->protocol_loc_begin();
4078     for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4079                                           FromProtoEnd = D->protocol_end();
4080          FromProto != FromProtoEnd;
4081          ++FromProto, ++FromProtoLoc) {
4082       ObjCProtocolDecl *ToProto
4083         = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4084       if (!ToProto)
4085         return nullptr;
4086       Protocols.push_back(ToProto);
4087       ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4088     }
4089 
4090     // FIXME: If we're merging, make sure that the protocol list is the same.
4091     ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4092                                 ProtocolLocs.data(), Importer.getToContext());
4093 
4094   } else {
4095     Importer.Imported(D, ToCategory);
4096   }
4097 
4098   // Import all of the members of this category.
4099   ImportDeclContext(D);
4100 
4101   // If we have an implementation, import it as well.
4102   if (D->getImplementation()) {
4103     ObjCCategoryImplDecl *Impl
4104       = cast_or_null<ObjCCategoryImplDecl>(
4105                                        Importer.Import(D->getImplementation()));
4106     if (!Impl)
4107       return nullptr;
4108 
4109     ToCategory->setImplementation(Impl);
4110   }
4111 
4112   return ToCategory;
4113 }
4114 
4115 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
4116                                        ObjCProtocolDecl *To,
4117                                        ImportDefinitionKind Kind) {
4118   if (To->getDefinition()) {
4119     if (shouldForceImportDeclContext(Kind))
4120       ImportDeclContext(From);
4121     return false;
4122   }
4123 
4124   // Start the protocol definition
4125   To->startDefinition();
4126 
4127   // Import protocols
4128   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4129   SmallVector<SourceLocation, 4> ProtocolLocs;
4130   ObjCProtocolDecl::protocol_loc_iterator
4131   FromProtoLoc = From->protocol_loc_begin();
4132   for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4133                                         FromProtoEnd = From->protocol_end();
4134        FromProto != FromProtoEnd;
4135        ++FromProto, ++FromProtoLoc) {
4136     ObjCProtocolDecl *ToProto
4137       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4138     if (!ToProto)
4139       return true;
4140     Protocols.push_back(ToProto);
4141     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4142   }
4143 
4144   // FIXME: If we're merging, make sure that the protocol list is the same.
4145   To->setProtocolList(Protocols.data(), Protocols.size(),
4146                       ProtocolLocs.data(), Importer.getToContext());
4147 
4148   if (shouldForceImportDeclContext(Kind)) {
4149     // Import all of the members of this protocol.
4150     ImportDeclContext(From, /*ForceImport=*/true);
4151   }
4152   return false;
4153 }
4154 
4155 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4156   // If this protocol has a definition in the translation unit we're coming
4157   // from, but this particular declaration is not that definition, import the
4158   // definition and map to that.
4159   ObjCProtocolDecl *Definition = D->getDefinition();
4160   if (Definition && Definition != D) {
4161     Decl *ImportedDef = Importer.Import(Definition);
4162     if (!ImportedDef)
4163       return nullptr;
4164 
4165     return Importer.Imported(D, ImportedDef);
4166   }
4167 
4168   // Import the major distinguishing characteristics of a protocol.
4169   DeclContext *DC, *LexicalDC;
4170   DeclarationName Name;
4171   SourceLocation Loc;
4172   NamedDecl *ToD;
4173   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4174     return nullptr;
4175   if (ToD)
4176     return ToD;
4177 
4178   ObjCProtocolDecl *MergeWithProtocol = nullptr;
4179   SmallVector<NamedDecl *, 2> FoundDecls;
4180   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4181   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4182     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4183       continue;
4184 
4185     if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
4186       break;
4187   }
4188 
4189   ObjCProtocolDecl *ToProto = MergeWithProtocol;
4190   if (!ToProto) {
4191     ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
4192                                        Name.getAsIdentifierInfo(), Loc,
4193                                        Importer.Import(D->getAtStartLoc()),
4194                                        /*PrevDecl=*/nullptr);
4195     ToProto->setLexicalDeclContext(LexicalDC);
4196     LexicalDC->addDeclInternal(ToProto);
4197   }
4198 
4199   Importer.Imported(D, ToProto);
4200 
4201   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
4202     return nullptr;
4203 
4204   return ToProto;
4205 }
4206 
4207 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4208   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4209   DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4210 
4211   SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
4212   SourceLocation LangLoc = Importer.Import(D->getLocation());
4213 
4214   bool HasBraces = D->hasBraces();
4215 
4216   LinkageSpecDecl *ToLinkageSpec =
4217     LinkageSpecDecl::Create(Importer.getToContext(),
4218                             DC,
4219                             ExternLoc,
4220                             LangLoc,
4221                             D->getLanguage(),
4222                             HasBraces);
4223 
4224   if (HasBraces) {
4225     SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
4226     ToLinkageSpec->setRBraceLoc(RBraceLoc);
4227   }
4228 
4229   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4230   LexicalDC->addDeclInternal(ToLinkageSpec);
4231 
4232   Importer.Imported(D, ToLinkageSpec);
4233 
4234   return ToLinkageSpec;
4235 }
4236 
4237 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
4238                                        ObjCInterfaceDecl *To,
4239                                        ImportDefinitionKind Kind) {
4240   if (To->getDefinition()) {
4241     // Check consistency of superclass.
4242     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4243     if (FromSuper) {
4244       FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
4245       if (!FromSuper)
4246         return true;
4247     }
4248 
4249     ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4250     if ((bool)FromSuper != (bool)ToSuper ||
4251         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4252       Importer.ToDiag(To->getLocation(),
4253                       diag::err_odr_objc_superclass_inconsistent)
4254         << To->getDeclName();
4255       if (ToSuper)
4256         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4257           << To->getSuperClass()->getDeclName();
4258       else
4259         Importer.ToDiag(To->getLocation(),
4260                         diag::note_odr_objc_missing_superclass);
4261       if (From->getSuperClass())
4262         Importer.FromDiag(From->getSuperClassLoc(),
4263                           diag::note_odr_objc_superclass)
4264         << From->getSuperClass()->getDeclName();
4265       else
4266         Importer.FromDiag(From->getLocation(),
4267                           diag::note_odr_objc_missing_superclass);
4268     }
4269 
4270     if (shouldForceImportDeclContext(Kind))
4271       ImportDeclContext(From);
4272     return false;
4273   }
4274 
4275   // Start the definition.
4276   To->startDefinition();
4277 
4278   // If this class has a superclass, import it.
4279   if (From->getSuperClass()) {
4280     TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
4281     if (!SuperTInfo)
4282       return true;
4283 
4284     To->setSuperClass(SuperTInfo);
4285   }
4286 
4287   // Import protocols
4288   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4289   SmallVector<SourceLocation, 4> ProtocolLocs;
4290   ObjCInterfaceDecl::protocol_loc_iterator
4291   FromProtoLoc = From->protocol_loc_begin();
4292 
4293   for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4294                                          FromProtoEnd = From->protocol_end();
4295        FromProto != FromProtoEnd;
4296        ++FromProto, ++FromProtoLoc) {
4297     ObjCProtocolDecl *ToProto
4298       = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
4299     if (!ToProto)
4300       return true;
4301     Protocols.push_back(ToProto);
4302     ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
4303   }
4304 
4305   // FIXME: If we're merging, make sure that the protocol list is the same.
4306   To->setProtocolList(Protocols.data(), Protocols.size(),
4307                       ProtocolLocs.data(), Importer.getToContext());
4308 
4309   // Import categories. When the categories themselves are imported, they'll
4310   // hook themselves into this interface.
4311   for (auto *Cat : From->known_categories())
4312     Importer.Import(Cat);
4313 
4314   // If we have an @implementation, import it as well.
4315   if (From->getImplementation()) {
4316     ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
4317                                      Importer.Import(From->getImplementation()));
4318     if (!Impl)
4319       return true;
4320 
4321     To->setImplementation(Impl);
4322   }
4323 
4324   if (shouldForceImportDeclContext(Kind)) {
4325     // Import all of the members of this class.
4326     ImportDeclContext(From, /*ForceImport=*/true);
4327   }
4328   return false;
4329 }
4330 
4331 ObjCTypeParamList *
4332 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4333   if (!list)
4334     return nullptr;
4335 
4336   SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4337   for (auto fromTypeParam : *list) {
4338     auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
4339                          Importer.Import(fromTypeParam));
4340     if (!toTypeParam)
4341       return nullptr;
4342 
4343     toTypeParams.push_back(toTypeParam);
4344   }
4345 
4346   return ObjCTypeParamList::create(Importer.getToContext(),
4347                                    Importer.Import(list->getLAngleLoc()),
4348                                    toTypeParams,
4349                                    Importer.Import(list->getRAngleLoc()));
4350 }
4351 
4352 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4353   // If this class has a definition in the translation unit we're coming from,
4354   // but this particular declaration is not that definition, import the
4355   // definition and map to that.
4356   ObjCInterfaceDecl *Definition = D->getDefinition();
4357   if (Definition && Definition != D) {
4358     Decl *ImportedDef = Importer.Import(Definition);
4359     if (!ImportedDef)
4360       return nullptr;
4361 
4362     return Importer.Imported(D, ImportedDef);
4363   }
4364 
4365   // Import the major distinguishing characteristics of an @interface.
4366   DeclContext *DC, *LexicalDC;
4367   DeclarationName Name;
4368   SourceLocation Loc;
4369   NamedDecl *ToD;
4370   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4371     return nullptr;
4372   if (ToD)
4373     return ToD;
4374 
4375   // Look for an existing interface with the same name.
4376   ObjCInterfaceDecl *MergeWithIface = nullptr;
4377   SmallVector<NamedDecl *, 2> FoundDecls;
4378   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4379   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4380     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4381       continue;
4382 
4383     if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
4384       break;
4385   }
4386 
4387   // Create an interface declaration, if one does not already exist.
4388   ObjCInterfaceDecl *ToIface = MergeWithIface;
4389   if (!ToIface) {
4390     ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4391                                         Importer.Import(D->getAtStartLoc()),
4392                                         Name.getAsIdentifierInfo(),
4393                                         /*TypeParamList=*/nullptr,
4394                                         /*PrevDecl=*/nullptr, Loc,
4395                                         D->isImplicitInterfaceDecl());
4396     ToIface->setLexicalDeclContext(LexicalDC);
4397     LexicalDC->addDeclInternal(ToIface);
4398   }
4399   Importer.Imported(D, ToIface);
4400   // Import the type parameter list after calling Imported, to avoid
4401   // loops when bringing in their DeclContext.
4402   ToIface->setTypeParamList(ImportObjCTypeParamList(
4403                               D->getTypeParamListAsWritten()));
4404 
4405   if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4406     return nullptr;
4407 
4408   return ToIface;
4409 }
4410 
4411 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4412   ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
4413                                         Importer.Import(D->getCategoryDecl()));
4414   if (!Category)
4415     return nullptr;
4416 
4417   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4418   if (!ToImpl) {
4419     DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4420     if (!DC)
4421       return nullptr;
4422 
4423     SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4424     ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4425                                           Importer.Import(D->getIdentifier()),
4426                                           Category->getClassInterface(),
4427                                           Importer.Import(D->getLocation()),
4428                                           Importer.Import(D->getAtStartLoc()),
4429                                           CategoryNameLoc);
4430 
4431     DeclContext *LexicalDC = DC;
4432     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4433       LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4434       if (!LexicalDC)
4435         return nullptr;
4436 
4437       ToImpl->setLexicalDeclContext(LexicalDC);
4438     }
4439 
4440     LexicalDC->addDeclInternal(ToImpl);
4441     Category->setImplementation(ToImpl);
4442   }
4443 
4444   Importer.Imported(D, ToImpl);
4445   ImportDeclContext(D);
4446   return ToImpl;
4447 }
4448 
4449 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4450   // Find the corresponding interface.
4451   ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
4452                                        Importer.Import(D->getClassInterface()));
4453   if (!Iface)
4454     return nullptr;
4455 
4456   // Import the superclass, if any.
4457   ObjCInterfaceDecl *Super = nullptr;
4458   if (D->getSuperClass()) {
4459     Super = cast_or_null<ObjCInterfaceDecl>(
4460                                           Importer.Import(D->getSuperClass()));
4461     if (!Super)
4462       return nullptr;
4463   }
4464 
4465   ObjCImplementationDecl *Impl = Iface->getImplementation();
4466   if (!Impl) {
4467     // We haven't imported an implementation yet. Create a new @implementation
4468     // now.
4469     Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4470                                   Importer.ImportContext(D->getDeclContext()),
4471                                           Iface, Super,
4472                                           Importer.Import(D->getLocation()),
4473                                           Importer.Import(D->getAtStartLoc()),
4474                                           Importer.Import(D->getSuperClassLoc()),
4475                                           Importer.Import(D->getIvarLBraceLoc()),
4476                                           Importer.Import(D->getIvarRBraceLoc()));
4477 
4478     if (D->getDeclContext() != D->getLexicalDeclContext()) {
4479       DeclContext *LexicalDC
4480         = Importer.ImportContext(D->getLexicalDeclContext());
4481       if (!LexicalDC)
4482         return nullptr;
4483       Impl->setLexicalDeclContext(LexicalDC);
4484     }
4485 
4486     // Associate the implementation with the class it implements.
4487     Iface->setImplementation(Impl);
4488     Importer.Imported(D, Iface->getImplementation());
4489   } else {
4490     Importer.Imported(D, Iface->getImplementation());
4491 
4492     // Verify that the existing @implementation has the same superclass.
4493     if ((Super && !Impl->getSuperClass()) ||
4494         (!Super && Impl->getSuperClass()) ||
4495         (Super && Impl->getSuperClass() &&
4496          !declaresSameEntity(Super->getCanonicalDecl(),
4497                              Impl->getSuperClass()))) {
4498       Importer.ToDiag(Impl->getLocation(),
4499                       diag::err_odr_objc_superclass_inconsistent)
4500         << Iface->getDeclName();
4501       // FIXME: It would be nice to have the location of the superclass
4502       // below.
4503       if (Impl->getSuperClass())
4504         Importer.ToDiag(Impl->getLocation(),
4505                         diag::note_odr_objc_superclass)
4506         << Impl->getSuperClass()->getDeclName();
4507       else
4508         Importer.ToDiag(Impl->getLocation(),
4509                         diag::note_odr_objc_missing_superclass);
4510       if (D->getSuperClass())
4511         Importer.FromDiag(D->getLocation(),
4512                           diag::note_odr_objc_superclass)
4513         << D->getSuperClass()->getDeclName();
4514       else
4515         Importer.FromDiag(D->getLocation(),
4516                           diag::note_odr_objc_missing_superclass);
4517       return nullptr;
4518     }
4519   }
4520 
4521   // Import all of the members of this @implementation.
4522   ImportDeclContext(D);
4523 
4524   return Impl;
4525 }
4526 
4527 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4528   // Import the major distinguishing characteristics of an @property.
4529   DeclContext *DC, *LexicalDC;
4530   DeclarationName Name;
4531   SourceLocation Loc;
4532   NamedDecl *ToD;
4533   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4534     return nullptr;
4535   if (ToD)
4536     return ToD;
4537 
4538   // Check whether we have already imported this property.
4539   SmallVector<NamedDecl *, 2> FoundDecls;
4540   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4541   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4542     if (ObjCPropertyDecl *FoundProp
4543                                 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
4544       // Check property types.
4545       if (!Importer.IsStructurallyEquivalent(D->getType(),
4546                                              FoundProp->getType())) {
4547         Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4548           << Name << D->getType() << FoundProp->getType();
4549         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4550           << FoundProp->getType();
4551         return nullptr;
4552       }
4553 
4554       // FIXME: Check property attributes, getters, setters, etc.?
4555 
4556       // Consider these properties to be equivalent.
4557       Importer.Imported(D, FoundProp);
4558       return FoundProp;
4559     }
4560   }
4561 
4562   // Import the type.
4563   TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4564   if (!TSI)
4565     return nullptr;
4566 
4567   // Create the new property.
4568   ObjCPropertyDecl *ToProperty
4569     = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4570                                Name.getAsIdentifierInfo(),
4571                                Importer.Import(D->getAtLoc()),
4572                                Importer.Import(D->getLParenLoc()),
4573                                Importer.Import(D->getType()),
4574                                TSI,
4575                                D->getPropertyImplementation());
4576   Importer.Imported(D, ToProperty);
4577   ToProperty->setLexicalDeclContext(LexicalDC);
4578   LexicalDC->addDeclInternal(ToProperty);
4579 
4580   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4581   ToProperty->setPropertyAttributesAsWritten(
4582                                       D->getPropertyAttributesAsWritten());
4583   ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4584   ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4585   ToProperty->setGetterMethodDecl(
4586      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4587   ToProperty->setSetterMethodDecl(
4588      cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4589   ToProperty->setPropertyIvarDecl(
4590        cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4591   return ToProperty;
4592 }
4593 
4594 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4595   ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4596                                         Importer.Import(D->getPropertyDecl()));
4597   if (!Property)
4598     return nullptr;
4599 
4600   DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4601   if (!DC)
4602     return nullptr;
4603 
4604   // Import the lexical declaration context.
4605   DeclContext *LexicalDC = DC;
4606   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4607     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4608     if (!LexicalDC)
4609       return nullptr;
4610   }
4611 
4612   ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4613   if (!InImpl)
4614     return nullptr;
4615 
4616   // Import the ivar (for an @synthesize).
4617   ObjCIvarDecl *Ivar = nullptr;
4618   if (D->getPropertyIvarDecl()) {
4619     Ivar = cast_or_null<ObjCIvarDecl>(
4620                                     Importer.Import(D->getPropertyIvarDecl()));
4621     if (!Ivar)
4622       return nullptr;
4623   }
4624 
4625   ObjCPropertyImplDecl *ToImpl
4626     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4627                                    Property->getQueryKind());
4628   if (!ToImpl) {
4629     ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4630                                           Importer.Import(D->getLocStart()),
4631                                           Importer.Import(D->getLocation()),
4632                                           Property,
4633                                           D->getPropertyImplementation(),
4634                                           Ivar,
4635                                   Importer.Import(D->getPropertyIvarDeclLoc()));
4636     ToImpl->setLexicalDeclContext(LexicalDC);
4637     Importer.Imported(D, ToImpl);
4638     LexicalDC->addDeclInternal(ToImpl);
4639   } else {
4640     // Check that we have the same kind of property implementation (@synthesize
4641     // vs. @dynamic).
4642     if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4643       Importer.ToDiag(ToImpl->getLocation(),
4644                       diag::err_odr_objc_property_impl_kind_inconsistent)
4645         << Property->getDeclName()
4646         << (ToImpl->getPropertyImplementation()
4647                                               == ObjCPropertyImplDecl::Dynamic);
4648       Importer.FromDiag(D->getLocation(),
4649                         diag::note_odr_objc_property_impl_kind)
4650         << D->getPropertyDecl()->getDeclName()
4651         << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4652       return nullptr;
4653     }
4654 
4655     // For @synthesize, check that we have the same
4656     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4657         Ivar != ToImpl->getPropertyIvarDecl()) {
4658       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4659                       diag::err_odr_objc_synthesize_ivar_inconsistent)
4660         << Property->getDeclName()
4661         << ToImpl->getPropertyIvarDecl()->getDeclName()
4662         << Ivar->getDeclName();
4663       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4664                         diag::note_odr_objc_synthesize_ivar_here)
4665         << D->getPropertyIvarDecl()->getDeclName();
4666       return nullptr;
4667     }
4668 
4669     // Merge the existing implementation with the new implementation.
4670     Importer.Imported(D, ToImpl);
4671   }
4672 
4673   return ToImpl;
4674 }
4675 
4676 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4677   // For template arguments, we adopt the translation unit as our declaration
4678   // context. This context will be fixed when the actual template declaration
4679   // is created.
4680 
4681   // FIXME: Import default argument.
4682   return TemplateTypeParmDecl::Create(Importer.getToContext(),
4683                               Importer.getToContext().getTranslationUnitDecl(),
4684                                       Importer.Import(D->getLocStart()),
4685                                       Importer.Import(D->getLocation()),
4686                                       D->getDepth(),
4687                                       D->getIndex(),
4688                                       Importer.Import(D->getIdentifier()),
4689                                       D->wasDeclaredWithTypename(),
4690                                       D->isParameterPack());
4691 }
4692 
4693 Decl *
4694 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4695   // Import the name of this declaration.
4696   DeclarationName Name = Importer.Import(D->getDeclName());
4697   if (D->getDeclName() && !Name)
4698     return nullptr;
4699 
4700   // Import the location of this declaration.
4701   SourceLocation Loc = Importer.Import(D->getLocation());
4702 
4703   // Import the type of this declaration.
4704   QualType T = Importer.Import(D->getType());
4705   if (T.isNull())
4706     return nullptr;
4707 
4708   // Import type-source information.
4709   TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4710   if (D->getTypeSourceInfo() && !TInfo)
4711     return nullptr;
4712 
4713   // FIXME: Import default argument.
4714 
4715   return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4716                                Importer.getToContext().getTranslationUnitDecl(),
4717                                          Importer.Import(D->getInnerLocStart()),
4718                                          Loc, D->getDepth(), D->getPosition(),
4719                                          Name.getAsIdentifierInfo(),
4720                                          T, D->isParameterPack(), TInfo);
4721 }
4722 
4723 Decl *
4724 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4725   // Import the name of this declaration.
4726   DeclarationName Name = Importer.Import(D->getDeclName());
4727   if (D->getDeclName() && !Name)
4728     return nullptr;
4729 
4730   // Import the location of this declaration.
4731   SourceLocation Loc = Importer.Import(D->getLocation());
4732 
4733   // Import template parameters.
4734   TemplateParameterList *TemplateParams
4735     = ImportTemplateParameterList(D->getTemplateParameters());
4736   if (!TemplateParams)
4737     return nullptr;
4738 
4739   // FIXME: Import default argument.
4740 
4741   return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4742                               Importer.getToContext().getTranslationUnitDecl(),
4743                                           Loc, D->getDepth(), D->getPosition(),
4744                                           D->isParameterPack(),
4745                                           Name.getAsIdentifierInfo(),
4746                                           TemplateParams);
4747 }
4748 
4749 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4750   // If this record has a definition in the translation unit we're coming from,
4751   // but this particular declaration is not that definition, import the
4752   // definition and map to that.
4753   CXXRecordDecl *Definition
4754     = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4755   if (Definition && Definition != D->getTemplatedDecl()) {
4756     Decl *ImportedDef
4757       = Importer.Import(Definition->getDescribedClassTemplate());
4758     if (!ImportedDef)
4759       return nullptr;
4760 
4761     return Importer.Imported(D, ImportedDef);
4762   }
4763 
4764   // Import the major distinguishing characteristics of this class template.
4765   DeclContext *DC, *LexicalDC;
4766   DeclarationName Name;
4767   SourceLocation Loc;
4768   NamedDecl *ToD;
4769   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4770     return nullptr;
4771   if (ToD)
4772     return ToD;
4773 
4774   // We may already have a template of the same name; try to find and match it.
4775   if (!DC->isFunctionOrMethod()) {
4776     SmallVector<NamedDecl *, 4> ConflictingDecls;
4777     SmallVector<NamedDecl *, 2> FoundDecls;
4778     DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4779     for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4780       if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4781         continue;
4782 
4783       Decl *Found = FoundDecls[I];
4784       if (ClassTemplateDecl *FoundTemplate
4785                                         = dyn_cast<ClassTemplateDecl>(Found)) {
4786         if (IsStructuralMatch(D, FoundTemplate)) {
4787           // The class templates structurally match; call it the same template.
4788           // FIXME: We may be filling in a forward declaration here. Handle
4789           // this case!
4790           Importer.Imported(D->getTemplatedDecl(),
4791                             FoundTemplate->getTemplatedDecl());
4792           return Importer.Imported(D, FoundTemplate);
4793         }
4794       }
4795 
4796       ConflictingDecls.push_back(FoundDecls[I]);
4797     }
4798 
4799     if (!ConflictingDecls.empty()) {
4800       Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4801                                          ConflictingDecls.data(),
4802                                          ConflictingDecls.size());
4803     }
4804 
4805     if (!Name)
4806       return nullptr;
4807   }
4808 
4809   CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4810 
4811   // Create the declaration that is being templated.
4812   // Create the declaration that is being templated.
4813   CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
4814         Importer.Import(DTemplated));
4815   if (!D2Templated)
4816     return nullptr;
4817 
4818   // Resolve possible cyclic import.
4819   if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4820     return AlreadyImported;
4821 
4822   // Create the class template declaration itself.
4823   TemplateParameterList *TemplateParams
4824     = ImportTemplateParameterList(D->getTemplateParameters());
4825   if (!TemplateParams)
4826     return nullptr;
4827 
4828   ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4829                                                     Loc, Name, TemplateParams,
4830                                                     D2Templated);
4831   D2Templated->setDescribedClassTemplate(D2);
4832 
4833   D2->setAccess(D->getAccess());
4834   D2->setLexicalDeclContext(LexicalDC);
4835   LexicalDC->addDeclInternal(D2);
4836 
4837   // Note the relationship between the class templates.
4838   Importer.Imported(D, D2);
4839   Importer.Imported(DTemplated, D2Templated);
4840 
4841   if (DTemplated->isCompleteDefinition() &&
4842       !D2Templated->isCompleteDefinition()) {
4843     // FIXME: Import definition!
4844   }
4845 
4846   return D2;
4847 }
4848 
4849 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4850                                           ClassTemplateSpecializationDecl *D) {
4851   // If this record has a definition in the translation unit we're coming from,
4852   // but this particular declaration is not that definition, import the
4853   // definition and map to that.
4854   TagDecl *Definition = D->getDefinition();
4855   if (Definition && Definition != D) {
4856     Decl *ImportedDef = Importer.Import(Definition);
4857     if (!ImportedDef)
4858       return nullptr;
4859 
4860     return Importer.Imported(D, ImportedDef);
4861   }
4862 
4863   ClassTemplateDecl *ClassTemplate
4864     = cast_or_null<ClassTemplateDecl>(Importer.Import(
4865                                                  D->getSpecializedTemplate()));
4866   if (!ClassTemplate)
4867     return nullptr;
4868 
4869   // Import the context of this declaration.
4870   DeclContext *DC = ClassTemplate->getDeclContext();
4871   if (!DC)
4872     return nullptr;
4873 
4874   DeclContext *LexicalDC = DC;
4875   if (D->getDeclContext() != D->getLexicalDeclContext()) {
4876     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4877     if (!LexicalDC)
4878       return nullptr;
4879   }
4880 
4881   // Import the location of this declaration.
4882   SourceLocation StartLoc = Importer.Import(D->getLocStart());
4883   SourceLocation IdLoc = Importer.Import(D->getLocation());
4884 
4885   // Import template arguments.
4886   SmallVector<TemplateArgument, 2> TemplateArgs;
4887   if (ImportTemplateArguments(D->getTemplateArgs().data(),
4888                               D->getTemplateArgs().size(),
4889                               TemplateArgs))
4890     return nullptr;
4891 
4892   // Try to find an existing specialization with these template arguments.
4893   void *InsertPos = nullptr;
4894   ClassTemplateSpecializationDecl *D2
4895     = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4896   if (D2) {
4897     // We already have a class template specialization with these template
4898     // arguments.
4899 
4900     // FIXME: Check for specialization vs. instantiation errors.
4901 
4902     if (RecordDecl *FoundDef = D2->getDefinition()) {
4903       if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4904         // The record types structurally match, or the "from" translation
4905         // unit only had a forward declaration anyway; call it the same
4906         // function.
4907         return Importer.Imported(D, FoundDef);
4908       }
4909     }
4910   } else {
4911     // Create a new specialization.
4912     if (ClassTemplatePartialSpecializationDecl *PartialSpec =
4913         dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4914 
4915       // Import TemplateArgumentListInfo
4916       TemplateArgumentListInfo ToTAInfo;
4917       auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4918       for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) {
4919         bool Error = false;
4920         auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I], Error);
4921         if (Error)
4922           return nullptr;
4923         ToTAInfo.addArgument(ToLoc);
4924       }
4925 
4926       QualType CanonInjType = Importer.Import(
4927             PartialSpec->getInjectedSpecializationType());
4928       if (CanonInjType.isNull())
4929         return nullptr;
4930       CanonInjType = CanonInjType.getCanonicalType();
4931 
4932       TemplateParameterList *ToTPList = ImportTemplateParameterList(
4933             PartialSpec->getTemplateParameters());
4934       if (!ToTPList && PartialSpec->getTemplateParameters())
4935         return nullptr;
4936 
4937       D2 = ClassTemplatePartialSpecializationDecl::Create(
4938             Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc,
4939             ToTPList, ClassTemplate,
4940             llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4941             ToTAInfo, CanonInjType, nullptr);
4942 
4943     } else {
4944       D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4945                                                    D->getTagKind(), DC,
4946                                                    StartLoc, IdLoc,
4947                                                    ClassTemplate,
4948                                                    TemplateArgs,
4949                                                    /*PrevDecl=*/nullptr);
4950     }
4951 
4952     D2->setSpecializationKind(D->getSpecializationKind());
4953 
4954     // Add this specialization to the class template.
4955     ClassTemplate->AddSpecialization(D2, InsertPos);
4956 
4957     // Import the qualifier, if any.
4958     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4959 
4960     Importer.Imported(D, D2);
4961 
4962     if (auto *TSI = D->getTypeAsWritten()) {
4963       TypeSourceInfo *TInfo = Importer.Import(TSI);
4964       if (!TInfo)
4965         return nullptr;
4966       D2->setTypeAsWritten(TInfo);
4967       D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4968       D2->setExternLoc(Importer.Import(D->getExternLoc()));
4969     }
4970 
4971     SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4972     if (POI.isValid())
4973       D2->setPointOfInstantiation(POI);
4974     else if (D->getPointOfInstantiation().isValid())
4975       return nullptr;
4976 
4977     D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4978 
4979     // Add the specialization to this context.
4980     D2->setLexicalDeclContext(LexicalDC);
4981     LexicalDC->addDeclInternal(D2);
4982   }
4983   Importer.Imported(D, D2);
4984   if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4985     return nullptr;
4986 
4987   return D2;
4988 }
4989 
4990 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4991   // If this variable has a definition in the translation unit we're coming
4992   // from,
4993   // but this particular declaration is not that definition, import the
4994   // definition and map to that.
4995   VarDecl *Definition =
4996       cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4997   if (Definition && Definition != D->getTemplatedDecl()) {
4998     Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4999     if (!ImportedDef)
5000       return nullptr;
5001 
5002     return Importer.Imported(D, ImportedDef);
5003   }
5004 
5005   // Import the major distinguishing characteristics of this variable template.
5006   DeclContext *DC, *LexicalDC;
5007   DeclarationName Name;
5008   SourceLocation Loc;
5009   NamedDecl *ToD;
5010   if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5011     return nullptr;
5012   if (ToD)
5013     return ToD;
5014 
5015   // We may already have a template of the same name; try to find and match it.
5016   assert(!DC->isFunctionOrMethod() &&
5017          "Variable templates cannot be declared at function scope");
5018   SmallVector<NamedDecl *, 4> ConflictingDecls;
5019   SmallVector<NamedDecl *, 2> FoundDecls;
5020   DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
5021   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
5022     if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5023       continue;
5024 
5025     Decl *Found = FoundDecls[I];
5026     if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
5027       if (IsStructuralMatch(D, FoundTemplate)) {
5028         // The variable templates structurally match; call it the same template.
5029         Importer.Imported(D->getTemplatedDecl(),
5030                           FoundTemplate->getTemplatedDecl());
5031         return Importer.Imported(D, FoundTemplate);
5032       }
5033     }
5034 
5035     ConflictingDecls.push_back(FoundDecls[I]);
5036   }
5037 
5038   if (!ConflictingDecls.empty()) {
5039     Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
5040                                        ConflictingDecls.data(),
5041                                        ConflictingDecls.size());
5042   }
5043 
5044   if (!Name)
5045     return nullptr;
5046 
5047   VarDecl *DTemplated = D->getTemplatedDecl();
5048 
5049   // Import the type.
5050   QualType T = Importer.Import(DTemplated->getType());
5051   if (T.isNull())
5052     return nullptr;
5053 
5054   // Create the declaration that is being templated.
5055   SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
5056   SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
5057   TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
5058   VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
5059                                          IdLoc, Name.getAsIdentifierInfo(), T,
5060                                          TInfo, DTemplated->getStorageClass());
5061   D2Templated->setAccess(DTemplated->getAccess());
5062   D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
5063   D2Templated->setLexicalDeclContext(LexicalDC);
5064 
5065   // Importer.Imported(DTemplated, D2Templated);
5066   // LexicalDC->addDeclInternal(D2Templated);
5067 
5068   // Merge the initializer.
5069   if (ImportDefinition(DTemplated, D2Templated))
5070     return nullptr;
5071 
5072   // Create the variable template declaration itself.
5073   TemplateParameterList *TemplateParams =
5074       ImportTemplateParameterList(D->getTemplateParameters());
5075   if (!TemplateParams)
5076     return nullptr;
5077 
5078   VarTemplateDecl *D2 = VarTemplateDecl::Create(
5079       Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
5080   D2Templated->setDescribedVarTemplate(D2);
5081 
5082   D2->setAccess(D->getAccess());
5083   D2->setLexicalDeclContext(LexicalDC);
5084   LexicalDC->addDeclInternal(D2);
5085 
5086   // Note the relationship between the variable templates.
5087   Importer.Imported(D, D2);
5088   Importer.Imported(DTemplated, D2Templated);
5089 
5090   if (DTemplated->isThisDeclarationADefinition() &&
5091       !D2Templated->isThisDeclarationADefinition()) {
5092     // FIXME: Import definition!
5093   }
5094 
5095   return D2;
5096 }
5097 
5098 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5099     VarTemplateSpecializationDecl *D) {
5100   // If this record has a definition in the translation unit we're coming from,
5101   // but this particular declaration is not that definition, import the
5102   // definition and map to that.
5103   VarDecl *Definition = D->getDefinition();
5104   if (Definition && Definition != D) {
5105     Decl *ImportedDef = Importer.Import(Definition);
5106     if (!ImportedDef)
5107       return nullptr;
5108 
5109     return Importer.Imported(D, ImportedDef);
5110   }
5111 
5112   VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
5113       Importer.Import(D->getSpecializedTemplate()));
5114   if (!VarTemplate)
5115     return nullptr;
5116 
5117   // Import the context of this declaration.
5118   DeclContext *DC = VarTemplate->getDeclContext();
5119   if (!DC)
5120     return nullptr;
5121 
5122   DeclContext *LexicalDC = DC;
5123   if (D->getDeclContext() != D->getLexicalDeclContext()) {
5124     LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
5125     if (!LexicalDC)
5126       return nullptr;
5127   }
5128 
5129   // Import the location of this declaration.
5130   SourceLocation StartLoc = Importer.Import(D->getLocStart());
5131   SourceLocation IdLoc = Importer.Import(D->getLocation());
5132 
5133   // Import template arguments.
5134   SmallVector<TemplateArgument, 2> TemplateArgs;
5135   if (ImportTemplateArguments(D->getTemplateArgs().data(),
5136                               D->getTemplateArgs().size(), TemplateArgs))
5137     return nullptr;
5138 
5139   // Try to find an existing specialization with these template arguments.
5140   void *InsertPos = nullptr;
5141   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5142       TemplateArgs, InsertPos);
5143   if (D2) {
5144     // We already have a variable template specialization with these template
5145     // arguments.
5146 
5147     // FIXME: Check for specialization vs. instantiation errors.
5148 
5149     if (VarDecl *FoundDef = D2->getDefinition()) {
5150       if (!D->isThisDeclarationADefinition() ||
5151           IsStructuralMatch(D, FoundDef)) {
5152         // The record types structurally match, or the "from" translation
5153         // unit only had a forward declaration anyway; call it the same
5154         // variable.
5155         return Importer.Imported(D, FoundDef);
5156       }
5157     }
5158   } else {
5159 
5160     // Import the type.
5161     QualType T = Importer.Import(D->getType());
5162     if (T.isNull())
5163       return nullptr;
5164     TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
5165 
5166     // Create a new specialization.
5167     D2 = VarTemplateSpecializationDecl::Create(
5168         Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
5169         D->getStorageClass(), TemplateArgs);
5170     D2->setSpecializationKind(D->getSpecializationKind());
5171     D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
5172 
5173     // Add this specialization to the class template.
5174     VarTemplate->AddSpecialization(D2, InsertPos);
5175 
5176     // Import the qualifier, if any.
5177     D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
5178 
5179     // Add the specialization to this context.
5180     D2->setLexicalDeclContext(LexicalDC);
5181     LexicalDC->addDeclInternal(D2);
5182   }
5183   Importer.Imported(D, D2);
5184 
5185   if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
5186     return nullptr;
5187 
5188   return D2;
5189 }
5190 
5191 //----------------------------------------------------------------------------
5192 // Import Statements
5193 //----------------------------------------------------------------------------
5194 
5195 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
5196   if (DG.isNull())
5197     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
5198   size_t NumDecls = DG.end() - DG.begin();
5199   SmallVector<Decl *, 1> ToDecls(NumDecls);
5200   auto &_Importer = this->Importer;
5201   std::transform(DG.begin(), DG.end(), ToDecls.begin(),
5202     [&_Importer](Decl *D) -> Decl * {
5203       return _Importer.Import(D);
5204     });
5205   return DeclGroupRef::Create(Importer.getToContext(),
5206                               ToDecls.begin(),
5207                               NumDecls);
5208 }
5209 
5210  Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
5211    Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
5212      << S->getStmtClassName();
5213    return nullptr;
5214  }
5215 
5216 
5217 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5218   SmallVector<IdentifierInfo *, 4> Names;
5219   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5220     IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
5221     if (!ToII)
5222       return nullptr;
5223     Names.push_back(ToII);
5224   }
5225   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5226     IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
5227     if (!ToII)
5228       return nullptr;
5229     Names.push_back(ToII);
5230   }
5231 
5232   SmallVector<StringLiteral *, 4> Clobbers;
5233   for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
5234     StringLiteral *Clobber = cast_or_null<StringLiteral>(
5235           Importer.Import(S->getClobberStringLiteral(I)));
5236     if (!Clobber)
5237       return nullptr;
5238     Clobbers.push_back(Clobber);
5239   }
5240 
5241   SmallVector<StringLiteral *, 4> Constraints;
5242   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5243     StringLiteral *Output = cast_or_null<StringLiteral>(
5244           Importer.Import(S->getOutputConstraintLiteral(I)));
5245     if (!Output)
5246       return nullptr;
5247     Constraints.push_back(Output);
5248   }
5249 
5250   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5251     StringLiteral *Input = cast_or_null<StringLiteral>(
5252           Importer.Import(S->getInputConstraintLiteral(I)));
5253     if (!Input)
5254       return nullptr;
5255     Constraints.push_back(Input);
5256   }
5257 
5258   SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
5259   if (ImportContainerChecked(S->outputs(), Exprs))
5260     return nullptr;
5261 
5262   if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
5263     return nullptr;
5264 
5265   StringLiteral *AsmStr = cast_or_null<StringLiteral>(
5266         Importer.Import(S->getAsmString()));
5267   if (!AsmStr)
5268     return nullptr;
5269 
5270   return new (Importer.getToContext()) GCCAsmStmt(
5271         Importer.getToContext(),
5272         Importer.Import(S->getAsmLoc()),
5273         S->isSimple(),
5274         S->isVolatile(),
5275         S->getNumOutputs(),
5276         S->getNumInputs(),
5277         Names.data(),
5278         Constraints.data(),
5279         Exprs.data(),
5280         AsmStr,
5281         S->getNumClobbers(),
5282         Clobbers.data(),
5283         Importer.Import(S->getRParenLoc()));
5284 }
5285 
5286 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
5287   DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
5288   for (Decl *ToD : ToDG) {
5289     if (!ToD)
5290       return nullptr;
5291   }
5292   SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
5293   SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5294   return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5295 }
5296 
5297 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5298   SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5299   return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5300                                                 S->hasLeadingEmptyMacro());
5301 }
5302 
5303 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5304   llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
5305 
5306   if (ImportContainerChecked(S->body(), ToStmts))
5307     return nullptr;
5308 
5309   SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5310   SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5311   return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
5312                                                     ToStmts,
5313                                                     ToLBraceLoc, ToRBraceLoc);
5314 }
5315 
5316 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5317   Expr *ToLHS = Importer.Import(S->getLHS());
5318   if (!ToLHS)
5319     return nullptr;
5320   Expr *ToRHS = Importer.Import(S->getRHS());
5321   if (!ToRHS && S->getRHS())
5322     return nullptr;
5323   SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5324   SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5325   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5326   return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
5327                                                 ToCaseLoc, ToEllipsisLoc,
5328                                                 ToColonLoc);
5329 }
5330 
5331 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5332   SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5333   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5334   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5335   if (!ToSubStmt && S->getSubStmt())
5336     return nullptr;
5337   return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5338                                                    ToSubStmt);
5339 }
5340 
5341 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5342   SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5343   LabelDecl *ToLabelDecl =
5344     cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5345   if (!ToLabelDecl && S->getDecl())
5346     return nullptr;
5347   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5348   if (!ToSubStmt && S->getSubStmt())
5349     return nullptr;
5350   return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5351                                                  ToSubStmt);
5352 }
5353 
5354 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5355   SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5356   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5357   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5358   ASTContext &_ToContext = Importer.getToContext();
5359   std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
5360     [&_ToContext](const Attr *A) -> const Attr * {
5361       return A->clone(_ToContext);
5362     });
5363   for (const Attr *ToA : ToAttrs) {
5364     if (!ToA)
5365       return nullptr;
5366   }
5367   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5368   if (!ToSubStmt && S->getSubStmt())
5369     return nullptr;
5370   return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5371                                 ToAttrs, ToSubStmt);
5372 }
5373 
5374 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5375   SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5376   Stmt *ToInit = Importer.Import(S->getInit());
5377   if (!ToInit && S->getInit())
5378     return nullptr;
5379   VarDecl *ToConditionVariable = nullptr;
5380   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5381     ToConditionVariable =
5382       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5383     if (!ToConditionVariable)
5384       return nullptr;
5385   }
5386   Expr *ToCondition = Importer.Import(S->getCond());
5387   if (!ToCondition && S->getCond())
5388     return nullptr;
5389   Stmt *ToThenStmt = Importer.Import(S->getThen());
5390   if (!ToThenStmt && S->getThen())
5391     return nullptr;
5392   SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5393   Stmt *ToElseStmt = Importer.Import(S->getElse());
5394   if (!ToElseStmt && S->getElse())
5395     return nullptr;
5396   return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5397                                               ToIfLoc, S->isConstexpr(),
5398                                               ToInit,
5399                                               ToConditionVariable,
5400                                               ToCondition, ToThenStmt,
5401                                               ToElseLoc, ToElseStmt);
5402 }
5403 
5404 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5405   Stmt *ToInit = Importer.Import(S->getInit());
5406   if (!ToInit && S->getInit())
5407     return nullptr;
5408   VarDecl *ToConditionVariable = nullptr;
5409   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5410     ToConditionVariable =
5411       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5412     if (!ToConditionVariable)
5413       return nullptr;
5414   }
5415   Expr *ToCondition = Importer.Import(S->getCond());
5416   if (!ToCondition && S->getCond())
5417     return nullptr;
5418   SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
5419                          Importer.getToContext(), ToInit,
5420                          ToConditionVariable, ToCondition);
5421   Stmt *ToBody = Importer.Import(S->getBody());
5422   if (!ToBody && S->getBody())
5423     return nullptr;
5424   ToStmt->setBody(ToBody);
5425   ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5426   // Now we have to re-chain the cases.
5427   SwitchCase *LastChainedSwitchCase = nullptr;
5428   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5429        SC = SC->getNextSwitchCase()) {
5430     SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5431     if (!ToSC)
5432       return nullptr;
5433     if (LastChainedSwitchCase)
5434       LastChainedSwitchCase->setNextSwitchCase(ToSC);
5435     else
5436       ToStmt->setSwitchCaseList(ToSC);
5437     LastChainedSwitchCase = ToSC;
5438   }
5439   return ToStmt;
5440 }
5441 
5442 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5443   VarDecl *ToConditionVariable = nullptr;
5444   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5445     ToConditionVariable =
5446       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5447     if (!ToConditionVariable)
5448       return nullptr;
5449   }
5450   Expr *ToCondition = Importer.Import(S->getCond());
5451   if (!ToCondition && S->getCond())
5452     return nullptr;
5453   Stmt *ToBody = Importer.Import(S->getBody());
5454   if (!ToBody && S->getBody())
5455     return nullptr;
5456   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5457   return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5458                                                  ToConditionVariable,
5459                                                  ToCondition, ToBody,
5460                                                  ToWhileLoc);
5461 }
5462 
5463 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5464   Stmt *ToBody = Importer.Import(S->getBody());
5465   if (!ToBody && S->getBody())
5466     return nullptr;
5467   Expr *ToCondition = Importer.Import(S->getCond());
5468   if (!ToCondition && S->getCond())
5469     return nullptr;
5470   SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5471   SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5472   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5473   return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5474                                               ToDoLoc, ToWhileLoc,
5475                                               ToRParenLoc);
5476 }
5477 
5478 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5479   Stmt *ToInit = Importer.Import(S->getInit());
5480   if (!ToInit && S->getInit())
5481     return nullptr;
5482   Expr *ToCondition = Importer.Import(S->getCond());
5483   if (!ToCondition && S->getCond())
5484     return nullptr;
5485   VarDecl *ToConditionVariable = nullptr;
5486   if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5487     ToConditionVariable =
5488       dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5489     if (!ToConditionVariable)
5490       return nullptr;
5491   }
5492   Expr *ToInc = Importer.Import(S->getInc());
5493   if (!ToInc && S->getInc())
5494     return nullptr;
5495   Stmt *ToBody = Importer.Import(S->getBody());
5496   if (!ToBody && S->getBody())
5497     return nullptr;
5498   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5499   SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5500   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5501   return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5502                                                ToInit, ToCondition,
5503                                                ToConditionVariable,
5504                                                ToInc, ToBody,
5505                                                ToForLoc, ToLParenLoc,
5506                                                ToRParenLoc);
5507 }
5508 
5509 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5510   LabelDecl *ToLabel = nullptr;
5511   if (LabelDecl *FromLabel = S->getLabel()) {
5512     ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5513     if (!ToLabel)
5514       return nullptr;
5515   }
5516   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5517   SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5518   return new (Importer.getToContext()) GotoStmt(ToLabel,
5519                                                 ToGotoLoc, ToLabelLoc);
5520 }
5521 
5522 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5523   SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5524   SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5525   Expr *ToTarget = Importer.Import(S->getTarget());
5526   if (!ToTarget && S->getTarget())
5527     return nullptr;
5528   return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5529                                                         ToTarget);
5530 }
5531 
5532 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5533   SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5534   return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5535 }
5536 
5537 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5538   SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5539   return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5540 }
5541 
5542 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5543   SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5544   Expr *ToRetExpr = Importer.Import(S->getRetValue());
5545   if (!ToRetExpr && S->getRetValue())
5546     return nullptr;
5547   VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
5548   VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5549   if (!ToNRVOCandidate && NRVOCandidate)
5550     return nullptr;
5551   return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5552                                                   ToNRVOCandidate);
5553 }
5554 
5555 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5556   SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5557   VarDecl *ToExceptionDecl = nullptr;
5558   if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5559     ToExceptionDecl =
5560       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5561     if (!ToExceptionDecl)
5562       return nullptr;
5563   }
5564   Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5565   if (!ToHandlerBlock && S->getHandlerBlock())
5566     return nullptr;
5567   return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5568                                                     ToExceptionDecl,
5569                                                     ToHandlerBlock);
5570 }
5571 
5572 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5573   SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5574   Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5575   if (!ToTryBlock && S->getTryBlock())
5576     return nullptr;
5577   SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5578   for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5579     CXXCatchStmt *FromHandler = S->getHandler(HI);
5580     if (Stmt *ToHandler = Importer.Import(FromHandler))
5581       ToHandlers[HI] = ToHandler;
5582     else
5583       return nullptr;
5584   }
5585   return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5586                             ToHandlers);
5587 }
5588 
5589 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5590   DeclStmt *ToRange =
5591     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5592   if (!ToRange && S->getRangeStmt())
5593     return nullptr;
5594   DeclStmt *ToBegin =
5595     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5596   if (!ToBegin && S->getBeginStmt())
5597     return nullptr;
5598   DeclStmt *ToEnd =
5599     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5600   if (!ToEnd && S->getEndStmt())
5601     return nullptr;
5602   Expr *ToCond = Importer.Import(S->getCond());
5603   if (!ToCond && S->getCond())
5604     return nullptr;
5605   Expr *ToInc = Importer.Import(S->getInc());
5606   if (!ToInc && S->getInc())
5607     return nullptr;
5608   DeclStmt *ToLoopVar =
5609     dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5610   if (!ToLoopVar && S->getLoopVarStmt())
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 ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5617   SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5618   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5619   return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5620                                                        ToCond, ToInc,
5621                                                        ToLoopVar, ToBody,
5622                                                        ToForLoc, ToCoawaitLoc,
5623                                                        ToColonLoc, ToRParenLoc);
5624 }
5625 
5626 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5627   Stmt *ToElem = Importer.Import(S->getElement());
5628   if (!ToElem && S->getElement())
5629     return nullptr;
5630   Expr *ToCollect = Importer.Import(S->getCollection());
5631   if (!ToCollect && S->getCollection())
5632     return nullptr;
5633   Stmt *ToBody = Importer.Import(S->getBody());
5634   if (!ToBody && S->getBody())
5635     return nullptr;
5636   SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5637   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5638   return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5639                                                              ToCollect,
5640                                                              ToBody, ToForLoc,
5641                                                              ToRParenLoc);
5642 }
5643 
5644 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5645   SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5646   SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5647   VarDecl *ToExceptionDecl = nullptr;
5648   if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5649     ToExceptionDecl =
5650       dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5651     if (!ToExceptionDecl)
5652       return nullptr;
5653   }
5654   Stmt *ToBody = Importer.Import(S->getCatchBody());
5655   if (!ToBody && S->getCatchBody())
5656     return nullptr;
5657   return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5658                                                        ToRParenLoc,
5659                                                        ToExceptionDecl,
5660                                                        ToBody);
5661 }
5662 
5663 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5664   SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5665   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5666   if (!ToAtFinallyStmt && S->getFinallyBody())
5667     return nullptr;
5668   return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5669                                                          ToAtFinallyStmt);
5670 }
5671 
5672 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5673   SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5674   Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5675   if (!ToAtTryStmt && S->getTryBody())
5676     return nullptr;
5677   SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5678   for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5679     ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5680     if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5681       ToCatchStmts[CI] = ToCatchStmt;
5682     else
5683       return nullptr;
5684   }
5685   Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5686   if (!ToAtFinallyStmt && S->getFinallyStmt())
5687     return nullptr;
5688   return ObjCAtTryStmt::Create(Importer.getToContext(),
5689                                ToAtTryLoc, ToAtTryStmt,
5690                                ToCatchStmts.begin(), ToCatchStmts.size(),
5691                                ToAtFinallyStmt);
5692 }
5693 
5694 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5695   (ObjCAtSynchronizedStmt *S) {
5696   SourceLocation ToAtSynchronizedLoc =
5697     Importer.Import(S->getAtSynchronizedLoc());
5698   Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5699   if (!ToSynchExpr && S->getSynchExpr())
5700     return nullptr;
5701   Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5702   if (!ToSynchBody && S->getSynchBody())
5703     return nullptr;
5704   return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5705     ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5706 }
5707 
5708 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5709   SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5710   Expr *ToThrow = Importer.Import(S->getThrowExpr());
5711   if (!ToThrow && S->getThrowExpr())
5712     return nullptr;
5713   return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5714 }
5715 
5716 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5717   (ObjCAutoreleasePoolStmt *S) {
5718   SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5719   Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5720   if (!ToSubStmt && S->getSubStmt())
5721     return nullptr;
5722   return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5723                                                                ToSubStmt);
5724 }
5725 
5726 //----------------------------------------------------------------------------
5727 // Import Expressions
5728 //----------------------------------------------------------------------------
5729 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5730   Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5731     << E->getStmtClassName();
5732   return nullptr;
5733 }
5734 
5735 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5736   QualType T = Importer.Import(E->getType());
5737   if (T.isNull())
5738     return nullptr;
5739 
5740   Expr *SubExpr = Importer.Import(E->getSubExpr());
5741   if (!SubExpr && E->getSubExpr())
5742     return nullptr;
5743 
5744   TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5745   if (!TInfo)
5746     return nullptr;
5747 
5748   return new (Importer.getToContext()) VAArgExpr(
5749         Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5750         Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5751 }
5752 
5753 
5754 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5755   QualType T = Importer.Import(E->getType());
5756   if (T.isNull())
5757     return nullptr;
5758 
5759   return new (Importer.getToContext()) GNUNullExpr(
5760         T, Importer.Import(E->getLocStart()));
5761 }
5762 
5763 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5764   QualType T = Importer.Import(E->getType());
5765   if (T.isNull())
5766     return nullptr;
5767 
5768   StringLiteral *SL = cast_or_null<StringLiteral>(
5769         Importer.Import(E->getFunctionName()));
5770   if (!SL && E->getFunctionName())
5771     return nullptr;
5772 
5773   return new (Importer.getToContext()) PredefinedExpr(
5774         Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5775 }
5776 
5777 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5778   ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5779   if (!ToD)
5780     return nullptr;
5781 
5782   NamedDecl *FoundD = nullptr;
5783   if (E->getDecl() != E->getFoundDecl()) {
5784     FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5785     if (!FoundD)
5786       return nullptr;
5787   }
5788 
5789   QualType T = Importer.Import(E->getType());
5790   if (T.isNull())
5791     return nullptr;
5792 
5793 
5794   TemplateArgumentListInfo ToTAInfo;
5795   TemplateArgumentListInfo *ResInfo = nullptr;
5796   if (E->hasExplicitTemplateArgs()) {
5797     for (const auto &FromLoc : E->template_arguments()) {
5798       bool Error = false;
5799       TemplateArgumentLoc ToTALoc = ImportTemplateArgumentLoc(FromLoc, Error);
5800       if (Error)
5801         return nullptr;
5802       ToTAInfo.addArgument(ToTALoc);
5803     }
5804     ResInfo = &ToTAInfo;
5805   }
5806 
5807   DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5808                                          Importer.Import(E->getQualifierLoc()),
5809                                    Importer.Import(E->getTemplateKeywordLoc()),
5810                                          ToD,
5811                                         E->refersToEnclosingVariableOrCapture(),
5812                                          Importer.Import(E->getLocation()),
5813                                          T, E->getValueKind(),
5814                                          FoundD, ResInfo);
5815   if (E->hadMultipleCandidates())
5816     DRE->setHadMultipleCandidates(true);
5817   return DRE;
5818 }
5819 
5820 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5821   QualType T = Importer.Import(E->getType());
5822   if (T.isNull())
5823     return nullptr;
5824 
5825   return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5826 }
5827 
5828 ASTNodeImporter::Designator
5829 ASTNodeImporter::ImportDesignator(const Designator &D) {
5830   if (D.isFieldDesignator()) {
5831     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5832     // Caller checks for import error
5833     return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5834                       Importer.Import(D.getFieldLoc()));
5835   }
5836   if (D.isArrayDesignator())
5837     return Designator(D.getFirstExprIndex(),
5838                       Importer.Import(D.getLBracketLoc()),
5839                       Importer.Import(D.getRBracketLoc()));
5840 
5841   assert(D.isArrayRangeDesignator());
5842   return Designator(D.getFirstExprIndex(),
5843                     Importer.Import(D.getLBracketLoc()),
5844                     Importer.Import(D.getEllipsisLoc()),
5845                     Importer.Import(D.getRBracketLoc()));
5846 }
5847 
5848 
5849 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5850   Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5851   if (!Init)
5852     return nullptr;
5853 
5854   SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5855   // List elements from the second, the first is Init itself
5856   for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5857     if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5858       IndexExprs[I - 1] = Arg;
5859     else
5860       return nullptr;
5861   }
5862 
5863   SmallVector<Designator, 4> Designators(DIE->size());
5864   llvm::transform(DIE->designators(), Designators.begin(),
5865                   [this](const Designator &D) -> Designator {
5866                     return ImportDesignator(D);
5867                   });
5868 
5869   for (const Designator &D : DIE->designators())
5870     if (D.isFieldDesignator() && !D.getFieldName())
5871       return nullptr;
5872 
5873   return DesignatedInitExpr::Create(
5874         Importer.getToContext(), Designators,
5875         IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5876         DIE->usesGNUSyntax(), Init);
5877 }
5878 
5879 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5880   QualType T = Importer.Import(E->getType());
5881   if (T.isNull())
5882     return nullptr;
5883 
5884   return new (Importer.getToContext())
5885       CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5886 }
5887 
5888 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5889   QualType T = Importer.Import(E->getType());
5890   if (T.isNull())
5891     return nullptr;
5892 
5893   return IntegerLiteral::Create(Importer.getToContext(),
5894                                 E->getValue(), T,
5895                                 Importer.Import(E->getLocation()));
5896 }
5897 
5898 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5899   QualType T = Importer.Import(E->getType());
5900   if (T.isNull())
5901     return nullptr;
5902 
5903   return FloatingLiteral::Create(Importer.getToContext(),
5904                                 E->getValue(), E->isExact(), T,
5905                                 Importer.Import(E->getLocation()));
5906 }
5907 
5908 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5909   QualType T = Importer.Import(E->getType());
5910   if (T.isNull())
5911     return nullptr;
5912 
5913   return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5914                                                         E->getKind(), T,
5915                                           Importer.Import(E->getLocation()));
5916 }
5917 
5918 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5919   QualType T = Importer.Import(E->getType());
5920   if (T.isNull())
5921     return nullptr;
5922 
5923   SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5924   ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5925 
5926   return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5927                                E->getKind(), E->isPascal(), T,
5928                                Locations.data(), Locations.size());
5929 }
5930 
5931 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5932   QualType T = Importer.Import(E->getType());
5933   if (T.isNull())
5934     return nullptr;
5935 
5936   TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5937   if (!TInfo)
5938     return nullptr;
5939 
5940   Expr *Init = Importer.Import(E->getInitializer());
5941   if (!Init)
5942     return nullptr;
5943 
5944   return new (Importer.getToContext()) CompoundLiteralExpr(
5945         Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5946         Init, E->isFileScope());
5947 }
5948 
5949 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5950   QualType T = Importer.Import(E->getType());
5951   if (T.isNull())
5952     return nullptr;
5953 
5954   SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5955   if (ImportArrayChecked(
5956         E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5957         Exprs.begin()))
5958     return nullptr;
5959 
5960   return new (Importer.getToContext()) AtomicExpr(
5961         Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5962         Importer.Import(E->getRParenLoc()));
5963 }
5964 
5965 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5966   QualType T = Importer.Import(E->getType());
5967   if (T.isNull())
5968     return nullptr;
5969 
5970   LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5971   if (!ToLabel)
5972     return nullptr;
5973 
5974   return new (Importer.getToContext()) AddrLabelExpr(
5975         Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5976         ToLabel, T);
5977 }
5978 
5979 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5980   Expr *SubExpr = Importer.Import(E->getSubExpr());
5981   if (!SubExpr)
5982     return nullptr;
5983 
5984   return new (Importer.getToContext())
5985                                   ParenExpr(Importer.Import(E->getLParen()),
5986                                             Importer.Import(E->getRParen()),
5987                                             SubExpr);
5988 }
5989 
5990 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5991   SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5992   if (ImportContainerChecked(E->exprs(), Exprs))
5993     return nullptr;
5994 
5995   return new (Importer.getToContext()) ParenListExpr(
5996         Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5997         Exprs, Importer.Import(E->getLParenLoc()));
5998 }
5999 
6000 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
6001   QualType T = Importer.Import(E->getType());
6002   if (T.isNull())
6003     return nullptr;
6004 
6005   CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
6006         Importer.Import(E->getSubStmt()));
6007   if (!ToSubStmt && E->getSubStmt())
6008     return nullptr;
6009 
6010   return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
6011         Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
6012 }
6013 
6014 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
6015   QualType T = Importer.Import(E->getType());
6016   if (T.isNull())
6017     return nullptr;
6018 
6019   Expr *SubExpr = Importer.Import(E->getSubExpr());
6020   if (!SubExpr)
6021     return nullptr;
6022 
6023   return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
6024                                                      T, E->getValueKind(),
6025                                                      E->getObjectKind(),
6026                                          Importer.Import(E->getOperatorLoc()));
6027 }
6028 
6029 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
6030                                             UnaryExprOrTypeTraitExpr *E) {
6031   QualType ResultType = Importer.Import(E->getType());
6032 
6033   if (E->isArgumentType()) {
6034     TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
6035     if (!TInfo)
6036       return nullptr;
6037 
6038     return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6039                                            TInfo, ResultType,
6040                                            Importer.Import(E->getOperatorLoc()),
6041                                            Importer.Import(E->getRParenLoc()));
6042   }
6043 
6044   Expr *SubExpr = Importer.Import(E->getArgumentExpr());
6045   if (!SubExpr)
6046     return nullptr;
6047 
6048   return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
6049                                           SubExpr, ResultType,
6050                                           Importer.Import(E->getOperatorLoc()),
6051                                           Importer.Import(E->getRParenLoc()));
6052 }
6053 
6054 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6055   QualType T = Importer.Import(E->getType());
6056   if (T.isNull())
6057     return nullptr;
6058 
6059   Expr *LHS = Importer.Import(E->getLHS());
6060   if (!LHS)
6061     return nullptr;
6062 
6063   Expr *RHS = Importer.Import(E->getRHS());
6064   if (!RHS)
6065     return nullptr;
6066 
6067   return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
6068                                                       T, E->getValueKind(),
6069                                                       E->getObjectKind(),
6070                                            Importer.Import(E->getOperatorLoc()),
6071                                                       E->isFPContractable());
6072 }
6073 
6074 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6075   QualType T = Importer.Import(E->getType());
6076   if (T.isNull())
6077     return nullptr;
6078 
6079   Expr *ToLHS = Importer.Import(E->getLHS());
6080   if (!ToLHS)
6081     return nullptr;
6082 
6083   Expr *ToRHS = Importer.Import(E->getRHS());
6084   if (!ToRHS)
6085     return nullptr;
6086 
6087   Expr *ToCond = Importer.Import(E->getCond());
6088   if (!ToCond)
6089     return nullptr;
6090 
6091   return new (Importer.getToContext()) ConditionalOperator(
6092         ToCond, Importer.Import(E->getQuestionLoc()),
6093         ToLHS, Importer.Import(E->getColonLoc()),
6094         ToRHS, T, E->getValueKind(), E->getObjectKind());
6095 }
6096 
6097 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
6098     BinaryConditionalOperator *E) {
6099   QualType T = Importer.Import(E->getType());
6100   if (T.isNull())
6101     return nullptr;
6102 
6103   Expr *Common = Importer.Import(E->getCommon());
6104   if (!Common)
6105     return nullptr;
6106 
6107   Expr *Cond = Importer.Import(E->getCond());
6108   if (!Cond)
6109     return nullptr;
6110 
6111   OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
6112         Importer.Import(E->getOpaqueValue()));
6113   if (!OpaqueValue)
6114     return nullptr;
6115 
6116   Expr *TrueExpr = Importer.Import(E->getTrueExpr());
6117   if (!TrueExpr)
6118     return nullptr;
6119 
6120   Expr *FalseExpr = Importer.Import(E->getFalseExpr());
6121   if (!FalseExpr)
6122     return nullptr;
6123 
6124   return new (Importer.getToContext()) BinaryConditionalOperator(
6125         Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
6126         Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
6127         T, E->getValueKind(), E->getObjectKind());
6128 }
6129 
6130 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
6131   QualType T = Importer.Import(E->getType());
6132   if (T.isNull())
6133     return nullptr;
6134 
6135   TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
6136   if (!ToQueried)
6137     return nullptr;
6138 
6139   Expr *Dim = Importer.Import(E->getDimensionExpression());
6140   if (!Dim && E->getDimensionExpression())
6141     return nullptr;
6142 
6143   return new (Importer.getToContext()) ArrayTypeTraitExpr(
6144         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6145         E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
6146 }
6147 
6148 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
6149   QualType T = Importer.Import(E->getType());
6150   if (T.isNull())
6151     return nullptr;
6152 
6153   Expr *ToQueried = Importer.Import(E->getQueriedExpression());
6154   if (!ToQueried)
6155     return nullptr;
6156 
6157   return new (Importer.getToContext()) ExpressionTraitExpr(
6158         Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
6159         E->getValue(), Importer.Import(E->getLocEnd()), T);
6160 }
6161 
6162 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
6163   QualType T = Importer.Import(E->getType());
6164   if (T.isNull())
6165     return nullptr;
6166 
6167   Expr *SourceExpr = Importer.Import(E->getSourceExpr());
6168   if (!SourceExpr && E->getSourceExpr())
6169     return nullptr;
6170 
6171   return new (Importer.getToContext()) OpaqueValueExpr(
6172         Importer.Import(E->getLocation()), T, E->getValueKind(),
6173         E->getObjectKind(), SourceExpr);
6174 }
6175 
6176 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
6177   QualType T = Importer.Import(E->getType());
6178   if (T.isNull())
6179     return nullptr;
6180 
6181   Expr *ToLHS = Importer.Import(E->getLHS());
6182   if (!ToLHS)
6183     return nullptr;
6184 
6185   Expr *ToRHS = Importer.Import(E->getRHS());
6186   if (!ToRHS)
6187     return nullptr;
6188 
6189   return new (Importer.getToContext()) ArraySubscriptExpr(
6190         ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
6191         Importer.Import(E->getRBracketLoc()));
6192 }
6193 
6194 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
6195   QualType T = Importer.Import(E->getType());
6196   if (T.isNull())
6197     return nullptr;
6198 
6199   QualType CompLHSType = Importer.Import(E->getComputationLHSType());
6200   if (CompLHSType.isNull())
6201     return nullptr;
6202 
6203   QualType CompResultType = Importer.Import(E->getComputationResultType());
6204   if (CompResultType.isNull())
6205     return nullptr;
6206 
6207   Expr *LHS = Importer.Import(E->getLHS());
6208   if (!LHS)
6209     return nullptr;
6210 
6211   Expr *RHS = Importer.Import(E->getRHS());
6212   if (!RHS)
6213     return nullptr;
6214 
6215   return new (Importer.getToContext())
6216                         CompoundAssignOperator(LHS, RHS, E->getOpcode(),
6217                                                T, E->getValueKind(),
6218                                                E->getObjectKind(),
6219                                                CompLHSType, CompResultType,
6220                                            Importer.Import(E->getOperatorLoc()),
6221                                                E->isFPContractable());
6222 }
6223 
6224 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
6225   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
6226     if (CXXBaseSpecifier *Spec = Importer.Import(*I))
6227       Path.push_back(Spec);
6228     else
6229       return true;
6230   }
6231   return false;
6232 }
6233 
6234 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
6235   QualType T = Importer.Import(E->getType());
6236   if (T.isNull())
6237     return nullptr;
6238 
6239   Expr *SubExpr = Importer.Import(E->getSubExpr());
6240   if (!SubExpr)
6241     return nullptr;
6242 
6243   CXXCastPath BasePath;
6244   if (ImportCastPath(E, BasePath))
6245     return nullptr;
6246 
6247   return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
6248                                   SubExpr, &BasePath, E->getValueKind());
6249 }
6250 
6251 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
6252   QualType T = Importer.Import(E->getType());
6253   if (T.isNull())
6254     return nullptr;
6255 
6256   Expr *SubExpr = Importer.Import(E->getSubExpr());
6257   if (!SubExpr)
6258     return nullptr;
6259 
6260   TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
6261   if (!TInfo && E->getTypeInfoAsWritten())
6262     return nullptr;
6263 
6264   CXXCastPath BasePath;
6265   if (ImportCastPath(E, BasePath))
6266     return nullptr;
6267 
6268   switch (E->getStmtClass()) {
6269   case Stmt::CStyleCastExprClass: {
6270     CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
6271     return CStyleCastExpr::Create(Importer.getToContext(), T,
6272                                   E->getValueKind(), E->getCastKind(),
6273                                   SubExpr, &BasePath, TInfo,
6274                                   Importer.Import(CCE->getLParenLoc()),
6275                                   Importer.Import(CCE->getRParenLoc()));
6276   }
6277 
6278   case Stmt::CXXFunctionalCastExprClass: {
6279     CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
6280     return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
6281                                          E->getValueKind(), TInfo,
6282                                          E->getCastKind(), SubExpr, &BasePath,
6283                                          Importer.Import(FCE->getLParenLoc()),
6284                                          Importer.Import(FCE->getRParenLoc()));
6285   }
6286 
6287   case Stmt::ObjCBridgedCastExprClass: {
6288       ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
6289       return new (Importer.getToContext()) ObjCBridgedCastExpr(
6290             Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
6291             E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
6292             TInfo, SubExpr);
6293   }
6294   default:
6295     break; // just fall through
6296   }
6297 
6298   CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
6299   SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
6300       RParenLoc = Importer.Import(Named->getRParenLoc());
6301   SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
6302 
6303   switch (E->getStmtClass()) {
6304   case Stmt::CXXStaticCastExprClass:
6305     return CXXStaticCastExpr::Create(Importer.getToContext(), T,
6306                                      E->getValueKind(), E->getCastKind(),
6307                                      SubExpr, &BasePath, TInfo,
6308                                      ExprLoc, RParenLoc, Brackets);
6309 
6310   case Stmt::CXXDynamicCastExprClass:
6311     return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6312                                       E->getValueKind(), E->getCastKind(),
6313                                       SubExpr, &BasePath, TInfo,
6314                                       ExprLoc, RParenLoc, Brackets);
6315 
6316   case Stmt::CXXReinterpretCastExprClass:
6317     return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6318                                           E->getValueKind(), E->getCastKind(),
6319                                           SubExpr, &BasePath, TInfo,
6320                                           ExprLoc, RParenLoc, Brackets);
6321 
6322   case Stmt::CXXConstCastExprClass:
6323     return CXXConstCastExpr::Create(Importer.getToContext(), T,
6324                                     E->getValueKind(), SubExpr, TInfo, ExprLoc,
6325                                     RParenLoc, Brackets);
6326   default:
6327     llvm_unreachable("Cast expression of unsupported type!");
6328     return nullptr;
6329   }
6330 }
6331 
6332 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6333   QualType T = Importer.Import(OE->getType());
6334   if (T.isNull())
6335     return nullptr;
6336 
6337   SmallVector<OffsetOfNode, 4> Nodes;
6338   for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6339     const OffsetOfNode &Node = OE->getComponent(I);
6340 
6341     switch (Node.getKind()) {
6342     case OffsetOfNode::Array:
6343       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6344                                    Node.getArrayExprIndex(),
6345                                    Importer.Import(Node.getLocEnd())));
6346       break;
6347 
6348     case OffsetOfNode::Base: {
6349       CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6350       if (!BS && Node.getBase())
6351         return nullptr;
6352       Nodes.push_back(OffsetOfNode(BS));
6353       break;
6354     }
6355     case OffsetOfNode::Field: {
6356       FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6357       if (!FD)
6358         return nullptr;
6359       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6360                                    Importer.Import(Node.getLocEnd())));
6361       break;
6362     }
6363     case OffsetOfNode::Identifier: {
6364       IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6365       if (!ToII)
6366         return nullptr;
6367       Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6368                                    Importer.Import(Node.getLocEnd())));
6369       break;
6370     }
6371     }
6372   }
6373 
6374   SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6375   for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6376     Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6377     if (!ToIndexExpr)
6378       return nullptr;
6379     Exprs[I] = ToIndexExpr;
6380   }
6381 
6382   TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6383   if (!TInfo && OE->getTypeSourceInfo())
6384     return nullptr;
6385 
6386   return OffsetOfExpr::Create(Importer.getToContext(), T,
6387                               Importer.Import(OE->getOperatorLoc()),
6388                               TInfo, Nodes, Exprs,
6389                               Importer.Import(OE->getRParenLoc()));
6390 }
6391 
6392 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6393   QualType T = Importer.Import(E->getType());
6394   if (T.isNull())
6395     return nullptr;
6396 
6397   Expr *Operand = Importer.Import(E->getOperand());
6398   if (!Operand)
6399     return nullptr;
6400 
6401   CanThrowResult CanThrow;
6402   if (E->isValueDependent())
6403     CanThrow = CT_Dependent;
6404   else
6405     CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6406 
6407   return new (Importer.getToContext()) CXXNoexceptExpr(
6408         T, Operand, CanThrow,
6409         Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6410 }
6411 
6412 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6413   QualType T = Importer.Import(E->getType());
6414   if (T.isNull())
6415     return nullptr;
6416 
6417   Expr *SubExpr = Importer.Import(E->getSubExpr());
6418   if (!SubExpr && E->getSubExpr())
6419     return nullptr;
6420 
6421   return new (Importer.getToContext()) CXXThrowExpr(
6422         SubExpr, T, Importer.Import(E->getThrowLoc()),
6423         E->isThrownVariableInScope());
6424 }
6425 
6426 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6427   ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
6428         Importer.Import(E->getParam()));
6429   if (!Param)
6430     return nullptr;
6431 
6432   return CXXDefaultArgExpr::Create(
6433         Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6434 }
6435 
6436 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6437   QualType T = Importer.Import(E->getType());
6438   if (T.isNull())
6439     return nullptr;
6440 
6441   TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6442   if (!TypeInfo)
6443     return nullptr;
6444 
6445   return new (Importer.getToContext()) CXXScalarValueInitExpr(
6446         T, TypeInfo, Importer.Import(E->getRParenLoc()));
6447 }
6448 
6449 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6450   Expr *SubExpr = Importer.Import(E->getSubExpr());
6451   if (!SubExpr)
6452     return nullptr;
6453 
6454   auto *Dtor = cast_or_null<CXXDestructorDecl>(
6455         Importer.Import(const_cast<CXXDestructorDecl *>(
6456                           E->getTemporary()->getDestructor())));
6457   if (!Dtor)
6458     return nullptr;
6459 
6460   ASTContext &ToCtx = Importer.getToContext();
6461   CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6462   return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6463 }
6464 
6465 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6466   QualType T = Importer.Import(CE->getType());
6467   if (T.isNull())
6468     return nullptr;
6469 
6470   SmallVector<Expr *, 8> Args(CE->getNumArgs());
6471   if (ImportContainerChecked(CE->arguments(), Args))
6472     return nullptr;
6473 
6474   auto *Ctor = cast_or_null<CXXConstructorDecl>(
6475         Importer.Import(CE->getConstructor()));
6476   if (!Ctor)
6477     return nullptr;
6478 
6479   return CXXTemporaryObjectExpr::Create(
6480         Importer.getToContext(), T,
6481         Importer.Import(CE->getLocStart()),
6482         Ctor,
6483         CE->isElidable(),
6484         Args,
6485         CE->hadMultipleCandidates(),
6486         CE->isListInitialization(),
6487         CE->isStdInitListInitialization(),
6488         CE->requiresZeroInitialization(),
6489         CE->getConstructionKind(),
6490         Importer.Import(CE->getParenOrBraceRange()));
6491 }
6492 
6493 Expr *
6494 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6495   QualType T = Importer.Import(E->getType());
6496   if (T.isNull())
6497     return nullptr;
6498 
6499   Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6500   if (!TempE)
6501     return nullptr;
6502 
6503   ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
6504         Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6505   if (!ExtendedBy && E->getExtendingDecl())
6506     return nullptr;
6507 
6508   auto *ToMTE =  new (Importer.getToContext()) MaterializeTemporaryExpr(
6509         T, TempE, E->isBoundToLvalueReference());
6510 
6511   // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6512   ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6513   return ToMTE;
6514 }
6515 
6516 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6517   QualType T = Importer.Import(CE->getType());
6518   if (T.isNull())
6519     return nullptr;
6520 
6521   SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6522   if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6523     return nullptr;
6524 
6525   FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
6526         Importer.Import(CE->getOperatorNew()));
6527   if (!OperatorNewDecl && CE->getOperatorNew())
6528     return nullptr;
6529 
6530   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6531         Importer.Import(CE->getOperatorDelete()));
6532   if (!OperatorDeleteDecl && CE->getOperatorDelete())
6533     return nullptr;
6534 
6535   Expr *ToInit = Importer.Import(CE->getInitializer());
6536   if (!ToInit && CE->getInitializer())
6537     return nullptr;
6538 
6539   TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6540   if (!TInfo)
6541     return nullptr;
6542 
6543   Expr *ToArrSize = Importer.Import(CE->getArraySize());
6544   if (!ToArrSize && CE->getArraySize())
6545     return nullptr;
6546 
6547   return new (Importer.getToContext()) CXXNewExpr(
6548         Importer.getToContext(),
6549         CE->isGlobalNew(),
6550         OperatorNewDecl, OperatorDeleteDecl,
6551         CE->passAlignment(),
6552         CE->doesUsualArrayDeleteWantSize(),
6553         PlacementArgs,
6554         Importer.Import(CE->getTypeIdParens()),
6555         ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6556         Importer.Import(CE->getSourceRange()),
6557         Importer.Import(CE->getDirectInitRange()));
6558 }
6559 
6560 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6561   QualType T = Importer.Import(E->getType());
6562   if (T.isNull())
6563     return nullptr;
6564 
6565   FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6566         Importer.Import(E->getOperatorDelete()));
6567   if (!OperatorDeleteDecl && E->getOperatorDelete())
6568     return nullptr;
6569 
6570   Expr *ToArg = Importer.Import(E->getArgument());
6571   if (!ToArg && E->getArgument())
6572     return nullptr;
6573 
6574   return new (Importer.getToContext()) CXXDeleteExpr(
6575         T, E->isGlobalDelete(),
6576         E->isArrayForm(),
6577         E->isArrayFormAsWritten(),
6578         E->doesUsualArrayDeleteWantSize(),
6579         OperatorDeleteDecl,
6580         ToArg,
6581         Importer.Import(E->getLocStart()));
6582 }
6583 
6584 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6585   QualType T = Importer.Import(E->getType());
6586   if (T.isNull())
6587     return nullptr;
6588 
6589   CXXConstructorDecl *ToCCD =
6590     dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6591   if (!ToCCD)
6592     return nullptr;
6593 
6594   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6595   if (ImportContainerChecked(E->arguments(), ToArgs))
6596     return nullptr;
6597 
6598   return CXXConstructExpr::Create(Importer.getToContext(), T,
6599                                   Importer.Import(E->getLocation()),
6600                                   ToCCD, E->isElidable(),
6601                                   ToArgs, E->hadMultipleCandidates(),
6602                                   E->isListInitialization(),
6603                                   E->isStdInitListInitialization(),
6604                                   E->requiresZeroInitialization(),
6605                                   E->getConstructionKind(),
6606                                   Importer.Import(E->getParenOrBraceRange()));
6607 }
6608 
6609 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6610   Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6611   if (!SubExpr && EWC->getSubExpr())
6612     return nullptr;
6613 
6614   SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6615   for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6616     if (ExprWithCleanups::CleanupObject Obj =
6617         cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6618       Objs[I] = Obj;
6619     else
6620       return nullptr;
6621 
6622   return ExprWithCleanups::Create(Importer.getToContext(),
6623                                   SubExpr, EWC->cleanupsHaveSideEffects(),
6624                                   Objs);
6625 }
6626 
6627 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6628   QualType T = Importer.Import(E->getType());
6629   if (T.isNull())
6630     return nullptr;
6631 
6632   Expr *ToFn = Importer.Import(E->getCallee());
6633   if (!ToFn)
6634     return nullptr;
6635 
6636   SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6637   if (ImportContainerChecked(E->arguments(), ToArgs))
6638     return nullptr;
6639 
6640   return new (Importer.getToContext()) CXXMemberCallExpr(
6641         Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6642         Importer.Import(E->getRParenLoc()));
6643 }
6644 
6645 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6646   QualType T = Importer.Import(E->getType());
6647   if (T.isNull())
6648     return nullptr;
6649 
6650   return new (Importer.getToContext())
6651   CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6652 }
6653 
6654 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6655   QualType T = Importer.Import(E->getType());
6656   if (T.isNull())
6657     return nullptr;
6658 
6659   return new (Importer.getToContext())
6660   CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6661 }
6662 
6663 
6664 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6665   QualType T = Importer.Import(E->getType());
6666   if (T.isNull())
6667     return nullptr;
6668 
6669   Expr *ToBase = Importer.Import(E->getBase());
6670   if (!ToBase && E->getBase())
6671     return nullptr;
6672 
6673   ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6674   if (!ToMember && E->getMemberDecl())
6675     return nullptr;
6676 
6677   DeclAccessPair ToFoundDecl = DeclAccessPair::make(
6678     dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
6679     E->getFoundDecl().getAccess());
6680 
6681   DeclarationNameInfo ToMemberNameInfo(
6682     Importer.Import(E->getMemberNameInfo().getName()),
6683     Importer.Import(E->getMemberNameInfo().getLoc()));
6684 
6685   if (E->hasExplicitTemplateArgs()) {
6686     return nullptr; // FIXME: handle template arguments
6687   }
6688 
6689   return MemberExpr::Create(Importer.getToContext(), ToBase,
6690                             E->isArrow(),
6691                             Importer.Import(E->getOperatorLoc()),
6692                             Importer.Import(E->getQualifierLoc()),
6693                             Importer.Import(E->getTemplateKeywordLoc()),
6694                             ToMember, ToFoundDecl, ToMemberNameInfo,
6695                             nullptr, T, E->getValueKind(),
6696                             E->getObjectKind());
6697 }
6698 
6699 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6700   QualType T = Importer.Import(E->getType());
6701   if (T.isNull())
6702     return nullptr;
6703 
6704   Expr *ToCallee = Importer.Import(E->getCallee());
6705   if (!ToCallee && E->getCallee())
6706     return nullptr;
6707 
6708   unsigned NumArgs = E->getNumArgs();
6709 
6710   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
6711 
6712   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
6713     Expr *FromArg = E->getArg(ai);
6714     Expr *ToArg = Importer.Import(FromArg);
6715     if (!ToArg)
6716       return nullptr;
6717     ToArgs[ai] = ToArg;
6718   }
6719 
6720   Expr **ToArgs_Copied = new (Importer.getToContext())
6721     Expr*[NumArgs];
6722 
6723   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6724     ToArgs_Copied[ai] = ToArgs[ai];
6725 
6726   return new (Importer.getToContext())
6727     CallExpr(Importer.getToContext(), ToCallee,
6728              llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6729              Importer.Import(E->getRParenLoc()));
6730 }
6731 
6732 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6733   QualType T = Importer.Import(ILE->getType());
6734   if (T.isNull())
6735     return nullptr;
6736 
6737   llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6738   if (ImportContainerChecked(ILE->inits(), Exprs))
6739     return nullptr;
6740 
6741   ASTContext &ToCtx = Importer.getToContext();
6742   InitListExpr *To = new (ToCtx) InitListExpr(
6743         ToCtx, Importer.Import(ILE->getLBraceLoc()),
6744         Exprs, Importer.Import(ILE->getLBraceLoc()));
6745   To->setType(T);
6746 
6747   if (ILE->hasArrayFiller()) {
6748     Expr *Filler = Importer.Import(ILE->getArrayFiller());
6749     if (!Filler)
6750       return nullptr;
6751     To->setArrayFiller(Filler);
6752   }
6753 
6754   if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6755     FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6756     if (!ToFD)
6757       return nullptr;
6758     To->setInitializedFieldInUnion(ToFD);
6759   }
6760 
6761   if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6762     InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
6763           Importer.Import(SyntForm));
6764     if (!ToSyntForm)
6765       return nullptr;
6766     To->setSyntacticForm(ToSyntForm);
6767   }
6768 
6769   To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6770   To->setValueDependent(ILE->isValueDependent());
6771   To->setInstantiationDependent(ILE->isInstantiationDependent());
6772 
6773   return To;
6774 }
6775 
6776 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6777   QualType ToType = Importer.Import(E->getType());
6778   if (ToType.isNull())
6779     return nullptr;
6780 
6781   Expr *ToCommon = Importer.Import(E->getCommonExpr());
6782   if (!ToCommon && E->getCommonExpr())
6783     return nullptr;
6784 
6785   Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6786   if (!ToSubExpr && E->getSubExpr())
6787     return nullptr;
6788 
6789   return new (Importer.getToContext())
6790       ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6791 }
6792 
6793 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6794   QualType ToType = Importer.Import(E->getType());
6795   if (ToType.isNull())
6796     return nullptr;
6797   return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6798 }
6799 
6800 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
6801   FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
6802       Importer.Import(DIE->getField()));
6803   if (!ToField && DIE->getField())
6804     return nullptr;
6805 
6806   return CXXDefaultInitExpr::Create(
6807       Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6808 }
6809 
6810 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6811   QualType ToType = Importer.Import(E->getType());
6812   if (ToType.isNull() && !E->getType().isNull())
6813     return nullptr;
6814   ExprValueKind VK = E->getValueKind();
6815   CastKind CK = E->getCastKind();
6816   Expr *ToOp = Importer.Import(E->getSubExpr());
6817   if (!ToOp && E->getSubExpr())
6818     return nullptr;
6819   CXXCastPath BasePath;
6820   if (ImportCastPath(E, BasePath))
6821     return nullptr;
6822   TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6823   SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6824   SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6825   SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6826 
6827   if (isa<CXXStaticCastExpr>(E)) {
6828     return CXXStaticCastExpr::Create(
6829         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6830         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6831   } else if (isa<CXXDynamicCastExpr>(E)) {
6832     return CXXDynamicCastExpr::Create(
6833         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6834         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6835   } else if (isa<CXXReinterpretCastExpr>(E)) {
6836     return CXXReinterpretCastExpr::Create(
6837         Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6838         ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6839   } else {
6840     return nullptr;
6841   }
6842 }
6843 
6844 
6845 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6846     SubstNonTypeTemplateParmExpr *E) {
6847   QualType T = Importer.Import(E->getType());
6848   if (T.isNull())
6849     return nullptr;
6850 
6851   NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
6852         Importer.Import(E->getParameter()));
6853   if (!Param)
6854     return nullptr;
6855 
6856   Expr *Replacement = Importer.Import(E->getReplacement());
6857   if (!Replacement)
6858     return nullptr;
6859 
6860   return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6861         T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6862         Replacement);
6863 }
6864 
6865 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6866                          ASTContext &FromContext, FileManager &FromFileManager,
6867                          bool MinimalImport)
6868   : ToContext(ToContext), FromContext(FromContext),
6869     ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6870     Minimal(MinimalImport), LastDiagFromFrom(false)
6871 {
6872   ImportedDecls[FromContext.getTranslationUnitDecl()]
6873     = ToContext.getTranslationUnitDecl();
6874 }
6875 
6876 ASTImporter::~ASTImporter() { }
6877 
6878 QualType ASTImporter::Import(QualType FromT) {
6879   if (FromT.isNull())
6880     return QualType();
6881 
6882   const Type *fromTy = FromT.getTypePtr();
6883 
6884   // Check whether we've already imported this type.
6885   llvm::DenseMap<const Type *, const Type *>::iterator Pos
6886     = ImportedTypes.find(fromTy);
6887   if (Pos != ImportedTypes.end())
6888     return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6889 
6890   // Import the type
6891   ASTNodeImporter Importer(*this);
6892   QualType ToT = Importer.Visit(fromTy);
6893   if (ToT.isNull())
6894     return ToT;
6895 
6896   // Record the imported type.
6897   ImportedTypes[fromTy] = ToT.getTypePtr();
6898 
6899   return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6900 }
6901 
6902 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6903   if (!FromTSI)
6904     return FromTSI;
6905 
6906   // FIXME: For now we just create a "trivial" type source info based
6907   // on the type and a single location. Implement a real version of this.
6908   QualType T = Import(FromTSI->getType());
6909   if (T.isNull())
6910     return nullptr;
6911 
6912   return ToContext.getTrivialTypeSourceInfo(T,
6913            Import(FromTSI->getTypeLoc().getLocStart()));
6914 }
6915 
6916 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6917   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6918   if (Pos != ImportedDecls.end()) {
6919     Decl *ToD = Pos->second;
6920     ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6921     return ToD;
6922   } else {
6923     return nullptr;
6924   }
6925 }
6926 
6927 Decl *ASTImporter::Import(Decl *FromD) {
6928   if (!FromD)
6929     return nullptr;
6930 
6931   ASTNodeImporter Importer(*this);
6932 
6933   // Check whether we've already imported this declaration.
6934   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6935   if (Pos != ImportedDecls.end()) {
6936     Decl *ToD = Pos->second;
6937     Importer.ImportDefinitionIfNeeded(FromD, ToD);
6938     return ToD;
6939   }
6940 
6941   // Import the type
6942   Decl *ToD = Importer.Visit(FromD);
6943   if (!ToD)
6944     return nullptr;
6945 
6946   // Record the imported declaration.
6947   ImportedDecls[FromD] = ToD;
6948 
6949   if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6950     // Keep track of anonymous tags that have an associated typedef.
6951     if (FromTag->getTypedefNameForAnonDecl())
6952       AnonTagsWithPendingTypedefs.push_back(FromTag);
6953   } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6954     // When we've finished transforming a typedef, see whether it was the
6955     // typedef for an anonymous tag.
6956     for (SmallVectorImpl<TagDecl *>::iterator
6957                FromTag = AnonTagsWithPendingTypedefs.begin(),
6958             FromTagEnd = AnonTagsWithPendingTypedefs.end();
6959          FromTag != FromTagEnd; ++FromTag) {
6960       if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6961         if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6962           // We found the typedef for an anonymous tag; link them.
6963           ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6964           AnonTagsWithPendingTypedefs.erase(FromTag);
6965           break;
6966         }
6967       }
6968     }
6969   }
6970 
6971   return ToD;
6972 }
6973 
6974 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6975   if (!FromDC)
6976     return FromDC;
6977 
6978   DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6979   if (!ToDC)
6980     return nullptr;
6981 
6982   // When we're using a record/enum/Objective-C class/protocol as a context, we
6983   // need it to have a definition.
6984   if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6985     RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6986     if (ToRecord->isCompleteDefinition()) {
6987       // Do nothing.
6988     } else if (FromRecord->isCompleteDefinition()) {
6989       ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6990                                               ASTNodeImporter::IDK_Basic);
6991     } else {
6992       CompleteDecl(ToRecord);
6993     }
6994   } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
6995     EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
6996     if (ToEnum->isCompleteDefinition()) {
6997       // Do nothing.
6998     } else if (FromEnum->isCompleteDefinition()) {
6999       ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7000                                               ASTNodeImporter::IDK_Basic);
7001     } else {
7002       CompleteDecl(ToEnum);
7003     }
7004   } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7005     ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
7006     if (ToClass->getDefinition()) {
7007       // Do nothing.
7008     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7009       ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7010                                               ASTNodeImporter::IDK_Basic);
7011     } else {
7012       CompleteDecl(ToClass);
7013     }
7014   } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7015     ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
7016     if (ToProto->getDefinition()) {
7017       // Do nothing.
7018     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7019       ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7020                                               ASTNodeImporter::IDK_Basic);
7021     } else {
7022       CompleteDecl(ToProto);
7023     }
7024   }
7025 
7026   return ToDC;
7027 }
7028 
7029 Expr *ASTImporter::Import(Expr *FromE) {
7030   if (!FromE)
7031     return nullptr;
7032 
7033   return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7034 }
7035 
7036 Stmt *ASTImporter::Import(Stmt *FromS) {
7037   if (!FromS)
7038     return nullptr;
7039 
7040   // Check whether we've already imported this declaration.
7041   llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7042   if (Pos != ImportedStmts.end())
7043     return Pos->second;
7044 
7045   // Import the type
7046   ASTNodeImporter Importer(*this);
7047   Stmt *ToS = Importer.Visit(FromS);
7048   if (!ToS)
7049     return nullptr;
7050 
7051   // Record the imported declaration.
7052   ImportedStmts[FromS] = ToS;
7053   return ToS;
7054 }
7055 
7056 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7057   if (!FromNNS)
7058     return nullptr;
7059 
7060   NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7061 
7062   switch (FromNNS->getKind()) {
7063   case NestedNameSpecifier::Identifier:
7064     if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7065       return NestedNameSpecifier::Create(ToContext, prefix, II);
7066     }
7067     return nullptr;
7068 
7069   case NestedNameSpecifier::Namespace:
7070     if (NamespaceDecl *NS =
7071           cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7072       return NestedNameSpecifier::Create(ToContext, prefix, NS);
7073     }
7074     return nullptr;
7075 
7076   case NestedNameSpecifier::NamespaceAlias:
7077     if (NamespaceAliasDecl *NSAD =
7078           cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7079       return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7080     }
7081     return nullptr;
7082 
7083   case NestedNameSpecifier::Global:
7084     return NestedNameSpecifier::GlobalSpecifier(ToContext);
7085 
7086   case NestedNameSpecifier::Super:
7087     if (CXXRecordDecl *RD =
7088             cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7089       return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7090     }
7091     return nullptr;
7092 
7093   case NestedNameSpecifier::TypeSpec:
7094   case NestedNameSpecifier::TypeSpecWithTemplate: {
7095       QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7096       if (!T.isNull()) {
7097         bool bTemplate = FromNNS->getKind() ==
7098                          NestedNameSpecifier::TypeSpecWithTemplate;
7099         return NestedNameSpecifier::Create(ToContext, prefix,
7100                                            bTemplate, T.getTypePtr());
7101       }
7102     }
7103       return nullptr;
7104   }
7105 
7106   llvm_unreachable("Invalid nested name specifier kind");
7107 }
7108 
7109 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
7110   // Copied from NestedNameSpecifier mostly.
7111   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7112   NestedNameSpecifierLoc NNS = FromNNS;
7113 
7114   // Push each of the nested-name-specifiers's onto a stack for
7115   // serialization in reverse order.
7116   while (NNS) {
7117     NestedNames.push_back(NNS);
7118     NNS = NNS.getPrefix();
7119   }
7120 
7121   NestedNameSpecifierLocBuilder Builder;
7122 
7123   while (!NestedNames.empty()) {
7124     NNS = NestedNames.pop_back_val();
7125     NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7126     if (!Spec)
7127       return NestedNameSpecifierLoc();
7128 
7129     NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7130     switch (Kind) {
7131     case NestedNameSpecifier::Identifier:
7132       Builder.Extend(getToContext(),
7133                      Spec->getAsIdentifier(),
7134                      Import(NNS.getLocalBeginLoc()),
7135                      Import(NNS.getLocalEndLoc()));
7136       break;
7137 
7138     case NestedNameSpecifier::Namespace:
7139       Builder.Extend(getToContext(),
7140                      Spec->getAsNamespace(),
7141                      Import(NNS.getLocalBeginLoc()),
7142                      Import(NNS.getLocalEndLoc()));
7143       break;
7144 
7145     case NestedNameSpecifier::NamespaceAlias:
7146       Builder.Extend(getToContext(),
7147                      Spec->getAsNamespaceAlias(),
7148                      Import(NNS.getLocalBeginLoc()),
7149                      Import(NNS.getLocalEndLoc()));
7150       break;
7151 
7152     case NestedNameSpecifier::TypeSpec:
7153     case NestedNameSpecifier::TypeSpecWithTemplate: {
7154       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7155             QualType(Spec->getAsType(), 0));
7156       Builder.Extend(getToContext(),
7157                      Import(NNS.getLocalBeginLoc()),
7158                      TSI->getTypeLoc(),
7159                      Import(NNS.getLocalEndLoc()));
7160       break;
7161     }
7162 
7163     case NestedNameSpecifier::Global:
7164       Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7165       break;
7166 
7167     case NestedNameSpecifier::Super: {
7168       SourceRange ToRange = Import(NNS.getSourceRange());
7169       Builder.MakeSuper(getToContext(),
7170                         Spec->getAsRecordDecl(),
7171                         ToRange.getBegin(),
7172                         ToRange.getEnd());
7173     }
7174   }
7175   }
7176 
7177   return Builder.getWithLocInContext(getToContext());
7178 }
7179 
7180 TemplateName ASTImporter::Import(TemplateName From) {
7181   switch (From.getKind()) {
7182   case TemplateName::Template:
7183     if (TemplateDecl *ToTemplate
7184                 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7185       return TemplateName(ToTemplate);
7186 
7187     return TemplateName();
7188 
7189   case TemplateName::OverloadedTemplate: {
7190     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7191     UnresolvedSet<2> ToTemplates;
7192     for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
7193                                              E = FromStorage->end();
7194          I != E; ++I) {
7195       if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
7196         ToTemplates.addDecl(To);
7197       else
7198         return TemplateName();
7199     }
7200     return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7201                                                ToTemplates.end());
7202   }
7203 
7204   case TemplateName::QualifiedTemplate: {
7205     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7206     NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7207     if (!Qualifier)
7208       return TemplateName();
7209 
7210     if (TemplateDecl *ToTemplate
7211         = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7212       return ToContext.getQualifiedTemplateName(Qualifier,
7213                                                 QTN->hasTemplateKeyword(),
7214                                                 ToTemplate);
7215 
7216     return TemplateName();
7217   }
7218 
7219   case TemplateName::DependentTemplate: {
7220     DependentTemplateName *DTN = From.getAsDependentTemplateName();
7221     NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7222     if (!Qualifier)
7223       return TemplateName();
7224 
7225     if (DTN->isIdentifier()) {
7226       return ToContext.getDependentTemplateName(Qualifier,
7227                                                 Import(DTN->getIdentifier()));
7228     }
7229 
7230     return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7231   }
7232 
7233   case TemplateName::SubstTemplateTemplateParm: {
7234     SubstTemplateTemplateParmStorage *subst
7235       = From.getAsSubstTemplateTemplateParm();
7236     TemplateTemplateParmDecl *param
7237       = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7238     if (!param)
7239       return TemplateName();
7240 
7241     TemplateName replacement = Import(subst->getReplacement());
7242     if (replacement.isNull()) return TemplateName();
7243 
7244     return ToContext.getSubstTemplateTemplateParm(param, replacement);
7245   }
7246 
7247   case TemplateName::SubstTemplateTemplateParmPack: {
7248     SubstTemplateTemplateParmPackStorage *SubstPack
7249       = From.getAsSubstTemplateTemplateParmPack();
7250     TemplateTemplateParmDecl *Param
7251       = cast_or_null<TemplateTemplateParmDecl>(
7252                                         Import(SubstPack->getParameterPack()));
7253     if (!Param)
7254       return TemplateName();
7255 
7256     ASTNodeImporter Importer(*this);
7257     TemplateArgument ArgPack
7258       = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7259     if (ArgPack.isNull())
7260       return TemplateName();
7261 
7262     return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7263   }
7264   }
7265 
7266   llvm_unreachable("Invalid template name kind");
7267 }
7268 
7269 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7270   if (FromLoc.isInvalid())
7271     return SourceLocation();
7272 
7273   SourceManager &FromSM = FromContext.getSourceManager();
7274 
7275   // For now, map everything down to its file location, so that we
7276   // don't have to import macro expansions.
7277   // FIXME: Import macro expansions!
7278   FromLoc = FromSM.getFileLoc(FromLoc);
7279   std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7280   SourceManager &ToSM = ToContext.getSourceManager();
7281   FileID ToFileID = Import(Decomposed.first);
7282   if (ToFileID.isInvalid())
7283     return SourceLocation();
7284   SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
7285                            .getLocWithOffset(Decomposed.second);
7286   return ret;
7287 }
7288 
7289 SourceRange ASTImporter::Import(SourceRange FromRange) {
7290   return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7291 }
7292 
7293 FileID ASTImporter::Import(FileID FromID) {
7294   llvm::DenseMap<FileID, FileID>::iterator Pos
7295     = ImportedFileIDs.find(FromID);
7296   if (Pos != ImportedFileIDs.end())
7297     return Pos->second;
7298 
7299   SourceManager &FromSM = FromContext.getSourceManager();
7300   SourceManager &ToSM = ToContext.getSourceManager();
7301   const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7302   assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
7303 
7304   // Include location of this file.
7305   SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7306 
7307   // Map the FileID for to the "to" source manager.
7308   FileID ToID;
7309   const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7310   if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7311     // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7312     // disk again
7313     // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7314     // than mmap the files several times.
7315     const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
7316     if (!Entry)
7317       return FileID();
7318     ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7319                              FromSLoc.getFile().getFileCharacteristic());
7320   } else {
7321     // FIXME: We want to re-use the existing MemoryBuffer!
7322     const llvm::MemoryBuffer *
7323         FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7324     std::unique_ptr<llvm::MemoryBuffer> ToBuf
7325       = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7326                                              FromBuf->getBufferIdentifier());
7327     ToID = ToSM.createFileID(std::move(ToBuf),
7328                              FromSLoc.getFile().getFileCharacteristic());
7329   }
7330 
7331 
7332   ImportedFileIDs[FromID] = ToID;
7333   return ToID;
7334 }
7335 
7336 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7337   Expr *ToExpr = Import(From->getInit());
7338   if (!ToExpr && From->getInit())
7339     return nullptr;
7340 
7341   if (From->isBaseInitializer()) {
7342     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7343     if (!ToTInfo && From->getTypeSourceInfo())
7344       return nullptr;
7345 
7346     return new (ToContext) CXXCtorInitializer(
7347         ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7348         ToExpr, Import(From->getRParenLoc()),
7349         From->isPackExpansion() ? Import(From->getEllipsisLoc())
7350                                 : SourceLocation());
7351   } else if (From->isMemberInitializer()) {
7352     FieldDecl *ToField =
7353         llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
7354     if (!ToField && From->getMember())
7355       return nullptr;
7356 
7357     return new (ToContext) CXXCtorInitializer(
7358         ToContext, ToField, Import(From->getMemberLocation()),
7359         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7360   } else if (From->isIndirectMemberInitializer()) {
7361     IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
7362         Import(From->getIndirectMember()));
7363     if (!ToIField && From->getIndirectMember())
7364       return nullptr;
7365 
7366     return new (ToContext) CXXCtorInitializer(
7367         ToContext, ToIField, Import(From->getMemberLocation()),
7368         Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7369   } else if (From->isDelegatingInitializer()) {
7370     TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7371     if (!ToTInfo && From->getTypeSourceInfo())
7372       return nullptr;
7373 
7374     return new (ToContext)
7375         CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7376                            ToExpr, Import(From->getRParenLoc()));
7377   } else {
7378     return nullptr;
7379   }
7380 }
7381 
7382 
7383 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7384   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7385   if (Pos != ImportedCXXBaseSpecifiers.end())
7386     return Pos->second;
7387 
7388   CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7389         Import(BaseSpec->getSourceRange()),
7390         BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7391         BaseSpec->getAccessSpecifierAsWritten(),
7392         Import(BaseSpec->getTypeSourceInfo()),
7393         Import(BaseSpec->getEllipsisLoc()));
7394   ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7395   return Imported;
7396 }
7397 
7398 void ASTImporter::ImportDefinition(Decl *From) {
7399   Decl *To = Import(From);
7400   if (!To)
7401     return;
7402 
7403   if (DeclContext *FromDC = cast<DeclContext>(From)) {
7404     ASTNodeImporter Importer(*this);
7405 
7406     if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
7407       if (!ToRecord->getDefinition()) {
7408         Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7409                                   ASTNodeImporter::IDK_Everything);
7410         return;
7411       }
7412     }
7413 
7414     if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
7415       if (!ToEnum->getDefinition()) {
7416         Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7417                                   ASTNodeImporter::IDK_Everything);
7418         return;
7419       }
7420     }
7421 
7422     if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7423       if (!ToIFace->getDefinition()) {
7424         Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7425                                   ASTNodeImporter::IDK_Everything);
7426         return;
7427       }
7428     }
7429 
7430     if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7431       if (!ToProto->getDefinition()) {
7432         Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7433                                   ASTNodeImporter::IDK_Everything);
7434         return;
7435       }
7436     }
7437 
7438     Importer.ImportDeclContext(FromDC, true);
7439   }
7440 }
7441 
7442 DeclarationName ASTImporter::Import(DeclarationName FromName) {
7443   if (!FromName)
7444     return DeclarationName();
7445 
7446   switch (FromName.getNameKind()) {
7447   case DeclarationName::Identifier:
7448     return Import(FromName.getAsIdentifierInfo());
7449 
7450   case DeclarationName::ObjCZeroArgSelector:
7451   case DeclarationName::ObjCOneArgSelector:
7452   case DeclarationName::ObjCMultiArgSelector:
7453     return Import(FromName.getObjCSelector());
7454 
7455   case DeclarationName::CXXConstructorName: {
7456     QualType T = Import(FromName.getCXXNameType());
7457     if (T.isNull())
7458       return DeclarationName();
7459 
7460     return ToContext.DeclarationNames.getCXXConstructorName(
7461                                                ToContext.getCanonicalType(T));
7462   }
7463 
7464   case DeclarationName::CXXDestructorName: {
7465     QualType T = Import(FromName.getCXXNameType());
7466     if (T.isNull())
7467       return DeclarationName();
7468 
7469     return ToContext.DeclarationNames.getCXXDestructorName(
7470                                                ToContext.getCanonicalType(T));
7471   }
7472 
7473   case DeclarationName::CXXDeductionGuideName: {
7474     TemplateDecl *Template = cast_or_null<TemplateDecl>(
7475         Import(FromName.getCXXDeductionGuideTemplate()));
7476     if (!Template)
7477       return DeclarationName();
7478     return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7479   }
7480 
7481   case DeclarationName::CXXConversionFunctionName: {
7482     QualType T = Import(FromName.getCXXNameType());
7483     if (T.isNull())
7484       return DeclarationName();
7485 
7486     return ToContext.DeclarationNames.getCXXConversionFunctionName(
7487                                                ToContext.getCanonicalType(T));
7488   }
7489 
7490   case DeclarationName::CXXOperatorName:
7491     return ToContext.DeclarationNames.getCXXOperatorName(
7492                                           FromName.getCXXOverloadedOperator());
7493 
7494   case DeclarationName::CXXLiteralOperatorName:
7495     return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7496                                    Import(FromName.getCXXLiteralIdentifier()));
7497 
7498   case DeclarationName::CXXUsingDirective:
7499     // FIXME: STATICS!
7500     return DeclarationName::getUsingDirectiveName();
7501   }
7502 
7503   llvm_unreachable("Invalid DeclarationName Kind!");
7504 }
7505 
7506 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
7507   if (!FromId)
7508     return nullptr;
7509 
7510   IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7511 
7512   if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7513     ToId->setBuiltinID(FromId->getBuiltinID());
7514 
7515   return ToId;
7516 }
7517 
7518 Selector ASTImporter::Import(Selector FromSel) {
7519   if (FromSel.isNull())
7520     return Selector();
7521 
7522   SmallVector<IdentifierInfo *, 4> Idents;
7523   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7524   for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7525     Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7526   return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7527 }
7528 
7529 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7530                                                 DeclContext *DC,
7531                                                 unsigned IDNS,
7532                                                 NamedDecl **Decls,
7533                                                 unsigned NumDecls) {
7534   return Name;
7535 }
7536 
7537 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
7538   if (LastDiagFromFrom)
7539     ToContext.getDiagnostics().notePriorDiagnosticFrom(
7540       FromContext.getDiagnostics());
7541   LastDiagFromFrom = false;
7542   return ToContext.getDiagnostics().Report(Loc, DiagID);
7543 }
7544 
7545 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
7546   if (!LastDiagFromFrom)
7547     FromContext.getDiagnostics().notePriorDiagnosticFrom(
7548       ToContext.getDiagnostics());
7549   LastDiagFromFrom = true;
7550   return FromContext.getDiagnostics().Report(Loc, DiagID);
7551 }
7552 
7553 void ASTImporter::CompleteDecl (Decl *D) {
7554   if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7555     if (!ID->getDefinition())
7556       ID->startDefinition();
7557   }
7558   else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7559     if (!PD->getDefinition())
7560       PD->startDefinition();
7561   }
7562   else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
7563     if (!TD->getDefinition() && !TD->isBeingDefined()) {
7564       TD->startDefinition();
7565       TD->setCompleteDefinition(true);
7566     }
7567   }
7568   else {
7569     assert (0 && "CompleteDecl called on a Decl that can't be completed");
7570   }
7571 }
7572 
7573 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
7574   if (From->hasAttrs()) {
7575     for (Attr *FromAttr : From->getAttrs())
7576       To->addAttr(FromAttr->clone(To->getASTContext()));
7577   }
7578   if (From->isUsed()) {
7579     To->setIsUsed();
7580   }
7581   if (From->isImplicit()) {
7582     To->setImplicit();
7583   }
7584   ImportedDecls[From] = To;
7585   return To;
7586 }
7587 
7588 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7589                                            bool Complain) {
7590   llvm::DenseMap<const Type *, const Type *>::iterator Pos
7591    = ImportedTypes.find(From.getTypePtr());
7592   if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7593     return true;
7594 
7595   StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7596                                    false, Complain);
7597   return Ctx.IsStructurallyEquivalent(From, To);
7598 }
7599