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