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