ASTImporter.cpp revision c6994005dc9f677c831b8e90bdab483cc2197c29 
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->isForwardDecl()) {
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      if (D->isInitiallyForwardDecl() && !D->isForwardDecl())
3191        ToIface->completedForwardDecl();
3192    }
3193    Importer.Imported(D, ToIface);
3194
3195    if (D->getSuperClass()) {
3196      ObjCInterfaceDecl *Super
3197        = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getSuperClass()));
3198      if (!Super)
3199        return 0;
3200
3201      ToIface->setSuperClass(Super);
3202      ToIface->setSuperClassLoc(Importer.Import(D->getSuperClassLoc()));
3203    }
3204
3205    // Import protocols
3206    SmallVector<ObjCProtocolDecl *, 4> Protocols;
3207    SmallVector<SourceLocation, 4> ProtocolLocs;
3208    ObjCInterfaceDecl::protocol_loc_iterator
3209      FromProtoLoc = D->protocol_loc_begin();
3210
3211    // FIXME: Should we be usng all_referenced_protocol_begin() here?
3212    for (ObjCInterfaceDecl::protocol_iterator FromProto = D->protocol_begin(),
3213                                           FromProtoEnd = D->protocol_end();
3214       FromProto != FromProtoEnd;
3215       ++FromProto, ++FromProtoLoc) {
3216      ObjCProtocolDecl *ToProto
3217        = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3218      if (!ToProto)
3219        return 0;
3220      Protocols.push_back(ToProto);
3221      ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3222    }
3223
3224    // FIXME: If we're merging, make sure that the protocol list is the same.
3225    ToIface->setProtocolList(Protocols.data(), Protocols.size(),
3226                             ProtocolLocs.data(), Importer.getToContext());
3227
3228    // Import @end range
3229    ToIface->setAtEndRange(Importer.Import(D->getAtEndRange()));
3230  } else {
3231    Importer.Imported(D, ToIface);
3232
3233    // Check for consistency of superclasses.
3234    DeclarationName FromSuperName, ToSuperName;
3235
3236    // If the superclass hasn't been imported yet, do so before checking.
3237    ObjCInterfaceDecl *DSuperClass = D->getSuperClass();
3238    ObjCInterfaceDecl *ToIfaceSuperClass = ToIface->getSuperClass();
3239
3240    if (DSuperClass && !ToIfaceSuperClass) {
3241      Decl *ImportedSuperClass = Importer.Import(DSuperClass);
3242      ObjCInterfaceDecl *ImportedSuperIface = cast<ObjCInterfaceDecl>(ImportedSuperClass);
3243      ToIface->setSuperClass(ImportedSuperIface);
3244    }
3245
3246    if (D->getSuperClass())
3247      FromSuperName = Importer.Import(D->getSuperClass()->getDeclName());
3248    if (ToIface->getSuperClass())
3249      ToSuperName = ToIface->getSuperClass()->getDeclName();
3250    if (FromSuperName != ToSuperName) {
3251      Importer.ToDiag(ToIface->getLocation(),
3252                      diag::err_odr_objc_superclass_inconsistent)
3253        << ToIface->getDeclName();
3254      if (ToIface->getSuperClass())
3255        Importer.ToDiag(ToIface->getSuperClassLoc(),
3256                        diag::note_odr_objc_superclass)
3257          << ToIface->getSuperClass()->getDeclName();
3258      else
3259        Importer.ToDiag(ToIface->getLocation(),
3260                        diag::note_odr_objc_missing_superclass);
3261      if (D->getSuperClass())
3262        Importer.FromDiag(D->getSuperClassLoc(),
3263                          diag::note_odr_objc_superclass)
3264          << D->getSuperClass()->getDeclName();
3265      else
3266        Importer.FromDiag(D->getLocation(),
3267                          diag::note_odr_objc_missing_superclass);
3268      return 0;
3269    }
3270  }
3271
3272  // Import categories. When the categories themselves are imported, they'll
3273  // hook themselves into this interface.
3274  for (ObjCCategoryDecl *FromCat = D->getCategoryList(); FromCat;
3275       FromCat = FromCat->getNextClassCategory())
3276    Importer.Import(FromCat);
3277
3278  // Import all of the members of this class.
3279  ImportDeclContext(D);
3280
3281  // If we have an @implementation, import it as well.
3282  if (D->getImplementation()) {
3283    ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3284                                       Importer.Import(D->getImplementation()));
3285    if (!Impl)
3286      return 0;
3287
3288    ToIface->setImplementation(Impl);
3289  }
3290
3291  return ToIface;
3292}
3293
3294Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3295  ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3296                                        Importer.Import(D->getCategoryDecl()));
3297  if (!Category)
3298    return 0;
3299
3300  ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3301  if (!ToImpl) {
3302    DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3303    if (!DC)
3304      return 0;
3305
3306    SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3307    ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3308                                          Importer.Import(D->getIdentifier()),
3309                                          Category->getClassInterface(),
3310                                          Importer.Import(D->getLocation()),
3311                                          Importer.Import(D->getAtStartLoc()),
3312                                          CategoryNameLoc);
3313
3314    DeclContext *LexicalDC = DC;
3315    if (D->getDeclContext() != D->getLexicalDeclContext()) {
3316      LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3317      if (!LexicalDC)
3318        return 0;
3319
3320      ToImpl->setLexicalDeclContext(LexicalDC);
3321    }
3322
3323    LexicalDC->addDeclInternal(ToImpl);
3324    Category->setImplementation(ToImpl);
3325  }
3326
3327  Importer.Imported(D, ToImpl);
3328  ImportDeclContext(D);
3329  return ToImpl;
3330}
3331
3332Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3333  // Find the corresponding interface.
3334  ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3335                                       Importer.Import(D->getClassInterface()));
3336  if (!Iface)
3337    return 0;
3338
3339  // Import the superclass, if any.
3340  ObjCInterfaceDecl *Super = 0;
3341  if (D->getSuperClass()) {
3342    Super = cast_or_null<ObjCInterfaceDecl>(
3343                                          Importer.Import(D->getSuperClass()));
3344    if (!Super)
3345      return 0;
3346  }
3347
3348  ObjCImplementationDecl *Impl = Iface->getImplementation();
3349  if (!Impl) {
3350    // We haven't imported an implementation yet. Create a new @implementation
3351    // now.
3352    Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3353                                  Importer.ImportContext(D->getDeclContext()),
3354                                          Iface, Super,
3355                                          Importer.Import(D->getLocation()),
3356                                          Importer.Import(D->getAtStartLoc()));
3357
3358    if (D->getDeclContext() != D->getLexicalDeclContext()) {
3359      DeclContext *LexicalDC
3360        = Importer.ImportContext(D->getLexicalDeclContext());
3361      if (!LexicalDC)
3362        return 0;
3363      Impl->setLexicalDeclContext(LexicalDC);
3364    }
3365
3366    // Associate the implementation with the class it implements.
3367    Iface->setImplementation(Impl);
3368    Importer.Imported(D, Iface->getImplementation());
3369  } else {
3370    Importer.Imported(D, Iface->getImplementation());
3371
3372    // Verify that the existing @implementation has the same superclass.
3373    if ((Super && !Impl->getSuperClass()) ||
3374        (!Super && Impl->getSuperClass()) ||
3375        (Super && Impl->getSuperClass() &&
3376         Super->getCanonicalDecl() != Impl->getSuperClass())) {
3377        Importer.ToDiag(Impl->getLocation(),
3378                        diag::err_odr_objc_superclass_inconsistent)
3379          << Iface->getDeclName();
3380        // FIXME: It would be nice to have the location of the superclass
3381        // below.
3382        if (Impl->getSuperClass())
3383          Importer.ToDiag(Impl->getLocation(),
3384                          diag::note_odr_objc_superclass)
3385          << Impl->getSuperClass()->getDeclName();
3386        else
3387          Importer.ToDiag(Impl->getLocation(),
3388                          diag::note_odr_objc_missing_superclass);
3389        if (D->getSuperClass())
3390          Importer.FromDiag(D->getLocation(),
3391                            diag::note_odr_objc_superclass)
3392          << D->getSuperClass()->getDeclName();
3393        else
3394          Importer.FromDiag(D->getLocation(),
3395                            diag::note_odr_objc_missing_superclass);
3396      return 0;
3397    }
3398  }
3399
3400  // Import all of the members of this @implementation.
3401  ImportDeclContext(D);
3402
3403  return Impl;
3404}
3405
3406Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3407  // Import the major distinguishing characteristics of an @property.
3408  DeclContext *DC, *LexicalDC;
3409  DeclarationName Name;
3410  SourceLocation Loc;
3411  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3412    return 0;
3413
3414  // Check whether we have already imported this property.
3415  llvm::SmallVector<NamedDecl *, 2> FoundDecls;
3416  DC->localUncachedLookup(Name, FoundDecls);
3417  for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3418    if (ObjCPropertyDecl *FoundProp
3419                                = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3420      // Check property types.
3421      if (!Importer.IsStructurallyEquivalent(D->getType(),
3422                                             FoundProp->getType())) {
3423        Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3424          << Name << D->getType() << FoundProp->getType();
3425        Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3426          << FoundProp->getType();
3427        return 0;
3428      }
3429
3430      // FIXME: Check property attributes, getters, setters, etc.?
3431
3432      // Consider these properties to be equivalent.
3433      Importer.Imported(D, FoundProp);
3434      return FoundProp;
3435    }
3436  }
3437
3438  // Import the type.
3439  TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3440  if (!T)
3441    return 0;
3442
3443  // Create the new property.
3444  ObjCPropertyDecl *ToProperty
3445    = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3446                               Name.getAsIdentifierInfo(),
3447                               Importer.Import(D->getAtLoc()),
3448                               T,
3449                               D->getPropertyImplementation());
3450  Importer.Imported(D, ToProperty);
3451  ToProperty->setLexicalDeclContext(LexicalDC);
3452  LexicalDC->addDeclInternal(ToProperty);
3453
3454  ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3455  ToProperty->setPropertyAttributesAsWritten(
3456                                      D->getPropertyAttributesAsWritten());
3457  ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3458  ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3459  ToProperty->setGetterMethodDecl(
3460     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3461  ToProperty->setSetterMethodDecl(
3462     cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3463  ToProperty->setPropertyIvarDecl(
3464       cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3465  return ToProperty;
3466}
3467
3468Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3469  ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3470                                        Importer.Import(D->getPropertyDecl()));
3471  if (!Property)
3472    return 0;
3473
3474  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3475  if (!DC)
3476    return 0;
3477
3478  // Import the lexical declaration context.
3479  DeclContext *LexicalDC = DC;
3480  if (D->getDeclContext() != D->getLexicalDeclContext()) {
3481    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3482    if (!LexicalDC)
3483      return 0;
3484  }
3485
3486  ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3487  if (!InImpl)
3488    return 0;
3489
3490  // Import the ivar (for an @synthesize).
3491  ObjCIvarDecl *Ivar = 0;
3492  if (D->getPropertyIvarDecl()) {
3493    Ivar = cast_or_null<ObjCIvarDecl>(
3494                                    Importer.Import(D->getPropertyIvarDecl()));
3495    if (!Ivar)
3496      return 0;
3497  }
3498
3499  ObjCPropertyImplDecl *ToImpl
3500    = InImpl->FindPropertyImplDecl(Property->getIdentifier());
3501  if (!ToImpl) {
3502    ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3503                                          Importer.Import(D->getLocStart()),
3504                                          Importer.Import(D->getLocation()),
3505                                          Property,
3506                                          D->getPropertyImplementation(),
3507                                          Ivar,
3508                                  Importer.Import(D->getPropertyIvarDeclLoc()));
3509    ToImpl->setLexicalDeclContext(LexicalDC);
3510    Importer.Imported(D, ToImpl);
3511    LexicalDC->addDeclInternal(ToImpl);
3512  } else {
3513    // Check that we have the same kind of property implementation (@synthesize
3514    // vs. @dynamic).
3515    if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3516      Importer.ToDiag(ToImpl->getLocation(),
3517                      diag::err_odr_objc_property_impl_kind_inconsistent)
3518        << Property->getDeclName()
3519        << (ToImpl->getPropertyImplementation()
3520                                              == ObjCPropertyImplDecl::Dynamic);
3521      Importer.FromDiag(D->getLocation(),
3522                        diag::note_odr_objc_property_impl_kind)
3523        << D->getPropertyDecl()->getDeclName()
3524        << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3525      return 0;
3526    }
3527
3528    // For @synthesize, check that we have the same
3529    if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3530        Ivar != ToImpl->getPropertyIvarDecl()) {
3531      Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3532                      diag::err_odr_objc_synthesize_ivar_inconsistent)
3533        << Property->getDeclName()
3534        << ToImpl->getPropertyIvarDecl()->getDeclName()
3535        << Ivar->getDeclName();
3536      Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3537                        diag::note_odr_objc_synthesize_ivar_here)
3538        << D->getPropertyIvarDecl()->getDeclName();
3539      return 0;
3540    }
3541
3542    // Merge the existing implementation with the new implementation.
3543    Importer.Imported(D, ToImpl);
3544  }
3545
3546  return ToImpl;
3547}
3548
3549Decl *
3550ASTNodeImporter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) {
3551  // Import the context of this declaration.
3552  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3553  if (!DC)
3554    return 0;
3555
3556  DeclContext *LexicalDC = DC;
3557  if (D->getDeclContext() != D->getLexicalDeclContext()) {
3558    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3559    if (!LexicalDC)
3560      return 0;
3561  }
3562
3563  // Import the location of this declaration.
3564  SourceLocation Loc = Importer.Import(D->getLocation());
3565
3566  SmallVector<ObjCProtocolDecl *, 4> Protocols;
3567  SmallVector<SourceLocation, 4> Locations;
3568  ObjCForwardProtocolDecl::protocol_loc_iterator FromProtoLoc
3569    = D->protocol_loc_begin();
3570  for (ObjCForwardProtocolDecl::protocol_iterator FromProto
3571         = D->protocol_begin(), FromProtoEnd = D->protocol_end();
3572       FromProto != FromProtoEnd;
3573       ++FromProto, ++FromProtoLoc) {
3574    ObjCProtocolDecl *ToProto
3575      = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3576    if (!ToProto)
3577      continue;
3578
3579    Protocols.push_back(ToProto);
3580    Locations.push_back(Importer.Import(*FromProtoLoc));
3581  }
3582
3583  ObjCForwardProtocolDecl *ToForward
3584    = ObjCForwardProtocolDecl::Create(Importer.getToContext(), DC, Loc,
3585                                      Protocols.data(), Protocols.size(),
3586                                      Locations.data());
3587  ToForward->setLexicalDeclContext(LexicalDC);
3588  LexicalDC->addDeclInternal(ToForward);
3589  Importer.Imported(D, ToForward);
3590  return ToForward;
3591}
3592
3593Decl *ASTNodeImporter::VisitObjCClassDecl(ObjCClassDecl *D) {
3594  // Import the context of this declaration.
3595  DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3596  if (!DC)
3597    return 0;
3598
3599  DeclContext *LexicalDC = DC;
3600  if (D->getDeclContext() != D->getLexicalDeclContext()) {
3601    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3602    if (!LexicalDC)
3603      return 0;
3604  }
3605
3606  // Import the location of this declaration.
3607  SourceLocation Loc = Importer.Import(D->getLocation());
3608  ObjCClassDecl::ObjCClassRef *From = D->getForwardDecl();
3609  ObjCInterfaceDecl *ToIface
3610    = cast_or_null<ObjCInterfaceDecl>(Importer.Import(From->getInterface()));
3611  ObjCClassDecl *ToClass = ObjCClassDecl::Create(Importer.getToContext(), DC,
3612                                        Loc,
3613                                        ToIface,
3614                                        Importer.Import(From->getLocation()));
3615
3616  ToClass->setLexicalDeclContext(LexicalDC);
3617  LexicalDC->addDeclInternal(ToClass);
3618  Importer.Imported(D, ToClass);
3619  return ToClass;
3620}
3621
3622Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3623  // For template arguments, we adopt the translation unit as our declaration
3624  // context. This context will be fixed when the actual template declaration
3625  // is created.
3626
3627  // FIXME: Import default argument.
3628  return TemplateTypeParmDecl::Create(Importer.getToContext(),
3629                              Importer.getToContext().getTranslationUnitDecl(),
3630                                      Importer.Import(D->getLocStart()),
3631                                      Importer.Import(D->getLocation()),
3632                                      D->getDepth(),
3633                                      D->getIndex(),
3634                                      Importer.Import(D->getIdentifier()),
3635                                      D->wasDeclaredWithTypename(),
3636                                      D->isParameterPack());
3637}
3638
3639Decl *
3640ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3641  // Import the name of this declaration.
3642  DeclarationName Name = Importer.Import(D->getDeclName());
3643  if (D->getDeclName() && !Name)
3644    return 0;
3645
3646  // Import the location of this declaration.
3647  SourceLocation Loc = Importer.Import(D->getLocation());
3648
3649  // Import the type of this declaration.
3650  QualType T = Importer.Import(D->getType());
3651  if (T.isNull())
3652    return 0;
3653
3654  // Import type-source information.
3655  TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3656  if (D->getTypeSourceInfo() && !TInfo)
3657    return 0;
3658
3659  // FIXME: Import default argument.
3660
3661  return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3662                               Importer.getToContext().getTranslationUnitDecl(),
3663                                         Importer.Import(D->getInnerLocStart()),
3664                                         Loc, D->getDepth(), D->getPosition(),
3665                                         Name.getAsIdentifierInfo(),
3666                                         T, D->isParameterPack(), TInfo);
3667}
3668
3669Decl *
3670ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3671  // Import the name of this declaration.
3672  DeclarationName Name = Importer.Import(D->getDeclName());
3673  if (D->getDeclName() && !Name)
3674    return 0;
3675
3676  // Import the location of this declaration.
3677  SourceLocation Loc = Importer.Import(D->getLocation());
3678
3679  // Import template parameters.
3680  TemplateParameterList *TemplateParams
3681    = ImportTemplateParameterList(D->getTemplateParameters());
3682  if (!TemplateParams)
3683    return 0;
3684
3685  // FIXME: Import default argument.
3686
3687  return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3688                              Importer.getToContext().getTranslationUnitDecl(),
3689                                          Loc, D->getDepth(), D->getPosition(),
3690                                          D->isParameterPack(),
3691                                          Name.getAsIdentifierInfo(),
3692                                          TemplateParams);
3693}
3694
3695Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
3696  // If this record has a definition in the translation unit we're coming from,
3697  // but this particular declaration is not that definition, import the
3698  // definition and map to that.
3699  CXXRecordDecl *Definition
3700    = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
3701  if (Definition && Definition != D->getTemplatedDecl()) {
3702    Decl *ImportedDef
3703      = Importer.Import(Definition->getDescribedClassTemplate());
3704    if (!ImportedDef)
3705      return 0;
3706
3707    return Importer.Imported(D, ImportedDef);
3708  }
3709
3710  // Import the major distinguishing characteristics of this class template.
3711  DeclContext *DC, *LexicalDC;
3712  DeclarationName Name;
3713  SourceLocation Loc;
3714  if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3715    return 0;
3716
3717  // We may already have a template of the same name; try to find and match it.
3718  if (!DC->isFunctionOrMethod()) {
3719    SmallVector<NamedDecl *, 4> ConflictingDecls;
3720    llvm::SmallVector<NamedDecl *, 2> FoundDecls;
3721    DC->localUncachedLookup(Name, FoundDecls);
3722    for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3723      if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3724        continue;
3725
3726      Decl *Found = FoundDecls[I];
3727      if (ClassTemplateDecl *FoundTemplate
3728                                        = dyn_cast<ClassTemplateDecl>(Found)) {
3729        if (IsStructuralMatch(D, FoundTemplate)) {
3730          // The class templates structurally match; call it the same template.
3731          // FIXME: We may be filling in a forward declaration here. Handle
3732          // this case!
3733          Importer.Imported(D->getTemplatedDecl(),
3734                            FoundTemplate->getTemplatedDecl());
3735          return Importer.Imported(D, FoundTemplate);
3736        }
3737      }
3738
3739      ConflictingDecls.push_back(FoundDecls[I]);
3740    }
3741
3742    if (!ConflictingDecls.empty()) {
3743      Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3744                                         ConflictingDecls.data(),
3745                                         ConflictingDecls.size());
3746    }
3747
3748    if (!Name)
3749      return 0;
3750  }
3751
3752  CXXRecordDecl *DTemplated = D->getTemplatedDecl();
3753
3754  // Create the declaration that is being templated.
3755  SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
3756  SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
3757  CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
3758                                                     DTemplated->getTagKind(),
3759                                                     DC, StartLoc, IdLoc,
3760                                                   Name.getAsIdentifierInfo());
3761  D2Templated->setAccess(DTemplated->getAccess());
3762  D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
3763  D2Templated->setLexicalDeclContext(LexicalDC);
3764
3765  // Create the class template declaration itself.
3766  TemplateParameterList *TemplateParams
3767    = ImportTemplateParameterList(D->getTemplateParameters());
3768  if (!TemplateParams)
3769    return 0;
3770
3771  ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
3772                                                    Loc, Name, TemplateParams,
3773                                                    D2Templated,
3774  /*PrevDecl=*/0);
3775  D2Templated->setDescribedClassTemplate(D2);
3776
3777  D2->setAccess(D->getAccess());
3778  D2->setLexicalDeclContext(LexicalDC);
3779  LexicalDC->addDeclInternal(D2);
3780
3781  // Note the relationship between the class templates.
3782  Importer.Imported(D, D2);
3783  Importer.Imported(DTemplated, D2Templated);
3784
3785  if (DTemplated->isCompleteDefinition() &&
3786      !D2Templated->isCompleteDefinition()) {
3787    // FIXME: Import definition!
3788  }
3789
3790  return D2;
3791}
3792
3793Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
3794                                          ClassTemplateSpecializationDecl *D) {
3795  // If this record has a definition in the translation unit we're coming from,
3796  // but this particular declaration is not that definition, import the
3797  // definition and map to that.
3798  TagDecl *Definition = D->getDefinition();
3799  if (Definition && Definition != D) {
3800    Decl *ImportedDef = Importer.Import(Definition);
3801    if (!ImportedDef)
3802      return 0;
3803
3804    return Importer.Imported(D, ImportedDef);
3805  }
3806
3807  ClassTemplateDecl *ClassTemplate
3808    = cast_or_null<ClassTemplateDecl>(Importer.Import(
3809                                                 D->getSpecializedTemplate()));
3810  if (!ClassTemplate)
3811    return 0;
3812
3813  // Import the context of this declaration.
3814  DeclContext *DC = ClassTemplate->getDeclContext();
3815  if (!DC)
3816    return 0;
3817
3818  DeclContext *LexicalDC = DC;
3819  if (D->getDeclContext() != D->getLexicalDeclContext()) {
3820    LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3821    if (!LexicalDC)
3822      return 0;
3823  }
3824
3825  // Import the location of this declaration.
3826  SourceLocation StartLoc = Importer.Import(D->getLocStart());
3827  SourceLocation IdLoc = Importer.Import(D->getLocation());
3828
3829  // Import template arguments.
3830  SmallVector<TemplateArgument, 2> TemplateArgs;
3831  if (ImportTemplateArguments(D->getTemplateArgs().data(),
3832                              D->getTemplateArgs().size(),
3833                              TemplateArgs))
3834    return 0;
3835
3836  // Try to find an existing specialization with these template arguments.
3837  void *InsertPos = 0;
3838  ClassTemplateSpecializationDecl *D2
3839    = ClassTemplate->findSpecialization(TemplateArgs.data(),
3840                                        TemplateArgs.size(), InsertPos);
3841  if (D2) {
3842    // We already have a class template specialization with these template
3843    // arguments.
3844
3845    // FIXME: Check for specialization vs. instantiation errors.
3846
3847    if (RecordDecl *FoundDef = D2->getDefinition()) {
3848      if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
3849        // The record types structurally match, or the "from" translation
3850        // unit only had a forward declaration anyway; call it the same
3851        // function.
3852        return Importer.Imported(D, FoundDef);
3853      }
3854    }
3855  } else {
3856    // Create a new specialization.
3857    D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
3858                                                 D->getTagKind(), DC,
3859                                                 StartLoc, IdLoc,
3860                                                 ClassTemplate,
3861                                                 TemplateArgs.data(),
3862                                                 TemplateArgs.size(),
3863                                                 /*PrevDecl=*/0);
3864    D2->setSpecializationKind(D->getSpecializationKind());
3865
3866    // Add this specialization to the class template.
3867    ClassTemplate->AddSpecialization(D2, InsertPos);
3868
3869    // Import the qualifier, if any.
3870    D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3871
3872    // Add the specialization to this context.
3873    D2->setLexicalDeclContext(LexicalDC);
3874    LexicalDC->addDeclInternal(D2);
3875  }
3876  Importer.Imported(D, D2);
3877
3878  if (D->isCompleteDefinition() && ImportDefinition(D, D2))
3879    return 0;
3880
3881  return D2;
3882}
3883
3884//----------------------------------------------------------------------------
3885// Import Statements
3886//----------------------------------------------------------------------------
3887
3888Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
3889  Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
3890    << S->getStmtClassName();
3891  return 0;
3892}
3893
3894//----------------------------------------------------------------------------
3895// Import Expressions
3896//----------------------------------------------------------------------------
3897Expr *ASTNodeImporter::VisitExpr(Expr *E) {
3898  Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
3899    << E->getStmtClassName();
3900  return 0;
3901}
3902
3903Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
3904  ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
3905  if (!ToD)
3906    return 0;
3907
3908  NamedDecl *FoundD = 0;
3909  if (E->getDecl() != E->getFoundDecl()) {
3910    FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
3911    if (!FoundD)
3912      return 0;
3913  }
3914
3915  QualType T = Importer.Import(E->getType());
3916  if (T.isNull())
3917    return 0;
3918
3919  DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
3920                                         Importer.Import(E->getQualifierLoc()),
3921                                         ToD,
3922                                         Importer.Import(E->getLocation()),
3923                                         T, E->getValueKind(),
3924                                         FoundD,
3925                                         /*FIXME:TemplateArgs=*/0);
3926  if (E->hadMultipleCandidates())
3927    DRE->setHadMultipleCandidates(true);
3928  return DRE;
3929}
3930
3931Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
3932  QualType T = Importer.Import(E->getType());
3933  if (T.isNull())
3934    return 0;
3935
3936  return IntegerLiteral::Create(Importer.getToContext(),
3937                                E->getValue(), T,
3938                                Importer.Import(E->getLocation()));
3939}
3940
3941Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
3942  QualType T = Importer.Import(E->getType());
3943  if (T.isNull())
3944    return 0;
3945
3946  return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
3947                                                        E->getKind(), T,
3948                                          Importer.Import(E->getLocation()));
3949}
3950
3951Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
3952  Expr *SubExpr = Importer.Import(E->getSubExpr());
3953  if (!SubExpr)
3954    return 0;
3955
3956  return new (Importer.getToContext())
3957                                  ParenExpr(Importer.Import(E->getLParen()),
3958                                            Importer.Import(E->getRParen()),
3959                                            SubExpr);
3960}
3961
3962Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
3963  QualType T = Importer.Import(E->getType());
3964  if (T.isNull())
3965    return 0;
3966
3967  Expr *SubExpr = Importer.Import(E->getSubExpr());
3968  if (!SubExpr)
3969    return 0;
3970
3971  return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
3972                                                     T, E->getValueKind(),
3973                                                     E->getObjectKind(),
3974                                         Importer.Import(E->getOperatorLoc()));
3975}
3976
3977Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
3978                                            UnaryExprOrTypeTraitExpr *E) {
3979  QualType ResultType = Importer.Import(E->getType());
3980
3981  if (E->isArgumentType()) {
3982    TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
3983    if (!TInfo)
3984      return 0;
3985
3986    return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
3987                                           TInfo, ResultType,
3988                                           Importer.Import(E->getOperatorLoc()),
3989                                           Importer.Import(E->getRParenLoc()));
3990  }
3991
3992  Expr *SubExpr = Importer.Import(E->getArgumentExpr());
3993  if (!SubExpr)
3994    return 0;
3995
3996  return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
3997                                          SubExpr, ResultType,
3998                                          Importer.Import(E->getOperatorLoc()),
3999                                          Importer.Import(E->getRParenLoc()));
4000}
4001
4002Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
4003  QualType T = Importer.Import(E->getType());
4004  if (T.isNull())
4005    return 0;
4006
4007  Expr *LHS = Importer.Import(E->getLHS());
4008  if (!LHS)
4009    return 0;
4010
4011  Expr *RHS = Importer.Import(E->getRHS());
4012  if (!RHS)
4013    return 0;
4014
4015  return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4016                                                      T, E->getValueKind(),
4017                                                      E->getObjectKind(),
4018                                          Importer.Import(E->getOperatorLoc()));
4019}
4020
4021Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
4022  QualType T = Importer.Import(E->getType());
4023  if (T.isNull())
4024    return 0;
4025
4026  QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4027  if (CompLHSType.isNull())
4028    return 0;
4029
4030  QualType CompResultType = Importer.Import(E->getComputationResultType());
4031  if (CompResultType.isNull())
4032    return 0;
4033
4034  Expr *LHS = Importer.Import(E->getLHS());
4035  if (!LHS)
4036    return 0;
4037
4038  Expr *RHS = Importer.Import(E->getRHS());
4039  if (!RHS)
4040    return 0;
4041
4042  return new (Importer.getToContext())
4043                        CompoundAssignOperator(LHS, RHS, E->getOpcode(),
4044                                               T, E->getValueKind(),
4045                                               E->getObjectKind(),
4046                                               CompLHSType, CompResultType,
4047                                          Importer.Import(E->getOperatorLoc()));
4048}
4049
4050static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
4051  if (E->path_empty()) return false;
4052
4053  // TODO: import cast paths
4054  return true;
4055}
4056
4057Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
4058  QualType T = Importer.Import(E->getType());
4059  if (T.isNull())
4060    return 0;
4061
4062  Expr *SubExpr = Importer.Import(E->getSubExpr());
4063  if (!SubExpr)
4064    return 0;
4065
4066  CXXCastPath BasePath;
4067  if (ImportCastPath(E, BasePath))
4068    return 0;
4069
4070  return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4071                                  SubExpr, &BasePath, E->getValueKind());
4072}
4073
4074Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
4075  QualType T = Importer.Import(E->getType());
4076  if (T.isNull())
4077    return 0;
4078
4079  Expr *SubExpr = Importer.Import(E->getSubExpr());
4080  if (!SubExpr)
4081    return 0;
4082
4083  TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4084  if (!TInfo && E->getTypeInfoAsWritten())
4085    return 0;
4086
4087  CXXCastPath BasePath;
4088  if (ImportCastPath(E, BasePath))
4089    return 0;
4090
4091  return CStyleCastExpr::Create(Importer.getToContext(), T,
4092                                E->getValueKind(), E->getCastKind(),
4093                                SubExpr, &BasePath, TInfo,
4094                                Importer.Import(E->getLParenLoc()),
4095                                Importer.Import(E->getRParenLoc()));
4096}
4097
4098ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
4099                         ASTContext &FromContext, FileManager &FromFileManager,
4100                         bool MinimalImport)
4101  : ToContext(ToContext), FromContext(FromContext),
4102    ToFileManager(ToFileManager), FromFileManager(FromFileManager),
4103    Minimal(MinimalImport)
4104{
4105  ImportedDecls[FromContext.getTranslationUnitDecl()]
4106    = ToContext.getTranslationUnitDecl();
4107}
4108
4109ASTImporter::~ASTImporter() { }
4110
4111QualType ASTImporter::Import(QualType FromT) {
4112  if (FromT.isNull())
4113    return QualType();
4114
4115  const Type *fromTy = FromT.getTypePtr();
4116
4117  // Check whether we've already imported this type.
4118  llvm::DenseMap<const Type *, const Type *>::iterator Pos
4119    = ImportedTypes.find(fromTy);
4120  if (Pos != ImportedTypes.end())
4121    return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
4122
4123  // Import the type
4124  ASTNodeImporter Importer(*this);
4125  QualType ToT = Importer.Visit(fromTy);
4126  if (ToT.isNull())
4127    return ToT;
4128
4129  // Record the imported type.
4130  ImportedTypes[fromTy] = ToT.getTypePtr();
4131
4132  return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
4133}
4134
4135TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
4136  if (!FromTSI)
4137    return FromTSI;
4138
4139  // FIXME: For now we just create a "trivial" type source info based
4140  // on the type and a single location. Implement a real version of this.
4141  QualType T = Import(FromTSI->getType());
4142  if (T.isNull())
4143    return 0;
4144
4145  return ToContext.getTrivialTypeSourceInfo(T,
4146                        FromTSI->getTypeLoc().getSourceRange().getBegin());
4147}
4148
4149Decl *ASTImporter::Import(Decl *FromD) {
4150  if (!FromD)
4151    return 0;
4152
4153  ASTNodeImporter Importer(*this);
4154
4155  // Check whether we've already imported this declaration.
4156  llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
4157  if (Pos != ImportedDecls.end()) {
4158    Decl *ToD = Pos->second;
4159    Importer.ImportDefinitionIfNeeded(FromD, ToD);
4160    return ToD;
4161  }
4162
4163  // Import the type
4164  Decl *ToD = Importer.Visit(FromD);
4165  if (!ToD)
4166    return 0;
4167
4168  // Record the imported declaration.
4169  ImportedDecls[FromD] = ToD;
4170
4171  if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
4172    // Keep track of anonymous tags that have an associated typedef.
4173    if (FromTag->getTypedefNameForAnonDecl())
4174      AnonTagsWithPendingTypedefs.push_back(FromTag);
4175  } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
4176    // When we've finished transforming a typedef, see whether it was the
4177    // typedef for an anonymous tag.
4178    for (SmallVector<TagDecl *, 4>::iterator
4179               FromTag = AnonTagsWithPendingTypedefs.begin(),
4180            FromTagEnd = AnonTagsWithPendingTypedefs.end();
4181         FromTag != FromTagEnd; ++FromTag) {
4182      if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
4183        if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
4184          // We found the typedef for an anonymous tag; link them.
4185          ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
4186          AnonTagsWithPendingTypedefs.erase(FromTag);
4187          break;
4188        }
4189      }
4190    }
4191  }
4192
4193  return ToD;
4194}
4195
4196DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
4197  if (!FromDC)
4198    return FromDC;
4199
4200  return cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
4201}
4202
4203Expr *ASTImporter::Import(Expr *FromE) {
4204  if (!FromE)
4205    return 0;
4206
4207  return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
4208}
4209
4210Stmt *ASTImporter::Import(Stmt *FromS) {
4211  if (!FromS)
4212    return 0;
4213
4214  // Check whether we've already imported this declaration.
4215  llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
4216  if (Pos != ImportedStmts.end())
4217    return Pos->second;
4218
4219  // Import the type
4220  ASTNodeImporter Importer(*this);
4221  Stmt *ToS = Importer.Visit(FromS);
4222  if (!ToS)
4223    return 0;
4224
4225  // Record the imported declaration.
4226  ImportedStmts[FromS] = ToS;
4227  return ToS;
4228}
4229
4230NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
4231  if (!FromNNS)
4232    return 0;
4233
4234  NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
4235
4236  switch (FromNNS->getKind()) {
4237  case NestedNameSpecifier::Identifier:
4238    if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
4239      return NestedNameSpecifier::Create(ToContext, prefix, II);
4240    }
4241    return 0;
4242
4243  case NestedNameSpecifier::Namespace:
4244    if (NamespaceDecl *NS =
4245          cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
4246      return NestedNameSpecifier::Create(ToContext, prefix, NS);
4247    }
4248    return 0;
4249
4250  case NestedNameSpecifier::NamespaceAlias:
4251    if (NamespaceAliasDecl *NSAD =
4252          cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
4253      return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
4254    }
4255    return 0;
4256
4257  case NestedNameSpecifier::Global:
4258    return NestedNameSpecifier::GlobalSpecifier(ToContext);
4259
4260  case NestedNameSpecifier::TypeSpec:
4261  case NestedNameSpecifier::TypeSpecWithTemplate: {
4262      QualType T = Import(QualType(FromNNS->getAsType(), 0u));
4263      if (!T.isNull()) {
4264        bool bTemplate = FromNNS->getKind() ==
4265                         NestedNameSpecifier::TypeSpecWithTemplate;
4266        return NestedNameSpecifier::Create(ToContext, prefix,
4267                                           bTemplate, T.getTypePtr());
4268      }
4269    }
4270    return 0;
4271  }
4272
4273  llvm_unreachable("Invalid nested name specifier kind");
4274  return 0;
4275}
4276
4277NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
4278  // FIXME: Implement!
4279  return NestedNameSpecifierLoc();
4280}
4281
4282TemplateName ASTImporter::Import(TemplateName From) {
4283  switch (From.getKind()) {
4284  case TemplateName::Template:
4285    if (TemplateDecl *ToTemplate
4286                = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4287      return TemplateName(ToTemplate);
4288
4289    return TemplateName();
4290
4291  case TemplateName::OverloadedTemplate: {
4292    OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
4293    UnresolvedSet<2> ToTemplates;
4294    for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
4295                                             E = FromStorage->end();
4296         I != E; ++I) {
4297      if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
4298        ToTemplates.addDecl(To);
4299      else
4300        return TemplateName();
4301    }
4302    return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
4303                                               ToTemplates.end());
4304  }
4305
4306  case TemplateName::QualifiedTemplate: {
4307    QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
4308    NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
4309    if (!Qualifier)
4310      return TemplateName();
4311
4312    if (TemplateDecl *ToTemplate
4313        = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4314      return ToContext.getQualifiedTemplateName(Qualifier,
4315                                                QTN->hasTemplateKeyword(),
4316                                                ToTemplate);
4317
4318    return TemplateName();
4319  }
4320
4321  case TemplateName::DependentTemplate: {
4322    DependentTemplateName *DTN = From.getAsDependentTemplateName();
4323    NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
4324    if (!Qualifier)
4325      return TemplateName();
4326
4327    if (DTN->isIdentifier()) {
4328      return ToContext.getDependentTemplateName(Qualifier,
4329                                                Import(DTN->getIdentifier()));
4330    }
4331
4332    return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
4333  }
4334
4335  case TemplateName::SubstTemplateTemplateParm: {
4336    SubstTemplateTemplateParmStorage *subst
4337      = From.getAsSubstTemplateTemplateParm();
4338    TemplateTemplateParmDecl *param
4339      = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
4340    if (!param)
4341      return TemplateName();
4342
4343    TemplateName replacement = Import(subst->getReplacement());
4344    if (replacement.isNull()) return TemplateName();
4345
4346    return ToContext.getSubstTemplateTemplateParm(param, replacement);
4347  }
4348
4349  case TemplateName::SubstTemplateTemplateParmPack: {
4350    SubstTemplateTemplateParmPackStorage *SubstPack
4351      = From.getAsSubstTemplateTemplateParmPack();
4352    TemplateTemplateParmDecl *Param
4353      = cast_or_null<TemplateTemplateParmDecl>(
4354                                        Import(SubstPack->getParameterPack()));
4355    if (!Param)
4356      return TemplateName();
4357
4358    ASTNodeImporter Importer(*this);
4359    TemplateArgument ArgPack
4360      = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4361    if (ArgPack.isNull())
4362      return TemplateName();
4363
4364    return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
4365  }
4366  }
4367
4368  llvm_unreachable("Invalid template name kind");
4369  return TemplateName();
4370}
4371
4372SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
4373  if (FromLoc.isInvalid())
4374    return SourceLocation();
4375
4376  SourceManager &FromSM = FromContext.getSourceManager();
4377
4378  // For now, map everything down to its spelling location, so that we
4379  // don't have to import macro expansions.
4380  // FIXME: Import macro expansions!
4381  FromLoc = FromSM.getSpellingLoc(FromLoc);
4382  std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
4383  SourceManager &ToSM = ToContext.getSourceManager();
4384  return ToSM.getLocForStartOfFile(Import(Decomposed.first))
4385             .getLocWithOffset(Decomposed.second);
4386}
4387
4388SourceRange ASTImporter::Import(SourceRange FromRange) {
4389  return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
4390}
4391
4392FileID ASTImporter::Import(FileID FromID) {
4393  llvm::DenseMap<FileID, FileID>::iterator Pos
4394    = ImportedFileIDs.find(FromID);
4395  if (Pos != ImportedFileIDs.end())
4396    return Pos->second;
4397
4398  SourceManager &FromSM = FromContext.getSourceManager();
4399  SourceManager &ToSM = ToContext.getSourceManager();
4400  const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
4401  assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
4402
4403  // Include location of this file.
4404  SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
4405
4406  // Map the FileID for to the "to" source manager.
4407  FileID ToID;
4408  const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
4409  if (Cache->OrigEntry) {
4410    // FIXME: We probably want to use getVirtualFile(), so we don't hit the
4411    // disk again
4412    // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
4413    // than mmap the files several times.
4414    const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
4415    ToID = ToSM.createFileID(Entry, ToIncludeLoc,
4416                             FromSLoc.getFile().getFileCharacteristic());
4417  } else {
4418    // FIXME: We want to re-use the existing MemoryBuffer!
4419    const llvm::MemoryBuffer *
4420        FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
4421    llvm::MemoryBuffer *ToBuf
4422      = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
4423                                             FromBuf->getBufferIdentifier());
4424    ToID = ToSM.createFileIDForMemBuffer(ToBuf);
4425  }
4426
4427
4428  ImportedFileIDs[FromID] = ToID;
4429  return ToID;
4430}
4431
4432void ASTImporter::ImportDefinition(Decl *From) {
4433  Decl *To = Import(From);
4434  if (!To)
4435    return;
4436
4437  if (DeclContext *FromDC = cast<DeclContext>(From)) {
4438    ASTNodeImporter Importer(*this);
4439
4440    if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
4441      if (!ToRecord->getDefinition()) {
4442        Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4443                                  /*ForceImport=*/true);
4444        return;
4445      }
4446    }
4447
4448    if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
4449      if (!ToEnum->getDefinition()) {
4450        Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4451                                  /*ForceImport=*/true);
4452        return;
4453      }
4454    }
4455
4456    Importer.ImportDeclContext(FromDC, true);
4457  }
4458}
4459
4460DeclarationName ASTImporter::Import(DeclarationName FromName) {
4461  if (!FromName)
4462    return DeclarationName();
4463
4464  switch (FromName.getNameKind()) {
4465  case DeclarationName::Identifier:
4466    return Import(FromName.getAsIdentifierInfo());
4467
4468  case DeclarationName::ObjCZeroArgSelector:
4469  case DeclarationName::ObjCOneArgSelector:
4470  case DeclarationName::ObjCMultiArgSelector:
4471    return Import(FromName.getObjCSelector());
4472
4473  case DeclarationName::CXXConstructorName: {
4474    QualType T = Import(FromName.getCXXNameType());
4475    if (T.isNull())
4476      return DeclarationName();
4477
4478    return ToContext.DeclarationNames.getCXXConstructorName(
4479                                               ToContext.getCanonicalType(T));
4480  }
4481
4482  case DeclarationName::CXXDestructorName: {
4483    QualType T = Import(FromName.getCXXNameType());
4484    if (T.isNull())
4485      return DeclarationName();
4486
4487    return ToContext.DeclarationNames.getCXXDestructorName(
4488                                               ToContext.getCanonicalType(T));
4489  }
4490
4491  case DeclarationName::CXXConversionFunctionName: {
4492    QualType T = Import(FromName.getCXXNameType());
4493    if (T.isNull())
4494      return DeclarationName();
4495
4496    return ToContext.DeclarationNames.getCXXConversionFunctionName(
4497                                               ToContext.getCanonicalType(T));
4498  }
4499
4500  case DeclarationName::CXXOperatorName:
4501    return ToContext.DeclarationNames.getCXXOperatorName(
4502                                          FromName.getCXXOverloadedOperator());
4503
4504  case DeclarationName::CXXLiteralOperatorName:
4505    return ToContext.DeclarationNames.getCXXLiteralOperatorName(
4506                                   Import(FromName.getCXXLiteralIdentifier()));
4507
4508  case DeclarationName::CXXUsingDirective:
4509    // FIXME: STATICS!
4510    return DeclarationName::getUsingDirectiveName();
4511  }
4512
4513  // Silence bogus GCC warning
4514  return DeclarationName();
4515}
4516
4517IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
4518  if (!FromId)
4519    return 0;
4520
4521  return &ToContext.Idents.get(FromId->getName());
4522}
4523
4524Selector ASTImporter::Import(Selector FromSel) {
4525  if (FromSel.isNull())
4526    return Selector();
4527
4528  SmallVector<IdentifierInfo *, 4> Idents;
4529  Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
4530  for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
4531    Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
4532  return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
4533}
4534
4535DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
4536                                                DeclContext *DC,
4537                                                unsigned IDNS,
4538                                                NamedDecl **Decls,
4539                                                unsigned NumDecls) {
4540  return Name;
4541}
4542
4543DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
4544  return ToContext.getDiagnostics().Report(Loc, DiagID);
4545}
4546
4547DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
4548  return FromContext.getDiagnostics().Report(Loc, DiagID);
4549}
4550
4551Decl *ASTImporter::Imported(Decl *From, Decl *To) {
4552  ImportedDecls[From] = To;
4553  return To;
4554}
4555
4556bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To) {
4557  llvm::DenseMap<const Type *, const Type *>::iterator Pos
4558   = ImportedTypes.find(From.getTypePtr());
4559  if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
4560    return true;
4561
4562  StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls);
4563  return Ctx.IsStructurallyEquivalent(From, To);
4564}
4565