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
27namespace 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 VisitBuiltinType(const BuiltinType *T);
43    QualType VisitComplexType(const ComplexType *T);
44    QualType VisitPointerType(const PointerType *T);
45    QualType VisitBlockPointerType(const BlockPointerType *T);
46    QualType VisitLValueReferenceType(const LValueReferenceType *T);
47    QualType VisitRValueReferenceType(const RValueReferenceType *T);
48    QualType VisitMemberPointerType(const MemberPointerType *T);
49    QualType VisitConstantArrayType(const ConstantArrayType *T);
50    QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
51    QualType VisitVariableArrayType(const VariableArrayType *T);
52    // FIXME: DependentSizedArrayType
53    // FIXME: DependentSizedExtVectorType
54    QualType VisitVectorType(const VectorType *T);
55    QualType VisitExtVectorType(const ExtVectorType *T);
56    QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
57    QualType VisitFunctionProtoType(const FunctionProtoType *T);
58    // FIXME: UnresolvedUsingType
59    QualType VisitParenType(const ParenType *T);
60    QualType VisitTypedefType(const TypedefType *T);
61    QualType VisitTypeOfExprType(const TypeOfExprType *T);
62    // FIXME: DependentTypeOfExprType
63    QualType VisitTypeOfType(const TypeOfType *T);
64    QualType VisitDecltypeType(const DecltypeType *T);
65    QualType VisitUnaryTransformType(const UnaryTransformType *T);
66    QualType VisitAutoType(const AutoType *T);
67    // FIXME: DependentDecltypeType
68    QualType VisitRecordType(const RecordType *T);
69    QualType VisitEnumType(const EnumType *T);
70    QualType VisitAttributedType(const AttributedType *T);
71    // FIXME: TemplateTypeParmType
72    // FIXME: SubstTemplateTypeParmType
73    QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
74    QualType VisitElaboratedType(const ElaboratedType *T);
75    // FIXME: DependentNameType
76    // FIXME: DependentTemplateSpecializationType
77    QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
78    QualType VisitObjCObjectType(const ObjCObjectType *T);
79    QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
80
81    // Importing declarations
82    bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
83                         DeclContext *&LexicalDC, DeclarationName &Name,
84                         SourceLocation &Loc);
85    void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
86    void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
87                                  DeclarationNameInfo& To);
88    void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
89
90    /// \brief What we should import from the definition.
91    enum ImportDefinitionKind {
92      /// \brief Import the default subset of the definition, which might be
93      /// nothing (if minimal import is set) or might be everything (if minimal
94      /// import is not set).
95      IDK_Default,
96      /// \brief Import everything.
97      IDK_Everything,
98      /// \brief Import only the bare bones needed to establish a valid
99      /// DeclContext.
100      IDK_Basic
101    };
102
103    bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
104      return IDK == IDK_Everything ||
105             (IDK == IDK_Default && !Importer.isMinimalImport());
106    }
107
108    bool ImportDefinition(RecordDecl *From, RecordDecl *To,
109                          ImportDefinitionKind Kind = IDK_Default);
110    bool ImportDefinition(VarDecl *From, VarDecl *To,
111                          ImportDefinitionKind Kind = IDK_Default);
112    bool ImportDefinition(EnumDecl *From, EnumDecl *To,
113                          ImportDefinitionKind Kind = IDK_Default);
114    bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
115                          ImportDefinitionKind Kind = IDK_Default);
116    bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
117                          ImportDefinitionKind Kind = IDK_Default);
118    TemplateParameterList *ImportTemplateParameterList(
119                                                 TemplateParameterList *Params);
120    TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
121    bool ImportTemplateArguments(const TemplateArgument *FromArgs,
122                                 unsigned NumFromArgs,
123                               SmallVectorImpl<TemplateArgument> &ToArgs);
124    bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
125                           bool Complain = true);
126    bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
127                           bool Complain = true);
128    bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
129    bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
130    bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
131    bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
132    Decl *VisitDecl(Decl *D);
133    Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
134    Decl *VisitNamespaceDecl(NamespaceDecl *D);
135    Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
136    Decl *VisitTypedefDecl(TypedefDecl *D);
137    Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
138    Decl *VisitEnumDecl(EnumDecl *D);
139    Decl *VisitRecordDecl(RecordDecl *D);
140    Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
141    Decl *VisitFunctionDecl(FunctionDecl *D);
142    Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
143    Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
144    Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
145    Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
146    Decl *VisitFieldDecl(FieldDecl *D);
147    Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
148    Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
149    Decl *VisitVarDecl(VarDecl *D);
150    Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
151    Decl *VisitParmVarDecl(ParmVarDecl *D);
152    Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
153    Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
154    Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
155    Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
156    Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
157    Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
158    Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
159    Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
160    Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
161    Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
162    Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
163    Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
164    Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
165    Decl *VisitClassTemplateSpecializationDecl(
166                                            ClassTemplateSpecializationDecl *D);
167    Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
168    Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
169
170    // Importing statements
171    Stmt *VisitStmt(Stmt *S);
172
173    // Importing expressions
174    Expr *VisitExpr(Expr *E);
175    Expr *VisitDeclRefExpr(DeclRefExpr *E);
176    Expr *VisitIntegerLiteral(IntegerLiteral *E);
177    Expr *VisitCharacterLiteral(CharacterLiteral *E);
178    Expr *VisitParenExpr(ParenExpr *E);
179    Expr *VisitUnaryOperator(UnaryOperator *E);
180    Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
181    Expr *VisitBinaryOperator(BinaryOperator *E);
182    Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
183    Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
184    Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
185  };
186}
187using namespace clang;
188
189//----------------------------------------------------------------------------
190// Structural Equivalence
191//----------------------------------------------------------------------------
192
193namespace {
194  struct StructuralEquivalenceContext {
195    /// \brief AST contexts for which we are checking structural equivalence.
196    ASTContext &C1, &C2;
197
198    /// \brief The set of "tentative" equivalences between two canonical
199    /// declarations, mapping from a declaration in the first context to the
200    /// declaration in the second context that we believe to be equivalent.
201    llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
202
203    /// \brief Queue of declarations in the first context whose equivalence
204    /// with a declaration in the second context still needs to be verified.
205    std::deque<Decl *> DeclsToCheck;
206
207    /// \brief Declaration (from, to) pairs that are known not to be equivalent
208    /// (which we have already complained about).
209    llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
210
211    /// \brief Whether we're being strict about the spelling of types when
212    /// unifying two types.
213    bool StrictTypeSpelling;
214
215    /// \brief Whether to complain about failures.
216    bool Complain;
217
218    /// \brief \c true if the last diagnostic came from C2.
219    bool LastDiagFromC2;
220
221    StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
222               llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
223                                 bool StrictTypeSpelling = false,
224                                 bool Complain = true)
225      : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
226        StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
227        LastDiagFromC2(false) {}
228
229    /// \brief Determine whether the two declarations are structurally
230    /// equivalent.
231    bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
232
233    /// \brief Determine whether the two types are structurally equivalent.
234    bool IsStructurallyEquivalent(QualType T1, QualType T2);
235
236  private:
237    /// \brief Finish checking all of the structural equivalences.
238    ///
239    /// \returns true if an error occurred, false otherwise.
240    bool Finish();
241
242  public:
243    DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
244      assert(Complain && "Not allowed to complain");
245      if (LastDiagFromC2)
246        C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
247      LastDiagFromC2 = false;
248      return C1.getDiagnostics().Report(Loc, DiagID);
249    }
250
251    DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
252      assert(Complain && "Not allowed to complain");
253      if (!LastDiagFromC2)
254        C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
255      LastDiagFromC2 = true;
256      return C2.getDiagnostics().Report(Loc, DiagID);
257    }
258  };
259}
260
261static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
262                                     QualType T1, QualType T2);
263static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
264                                     Decl *D1, Decl *D2);
265
266/// \brief Determine structural equivalence of two expressions.
267static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
268                                     Expr *E1, Expr *E2) {
269  if (!E1 || !E2)
270    return E1 == E2;
271
272  // FIXME: Actually perform a structural comparison!
273  return true;
274}
275
276/// \brief Determine whether two identifiers are equivalent.
277static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
278                                     const IdentifierInfo *Name2) {
279  if (!Name1 || !Name2)
280    return Name1 == Name2;
281
282  return Name1->getName() == Name2->getName();
283}
284
285/// \brief Determine whether two nested-name-specifiers are equivalent.
286static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
287                                     NestedNameSpecifier *NNS1,
288                                     NestedNameSpecifier *NNS2) {
289  // FIXME: Implement!
290  return true;
291}
292
293/// \brief Determine whether two template arguments are equivalent.
294static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
295                                     const TemplateArgument &Arg1,
296                                     const TemplateArgument &Arg2) {
297  if (Arg1.getKind() != Arg2.getKind())
298    return false;
299
300  switch (Arg1.getKind()) {
301  case TemplateArgument::Null:
302    return true;
303
304  case TemplateArgument::Type:
305    return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
306
307  case TemplateArgument::Integral:
308    if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
309                                          Arg2.getIntegralType()))
310      return false;
311
312    return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
313
314  case TemplateArgument::Declaration:
315    return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
316
317  case TemplateArgument::NullPtr:
318    return true; // FIXME: Is this correct?
319
320  case TemplateArgument::Template:
321    return IsStructurallyEquivalent(Context,
322                                    Arg1.getAsTemplate(),
323                                    Arg2.getAsTemplate());
324
325  case TemplateArgument::TemplateExpansion:
326    return IsStructurallyEquivalent(Context,
327                                    Arg1.getAsTemplateOrTemplatePattern(),
328                                    Arg2.getAsTemplateOrTemplatePattern());
329
330  case TemplateArgument::Expression:
331    return IsStructurallyEquivalent(Context,
332                                    Arg1.getAsExpr(), Arg2.getAsExpr());
333
334  case TemplateArgument::Pack:
335    if (Arg1.pack_size() != Arg2.pack_size())
336      return false;
337
338    for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
339      if (!IsStructurallyEquivalent(Context,
340                                    Arg1.pack_begin()[I],
341                                    Arg2.pack_begin()[I]))
342        return false;
343
344    return true;
345  }
346
347  llvm_unreachable("Invalid template argument kind");
348}
349
350/// \brief Determine structural equivalence for the common part of array
351/// types.
352static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
353                                          const ArrayType *Array1,
354                                          const ArrayType *Array2) {
355  if (!IsStructurallyEquivalent(Context,
356                                Array1->getElementType(),
357                                Array2->getElementType()))
358    return false;
359  if (Array1->getSizeModifier() != Array2->getSizeModifier())
360    return false;
361  if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
362    return false;
363
364  return true;
365}
366
367/// \brief Determine structural equivalence of two types.
368static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
369                                     QualType T1, QualType T2) {
370  if (T1.isNull() || T2.isNull())
371    return T1.isNull() && T2.isNull();
372
373  if (!Context.StrictTypeSpelling) {
374    // We aren't being strict about token-to-token equivalence of types,
375    // so map down to the canonical type.
376    T1 = Context.C1.getCanonicalType(T1);
377    T2 = Context.C2.getCanonicalType(T2);
378  }
379
380  if (T1.getQualifiers() != T2.getQualifiers())
381    return false;
382
383  Type::TypeClass TC = T1->getTypeClass();
384
385  if (T1->getTypeClass() != T2->getTypeClass()) {
386    // Compare function types with prototypes vs. without prototypes as if
387    // both did not have prototypes.
388    if (T1->getTypeClass() == Type::FunctionProto &&
389        T2->getTypeClass() == Type::FunctionNoProto)
390      TC = Type::FunctionNoProto;
391    else if (T1->getTypeClass() == Type::FunctionNoProto &&
392             T2->getTypeClass() == Type::FunctionProto)
393      TC = Type::FunctionNoProto;
394    else
395      return false;
396  }
397
398  switch (TC) {
399  case Type::Builtin:
400    // FIXME: Deal with Char_S/Char_U.
401    if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
402      return false;
403    break;
404
405  case Type::Complex:
406    if (!IsStructurallyEquivalent(Context,
407                                  cast<ComplexType>(T1)->getElementType(),
408                                  cast<ComplexType>(T2)->getElementType()))
409      return false;
410    break;
411
412  case Type::Adjusted:
413  case Type::Decayed:
414    if (!IsStructurallyEquivalent(Context,
415                                  cast<AdjustedType>(T1)->getOriginalType(),
416                                  cast<AdjustedType>(T2)->getOriginalType()))
417      return false;
418    break;
419
420  case Type::Pointer:
421    if (!IsStructurallyEquivalent(Context,
422                                  cast<PointerType>(T1)->getPointeeType(),
423                                  cast<PointerType>(T2)->getPointeeType()))
424      return false;
425    break;
426
427  case Type::BlockPointer:
428    if (!IsStructurallyEquivalent(Context,
429                                  cast<BlockPointerType>(T1)->getPointeeType(),
430                                  cast<BlockPointerType>(T2)->getPointeeType()))
431      return false;
432    break;
433
434  case Type::LValueReference:
435  case Type::RValueReference: {
436    const ReferenceType *Ref1 = cast<ReferenceType>(T1);
437    const ReferenceType *Ref2 = cast<ReferenceType>(T2);
438    if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
439      return false;
440    if (Ref1->isInnerRef() != Ref2->isInnerRef())
441      return false;
442    if (!IsStructurallyEquivalent(Context,
443                                  Ref1->getPointeeTypeAsWritten(),
444                                  Ref2->getPointeeTypeAsWritten()))
445      return false;
446    break;
447  }
448
449  case Type::MemberPointer: {
450    const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
451    const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
452    if (!IsStructurallyEquivalent(Context,
453                                  MemPtr1->getPointeeType(),
454                                  MemPtr2->getPointeeType()))
455      return false;
456    if (!IsStructurallyEquivalent(Context,
457                                  QualType(MemPtr1->getClass(), 0),
458                                  QualType(MemPtr2->getClass(), 0)))
459      return false;
460    break;
461  }
462
463  case Type::ConstantArray: {
464    const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
465    const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
466    if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
467      return false;
468
469    if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
470      return false;
471    break;
472  }
473
474  case Type::IncompleteArray:
475    if (!IsArrayStructurallyEquivalent(Context,
476                                       cast<ArrayType>(T1),
477                                       cast<ArrayType>(T2)))
478      return false;
479    break;
480
481  case Type::VariableArray: {
482    const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
483    const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
484    if (!IsStructurallyEquivalent(Context,
485                                  Array1->getSizeExpr(), Array2->getSizeExpr()))
486      return false;
487
488    if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
489      return false;
490
491    break;
492  }
493
494  case Type::DependentSizedArray: {
495    const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
496    const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
497    if (!IsStructurallyEquivalent(Context,
498                                  Array1->getSizeExpr(), Array2->getSizeExpr()))
499      return false;
500
501    if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
502      return false;
503
504    break;
505  }
506
507  case Type::DependentSizedExtVector: {
508    const DependentSizedExtVectorType *Vec1
509      = cast<DependentSizedExtVectorType>(T1);
510    const DependentSizedExtVectorType *Vec2
511      = cast<DependentSizedExtVectorType>(T2);
512    if (!IsStructurallyEquivalent(Context,
513                                  Vec1->getSizeExpr(), Vec2->getSizeExpr()))
514      return false;
515    if (!IsStructurallyEquivalent(Context,
516                                  Vec1->getElementType(),
517                                  Vec2->getElementType()))
518      return false;
519    break;
520  }
521
522  case Type::Vector:
523  case Type::ExtVector: {
524    const VectorType *Vec1 = cast<VectorType>(T1);
525    const VectorType *Vec2 = cast<VectorType>(T2);
526    if (!IsStructurallyEquivalent(Context,
527                                  Vec1->getElementType(),
528                                  Vec2->getElementType()))
529      return false;
530    if (Vec1->getNumElements() != Vec2->getNumElements())
531      return false;
532    if (Vec1->getVectorKind() != Vec2->getVectorKind())
533      return false;
534    break;
535  }
536
537  case Type::FunctionProto: {
538    const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
539    const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
540    if (Proto1->getNumParams() != Proto2->getNumParams())
541      return false;
542    for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
543      if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
544                                    Proto2->getParamType(I)))
545        return false;
546    }
547    if (Proto1->isVariadic() != Proto2->isVariadic())
548      return false;
549    if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
550      return false;
551    if (Proto1->getExceptionSpecType() == EST_Dynamic) {
552      if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
553        return false;
554      for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
555        if (!IsStructurallyEquivalent(Context,
556                                      Proto1->getExceptionType(I),
557                                      Proto2->getExceptionType(I)))
558          return false;
559      }
560    } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
561      if (!IsStructurallyEquivalent(Context,
562                                    Proto1->getNoexceptExpr(),
563                                    Proto2->getNoexceptExpr()))
564        return false;
565    }
566    if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
567      return false;
568
569    // Fall through to check the bits common with FunctionNoProtoType.
570  }
571
572  case Type::FunctionNoProto: {
573    const FunctionType *Function1 = cast<FunctionType>(T1);
574    const FunctionType *Function2 = cast<FunctionType>(T2);
575    if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
576                                  Function2->getReturnType()))
577      return false;
578      if (Function1->getExtInfo() != Function2->getExtInfo())
579        return false;
580    break;
581  }
582
583  case Type::UnresolvedUsing:
584    if (!IsStructurallyEquivalent(Context,
585                                  cast<UnresolvedUsingType>(T1)->getDecl(),
586                                  cast<UnresolvedUsingType>(T2)->getDecl()))
587      return false;
588
589    break;
590
591  case Type::Attributed:
592    if (!IsStructurallyEquivalent(Context,
593                                  cast<AttributedType>(T1)->getModifiedType(),
594                                  cast<AttributedType>(T2)->getModifiedType()))
595      return false;
596    if (!IsStructurallyEquivalent(Context,
597                                cast<AttributedType>(T1)->getEquivalentType(),
598                                cast<AttributedType>(T2)->getEquivalentType()))
599      return false;
600    break;
601
602  case Type::Paren:
603    if (!IsStructurallyEquivalent(Context,
604                                  cast<ParenType>(T1)->getInnerType(),
605                                  cast<ParenType>(T2)->getInnerType()))
606      return false;
607    break;
608
609  case Type::Typedef:
610    if (!IsStructurallyEquivalent(Context,
611                                  cast<TypedefType>(T1)->getDecl(),
612                                  cast<TypedefType>(T2)->getDecl()))
613      return false;
614    break;
615
616  case Type::TypeOfExpr:
617    if (!IsStructurallyEquivalent(Context,
618                                cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
619                                cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
620      return false;
621    break;
622
623  case Type::TypeOf:
624    if (!IsStructurallyEquivalent(Context,
625                                  cast<TypeOfType>(T1)->getUnderlyingType(),
626                                  cast<TypeOfType>(T2)->getUnderlyingType()))
627      return false;
628    break;
629
630  case Type::UnaryTransform:
631    if (!IsStructurallyEquivalent(Context,
632                             cast<UnaryTransformType>(T1)->getUnderlyingType(),
633                             cast<UnaryTransformType>(T1)->getUnderlyingType()))
634      return false;
635    break;
636
637  case Type::Decltype:
638    if (!IsStructurallyEquivalent(Context,
639                                  cast<DecltypeType>(T1)->getUnderlyingExpr(),
640                                  cast<DecltypeType>(T2)->getUnderlyingExpr()))
641      return false;
642    break;
643
644  case Type::Auto:
645    if (!IsStructurallyEquivalent(Context,
646                                  cast<AutoType>(T1)->getDeducedType(),
647                                  cast<AutoType>(T2)->getDeducedType()))
648      return false;
649    break;
650
651  case Type::Record:
652  case Type::Enum:
653    if (!IsStructurallyEquivalent(Context,
654                                  cast<TagType>(T1)->getDecl(),
655                                  cast<TagType>(T2)->getDecl()))
656      return false;
657    break;
658
659  case Type::TemplateTypeParm: {
660    const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
661    const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
662    if (Parm1->getDepth() != Parm2->getDepth())
663      return false;
664    if (Parm1->getIndex() != Parm2->getIndex())
665      return false;
666    if (Parm1->isParameterPack() != Parm2->isParameterPack())
667      return false;
668
669    // Names of template type parameters are never significant.
670    break;
671  }
672
673  case Type::SubstTemplateTypeParm: {
674    const SubstTemplateTypeParmType *Subst1
675      = cast<SubstTemplateTypeParmType>(T1);
676    const SubstTemplateTypeParmType *Subst2
677      = cast<SubstTemplateTypeParmType>(T2);
678    if (!IsStructurallyEquivalent(Context,
679                                  QualType(Subst1->getReplacedParameter(), 0),
680                                  QualType(Subst2->getReplacedParameter(), 0)))
681      return false;
682    if (!IsStructurallyEquivalent(Context,
683                                  Subst1->getReplacementType(),
684                                  Subst2->getReplacementType()))
685      return false;
686    break;
687  }
688
689  case Type::SubstTemplateTypeParmPack: {
690    const SubstTemplateTypeParmPackType *Subst1
691      = cast<SubstTemplateTypeParmPackType>(T1);
692    const SubstTemplateTypeParmPackType *Subst2
693      = cast<SubstTemplateTypeParmPackType>(T2);
694    if (!IsStructurallyEquivalent(Context,
695                                  QualType(Subst1->getReplacedParameter(), 0),
696                                  QualType(Subst2->getReplacedParameter(), 0)))
697      return false;
698    if (!IsStructurallyEquivalent(Context,
699                                  Subst1->getArgumentPack(),
700                                  Subst2->getArgumentPack()))
701      return false;
702    break;
703  }
704  case Type::TemplateSpecialization: {
705    const TemplateSpecializationType *Spec1
706      = cast<TemplateSpecializationType>(T1);
707    const TemplateSpecializationType *Spec2
708      = cast<TemplateSpecializationType>(T2);
709    if (!IsStructurallyEquivalent(Context,
710                                  Spec1->getTemplateName(),
711                                  Spec2->getTemplateName()))
712      return false;
713    if (Spec1->getNumArgs() != Spec2->getNumArgs())
714      return false;
715    for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
716      if (!IsStructurallyEquivalent(Context,
717                                    Spec1->getArg(I), Spec2->getArg(I)))
718        return false;
719    }
720    break;
721  }
722
723  case Type::Elaborated: {
724    const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
725    const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
726    // CHECKME: what if a keyword is ETK_None or ETK_typename ?
727    if (Elab1->getKeyword() != Elab2->getKeyword())
728      return false;
729    if (!IsStructurallyEquivalent(Context,
730                                  Elab1->getQualifier(),
731                                  Elab2->getQualifier()))
732      return false;
733    if (!IsStructurallyEquivalent(Context,
734                                  Elab1->getNamedType(),
735                                  Elab2->getNamedType()))
736      return false;
737    break;
738  }
739
740  case Type::InjectedClassName: {
741    const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
742    const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
743    if (!IsStructurallyEquivalent(Context,
744                                  Inj1->getInjectedSpecializationType(),
745                                  Inj2->getInjectedSpecializationType()))
746      return false;
747    break;
748  }
749
750  case Type::DependentName: {
751    const DependentNameType *Typename1 = cast<DependentNameType>(T1);
752    const DependentNameType *Typename2 = cast<DependentNameType>(T2);
753    if (!IsStructurallyEquivalent(Context,
754                                  Typename1->getQualifier(),
755                                  Typename2->getQualifier()))
756      return false;
757    if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
758                                  Typename2->getIdentifier()))
759      return false;
760
761    break;
762  }
763
764  case Type::DependentTemplateSpecialization: {
765    const DependentTemplateSpecializationType *Spec1 =
766      cast<DependentTemplateSpecializationType>(T1);
767    const DependentTemplateSpecializationType *Spec2 =
768      cast<DependentTemplateSpecializationType>(T2);
769    if (!IsStructurallyEquivalent(Context,
770                                  Spec1->getQualifier(),
771                                  Spec2->getQualifier()))
772      return false;
773    if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
774                                  Spec2->getIdentifier()))
775      return false;
776    if (Spec1->getNumArgs() != Spec2->getNumArgs())
777      return false;
778    for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
779      if (!IsStructurallyEquivalent(Context,
780                                    Spec1->getArg(I), Spec2->getArg(I)))
781        return false;
782    }
783    break;
784  }
785
786  case Type::PackExpansion:
787    if (!IsStructurallyEquivalent(Context,
788                                  cast<PackExpansionType>(T1)->getPattern(),
789                                  cast<PackExpansionType>(T2)->getPattern()))
790      return false;
791    break;
792
793  case Type::ObjCInterface: {
794    const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
795    const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
796    if (!IsStructurallyEquivalent(Context,
797                                  Iface1->getDecl(), Iface2->getDecl()))
798      return false;
799    break;
800  }
801
802  case Type::ObjCObject: {
803    const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
804    const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
805    if (!IsStructurallyEquivalent(Context,
806                                  Obj1->getBaseType(),
807                                  Obj2->getBaseType()))
808      return false;
809    if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
810      return false;
811    for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
812      if (!IsStructurallyEquivalent(Context,
813                                    Obj1->getProtocol(I),
814                                    Obj2->getProtocol(I)))
815        return false;
816    }
817    break;
818  }
819
820  case Type::ObjCObjectPointer: {
821    const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
822    const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
823    if (!IsStructurallyEquivalent(Context,
824                                  Ptr1->getPointeeType(),
825                                  Ptr2->getPointeeType()))
826      return false;
827    break;
828  }
829
830  case Type::Atomic: {
831    if (!IsStructurallyEquivalent(Context,
832                                  cast<AtomicType>(T1)->getValueType(),
833                                  cast<AtomicType>(T2)->getValueType()))
834      return false;
835    break;
836  }
837
838  } // end switch
839
840  return true;
841}
842
843/// \brief Determine structural equivalence of two fields.
844static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
845                                     FieldDecl *Field1, FieldDecl *Field2) {
846  RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
847
848  // For anonymous structs/unions, match up the anonymous struct/union type
849  // declarations directly, so that we don't go off searching for anonymous
850  // types
851  if (Field1->isAnonymousStructOrUnion() &&
852      Field2->isAnonymousStructOrUnion()) {
853    RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
854    RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
855    return IsStructurallyEquivalent(Context, D1, D2);
856  }
857
858  // Check for equivalent field names.
859  IdentifierInfo *Name1 = Field1->getIdentifier();
860  IdentifierInfo *Name2 = Field2->getIdentifier();
861  if (!::IsStructurallyEquivalent(Name1, Name2))
862    return false;
863
864  if (!IsStructurallyEquivalent(Context,
865                                Field1->getType(), Field2->getType())) {
866    if (Context.Complain) {
867      Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
868        << Context.C2.getTypeDeclType(Owner2);
869      Context.Diag2(Field2->getLocation(), diag::note_odr_field)
870        << Field2->getDeclName() << Field2->getType();
871      Context.Diag1(Field1->getLocation(), diag::note_odr_field)
872        << Field1->getDeclName() << Field1->getType();
873    }
874    return false;
875  }
876
877  if (Field1->isBitField() != Field2->isBitField()) {
878    if (Context.Complain) {
879      Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
880        << Context.C2.getTypeDeclType(Owner2);
881      if (Field1->isBitField()) {
882        Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
883        << Field1->getDeclName() << Field1->getType()
884        << Field1->getBitWidthValue(Context.C1);
885        Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
886        << Field2->getDeclName();
887      } else {
888        Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
889        << Field2->getDeclName() << Field2->getType()
890        << Field2->getBitWidthValue(Context.C2);
891        Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
892        << Field1->getDeclName();
893      }
894    }
895    return false;
896  }
897
898  if (Field1->isBitField()) {
899    // Make sure that the bit-fields are the same length.
900    unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
901    unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
902
903    if (Bits1 != Bits2) {
904      if (Context.Complain) {
905        Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
906          << Context.C2.getTypeDeclType(Owner2);
907        Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
908          << Field2->getDeclName() << Field2->getType() << Bits2;
909        Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
910          << Field1->getDeclName() << Field1->getType() << Bits1;
911      }
912      return false;
913    }
914  }
915
916  return true;
917}
918
919/// \brief Find the index of the given anonymous struct/union within its
920/// context.
921///
922/// \returns Returns the index of this anonymous struct/union in its context,
923/// including the next assigned index (if none of them match). Returns an
924/// empty option if the context is not a record, i.e.. if the anonymous
925/// struct/union is at namespace or block scope.
926static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
927  ASTContext &Context = Anon->getASTContext();
928  QualType AnonTy = Context.getRecordType(Anon);
929
930  RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
931  if (!Owner)
932    return None;
933
934  unsigned Index = 0;
935  for (const auto *D : Owner->noload_decls()) {
936    const auto *F = dyn_cast<FieldDecl>(D);
937    if (!F || !F->isAnonymousStructOrUnion())
938      continue;
939
940    if (Context.hasSameType(F->getType(), AnonTy))
941      break;
942
943    ++Index;
944  }
945
946  return Index;
947}
948
949/// \brief Determine structural equivalence of two records.
950static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
951                                     RecordDecl *D1, RecordDecl *D2) {
952  if (D1->isUnion() != D2->isUnion()) {
953    if (Context.Complain) {
954      Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
955        << Context.C2.getTypeDeclType(D2);
956      Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
957        << D1->getDeclName() << (unsigned)D1->getTagKind();
958    }
959    return false;
960  }
961
962  if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
963    // If both anonymous structs/unions are in a record context, make sure
964    // they occur in the same location in the context records.
965    if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
966      if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
967        if (*Index1 != *Index2)
968          return false;
969      }
970    }
971  }
972
973  // If both declarations are class template specializations, we know
974  // the ODR applies, so check the template and template arguments.
975  ClassTemplateSpecializationDecl *Spec1
976    = dyn_cast<ClassTemplateSpecializationDecl>(D1);
977  ClassTemplateSpecializationDecl *Spec2
978    = dyn_cast<ClassTemplateSpecializationDecl>(D2);
979  if (Spec1 && Spec2) {
980    // Check that the specialized templates are the same.
981    if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
982                                  Spec2->getSpecializedTemplate()))
983      return false;
984
985    // Check that the template arguments are the same.
986    if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
987      return false;
988
989    for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
990      if (!IsStructurallyEquivalent(Context,
991                                    Spec1->getTemplateArgs().get(I),
992                                    Spec2->getTemplateArgs().get(I)))
993        return false;
994  }
995  // If one is a class template specialization and the other is not, these
996  // structures are different.
997  else if (Spec1 || Spec2)
998    return false;
999
1000  // Compare the definitions of these two records. If either or both are
1001  // incomplete, we assume that they are equivalent.
1002  D1 = D1->getDefinition();
1003  D2 = D2->getDefinition();
1004  if (!D1 || !D2)
1005    return true;
1006
1007  if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1008    if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1009      if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1010        if (Context.Complain) {
1011          Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1012            << Context.C2.getTypeDeclType(D2);
1013          Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1014            << D2CXX->getNumBases();
1015          Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1016            << D1CXX->getNumBases();
1017        }
1018        return false;
1019      }
1020
1021      // Check the base classes.
1022      for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1023                                           BaseEnd1 = D1CXX->bases_end(),
1024                                                Base2 = D2CXX->bases_begin();
1025           Base1 != BaseEnd1;
1026           ++Base1, ++Base2) {
1027        if (!IsStructurallyEquivalent(Context,
1028                                      Base1->getType(), Base2->getType())) {
1029          if (Context.Complain) {
1030            Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1031              << Context.C2.getTypeDeclType(D2);
1032            Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1033              << Base2->getType()
1034              << Base2->getSourceRange();
1035            Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1036              << Base1->getType()
1037              << Base1->getSourceRange();
1038          }
1039          return false;
1040        }
1041
1042        // Check virtual vs. non-virtual inheritance mismatch.
1043        if (Base1->isVirtual() != Base2->isVirtual()) {
1044          if (Context.Complain) {
1045            Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1046              << Context.C2.getTypeDeclType(D2);
1047            Context.Diag2(Base2->getLocStart(),
1048                          diag::note_odr_virtual_base)
1049              << Base2->isVirtual() << Base2->getSourceRange();
1050            Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1051              << Base1->isVirtual()
1052              << Base1->getSourceRange();
1053          }
1054          return false;
1055        }
1056      }
1057    } else if (D1CXX->getNumBases() > 0) {
1058      if (Context.Complain) {
1059        Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1060          << Context.C2.getTypeDeclType(D2);
1061        const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1062        Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1063          << Base1->getType()
1064          << Base1->getSourceRange();
1065        Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1066      }
1067      return false;
1068    }
1069  }
1070
1071  // Check the fields for consistency.
1072  RecordDecl::field_iterator Field2 = D2->field_begin(),
1073                             Field2End = D2->field_end();
1074  for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1075                                  Field1End = D1->field_end();
1076       Field1 != Field1End;
1077       ++Field1, ++Field2) {
1078    if (Field2 == Field2End) {
1079      if (Context.Complain) {
1080        Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1081          << Context.C2.getTypeDeclType(D2);
1082        Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1083          << Field1->getDeclName() << Field1->getType();
1084        Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1085      }
1086      return false;
1087    }
1088
1089    if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1090      return false;
1091  }
1092
1093  if (Field2 != Field2End) {
1094    if (Context.Complain) {
1095      Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1096        << Context.C2.getTypeDeclType(D2);
1097      Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1098        << Field2->getDeclName() << Field2->getType();
1099      Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1100    }
1101    return false;
1102  }
1103
1104  return true;
1105}
1106
1107/// \brief Determine structural equivalence of two enums.
1108static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1109                                     EnumDecl *D1, EnumDecl *D2) {
1110  EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1111                             EC2End = D2->enumerator_end();
1112  for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1113                                  EC1End = D1->enumerator_end();
1114       EC1 != EC1End; ++EC1, ++EC2) {
1115    if (EC2 == EC2End) {
1116      if (Context.Complain) {
1117        Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1118          << Context.C2.getTypeDeclType(D2);
1119        Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1120          << EC1->getDeclName()
1121          << EC1->getInitVal().toString(10);
1122        Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1123      }
1124      return false;
1125    }
1126
1127    llvm::APSInt Val1 = EC1->getInitVal();
1128    llvm::APSInt Val2 = EC2->getInitVal();
1129    if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1130        !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1131      if (Context.Complain) {
1132        Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1133          << Context.C2.getTypeDeclType(D2);
1134        Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1135          << EC2->getDeclName()
1136          << EC2->getInitVal().toString(10);
1137        Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1138          << EC1->getDeclName()
1139          << EC1->getInitVal().toString(10);
1140      }
1141      return false;
1142    }
1143  }
1144
1145  if (EC2 != EC2End) {
1146    if (Context.Complain) {
1147      Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1148        << Context.C2.getTypeDeclType(D2);
1149      Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1150        << EC2->getDeclName()
1151        << EC2->getInitVal().toString(10);
1152      Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1153    }
1154    return false;
1155  }
1156
1157  return true;
1158}
1159
1160static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1161                                     TemplateParameterList *Params1,
1162                                     TemplateParameterList *Params2) {
1163  if (Params1->size() != Params2->size()) {
1164    if (Context.Complain) {
1165      Context.Diag2(Params2->getTemplateLoc(),
1166                    diag::err_odr_different_num_template_parameters)
1167        << Params1->size() << Params2->size();
1168      Context.Diag1(Params1->getTemplateLoc(),
1169                    diag::note_odr_template_parameter_list);
1170    }
1171    return false;
1172  }
1173
1174  for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1175    if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1176      if (Context.Complain) {
1177        Context.Diag2(Params2->getParam(I)->getLocation(),
1178                      diag::err_odr_different_template_parameter_kind);
1179        Context.Diag1(Params1->getParam(I)->getLocation(),
1180                      diag::note_odr_template_parameter_here);
1181      }
1182      return false;
1183    }
1184
1185    if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1186                                          Params2->getParam(I))) {
1187
1188      return false;
1189    }
1190  }
1191
1192  return true;
1193}
1194
1195static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1196                                     TemplateTypeParmDecl *D1,
1197                                     TemplateTypeParmDecl *D2) {
1198  if (D1->isParameterPack() != D2->isParameterPack()) {
1199    if (Context.Complain) {
1200      Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1201        << D2->isParameterPack();
1202      Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1203        << D1->isParameterPack();
1204    }
1205    return false;
1206  }
1207
1208  return true;
1209}
1210
1211static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1212                                     NonTypeTemplateParmDecl *D1,
1213                                     NonTypeTemplateParmDecl *D2) {
1214  if (D1->isParameterPack() != D2->isParameterPack()) {
1215    if (Context.Complain) {
1216      Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1217        << D2->isParameterPack();
1218      Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1219        << D1->isParameterPack();
1220    }
1221    return false;
1222  }
1223
1224  // Check types.
1225  if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1226    if (Context.Complain) {
1227      Context.Diag2(D2->getLocation(),
1228                    diag::err_odr_non_type_parameter_type_inconsistent)
1229        << D2->getType() << D1->getType();
1230      Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1231        << D1->getType();
1232    }
1233    return false;
1234  }
1235
1236  return true;
1237}
1238
1239static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1240                                     TemplateTemplateParmDecl *D1,
1241                                     TemplateTemplateParmDecl *D2) {
1242  if (D1->isParameterPack() != D2->isParameterPack()) {
1243    if (Context.Complain) {
1244      Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1245        << D2->isParameterPack();
1246      Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1247        << D1->isParameterPack();
1248    }
1249    return false;
1250  }
1251
1252  // Check template parameter lists.
1253  return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1254                                  D2->getTemplateParameters());
1255}
1256
1257static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1258                                     ClassTemplateDecl *D1,
1259                                     ClassTemplateDecl *D2) {
1260  // Check template parameters.
1261  if (!IsStructurallyEquivalent(Context,
1262                                D1->getTemplateParameters(),
1263                                D2->getTemplateParameters()))
1264    return false;
1265
1266  // Check the templated declaration.
1267  return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1268                                          D2->getTemplatedDecl());
1269}
1270
1271/// \brief Determine structural equivalence of two declarations.
1272static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1273                                     Decl *D1, Decl *D2) {
1274  // FIXME: Check for known structural equivalences via a callback of some sort.
1275
1276  // Check whether we already know that these two declarations are not
1277  // structurally equivalent.
1278  if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1279                                                      D2->getCanonicalDecl())))
1280    return false;
1281
1282  // Determine whether we've already produced a tentative equivalence for D1.
1283  Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1284  if (EquivToD1)
1285    return EquivToD1 == D2->getCanonicalDecl();
1286
1287  // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1288  EquivToD1 = D2->getCanonicalDecl();
1289  Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1290  return true;
1291}
1292
1293bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1294                                                            Decl *D2) {
1295  if (!::IsStructurallyEquivalent(*this, D1, D2))
1296    return false;
1297
1298  return !Finish();
1299}
1300
1301bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1302                                                            QualType T2) {
1303  if (!::IsStructurallyEquivalent(*this, T1, T2))
1304    return false;
1305
1306  return !Finish();
1307}
1308
1309bool StructuralEquivalenceContext::Finish() {
1310  while (!DeclsToCheck.empty()) {
1311    // Check the next declaration.
1312    Decl *D1 = DeclsToCheck.front();
1313    DeclsToCheck.pop_front();
1314
1315    Decl *D2 = TentativeEquivalences[D1];
1316    assert(D2 && "Unrecorded tentative equivalence?");
1317
1318    bool Equivalent = true;
1319
1320    // FIXME: Switch on all declaration kinds. For now, we're just going to
1321    // check the obvious ones.
1322    if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1323      if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1324        // Check for equivalent structure names.
1325        IdentifierInfo *Name1 = Record1->getIdentifier();
1326        if (!Name1 && Record1->getTypedefNameForAnonDecl())
1327          Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1328        IdentifierInfo *Name2 = Record2->getIdentifier();
1329        if (!Name2 && Record2->getTypedefNameForAnonDecl())
1330          Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1331        if (!::IsStructurallyEquivalent(Name1, Name2) ||
1332            !::IsStructurallyEquivalent(*this, Record1, Record2))
1333          Equivalent = false;
1334      } else {
1335        // Record/non-record mismatch.
1336        Equivalent = false;
1337      }
1338    } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1339      if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1340        // Check for equivalent enum names.
1341        IdentifierInfo *Name1 = Enum1->getIdentifier();
1342        if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1343          Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1344        IdentifierInfo *Name2 = Enum2->getIdentifier();
1345        if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1346          Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1347        if (!::IsStructurallyEquivalent(Name1, Name2) ||
1348            !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1349          Equivalent = false;
1350      } else {
1351        // Enum/non-enum mismatch
1352        Equivalent = false;
1353      }
1354    } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1355      if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1356        if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1357                                        Typedef2->getIdentifier()) ||
1358            !::IsStructurallyEquivalent(*this,
1359                                        Typedef1->getUnderlyingType(),
1360                                        Typedef2->getUnderlyingType()))
1361          Equivalent = false;
1362      } else {
1363        // Typedef/non-typedef mismatch.
1364        Equivalent = false;
1365      }
1366    } else if (ClassTemplateDecl *ClassTemplate1
1367                                           = dyn_cast<ClassTemplateDecl>(D1)) {
1368      if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1369        if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1370                                        ClassTemplate2->getIdentifier()) ||
1371            !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1372          Equivalent = false;
1373      } else {
1374        // Class template/non-class-template mismatch.
1375        Equivalent = false;
1376      }
1377    } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1378      if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1379        if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1380          Equivalent = false;
1381      } else {
1382        // Kind mismatch.
1383        Equivalent = false;
1384      }
1385    } else if (NonTypeTemplateParmDecl *NTTP1
1386                                     = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1387      if (NonTypeTemplateParmDecl *NTTP2
1388                                      = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1389        if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1390          Equivalent = false;
1391      } else {
1392        // Kind mismatch.
1393        Equivalent = false;
1394      }
1395    } else if (TemplateTemplateParmDecl *TTP1
1396                                  = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1397      if (TemplateTemplateParmDecl *TTP2
1398                                    = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1399        if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1400          Equivalent = false;
1401      } else {
1402        // Kind mismatch.
1403        Equivalent = false;
1404      }
1405    }
1406
1407    if (!Equivalent) {
1408      // Note that these two declarations are not equivalent (and we already
1409      // know about it).
1410      NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1411                                               D2->getCanonicalDecl()));
1412      return true;
1413    }
1414    // FIXME: Check other declaration kinds!
1415  }
1416
1417  return false;
1418}
1419
1420//----------------------------------------------------------------------------
1421// Import Types
1422//----------------------------------------------------------------------------
1423
1424QualType ASTNodeImporter::VisitType(const Type *T) {
1425  Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1426    << T->getTypeClassName();
1427  return QualType();
1428}
1429
1430QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1431  switch (T->getKind()) {
1432#define SHARED_SINGLETON_TYPE(Expansion)
1433#define BUILTIN_TYPE(Id, SingletonId) \
1434  case BuiltinType::Id: return Importer.getToContext().SingletonId;
1435#include "clang/AST/BuiltinTypes.def"
1436
1437  // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1438  // context supports C++.
1439
1440  // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1441  // context supports ObjC.
1442
1443  case BuiltinType::Char_U:
1444    // The context we're importing from has an unsigned 'char'. If we're
1445    // importing into a context with a signed 'char', translate to
1446    // 'unsigned char' instead.
1447    if (Importer.getToContext().getLangOpts().CharIsSigned)
1448      return Importer.getToContext().UnsignedCharTy;
1449
1450    return Importer.getToContext().CharTy;
1451
1452  case BuiltinType::Char_S:
1453    // The context we're importing from has an unsigned 'char'. If we're
1454    // importing into a context with a signed 'char', translate to
1455    // 'unsigned char' instead.
1456    if (!Importer.getToContext().getLangOpts().CharIsSigned)
1457      return Importer.getToContext().SignedCharTy;
1458
1459    return Importer.getToContext().CharTy;
1460
1461  case BuiltinType::WChar_S:
1462  case BuiltinType::WChar_U:
1463    // FIXME: If not in C++, shall we translate to the C equivalent of
1464    // wchar_t?
1465    return Importer.getToContext().WCharTy;
1466  }
1467
1468  llvm_unreachable("Invalid BuiltinType Kind!");
1469}
1470
1471QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1472  QualType ToElementType = Importer.Import(T->getElementType());
1473  if (ToElementType.isNull())
1474    return QualType();
1475
1476  return Importer.getToContext().getComplexType(ToElementType);
1477}
1478
1479QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1480  QualType ToPointeeType = Importer.Import(T->getPointeeType());
1481  if (ToPointeeType.isNull())
1482    return QualType();
1483
1484  return Importer.getToContext().getPointerType(ToPointeeType);
1485}
1486
1487QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1488  // FIXME: Check for blocks support in "to" context.
1489  QualType ToPointeeType = Importer.Import(T->getPointeeType());
1490  if (ToPointeeType.isNull())
1491    return QualType();
1492
1493  return Importer.getToContext().getBlockPointerType(ToPointeeType);
1494}
1495
1496QualType
1497ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1498  // FIXME: Check for C++ support in "to" context.
1499  QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1500  if (ToPointeeType.isNull())
1501    return QualType();
1502
1503  return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1504}
1505
1506QualType
1507ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1508  // FIXME: Check for C++0x support in "to" context.
1509  QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1510  if (ToPointeeType.isNull())
1511    return QualType();
1512
1513  return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1514}
1515
1516QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1517  // FIXME: Check for C++ support in "to" context.
1518  QualType ToPointeeType = Importer.Import(T->getPointeeType());
1519  if (ToPointeeType.isNull())
1520    return QualType();
1521
1522  QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1523  return Importer.getToContext().getMemberPointerType(ToPointeeType,
1524                                                      ClassType.getTypePtr());
1525}
1526
1527QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1528  QualType ToElementType = Importer.Import(T->getElementType());
1529  if (ToElementType.isNull())
1530    return QualType();
1531
1532  return Importer.getToContext().getConstantArrayType(ToElementType,
1533                                                      T->getSize(),
1534                                                      T->getSizeModifier(),
1535                                               T->getIndexTypeCVRQualifiers());
1536}
1537
1538QualType
1539ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1540  QualType ToElementType = Importer.Import(T->getElementType());
1541  if (ToElementType.isNull())
1542    return QualType();
1543
1544  return Importer.getToContext().getIncompleteArrayType(ToElementType,
1545                                                        T->getSizeModifier(),
1546                                                T->getIndexTypeCVRQualifiers());
1547}
1548
1549QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1550  QualType ToElementType = Importer.Import(T->getElementType());
1551  if (ToElementType.isNull())
1552    return QualType();
1553
1554  Expr *Size = Importer.Import(T->getSizeExpr());
1555  if (!Size)
1556    return QualType();
1557
1558  SourceRange Brackets = Importer.Import(T->getBracketsRange());
1559  return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1560                                                      T->getSizeModifier(),
1561                                                T->getIndexTypeCVRQualifiers(),
1562                                                      Brackets);
1563}
1564
1565QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1566  QualType ToElementType = Importer.Import(T->getElementType());
1567  if (ToElementType.isNull())
1568    return QualType();
1569
1570  return Importer.getToContext().getVectorType(ToElementType,
1571                                               T->getNumElements(),
1572                                               T->getVectorKind());
1573}
1574
1575QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1576  QualType ToElementType = Importer.Import(T->getElementType());
1577  if (ToElementType.isNull())
1578    return QualType();
1579
1580  return Importer.getToContext().getExtVectorType(ToElementType,
1581                                                  T->getNumElements());
1582}
1583
1584QualType
1585ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1586  // FIXME: What happens if we're importing a function without a prototype
1587  // into C++? Should we make it variadic?
1588  QualType ToResultType = Importer.Import(T->getReturnType());
1589  if (ToResultType.isNull())
1590    return QualType();
1591
1592  return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1593                                                        T->getExtInfo());
1594}
1595
1596QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1597  QualType ToResultType = Importer.Import(T->getReturnType());
1598  if (ToResultType.isNull())
1599    return QualType();
1600
1601  // Import argument types
1602  SmallVector<QualType, 4> ArgTypes;
1603  for (const auto &A : T->param_types()) {
1604    QualType ArgType = Importer.Import(A);
1605    if (ArgType.isNull())
1606      return QualType();
1607    ArgTypes.push_back(ArgType);
1608  }
1609
1610  // Import exception types
1611  SmallVector<QualType, 4> ExceptionTypes;
1612  for (const auto &E : T->exceptions()) {
1613    QualType ExceptionType = Importer.Import(E);
1614    if (ExceptionType.isNull())
1615      return QualType();
1616    ExceptionTypes.push_back(ExceptionType);
1617  }
1618
1619  FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1620  FunctionProtoType::ExtProtoInfo ToEPI;
1621
1622  ToEPI.ExtInfo = FromEPI.ExtInfo;
1623  ToEPI.Variadic = FromEPI.Variadic;
1624  ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1625  ToEPI.TypeQuals = FromEPI.TypeQuals;
1626  ToEPI.RefQualifier = FromEPI.RefQualifier;
1627  ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1628  ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1629  ToEPI.ExceptionSpec.NoexceptExpr =
1630      Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1631  ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1632      Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1633  ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1634      Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1635
1636  return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1637}
1638
1639QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1640  QualType ToInnerType = Importer.Import(T->getInnerType());
1641  if (ToInnerType.isNull())
1642    return QualType();
1643
1644  return Importer.getToContext().getParenType(ToInnerType);
1645}
1646
1647QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1648  TypedefNameDecl *ToDecl
1649             = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1650  if (!ToDecl)
1651    return QualType();
1652
1653  return Importer.getToContext().getTypeDeclType(ToDecl);
1654}
1655
1656QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1657  Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1658  if (!ToExpr)
1659    return QualType();
1660
1661  return Importer.getToContext().getTypeOfExprType(ToExpr);
1662}
1663
1664QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1665  QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1666  if (ToUnderlyingType.isNull())
1667    return QualType();
1668
1669  return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1670}
1671
1672QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1673  // FIXME: Make sure that the "to" context supports C++0x!
1674  Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1675  if (!ToExpr)
1676    return QualType();
1677
1678  QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1679  if (UnderlyingType.isNull())
1680    return QualType();
1681
1682  return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1683}
1684
1685QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1686  QualType ToBaseType = Importer.Import(T->getBaseType());
1687  QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1688  if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1689    return QualType();
1690
1691  return Importer.getToContext().getUnaryTransformType(ToBaseType,
1692                                                       ToUnderlyingType,
1693                                                       T->getUTTKind());
1694}
1695
1696QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1697  // FIXME: Make sure that the "to" context supports C++11!
1698  QualType FromDeduced = T->getDeducedType();
1699  QualType ToDeduced;
1700  if (!FromDeduced.isNull()) {
1701    ToDeduced = Importer.Import(FromDeduced);
1702    if (ToDeduced.isNull())
1703      return QualType();
1704  }
1705
1706  return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto(),
1707                                             /*IsDependent*/false);
1708}
1709
1710QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1711  RecordDecl *ToDecl
1712    = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1713  if (!ToDecl)
1714    return QualType();
1715
1716  return Importer.getToContext().getTagDeclType(ToDecl);
1717}
1718
1719QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1720  EnumDecl *ToDecl
1721    = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1722  if (!ToDecl)
1723    return QualType();
1724
1725  return Importer.getToContext().getTagDeclType(ToDecl);
1726}
1727
1728QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1729  QualType FromModifiedType = T->getModifiedType();
1730  QualType FromEquivalentType = T->getEquivalentType();
1731  QualType ToModifiedType;
1732  QualType ToEquivalentType;
1733
1734  if (!FromModifiedType.isNull()) {
1735    ToModifiedType = Importer.Import(FromModifiedType);
1736    if (ToModifiedType.isNull())
1737      return QualType();
1738  }
1739  if (!FromEquivalentType.isNull()) {
1740    ToEquivalentType = Importer.Import(FromEquivalentType);
1741    if (ToEquivalentType.isNull())
1742      return QualType();
1743  }
1744
1745  return Importer.getToContext().getAttributedType(T->getAttrKind(),
1746    ToModifiedType, ToEquivalentType);
1747}
1748
1749QualType ASTNodeImporter::VisitTemplateSpecializationType(
1750                                       const TemplateSpecializationType *T) {
1751  TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1752  if (ToTemplate.isNull())
1753    return QualType();
1754
1755  SmallVector<TemplateArgument, 2> ToTemplateArgs;
1756  if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1757    return QualType();
1758
1759  QualType ToCanonType;
1760  if (!QualType(T, 0).isCanonical()) {
1761    QualType FromCanonType
1762      = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1763    ToCanonType =Importer.Import(FromCanonType);
1764    if (ToCanonType.isNull())
1765      return QualType();
1766  }
1767  return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1768                                                         ToTemplateArgs.data(),
1769                                                         ToTemplateArgs.size(),
1770                                                               ToCanonType);
1771}
1772
1773QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1774  NestedNameSpecifier *ToQualifier = nullptr;
1775  // Note: the qualifier in an ElaboratedType is optional.
1776  if (T->getQualifier()) {
1777    ToQualifier = Importer.Import(T->getQualifier());
1778    if (!ToQualifier)
1779      return QualType();
1780  }
1781
1782  QualType ToNamedType = Importer.Import(T->getNamedType());
1783  if (ToNamedType.isNull())
1784    return QualType();
1785
1786  return Importer.getToContext().getElaboratedType(T->getKeyword(),
1787                                                   ToQualifier, ToNamedType);
1788}
1789
1790QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1791  ObjCInterfaceDecl *Class
1792    = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1793  if (!Class)
1794    return QualType();
1795
1796  return Importer.getToContext().getObjCInterfaceType(Class);
1797}
1798
1799QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1800  QualType ToBaseType = Importer.Import(T->getBaseType());
1801  if (ToBaseType.isNull())
1802    return QualType();
1803
1804  SmallVector<ObjCProtocolDecl *, 4> Protocols;
1805  for (auto *P : T->quals()) {
1806    ObjCProtocolDecl *Protocol
1807      = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1808    if (!Protocol)
1809      return QualType();
1810    Protocols.push_back(Protocol);
1811  }
1812
1813  return Importer.getToContext().getObjCObjectType(ToBaseType,
1814                                                   Protocols.data(),
1815                                                   Protocols.size());
1816}
1817
1818QualType
1819ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1820  QualType ToPointeeType = Importer.Import(T->getPointeeType());
1821  if (ToPointeeType.isNull())
1822    return QualType();
1823
1824  return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1825}
1826
1827//----------------------------------------------------------------------------
1828// Import Declarations
1829//----------------------------------------------------------------------------
1830bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1831                                      DeclContext *&LexicalDC,
1832                                      DeclarationName &Name,
1833                                      SourceLocation &Loc) {
1834  // Import the context of this declaration.
1835  DC = Importer.ImportContext(D->getDeclContext());
1836  if (!DC)
1837    return true;
1838
1839  LexicalDC = DC;
1840  if (D->getDeclContext() != D->getLexicalDeclContext()) {
1841    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1842    if (!LexicalDC)
1843      return true;
1844  }
1845
1846  // Import the name of this declaration.
1847  Name = Importer.Import(D->getDeclName());
1848  if (D->getDeclName() && !Name)
1849    return true;
1850
1851  // Import the location of this declaration.
1852  Loc = Importer.Import(D->getLocation());
1853  return false;
1854}
1855
1856void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1857  if (!FromD)
1858    return;
1859
1860  if (!ToD) {
1861    ToD = Importer.Import(FromD);
1862    if (!ToD)
1863      return;
1864  }
1865
1866  if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1867    if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1868      if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1869        ImportDefinition(FromRecord, ToRecord);
1870      }
1871    }
1872    return;
1873  }
1874
1875  if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1876    if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1877      if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1878        ImportDefinition(FromEnum, ToEnum);
1879      }
1880    }
1881    return;
1882  }
1883}
1884
1885void
1886ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1887                                          DeclarationNameInfo& To) {
1888  // NOTE: To.Name and To.Loc are already imported.
1889  // We only have to import To.LocInfo.
1890  switch (To.getName().getNameKind()) {
1891  case DeclarationName::Identifier:
1892  case DeclarationName::ObjCZeroArgSelector:
1893  case DeclarationName::ObjCOneArgSelector:
1894  case DeclarationName::ObjCMultiArgSelector:
1895  case DeclarationName::CXXUsingDirective:
1896    return;
1897
1898  case DeclarationName::CXXOperatorName: {
1899    SourceRange Range = From.getCXXOperatorNameRange();
1900    To.setCXXOperatorNameRange(Importer.Import(Range));
1901    return;
1902  }
1903  case DeclarationName::CXXLiteralOperatorName: {
1904    SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1905    To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1906    return;
1907  }
1908  case DeclarationName::CXXConstructorName:
1909  case DeclarationName::CXXDestructorName:
1910  case DeclarationName::CXXConversionFunctionName: {
1911    TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1912    To.setNamedTypeInfo(Importer.Import(FromTInfo));
1913    return;
1914  }
1915  }
1916  llvm_unreachable("Unknown name kind.");
1917}
1918
1919void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1920  if (Importer.isMinimalImport() && !ForceImport) {
1921    Importer.ImportContext(FromDC);
1922    return;
1923  }
1924
1925  for (auto *From : FromDC->decls())
1926    Importer.Import(From);
1927}
1928
1929bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1930                                       ImportDefinitionKind Kind) {
1931  if (To->getDefinition() || To->isBeingDefined()) {
1932    if (Kind == IDK_Everything)
1933      ImportDeclContext(From, /*ForceImport=*/true);
1934
1935    return false;
1936  }
1937
1938  To->startDefinition();
1939
1940  // Add base classes.
1941  if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1942    CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
1943
1944    struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1945    struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1946    ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1947    ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1948    ToData.Aggregate = FromData.Aggregate;
1949    ToData.PlainOldData = FromData.PlainOldData;
1950    ToData.Empty = FromData.Empty;
1951    ToData.Polymorphic = FromData.Polymorphic;
1952    ToData.Abstract = FromData.Abstract;
1953    ToData.IsStandardLayout = FromData.IsStandardLayout;
1954    ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
1955    ToData.HasPrivateFields = FromData.HasPrivateFields;
1956    ToData.HasProtectedFields = FromData.HasProtectedFields;
1957    ToData.HasPublicFields = FromData.HasPublicFields;
1958    ToData.HasMutableFields = FromData.HasMutableFields;
1959    ToData.HasVariantMembers = FromData.HasVariantMembers;
1960    ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1961    ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1962    ToData.HasUninitializedReferenceMember
1963      = FromData.HasUninitializedReferenceMember;
1964    ToData.NeedOverloadResolutionForMoveConstructor
1965      = FromData.NeedOverloadResolutionForMoveConstructor;
1966    ToData.NeedOverloadResolutionForMoveAssignment
1967      = FromData.NeedOverloadResolutionForMoveAssignment;
1968    ToData.NeedOverloadResolutionForDestructor
1969      = FromData.NeedOverloadResolutionForDestructor;
1970    ToData.DefaultedMoveConstructorIsDeleted
1971      = FromData.DefaultedMoveConstructorIsDeleted;
1972    ToData.DefaultedMoveAssignmentIsDeleted
1973      = FromData.DefaultedMoveAssignmentIsDeleted;
1974    ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1975    ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1976    ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1977    ToData.HasConstexprNonCopyMoveConstructor
1978      = FromData.HasConstexprNonCopyMoveConstructor;
1979    ToData.DefaultedDefaultConstructorIsConstexpr
1980      = FromData.DefaultedDefaultConstructorIsConstexpr;
1981    ToData.HasConstexprDefaultConstructor
1982      = FromData.HasConstexprDefaultConstructor;
1983    ToData.HasNonLiteralTypeFieldsOrBases
1984      = FromData.HasNonLiteralTypeFieldsOrBases;
1985    // ComputedVisibleConversions not imported.
1986    ToData.UserProvidedDefaultConstructor
1987      = FromData.UserProvidedDefaultConstructor;
1988    ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1989    ToData.ImplicitCopyConstructorHasConstParam
1990      = FromData.ImplicitCopyConstructorHasConstParam;
1991    ToData.ImplicitCopyAssignmentHasConstParam
1992      = FromData.ImplicitCopyAssignmentHasConstParam;
1993    ToData.HasDeclaredCopyConstructorWithConstParam
1994      = FromData.HasDeclaredCopyConstructorWithConstParam;
1995    ToData.HasDeclaredCopyAssignmentWithConstParam
1996      = FromData.HasDeclaredCopyAssignmentWithConstParam;
1997    ToData.IsLambda = FromData.IsLambda;
1998
1999    SmallVector<CXXBaseSpecifier *, 4> Bases;
2000    for (const auto &Base1 : FromCXX->bases()) {
2001      QualType T = Importer.Import(Base1.getType());
2002      if (T.isNull())
2003        return true;
2004
2005      SourceLocation EllipsisLoc;
2006      if (Base1.isPackExpansion())
2007        EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2008
2009      // Ensure that we have a definition for the base.
2010      ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2011
2012      Bases.push_back(
2013                    new (Importer.getToContext())
2014                      CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2015                                       Base1.isVirtual(),
2016                                       Base1.isBaseOfClass(),
2017                                       Base1.getAccessSpecifierAsWritten(),
2018                                   Importer.Import(Base1.getTypeSourceInfo()),
2019                                       EllipsisLoc));
2020    }
2021    if (!Bases.empty())
2022      ToCXX->setBases(Bases.data(), Bases.size());
2023  }
2024
2025  if (shouldForceImportDeclContext(Kind))
2026    ImportDeclContext(From, /*ForceImport=*/true);
2027
2028  To->completeDefinition();
2029  return false;
2030}
2031
2032bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2033                                       ImportDefinitionKind Kind) {
2034  if (To->getDefinition())
2035    return false;
2036
2037  // FIXME: Can we really import any initializer? Alternatively, we could force
2038  // ourselves to import every declaration of a variable and then only use
2039  // getInit() here.
2040  To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2041
2042  // FIXME: Other bits to merge?
2043
2044  return false;
2045}
2046
2047bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2048                                       ImportDefinitionKind Kind) {
2049  if (To->getDefinition() || To->isBeingDefined()) {
2050    if (Kind == IDK_Everything)
2051      ImportDeclContext(From, /*ForceImport=*/true);
2052    return false;
2053  }
2054
2055  To->startDefinition();
2056
2057  QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2058  if (T.isNull())
2059    return true;
2060
2061  QualType ToPromotionType = Importer.Import(From->getPromotionType());
2062  if (ToPromotionType.isNull())
2063    return true;
2064
2065  if (shouldForceImportDeclContext(Kind))
2066    ImportDeclContext(From, /*ForceImport=*/true);
2067
2068  // FIXME: we might need to merge the number of positive or negative bits
2069  // if the enumerator lists don't match.
2070  To->completeDefinition(T, ToPromotionType,
2071                         From->getNumPositiveBits(),
2072                         From->getNumNegativeBits());
2073  return false;
2074}
2075
2076TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2077                                                TemplateParameterList *Params) {
2078  SmallVector<NamedDecl *, 4> ToParams;
2079  ToParams.reserve(Params->size());
2080  for (TemplateParameterList::iterator P = Params->begin(),
2081                                    PEnd = Params->end();
2082       P != PEnd; ++P) {
2083    Decl *To = Importer.Import(*P);
2084    if (!To)
2085      return nullptr;
2086
2087    ToParams.push_back(cast<NamedDecl>(To));
2088  }
2089
2090  return TemplateParameterList::Create(Importer.getToContext(),
2091                                       Importer.Import(Params->getTemplateLoc()),
2092                                       Importer.Import(Params->getLAngleLoc()),
2093                                       ToParams.data(), ToParams.size(),
2094                                       Importer.Import(Params->getRAngleLoc()));
2095}
2096
2097TemplateArgument
2098ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2099  switch (From.getKind()) {
2100  case TemplateArgument::Null:
2101    return TemplateArgument();
2102
2103  case TemplateArgument::Type: {
2104    QualType ToType = Importer.Import(From.getAsType());
2105    if (ToType.isNull())
2106      return TemplateArgument();
2107    return TemplateArgument(ToType);
2108  }
2109
2110  case TemplateArgument::Integral: {
2111    QualType ToType = Importer.Import(From.getIntegralType());
2112    if (ToType.isNull())
2113      return TemplateArgument();
2114    return TemplateArgument(From, ToType);
2115  }
2116
2117  case TemplateArgument::Declaration: {
2118    ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2119    QualType ToType = Importer.Import(From.getParamTypeForDecl());
2120    if (!To || ToType.isNull())
2121      return TemplateArgument();
2122    return TemplateArgument(To, ToType);
2123  }
2124
2125  case TemplateArgument::NullPtr: {
2126    QualType ToType = Importer.Import(From.getNullPtrType());
2127    if (ToType.isNull())
2128      return TemplateArgument();
2129    return TemplateArgument(ToType, /*isNullPtr*/true);
2130  }
2131
2132  case TemplateArgument::Template: {
2133    TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2134    if (ToTemplate.isNull())
2135      return TemplateArgument();
2136
2137    return TemplateArgument(ToTemplate);
2138  }
2139
2140  case TemplateArgument::TemplateExpansion: {
2141    TemplateName ToTemplate
2142      = Importer.Import(From.getAsTemplateOrTemplatePattern());
2143    if (ToTemplate.isNull())
2144      return TemplateArgument();
2145
2146    return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2147  }
2148
2149  case TemplateArgument::Expression:
2150    if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2151      return TemplateArgument(ToExpr);
2152    return TemplateArgument();
2153
2154  case TemplateArgument::Pack: {
2155    SmallVector<TemplateArgument, 2> ToPack;
2156    ToPack.reserve(From.pack_size());
2157    if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2158      return TemplateArgument();
2159
2160    TemplateArgument *ToArgs
2161      = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2162    std::copy(ToPack.begin(), ToPack.end(), ToArgs);
2163    return TemplateArgument(ToArgs, ToPack.size());
2164  }
2165  }
2166
2167  llvm_unreachable("Invalid template argument kind");
2168}
2169
2170bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2171                                              unsigned NumFromArgs,
2172                              SmallVectorImpl<TemplateArgument> &ToArgs) {
2173  for (unsigned I = 0; I != NumFromArgs; ++I) {
2174    TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2175    if (To.isNull() && !FromArgs[I].isNull())
2176      return true;
2177
2178    ToArgs.push_back(To);
2179  }
2180
2181  return false;
2182}
2183
2184bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2185                                        RecordDecl *ToRecord, bool Complain) {
2186  // Eliminate a potential failure point where we attempt to re-import
2187  // something we're trying to import while completing ToRecord.
2188  Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2189  if (ToOrigin) {
2190    RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2191    if (ToOriginRecord)
2192      ToRecord = ToOriginRecord;
2193  }
2194
2195  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2196                                   ToRecord->getASTContext(),
2197                                   Importer.getNonEquivalentDecls(),
2198                                   false, Complain);
2199  return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2200}
2201
2202bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2203                                        bool Complain) {
2204  StructuralEquivalenceContext Ctx(
2205      Importer.getFromContext(), Importer.getToContext(),
2206      Importer.getNonEquivalentDecls(), false, Complain);
2207  return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2208}
2209
2210bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2211  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2212                                   Importer.getToContext(),
2213                                   Importer.getNonEquivalentDecls());
2214  return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2215}
2216
2217bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2218                                        EnumConstantDecl *ToEC)
2219{
2220  const llvm::APSInt &FromVal = FromEC->getInitVal();
2221  const llvm::APSInt &ToVal = ToEC->getInitVal();
2222
2223  return FromVal.isSigned() == ToVal.isSigned() &&
2224         FromVal.getBitWidth() == ToVal.getBitWidth() &&
2225         FromVal == ToVal;
2226}
2227
2228bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2229                                        ClassTemplateDecl *To) {
2230  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2231                                   Importer.getToContext(),
2232                                   Importer.getNonEquivalentDecls());
2233  return Ctx.IsStructurallyEquivalent(From, To);
2234}
2235
2236bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2237                                        VarTemplateDecl *To) {
2238  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2239                                   Importer.getToContext(),
2240                                   Importer.getNonEquivalentDecls());
2241  return Ctx.IsStructurallyEquivalent(From, To);
2242}
2243
2244Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2245  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2246    << D->getDeclKindName();
2247  return nullptr;
2248}
2249
2250Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2251  TranslationUnitDecl *ToD =
2252    Importer.getToContext().getTranslationUnitDecl();
2253
2254  Importer.Imported(D, ToD);
2255
2256  return ToD;
2257}
2258
2259Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2260  // Import the major distinguishing characteristics of this namespace.
2261  DeclContext *DC, *LexicalDC;
2262  DeclarationName Name;
2263  SourceLocation Loc;
2264  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2265    return nullptr;
2266
2267  NamespaceDecl *MergeWithNamespace = nullptr;
2268  if (!Name) {
2269    // This is an anonymous namespace. Adopt an existing anonymous
2270    // namespace if we can.
2271    // FIXME: Not testable.
2272    if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2273      MergeWithNamespace = TU->getAnonymousNamespace();
2274    else
2275      MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2276  } else {
2277    SmallVector<NamedDecl *, 4> ConflictingDecls;
2278    SmallVector<NamedDecl *, 2> FoundDecls;
2279    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2280    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2281      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2282        continue;
2283
2284      if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2285        MergeWithNamespace = FoundNS;
2286        ConflictingDecls.clear();
2287        break;
2288      }
2289
2290      ConflictingDecls.push_back(FoundDecls[I]);
2291    }
2292
2293    if (!ConflictingDecls.empty()) {
2294      Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2295                                         ConflictingDecls.data(),
2296                                         ConflictingDecls.size());
2297    }
2298  }
2299
2300  // Create the "to" namespace, if needed.
2301  NamespaceDecl *ToNamespace = MergeWithNamespace;
2302  if (!ToNamespace) {
2303    ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2304                                        D->isInline(),
2305                                        Importer.Import(D->getLocStart()),
2306                                        Loc, Name.getAsIdentifierInfo(),
2307                                        /*PrevDecl=*/nullptr);
2308    ToNamespace->setLexicalDeclContext(LexicalDC);
2309    LexicalDC->addDeclInternal(ToNamespace);
2310
2311    // If this is an anonymous namespace, register it as the anonymous
2312    // namespace within its context.
2313    if (!Name) {
2314      if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2315        TU->setAnonymousNamespace(ToNamespace);
2316      else
2317        cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2318    }
2319  }
2320  Importer.Imported(D, ToNamespace);
2321
2322  ImportDeclContext(D);
2323
2324  return ToNamespace;
2325}
2326
2327Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2328  // Import the major distinguishing characteristics of this typedef.
2329  DeclContext *DC, *LexicalDC;
2330  DeclarationName Name;
2331  SourceLocation Loc;
2332  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2333    return nullptr;
2334
2335  // If this typedef is not in block scope, determine whether we've
2336  // seen a typedef with the same name (that we can merge with) or any
2337  // other entity by that name (which name lookup could conflict with).
2338  if (!DC->isFunctionOrMethod()) {
2339    SmallVector<NamedDecl *, 4> ConflictingDecls;
2340    unsigned IDNS = Decl::IDNS_Ordinary;
2341    SmallVector<NamedDecl *, 2> FoundDecls;
2342    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2343    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2344      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2345        continue;
2346      if (TypedefNameDecl *FoundTypedef =
2347            dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2348        if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2349                                            FoundTypedef->getUnderlyingType()))
2350          return Importer.Imported(D, FoundTypedef);
2351      }
2352
2353      ConflictingDecls.push_back(FoundDecls[I]);
2354    }
2355
2356    if (!ConflictingDecls.empty()) {
2357      Name = Importer.HandleNameConflict(Name, DC, IDNS,
2358                                         ConflictingDecls.data(),
2359                                         ConflictingDecls.size());
2360      if (!Name)
2361        return nullptr;
2362    }
2363  }
2364
2365  // Import the underlying type of this typedef;
2366  QualType T = Importer.Import(D->getUnderlyingType());
2367  if (T.isNull())
2368    return nullptr;
2369
2370  // Create the new typedef node.
2371  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2372  SourceLocation StartL = Importer.Import(D->getLocStart());
2373  TypedefNameDecl *ToTypedef;
2374  if (IsAlias)
2375    ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2376                                      StartL, Loc,
2377                                      Name.getAsIdentifierInfo(),
2378                                      TInfo);
2379  else
2380    ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2381                                    StartL, Loc,
2382                                    Name.getAsIdentifierInfo(),
2383                                    TInfo);
2384
2385  ToTypedef->setAccess(D->getAccess());
2386  ToTypedef->setLexicalDeclContext(LexicalDC);
2387  Importer.Imported(D, ToTypedef);
2388  LexicalDC->addDeclInternal(ToTypedef);
2389
2390  return ToTypedef;
2391}
2392
2393Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2394  return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2395}
2396
2397Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2398  return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2399}
2400
2401Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2402  // Import the major distinguishing characteristics of this enum.
2403  DeclContext *DC, *LexicalDC;
2404  DeclarationName Name;
2405  SourceLocation Loc;
2406  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2407    return nullptr;
2408
2409  // Figure out what enum name we're looking for.
2410  unsigned IDNS = Decl::IDNS_Tag;
2411  DeclarationName SearchName = Name;
2412  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2413    SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2414    IDNS = Decl::IDNS_Ordinary;
2415  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2416    IDNS |= Decl::IDNS_Ordinary;
2417
2418  // We may already have an enum of the same name; try to find and match it.
2419  if (!DC->isFunctionOrMethod() && SearchName) {
2420    SmallVector<NamedDecl *, 4> ConflictingDecls;
2421    SmallVector<NamedDecl *, 2> FoundDecls;
2422    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2423    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2424      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2425        continue;
2426
2427      Decl *Found = FoundDecls[I];
2428      if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2429        if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2430          Found = Tag->getDecl();
2431      }
2432
2433      if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2434        if (IsStructuralMatch(D, FoundEnum))
2435          return Importer.Imported(D, FoundEnum);
2436      }
2437
2438      ConflictingDecls.push_back(FoundDecls[I]);
2439    }
2440
2441    if (!ConflictingDecls.empty()) {
2442      Name = Importer.HandleNameConflict(Name, DC, IDNS,
2443                                         ConflictingDecls.data(),
2444                                         ConflictingDecls.size());
2445    }
2446  }
2447
2448  // Create the enum declaration.
2449  EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2450                                  Importer.Import(D->getLocStart()),
2451                                  Loc, Name.getAsIdentifierInfo(), nullptr,
2452                                  D->isScoped(), D->isScopedUsingClassTag(),
2453                                  D->isFixed());
2454  // Import the qualifier, if any.
2455  D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2456  D2->setAccess(D->getAccess());
2457  D2->setLexicalDeclContext(LexicalDC);
2458  Importer.Imported(D, D2);
2459  LexicalDC->addDeclInternal(D2);
2460
2461  // Import the integer type.
2462  QualType ToIntegerType = Importer.Import(D->getIntegerType());
2463  if (ToIntegerType.isNull())
2464    return nullptr;
2465  D2->setIntegerType(ToIntegerType);
2466
2467  // Import the definition
2468  if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2469    return nullptr;
2470
2471  return D2;
2472}
2473
2474Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2475  // If this record has a definition in the translation unit we're coming from,
2476  // but this particular declaration is not that definition, import the
2477  // definition and map to that.
2478  TagDecl *Definition = D->getDefinition();
2479  if (Definition && Definition != D) {
2480    Decl *ImportedDef = Importer.Import(Definition);
2481    if (!ImportedDef)
2482      return nullptr;
2483
2484    return Importer.Imported(D, ImportedDef);
2485  }
2486
2487  // Import the major distinguishing characteristics of this record.
2488  DeclContext *DC, *LexicalDC;
2489  DeclarationName Name;
2490  SourceLocation Loc;
2491  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2492    return nullptr;
2493
2494  // Figure out what structure name we're looking for.
2495  unsigned IDNS = Decl::IDNS_Tag;
2496  DeclarationName SearchName = Name;
2497  if (!SearchName && D->getTypedefNameForAnonDecl()) {
2498    SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2499    IDNS = Decl::IDNS_Ordinary;
2500  } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2501    IDNS |= Decl::IDNS_Ordinary;
2502
2503  // We may already have a record of the same name; try to find and match it.
2504  RecordDecl *AdoptDecl = nullptr;
2505  if (!DC->isFunctionOrMethod()) {
2506    SmallVector<NamedDecl *, 4> ConflictingDecls;
2507    SmallVector<NamedDecl *, 2> FoundDecls;
2508    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2509    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2510      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2511        continue;
2512
2513      Decl *Found = FoundDecls[I];
2514      if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2515        if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2516          Found = Tag->getDecl();
2517      }
2518
2519      if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2520        if (D->isAnonymousStructOrUnion() &&
2521            FoundRecord->isAnonymousStructOrUnion()) {
2522          // If both anonymous structs/unions are in a record context, make sure
2523          // they occur in the same location in the context records.
2524          if (Optional<unsigned> Index1
2525              = findAnonymousStructOrUnionIndex(D)) {
2526            if (Optional<unsigned> Index2 =
2527                    findAnonymousStructOrUnionIndex(FoundRecord)) {
2528              if (*Index1 != *Index2)
2529                continue;
2530            }
2531          }
2532        }
2533
2534        if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2535          if ((SearchName && !D->isCompleteDefinition())
2536              || (D->isCompleteDefinition() &&
2537                  D->isAnonymousStructOrUnion()
2538                    == FoundDef->isAnonymousStructOrUnion() &&
2539                  IsStructuralMatch(D, FoundDef))) {
2540            // The record types structurally match, or the "from" translation
2541            // unit only had a forward declaration anyway; call it the same
2542            // function.
2543            // FIXME: For C++, we should also merge methods here.
2544            return Importer.Imported(D, FoundDef);
2545          }
2546        } else if (!D->isCompleteDefinition()) {
2547          // We have a forward declaration of this type, so adopt that forward
2548          // declaration rather than building a new one.
2549
2550          // If one or both can be completed from external storage then try one
2551          // last time to complete and compare them before doing this.
2552
2553          if (FoundRecord->hasExternalLexicalStorage() &&
2554              !FoundRecord->isCompleteDefinition())
2555            FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2556          if (D->hasExternalLexicalStorage())
2557            D->getASTContext().getExternalSource()->CompleteType(D);
2558
2559          if (FoundRecord->isCompleteDefinition() &&
2560              D->isCompleteDefinition() &&
2561              !IsStructuralMatch(D, FoundRecord))
2562            continue;
2563
2564          AdoptDecl = FoundRecord;
2565          continue;
2566        } else if (!SearchName) {
2567          continue;
2568        }
2569      }
2570
2571      ConflictingDecls.push_back(FoundDecls[I]);
2572    }
2573
2574    if (!ConflictingDecls.empty() && SearchName) {
2575      Name = Importer.HandleNameConflict(Name, DC, IDNS,
2576                                         ConflictingDecls.data(),
2577                                         ConflictingDecls.size());
2578    }
2579  }
2580
2581  // Create the record declaration.
2582  RecordDecl *D2 = AdoptDecl;
2583  SourceLocation StartLoc = Importer.Import(D->getLocStart());
2584  if (!D2) {
2585    if (isa<CXXRecordDecl>(D)) {
2586      CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2587                                                   D->getTagKind(),
2588                                                   DC, StartLoc, Loc,
2589                                                   Name.getAsIdentifierInfo());
2590      D2 = D2CXX;
2591      D2->setAccess(D->getAccess());
2592    } else {
2593      D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2594                              DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2595    }
2596
2597    D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2598    D2->setLexicalDeclContext(LexicalDC);
2599    LexicalDC->addDeclInternal(D2);
2600    if (D->isAnonymousStructOrUnion())
2601      D2->setAnonymousStructOrUnion(true);
2602  }
2603
2604  Importer.Imported(D, D2);
2605
2606  if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2607    return nullptr;
2608
2609  return D2;
2610}
2611
2612Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2613  // Import the major distinguishing characteristics of this enumerator.
2614  DeclContext *DC, *LexicalDC;
2615  DeclarationName Name;
2616  SourceLocation Loc;
2617  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2618    return nullptr;
2619
2620  QualType T = Importer.Import(D->getType());
2621  if (T.isNull())
2622    return nullptr;
2623
2624  // Determine whether there are any other declarations with the same name and
2625  // in the same context.
2626  if (!LexicalDC->isFunctionOrMethod()) {
2627    SmallVector<NamedDecl *, 4> ConflictingDecls;
2628    unsigned IDNS = Decl::IDNS_Ordinary;
2629    SmallVector<NamedDecl *, 2> FoundDecls;
2630    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2631    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2632      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2633        continue;
2634
2635      if (EnumConstantDecl *FoundEnumConstant
2636            = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2637        if (IsStructuralMatch(D, FoundEnumConstant))
2638          return Importer.Imported(D, FoundEnumConstant);
2639      }
2640
2641      ConflictingDecls.push_back(FoundDecls[I]);
2642    }
2643
2644    if (!ConflictingDecls.empty()) {
2645      Name = Importer.HandleNameConflict(Name, DC, IDNS,
2646                                         ConflictingDecls.data(),
2647                                         ConflictingDecls.size());
2648      if (!Name)
2649        return nullptr;
2650    }
2651  }
2652
2653  Expr *Init = Importer.Import(D->getInitExpr());
2654  if (D->getInitExpr() && !Init)
2655    return nullptr;
2656
2657  EnumConstantDecl *ToEnumerator
2658    = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2659                               Name.getAsIdentifierInfo(), T,
2660                               Init, D->getInitVal());
2661  ToEnumerator->setAccess(D->getAccess());
2662  ToEnumerator->setLexicalDeclContext(LexicalDC);
2663  Importer.Imported(D, ToEnumerator);
2664  LexicalDC->addDeclInternal(ToEnumerator);
2665  return ToEnumerator;
2666}
2667
2668Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2669  // Import the major distinguishing characteristics of this function.
2670  DeclContext *DC, *LexicalDC;
2671  DeclarationName Name;
2672  SourceLocation Loc;
2673  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2674    return nullptr;
2675
2676  // Try to find a function in our own ("to") context with the same name, same
2677  // type, and in the same context as the function we're importing.
2678  if (!LexicalDC->isFunctionOrMethod()) {
2679    SmallVector<NamedDecl *, 4> ConflictingDecls;
2680    unsigned IDNS = Decl::IDNS_Ordinary;
2681    SmallVector<NamedDecl *, 2> FoundDecls;
2682    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2683    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2684      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2685        continue;
2686
2687      if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2688        if (FoundFunction->hasExternalFormalLinkage() &&
2689            D->hasExternalFormalLinkage()) {
2690          if (Importer.IsStructurallyEquivalent(D->getType(),
2691                                                FoundFunction->getType())) {
2692            // FIXME: Actually try to merge the body and other attributes.
2693            return Importer.Imported(D, FoundFunction);
2694          }
2695
2696          // FIXME: Check for overloading more carefully, e.g., by boosting
2697          // Sema::IsOverload out to the AST library.
2698
2699          // Function overloading is okay in C++.
2700          if (Importer.getToContext().getLangOpts().CPlusPlus)
2701            continue;
2702
2703          // Complain about inconsistent function types.
2704          Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2705            << Name << D->getType() << FoundFunction->getType();
2706          Importer.ToDiag(FoundFunction->getLocation(),
2707                          diag::note_odr_value_here)
2708            << FoundFunction->getType();
2709        }
2710      }
2711
2712      ConflictingDecls.push_back(FoundDecls[I]);
2713    }
2714
2715    if (!ConflictingDecls.empty()) {
2716      Name = Importer.HandleNameConflict(Name, DC, IDNS,
2717                                         ConflictingDecls.data(),
2718                                         ConflictingDecls.size());
2719      if (!Name)
2720        return nullptr;
2721    }
2722  }
2723
2724  DeclarationNameInfo NameInfo(Name, Loc);
2725  // Import additional name location/type info.
2726  ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2727
2728  QualType FromTy = D->getType();
2729  bool usedDifferentExceptionSpec = false;
2730
2731  if (const FunctionProtoType *
2732        FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2733    FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2734    // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2735    // FunctionDecl that we are importing the FunctionProtoType for.
2736    // To avoid an infinite recursion when importing, create the FunctionDecl
2737    // with a simplified function type and update it afterwards.
2738    if (FromEPI.ExceptionSpec.SourceDecl ||
2739        FromEPI.ExceptionSpec.SourceTemplate ||
2740        FromEPI.ExceptionSpec.NoexceptExpr) {
2741      FunctionProtoType::ExtProtoInfo DefaultEPI;
2742      FromTy = Importer.getFromContext().getFunctionType(
2743          FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2744      usedDifferentExceptionSpec = true;
2745    }
2746  }
2747
2748  // Import the type.
2749  QualType T = Importer.Import(FromTy);
2750  if (T.isNull())
2751    return nullptr;
2752
2753  // Import the function parameters.
2754  SmallVector<ParmVarDecl *, 8> Parameters;
2755  for (auto P : D->params()) {
2756    ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2757    if (!ToP)
2758      return nullptr;
2759
2760    Parameters.push_back(ToP);
2761  }
2762
2763  // Create the imported function.
2764  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2765  FunctionDecl *ToFunction = nullptr;
2766  if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2767    ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2768                                            cast<CXXRecordDecl>(DC),
2769                                            D->getInnerLocStart(),
2770                                            NameInfo, T, TInfo,
2771                                            FromConstructor->isExplicit(),
2772                                            D->isInlineSpecified(),
2773                                            D->isImplicit(),
2774                                            D->isConstexpr());
2775  } else if (isa<CXXDestructorDecl>(D)) {
2776    ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2777                                           cast<CXXRecordDecl>(DC),
2778                                           D->getInnerLocStart(),
2779                                           NameInfo, T, TInfo,
2780                                           D->isInlineSpecified(),
2781                                           D->isImplicit());
2782  } else if (CXXConversionDecl *FromConversion
2783                                           = dyn_cast<CXXConversionDecl>(D)) {
2784    ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2785                                           cast<CXXRecordDecl>(DC),
2786                                           D->getInnerLocStart(),
2787                                           NameInfo, T, TInfo,
2788                                           D->isInlineSpecified(),
2789                                           FromConversion->isExplicit(),
2790                                           D->isConstexpr(),
2791                                           Importer.Import(D->getLocEnd()));
2792  } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2793    ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2794                                       cast<CXXRecordDecl>(DC),
2795                                       D->getInnerLocStart(),
2796                                       NameInfo, T, TInfo,
2797                                       Method->getStorageClass(),
2798                                       Method->isInlineSpecified(),
2799                                       D->isConstexpr(),
2800                                       Importer.Import(D->getLocEnd()));
2801  } else {
2802    ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2803                                      D->getInnerLocStart(),
2804                                      NameInfo, T, TInfo, D->getStorageClass(),
2805                                      D->isInlineSpecified(),
2806                                      D->hasWrittenPrototype(),
2807                                      D->isConstexpr());
2808  }
2809
2810  // Import the qualifier, if any.
2811  ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2812  ToFunction->setAccess(D->getAccess());
2813  ToFunction->setLexicalDeclContext(LexicalDC);
2814  ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2815  ToFunction->setTrivial(D->isTrivial());
2816  ToFunction->setPure(D->isPure());
2817  Importer.Imported(D, ToFunction);
2818
2819  // Set the parameters.
2820  for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2821    Parameters[I]->setOwningFunction(ToFunction);
2822    ToFunction->addDeclInternal(Parameters[I]);
2823  }
2824  ToFunction->setParams(Parameters);
2825
2826  if (usedDifferentExceptionSpec) {
2827    // Update FunctionProtoType::ExtProtoInfo.
2828    QualType T = Importer.Import(D->getType());
2829    if (T.isNull())
2830      return nullptr;
2831    ToFunction->setType(T);
2832  }
2833
2834  // FIXME: Other bits to merge?
2835
2836  // Add this function to the lexical context.
2837  LexicalDC->addDeclInternal(ToFunction);
2838
2839  return ToFunction;
2840}
2841
2842Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2843  return VisitFunctionDecl(D);
2844}
2845
2846Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2847  return VisitCXXMethodDecl(D);
2848}
2849
2850Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2851  return VisitCXXMethodDecl(D);
2852}
2853
2854Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2855  return VisitCXXMethodDecl(D);
2856}
2857
2858static unsigned getFieldIndex(Decl *F) {
2859  RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2860  if (!Owner)
2861    return 0;
2862
2863  unsigned Index = 1;
2864  for (const auto *D : Owner->noload_decls()) {
2865    if (D == F)
2866      return Index;
2867
2868    if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2869      ++Index;
2870  }
2871
2872  return Index;
2873}
2874
2875Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2876  // Import the major distinguishing characteristics of a variable.
2877  DeclContext *DC, *LexicalDC;
2878  DeclarationName Name;
2879  SourceLocation Loc;
2880  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2881    return nullptr;
2882
2883  // Determine whether we've already imported this field.
2884  SmallVector<NamedDecl *, 2> FoundDecls;
2885  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2886  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2887    if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2888      // For anonymous fields, match up by index.
2889      if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2890        continue;
2891
2892      if (Importer.IsStructurallyEquivalent(D->getType(),
2893                                            FoundField->getType())) {
2894        Importer.Imported(D, FoundField);
2895        return FoundField;
2896      }
2897
2898      Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2899        << Name << D->getType() << FoundField->getType();
2900      Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2901        << FoundField->getType();
2902      return nullptr;
2903    }
2904  }
2905
2906  // Import the type.
2907  QualType T = Importer.Import(D->getType());
2908  if (T.isNull())
2909    return nullptr;
2910
2911  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2912  Expr *BitWidth = Importer.Import(D->getBitWidth());
2913  if (!BitWidth && D->getBitWidth())
2914    return nullptr;
2915
2916  FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2917                                         Importer.Import(D->getInnerLocStart()),
2918                                         Loc, Name.getAsIdentifierInfo(),
2919                                         T, TInfo, BitWidth, D->isMutable(),
2920                                         D->getInClassInitStyle());
2921  ToField->setAccess(D->getAccess());
2922  ToField->setLexicalDeclContext(LexicalDC);
2923  if (ToField->hasInClassInitializer())
2924    ToField->setInClassInitializer(D->getInClassInitializer());
2925  ToField->setImplicit(D->isImplicit());
2926  Importer.Imported(D, ToField);
2927  LexicalDC->addDeclInternal(ToField);
2928  return ToField;
2929}
2930
2931Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2932  // Import the major distinguishing characteristics of a variable.
2933  DeclContext *DC, *LexicalDC;
2934  DeclarationName Name;
2935  SourceLocation Loc;
2936  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2937    return nullptr;
2938
2939  // Determine whether we've already imported this field.
2940  SmallVector<NamedDecl *, 2> FoundDecls;
2941  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2942  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2943    if (IndirectFieldDecl *FoundField
2944                                = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2945      // For anonymous indirect fields, match up by index.
2946      if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2947        continue;
2948
2949      if (Importer.IsStructurallyEquivalent(D->getType(),
2950                                            FoundField->getType(),
2951                                            !Name.isEmpty())) {
2952        Importer.Imported(D, FoundField);
2953        return FoundField;
2954      }
2955
2956      // If there are more anonymous fields to check, continue.
2957      if (!Name && I < N-1)
2958        continue;
2959
2960      Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2961        << Name << D->getType() << FoundField->getType();
2962      Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2963        << FoundField->getType();
2964      return nullptr;
2965    }
2966  }
2967
2968  // Import the type.
2969  QualType T = Importer.Import(D->getType());
2970  if (T.isNull())
2971    return nullptr;
2972
2973  NamedDecl **NamedChain =
2974    new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2975
2976  unsigned i = 0;
2977  for (auto *PI : D->chain()) {
2978    Decl *D = Importer.Import(PI);
2979    if (!D)
2980      return nullptr;
2981    NamedChain[i++] = cast<NamedDecl>(D);
2982  }
2983
2984  IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
2985      Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
2986      NamedChain, D->getChainingSize());
2987
2988  for (const auto *Attr : D->attrs())
2989    ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
2990
2991  ToIndirectField->setAccess(D->getAccess());
2992  ToIndirectField->setLexicalDeclContext(LexicalDC);
2993  Importer.Imported(D, ToIndirectField);
2994  LexicalDC->addDeclInternal(ToIndirectField);
2995  return ToIndirectField;
2996}
2997
2998Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
2999  // Import the major distinguishing characteristics of an ivar.
3000  DeclContext *DC, *LexicalDC;
3001  DeclarationName Name;
3002  SourceLocation Loc;
3003  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3004    return nullptr;
3005
3006  // Determine whether we've already imported this ivar
3007  SmallVector<NamedDecl *, 2> FoundDecls;
3008  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3009  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3010    if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3011      if (Importer.IsStructurallyEquivalent(D->getType(),
3012                                            FoundIvar->getType())) {
3013        Importer.Imported(D, FoundIvar);
3014        return FoundIvar;
3015      }
3016
3017      Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3018        << Name << D->getType() << FoundIvar->getType();
3019      Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3020        << FoundIvar->getType();
3021      return nullptr;
3022    }
3023  }
3024
3025  // Import the type.
3026  QualType T = Importer.Import(D->getType());
3027  if (T.isNull())
3028    return nullptr;
3029
3030  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3031  Expr *BitWidth = Importer.Import(D->getBitWidth());
3032  if (!BitWidth && D->getBitWidth())
3033    return nullptr;
3034
3035  ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3036                                              cast<ObjCContainerDecl>(DC),
3037                                       Importer.Import(D->getInnerLocStart()),
3038                                              Loc, Name.getAsIdentifierInfo(),
3039                                              T, TInfo, D->getAccessControl(),
3040                                              BitWidth, D->getSynthesize());
3041  ToIvar->setLexicalDeclContext(LexicalDC);
3042  Importer.Imported(D, ToIvar);
3043  LexicalDC->addDeclInternal(ToIvar);
3044  return ToIvar;
3045
3046}
3047
3048Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3049  // Import the major distinguishing characteristics of a variable.
3050  DeclContext *DC, *LexicalDC;
3051  DeclarationName Name;
3052  SourceLocation Loc;
3053  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3054    return nullptr;
3055
3056  // Try to find a variable in our own ("to") context with the same name and
3057  // in the same context as the variable we're importing.
3058  if (D->isFileVarDecl()) {
3059    VarDecl *MergeWithVar = nullptr;
3060    SmallVector<NamedDecl *, 4> ConflictingDecls;
3061    unsigned IDNS = Decl::IDNS_Ordinary;
3062    SmallVector<NamedDecl *, 2> FoundDecls;
3063    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3064    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3065      if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3066        continue;
3067
3068      if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3069        // We have found a variable that we may need to merge with. Check it.
3070        if (FoundVar->hasExternalFormalLinkage() &&
3071            D->hasExternalFormalLinkage()) {
3072          if (Importer.IsStructurallyEquivalent(D->getType(),
3073                                                FoundVar->getType())) {
3074            MergeWithVar = FoundVar;
3075            break;
3076          }
3077
3078          const ArrayType *FoundArray
3079            = Importer.getToContext().getAsArrayType(FoundVar->getType());
3080          const ArrayType *TArray
3081            = Importer.getToContext().getAsArrayType(D->getType());
3082          if (FoundArray && TArray) {
3083            if (isa<IncompleteArrayType>(FoundArray) &&
3084                isa<ConstantArrayType>(TArray)) {
3085              // Import the type.
3086              QualType T = Importer.Import(D->getType());
3087              if (T.isNull())
3088                return nullptr;
3089
3090              FoundVar->setType(T);
3091              MergeWithVar = FoundVar;
3092              break;
3093            } else if (isa<IncompleteArrayType>(TArray) &&
3094                       isa<ConstantArrayType>(FoundArray)) {
3095              MergeWithVar = FoundVar;
3096              break;
3097            }
3098          }
3099
3100          Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3101            << Name << D->getType() << FoundVar->getType();
3102          Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3103            << FoundVar->getType();
3104        }
3105      }
3106
3107      ConflictingDecls.push_back(FoundDecls[I]);
3108    }
3109
3110    if (MergeWithVar) {
3111      // An equivalent variable with external linkage has been found. Link
3112      // the two declarations, then merge them.
3113      Importer.Imported(D, MergeWithVar);
3114
3115      if (VarDecl *DDef = D->getDefinition()) {
3116        if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3117          Importer.ToDiag(ExistingDef->getLocation(),
3118                          diag::err_odr_variable_multiple_def)
3119            << Name;
3120          Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3121        } else {
3122          Expr *Init = Importer.Import(DDef->getInit());
3123          MergeWithVar->setInit(Init);
3124          if (DDef->isInitKnownICE()) {
3125            EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3126            Eval->CheckedICE = true;
3127            Eval->IsICE = DDef->isInitICE();
3128          }
3129        }
3130      }
3131
3132      return MergeWithVar;
3133    }
3134
3135    if (!ConflictingDecls.empty()) {
3136      Name = Importer.HandleNameConflict(Name, DC, IDNS,
3137                                         ConflictingDecls.data(),
3138                                         ConflictingDecls.size());
3139      if (!Name)
3140        return nullptr;
3141    }
3142  }
3143
3144  // Import the type.
3145  QualType T = Importer.Import(D->getType());
3146  if (T.isNull())
3147    return nullptr;
3148
3149  // Create the imported variable.
3150  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3151  VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3152                                   Importer.Import(D->getInnerLocStart()),
3153                                   Loc, Name.getAsIdentifierInfo(),
3154                                   T, TInfo,
3155                                   D->getStorageClass());
3156  ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3157  ToVar->setAccess(D->getAccess());
3158  ToVar->setLexicalDeclContext(LexicalDC);
3159  Importer.Imported(D, ToVar);
3160  LexicalDC->addDeclInternal(ToVar);
3161
3162  // Merge the initializer.
3163  if (ImportDefinition(D, ToVar))
3164    return nullptr;
3165
3166  return ToVar;
3167}
3168
3169Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3170  // Parameters are created in the translation unit's context, then moved
3171  // into the function declaration's context afterward.
3172  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3173
3174  // Import the name of this declaration.
3175  DeclarationName Name = Importer.Import(D->getDeclName());
3176  if (D->getDeclName() && !Name)
3177    return nullptr;
3178
3179  // Import the location of this declaration.
3180  SourceLocation Loc = Importer.Import(D->getLocation());
3181
3182  // Import the parameter's type.
3183  QualType T = Importer.Import(D->getType());
3184  if (T.isNull())
3185    return nullptr;
3186
3187  // Create the imported parameter.
3188  ImplicitParamDecl *ToParm
3189    = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3190                                Loc, Name.getAsIdentifierInfo(),
3191                                T);
3192  return Importer.Imported(D, ToParm);
3193}
3194
3195Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3196  // Parameters are created in the translation unit's context, then moved
3197  // into the function declaration's context afterward.
3198  DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3199
3200  // Import the name of this declaration.
3201  DeclarationName Name = Importer.Import(D->getDeclName());
3202  if (D->getDeclName() && !Name)
3203    return nullptr;
3204
3205  // Import the location of this declaration.
3206  SourceLocation Loc = Importer.Import(D->getLocation());
3207
3208  // Import the parameter's type.
3209  QualType T = Importer.Import(D->getType());
3210  if (T.isNull())
3211    return nullptr;
3212
3213  // Create the imported parameter.
3214  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3215  ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3216                                     Importer.Import(D->getInnerLocStart()),
3217                                            Loc, Name.getAsIdentifierInfo(),
3218                                            T, TInfo, D->getStorageClass(),
3219                                            /*FIXME: Default argument*/nullptr);
3220  ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3221  return Importer.Imported(D, ToParm);
3222}
3223
3224Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3225  // Import the major distinguishing characteristics of a method.
3226  DeclContext *DC, *LexicalDC;
3227  DeclarationName Name;
3228  SourceLocation Loc;
3229  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3230    return nullptr;
3231
3232  SmallVector<NamedDecl *, 2> FoundDecls;
3233  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3234  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3235    if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3236      if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3237        continue;
3238
3239      // Check return types.
3240      if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3241                                             FoundMethod->getReturnType())) {
3242        Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3243            << D->isInstanceMethod() << Name << D->getReturnType()
3244            << FoundMethod->getReturnType();
3245        Importer.ToDiag(FoundMethod->getLocation(),
3246                        diag::note_odr_objc_method_here)
3247          << D->isInstanceMethod() << Name;
3248        return nullptr;
3249      }
3250
3251      // Check the number of parameters.
3252      if (D->param_size() != FoundMethod->param_size()) {
3253        Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3254          << D->isInstanceMethod() << Name
3255          << D->param_size() << FoundMethod->param_size();
3256        Importer.ToDiag(FoundMethod->getLocation(),
3257                        diag::note_odr_objc_method_here)
3258          << D->isInstanceMethod() << Name;
3259        return nullptr;
3260      }
3261
3262      // Check parameter types.
3263      for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3264             PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3265           P != PEnd; ++P, ++FoundP) {
3266        if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3267                                               (*FoundP)->getType())) {
3268          Importer.FromDiag((*P)->getLocation(),
3269                            diag::err_odr_objc_method_param_type_inconsistent)
3270            << D->isInstanceMethod() << Name
3271            << (*P)->getType() << (*FoundP)->getType();
3272          Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3273            << (*FoundP)->getType();
3274          return nullptr;
3275        }
3276      }
3277
3278      // Check variadic/non-variadic.
3279      // Check the number of parameters.
3280      if (D->isVariadic() != FoundMethod->isVariadic()) {
3281        Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3282          << D->isInstanceMethod() << Name;
3283        Importer.ToDiag(FoundMethod->getLocation(),
3284                        diag::note_odr_objc_method_here)
3285          << D->isInstanceMethod() << Name;
3286        return nullptr;
3287      }
3288
3289      // FIXME: Any other bits we need to merge?
3290      return Importer.Imported(D, FoundMethod);
3291    }
3292  }
3293
3294  // Import the result type.
3295  QualType ResultTy = Importer.Import(D->getReturnType());
3296  if (ResultTy.isNull())
3297    return nullptr;
3298
3299  TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3300
3301  ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3302      Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3303      Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3304      D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3305      D->getImplementationControl(), D->hasRelatedResultType());
3306
3307  // FIXME: When we decide to merge method definitions, we'll need to
3308  // deal with implicit parameters.
3309
3310  // Import the parameters
3311  SmallVector<ParmVarDecl *, 5> ToParams;
3312  for (auto *FromP : D->params()) {
3313    ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3314    if (!ToP)
3315      return nullptr;
3316
3317    ToParams.push_back(ToP);
3318  }
3319
3320  // Set the parameters.
3321  for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3322    ToParams[I]->setOwningFunction(ToMethod);
3323    ToMethod->addDeclInternal(ToParams[I]);
3324  }
3325  SmallVector<SourceLocation, 12> SelLocs;
3326  D->getSelectorLocs(SelLocs);
3327  ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3328
3329  ToMethod->setLexicalDeclContext(LexicalDC);
3330  Importer.Imported(D, ToMethod);
3331  LexicalDC->addDeclInternal(ToMethod);
3332  return ToMethod;
3333}
3334
3335Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3336  // Import the major distinguishing characteristics of a category.
3337  DeclContext *DC, *LexicalDC;
3338  DeclarationName Name;
3339  SourceLocation Loc;
3340  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3341    return nullptr;
3342
3343  ObjCInterfaceDecl *ToInterface
3344    = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3345  if (!ToInterface)
3346    return nullptr;
3347
3348  // Determine if we've already encountered this category.
3349  ObjCCategoryDecl *MergeWithCategory
3350    = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3351  ObjCCategoryDecl *ToCategory = MergeWithCategory;
3352  if (!ToCategory) {
3353    ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3354                                          Importer.Import(D->getAtStartLoc()),
3355                                          Loc,
3356                                       Importer.Import(D->getCategoryNameLoc()),
3357                                          Name.getAsIdentifierInfo(),
3358                                          ToInterface,
3359                                       Importer.Import(D->getIvarLBraceLoc()),
3360                                       Importer.Import(D->getIvarRBraceLoc()));
3361    ToCategory->setLexicalDeclContext(LexicalDC);
3362    LexicalDC->addDeclInternal(ToCategory);
3363    Importer.Imported(D, ToCategory);
3364
3365    // Import protocols
3366    SmallVector<ObjCProtocolDecl *, 4> Protocols;
3367    SmallVector<SourceLocation, 4> ProtocolLocs;
3368    ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3369      = D->protocol_loc_begin();
3370    for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3371                                          FromProtoEnd = D->protocol_end();
3372         FromProto != FromProtoEnd;
3373         ++FromProto, ++FromProtoLoc) {
3374      ObjCProtocolDecl *ToProto
3375        = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3376      if (!ToProto)
3377        return nullptr;
3378      Protocols.push_back(ToProto);
3379      ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3380    }
3381
3382    // FIXME: If we're merging, make sure that the protocol list is the same.
3383    ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3384                                ProtocolLocs.data(), Importer.getToContext());
3385
3386  } else {
3387    Importer.Imported(D, ToCategory);
3388  }
3389
3390  // Import all of the members of this category.
3391  ImportDeclContext(D);
3392
3393  // If we have an implementation, import it as well.
3394  if (D->getImplementation()) {
3395    ObjCCategoryImplDecl *Impl
3396      = cast_or_null<ObjCCategoryImplDecl>(
3397                                       Importer.Import(D->getImplementation()));
3398    if (!Impl)
3399      return nullptr;
3400
3401    ToCategory->setImplementation(Impl);
3402  }
3403
3404  return ToCategory;
3405}
3406
3407bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3408                                       ObjCProtocolDecl *To,
3409                                       ImportDefinitionKind Kind) {
3410  if (To->getDefinition()) {
3411    if (shouldForceImportDeclContext(Kind))
3412      ImportDeclContext(From);
3413    return false;
3414  }
3415
3416  // Start the protocol definition
3417  To->startDefinition();
3418
3419  // Import protocols
3420  SmallVector<ObjCProtocolDecl *, 4> Protocols;
3421  SmallVector<SourceLocation, 4> ProtocolLocs;
3422  ObjCProtocolDecl::protocol_loc_iterator
3423  FromProtoLoc = From->protocol_loc_begin();
3424  for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3425                                        FromProtoEnd = From->protocol_end();
3426       FromProto != FromProtoEnd;
3427       ++FromProto, ++FromProtoLoc) {
3428    ObjCProtocolDecl *ToProto
3429      = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3430    if (!ToProto)
3431      return true;
3432    Protocols.push_back(ToProto);
3433    ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3434  }
3435
3436  // FIXME: If we're merging, make sure that the protocol list is the same.
3437  To->setProtocolList(Protocols.data(), Protocols.size(),
3438                      ProtocolLocs.data(), Importer.getToContext());
3439
3440  if (shouldForceImportDeclContext(Kind)) {
3441    // Import all of the members of this protocol.
3442    ImportDeclContext(From, /*ForceImport=*/true);
3443  }
3444  return false;
3445}
3446
3447Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3448  // If this protocol has a definition in the translation unit we're coming
3449  // from, but this particular declaration is not that definition, import the
3450  // definition and map to that.
3451  ObjCProtocolDecl *Definition = D->getDefinition();
3452  if (Definition && Definition != D) {
3453    Decl *ImportedDef = Importer.Import(Definition);
3454    if (!ImportedDef)
3455      return nullptr;
3456
3457    return Importer.Imported(D, ImportedDef);
3458  }
3459
3460  // Import the major distinguishing characteristics of a protocol.
3461  DeclContext *DC, *LexicalDC;
3462  DeclarationName Name;
3463  SourceLocation Loc;
3464  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3465    return nullptr;
3466
3467  ObjCProtocolDecl *MergeWithProtocol = nullptr;
3468  SmallVector<NamedDecl *, 2> FoundDecls;
3469  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3470  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3471    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3472      continue;
3473
3474    if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3475      break;
3476  }
3477
3478  ObjCProtocolDecl *ToProto = MergeWithProtocol;
3479  if (!ToProto) {
3480    ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3481                                       Name.getAsIdentifierInfo(), Loc,
3482                                       Importer.Import(D->getAtStartLoc()),
3483                                       /*PrevDecl=*/nullptr);
3484    ToProto->setLexicalDeclContext(LexicalDC);
3485    LexicalDC->addDeclInternal(ToProto);
3486  }
3487
3488  Importer.Imported(D, ToProto);
3489
3490  if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3491    return nullptr;
3492
3493  return ToProto;
3494}
3495
3496Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3497  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3498  DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3499
3500  SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3501  SourceLocation LangLoc = Importer.Import(D->getLocation());
3502
3503  bool HasBraces = D->hasBraces();
3504
3505  LinkageSpecDecl *ToLinkageSpec =
3506    LinkageSpecDecl::Create(Importer.getToContext(),
3507                            DC,
3508                            ExternLoc,
3509                            LangLoc,
3510                            D->getLanguage(),
3511                            HasBraces);
3512
3513  if (HasBraces) {
3514    SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3515    ToLinkageSpec->setRBraceLoc(RBraceLoc);
3516  }
3517
3518  ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3519  LexicalDC->addDeclInternal(ToLinkageSpec);
3520
3521  Importer.Imported(D, ToLinkageSpec);
3522
3523  return ToLinkageSpec;
3524}
3525
3526bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3527                                       ObjCInterfaceDecl *To,
3528                                       ImportDefinitionKind Kind) {
3529  if (To->getDefinition()) {
3530    // Check consistency of superclass.
3531    ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3532    if (FromSuper) {
3533      FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3534      if (!FromSuper)
3535        return true;
3536    }
3537
3538    ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3539    if ((bool)FromSuper != (bool)ToSuper ||
3540        (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3541      Importer.ToDiag(To->getLocation(),
3542                      diag::err_odr_objc_superclass_inconsistent)
3543        << To->getDeclName();
3544      if (ToSuper)
3545        Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3546          << To->getSuperClass()->getDeclName();
3547      else
3548        Importer.ToDiag(To->getLocation(),
3549                        diag::note_odr_objc_missing_superclass);
3550      if (From->getSuperClass())
3551        Importer.FromDiag(From->getSuperClassLoc(),
3552                          diag::note_odr_objc_superclass)
3553        << From->getSuperClass()->getDeclName();
3554      else
3555        Importer.FromDiag(From->getLocation(),
3556                          diag::note_odr_objc_missing_superclass);
3557    }
3558
3559    if (shouldForceImportDeclContext(Kind))
3560      ImportDeclContext(From);
3561    return false;
3562  }
3563
3564  // Start the definition.
3565  To->startDefinition();
3566
3567  // If this class has a superclass, import it.
3568  if (From->getSuperClass()) {
3569    ObjCInterfaceDecl *Super = cast_or_null<ObjCInterfaceDecl>(
3570                                 Importer.Import(From->getSuperClass()));
3571    if (!Super)
3572      return true;
3573
3574    To->setSuperClass(Super);
3575    To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3576  }
3577
3578  // Import protocols
3579  SmallVector<ObjCProtocolDecl *, 4> Protocols;
3580  SmallVector<SourceLocation, 4> ProtocolLocs;
3581  ObjCInterfaceDecl::protocol_loc_iterator
3582  FromProtoLoc = From->protocol_loc_begin();
3583
3584  for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3585                                         FromProtoEnd = From->protocol_end();
3586       FromProto != FromProtoEnd;
3587       ++FromProto, ++FromProtoLoc) {
3588    ObjCProtocolDecl *ToProto
3589      = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3590    if (!ToProto)
3591      return true;
3592    Protocols.push_back(ToProto);
3593    ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3594  }
3595
3596  // FIXME: If we're merging, make sure that the protocol list is the same.
3597  To->setProtocolList(Protocols.data(), Protocols.size(),
3598                      ProtocolLocs.data(), Importer.getToContext());
3599
3600  // Import categories. When the categories themselves are imported, they'll
3601  // hook themselves into this interface.
3602  for (auto *Cat : From->known_categories())
3603    Importer.Import(Cat);
3604
3605  // If we have an @implementation, import it as well.
3606  if (From->getImplementation()) {
3607    ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3608                                     Importer.Import(From->getImplementation()));
3609    if (!Impl)
3610      return true;
3611
3612    To->setImplementation(Impl);
3613  }
3614
3615  if (shouldForceImportDeclContext(Kind)) {
3616    // Import all of the members of this class.
3617    ImportDeclContext(From, /*ForceImport=*/true);
3618  }
3619  return false;
3620}
3621
3622Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3623  // If this class has a definition in the translation unit we're coming from,
3624  // but this particular declaration is not that definition, import the
3625  // definition and map to that.
3626  ObjCInterfaceDecl *Definition = D->getDefinition();
3627  if (Definition && Definition != D) {
3628    Decl *ImportedDef = Importer.Import(Definition);
3629    if (!ImportedDef)
3630      return nullptr;
3631
3632    return Importer.Imported(D, ImportedDef);
3633  }
3634
3635  // Import the major distinguishing characteristics of an @interface.
3636  DeclContext *DC, *LexicalDC;
3637  DeclarationName Name;
3638  SourceLocation Loc;
3639  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3640    return nullptr;
3641
3642  // Look for an existing interface with the same name.
3643  ObjCInterfaceDecl *MergeWithIface = nullptr;
3644  SmallVector<NamedDecl *, 2> FoundDecls;
3645  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3646  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3647    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3648      continue;
3649
3650    if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3651      break;
3652  }
3653
3654  // Create an interface declaration, if one does not already exist.
3655  ObjCInterfaceDecl *ToIface = MergeWithIface;
3656  if (!ToIface) {
3657    ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3658                                        Importer.Import(D->getAtStartLoc()),
3659                                        Name.getAsIdentifierInfo(),
3660                                        /*PrevDecl=*/nullptr, Loc,
3661                                        D->isImplicitInterfaceDecl());
3662    ToIface->setLexicalDeclContext(LexicalDC);
3663    LexicalDC->addDeclInternal(ToIface);
3664  }
3665  Importer.Imported(D, ToIface);
3666
3667  if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3668    return nullptr;
3669
3670  return ToIface;
3671}
3672
3673Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3674  ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3675                                        Importer.Import(D->getCategoryDecl()));
3676  if (!Category)
3677    return nullptr;
3678
3679  ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3680  if (!ToImpl) {
3681    DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3682    if (!DC)
3683      return nullptr;
3684
3685    SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3686    ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3687                                          Importer.Import(D->getIdentifier()),
3688                                          Category->getClassInterface(),
3689                                          Importer.Import(D->getLocation()),
3690                                          Importer.Import(D->getAtStartLoc()),
3691                                          CategoryNameLoc);
3692
3693    DeclContext *LexicalDC = DC;
3694    if (D->getDeclContext() != D->getLexicalDeclContext()) {
3695      LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3696      if (!LexicalDC)
3697        return nullptr;
3698
3699      ToImpl->setLexicalDeclContext(LexicalDC);
3700    }
3701
3702    LexicalDC->addDeclInternal(ToImpl);
3703    Category->setImplementation(ToImpl);
3704  }
3705
3706  Importer.Imported(D, ToImpl);
3707  ImportDeclContext(D);
3708  return ToImpl;
3709}
3710
3711Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3712  // Find the corresponding interface.
3713  ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3714                                       Importer.Import(D->getClassInterface()));
3715  if (!Iface)
3716    return nullptr;
3717
3718  // Import the superclass, if any.
3719  ObjCInterfaceDecl *Super = nullptr;
3720  if (D->getSuperClass()) {
3721    Super = cast_or_null<ObjCInterfaceDecl>(
3722                                          Importer.Import(D->getSuperClass()));
3723    if (!Super)
3724      return nullptr;
3725  }
3726
3727  ObjCImplementationDecl *Impl = Iface->getImplementation();
3728  if (!Impl) {
3729    // We haven't imported an implementation yet. Create a new @implementation
3730    // now.
3731    Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3732                                  Importer.ImportContext(D->getDeclContext()),
3733                                          Iface, Super,
3734                                          Importer.Import(D->getLocation()),
3735                                          Importer.Import(D->getAtStartLoc()),
3736                                          Importer.Import(D->getSuperClassLoc()),
3737                                          Importer.Import(D->getIvarLBraceLoc()),
3738                                          Importer.Import(D->getIvarRBraceLoc()));
3739
3740    if (D->getDeclContext() != D->getLexicalDeclContext()) {
3741      DeclContext *LexicalDC
3742        = Importer.ImportContext(D->getLexicalDeclContext());
3743      if (!LexicalDC)
3744        return nullptr;
3745      Impl->setLexicalDeclContext(LexicalDC);
3746    }
3747
3748    // Associate the implementation with the class it implements.
3749    Iface->setImplementation(Impl);
3750    Importer.Imported(D, Iface->getImplementation());
3751  } else {
3752    Importer.Imported(D, Iface->getImplementation());
3753
3754    // Verify that the existing @implementation has the same superclass.
3755    if ((Super && !Impl->getSuperClass()) ||
3756        (!Super && Impl->getSuperClass()) ||
3757        (Super && Impl->getSuperClass() &&
3758         !declaresSameEntity(Super->getCanonicalDecl(),
3759                             Impl->getSuperClass()))) {
3760      Importer.ToDiag(Impl->getLocation(),
3761                      diag::err_odr_objc_superclass_inconsistent)
3762        << Iface->getDeclName();
3763      // FIXME: It would be nice to have the location of the superclass
3764      // below.
3765      if (Impl->getSuperClass())
3766        Importer.ToDiag(Impl->getLocation(),
3767                        diag::note_odr_objc_superclass)
3768        << Impl->getSuperClass()->getDeclName();
3769      else
3770        Importer.ToDiag(Impl->getLocation(),
3771                        diag::note_odr_objc_missing_superclass);
3772      if (D->getSuperClass())
3773        Importer.FromDiag(D->getLocation(),
3774                          diag::note_odr_objc_superclass)
3775        << D->getSuperClass()->getDeclName();
3776      else
3777        Importer.FromDiag(D->getLocation(),
3778                          diag::note_odr_objc_missing_superclass);
3779      return nullptr;
3780    }
3781  }
3782
3783  // Import all of the members of this @implementation.
3784  ImportDeclContext(D);
3785
3786  return Impl;
3787}
3788
3789Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3790  // Import the major distinguishing characteristics of an @property.
3791  DeclContext *DC, *LexicalDC;
3792  DeclarationName Name;
3793  SourceLocation Loc;
3794  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3795    return nullptr;
3796
3797  // Check whether we have already imported this property.
3798  SmallVector<NamedDecl *, 2> FoundDecls;
3799  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3800  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3801    if (ObjCPropertyDecl *FoundProp
3802                                = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3803      // Check property types.
3804      if (!Importer.IsStructurallyEquivalent(D->getType(),
3805                                             FoundProp->getType())) {
3806        Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3807          << Name << D->getType() << FoundProp->getType();
3808        Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3809          << FoundProp->getType();
3810        return nullptr;
3811      }
3812
3813      // FIXME: Check property attributes, getters, setters, etc.?
3814
3815      // Consider these properties to be equivalent.
3816      Importer.Imported(D, FoundProp);
3817      return FoundProp;
3818    }
3819  }
3820
3821  // Import the type.
3822  TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3823  if (!T)
3824    return nullptr;
3825
3826  // Create the new property.
3827  ObjCPropertyDecl *ToProperty
3828    = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3829                               Name.getAsIdentifierInfo(),
3830                               Importer.Import(D->getAtLoc()),
3831                               Importer.Import(D->getLParenLoc()),
3832                               T,
3833                               D->getPropertyImplementation());
3834  Importer.Imported(D, ToProperty);
3835  ToProperty->setLexicalDeclContext(LexicalDC);
3836  LexicalDC->addDeclInternal(ToProperty);
3837
3838  ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3839  ToProperty->setPropertyAttributesAsWritten(
3840                                      D->getPropertyAttributesAsWritten());
3841  ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3842  ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3843  ToProperty->setGetterMethodDecl(
3844     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3845  ToProperty->setSetterMethodDecl(
3846     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3847  ToProperty->setPropertyIvarDecl(
3848       cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3849  return ToProperty;
3850}
3851
3852Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3853  ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3854                                        Importer.Import(D->getPropertyDecl()));
3855  if (!Property)
3856    return nullptr;
3857
3858  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3859  if (!DC)
3860    return nullptr;
3861
3862  // Import the lexical declaration context.
3863  DeclContext *LexicalDC = DC;
3864  if (D->getDeclContext() != D->getLexicalDeclContext()) {
3865    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3866    if (!LexicalDC)
3867      return nullptr;
3868  }
3869
3870  ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3871  if (!InImpl)
3872    return nullptr;
3873
3874  // Import the ivar (for an @synthesize).
3875  ObjCIvarDecl *Ivar = nullptr;
3876  if (D->getPropertyIvarDecl()) {
3877    Ivar = cast_or_null<ObjCIvarDecl>(
3878                                    Importer.Import(D->getPropertyIvarDecl()));
3879    if (!Ivar)
3880      return nullptr;
3881  }
3882
3883  ObjCPropertyImplDecl *ToImpl
3884    = InImpl->FindPropertyImplDecl(Property->getIdentifier());
3885  if (!ToImpl) {
3886    ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3887                                          Importer.Import(D->getLocStart()),
3888                                          Importer.Import(D->getLocation()),
3889                                          Property,
3890                                          D->getPropertyImplementation(),
3891                                          Ivar,
3892                                  Importer.Import(D->getPropertyIvarDeclLoc()));
3893    ToImpl->setLexicalDeclContext(LexicalDC);
3894    Importer.Imported(D, ToImpl);
3895    LexicalDC->addDeclInternal(ToImpl);
3896  } else {
3897    // Check that we have the same kind of property implementation (@synthesize
3898    // vs. @dynamic).
3899    if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3900      Importer.ToDiag(ToImpl->getLocation(),
3901                      diag::err_odr_objc_property_impl_kind_inconsistent)
3902        << Property->getDeclName()
3903        << (ToImpl->getPropertyImplementation()
3904                                              == ObjCPropertyImplDecl::Dynamic);
3905      Importer.FromDiag(D->getLocation(),
3906                        diag::note_odr_objc_property_impl_kind)
3907        << D->getPropertyDecl()->getDeclName()
3908        << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3909      return nullptr;
3910    }
3911
3912    // For @synthesize, check that we have the same
3913    if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3914        Ivar != ToImpl->getPropertyIvarDecl()) {
3915      Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3916                      diag::err_odr_objc_synthesize_ivar_inconsistent)
3917        << Property->getDeclName()
3918        << ToImpl->getPropertyIvarDecl()->getDeclName()
3919        << Ivar->getDeclName();
3920      Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3921                        diag::note_odr_objc_synthesize_ivar_here)
3922        << D->getPropertyIvarDecl()->getDeclName();
3923      return nullptr;
3924    }
3925
3926    // Merge the existing implementation with the new implementation.
3927    Importer.Imported(D, ToImpl);
3928  }
3929
3930  return ToImpl;
3931}
3932
3933Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3934  // For template arguments, we adopt the translation unit as our declaration
3935  // context. This context will be fixed when the actual template declaration
3936  // is created.
3937
3938  // FIXME: Import default argument.
3939  return TemplateTypeParmDecl::Create(Importer.getToContext(),
3940                              Importer.getToContext().getTranslationUnitDecl(),
3941                                      Importer.Import(D->getLocStart()),
3942                                      Importer.Import(D->getLocation()),
3943                                      D->getDepth(),
3944                                      D->getIndex(),
3945                                      Importer.Import(D->getIdentifier()),
3946                                      D->wasDeclaredWithTypename(),
3947                                      D->isParameterPack());
3948}
3949
3950Decl *
3951ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3952  // Import the name of this declaration.
3953  DeclarationName Name = Importer.Import(D->getDeclName());
3954  if (D->getDeclName() && !Name)
3955    return nullptr;
3956
3957  // Import the location of this declaration.
3958  SourceLocation Loc = Importer.Import(D->getLocation());
3959
3960  // Import the type of this declaration.
3961  QualType T = Importer.Import(D->getType());
3962  if (T.isNull())
3963    return nullptr;
3964
3965  // Import type-source information.
3966  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3967  if (D->getTypeSourceInfo() && !TInfo)
3968    return nullptr;
3969
3970  // FIXME: Import default argument.
3971
3972  return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3973                               Importer.getToContext().getTranslationUnitDecl(),
3974                                         Importer.Import(D->getInnerLocStart()),
3975                                         Loc, D->getDepth(), D->getPosition(),
3976                                         Name.getAsIdentifierInfo(),
3977                                         T, D->isParameterPack(), TInfo);
3978}
3979
3980Decl *
3981ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3982  // Import the name of this declaration.
3983  DeclarationName Name = Importer.Import(D->getDeclName());
3984  if (D->getDeclName() && !Name)
3985    return nullptr;
3986
3987  // Import the location of this declaration.
3988  SourceLocation Loc = Importer.Import(D->getLocation());
3989
3990  // Import template parameters.
3991  TemplateParameterList *TemplateParams
3992    = ImportTemplateParameterList(D->getTemplateParameters());
3993  if (!TemplateParams)
3994    return nullptr;
3995
3996  // FIXME: Import default argument.
3997
3998  return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3999                              Importer.getToContext().getTranslationUnitDecl(),
4000                                          Loc, D->getDepth(), D->getPosition(),
4001                                          D->isParameterPack(),
4002                                          Name.getAsIdentifierInfo(),
4003                                          TemplateParams);
4004}
4005
4006Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4007  // If this record has a definition in the translation unit we're coming from,
4008  // but this particular declaration is not that definition, import the
4009  // definition and map to that.
4010  CXXRecordDecl *Definition
4011    = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4012  if (Definition && Definition != D->getTemplatedDecl()) {
4013    Decl *ImportedDef
4014      = Importer.Import(Definition->getDescribedClassTemplate());
4015    if (!ImportedDef)
4016      return nullptr;
4017
4018    return Importer.Imported(D, ImportedDef);
4019  }
4020
4021  // Import the major distinguishing characteristics of this class template.
4022  DeclContext *DC, *LexicalDC;
4023  DeclarationName Name;
4024  SourceLocation Loc;
4025  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
4026    return nullptr;
4027
4028  // We may already have a template of the same name; try to find and match it.
4029  if (!DC->isFunctionOrMethod()) {
4030    SmallVector<NamedDecl *, 4> ConflictingDecls;
4031    SmallVector<NamedDecl *, 2> FoundDecls;
4032    DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4033    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4034      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4035        continue;
4036
4037      Decl *Found = FoundDecls[I];
4038      if (ClassTemplateDecl *FoundTemplate
4039                                        = dyn_cast<ClassTemplateDecl>(Found)) {
4040        if (IsStructuralMatch(D, FoundTemplate)) {
4041          // The class templates structurally match; call it the same template.
4042          // FIXME: We may be filling in a forward declaration here. Handle
4043          // this case!
4044          Importer.Imported(D->getTemplatedDecl(),
4045                            FoundTemplate->getTemplatedDecl());
4046          return Importer.Imported(D, FoundTemplate);
4047        }
4048      }
4049
4050      ConflictingDecls.push_back(FoundDecls[I]);
4051    }
4052
4053    if (!ConflictingDecls.empty()) {
4054      Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4055                                         ConflictingDecls.data(),
4056                                         ConflictingDecls.size());
4057    }
4058
4059    if (!Name)
4060      return nullptr;
4061  }
4062
4063  CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4064
4065  // Create the declaration that is being templated.
4066  SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4067  SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4068  CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4069                                                     DTemplated->getTagKind(),
4070                                                     DC, StartLoc, IdLoc,
4071                                                   Name.getAsIdentifierInfo());
4072  D2Templated->setAccess(DTemplated->getAccess());
4073  D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4074  D2Templated->setLexicalDeclContext(LexicalDC);
4075
4076  // Create the class template declaration itself.
4077  TemplateParameterList *TemplateParams
4078    = ImportTemplateParameterList(D->getTemplateParameters());
4079  if (!TemplateParams)
4080    return nullptr;
4081
4082  ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4083                                                    Loc, Name, TemplateParams,
4084                                                    D2Templated,
4085                                                    /*PrevDecl=*/nullptr);
4086  D2Templated->setDescribedClassTemplate(D2);
4087
4088  D2->setAccess(D->getAccess());
4089  D2->setLexicalDeclContext(LexicalDC);
4090  LexicalDC->addDeclInternal(D2);
4091
4092  // Note the relationship between the class templates.
4093  Importer.Imported(D, D2);
4094  Importer.Imported(DTemplated, D2Templated);
4095
4096  if (DTemplated->isCompleteDefinition() &&
4097      !D2Templated->isCompleteDefinition()) {
4098    // FIXME: Import definition!
4099  }
4100
4101  return D2;
4102}
4103
4104Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4105                                          ClassTemplateSpecializationDecl *D) {
4106  // If this record has a definition in the translation unit we're coming from,
4107  // but this particular declaration is not that definition, import the
4108  // definition and map to that.
4109  TagDecl *Definition = D->getDefinition();
4110  if (Definition && Definition != D) {
4111    Decl *ImportedDef = Importer.Import(Definition);
4112    if (!ImportedDef)
4113      return nullptr;
4114
4115    return Importer.Imported(D, ImportedDef);
4116  }
4117
4118  ClassTemplateDecl *ClassTemplate
4119    = cast_or_null<ClassTemplateDecl>(Importer.Import(
4120                                                 D->getSpecializedTemplate()));
4121  if (!ClassTemplate)
4122    return nullptr;
4123
4124  // Import the context of this declaration.
4125  DeclContext *DC = ClassTemplate->getDeclContext();
4126  if (!DC)
4127    return nullptr;
4128
4129  DeclContext *LexicalDC = DC;
4130  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4131    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4132    if (!LexicalDC)
4133      return nullptr;
4134  }
4135
4136  // Import the location of this declaration.
4137  SourceLocation StartLoc = Importer.Import(D->getLocStart());
4138  SourceLocation IdLoc = Importer.Import(D->getLocation());
4139
4140  // Import template arguments.
4141  SmallVector<TemplateArgument, 2> TemplateArgs;
4142  if (ImportTemplateArguments(D->getTemplateArgs().data(),
4143                              D->getTemplateArgs().size(),
4144                              TemplateArgs))
4145    return nullptr;
4146
4147  // Try to find an existing specialization with these template arguments.
4148  void *InsertPos = nullptr;
4149  ClassTemplateSpecializationDecl *D2
4150    = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4151  if (D2) {
4152    // We already have a class template specialization with these template
4153    // arguments.
4154
4155    // FIXME: Check for specialization vs. instantiation errors.
4156
4157    if (RecordDecl *FoundDef = D2->getDefinition()) {
4158      if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4159        // The record types structurally match, or the "from" translation
4160        // unit only had a forward declaration anyway; call it the same
4161        // function.
4162        return Importer.Imported(D, FoundDef);
4163      }
4164    }
4165  } else {
4166    // Create a new specialization.
4167    D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4168                                                 D->getTagKind(), DC,
4169                                                 StartLoc, IdLoc,
4170                                                 ClassTemplate,
4171                                                 TemplateArgs.data(),
4172                                                 TemplateArgs.size(),
4173                                                 /*PrevDecl=*/nullptr);
4174    D2->setSpecializationKind(D->getSpecializationKind());
4175
4176    // Add this specialization to the class template.
4177    ClassTemplate->AddSpecialization(D2, InsertPos);
4178
4179    // Import the qualifier, if any.
4180    D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4181
4182    // Add the specialization to this context.
4183    D2->setLexicalDeclContext(LexicalDC);
4184    LexicalDC->addDeclInternal(D2);
4185  }
4186  Importer.Imported(D, D2);
4187
4188  if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4189    return nullptr;
4190
4191  return D2;
4192}
4193
4194Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4195  // If this variable has a definition in the translation unit we're coming
4196  // from,
4197  // but this particular declaration is not that definition, import the
4198  // definition and map to that.
4199  VarDecl *Definition =
4200      cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4201  if (Definition && Definition != D->getTemplatedDecl()) {
4202    Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4203    if (!ImportedDef)
4204      return nullptr;
4205
4206    return Importer.Imported(D, ImportedDef);
4207  }
4208
4209  // Import the major distinguishing characteristics of this variable template.
4210  DeclContext *DC, *LexicalDC;
4211  DeclarationName Name;
4212  SourceLocation Loc;
4213  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
4214    return nullptr;
4215
4216  // We may already have a template of the same name; try to find and match it.
4217  assert(!DC->isFunctionOrMethod() &&
4218         "Variable templates cannot be declared at function scope");
4219  SmallVector<NamedDecl *, 4> ConflictingDecls;
4220  SmallVector<NamedDecl *, 2> FoundDecls;
4221  DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4222  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4223    if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4224      continue;
4225
4226    Decl *Found = FoundDecls[I];
4227    if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4228      if (IsStructuralMatch(D, FoundTemplate)) {
4229        // The variable templates structurally match; call it the same template.
4230        Importer.Imported(D->getTemplatedDecl(),
4231                          FoundTemplate->getTemplatedDecl());
4232        return Importer.Imported(D, FoundTemplate);
4233      }
4234    }
4235
4236    ConflictingDecls.push_back(FoundDecls[I]);
4237  }
4238
4239  if (!ConflictingDecls.empty()) {
4240    Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4241                                       ConflictingDecls.data(),
4242                                       ConflictingDecls.size());
4243  }
4244
4245  if (!Name)
4246    return nullptr;
4247
4248  VarDecl *DTemplated = D->getTemplatedDecl();
4249
4250  // Import the type.
4251  QualType T = Importer.Import(DTemplated->getType());
4252  if (T.isNull())
4253    return nullptr;
4254
4255  // Create the declaration that is being templated.
4256  SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4257  SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4258  TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4259  VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4260                                         IdLoc, Name.getAsIdentifierInfo(), T,
4261                                         TInfo, DTemplated->getStorageClass());
4262  D2Templated->setAccess(DTemplated->getAccess());
4263  D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4264  D2Templated->setLexicalDeclContext(LexicalDC);
4265
4266  // Importer.Imported(DTemplated, D2Templated);
4267  // LexicalDC->addDeclInternal(D2Templated);
4268
4269  // Merge the initializer.
4270  if (ImportDefinition(DTemplated, D2Templated))
4271    return nullptr;
4272
4273  // Create the variable template declaration itself.
4274  TemplateParameterList *TemplateParams =
4275      ImportTemplateParameterList(D->getTemplateParameters());
4276  if (!TemplateParams)
4277    return nullptr;
4278
4279  VarTemplateDecl *D2 = VarTemplateDecl::Create(
4280      Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4281  D2Templated->setDescribedVarTemplate(D2);
4282
4283  D2->setAccess(D->getAccess());
4284  D2->setLexicalDeclContext(LexicalDC);
4285  LexicalDC->addDeclInternal(D2);
4286
4287  // Note the relationship between the variable templates.
4288  Importer.Imported(D, D2);
4289  Importer.Imported(DTemplated, D2Templated);
4290
4291  if (DTemplated->isThisDeclarationADefinition() &&
4292      !D2Templated->isThisDeclarationADefinition()) {
4293    // FIXME: Import definition!
4294  }
4295
4296  return D2;
4297}
4298
4299Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4300    VarTemplateSpecializationDecl *D) {
4301  // If this record has a definition in the translation unit we're coming from,
4302  // but this particular declaration is not that definition, import the
4303  // definition and map to that.
4304  VarDecl *Definition = D->getDefinition();
4305  if (Definition && Definition != D) {
4306    Decl *ImportedDef = Importer.Import(Definition);
4307    if (!ImportedDef)
4308      return nullptr;
4309
4310    return Importer.Imported(D, ImportedDef);
4311  }
4312
4313  VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4314      Importer.Import(D->getSpecializedTemplate()));
4315  if (!VarTemplate)
4316    return nullptr;
4317
4318  // Import the context of this declaration.
4319  DeclContext *DC = VarTemplate->getDeclContext();
4320  if (!DC)
4321    return nullptr;
4322
4323  DeclContext *LexicalDC = DC;
4324  if (D->getDeclContext() != D->getLexicalDeclContext()) {
4325    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4326    if (!LexicalDC)
4327      return nullptr;
4328  }
4329
4330  // Import the location of this declaration.
4331  SourceLocation StartLoc = Importer.Import(D->getLocStart());
4332  SourceLocation IdLoc = Importer.Import(D->getLocation());
4333
4334  // Import template arguments.
4335  SmallVector<TemplateArgument, 2> TemplateArgs;
4336  if (ImportTemplateArguments(D->getTemplateArgs().data(),
4337                              D->getTemplateArgs().size(), TemplateArgs))
4338    return nullptr;
4339
4340  // Try to find an existing specialization with these template arguments.
4341  void *InsertPos = nullptr;
4342  VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4343      TemplateArgs, InsertPos);
4344  if (D2) {
4345    // We already have a variable template specialization with these template
4346    // arguments.
4347
4348    // FIXME: Check for specialization vs. instantiation errors.
4349
4350    if (VarDecl *FoundDef = D2->getDefinition()) {
4351      if (!D->isThisDeclarationADefinition() ||
4352          IsStructuralMatch(D, FoundDef)) {
4353        // The record types structurally match, or the "from" translation
4354        // unit only had a forward declaration anyway; call it the same
4355        // variable.
4356        return Importer.Imported(D, FoundDef);
4357      }
4358    }
4359  } else {
4360
4361    // Import the type.
4362    QualType T = Importer.Import(D->getType());
4363    if (T.isNull())
4364      return nullptr;
4365    TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4366
4367    // Create a new specialization.
4368    D2 = VarTemplateSpecializationDecl::Create(
4369        Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4370        D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size());
4371    D2->setSpecializationKind(D->getSpecializationKind());
4372    D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4373
4374    // Add this specialization to the class template.
4375    VarTemplate->AddSpecialization(D2, InsertPos);
4376
4377    // Import the qualifier, if any.
4378    D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4379
4380    // Add the specialization to this context.
4381    D2->setLexicalDeclContext(LexicalDC);
4382    LexicalDC->addDeclInternal(D2);
4383  }
4384  Importer.Imported(D, D2);
4385
4386  if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4387    return nullptr;
4388
4389  return D2;
4390}
4391
4392//----------------------------------------------------------------------------
4393// Import Statements
4394//----------------------------------------------------------------------------
4395
4396Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4397  Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4398    << S->getStmtClassName();
4399  return nullptr;
4400}
4401
4402//----------------------------------------------------------------------------
4403// Import Expressions
4404//----------------------------------------------------------------------------
4405Expr *ASTNodeImporter::VisitExpr(Expr *E) {
4406  Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4407    << E->getStmtClassName();
4408  return nullptr;
4409}
4410
4411Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
4412  ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4413  if (!ToD)
4414    return nullptr;
4415
4416  NamedDecl *FoundD = nullptr;
4417  if (E->getDecl() != E->getFoundDecl()) {
4418    FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4419    if (!FoundD)
4420      return nullptr;
4421  }
4422
4423  QualType T = Importer.Import(E->getType());
4424  if (T.isNull())
4425    return nullptr;
4426
4427  DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4428                                         Importer.Import(E->getQualifierLoc()),
4429                                   Importer.Import(E->getTemplateKeywordLoc()),
4430                                         ToD,
4431                                        E->refersToEnclosingVariableOrCapture(),
4432                                         Importer.Import(E->getLocation()),
4433                                         T, E->getValueKind(),
4434                                         FoundD,
4435                                         /*FIXME:TemplateArgs=*/nullptr);
4436  if (E->hadMultipleCandidates())
4437    DRE->setHadMultipleCandidates(true);
4438  return DRE;
4439}
4440
4441Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
4442  QualType T = Importer.Import(E->getType());
4443  if (T.isNull())
4444    return nullptr;
4445
4446  return IntegerLiteral::Create(Importer.getToContext(),
4447                                E->getValue(), T,
4448                                Importer.Import(E->getLocation()));
4449}
4450
4451Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
4452  QualType T = Importer.Import(E->getType());
4453  if (T.isNull())
4454    return nullptr;
4455
4456  return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4457                                                        E->getKind(), T,
4458                                          Importer.Import(E->getLocation()));
4459}
4460
4461Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
4462  Expr *SubExpr = Importer.Import(E->getSubExpr());
4463  if (!SubExpr)
4464    return nullptr;
4465
4466  return new (Importer.getToContext())
4467                                  ParenExpr(Importer.Import(E->getLParen()),
4468                                            Importer.Import(E->getRParen()),
4469                                            SubExpr);
4470}
4471
4472Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
4473  QualType T = Importer.Import(E->getType());
4474  if (T.isNull())
4475    return nullptr;
4476
4477  Expr *SubExpr = Importer.Import(E->getSubExpr());
4478  if (!SubExpr)
4479    return nullptr;
4480
4481  return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4482                                                     T, E->getValueKind(),
4483                                                     E->getObjectKind(),
4484                                         Importer.Import(E->getOperatorLoc()));
4485}
4486
4487Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
4488                                            UnaryExprOrTypeTraitExpr *E) {
4489  QualType ResultType = Importer.Import(E->getType());
4490
4491  if (E->isArgumentType()) {
4492    TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4493    if (!TInfo)
4494      return nullptr;
4495
4496    return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4497                                           TInfo, ResultType,
4498                                           Importer.Import(E->getOperatorLoc()),
4499                                           Importer.Import(E->getRParenLoc()));
4500  }
4501
4502  Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4503  if (!SubExpr)
4504    return nullptr;
4505
4506  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4507                                          SubExpr, ResultType,
4508                                          Importer.Import(E->getOperatorLoc()),
4509                                          Importer.Import(E->getRParenLoc()));
4510}
4511
4512Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
4513  QualType T = Importer.Import(E->getType());
4514  if (T.isNull())
4515    return nullptr;
4516
4517  Expr *LHS = Importer.Import(E->getLHS());
4518  if (!LHS)
4519    return nullptr;
4520
4521  Expr *RHS = Importer.Import(E->getRHS());
4522  if (!RHS)
4523    return nullptr;
4524
4525  return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4526                                                      T, E->getValueKind(),
4527                                                      E->getObjectKind(),
4528                                           Importer.Import(E->getOperatorLoc()),
4529                                                      E->isFPContractable());
4530}
4531
4532Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
4533  QualType T = Importer.Import(E->getType());
4534  if (T.isNull())
4535    return nullptr;
4536
4537  QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4538  if (CompLHSType.isNull())
4539    return nullptr;
4540
4541  QualType CompResultType = Importer.Import(E->getComputationResultType());
4542  if (CompResultType.isNull())
4543    return nullptr;
4544
4545  Expr *LHS = Importer.Import(E->getLHS());
4546  if (!LHS)
4547    return nullptr;
4548
4549  Expr *RHS = Importer.Import(E->getRHS());
4550  if (!RHS)
4551    return nullptr;
4552
4553  return new (Importer.getToContext())
4554                        CompoundAssignOperator(LHS, RHS, E->getOpcode(),
4555                                               T, E->getValueKind(),
4556                                               E->getObjectKind(),
4557                                               CompLHSType, CompResultType,
4558                                           Importer.Import(E->getOperatorLoc()),
4559                                               E->isFPContractable());
4560}
4561
4562static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
4563  if (E->path_empty()) return false;
4564
4565  // TODO: import cast paths
4566  return true;
4567}
4568
4569Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
4570  QualType T = Importer.Import(E->getType());
4571  if (T.isNull())
4572    return nullptr;
4573
4574  Expr *SubExpr = Importer.Import(E->getSubExpr());
4575  if (!SubExpr)
4576    return nullptr;
4577
4578  CXXCastPath BasePath;
4579  if (ImportCastPath(E, BasePath))
4580    return nullptr;
4581
4582  return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4583                                  SubExpr, &BasePath, E->getValueKind());
4584}
4585
4586Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
4587  QualType T = Importer.Import(E->getType());
4588  if (T.isNull())
4589    return nullptr;
4590
4591  Expr *SubExpr = Importer.Import(E->getSubExpr());
4592  if (!SubExpr)
4593    return nullptr;
4594
4595  TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4596  if (!TInfo && E->getTypeInfoAsWritten())
4597    return nullptr;
4598
4599  CXXCastPath BasePath;
4600  if (ImportCastPath(E, BasePath))
4601    return nullptr;
4602
4603  return CStyleCastExpr::Create(Importer.getToContext(), T,
4604                                E->getValueKind(), E->getCastKind(),
4605                                SubExpr, &BasePath, TInfo,
4606                                Importer.Import(E->getLParenLoc()),
4607                                Importer.Import(E->getRParenLoc()));
4608}
4609
4610ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
4611                         ASTContext &FromContext, FileManager &FromFileManager,
4612                         bool MinimalImport)
4613  : ToContext(ToContext), FromContext(FromContext),
4614    ToFileManager(ToFileManager), FromFileManager(FromFileManager),
4615    Minimal(MinimalImport), LastDiagFromFrom(false)
4616{
4617  ImportedDecls[FromContext.getTranslationUnitDecl()]
4618    = ToContext.getTranslationUnitDecl();
4619}
4620
4621ASTImporter::~ASTImporter() { }
4622
4623QualType ASTImporter::Import(QualType FromT) {
4624  if (FromT.isNull())
4625    return QualType();
4626
4627  const Type *fromTy = FromT.getTypePtr();
4628
4629  // Check whether we've already imported this type.
4630  llvm::DenseMap<const Type *, const Type *>::iterator Pos
4631    = ImportedTypes.find(fromTy);
4632  if (Pos != ImportedTypes.end())
4633    return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
4634
4635  // Import the type
4636  ASTNodeImporter Importer(*this);
4637  QualType ToT = Importer.Visit(fromTy);
4638  if (ToT.isNull())
4639    return ToT;
4640
4641  // Record the imported type.
4642  ImportedTypes[fromTy] = ToT.getTypePtr();
4643
4644  return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
4645}
4646
4647TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
4648  if (!FromTSI)
4649    return FromTSI;
4650
4651  // FIXME: For now we just create a "trivial" type source info based
4652  // on the type and a single location. Implement a real version of this.
4653  QualType T = Import(FromTSI->getType());
4654  if (T.isNull())
4655    return nullptr;
4656
4657  return ToContext.getTrivialTypeSourceInfo(T,
4658                        FromTSI->getTypeLoc().getLocStart());
4659}
4660
4661Decl *ASTImporter::Import(Decl *FromD) {
4662  if (!FromD)
4663    return nullptr;
4664
4665  ASTNodeImporter Importer(*this);
4666
4667  // Check whether we've already imported this declaration.
4668  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
4669  if (Pos != ImportedDecls.end()) {
4670    Decl *ToD = Pos->second;
4671    Importer.ImportDefinitionIfNeeded(FromD, ToD);
4672    return ToD;
4673  }
4674
4675  // Import the type
4676  Decl *ToD = Importer.Visit(FromD);
4677  if (!ToD)
4678    return nullptr;
4679
4680  // Record the imported declaration.
4681  ImportedDecls[FromD] = ToD;
4682
4683  if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
4684    // Keep track of anonymous tags that have an associated typedef.
4685    if (FromTag->getTypedefNameForAnonDecl())
4686      AnonTagsWithPendingTypedefs.push_back(FromTag);
4687  } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
4688    // When we've finished transforming a typedef, see whether it was the
4689    // typedef for an anonymous tag.
4690    for (SmallVectorImpl<TagDecl *>::iterator
4691               FromTag = AnonTagsWithPendingTypedefs.begin(),
4692            FromTagEnd = AnonTagsWithPendingTypedefs.end();
4693         FromTag != FromTagEnd; ++FromTag) {
4694      if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
4695        if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
4696          // We found the typedef for an anonymous tag; link them.
4697          ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
4698          AnonTagsWithPendingTypedefs.erase(FromTag);
4699          break;
4700        }
4701      }
4702    }
4703  }
4704
4705  return ToD;
4706}
4707
4708DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
4709  if (!FromDC)
4710    return FromDC;
4711
4712  DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
4713  if (!ToDC)
4714    return nullptr;
4715
4716  // When we're using a record/enum/Objective-C class/protocol as a context, we
4717  // need it to have a definition.
4718  if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
4719    RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
4720    if (ToRecord->isCompleteDefinition()) {
4721      // Do nothing.
4722    } else if (FromRecord->isCompleteDefinition()) {
4723      ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
4724                                              ASTNodeImporter::IDK_Basic);
4725    } else {
4726      CompleteDecl(ToRecord);
4727    }
4728  } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
4729    EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
4730    if (ToEnum->isCompleteDefinition()) {
4731      // Do nothing.
4732    } else if (FromEnum->isCompleteDefinition()) {
4733      ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
4734                                              ASTNodeImporter::IDK_Basic);
4735    } else {
4736      CompleteDecl(ToEnum);
4737    }
4738  } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
4739    ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
4740    if (ToClass->getDefinition()) {
4741      // Do nothing.
4742    } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
4743      ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
4744                                              ASTNodeImporter::IDK_Basic);
4745    } else {
4746      CompleteDecl(ToClass);
4747    }
4748  } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
4749    ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
4750    if (ToProto->getDefinition()) {
4751      // Do nothing.
4752    } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
4753      ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
4754                                              ASTNodeImporter::IDK_Basic);
4755    } else {
4756      CompleteDecl(ToProto);
4757    }
4758  }
4759
4760  return ToDC;
4761}
4762
4763Expr *ASTImporter::Import(Expr *FromE) {
4764  if (!FromE)
4765    return nullptr;
4766
4767  return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
4768}
4769
4770Stmt *ASTImporter::Import(Stmt *FromS) {
4771  if (!FromS)
4772    return nullptr;
4773
4774  // Check whether we've already imported this declaration.
4775  llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
4776  if (Pos != ImportedStmts.end())
4777    return Pos->second;
4778
4779  // Import the type
4780  ASTNodeImporter Importer(*this);
4781  Stmt *ToS = Importer.Visit(FromS);
4782  if (!ToS)
4783    return nullptr;
4784
4785  // Record the imported declaration.
4786  ImportedStmts[FromS] = ToS;
4787  return ToS;
4788}
4789
4790NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
4791  if (!FromNNS)
4792    return nullptr;
4793
4794  NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
4795
4796  switch (FromNNS->getKind()) {
4797  case NestedNameSpecifier::Identifier:
4798    if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
4799      return NestedNameSpecifier::Create(ToContext, prefix, II);
4800    }
4801    return nullptr;
4802
4803  case NestedNameSpecifier::Namespace:
4804    if (NamespaceDecl *NS =
4805          cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
4806      return NestedNameSpecifier::Create(ToContext, prefix, NS);
4807    }
4808    return nullptr;
4809
4810  case NestedNameSpecifier::NamespaceAlias:
4811    if (NamespaceAliasDecl *NSAD =
4812          cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
4813      return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
4814    }
4815    return nullptr;
4816
4817  case NestedNameSpecifier::Global:
4818    return NestedNameSpecifier::GlobalSpecifier(ToContext);
4819
4820  case NestedNameSpecifier::Super:
4821    if (CXXRecordDecl *RD =
4822            cast<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
4823      return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
4824    }
4825    return nullptr;
4826
4827  case NestedNameSpecifier::TypeSpec:
4828  case NestedNameSpecifier::TypeSpecWithTemplate: {
4829      QualType T = Import(QualType(FromNNS->getAsType(), 0u));
4830      if (!T.isNull()) {
4831        bool bTemplate = FromNNS->getKind() ==
4832                         NestedNameSpecifier::TypeSpecWithTemplate;
4833        return NestedNameSpecifier::Create(ToContext, prefix,
4834                                           bTemplate, T.getTypePtr());
4835      }
4836    }
4837      return nullptr;
4838  }
4839
4840  llvm_unreachable("Invalid nested name specifier kind");
4841}
4842
4843NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
4844  // FIXME: Implement!
4845  return NestedNameSpecifierLoc();
4846}
4847
4848TemplateName ASTImporter::Import(TemplateName From) {
4849  switch (From.getKind()) {
4850  case TemplateName::Template:
4851    if (TemplateDecl *ToTemplate
4852                = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4853      return TemplateName(ToTemplate);
4854
4855    return TemplateName();
4856
4857  case TemplateName::OverloadedTemplate: {
4858    OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
4859    UnresolvedSet<2> ToTemplates;
4860    for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
4861                                             E = FromStorage->end();
4862         I != E; ++I) {
4863      if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
4864        ToTemplates.addDecl(To);
4865      else
4866        return TemplateName();
4867    }
4868    return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
4869                                               ToTemplates.end());
4870  }
4871
4872  case TemplateName::QualifiedTemplate: {
4873    QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
4874    NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
4875    if (!Qualifier)
4876      return TemplateName();
4877
4878    if (TemplateDecl *ToTemplate
4879        = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4880      return ToContext.getQualifiedTemplateName(Qualifier,
4881                                                QTN->hasTemplateKeyword(),
4882                                                ToTemplate);
4883
4884    return TemplateName();
4885  }
4886
4887  case TemplateName::DependentTemplate: {
4888    DependentTemplateName *DTN = From.getAsDependentTemplateName();
4889    NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
4890    if (!Qualifier)
4891      return TemplateName();
4892
4893    if (DTN->isIdentifier()) {
4894      return ToContext.getDependentTemplateName(Qualifier,
4895                                                Import(DTN->getIdentifier()));
4896    }
4897
4898    return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
4899  }
4900
4901  case TemplateName::SubstTemplateTemplateParm: {
4902    SubstTemplateTemplateParmStorage *subst
4903      = From.getAsSubstTemplateTemplateParm();
4904    TemplateTemplateParmDecl *param
4905      = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
4906    if (!param)
4907      return TemplateName();
4908
4909    TemplateName replacement = Import(subst->getReplacement());
4910    if (replacement.isNull()) return TemplateName();
4911
4912    return ToContext.getSubstTemplateTemplateParm(param, replacement);
4913  }
4914
4915  case TemplateName::SubstTemplateTemplateParmPack: {
4916    SubstTemplateTemplateParmPackStorage *SubstPack
4917      = From.getAsSubstTemplateTemplateParmPack();
4918    TemplateTemplateParmDecl *Param
4919      = cast_or_null<TemplateTemplateParmDecl>(
4920                                        Import(SubstPack->getParameterPack()));
4921    if (!Param)
4922      return TemplateName();
4923
4924    ASTNodeImporter Importer(*this);
4925    TemplateArgument ArgPack
4926      = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4927    if (ArgPack.isNull())
4928      return TemplateName();
4929
4930    return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
4931  }
4932  }
4933
4934  llvm_unreachable("Invalid template name kind");
4935}
4936
4937SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
4938  if (FromLoc.isInvalid())
4939    return SourceLocation();
4940
4941  SourceManager &FromSM = FromContext.getSourceManager();
4942
4943  // For now, map everything down to its spelling location, so that we
4944  // don't have to import macro expansions.
4945  // FIXME: Import macro expansions!
4946  FromLoc = FromSM.getSpellingLoc(FromLoc);
4947  std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
4948  SourceManager &ToSM = ToContext.getSourceManager();
4949  FileID ToFileID = Import(Decomposed.first);
4950  if (ToFileID.isInvalid())
4951    return SourceLocation();
4952  return ToSM.getLocForStartOfFile(ToFileID)
4953             .getLocWithOffset(Decomposed.second);
4954}
4955
4956SourceRange ASTImporter::Import(SourceRange FromRange) {
4957  return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
4958}
4959
4960FileID ASTImporter::Import(FileID FromID) {
4961  llvm::DenseMap<FileID, FileID>::iterator Pos
4962    = ImportedFileIDs.find(FromID);
4963  if (Pos != ImportedFileIDs.end())
4964    return Pos->second;
4965
4966  SourceManager &FromSM = FromContext.getSourceManager();
4967  SourceManager &ToSM = ToContext.getSourceManager();
4968  const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
4969  assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
4970
4971  // Include location of this file.
4972  SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
4973
4974  // Map the FileID for to the "to" source manager.
4975  FileID ToID;
4976  const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
4977  if (Cache->OrigEntry) {
4978    // FIXME: We probably want to use getVirtualFile(), so we don't hit the
4979    // disk again
4980    // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
4981    // than mmap the files several times.
4982    const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
4983    if (!Entry)
4984      return FileID();
4985    ToID = ToSM.createFileID(Entry, ToIncludeLoc,
4986                             FromSLoc.getFile().getFileCharacteristic());
4987  } else {
4988    // FIXME: We want to re-use the existing MemoryBuffer!
4989    const llvm::MemoryBuffer *
4990        FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
4991    std::unique_ptr<llvm::MemoryBuffer> ToBuf
4992      = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
4993                                             FromBuf->getBufferIdentifier());
4994    ToID = ToSM.createFileID(std::move(ToBuf),
4995                             FromSLoc.getFile().getFileCharacteristic());
4996  }
4997
4998
4999  ImportedFileIDs[FromID] = ToID;
5000  return ToID;
5001}
5002
5003void ASTImporter::ImportDefinition(Decl *From) {
5004  Decl *To = Import(From);
5005  if (!To)
5006    return;
5007
5008  if (DeclContext *FromDC = cast<DeclContext>(From)) {
5009    ASTNodeImporter Importer(*this);
5010
5011    if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
5012      if (!ToRecord->getDefinition()) {
5013        Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
5014                                  ASTNodeImporter::IDK_Everything);
5015        return;
5016      }
5017    }
5018
5019    if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
5020      if (!ToEnum->getDefinition()) {
5021        Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
5022                                  ASTNodeImporter::IDK_Everything);
5023        return;
5024      }
5025    }
5026
5027    if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
5028      if (!ToIFace->getDefinition()) {
5029        Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
5030                                  ASTNodeImporter::IDK_Everything);
5031        return;
5032      }
5033    }
5034
5035    if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
5036      if (!ToProto->getDefinition()) {
5037        Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
5038                                  ASTNodeImporter::IDK_Everything);
5039        return;
5040      }
5041    }
5042
5043    Importer.ImportDeclContext(FromDC, true);
5044  }
5045}
5046
5047DeclarationName ASTImporter::Import(DeclarationName FromName) {
5048  if (!FromName)
5049    return DeclarationName();
5050
5051  switch (FromName.getNameKind()) {
5052  case DeclarationName::Identifier:
5053    return Import(FromName.getAsIdentifierInfo());
5054
5055  case DeclarationName::ObjCZeroArgSelector:
5056  case DeclarationName::ObjCOneArgSelector:
5057  case DeclarationName::ObjCMultiArgSelector:
5058    return Import(FromName.getObjCSelector());
5059
5060  case DeclarationName::CXXConstructorName: {
5061    QualType T = Import(FromName.getCXXNameType());
5062    if (T.isNull())
5063      return DeclarationName();
5064
5065    return ToContext.DeclarationNames.getCXXConstructorName(
5066                                               ToContext.getCanonicalType(T));
5067  }
5068
5069  case DeclarationName::CXXDestructorName: {
5070    QualType T = Import(FromName.getCXXNameType());
5071    if (T.isNull())
5072      return DeclarationName();
5073
5074    return ToContext.DeclarationNames.getCXXDestructorName(
5075                                               ToContext.getCanonicalType(T));
5076  }
5077
5078  case DeclarationName::CXXConversionFunctionName: {
5079    QualType T = Import(FromName.getCXXNameType());
5080    if (T.isNull())
5081      return DeclarationName();
5082
5083    return ToContext.DeclarationNames.getCXXConversionFunctionName(
5084                                               ToContext.getCanonicalType(T));
5085  }
5086
5087  case DeclarationName::CXXOperatorName:
5088    return ToContext.DeclarationNames.getCXXOperatorName(
5089                                          FromName.getCXXOverloadedOperator());
5090
5091  case DeclarationName::CXXLiteralOperatorName:
5092    return ToContext.DeclarationNames.getCXXLiteralOperatorName(
5093                                   Import(FromName.getCXXLiteralIdentifier()));
5094
5095  case DeclarationName::CXXUsingDirective:
5096    // FIXME: STATICS!
5097    return DeclarationName::getUsingDirectiveName();
5098  }
5099
5100  llvm_unreachable("Invalid DeclarationName Kind!");
5101}
5102
5103IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
5104  if (!FromId)
5105    return nullptr;
5106
5107  return &ToContext.Idents.get(FromId->getName());
5108}
5109
5110Selector ASTImporter::Import(Selector FromSel) {
5111  if (FromSel.isNull())
5112    return Selector();
5113
5114  SmallVector<IdentifierInfo *, 4> Idents;
5115  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
5116  for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
5117    Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
5118  return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
5119}
5120
5121DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
5122                                                DeclContext *DC,
5123                                                unsigned IDNS,
5124                                                NamedDecl **Decls,
5125                                                unsigned NumDecls) {
5126  return Name;
5127}
5128
5129DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
5130  if (LastDiagFromFrom)
5131    ToContext.getDiagnostics().notePriorDiagnosticFrom(
5132      FromContext.getDiagnostics());
5133  LastDiagFromFrom = false;
5134  return ToContext.getDiagnostics().Report(Loc, DiagID);
5135}
5136
5137DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
5138  if (!LastDiagFromFrom)
5139    FromContext.getDiagnostics().notePriorDiagnosticFrom(
5140      ToContext.getDiagnostics());
5141  LastDiagFromFrom = true;
5142  return FromContext.getDiagnostics().Report(Loc, DiagID);
5143}
5144
5145void ASTImporter::CompleteDecl (Decl *D) {
5146  if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
5147    if (!ID->getDefinition())
5148      ID->startDefinition();
5149  }
5150  else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
5151    if (!PD->getDefinition())
5152      PD->startDefinition();
5153  }
5154  else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
5155    if (!TD->getDefinition() && !TD->isBeingDefined()) {
5156      TD->startDefinition();
5157      TD->setCompleteDefinition(true);
5158    }
5159  }
5160  else {
5161    assert (0 && "CompleteDecl called on a Decl that can't be completed");
5162  }
5163}
5164
5165Decl *ASTImporter::Imported(Decl *From, Decl *To) {
5166  ImportedDecls[From] = To;
5167  return To;
5168}
5169
5170bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
5171                                           bool Complain) {
5172  llvm::DenseMap<const Type *, const Type *>::iterator Pos
5173   = ImportedTypes.find(From.getTypePtr());
5174  if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
5175    return true;
5176
5177  StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
5178                                   false, Complain);
5179  return Ctx.IsStructurallyEquivalent(From, To);
5180}
5181