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