1 //===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ASTImporter class which imports AST nodes from one
11 // context into another context.
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTImporter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTDiagnostic.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclVisitor.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/AST/TypeVisitor.h"
22 #include "clang/Basic/FileManager.h"
23 #include "clang/Basic/SourceManager.h"
24 #include "llvm/Support/MemoryBuffer.h"
28 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
29 public DeclVisitor<ASTNodeImporter, Decl *>,
30 public StmtVisitor<ASTNodeImporter, Stmt *> {
31 ASTImporter &Importer;
34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
36 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
37 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
38 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
41 QualType VisitType(const Type *T);
42 QualType VisitBuiltinType(const BuiltinType *T);
43 QualType VisitComplexType(const ComplexType *T);
44 QualType VisitPointerType(const PointerType *T);
45 QualType VisitBlockPointerType(const BlockPointerType *T);
46 QualType VisitLValueReferenceType(const LValueReferenceType *T);
47 QualType VisitRValueReferenceType(const RValueReferenceType *T);
48 QualType VisitMemberPointerType(const MemberPointerType *T);
49 QualType VisitConstantArrayType(const ConstantArrayType *T);
50 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
51 QualType VisitVariableArrayType(const VariableArrayType *T);
52 // FIXME: DependentSizedArrayType
53 // FIXME: DependentSizedExtVectorType
54 QualType VisitVectorType(const VectorType *T);
55 QualType VisitExtVectorType(const ExtVectorType *T);
56 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
57 QualType VisitFunctionProtoType(const FunctionProtoType *T);
58 // FIXME: UnresolvedUsingType
59 QualType VisitParenType(const ParenType *T);
60 QualType VisitTypedefType(const TypedefType *T);
61 QualType VisitTypeOfExprType(const TypeOfExprType *T);
62 // FIXME: DependentTypeOfExprType
63 QualType VisitTypeOfType(const TypeOfType *T);
64 QualType VisitDecltypeType(const DecltypeType *T);
65 QualType VisitUnaryTransformType(const UnaryTransformType *T);
66 QualType VisitAutoType(const AutoType *T);
67 // FIXME: DependentDecltypeType
68 QualType VisitRecordType(const RecordType *T);
69 QualType VisitEnumType(const EnumType *T);
70 // FIXME: TemplateTypeParmType
71 // FIXME: SubstTemplateTypeParmType
72 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
73 QualType VisitElaboratedType(const ElaboratedType *T);
74 // FIXME: DependentNameType
75 // FIXME: DependentTemplateSpecializationType
76 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
77 QualType VisitObjCObjectType(const ObjCObjectType *T);
78 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
80 // Importing declarations
81 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
82 DeclContext *&LexicalDC, DeclarationName &Name,
84 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = 0);
85 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
86 DeclarationNameInfo& To);
87 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
89 /// \brief What we should import from the definition.
90 enum ImportDefinitionKind {
91 /// \brief Import the default subset of the definition, which might be
92 /// nothing (if minimal import is set) or might be everything (if minimal
93 /// import is not set).
95 /// \brief Import everything.
97 /// \brief Import only the bare bones needed to establish a valid
102 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
103 return IDK == IDK_Everything ||
104 (IDK == IDK_Default && !Importer.isMinimalImport());
107 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
108 ImportDefinitionKind Kind = IDK_Default);
109 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
110 ImportDefinitionKind Kind = IDK_Default);
111 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
112 ImportDefinitionKind Kind = IDK_Default);
113 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
114 ImportDefinitionKind Kind = IDK_Default);
115 TemplateParameterList *ImportTemplateParameterList(
116 TemplateParameterList *Params);
117 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
118 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
119 unsigned NumFromArgs,
120 SmallVectorImpl<TemplateArgument> &ToArgs);
121 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
122 bool Complain = true);
123 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
124 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
125 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
126 Decl *VisitDecl(Decl *D);
127 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
128 Decl *VisitNamespaceDecl(NamespaceDecl *D);
129 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
130 Decl *VisitTypedefDecl(TypedefDecl *D);
131 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
132 Decl *VisitEnumDecl(EnumDecl *D);
133 Decl *VisitRecordDecl(RecordDecl *D);
134 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
135 Decl *VisitFunctionDecl(FunctionDecl *D);
136 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
137 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
138 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
139 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
140 Decl *VisitFieldDecl(FieldDecl *D);
141 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
142 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
143 Decl *VisitVarDecl(VarDecl *D);
144 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
145 Decl *VisitParmVarDecl(ParmVarDecl *D);
146 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
147 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
148 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
149 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
150 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
151 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
152 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
153 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
154 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
155 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
156 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
157 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
158 Decl *VisitClassTemplateSpecializationDecl(
159 ClassTemplateSpecializationDecl *D);
161 // Importing statements
162 Stmt *VisitStmt(Stmt *S);
164 // Importing expressions
165 Expr *VisitExpr(Expr *E);
166 Expr *VisitDeclRefExpr(DeclRefExpr *E);
167 Expr *VisitIntegerLiteral(IntegerLiteral *E);
168 Expr *VisitCharacterLiteral(CharacterLiteral *E);
169 Expr *VisitParenExpr(ParenExpr *E);
170 Expr *VisitUnaryOperator(UnaryOperator *E);
171 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
172 Expr *VisitBinaryOperator(BinaryOperator *E);
173 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
174 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
175 Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
178 using namespace clang;
180 //----------------------------------------------------------------------------
181 // Structural Equivalence
182 //----------------------------------------------------------------------------
185 struct StructuralEquivalenceContext {
186 /// \brief AST contexts for which we are checking structural equivalence.
189 /// \brief The set of "tentative" equivalences between two canonical
190 /// declarations, mapping from a declaration in the first context to the
191 /// declaration in the second context that we believe to be equivalent.
192 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
194 /// \brief Queue of declarations in the first context whose equivalence
195 /// with a declaration in the second context still needs to be verified.
196 std::deque<Decl *> DeclsToCheck;
198 /// \brief Declaration (from, to) pairs that are known not to be equivalent
199 /// (which we have already complained about).
200 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
202 /// \brief Whether we're being strict about the spelling of types when
203 /// unifying two types.
204 bool StrictTypeSpelling;
206 /// \brief Whether to complain about failures.
209 /// \brief \c true if the last diagnostic came from C2.
212 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
213 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
214 bool StrictTypeSpelling = false,
215 bool Complain = true)
216 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
217 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
218 LastDiagFromC2(false) {}
220 /// \brief Determine whether the two declarations are structurally
222 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
224 /// \brief Determine whether the two types are structurally equivalent.
225 bool IsStructurallyEquivalent(QualType T1, QualType T2);
228 /// \brief Finish checking all of the structural equivalences.
230 /// \returns true if an error occurred, false otherwise.
234 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
235 assert(Complain && "Not allowed to complain");
237 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
238 LastDiagFromC2 = false;
239 return C1.getDiagnostics().Report(Loc, DiagID);
242 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
243 assert(Complain && "Not allowed to complain");
245 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
246 LastDiagFromC2 = true;
247 return C2.getDiagnostics().Report(Loc, DiagID);
252 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
253 QualType T1, QualType T2);
254 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
257 /// \brief Determine structural equivalence of two expressions.
258 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
259 Expr *E1, Expr *E2) {
263 // FIXME: Actually perform a structural comparison!
267 /// \brief Determine whether two identifiers are equivalent.
268 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
269 const IdentifierInfo *Name2) {
270 if (!Name1 || !Name2)
271 return Name1 == Name2;
273 return Name1->getName() == Name2->getName();
276 /// \brief Determine whether two nested-name-specifiers are equivalent.
277 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
278 NestedNameSpecifier *NNS1,
279 NestedNameSpecifier *NNS2) {
284 /// \brief Determine whether two template arguments are equivalent.
285 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
286 const TemplateArgument &Arg1,
287 const TemplateArgument &Arg2) {
288 if (Arg1.getKind() != Arg2.getKind())
291 switch (Arg1.getKind()) {
292 case TemplateArgument::Null:
295 case TemplateArgument::Type:
296 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
298 case TemplateArgument::Integral:
299 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
300 Arg2.getIntegralType()))
303 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
305 case TemplateArgument::Declaration:
306 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
308 case TemplateArgument::NullPtr:
309 return true; // FIXME: Is this correct?
311 case TemplateArgument::Template:
312 return IsStructurallyEquivalent(Context,
313 Arg1.getAsTemplate(),
314 Arg2.getAsTemplate());
316 case TemplateArgument::TemplateExpansion:
317 return IsStructurallyEquivalent(Context,
318 Arg1.getAsTemplateOrTemplatePattern(),
319 Arg2.getAsTemplateOrTemplatePattern());
321 case TemplateArgument::Expression:
322 return IsStructurallyEquivalent(Context,
323 Arg1.getAsExpr(), Arg2.getAsExpr());
325 case TemplateArgument::Pack:
326 if (Arg1.pack_size() != Arg2.pack_size())
329 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
330 if (!IsStructurallyEquivalent(Context,
331 Arg1.pack_begin()[I],
332 Arg2.pack_begin()[I]))
338 llvm_unreachable("Invalid template argument kind");
341 /// \brief Determine structural equivalence for the common part of array
343 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
344 const ArrayType *Array1,
345 const ArrayType *Array2) {
346 if (!IsStructurallyEquivalent(Context,
347 Array1->getElementType(),
348 Array2->getElementType()))
350 if (Array1->getSizeModifier() != Array2->getSizeModifier())
352 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
358 /// \brief Determine structural equivalence of two types.
359 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
360 QualType T1, QualType T2) {
361 if (T1.isNull() || T2.isNull())
362 return T1.isNull() && T2.isNull();
364 if (!Context.StrictTypeSpelling) {
365 // We aren't being strict about token-to-token equivalence of types,
366 // so map down to the canonical type.
367 T1 = Context.C1.getCanonicalType(T1);
368 T2 = Context.C2.getCanonicalType(T2);
371 if (T1.getQualifiers() != T2.getQualifiers())
374 Type::TypeClass TC = T1->getTypeClass();
376 if (T1->getTypeClass() != T2->getTypeClass()) {
377 // Compare function types with prototypes vs. without prototypes as if
378 // both did not have prototypes.
379 if (T1->getTypeClass() == Type::FunctionProto &&
380 T2->getTypeClass() == Type::FunctionNoProto)
381 TC = Type::FunctionNoProto;
382 else if (T1->getTypeClass() == Type::FunctionNoProto &&
383 T2->getTypeClass() == Type::FunctionProto)
384 TC = Type::FunctionNoProto;
391 // FIXME: Deal with Char_S/Char_U.
392 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
397 if (!IsStructurallyEquivalent(Context,
398 cast<ComplexType>(T1)->getElementType(),
399 cast<ComplexType>(T2)->getElementType()))
404 if (!IsStructurallyEquivalent(Context,
405 cast<PointerType>(T1)->getPointeeType(),
406 cast<PointerType>(T2)->getPointeeType()))
410 case Type::BlockPointer:
411 if (!IsStructurallyEquivalent(Context,
412 cast<BlockPointerType>(T1)->getPointeeType(),
413 cast<BlockPointerType>(T2)->getPointeeType()))
417 case Type::LValueReference:
418 case Type::RValueReference: {
419 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
420 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
421 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
423 if (Ref1->isInnerRef() != Ref2->isInnerRef())
425 if (!IsStructurallyEquivalent(Context,
426 Ref1->getPointeeTypeAsWritten(),
427 Ref2->getPointeeTypeAsWritten()))
432 case Type::MemberPointer: {
433 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
434 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
435 if (!IsStructurallyEquivalent(Context,
436 MemPtr1->getPointeeType(),
437 MemPtr2->getPointeeType()))
439 if (!IsStructurallyEquivalent(Context,
440 QualType(MemPtr1->getClass(), 0),
441 QualType(MemPtr2->getClass(), 0)))
446 case Type::ConstantArray: {
447 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
448 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
449 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
452 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
457 case Type::IncompleteArray:
458 if (!IsArrayStructurallyEquivalent(Context,
460 cast<ArrayType>(T2)))
464 case Type::VariableArray: {
465 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
466 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
467 if (!IsStructurallyEquivalent(Context,
468 Array1->getSizeExpr(), Array2->getSizeExpr()))
471 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
477 case Type::DependentSizedArray: {
478 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
479 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
480 if (!IsStructurallyEquivalent(Context,
481 Array1->getSizeExpr(), Array2->getSizeExpr()))
484 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
490 case Type::DependentSizedExtVector: {
491 const DependentSizedExtVectorType *Vec1
492 = cast<DependentSizedExtVectorType>(T1);
493 const DependentSizedExtVectorType *Vec2
494 = cast<DependentSizedExtVectorType>(T2);
495 if (!IsStructurallyEquivalent(Context,
496 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
498 if (!IsStructurallyEquivalent(Context,
499 Vec1->getElementType(),
500 Vec2->getElementType()))
506 case Type::ExtVector: {
507 const VectorType *Vec1 = cast<VectorType>(T1);
508 const VectorType *Vec2 = cast<VectorType>(T2);
509 if (!IsStructurallyEquivalent(Context,
510 Vec1->getElementType(),
511 Vec2->getElementType()))
513 if (Vec1->getNumElements() != Vec2->getNumElements())
515 if (Vec1->getVectorKind() != Vec2->getVectorKind())
520 case Type::FunctionProto: {
521 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
522 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
523 if (Proto1->getNumArgs() != Proto2->getNumArgs())
525 for (unsigned I = 0, N = Proto1->getNumArgs(); I != N; ++I) {
526 if (!IsStructurallyEquivalent(Context,
527 Proto1->getArgType(I),
528 Proto2->getArgType(I)))
531 if (Proto1->isVariadic() != Proto2->isVariadic())
533 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
535 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
536 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
538 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
539 if (!IsStructurallyEquivalent(Context,
540 Proto1->getExceptionType(I),
541 Proto2->getExceptionType(I)))
544 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
545 if (!IsStructurallyEquivalent(Context,
546 Proto1->getNoexceptExpr(),
547 Proto2->getNoexceptExpr()))
550 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
553 // Fall through to check the bits common with FunctionNoProtoType.
556 case Type::FunctionNoProto: {
557 const FunctionType *Function1 = cast<FunctionType>(T1);
558 const FunctionType *Function2 = cast<FunctionType>(T2);
559 if (!IsStructurallyEquivalent(Context,
560 Function1->getResultType(),
561 Function2->getResultType()))
563 if (Function1->getExtInfo() != Function2->getExtInfo())
568 case Type::UnresolvedUsing:
569 if (!IsStructurallyEquivalent(Context,
570 cast<UnresolvedUsingType>(T1)->getDecl(),
571 cast<UnresolvedUsingType>(T2)->getDecl()))
576 case Type::Attributed:
577 if (!IsStructurallyEquivalent(Context,
578 cast<AttributedType>(T1)->getModifiedType(),
579 cast<AttributedType>(T2)->getModifiedType()))
581 if (!IsStructurallyEquivalent(Context,
582 cast<AttributedType>(T1)->getEquivalentType(),
583 cast<AttributedType>(T2)->getEquivalentType()))
588 if (!IsStructurallyEquivalent(Context,
589 cast<ParenType>(T1)->getInnerType(),
590 cast<ParenType>(T2)->getInnerType()))
595 if (!IsStructurallyEquivalent(Context,
596 cast<TypedefType>(T1)->getDecl(),
597 cast<TypedefType>(T2)->getDecl()))
601 case Type::TypeOfExpr:
602 if (!IsStructurallyEquivalent(Context,
603 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
604 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
609 if (!IsStructurallyEquivalent(Context,
610 cast<TypeOfType>(T1)->getUnderlyingType(),
611 cast<TypeOfType>(T2)->getUnderlyingType()))
615 case Type::UnaryTransform:
616 if (!IsStructurallyEquivalent(Context,
617 cast<UnaryTransformType>(T1)->getUnderlyingType(),
618 cast<UnaryTransformType>(T1)->getUnderlyingType()))
623 if (!IsStructurallyEquivalent(Context,
624 cast<DecltypeType>(T1)->getUnderlyingExpr(),
625 cast<DecltypeType>(T2)->getUnderlyingExpr()))
630 if (!IsStructurallyEquivalent(Context,
631 cast<AutoType>(T1)->getDeducedType(),
632 cast<AutoType>(T2)->getDeducedType()))
638 if (!IsStructurallyEquivalent(Context,
639 cast<TagType>(T1)->getDecl(),
640 cast<TagType>(T2)->getDecl()))
644 case Type::TemplateTypeParm: {
645 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
646 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
647 if (Parm1->getDepth() != Parm2->getDepth())
649 if (Parm1->getIndex() != Parm2->getIndex())
651 if (Parm1->isParameterPack() != Parm2->isParameterPack())
654 // Names of template type parameters are never significant.
658 case Type::SubstTemplateTypeParm: {
659 const SubstTemplateTypeParmType *Subst1
660 = cast<SubstTemplateTypeParmType>(T1);
661 const SubstTemplateTypeParmType *Subst2
662 = cast<SubstTemplateTypeParmType>(T2);
663 if (!IsStructurallyEquivalent(Context,
664 QualType(Subst1->getReplacedParameter(), 0),
665 QualType(Subst2->getReplacedParameter(), 0)))
667 if (!IsStructurallyEquivalent(Context,
668 Subst1->getReplacementType(),
669 Subst2->getReplacementType()))
674 case Type::SubstTemplateTypeParmPack: {
675 const SubstTemplateTypeParmPackType *Subst1
676 = cast<SubstTemplateTypeParmPackType>(T1);
677 const SubstTemplateTypeParmPackType *Subst2
678 = cast<SubstTemplateTypeParmPackType>(T2);
679 if (!IsStructurallyEquivalent(Context,
680 QualType(Subst1->getReplacedParameter(), 0),
681 QualType(Subst2->getReplacedParameter(), 0)))
683 if (!IsStructurallyEquivalent(Context,
684 Subst1->getArgumentPack(),
685 Subst2->getArgumentPack()))
689 case Type::TemplateSpecialization: {
690 const TemplateSpecializationType *Spec1
691 = cast<TemplateSpecializationType>(T1);
692 const TemplateSpecializationType *Spec2
693 = cast<TemplateSpecializationType>(T2);
694 if (!IsStructurallyEquivalent(Context,
695 Spec1->getTemplateName(),
696 Spec2->getTemplateName()))
698 if (Spec1->getNumArgs() != Spec2->getNumArgs())
700 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
701 if (!IsStructurallyEquivalent(Context,
702 Spec1->getArg(I), Spec2->getArg(I)))
708 case Type::Elaborated: {
709 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
710 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
711 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
712 if (Elab1->getKeyword() != Elab2->getKeyword())
714 if (!IsStructurallyEquivalent(Context,
715 Elab1->getQualifier(),
716 Elab2->getQualifier()))
718 if (!IsStructurallyEquivalent(Context,
719 Elab1->getNamedType(),
720 Elab2->getNamedType()))
725 case Type::InjectedClassName: {
726 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
727 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
728 if (!IsStructurallyEquivalent(Context,
729 Inj1->getInjectedSpecializationType(),
730 Inj2->getInjectedSpecializationType()))
735 case Type::DependentName: {
736 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
737 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
738 if (!IsStructurallyEquivalent(Context,
739 Typename1->getQualifier(),
740 Typename2->getQualifier()))
742 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
743 Typename2->getIdentifier()))
749 case Type::DependentTemplateSpecialization: {
750 const DependentTemplateSpecializationType *Spec1 =
751 cast<DependentTemplateSpecializationType>(T1);
752 const DependentTemplateSpecializationType *Spec2 =
753 cast<DependentTemplateSpecializationType>(T2);
754 if (!IsStructurallyEquivalent(Context,
755 Spec1->getQualifier(),
756 Spec2->getQualifier()))
758 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
759 Spec2->getIdentifier()))
761 if (Spec1->getNumArgs() != Spec2->getNumArgs())
763 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
764 if (!IsStructurallyEquivalent(Context,
765 Spec1->getArg(I), Spec2->getArg(I)))
771 case Type::PackExpansion:
772 if (!IsStructurallyEquivalent(Context,
773 cast<PackExpansionType>(T1)->getPattern(),
774 cast<PackExpansionType>(T2)->getPattern()))
778 case Type::ObjCInterface: {
779 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
780 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
781 if (!IsStructurallyEquivalent(Context,
782 Iface1->getDecl(), Iface2->getDecl()))
787 case Type::ObjCObject: {
788 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
789 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
790 if (!IsStructurallyEquivalent(Context,
792 Obj2->getBaseType()))
794 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
796 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
797 if (!IsStructurallyEquivalent(Context,
798 Obj1->getProtocol(I),
799 Obj2->getProtocol(I)))
805 case Type::ObjCObjectPointer: {
806 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
807 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
808 if (!IsStructurallyEquivalent(Context,
809 Ptr1->getPointeeType(),
810 Ptr2->getPointeeType()))
816 if (!IsStructurallyEquivalent(Context,
817 cast<AtomicType>(T1)->getValueType(),
818 cast<AtomicType>(T2)->getValueType()))
828 /// \brief Determine structural equivalence of two fields.
829 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
830 FieldDecl *Field1, FieldDecl *Field2) {
831 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
833 // For anonymous structs/unions, match up the anonymous struct/union type
834 // declarations directly, so that we don't go off searching for anonymous
836 if (Field1->isAnonymousStructOrUnion() &&
837 Field2->isAnonymousStructOrUnion()) {
838 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
839 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
840 return IsStructurallyEquivalent(Context, D1, D2);
843 // Check for equivalent field names.
844 IdentifierInfo *Name1 = Field1->getIdentifier();
845 IdentifierInfo *Name2 = Field2->getIdentifier();
846 if (!::IsStructurallyEquivalent(Name1, Name2))
849 if (!IsStructurallyEquivalent(Context,
850 Field1->getType(), Field2->getType())) {
851 if (Context.Complain) {
852 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
853 << Context.C2.getTypeDeclType(Owner2);
854 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
855 << Field2->getDeclName() << Field2->getType();
856 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
857 << Field1->getDeclName() << Field1->getType();
862 if (Field1->isBitField() != Field2->isBitField()) {
863 if (Context.Complain) {
864 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
865 << Context.C2.getTypeDeclType(Owner2);
866 if (Field1->isBitField()) {
867 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
868 << Field1->getDeclName() << Field1->getType()
869 << Field1->getBitWidthValue(Context.C1);
870 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
871 << Field2->getDeclName();
873 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
874 << Field2->getDeclName() << Field2->getType()
875 << Field2->getBitWidthValue(Context.C2);
876 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
877 << Field1->getDeclName();
883 if (Field1->isBitField()) {
884 // Make sure that the bit-fields are the same length.
885 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
886 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
888 if (Bits1 != Bits2) {
889 if (Context.Complain) {
890 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
891 << Context.C2.getTypeDeclType(Owner2);
892 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
893 << Field2->getDeclName() << Field2->getType() << Bits2;
894 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
895 << Field1->getDeclName() << Field1->getType() << Bits1;
904 /// \brief Find the index of the given anonymous struct/union within its
907 /// \returns Returns the index of this anonymous struct/union in its context,
908 /// including the next assigned index (if none of them match). Returns an
909 /// empty option if the context is not a record, i.e.. if the anonymous
910 /// struct/union is at namespace or block scope.
911 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
912 ASTContext &Context = Anon->getASTContext();
913 QualType AnonTy = Context.getRecordType(Anon);
915 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
920 for (DeclContext::decl_iterator D = Owner->noload_decls_begin(),
921 DEnd = Owner->noload_decls_end();
923 FieldDecl *F = dyn_cast<FieldDecl>(*D);
924 if (!F || !F->isAnonymousStructOrUnion())
927 if (Context.hasSameType(F->getType(), AnonTy))
936 /// \brief Determine structural equivalence of two records.
937 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
938 RecordDecl *D1, RecordDecl *D2) {
939 if (D1->isUnion() != D2->isUnion()) {
940 if (Context.Complain) {
941 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
942 << Context.C2.getTypeDeclType(D2);
943 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
944 << D1->getDeclName() << (unsigned)D1->getTagKind();
949 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
950 // If both anonymous structs/unions are in a record context, make sure
951 // they occur in the same location in the context records.
952 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
953 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
954 if (*Index1 != *Index2)
960 // If both declarations are class template specializations, we know
961 // the ODR applies, so check the template and template arguments.
962 ClassTemplateSpecializationDecl *Spec1
963 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
964 ClassTemplateSpecializationDecl *Spec2
965 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
966 if (Spec1 && Spec2) {
967 // Check that the specialized templates are the same.
968 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
969 Spec2->getSpecializedTemplate()))
972 // Check that the template arguments are the same.
973 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
976 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
977 if (!IsStructurallyEquivalent(Context,
978 Spec1->getTemplateArgs().get(I),
979 Spec2->getTemplateArgs().get(I)))
982 // If one is a class template specialization and the other is not, these
983 // structures are different.
984 else if (Spec1 || Spec2)
987 // Compare the definitions of these two records. If either or both are
988 // incomplete, we assume that they are equivalent.
989 D1 = D1->getDefinition();
990 D2 = D2->getDefinition();
994 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
995 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
996 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
997 if (Context.Complain) {
998 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
999 << Context.C2.getTypeDeclType(D2);
1000 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1001 << D2CXX->getNumBases();
1002 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1003 << D1CXX->getNumBases();
1008 // Check the base classes.
1009 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1010 BaseEnd1 = D1CXX->bases_end(),
1011 Base2 = D2CXX->bases_begin();
1014 if (!IsStructurallyEquivalent(Context,
1015 Base1->getType(), Base2->getType())) {
1016 if (Context.Complain) {
1017 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1018 << Context.C2.getTypeDeclType(D2);
1019 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1021 << Base2->getSourceRange();
1022 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1024 << Base1->getSourceRange();
1029 // Check virtual vs. non-virtual inheritance mismatch.
1030 if (Base1->isVirtual() != Base2->isVirtual()) {
1031 if (Context.Complain) {
1032 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1033 << Context.C2.getTypeDeclType(D2);
1034 Context.Diag2(Base2->getLocStart(),
1035 diag::note_odr_virtual_base)
1036 << Base2->isVirtual() << Base2->getSourceRange();
1037 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1038 << Base1->isVirtual()
1039 << Base1->getSourceRange();
1044 } else if (D1CXX->getNumBases() > 0) {
1045 if (Context.Complain) {
1046 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1047 << Context.C2.getTypeDeclType(D2);
1048 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1049 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1051 << Base1->getSourceRange();
1052 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1058 // Check the fields for consistency.
1059 RecordDecl::field_iterator Field2 = D2->field_begin(),
1060 Field2End = D2->field_end();
1061 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1062 Field1End = D1->field_end();
1063 Field1 != Field1End;
1064 ++Field1, ++Field2) {
1065 if (Field2 == Field2End) {
1066 if (Context.Complain) {
1067 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1068 << Context.C2.getTypeDeclType(D2);
1069 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1070 << Field1->getDeclName() << Field1->getType();
1071 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1076 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1080 if (Field2 != Field2End) {
1081 if (Context.Complain) {
1082 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1083 << Context.C2.getTypeDeclType(D2);
1084 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1085 << Field2->getDeclName() << Field2->getType();
1086 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1094 /// \brief Determine structural equivalence of two enums.
1095 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1096 EnumDecl *D1, EnumDecl *D2) {
1097 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1098 EC2End = D2->enumerator_end();
1099 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1100 EC1End = D1->enumerator_end();
1101 EC1 != EC1End; ++EC1, ++EC2) {
1102 if (EC2 == EC2End) {
1103 if (Context.Complain) {
1104 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1105 << Context.C2.getTypeDeclType(D2);
1106 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1107 << EC1->getDeclName()
1108 << EC1->getInitVal().toString(10);
1109 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1114 llvm::APSInt Val1 = EC1->getInitVal();
1115 llvm::APSInt Val2 = EC2->getInitVal();
1116 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1117 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1118 if (Context.Complain) {
1119 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1120 << Context.C2.getTypeDeclType(D2);
1121 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1122 << EC2->getDeclName()
1123 << EC2->getInitVal().toString(10);
1124 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1125 << EC1->getDeclName()
1126 << EC1->getInitVal().toString(10);
1132 if (EC2 != EC2End) {
1133 if (Context.Complain) {
1134 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1135 << Context.C2.getTypeDeclType(D2);
1136 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1137 << EC2->getDeclName()
1138 << EC2->getInitVal().toString(10);
1139 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1147 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1148 TemplateParameterList *Params1,
1149 TemplateParameterList *Params2) {
1150 if (Params1->size() != Params2->size()) {
1151 if (Context.Complain) {
1152 Context.Diag2(Params2->getTemplateLoc(),
1153 diag::err_odr_different_num_template_parameters)
1154 << Params1->size() << Params2->size();
1155 Context.Diag1(Params1->getTemplateLoc(),
1156 diag::note_odr_template_parameter_list);
1161 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1162 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1163 if (Context.Complain) {
1164 Context.Diag2(Params2->getParam(I)->getLocation(),
1165 diag::err_odr_different_template_parameter_kind);
1166 Context.Diag1(Params1->getParam(I)->getLocation(),
1167 diag::note_odr_template_parameter_here);
1172 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1173 Params2->getParam(I))) {
1182 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1183 TemplateTypeParmDecl *D1,
1184 TemplateTypeParmDecl *D2) {
1185 if (D1->isParameterPack() != D2->isParameterPack()) {
1186 if (Context.Complain) {
1187 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1188 << D2->isParameterPack();
1189 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1190 << D1->isParameterPack();
1198 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1199 NonTypeTemplateParmDecl *D1,
1200 NonTypeTemplateParmDecl *D2) {
1201 if (D1->isParameterPack() != D2->isParameterPack()) {
1202 if (Context.Complain) {
1203 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1204 << D2->isParameterPack();
1205 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1206 << D1->isParameterPack();
1212 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1213 if (Context.Complain) {
1214 Context.Diag2(D2->getLocation(),
1215 diag::err_odr_non_type_parameter_type_inconsistent)
1216 << D2->getType() << D1->getType();
1217 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1226 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1227 TemplateTemplateParmDecl *D1,
1228 TemplateTemplateParmDecl *D2) {
1229 if (D1->isParameterPack() != D2->isParameterPack()) {
1230 if (Context.Complain) {
1231 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1232 << D2->isParameterPack();
1233 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1234 << D1->isParameterPack();
1239 // Check template parameter lists.
1240 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1241 D2->getTemplateParameters());
1244 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1245 ClassTemplateDecl *D1,
1246 ClassTemplateDecl *D2) {
1247 // Check template parameters.
1248 if (!IsStructurallyEquivalent(Context,
1249 D1->getTemplateParameters(),
1250 D2->getTemplateParameters()))
1253 // Check the templated declaration.
1254 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1255 D2->getTemplatedDecl());
1258 /// \brief Determine structural equivalence of two declarations.
1259 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1260 Decl *D1, Decl *D2) {
1261 // FIXME: Check for known structural equivalences via a callback of some sort.
1263 // Check whether we already know that these two declarations are not
1264 // structurally equivalent.
1265 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1266 D2->getCanonicalDecl())))
1269 // Determine whether we've already produced a tentative equivalence for D1.
1270 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1272 return EquivToD1 == D2->getCanonicalDecl();
1274 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1275 EquivToD1 = D2->getCanonicalDecl();
1276 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1280 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1282 if (!::IsStructurallyEquivalent(*this, D1, D2))
1288 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1290 if (!::IsStructurallyEquivalent(*this, T1, T2))
1296 bool StructuralEquivalenceContext::Finish() {
1297 while (!DeclsToCheck.empty()) {
1298 // Check the next declaration.
1299 Decl *D1 = DeclsToCheck.front();
1300 DeclsToCheck.pop_front();
1302 Decl *D2 = TentativeEquivalences[D1];
1303 assert(D2 && "Unrecorded tentative equivalence?");
1305 bool Equivalent = true;
1307 // FIXME: Switch on all declaration kinds. For now, we're just going to
1308 // check the obvious ones.
1309 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1310 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1311 // Check for equivalent structure names.
1312 IdentifierInfo *Name1 = Record1->getIdentifier();
1313 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1314 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1315 IdentifierInfo *Name2 = Record2->getIdentifier();
1316 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1317 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1318 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1319 !::IsStructurallyEquivalent(*this, Record1, Record2))
1322 // Record/non-record mismatch.
1325 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1326 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1327 // Check for equivalent enum names.
1328 IdentifierInfo *Name1 = Enum1->getIdentifier();
1329 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1330 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1331 IdentifierInfo *Name2 = Enum2->getIdentifier();
1332 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1333 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1334 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1335 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1338 // Enum/non-enum mismatch
1341 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1342 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1343 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1344 Typedef2->getIdentifier()) ||
1345 !::IsStructurallyEquivalent(*this,
1346 Typedef1->getUnderlyingType(),
1347 Typedef2->getUnderlyingType()))
1350 // Typedef/non-typedef mismatch.
1353 } else if (ClassTemplateDecl *ClassTemplate1
1354 = dyn_cast<ClassTemplateDecl>(D1)) {
1355 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1356 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1357 ClassTemplate2->getIdentifier()) ||
1358 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1361 // Class template/non-class-template mismatch.
1364 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1365 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1366 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1372 } else if (NonTypeTemplateParmDecl *NTTP1
1373 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1374 if (NonTypeTemplateParmDecl *NTTP2
1375 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1376 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1382 } else if (TemplateTemplateParmDecl *TTP1
1383 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1384 if (TemplateTemplateParmDecl *TTP2
1385 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1386 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1395 // Note that these two declarations are not equivalent (and we already
1397 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1398 D2->getCanonicalDecl()));
1401 // FIXME: Check other declaration kinds!
1407 //----------------------------------------------------------------------------
1409 //----------------------------------------------------------------------------
1411 QualType ASTNodeImporter::VisitType(const Type *T) {
1412 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1413 << T->getTypeClassName();
1417 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1418 switch (T->getKind()) {
1419 #define SHARED_SINGLETON_TYPE(Expansion)
1420 #define BUILTIN_TYPE(Id, SingletonId) \
1421 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1422 #include "clang/AST/BuiltinTypes.def"
1424 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1425 // context supports C++.
1427 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1428 // context supports ObjC.
1430 case BuiltinType::Char_U:
1431 // The context we're importing from has an unsigned 'char'. If we're
1432 // importing into a context with a signed 'char', translate to
1433 // 'unsigned char' instead.
1434 if (Importer.getToContext().getLangOpts().CharIsSigned)
1435 return Importer.getToContext().UnsignedCharTy;
1437 return Importer.getToContext().CharTy;
1439 case BuiltinType::Char_S:
1440 // The context we're importing from has an unsigned 'char'. If we're
1441 // importing into a context with a signed 'char', translate to
1442 // 'unsigned char' instead.
1443 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1444 return Importer.getToContext().SignedCharTy;
1446 return Importer.getToContext().CharTy;
1448 case BuiltinType::WChar_S:
1449 case BuiltinType::WChar_U:
1450 // FIXME: If not in C++, shall we translate to the C equivalent of
1452 return Importer.getToContext().WCharTy;
1455 llvm_unreachable("Invalid BuiltinType Kind!");
1458 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1459 QualType ToElementType = Importer.Import(T->getElementType());
1460 if (ToElementType.isNull())
1463 return Importer.getToContext().getComplexType(ToElementType);
1466 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1467 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1468 if (ToPointeeType.isNull())
1471 return Importer.getToContext().getPointerType(ToPointeeType);
1474 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1475 // FIXME: Check for blocks support in "to" context.
1476 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1477 if (ToPointeeType.isNull())
1480 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1484 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1485 // FIXME: Check for C++ support in "to" context.
1486 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1487 if (ToPointeeType.isNull())
1490 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1494 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1495 // FIXME: Check for C++0x support in "to" context.
1496 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1497 if (ToPointeeType.isNull())
1500 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1503 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1504 // FIXME: Check for C++ support in "to" context.
1505 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1506 if (ToPointeeType.isNull())
1509 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1510 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1511 ClassType.getTypePtr());
1514 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1515 QualType ToElementType = Importer.Import(T->getElementType());
1516 if (ToElementType.isNull())
1519 return Importer.getToContext().getConstantArrayType(ToElementType,
1521 T->getSizeModifier(),
1522 T->getIndexTypeCVRQualifiers());
1526 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1527 QualType ToElementType = Importer.Import(T->getElementType());
1528 if (ToElementType.isNull())
1531 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1532 T->getSizeModifier(),
1533 T->getIndexTypeCVRQualifiers());
1536 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1537 QualType ToElementType = Importer.Import(T->getElementType());
1538 if (ToElementType.isNull())
1541 Expr *Size = Importer.Import(T->getSizeExpr());
1545 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1546 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1547 T->getSizeModifier(),
1548 T->getIndexTypeCVRQualifiers(),
1552 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1553 QualType ToElementType = Importer.Import(T->getElementType());
1554 if (ToElementType.isNull())
1557 return Importer.getToContext().getVectorType(ToElementType,
1558 T->getNumElements(),
1559 T->getVectorKind());
1562 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1563 QualType ToElementType = Importer.Import(T->getElementType());
1564 if (ToElementType.isNull())
1567 return Importer.getToContext().getExtVectorType(ToElementType,
1568 T->getNumElements());
1572 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1573 // FIXME: What happens if we're importing a function without a prototype
1574 // into C++? Should we make it variadic?
1575 QualType ToResultType = Importer.Import(T->getResultType());
1576 if (ToResultType.isNull())
1579 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1583 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1584 QualType ToResultType = Importer.Import(T->getResultType());
1585 if (ToResultType.isNull())
1588 // Import argument types
1589 SmallVector<QualType, 4> ArgTypes;
1590 for (FunctionProtoType::arg_type_iterator A = T->arg_type_begin(),
1591 AEnd = T->arg_type_end();
1593 QualType ArgType = Importer.Import(*A);
1594 if (ArgType.isNull())
1596 ArgTypes.push_back(ArgType);
1599 // Import exception types
1600 SmallVector<QualType, 4> ExceptionTypes;
1601 for (FunctionProtoType::exception_iterator E = T->exception_begin(),
1602 EEnd = T->exception_end();
1604 QualType ExceptionType = Importer.Import(*E);
1605 if (ExceptionType.isNull())
1607 ExceptionTypes.push_back(ExceptionType);
1610 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1611 FunctionProtoType::ExtProtoInfo ToEPI;
1613 ToEPI.ExtInfo = FromEPI.ExtInfo;
1614 ToEPI.Variadic = FromEPI.Variadic;
1615 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1616 ToEPI.TypeQuals = FromEPI.TypeQuals;
1617 ToEPI.RefQualifier = FromEPI.RefQualifier;
1618 ToEPI.NumExceptions = ExceptionTypes.size();
1619 ToEPI.Exceptions = ExceptionTypes.data();
1620 ToEPI.ConsumedArguments = FromEPI.ConsumedArguments;
1621 ToEPI.ExceptionSpecType = FromEPI.ExceptionSpecType;
1622 ToEPI.NoexceptExpr = Importer.Import(FromEPI.NoexceptExpr);
1623 ToEPI.ExceptionSpecDecl = cast_or_null<FunctionDecl>(
1624 Importer.Import(FromEPI.ExceptionSpecDecl));
1625 ToEPI.ExceptionSpecTemplate = cast_or_null<FunctionDecl>(
1626 Importer.Import(FromEPI.ExceptionSpecTemplate));
1628 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1631 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1632 QualType ToInnerType = Importer.Import(T->getInnerType());
1633 if (ToInnerType.isNull())
1636 return Importer.getToContext().getParenType(ToInnerType);
1639 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1640 TypedefNameDecl *ToDecl
1641 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1645 return Importer.getToContext().getTypeDeclType(ToDecl);
1648 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1649 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1653 return Importer.getToContext().getTypeOfExprType(ToExpr);
1656 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1657 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1658 if (ToUnderlyingType.isNull())
1661 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1664 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1665 // FIXME: Make sure that the "to" context supports C++0x!
1666 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1670 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1671 if (UnderlyingType.isNull())
1674 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1677 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1678 QualType ToBaseType = Importer.Import(T->getBaseType());
1679 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1680 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1683 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1688 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1689 // FIXME: Make sure that the "to" context supports C++11!
1690 QualType FromDeduced = T->getDeducedType();
1692 if (!FromDeduced.isNull()) {
1693 ToDeduced = Importer.Import(FromDeduced);
1694 if (ToDeduced.isNull())
1698 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto());
1701 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1703 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1707 return Importer.getToContext().getTagDeclType(ToDecl);
1710 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1712 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1716 return Importer.getToContext().getTagDeclType(ToDecl);
1719 QualType ASTNodeImporter::VisitTemplateSpecializationType(
1720 const TemplateSpecializationType *T) {
1721 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1722 if (ToTemplate.isNull())
1725 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1726 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1729 QualType ToCanonType;
1730 if (!QualType(T, 0).isCanonical()) {
1731 QualType FromCanonType
1732 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1733 ToCanonType =Importer.Import(FromCanonType);
1734 if (ToCanonType.isNull())
1737 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1738 ToTemplateArgs.data(),
1739 ToTemplateArgs.size(),
1743 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1744 NestedNameSpecifier *ToQualifier = 0;
1745 // Note: the qualifier in an ElaboratedType is optional.
1746 if (T->getQualifier()) {
1747 ToQualifier = Importer.Import(T->getQualifier());
1752 QualType ToNamedType = Importer.Import(T->getNamedType());
1753 if (ToNamedType.isNull())
1756 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1757 ToQualifier, ToNamedType);
1760 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1761 ObjCInterfaceDecl *Class
1762 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1766 return Importer.getToContext().getObjCInterfaceType(Class);
1769 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1770 QualType ToBaseType = Importer.Import(T->getBaseType());
1771 if (ToBaseType.isNull())
1774 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1775 for (ObjCObjectType::qual_iterator P = T->qual_begin(),
1776 PEnd = T->qual_end();
1778 ObjCProtocolDecl *Protocol
1779 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1782 Protocols.push_back(Protocol);
1785 return Importer.getToContext().getObjCObjectType(ToBaseType,
1791 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1792 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1793 if (ToPointeeType.isNull())
1796 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1799 //----------------------------------------------------------------------------
1800 // Import Declarations
1801 //----------------------------------------------------------------------------
1802 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1803 DeclContext *&LexicalDC,
1804 DeclarationName &Name,
1805 SourceLocation &Loc) {
1806 // Import the context of this declaration.
1807 DC = Importer.ImportContext(D->getDeclContext());
1812 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1813 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1818 // Import the name of this declaration.
1819 Name = Importer.Import(D->getDeclName());
1820 if (D->getDeclName() && !Name)
1823 // Import the location of this declaration.
1824 Loc = Importer.Import(D->getLocation());
1828 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1833 ToD = Importer.Import(FromD);
1838 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1839 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1840 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1841 ImportDefinition(FromRecord, ToRecord);
1847 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1848 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1849 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1850 ImportDefinition(FromEnum, ToEnum);
1858 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1859 DeclarationNameInfo& To) {
1860 // NOTE: To.Name and To.Loc are already imported.
1861 // We only have to import To.LocInfo.
1862 switch (To.getName().getNameKind()) {
1863 case DeclarationName::Identifier:
1864 case DeclarationName::ObjCZeroArgSelector:
1865 case DeclarationName::ObjCOneArgSelector:
1866 case DeclarationName::ObjCMultiArgSelector:
1867 case DeclarationName::CXXUsingDirective:
1870 case DeclarationName::CXXOperatorName: {
1871 SourceRange Range = From.getCXXOperatorNameRange();
1872 To.setCXXOperatorNameRange(Importer.Import(Range));
1875 case DeclarationName::CXXLiteralOperatorName: {
1876 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1877 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1880 case DeclarationName::CXXConstructorName:
1881 case DeclarationName::CXXDestructorName:
1882 case DeclarationName::CXXConversionFunctionName: {
1883 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1884 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1888 llvm_unreachable("Unknown name kind.");
1891 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1892 if (Importer.isMinimalImport() && !ForceImport) {
1893 Importer.ImportContext(FromDC);
1897 for (DeclContext::decl_iterator From = FromDC->decls_begin(),
1898 FromEnd = FromDC->decls_end();
1901 Importer.Import(*From);
1904 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1905 ImportDefinitionKind Kind) {
1906 if (To->getDefinition() || To->isBeingDefined()) {
1907 if (Kind == IDK_Everything)
1908 ImportDeclContext(From, /*ForceImport=*/true);
1913 To->startDefinition();
1915 // Add base classes.
1916 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1917 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
1919 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1920 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1921 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1922 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1923 ToData.Aggregate = FromData.Aggregate;
1924 ToData.PlainOldData = FromData.PlainOldData;
1925 ToData.Empty = FromData.Empty;
1926 ToData.Polymorphic = FromData.Polymorphic;
1927 ToData.Abstract = FromData.Abstract;
1928 ToData.IsStandardLayout = FromData.IsStandardLayout;
1929 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
1930 ToData.HasPrivateFields = FromData.HasPrivateFields;
1931 ToData.HasProtectedFields = FromData.HasProtectedFields;
1932 ToData.HasPublicFields = FromData.HasPublicFields;
1933 ToData.HasMutableFields = FromData.HasMutableFields;
1934 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1935 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1936 ToData.HasUninitializedReferenceMember
1937 = FromData.HasUninitializedReferenceMember;
1938 ToData.NeedOverloadResolutionForMoveConstructor
1939 = FromData.NeedOverloadResolutionForMoveConstructor;
1940 ToData.NeedOverloadResolutionForMoveAssignment
1941 = FromData.NeedOverloadResolutionForMoveAssignment;
1942 ToData.NeedOverloadResolutionForDestructor
1943 = FromData.NeedOverloadResolutionForDestructor;
1944 ToData.DefaultedMoveConstructorIsDeleted
1945 = FromData.DefaultedMoveConstructorIsDeleted;
1946 ToData.DefaultedMoveAssignmentIsDeleted
1947 = FromData.DefaultedMoveAssignmentIsDeleted;
1948 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1949 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1950 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1951 ToData.HasConstexprNonCopyMoveConstructor
1952 = FromData.HasConstexprNonCopyMoveConstructor;
1953 ToData.DefaultedDefaultConstructorIsConstexpr
1954 = FromData.DefaultedDefaultConstructorIsConstexpr;
1955 ToData.HasConstexprDefaultConstructor
1956 = FromData.HasConstexprDefaultConstructor;
1957 ToData.HasNonLiteralTypeFieldsOrBases
1958 = FromData.HasNonLiteralTypeFieldsOrBases;
1959 // ComputedVisibleConversions not imported.
1960 ToData.UserProvidedDefaultConstructor
1961 = FromData.UserProvidedDefaultConstructor;
1962 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1963 ToData.ImplicitCopyConstructorHasConstParam
1964 = FromData.ImplicitCopyConstructorHasConstParam;
1965 ToData.ImplicitCopyAssignmentHasConstParam
1966 = FromData.ImplicitCopyAssignmentHasConstParam;
1967 ToData.HasDeclaredCopyConstructorWithConstParam
1968 = FromData.HasDeclaredCopyConstructorWithConstParam;
1969 ToData.HasDeclaredCopyAssignmentWithConstParam
1970 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1971 ToData.FailedImplicitMoveConstructor
1972 = FromData.FailedImplicitMoveConstructor;
1973 ToData.FailedImplicitMoveAssignment = FromData.FailedImplicitMoveAssignment;
1974 ToData.IsLambda = FromData.IsLambda;
1976 SmallVector<CXXBaseSpecifier *, 4> Bases;
1977 for (CXXRecordDecl::base_class_iterator
1978 Base1 = FromCXX->bases_begin(),
1979 FromBaseEnd = FromCXX->bases_end();
1980 Base1 != FromBaseEnd;
1982 QualType T = Importer.Import(Base1->getType());
1986 SourceLocation EllipsisLoc;
1987 if (Base1->isPackExpansion())
1988 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
1990 // Ensure that we have a definition for the base.
1991 ImportDefinitionIfNeeded(Base1->getType()->getAsCXXRecordDecl());
1994 new (Importer.getToContext())
1995 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
1997 Base1->isBaseOfClass(),
1998 Base1->getAccessSpecifierAsWritten(),
1999 Importer.Import(Base1->getTypeSourceInfo()),
2003 ToCXX->setBases(Bases.data(), Bases.size());
2006 if (shouldForceImportDeclContext(Kind))
2007 ImportDeclContext(From, /*ForceImport=*/true);
2009 To->completeDefinition();
2013 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2014 ImportDefinitionKind Kind) {
2015 if (To->getDefinition() || To->isBeingDefined()) {
2016 if (Kind == IDK_Everything)
2017 ImportDeclContext(From, /*ForceImport=*/true);
2021 To->startDefinition();
2023 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2027 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2028 if (ToPromotionType.isNull())
2031 if (shouldForceImportDeclContext(Kind))
2032 ImportDeclContext(From, /*ForceImport=*/true);
2034 // FIXME: we might need to merge the number of positive or negative bits
2035 // if the enumerator lists don't match.
2036 To->completeDefinition(T, ToPromotionType,
2037 From->getNumPositiveBits(),
2038 From->getNumNegativeBits());
2042 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2043 TemplateParameterList *Params) {
2044 SmallVector<NamedDecl *, 4> ToParams;
2045 ToParams.reserve(Params->size());
2046 for (TemplateParameterList::iterator P = Params->begin(),
2047 PEnd = Params->end();
2049 Decl *To = Importer.Import(*P);
2053 ToParams.push_back(cast<NamedDecl>(To));
2056 return TemplateParameterList::Create(Importer.getToContext(),
2057 Importer.Import(Params->getTemplateLoc()),
2058 Importer.Import(Params->getLAngleLoc()),
2059 ToParams.data(), ToParams.size(),
2060 Importer.Import(Params->getRAngleLoc()));
2064 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2065 switch (From.getKind()) {
2066 case TemplateArgument::Null:
2067 return TemplateArgument();
2069 case TemplateArgument::Type: {
2070 QualType ToType = Importer.Import(From.getAsType());
2071 if (ToType.isNull())
2072 return TemplateArgument();
2073 return TemplateArgument(ToType);
2076 case TemplateArgument::Integral: {
2077 QualType ToType = Importer.Import(From.getIntegralType());
2078 if (ToType.isNull())
2079 return TemplateArgument();
2080 return TemplateArgument(From, ToType);
2083 case TemplateArgument::Declaration: {
2084 ValueDecl *FromD = From.getAsDecl();
2085 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2086 return TemplateArgument(To, From.isDeclForReferenceParam());
2087 return TemplateArgument();
2090 case TemplateArgument::NullPtr: {
2091 QualType ToType = Importer.Import(From.getNullPtrType());
2092 if (ToType.isNull())
2093 return TemplateArgument();
2094 return TemplateArgument(ToType, /*isNullPtr*/true);
2097 case TemplateArgument::Template: {
2098 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2099 if (ToTemplate.isNull())
2100 return TemplateArgument();
2102 return TemplateArgument(ToTemplate);
2105 case TemplateArgument::TemplateExpansion: {
2106 TemplateName ToTemplate
2107 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2108 if (ToTemplate.isNull())
2109 return TemplateArgument();
2111 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2114 case TemplateArgument::Expression:
2115 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2116 return TemplateArgument(ToExpr);
2117 return TemplateArgument();
2119 case TemplateArgument::Pack: {
2120 SmallVector<TemplateArgument, 2> ToPack;
2121 ToPack.reserve(From.pack_size());
2122 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2123 return TemplateArgument();
2125 TemplateArgument *ToArgs
2126 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2127 std::copy(ToPack.begin(), ToPack.end(), ToArgs);
2128 return TemplateArgument(ToArgs, ToPack.size());
2132 llvm_unreachable("Invalid template argument kind");
2135 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2136 unsigned NumFromArgs,
2137 SmallVectorImpl<TemplateArgument> &ToArgs) {
2138 for (unsigned I = 0; I != NumFromArgs; ++I) {
2139 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2140 if (To.isNull() && !FromArgs[I].isNull())
2143 ToArgs.push_back(To);
2149 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2150 RecordDecl *ToRecord, bool Complain) {
2151 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2152 Importer.getToContext(),
2153 Importer.getNonEquivalentDecls(),
2155 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2158 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2159 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2160 Importer.getToContext(),
2161 Importer.getNonEquivalentDecls());
2162 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2165 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2166 EnumConstantDecl *ToEC)
2168 const llvm::APSInt &FromVal = FromEC->getInitVal();
2169 const llvm::APSInt &ToVal = ToEC->getInitVal();
2171 return FromVal.isSigned() == ToVal.isSigned() &&
2172 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2176 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2177 ClassTemplateDecl *To) {
2178 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2179 Importer.getToContext(),
2180 Importer.getNonEquivalentDecls());
2181 return Ctx.IsStructurallyEquivalent(From, To);
2184 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2185 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2186 << D->getDeclKindName();
2190 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2191 TranslationUnitDecl *ToD =
2192 Importer.getToContext().getTranslationUnitDecl();
2194 Importer.Imported(D, ToD);
2199 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2200 // Import the major distinguishing characteristics of this namespace.
2201 DeclContext *DC, *LexicalDC;
2202 DeclarationName Name;
2204 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2207 NamespaceDecl *MergeWithNamespace = 0;
2209 // This is an anonymous namespace. Adopt an existing anonymous
2210 // namespace if we can.
2211 // FIXME: Not testable.
2212 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2213 MergeWithNamespace = TU->getAnonymousNamespace();
2215 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2217 SmallVector<NamedDecl *, 4> ConflictingDecls;
2218 SmallVector<NamedDecl *, 2> FoundDecls;
2219 DC->localUncachedLookup(Name, FoundDecls);
2220 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2221 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2224 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2225 MergeWithNamespace = FoundNS;
2226 ConflictingDecls.clear();
2230 ConflictingDecls.push_back(FoundDecls[I]);
2233 if (!ConflictingDecls.empty()) {
2234 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2235 ConflictingDecls.data(),
2236 ConflictingDecls.size());
2240 // Create the "to" namespace, if needed.
2241 NamespaceDecl *ToNamespace = MergeWithNamespace;
2243 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2245 Importer.Import(D->getLocStart()),
2246 Loc, Name.getAsIdentifierInfo(),
2248 ToNamespace->setLexicalDeclContext(LexicalDC);
2249 LexicalDC->addDeclInternal(ToNamespace);
2251 // If this is an anonymous namespace, register it as the anonymous
2252 // namespace within its context.
2254 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2255 TU->setAnonymousNamespace(ToNamespace);
2257 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2260 Importer.Imported(D, ToNamespace);
2262 ImportDeclContext(D);
2267 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2268 // Import the major distinguishing characteristics of this typedef.
2269 DeclContext *DC, *LexicalDC;
2270 DeclarationName Name;
2272 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2275 // If this typedef is not in block scope, determine whether we've
2276 // seen a typedef with the same name (that we can merge with) or any
2277 // other entity by that name (which name lookup could conflict with).
2278 if (!DC->isFunctionOrMethod()) {
2279 SmallVector<NamedDecl *, 4> ConflictingDecls;
2280 unsigned IDNS = Decl::IDNS_Ordinary;
2281 SmallVector<NamedDecl *, 2> FoundDecls;
2282 DC->localUncachedLookup(Name, FoundDecls);
2283 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2284 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2286 if (TypedefNameDecl *FoundTypedef =
2287 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2288 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2289 FoundTypedef->getUnderlyingType()))
2290 return Importer.Imported(D, FoundTypedef);
2293 ConflictingDecls.push_back(FoundDecls[I]);
2296 if (!ConflictingDecls.empty()) {
2297 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2298 ConflictingDecls.data(),
2299 ConflictingDecls.size());
2305 // Import the underlying type of this typedef;
2306 QualType T = Importer.Import(D->getUnderlyingType());
2310 // Create the new typedef node.
2311 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2312 SourceLocation StartL = Importer.Import(D->getLocStart());
2313 TypedefNameDecl *ToTypedef;
2315 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2317 Name.getAsIdentifierInfo(),
2320 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2322 Name.getAsIdentifierInfo(),
2325 ToTypedef->setAccess(D->getAccess());
2326 ToTypedef->setLexicalDeclContext(LexicalDC);
2327 Importer.Imported(D, ToTypedef);
2328 LexicalDC->addDeclInternal(ToTypedef);
2333 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2334 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2337 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2338 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2341 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2342 // Import the major distinguishing characteristics of this enum.
2343 DeclContext *DC, *LexicalDC;
2344 DeclarationName Name;
2346 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2349 // Figure out what enum name we're looking for.
2350 unsigned IDNS = Decl::IDNS_Tag;
2351 DeclarationName SearchName = Name;
2352 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2353 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2354 IDNS = Decl::IDNS_Ordinary;
2355 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2356 IDNS |= Decl::IDNS_Ordinary;
2358 // We may already have an enum of the same name; try to find and match it.
2359 if (!DC->isFunctionOrMethod() && SearchName) {
2360 SmallVector<NamedDecl *, 4> ConflictingDecls;
2361 SmallVector<NamedDecl *, 2> FoundDecls;
2362 DC->localUncachedLookup(SearchName, FoundDecls);
2363 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2364 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2367 Decl *Found = FoundDecls[I];
2368 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2369 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2370 Found = Tag->getDecl();
2373 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2374 if (IsStructuralMatch(D, FoundEnum))
2375 return Importer.Imported(D, FoundEnum);
2378 ConflictingDecls.push_back(FoundDecls[I]);
2381 if (!ConflictingDecls.empty()) {
2382 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2383 ConflictingDecls.data(),
2384 ConflictingDecls.size());
2388 // Create the enum declaration.
2389 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2390 Importer.Import(D->getLocStart()),
2391 Loc, Name.getAsIdentifierInfo(), 0,
2392 D->isScoped(), D->isScopedUsingClassTag(),
2394 // Import the qualifier, if any.
2395 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2396 D2->setAccess(D->getAccess());
2397 D2->setLexicalDeclContext(LexicalDC);
2398 Importer.Imported(D, D2);
2399 LexicalDC->addDeclInternal(D2);
2401 // Import the integer type.
2402 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2403 if (ToIntegerType.isNull())
2405 D2->setIntegerType(ToIntegerType);
2407 // Import the definition
2408 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2414 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2415 // If this record has a definition in the translation unit we're coming from,
2416 // but this particular declaration is not that definition, import the
2417 // definition and map to that.
2418 TagDecl *Definition = D->getDefinition();
2419 if (Definition && Definition != D) {
2420 Decl *ImportedDef = Importer.Import(Definition);
2424 return Importer.Imported(D, ImportedDef);
2427 // Import the major distinguishing characteristics of this record.
2428 DeclContext *DC, *LexicalDC;
2429 DeclarationName Name;
2431 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2434 // Figure out what structure name we're looking for.
2435 unsigned IDNS = Decl::IDNS_Tag;
2436 DeclarationName SearchName = Name;
2437 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2438 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2439 IDNS = Decl::IDNS_Ordinary;
2440 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2441 IDNS |= Decl::IDNS_Ordinary;
2443 // We may already have a record of the same name; try to find and match it.
2444 RecordDecl *AdoptDecl = 0;
2445 if (!DC->isFunctionOrMethod()) {
2446 SmallVector<NamedDecl *, 4> ConflictingDecls;
2447 SmallVector<NamedDecl *, 2> FoundDecls;
2448 DC->localUncachedLookup(SearchName, FoundDecls);
2449 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2450 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2453 Decl *Found = FoundDecls[I];
2454 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2455 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2456 Found = Tag->getDecl();
2459 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2460 if (D->isAnonymousStructOrUnion() &&
2461 FoundRecord->isAnonymousStructOrUnion()) {
2462 // If both anonymous structs/unions are in a record context, make sure
2463 // they occur in the same location in the context records.
2464 if (Optional<unsigned> Index1
2465 = findAnonymousStructOrUnionIndex(D)) {
2466 if (Optional<unsigned> Index2 =
2467 findAnonymousStructOrUnionIndex(FoundRecord)) {
2468 if (*Index1 != *Index2)
2474 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2475 if ((SearchName && !D->isCompleteDefinition())
2476 || (D->isCompleteDefinition() &&
2477 D->isAnonymousStructOrUnion()
2478 == FoundDef->isAnonymousStructOrUnion() &&
2479 IsStructuralMatch(D, FoundDef))) {
2480 // The record types structurally match, or the "from" translation
2481 // unit only had a forward declaration anyway; call it the same
2483 // FIXME: For C++, we should also merge methods here.
2484 return Importer.Imported(D, FoundDef);
2486 } else if (!D->isCompleteDefinition()) {
2487 // We have a forward declaration of this type, so adopt that forward
2488 // declaration rather than building a new one.
2489 AdoptDecl = FoundRecord;
2491 } else if (!SearchName) {
2496 ConflictingDecls.push_back(FoundDecls[I]);
2499 if (!ConflictingDecls.empty() && SearchName) {
2500 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2501 ConflictingDecls.data(),
2502 ConflictingDecls.size());
2506 // Create the record declaration.
2507 RecordDecl *D2 = AdoptDecl;
2508 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2510 if (isa<CXXRecordDecl>(D)) {
2511 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2514 Name.getAsIdentifierInfo());
2516 D2->setAccess(D->getAccess());
2518 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2519 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2522 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2523 D2->setLexicalDeclContext(LexicalDC);
2524 LexicalDC->addDeclInternal(D2);
2525 if (D->isAnonymousStructOrUnion())
2526 D2->setAnonymousStructOrUnion(true);
2529 Importer.Imported(D, D2);
2531 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2537 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2538 // Import the major distinguishing characteristics of this enumerator.
2539 DeclContext *DC, *LexicalDC;
2540 DeclarationName Name;
2542 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2545 QualType T = Importer.Import(D->getType());
2549 // Determine whether there are any other declarations with the same name and
2550 // in the same context.
2551 if (!LexicalDC->isFunctionOrMethod()) {
2552 SmallVector<NamedDecl *, 4> ConflictingDecls;
2553 unsigned IDNS = Decl::IDNS_Ordinary;
2554 SmallVector<NamedDecl *, 2> FoundDecls;
2555 DC->localUncachedLookup(Name, FoundDecls);
2556 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2557 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2560 if (EnumConstantDecl *FoundEnumConstant
2561 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2562 if (IsStructuralMatch(D, FoundEnumConstant))
2563 return Importer.Imported(D, FoundEnumConstant);
2566 ConflictingDecls.push_back(FoundDecls[I]);
2569 if (!ConflictingDecls.empty()) {
2570 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2571 ConflictingDecls.data(),
2572 ConflictingDecls.size());
2578 Expr *Init = Importer.Import(D->getInitExpr());
2579 if (D->getInitExpr() && !Init)
2582 EnumConstantDecl *ToEnumerator
2583 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2584 Name.getAsIdentifierInfo(), T,
2585 Init, D->getInitVal());
2586 ToEnumerator->setAccess(D->getAccess());
2587 ToEnumerator->setLexicalDeclContext(LexicalDC);
2588 Importer.Imported(D, ToEnumerator);
2589 LexicalDC->addDeclInternal(ToEnumerator);
2590 return ToEnumerator;
2593 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2594 // Import the major distinguishing characteristics of this function.
2595 DeclContext *DC, *LexicalDC;
2596 DeclarationName Name;
2598 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2601 // Try to find a function in our own ("to") context with the same name, same
2602 // type, and in the same context as the function we're importing.
2603 if (!LexicalDC->isFunctionOrMethod()) {
2604 SmallVector<NamedDecl *, 4> ConflictingDecls;
2605 unsigned IDNS = Decl::IDNS_Ordinary;
2606 SmallVector<NamedDecl *, 2> FoundDecls;
2607 DC->localUncachedLookup(Name, FoundDecls);
2608 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2609 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2612 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2613 if (isExternalLinkage(FoundFunction->getLinkage()) &&
2614 isExternalLinkage(D->getLinkage())) {
2615 if (Importer.IsStructurallyEquivalent(D->getType(),
2616 FoundFunction->getType())) {
2617 // FIXME: Actually try to merge the body and other attributes.
2618 return Importer.Imported(D, FoundFunction);
2621 // FIXME: Check for overloading more carefully, e.g., by boosting
2622 // Sema::IsOverload out to the AST library.
2624 // Function overloading is okay in C++.
2625 if (Importer.getToContext().getLangOpts().CPlusPlus)
2628 // Complain about inconsistent function types.
2629 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2630 << Name << D->getType() << FoundFunction->getType();
2631 Importer.ToDiag(FoundFunction->getLocation(),
2632 diag::note_odr_value_here)
2633 << FoundFunction->getType();
2637 ConflictingDecls.push_back(FoundDecls[I]);
2640 if (!ConflictingDecls.empty()) {
2641 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2642 ConflictingDecls.data(),
2643 ConflictingDecls.size());
2649 DeclarationNameInfo NameInfo(Name, Loc);
2650 // Import additional name location/type info.
2651 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2653 QualType FromTy = D->getType();
2654 bool usedDifferentExceptionSpec = false;
2656 if (const FunctionProtoType *
2657 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2658 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2659 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2660 // FunctionDecl that we are importing the FunctionProtoType for.
2661 // To avoid an infinite recursion when importing, create the FunctionDecl
2662 // with a simplified function type and update it afterwards.
2663 if (FromEPI.ExceptionSpecDecl || FromEPI.ExceptionSpecTemplate ||
2664 FromEPI.NoexceptExpr) {
2665 FunctionProtoType::ExtProtoInfo DefaultEPI;
2666 FromTy = Importer.getFromContext().getFunctionType(
2667 FromFPT->getResultType(),
2668 ArrayRef<QualType>(FromFPT->arg_type_begin(),
2669 FromFPT->getNumArgs()),
2671 usedDifferentExceptionSpec = true;
2676 QualType T = Importer.Import(FromTy);
2680 // Import the function parameters.
2681 SmallVector<ParmVarDecl *, 8> Parameters;
2682 for (FunctionDecl::param_iterator P = D->param_begin(), PEnd = D->param_end();
2684 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*P));
2688 Parameters.push_back(ToP);
2691 // Create the imported function.
2692 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2693 FunctionDecl *ToFunction = 0;
2694 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2695 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2696 cast<CXXRecordDecl>(DC),
2697 D->getInnerLocStart(),
2699 FromConstructor->isExplicit(),
2700 D->isInlineSpecified(),
2703 } else if (isa<CXXDestructorDecl>(D)) {
2704 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2705 cast<CXXRecordDecl>(DC),
2706 D->getInnerLocStart(),
2708 D->isInlineSpecified(),
2710 } else if (CXXConversionDecl *FromConversion
2711 = dyn_cast<CXXConversionDecl>(D)) {
2712 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2713 cast<CXXRecordDecl>(DC),
2714 D->getInnerLocStart(),
2716 D->isInlineSpecified(),
2717 FromConversion->isExplicit(),
2719 Importer.Import(D->getLocEnd()));
2720 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2721 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2722 cast<CXXRecordDecl>(DC),
2723 D->getInnerLocStart(),
2725 Method->getStorageClass(),
2726 Method->isInlineSpecified(),
2728 Importer.Import(D->getLocEnd()));
2730 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2731 D->getInnerLocStart(),
2732 NameInfo, T, TInfo, D->getStorageClass(),
2733 D->isInlineSpecified(),
2734 D->hasWrittenPrototype(),
2738 // Import the qualifier, if any.
2739 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2740 ToFunction->setAccess(D->getAccess());
2741 ToFunction->setLexicalDeclContext(LexicalDC);
2742 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2743 ToFunction->setTrivial(D->isTrivial());
2744 ToFunction->setPure(D->isPure());
2745 Importer.Imported(D, ToFunction);
2747 // Set the parameters.
2748 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2749 Parameters[I]->setOwningFunction(ToFunction);
2750 ToFunction->addDeclInternal(Parameters[I]);
2752 ToFunction->setParams(Parameters);
2754 if (usedDifferentExceptionSpec) {
2755 // Update FunctionProtoType::ExtProtoInfo.
2756 QualType T = Importer.Import(D->getType());
2759 ToFunction->setType(T);
2762 // FIXME: Other bits to merge?
2764 // Add this function to the lexical context.
2765 LexicalDC->addDeclInternal(ToFunction);
2770 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2771 return VisitFunctionDecl(D);
2774 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2775 return VisitCXXMethodDecl(D);
2778 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2779 return VisitCXXMethodDecl(D);
2782 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2783 return VisitCXXMethodDecl(D);
2786 static unsigned getFieldIndex(Decl *F) {
2787 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2792 for (DeclContext::decl_iterator D = Owner->noload_decls_begin(),
2793 DEnd = Owner->noload_decls_end();
2798 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2805 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2806 // Import the major distinguishing characteristics of a variable.
2807 DeclContext *DC, *LexicalDC;
2808 DeclarationName Name;
2810 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2813 // Determine whether we've already imported this field.
2814 SmallVector<NamedDecl *, 2> FoundDecls;
2815 DC->localUncachedLookup(Name, FoundDecls);
2816 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2817 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2818 // For anonymous fields, match up by index.
2819 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2822 if (Importer.IsStructurallyEquivalent(D->getType(),
2823 FoundField->getType())) {
2824 Importer.Imported(D, FoundField);
2828 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2829 << Name << D->getType() << FoundField->getType();
2830 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2831 << FoundField->getType();
2837 QualType T = Importer.Import(D->getType());
2841 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2842 Expr *BitWidth = Importer.Import(D->getBitWidth());
2843 if (!BitWidth && D->getBitWidth())
2846 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2847 Importer.Import(D->getInnerLocStart()),
2848 Loc, Name.getAsIdentifierInfo(),
2849 T, TInfo, BitWidth, D->isMutable(),
2850 D->getInClassInitStyle());
2851 ToField->setAccess(D->getAccess());
2852 ToField->setLexicalDeclContext(LexicalDC);
2853 if (ToField->hasInClassInitializer())
2854 ToField->setInClassInitializer(D->getInClassInitializer());
2855 ToField->setImplicit(D->isImplicit());
2856 Importer.Imported(D, ToField);
2857 LexicalDC->addDeclInternal(ToField);
2861 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2862 // Import the major distinguishing characteristics of a variable.
2863 DeclContext *DC, *LexicalDC;
2864 DeclarationName Name;
2866 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2869 // Determine whether we've already imported this field.
2870 SmallVector<NamedDecl *, 2> FoundDecls;
2871 DC->localUncachedLookup(Name, FoundDecls);
2872 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2873 if (IndirectFieldDecl *FoundField
2874 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2875 // For anonymous indirect fields, match up by index.
2876 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2879 if (Importer.IsStructurallyEquivalent(D->getType(),
2880 FoundField->getType(),
2882 Importer.Imported(D, FoundField);
2886 // If there are more anonymous fields to check, continue.
2887 if (!Name && I < N-1)
2890 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2891 << Name << D->getType() << FoundField->getType();
2892 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2893 << FoundField->getType();
2899 QualType T = Importer.Import(D->getType());
2903 NamedDecl **NamedChain =
2904 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2907 for (IndirectFieldDecl::chain_iterator PI = D->chain_begin(),
2908 PE = D->chain_end(); PI != PE; ++PI) {
2909 Decl* D = Importer.Import(*PI);
2912 NamedChain[i++] = cast<NamedDecl>(D);
2915 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
2916 Importer.getToContext(), DC,
2917 Loc, Name.getAsIdentifierInfo(), T,
2918 NamedChain, D->getChainingSize());
2919 ToIndirectField->setAccess(D->getAccess());
2920 ToIndirectField->setLexicalDeclContext(LexicalDC);
2921 Importer.Imported(D, ToIndirectField);
2922 LexicalDC->addDeclInternal(ToIndirectField);
2923 return ToIndirectField;
2926 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
2927 // Import the major distinguishing characteristics of an ivar.
2928 DeclContext *DC, *LexicalDC;
2929 DeclarationName Name;
2931 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2934 // Determine whether we've already imported this ivar
2935 SmallVector<NamedDecl *, 2> FoundDecls;
2936 DC->localUncachedLookup(Name, FoundDecls);
2937 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2938 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
2939 if (Importer.IsStructurallyEquivalent(D->getType(),
2940 FoundIvar->getType())) {
2941 Importer.Imported(D, FoundIvar);
2945 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2946 << Name << D->getType() << FoundIvar->getType();
2947 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2948 << FoundIvar->getType();
2954 QualType T = Importer.Import(D->getType());
2958 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2959 Expr *BitWidth = Importer.Import(D->getBitWidth());
2960 if (!BitWidth && D->getBitWidth())
2963 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
2964 cast<ObjCContainerDecl>(DC),
2965 Importer.Import(D->getInnerLocStart()),
2966 Loc, Name.getAsIdentifierInfo(),
2967 T, TInfo, D->getAccessControl(),
2968 BitWidth, D->getSynthesize());
2969 ToIvar->setLexicalDeclContext(LexicalDC);
2970 Importer.Imported(D, ToIvar);
2971 LexicalDC->addDeclInternal(ToIvar);
2976 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
2977 // Import the major distinguishing characteristics of a variable.
2978 DeclContext *DC, *LexicalDC;
2979 DeclarationName Name;
2981 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2984 // Try to find a variable in our own ("to") context with the same name and
2985 // in the same context as the variable we're importing.
2986 if (D->isFileVarDecl()) {
2987 VarDecl *MergeWithVar = 0;
2988 SmallVector<NamedDecl *, 4> ConflictingDecls;
2989 unsigned IDNS = Decl::IDNS_Ordinary;
2990 SmallVector<NamedDecl *, 2> FoundDecls;
2991 DC->localUncachedLookup(Name, FoundDecls);
2992 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2993 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2996 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
2997 // We have found a variable that we may need to merge with. Check it.
2998 if (isExternalLinkage(FoundVar->getLinkage()) &&
2999 isExternalLinkage(D->getLinkage())) {
3000 if (Importer.IsStructurallyEquivalent(D->getType(),
3001 FoundVar->getType())) {
3002 MergeWithVar = FoundVar;
3006 const ArrayType *FoundArray
3007 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3008 const ArrayType *TArray
3009 = Importer.getToContext().getAsArrayType(D->getType());
3010 if (FoundArray && TArray) {
3011 if (isa<IncompleteArrayType>(FoundArray) &&
3012 isa<ConstantArrayType>(TArray)) {
3014 QualType T = Importer.Import(D->getType());
3018 FoundVar->setType(T);
3019 MergeWithVar = FoundVar;
3021 } else if (isa<IncompleteArrayType>(TArray) &&
3022 isa<ConstantArrayType>(FoundArray)) {
3023 MergeWithVar = FoundVar;
3028 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3029 << Name << D->getType() << FoundVar->getType();
3030 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3031 << FoundVar->getType();
3035 ConflictingDecls.push_back(FoundDecls[I]);
3039 // An equivalent variable with external linkage has been found. Link
3040 // the two declarations, then merge them.
3041 Importer.Imported(D, MergeWithVar);
3043 if (VarDecl *DDef = D->getDefinition()) {
3044 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3045 Importer.ToDiag(ExistingDef->getLocation(),
3046 diag::err_odr_variable_multiple_def)
3048 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3050 Expr *Init = Importer.Import(DDef->getInit());
3051 MergeWithVar->setInit(Init);
3052 if (DDef->isInitKnownICE()) {
3053 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3054 Eval->CheckedICE = true;
3055 Eval->IsICE = DDef->isInitICE();
3060 return MergeWithVar;
3063 if (!ConflictingDecls.empty()) {
3064 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3065 ConflictingDecls.data(),
3066 ConflictingDecls.size());
3073 QualType T = Importer.Import(D->getType());
3077 // Create the imported variable.
3078 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3079 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3080 Importer.Import(D->getInnerLocStart()),
3081 Loc, Name.getAsIdentifierInfo(),
3083 D->getStorageClass());
3084 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3085 ToVar->setAccess(D->getAccess());
3086 ToVar->setLexicalDeclContext(LexicalDC);
3087 Importer.Imported(D, ToVar);
3088 LexicalDC->addDeclInternal(ToVar);
3090 // Merge the initializer.
3091 // FIXME: Can we really import any initializer? Alternatively, we could force
3092 // ourselves to import every declaration of a variable and then only use
3094 ToVar->setInit(Importer.Import(const_cast<Expr *>(D->getAnyInitializer())));
3096 // FIXME: Other bits to merge?
3101 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3102 // Parameters are created in the translation unit's context, then moved
3103 // into the function declaration's context afterward.
3104 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3106 // Import the name of this declaration.
3107 DeclarationName Name = Importer.Import(D->getDeclName());
3108 if (D->getDeclName() && !Name)
3111 // Import the location of this declaration.
3112 SourceLocation Loc = Importer.Import(D->getLocation());
3114 // Import the parameter's type.
3115 QualType T = Importer.Import(D->getType());
3119 // Create the imported parameter.
3120 ImplicitParamDecl *ToParm
3121 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3122 Loc, Name.getAsIdentifierInfo(),
3124 return Importer.Imported(D, ToParm);
3127 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3128 // Parameters are created in the translation unit's context, then moved
3129 // into the function declaration's context afterward.
3130 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3132 // Import the name of this declaration.
3133 DeclarationName Name = Importer.Import(D->getDeclName());
3134 if (D->getDeclName() && !Name)
3137 // Import the location of this declaration.
3138 SourceLocation Loc = Importer.Import(D->getLocation());
3140 // Import the parameter's type.
3141 QualType T = Importer.Import(D->getType());
3145 // Create the imported parameter.
3146 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3147 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3148 Importer.Import(D->getInnerLocStart()),
3149 Loc, Name.getAsIdentifierInfo(),
3150 T, TInfo, D->getStorageClass(),
3151 /*FIXME: Default argument*/ 0);
3152 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3153 return Importer.Imported(D, ToParm);
3156 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3157 // Import the major distinguishing characteristics of a method.
3158 DeclContext *DC, *LexicalDC;
3159 DeclarationName Name;
3161 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3164 SmallVector<NamedDecl *, 2> FoundDecls;
3165 DC->localUncachedLookup(Name, FoundDecls);
3166 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3167 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3168 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3171 // Check return types.
3172 if (!Importer.IsStructurallyEquivalent(D->getResultType(),
3173 FoundMethod->getResultType())) {
3174 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3175 << D->isInstanceMethod() << Name
3176 << D->getResultType() << FoundMethod->getResultType();
3177 Importer.ToDiag(FoundMethod->getLocation(),
3178 diag::note_odr_objc_method_here)
3179 << D->isInstanceMethod() << Name;
3183 // Check the number of parameters.
3184 if (D->param_size() != FoundMethod->param_size()) {
3185 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3186 << D->isInstanceMethod() << Name
3187 << D->param_size() << FoundMethod->param_size();
3188 Importer.ToDiag(FoundMethod->getLocation(),
3189 diag::note_odr_objc_method_here)
3190 << D->isInstanceMethod() << Name;
3194 // Check parameter types.
3195 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3196 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3197 P != PEnd; ++P, ++FoundP) {
3198 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3199 (*FoundP)->getType())) {
3200 Importer.FromDiag((*P)->getLocation(),
3201 diag::err_odr_objc_method_param_type_inconsistent)
3202 << D->isInstanceMethod() << Name
3203 << (*P)->getType() << (*FoundP)->getType();
3204 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3205 << (*FoundP)->getType();
3210 // Check variadic/non-variadic.
3211 // Check the number of parameters.
3212 if (D->isVariadic() != FoundMethod->isVariadic()) {
3213 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3214 << D->isInstanceMethod() << Name;
3215 Importer.ToDiag(FoundMethod->getLocation(),
3216 diag::note_odr_objc_method_here)
3217 << D->isInstanceMethod() << Name;
3221 // FIXME: Any other bits we need to merge?
3222 return Importer.Imported(D, FoundMethod);
3226 // Import the result type.
3227 QualType ResultTy = Importer.Import(D->getResultType());
3228 if (ResultTy.isNull())
3231 TypeSourceInfo *ResultTInfo = Importer.Import(D->getResultTypeSourceInfo());
3233 ObjCMethodDecl *ToMethod
3234 = ObjCMethodDecl::Create(Importer.getToContext(),
3236 Importer.Import(D->getLocEnd()),
3237 Name.getObjCSelector(),
3238 ResultTy, ResultTInfo, DC,
3239 D->isInstanceMethod(),
3241 D->isPropertyAccessor(),
3244 D->getImplementationControl(),
3245 D->hasRelatedResultType());
3247 // FIXME: When we decide to merge method definitions, we'll need to
3248 // deal with implicit parameters.
3250 // Import the parameters
3251 SmallVector<ParmVarDecl *, 5> ToParams;
3252 for (ObjCMethodDecl::param_iterator FromP = D->param_begin(),
3253 FromPEnd = D->param_end();
3256 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(*FromP));
3260 ToParams.push_back(ToP);
3263 // Set the parameters.
3264 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3265 ToParams[I]->setOwningFunction(ToMethod);
3266 ToMethod->addDeclInternal(ToParams[I]);
3268 SmallVector<SourceLocation, 12> SelLocs;
3269 D->getSelectorLocs(SelLocs);
3270 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3272 ToMethod->setLexicalDeclContext(LexicalDC);
3273 Importer.Imported(D, ToMethod);
3274 LexicalDC->addDeclInternal(ToMethod);
3278 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3279 // Import the major distinguishing characteristics of a category.
3280 DeclContext *DC, *LexicalDC;
3281 DeclarationName Name;
3283 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3286 ObjCInterfaceDecl *ToInterface
3287 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3291 // Determine if we've already encountered this category.
3292 ObjCCategoryDecl *MergeWithCategory
3293 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3294 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3296 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3297 Importer.Import(D->getAtStartLoc()),
3299 Importer.Import(D->getCategoryNameLoc()),
3300 Name.getAsIdentifierInfo(),
3302 Importer.Import(D->getIvarLBraceLoc()),
3303 Importer.Import(D->getIvarRBraceLoc()));
3304 ToCategory->setLexicalDeclContext(LexicalDC);
3305 LexicalDC->addDeclInternal(ToCategory);
3306 Importer.Imported(D, ToCategory);
3309 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3310 SmallVector<SourceLocation, 4> ProtocolLocs;
3311 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3312 = D->protocol_loc_begin();
3313 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3314 FromProtoEnd = D->protocol_end();
3315 FromProto != FromProtoEnd;
3316 ++FromProto, ++FromProtoLoc) {
3317 ObjCProtocolDecl *ToProto
3318 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3321 Protocols.push_back(ToProto);
3322 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3325 // FIXME: If we're merging, make sure that the protocol list is the same.
3326 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3327 ProtocolLocs.data(), Importer.getToContext());
3330 Importer.Imported(D, ToCategory);
3333 // Import all of the members of this category.
3334 ImportDeclContext(D);
3336 // If we have an implementation, import it as well.
3337 if (D->getImplementation()) {
3338 ObjCCategoryImplDecl *Impl
3339 = cast_or_null<ObjCCategoryImplDecl>(
3340 Importer.Import(D->getImplementation()));
3344 ToCategory->setImplementation(Impl);
3350 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3351 ObjCProtocolDecl *To,
3352 ImportDefinitionKind Kind) {
3353 if (To->getDefinition()) {
3354 if (shouldForceImportDeclContext(Kind))
3355 ImportDeclContext(From);
3359 // Start the protocol definition
3360 To->startDefinition();
3363 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3364 SmallVector<SourceLocation, 4> ProtocolLocs;
3365 ObjCProtocolDecl::protocol_loc_iterator
3366 FromProtoLoc = From->protocol_loc_begin();
3367 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3368 FromProtoEnd = From->protocol_end();
3369 FromProto != FromProtoEnd;
3370 ++FromProto, ++FromProtoLoc) {
3371 ObjCProtocolDecl *ToProto
3372 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3375 Protocols.push_back(ToProto);
3376 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3379 // FIXME: If we're merging, make sure that the protocol list is the same.
3380 To->setProtocolList(Protocols.data(), Protocols.size(),
3381 ProtocolLocs.data(), Importer.getToContext());
3383 if (shouldForceImportDeclContext(Kind)) {
3384 // Import all of the members of this protocol.
3385 ImportDeclContext(From, /*ForceImport=*/true);
3390 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3391 // If this protocol has a definition in the translation unit we're coming
3392 // from, but this particular declaration is not that definition, import the
3393 // definition and map to that.
3394 ObjCProtocolDecl *Definition = D->getDefinition();
3395 if (Definition && Definition != D) {
3396 Decl *ImportedDef = Importer.Import(Definition);
3400 return Importer.Imported(D, ImportedDef);
3403 // Import the major distinguishing characteristics of a protocol.
3404 DeclContext *DC, *LexicalDC;
3405 DeclarationName Name;
3407 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3410 ObjCProtocolDecl *MergeWithProtocol = 0;
3411 SmallVector<NamedDecl *, 2> FoundDecls;
3412 DC->localUncachedLookup(Name, FoundDecls);
3413 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3414 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3417 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3421 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3423 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3424 Name.getAsIdentifierInfo(), Loc,
3425 Importer.Import(D->getAtStartLoc()),
3427 ToProto->setLexicalDeclContext(LexicalDC);
3428 LexicalDC->addDeclInternal(ToProto);
3431 Importer.Imported(D, ToProto);
3433 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3439 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3440 ObjCInterfaceDecl *To,
3441 ImportDefinitionKind Kind) {
3442 if (To->getDefinition()) {
3443 // Check consistency of superclass.
3444 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3446 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3451 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3452 if ((bool)FromSuper != (bool)ToSuper ||
3453 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3454 Importer.ToDiag(To->getLocation(),
3455 diag::err_odr_objc_superclass_inconsistent)
3456 << To->getDeclName();
3458 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3459 << To->getSuperClass()->getDeclName();
3461 Importer.ToDiag(To->getLocation(),
3462 diag::note_odr_objc_missing_superclass);
3463 if (From->getSuperClass())
3464 Importer.FromDiag(From->getSuperClassLoc(),
3465 diag::note_odr_objc_superclass)
3466 << From->getSuperClass()->getDeclName();
3468 Importer.FromDiag(From->getLocation(),
3469 diag::note_odr_objc_missing_superclass);
3472 if (shouldForceImportDeclContext(Kind))
3473 ImportDeclContext(From);
3477 // Start the definition.
3478 To->startDefinition();
3480 // If this class has a superclass, import it.
3481 if (From->getSuperClass()) {
3482 ObjCInterfaceDecl *Super = cast_or_null<ObjCInterfaceDecl>(
3483 Importer.Import(From->getSuperClass()));
3487 To->setSuperClass(Super);
3488 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3492 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3493 SmallVector<SourceLocation, 4> ProtocolLocs;
3494 ObjCInterfaceDecl::protocol_loc_iterator
3495 FromProtoLoc = From->protocol_loc_begin();
3497 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3498 FromProtoEnd = From->protocol_end();
3499 FromProto != FromProtoEnd;
3500 ++FromProto, ++FromProtoLoc) {
3501 ObjCProtocolDecl *ToProto
3502 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3505 Protocols.push_back(ToProto);
3506 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3509 // FIXME: If we're merging, make sure that the protocol list is the same.
3510 To->setProtocolList(Protocols.data(), Protocols.size(),
3511 ProtocolLocs.data(), Importer.getToContext());
3513 // Import categories. When the categories themselves are imported, they'll
3514 // hook themselves into this interface.
3515 for (ObjCInterfaceDecl::known_categories_iterator
3516 Cat = From->known_categories_begin(),
3517 CatEnd = From->known_categories_end();
3518 Cat != CatEnd; ++Cat) {
3519 Importer.Import(*Cat);
3522 // If we have an @implementation, import it as well.
3523 if (From->getImplementation()) {
3524 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3525 Importer.Import(From->getImplementation()));
3529 To->setImplementation(Impl);
3532 if (shouldForceImportDeclContext(Kind)) {
3533 // Import all of the members of this class.
3534 ImportDeclContext(From, /*ForceImport=*/true);
3539 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3540 // If this class has a definition in the translation unit we're coming from,
3541 // but this particular declaration is not that definition, import the
3542 // definition and map to that.
3543 ObjCInterfaceDecl *Definition = D->getDefinition();
3544 if (Definition && Definition != D) {
3545 Decl *ImportedDef = Importer.Import(Definition);
3549 return Importer.Imported(D, ImportedDef);
3552 // Import the major distinguishing characteristics of an @interface.
3553 DeclContext *DC, *LexicalDC;
3554 DeclarationName Name;
3556 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3559 // Look for an existing interface with the same name.
3560 ObjCInterfaceDecl *MergeWithIface = 0;
3561 SmallVector<NamedDecl *, 2> FoundDecls;
3562 DC->localUncachedLookup(Name, FoundDecls);
3563 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3564 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3567 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3571 // Create an interface declaration, if one does not already exist.
3572 ObjCInterfaceDecl *ToIface = MergeWithIface;
3574 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3575 Importer.Import(D->getAtStartLoc()),
3576 Name.getAsIdentifierInfo(),
3578 D->isImplicitInterfaceDecl());
3579 ToIface->setLexicalDeclContext(LexicalDC);
3580 LexicalDC->addDeclInternal(ToIface);
3582 Importer.Imported(D, ToIface);
3584 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3590 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3591 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3592 Importer.Import(D->getCategoryDecl()));
3596 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3598 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3602 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3603 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3604 Importer.Import(D->getIdentifier()),
3605 Category->getClassInterface(),
3606 Importer.Import(D->getLocation()),
3607 Importer.Import(D->getAtStartLoc()),
3610 DeclContext *LexicalDC = DC;
3611 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3612 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3616 ToImpl->setLexicalDeclContext(LexicalDC);
3619 LexicalDC->addDeclInternal(ToImpl);
3620 Category->setImplementation(ToImpl);
3623 Importer.Imported(D, ToImpl);
3624 ImportDeclContext(D);
3628 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3629 // Find the corresponding interface.
3630 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3631 Importer.Import(D->getClassInterface()));
3635 // Import the superclass, if any.
3636 ObjCInterfaceDecl *Super = 0;
3637 if (D->getSuperClass()) {
3638 Super = cast_or_null<ObjCInterfaceDecl>(
3639 Importer.Import(D->getSuperClass()));
3644 ObjCImplementationDecl *Impl = Iface->getImplementation();
3646 // We haven't imported an implementation yet. Create a new @implementation
3648 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3649 Importer.ImportContext(D->getDeclContext()),
3651 Importer.Import(D->getLocation()),
3652 Importer.Import(D->getAtStartLoc()),
3653 Importer.Import(D->getSuperClassLoc()),
3654 Importer.Import(D->getIvarLBraceLoc()),
3655 Importer.Import(D->getIvarRBraceLoc()));
3657 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3658 DeclContext *LexicalDC
3659 = Importer.ImportContext(D->getLexicalDeclContext());
3662 Impl->setLexicalDeclContext(LexicalDC);
3665 // Associate the implementation with the class it implements.
3666 Iface->setImplementation(Impl);
3667 Importer.Imported(D, Iface->getImplementation());
3669 Importer.Imported(D, Iface->getImplementation());
3671 // Verify that the existing @implementation has the same superclass.
3672 if ((Super && !Impl->getSuperClass()) ||
3673 (!Super && Impl->getSuperClass()) ||
3674 (Super && Impl->getSuperClass() &&
3675 !declaresSameEntity(Super->getCanonicalDecl(), Impl->getSuperClass()))) {
3676 Importer.ToDiag(Impl->getLocation(),
3677 diag::err_odr_objc_superclass_inconsistent)
3678 << Iface->getDeclName();
3679 // FIXME: It would be nice to have the location of the superclass
3681 if (Impl->getSuperClass())
3682 Importer.ToDiag(Impl->getLocation(),
3683 diag::note_odr_objc_superclass)
3684 << Impl->getSuperClass()->getDeclName();
3686 Importer.ToDiag(Impl->getLocation(),
3687 diag::note_odr_objc_missing_superclass);
3688 if (D->getSuperClass())
3689 Importer.FromDiag(D->getLocation(),
3690 diag::note_odr_objc_superclass)
3691 << D->getSuperClass()->getDeclName();
3693 Importer.FromDiag(D->getLocation(),
3694 diag::note_odr_objc_missing_superclass);
3699 // Import all of the members of this @implementation.
3700 ImportDeclContext(D);
3705 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3706 // Import the major distinguishing characteristics of an @property.
3707 DeclContext *DC, *LexicalDC;
3708 DeclarationName Name;
3710 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3713 // Check whether we have already imported this property.
3714 SmallVector<NamedDecl *, 2> FoundDecls;
3715 DC->localUncachedLookup(Name, FoundDecls);
3716 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3717 if (ObjCPropertyDecl *FoundProp
3718 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3719 // Check property types.
3720 if (!Importer.IsStructurallyEquivalent(D->getType(),
3721 FoundProp->getType())) {
3722 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3723 << Name << D->getType() << FoundProp->getType();
3724 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3725 << FoundProp->getType();
3729 // FIXME: Check property attributes, getters, setters, etc.?
3731 // Consider these properties to be equivalent.
3732 Importer.Imported(D, FoundProp);
3738 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3742 // Create the new property.
3743 ObjCPropertyDecl *ToProperty
3744 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3745 Name.getAsIdentifierInfo(),
3746 Importer.Import(D->getAtLoc()),
3747 Importer.Import(D->getLParenLoc()),
3749 D->getPropertyImplementation());
3750 Importer.Imported(D, ToProperty);
3751 ToProperty->setLexicalDeclContext(LexicalDC);
3752 LexicalDC->addDeclInternal(ToProperty);
3754 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3755 ToProperty->setPropertyAttributesAsWritten(
3756 D->getPropertyAttributesAsWritten());
3757 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3758 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3759 ToProperty->setGetterMethodDecl(
3760 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3761 ToProperty->setSetterMethodDecl(
3762 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3763 ToProperty->setPropertyIvarDecl(
3764 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3768 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3769 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3770 Importer.Import(D->getPropertyDecl()));
3774 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3778 // Import the lexical declaration context.
3779 DeclContext *LexicalDC = DC;
3780 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3781 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3786 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3790 // Import the ivar (for an @synthesize).
3791 ObjCIvarDecl *Ivar = 0;
3792 if (D->getPropertyIvarDecl()) {
3793 Ivar = cast_or_null<ObjCIvarDecl>(
3794 Importer.Import(D->getPropertyIvarDecl()));
3799 ObjCPropertyImplDecl *ToImpl
3800 = InImpl->FindPropertyImplDecl(Property->getIdentifier());
3802 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3803 Importer.Import(D->getLocStart()),
3804 Importer.Import(D->getLocation()),
3806 D->getPropertyImplementation(),
3808 Importer.Import(D->getPropertyIvarDeclLoc()));
3809 ToImpl->setLexicalDeclContext(LexicalDC);
3810 Importer.Imported(D, ToImpl);
3811 LexicalDC->addDeclInternal(ToImpl);
3813 // Check that we have the same kind of property implementation (@synthesize
3815 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3816 Importer.ToDiag(ToImpl->getLocation(),
3817 diag::err_odr_objc_property_impl_kind_inconsistent)
3818 << Property->getDeclName()
3819 << (ToImpl->getPropertyImplementation()
3820 == ObjCPropertyImplDecl::Dynamic);
3821 Importer.FromDiag(D->getLocation(),
3822 diag::note_odr_objc_property_impl_kind)
3823 << D->getPropertyDecl()->getDeclName()
3824 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3828 // For @synthesize, check that we have the same
3829 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3830 Ivar != ToImpl->getPropertyIvarDecl()) {
3831 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3832 diag::err_odr_objc_synthesize_ivar_inconsistent)
3833 << Property->getDeclName()
3834 << ToImpl->getPropertyIvarDecl()->getDeclName()
3835 << Ivar->getDeclName();
3836 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3837 diag::note_odr_objc_synthesize_ivar_here)
3838 << D->getPropertyIvarDecl()->getDeclName();
3842 // Merge the existing implementation with the new implementation.
3843 Importer.Imported(D, ToImpl);
3849 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3850 // For template arguments, we adopt the translation unit as our declaration
3851 // context. This context will be fixed when the actual template declaration
3854 // FIXME: Import default argument.
3855 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3856 Importer.getToContext().getTranslationUnitDecl(),
3857 Importer.Import(D->getLocStart()),
3858 Importer.Import(D->getLocation()),
3861 Importer.Import(D->getIdentifier()),
3862 D->wasDeclaredWithTypename(),
3863 D->isParameterPack());
3867 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3868 // Import the name of this declaration.
3869 DeclarationName Name = Importer.Import(D->getDeclName());
3870 if (D->getDeclName() && !Name)
3873 // Import the location of this declaration.
3874 SourceLocation Loc = Importer.Import(D->getLocation());
3876 // Import the type of this declaration.
3877 QualType T = Importer.Import(D->getType());
3881 // Import type-source information.
3882 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3883 if (D->getTypeSourceInfo() && !TInfo)
3886 // FIXME: Import default argument.
3888 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3889 Importer.getToContext().getTranslationUnitDecl(),
3890 Importer.Import(D->getInnerLocStart()),
3891 Loc, D->getDepth(), D->getPosition(),
3892 Name.getAsIdentifierInfo(),
3893 T, D->isParameterPack(), TInfo);
3897 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3898 // Import the name of this declaration.
3899 DeclarationName Name = Importer.Import(D->getDeclName());
3900 if (D->getDeclName() && !Name)
3903 // Import the location of this declaration.
3904 SourceLocation Loc = Importer.Import(D->getLocation());
3906 // Import template parameters.
3907 TemplateParameterList *TemplateParams
3908 = ImportTemplateParameterList(D->getTemplateParameters());
3909 if (!TemplateParams)
3912 // FIXME: Import default argument.
3914 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3915 Importer.getToContext().getTranslationUnitDecl(),
3916 Loc, D->getDepth(), D->getPosition(),
3917 D->isParameterPack(),
3918 Name.getAsIdentifierInfo(),
3922 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
3923 // If this record has a definition in the translation unit we're coming from,
3924 // but this particular declaration is not that definition, import the
3925 // definition and map to that.
3926 CXXRecordDecl *Definition
3927 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
3928 if (Definition && Definition != D->getTemplatedDecl()) {
3930 = Importer.Import(Definition->getDescribedClassTemplate());
3934 return Importer.Imported(D, ImportedDef);
3937 // Import the major distinguishing characteristics of this class template.
3938 DeclContext *DC, *LexicalDC;
3939 DeclarationName Name;
3941 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3944 // We may already have a template of the same name; try to find and match it.
3945 if (!DC->isFunctionOrMethod()) {
3946 SmallVector<NamedDecl *, 4> ConflictingDecls;
3947 SmallVector<NamedDecl *, 2> FoundDecls;
3948 DC->localUncachedLookup(Name, FoundDecls);
3949 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3950 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3953 Decl *Found = FoundDecls[I];
3954 if (ClassTemplateDecl *FoundTemplate
3955 = dyn_cast<ClassTemplateDecl>(Found)) {
3956 if (IsStructuralMatch(D, FoundTemplate)) {
3957 // The class templates structurally match; call it the same template.
3958 // FIXME: We may be filling in a forward declaration here. Handle
3960 Importer.Imported(D->getTemplatedDecl(),
3961 FoundTemplate->getTemplatedDecl());
3962 return Importer.Imported(D, FoundTemplate);
3966 ConflictingDecls.push_back(FoundDecls[I]);
3969 if (!ConflictingDecls.empty()) {
3970 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3971 ConflictingDecls.data(),
3972 ConflictingDecls.size());
3979 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
3981 // Create the declaration that is being templated.
3982 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
3983 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
3984 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
3985 DTemplated->getTagKind(),
3986 DC, StartLoc, IdLoc,
3987 Name.getAsIdentifierInfo());
3988 D2Templated->setAccess(DTemplated->getAccess());
3989 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
3990 D2Templated->setLexicalDeclContext(LexicalDC);
3992 // Create the class template declaration itself.
3993 TemplateParameterList *TemplateParams
3994 = ImportTemplateParameterList(D->getTemplateParameters());
3995 if (!TemplateParams)
3998 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
3999 Loc, Name, TemplateParams,
4002 D2Templated->setDescribedClassTemplate(D2);
4004 D2->setAccess(D->getAccess());
4005 D2->setLexicalDeclContext(LexicalDC);
4006 LexicalDC->addDeclInternal(D2);
4008 // Note the relationship between the class templates.
4009 Importer.Imported(D, D2);
4010 Importer.Imported(DTemplated, D2Templated);
4012 if (DTemplated->isCompleteDefinition() &&
4013 !D2Templated->isCompleteDefinition()) {
4014 // FIXME: Import definition!
4020 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4021 ClassTemplateSpecializationDecl *D) {
4022 // If this record has a definition in the translation unit we're coming from,
4023 // but this particular declaration is not that definition, import the
4024 // definition and map to that.
4025 TagDecl *Definition = D->getDefinition();
4026 if (Definition && Definition != D) {
4027 Decl *ImportedDef = Importer.Import(Definition);
4031 return Importer.Imported(D, ImportedDef);
4034 ClassTemplateDecl *ClassTemplate
4035 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4036 D->getSpecializedTemplate()));
4040 // Import the context of this declaration.
4041 DeclContext *DC = ClassTemplate->getDeclContext();
4045 DeclContext *LexicalDC = DC;
4046 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4047 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4052 // Import the location of this declaration.
4053 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4054 SourceLocation IdLoc = Importer.Import(D->getLocation());
4056 // Import template arguments.
4057 SmallVector<TemplateArgument, 2> TemplateArgs;
4058 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4059 D->getTemplateArgs().size(),
4063 // Try to find an existing specialization with these template arguments.
4064 void *InsertPos = 0;
4065 ClassTemplateSpecializationDecl *D2
4066 = ClassTemplate->findSpecialization(TemplateArgs.data(),
4067 TemplateArgs.size(), InsertPos);
4069 // We already have a class template specialization with these template
4072 // FIXME: Check for specialization vs. instantiation errors.
4074 if (RecordDecl *FoundDef = D2->getDefinition()) {
4075 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4076 // The record types structurally match, or the "from" translation
4077 // unit only had a forward declaration anyway; call it the same
4079 return Importer.Imported(D, FoundDef);
4083 // Create a new specialization.
4084 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4085 D->getTagKind(), DC,
4088 TemplateArgs.data(),
4089 TemplateArgs.size(),
4091 D2->setSpecializationKind(D->getSpecializationKind());
4093 // Add this specialization to the class template.
4094 ClassTemplate->AddSpecialization(D2, InsertPos);
4096 // Import the qualifier, if any.
4097 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4099 // Add the specialization to this context.
4100 D2->setLexicalDeclContext(LexicalDC);
4101 LexicalDC->addDeclInternal(D2);
4103 Importer.Imported(D, D2);
4105 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4111 //----------------------------------------------------------------------------
4112 // Import Statements
4113 //----------------------------------------------------------------------------
4115 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4116 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4117 << S->getStmtClassName();
4121 //----------------------------------------------------------------------------
4122 // Import Expressions
4123 //----------------------------------------------------------------------------
4124 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
4125 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4126 << E->getStmtClassName();
4130 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
4131 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4135 NamedDecl *FoundD = 0;
4136 if (E->getDecl() != E->getFoundDecl()) {
4137 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4142 QualType T = Importer.Import(E->getType());
4146 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4147 Importer.Import(E->getQualifierLoc()),
4148 Importer.Import(E->getTemplateKeywordLoc()),
4150 E->refersToEnclosingLocal(),
4151 Importer.Import(E->getLocation()),
4152 T, E->getValueKind(),
4154 /*FIXME:TemplateArgs=*/0);
4155 if (E->hadMultipleCandidates())
4156 DRE->setHadMultipleCandidates(true);
4160 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
4161 QualType T = Importer.Import(E->getType());
4165 return IntegerLiteral::Create(Importer.getToContext(),
4167 Importer.Import(E->getLocation()));
4170 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
4171 QualType T = Importer.Import(E->getType());
4175 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4177 Importer.Import(E->getLocation()));
4180 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
4181 Expr *SubExpr = Importer.Import(E->getSubExpr());
4185 return new (Importer.getToContext())
4186 ParenExpr(Importer.Import(E->getLParen()),
4187 Importer.Import(E->getRParen()),
4191 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
4192 QualType T = Importer.Import(E->getType());
4196 Expr *SubExpr = Importer.Import(E->getSubExpr());
4200 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4201 T, E->getValueKind(),
4203 Importer.Import(E->getOperatorLoc()));
4206 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
4207 UnaryExprOrTypeTraitExpr *E) {
4208 QualType ResultType = Importer.Import(E->getType());
4210 if (E->isArgumentType()) {
4211 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4215 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4217 Importer.Import(E->getOperatorLoc()),
4218 Importer.Import(E->getRParenLoc()));
4221 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4225 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4226 SubExpr, ResultType,
4227 Importer.Import(E->getOperatorLoc()),
4228 Importer.Import(E->getRParenLoc()));
4231 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
4232 QualType T = Importer.Import(E->getType());
4236 Expr *LHS = Importer.Import(E->getLHS());
4240 Expr *RHS = Importer.Import(E->getRHS());
4244 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4245 T, E->getValueKind(),
4247 Importer.Import(E->getOperatorLoc()),
4248 E->isFPContractable());
4251 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
4252 QualType T = Importer.Import(E->getType());
4256 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4257 if (CompLHSType.isNull())
4260 QualType CompResultType = Importer.Import(E->getComputationResultType());
4261 if (CompResultType.isNull())
4264 Expr *LHS = Importer.Import(E->getLHS());
4268 Expr *RHS = Importer.Import(E->getRHS());
4272 return new (Importer.getToContext())
4273 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
4274 T, E->getValueKind(),
4276 CompLHSType, CompResultType,
4277 Importer.Import(E->getOperatorLoc()),
4278 E->isFPContractable());
4281 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
4282 if (E->path_empty()) return false;
4284 // TODO: import cast paths
4288 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
4289 QualType T = Importer.Import(E->getType());
4293 Expr *SubExpr = Importer.Import(E->getSubExpr());
4297 CXXCastPath BasePath;
4298 if (ImportCastPath(E, BasePath))
4301 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4302 SubExpr, &BasePath, E->getValueKind());
4305 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
4306 QualType T = Importer.Import(E->getType());
4310 Expr *SubExpr = Importer.Import(E->getSubExpr());
4314 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4315 if (!TInfo && E->getTypeInfoAsWritten())
4318 CXXCastPath BasePath;
4319 if (ImportCastPath(E, BasePath))
4322 return CStyleCastExpr::Create(Importer.getToContext(), T,
4323 E->getValueKind(), E->getCastKind(),
4324 SubExpr, &BasePath, TInfo,
4325 Importer.Import(E->getLParenLoc()),
4326 Importer.Import(E->getRParenLoc()));
4329 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
4330 ASTContext &FromContext, FileManager &FromFileManager,
4332 : ToContext(ToContext), FromContext(FromContext),
4333 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
4334 Minimal(MinimalImport), LastDiagFromFrom(false)
4336 ImportedDecls[FromContext.getTranslationUnitDecl()]
4337 = ToContext.getTranslationUnitDecl();
4340 ASTImporter::~ASTImporter() { }
4342 QualType ASTImporter::Import(QualType FromT) {
4346 const Type *fromTy = FromT.getTypePtr();
4348 // Check whether we've already imported this type.
4349 llvm::DenseMap<const Type *, const Type *>::iterator Pos
4350 = ImportedTypes.find(fromTy);
4351 if (Pos != ImportedTypes.end())
4352 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
4355 ASTNodeImporter Importer(*this);
4356 QualType ToT = Importer.Visit(fromTy);
4360 // Record the imported type.
4361 ImportedTypes[fromTy] = ToT.getTypePtr();
4363 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
4366 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
4370 // FIXME: For now we just create a "trivial" type source info based
4371 // on the type and a single location. Implement a real version of this.
4372 QualType T = Import(FromTSI->getType());
4376 return ToContext.getTrivialTypeSourceInfo(T,
4377 FromTSI->getTypeLoc().getLocStart());
4380 Decl *ASTImporter::Import(Decl *FromD) {
4384 ASTNodeImporter Importer(*this);
4386 // Check whether we've already imported this declaration.
4387 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
4388 if (Pos != ImportedDecls.end()) {
4389 Decl *ToD = Pos->second;
4390 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4395 Decl *ToD = Importer.Visit(FromD);
4399 // Record the imported declaration.
4400 ImportedDecls[FromD] = ToD;
4402 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
4403 // Keep track of anonymous tags that have an associated typedef.
4404 if (FromTag->getTypedefNameForAnonDecl())
4405 AnonTagsWithPendingTypedefs.push_back(FromTag);
4406 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
4407 // When we've finished transforming a typedef, see whether it was the
4408 // typedef for an anonymous tag.
4409 for (SmallVector<TagDecl *, 4>::iterator
4410 FromTag = AnonTagsWithPendingTypedefs.begin(),
4411 FromTagEnd = AnonTagsWithPendingTypedefs.end();
4412 FromTag != FromTagEnd; ++FromTag) {
4413 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
4414 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
4415 // We found the typedef for an anonymous tag; link them.
4416 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
4417 AnonTagsWithPendingTypedefs.erase(FromTag);
4427 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
4431 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
4435 // When we're using a record/enum/Objective-C class/protocol as a context, we
4436 // need it to have a definition.
4437 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
4438 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
4439 if (ToRecord->isCompleteDefinition()) {
4441 } else if (FromRecord->isCompleteDefinition()) {
4442 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
4443 ASTNodeImporter::IDK_Basic);
4445 CompleteDecl(ToRecord);
4447 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
4448 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
4449 if (ToEnum->isCompleteDefinition()) {
4451 } else if (FromEnum->isCompleteDefinition()) {
4452 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
4453 ASTNodeImporter::IDK_Basic);
4455 CompleteDecl(ToEnum);
4457 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
4458 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
4459 if (ToClass->getDefinition()) {
4461 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
4462 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
4463 ASTNodeImporter::IDK_Basic);
4465 CompleteDecl(ToClass);
4467 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
4468 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
4469 if (ToProto->getDefinition()) {
4471 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
4472 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
4473 ASTNodeImporter::IDK_Basic);
4475 CompleteDecl(ToProto);
4482 Expr *ASTImporter::Import(Expr *FromE) {
4486 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
4489 Stmt *ASTImporter::Import(Stmt *FromS) {
4493 // Check whether we've already imported this declaration.
4494 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
4495 if (Pos != ImportedStmts.end())
4499 ASTNodeImporter Importer(*this);
4500 Stmt *ToS = Importer.Visit(FromS);
4504 // Record the imported declaration.
4505 ImportedStmts[FromS] = ToS;
4509 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
4513 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
4515 switch (FromNNS->getKind()) {
4516 case NestedNameSpecifier::Identifier:
4517 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
4518 return NestedNameSpecifier::Create(ToContext, prefix, II);
4522 case NestedNameSpecifier::Namespace:
4523 if (NamespaceDecl *NS =
4524 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
4525 return NestedNameSpecifier::Create(ToContext, prefix, NS);
4529 case NestedNameSpecifier::NamespaceAlias:
4530 if (NamespaceAliasDecl *NSAD =
4531 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
4532 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
4536 case NestedNameSpecifier::Global:
4537 return NestedNameSpecifier::GlobalSpecifier(ToContext);
4539 case NestedNameSpecifier::TypeSpec:
4540 case NestedNameSpecifier::TypeSpecWithTemplate: {
4541 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
4543 bool bTemplate = FromNNS->getKind() ==
4544 NestedNameSpecifier::TypeSpecWithTemplate;
4545 return NestedNameSpecifier::Create(ToContext, prefix,
4546 bTemplate, T.getTypePtr());
4552 llvm_unreachable("Invalid nested name specifier kind");
4555 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
4556 // FIXME: Implement!
4557 return NestedNameSpecifierLoc();
4560 TemplateName ASTImporter::Import(TemplateName From) {
4561 switch (From.getKind()) {
4562 case TemplateName::Template:
4563 if (TemplateDecl *ToTemplate
4564 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4565 return TemplateName(ToTemplate);
4567 return TemplateName();
4569 case TemplateName::OverloadedTemplate: {
4570 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
4571 UnresolvedSet<2> ToTemplates;
4572 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
4573 E = FromStorage->end();
4575 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
4576 ToTemplates.addDecl(To);
4578 return TemplateName();
4580 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
4584 case TemplateName::QualifiedTemplate: {
4585 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
4586 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
4588 return TemplateName();
4590 if (TemplateDecl *ToTemplate
4591 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4592 return ToContext.getQualifiedTemplateName(Qualifier,
4593 QTN->hasTemplateKeyword(),
4596 return TemplateName();
4599 case TemplateName::DependentTemplate: {
4600 DependentTemplateName *DTN = From.getAsDependentTemplateName();
4601 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
4603 return TemplateName();
4605 if (DTN->isIdentifier()) {
4606 return ToContext.getDependentTemplateName(Qualifier,
4607 Import(DTN->getIdentifier()));
4610 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
4613 case TemplateName::SubstTemplateTemplateParm: {
4614 SubstTemplateTemplateParmStorage *subst
4615 = From.getAsSubstTemplateTemplateParm();
4616 TemplateTemplateParmDecl *param
4617 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
4619 return TemplateName();
4621 TemplateName replacement = Import(subst->getReplacement());
4622 if (replacement.isNull()) return TemplateName();
4624 return ToContext.getSubstTemplateTemplateParm(param, replacement);
4627 case TemplateName::SubstTemplateTemplateParmPack: {
4628 SubstTemplateTemplateParmPackStorage *SubstPack
4629 = From.getAsSubstTemplateTemplateParmPack();
4630 TemplateTemplateParmDecl *Param
4631 = cast_or_null<TemplateTemplateParmDecl>(
4632 Import(SubstPack->getParameterPack()));
4634 return TemplateName();
4636 ASTNodeImporter Importer(*this);
4637 TemplateArgument ArgPack
4638 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4639 if (ArgPack.isNull())
4640 return TemplateName();
4642 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
4646 llvm_unreachable("Invalid template name kind");
4649 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
4650 if (FromLoc.isInvalid())
4651 return SourceLocation();
4653 SourceManager &FromSM = FromContext.getSourceManager();
4655 // For now, map everything down to its spelling location, so that we
4656 // don't have to import macro expansions.
4657 // FIXME: Import macro expansions!
4658 FromLoc = FromSM.getSpellingLoc(FromLoc);
4659 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
4660 SourceManager &ToSM = ToContext.getSourceManager();
4661 return ToSM.getLocForStartOfFile(Import(Decomposed.first))
4662 .getLocWithOffset(Decomposed.second);
4665 SourceRange ASTImporter::Import(SourceRange FromRange) {
4666 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
4669 FileID ASTImporter::Import(FileID FromID) {
4670 llvm::DenseMap<FileID, FileID>::iterator Pos
4671 = ImportedFileIDs.find(FromID);
4672 if (Pos != ImportedFileIDs.end())
4675 SourceManager &FromSM = FromContext.getSourceManager();
4676 SourceManager &ToSM = ToContext.getSourceManager();
4677 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
4678 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
4680 // Include location of this file.
4681 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
4683 // Map the FileID for to the "to" source manager.
4685 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
4686 if (Cache->OrigEntry) {
4687 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
4689 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
4690 // than mmap the files several times.
4691 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
4692 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
4693 FromSLoc.getFile().getFileCharacteristic());
4695 // FIXME: We want to re-use the existing MemoryBuffer!
4696 const llvm::MemoryBuffer *
4697 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
4698 llvm::MemoryBuffer *ToBuf
4699 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
4700 FromBuf->getBufferIdentifier());
4701 ToID = ToSM.createFileIDForMemBuffer(ToBuf,
4702 FromSLoc.getFile().getFileCharacteristic());
4706 ImportedFileIDs[FromID] = ToID;
4710 void ASTImporter::ImportDefinition(Decl *From) {
4711 Decl *To = Import(From);
4715 if (DeclContext *FromDC = cast<DeclContext>(From)) {
4716 ASTNodeImporter Importer(*this);
4718 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
4719 if (!ToRecord->getDefinition()) {
4720 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4721 ASTNodeImporter::IDK_Everything);
4726 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
4727 if (!ToEnum->getDefinition()) {
4728 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4729 ASTNodeImporter::IDK_Everything);
4734 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
4735 if (!ToIFace->getDefinition()) {
4736 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4737 ASTNodeImporter::IDK_Everything);
4742 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
4743 if (!ToProto->getDefinition()) {
4744 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4745 ASTNodeImporter::IDK_Everything);
4750 Importer.ImportDeclContext(FromDC, true);
4754 DeclarationName ASTImporter::Import(DeclarationName FromName) {
4756 return DeclarationName();
4758 switch (FromName.getNameKind()) {
4759 case DeclarationName::Identifier:
4760 return Import(FromName.getAsIdentifierInfo());
4762 case DeclarationName::ObjCZeroArgSelector:
4763 case DeclarationName::ObjCOneArgSelector:
4764 case DeclarationName::ObjCMultiArgSelector:
4765 return Import(FromName.getObjCSelector());
4767 case DeclarationName::CXXConstructorName: {
4768 QualType T = Import(FromName.getCXXNameType());
4770 return DeclarationName();
4772 return ToContext.DeclarationNames.getCXXConstructorName(
4773 ToContext.getCanonicalType(T));
4776 case DeclarationName::CXXDestructorName: {
4777 QualType T = Import(FromName.getCXXNameType());
4779 return DeclarationName();
4781 return ToContext.DeclarationNames.getCXXDestructorName(
4782 ToContext.getCanonicalType(T));
4785 case DeclarationName::CXXConversionFunctionName: {
4786 QualType T = Import(FromName.getCXXNameType());
4788 return DeclarationName();
4790 return ToContext.DeclarationNames.getCXXConversionFunctionName(
4791 ToContext.getCanonicalType(T));
4794 case DeclarationName::CXXOperatorName:
4795 return ToContext.DeclarationNames.getCXXOperatorName(
4796 FromName.getCXXOverloadedOperator());
4798 case DeclarationName::CXXLiteralOperatorName:
4799 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
4800 Import(FromName.getCXXLiteralIdentifier()));
4802 case DeclarationName::CXXUsingDirective:
4804 return DeclarationName::getUsingDirectiveName();
4807 llvm_unreachable("Invalid DeclarationName Kind!");
4810 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
4814 return &ToContext.Idents.get(FromId->getName());
4817 Selector ASTImporter::Import(Selector FromSel) {
4818 if (FromSel.isNull())
4821 SmallVector<IdentifierInfo *, 4> Idents;
4822 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
4823 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
4824 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
4825 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
4828 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
4832 unsigned NumDecls) {
4836 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
4837 if (LastDiagFromFrom)
4838 ToContext.getDiagnostics().notePriorDiagnosticFrom(
4839 FromContext.getDiagnostics());
4840 LastDiagFromFrom = false;
4841 return ToContext.getDiagnostics().Report(Loc, DiagID);
4844 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
4845 if (!LastDiagFromFrom)
4846 FromContext.getDiagnostics().notePriorDiagnosticFrom(
4847 ToContext.getDiagnostics());
4848 LastDiagFromFrom = true;
4849 return FromContext.getDiagnostics().Report(Loc, DiagID);
4852 void ASTImporter::CompleteDecl (Decl *D) {
4853 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
4854 if (!ID->getDefinition())
4855 ID->startDefinition();
4857 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
4858 if (!PD->getDefinition())
4859 PD->startDefinition();
4861 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
4862 if (!TD->getDefinition() && !TD->isBeingDefined()) {
4863 TD->startDefinition();
4864 TD->setCompleteDefinition(true);
4868 assert (0 && "CompleteDecl called on a Decl that can't be completed");
4872 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
4873 ImportedDecls[From] = To;
4877 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
4879 llvm::DenseMap<const Type *, const Type *>::iterator Pos
4880 = ImportedTypes.find(From.getTypePtr());
4881 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
4884 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
4886 return Ctx.IsStructurallyEquivalent(From, To);