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(VarDecl *From, VarDecl *To,
110 ImportDefinitionKind Kind = IDK_Default);
111 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
112 ImportDefinitionKind Kind = IDK_Default);
113 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
114 ImportDefinitionKind Kind = IDK_Default);
115 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
116 ImportDefinitionKind Kind = IDK_Default);
117 TemplateParameterList *ImportTemplateParameterList(
118 TemplateParameterList *Params);
119 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
120 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
121 unsigned NumFromArgs,
122 SmallVectorImpl<TemplateArgument> &ToArgs);
123 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
124 bool Complain = true);
125 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
126 bool Complain = true);
127 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
128 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
129 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
130 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
131 Decl *VisitDecl(Decl *D);
132 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
133 Decl *VisitNamespaceDecl(NamespaceDecl *D);
134 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
135 Decl *VisitTypedefDecl(TypedefDecl *D);
136 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
137 Decl *VisitEnumDecl(EnumDecl *D);
138 Decl *VisitRecordDecl(RecordDecl *D);
139 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
140 Decl *VisitFunctionDecl(FunctionDecl *D);
141 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
142 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
143 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
144 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
145 Decl *VisitFieldDecl(FieldDecl *D);
146 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
147 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
148 Decl *VisitVarDecl(VarDecl *D);
149 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
150 Decl *VisitParmVarDecl(ParmVarDecl *D);
151 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
152 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
153 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
154 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
155 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
156 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
157 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
158 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
159 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
160 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
161 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
162 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
163 Decl *VisitClassTemplateSpecializationDecl(
164 ClassTemplateSpecializationDecl *D);
165 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
166 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
168 // Importing statements
169 Stmt *VisitStmt(Stmt *S);
171 // Importing expressions
172 Expr *VisitExpr(Expr *E);
173 Expr *VisitDeclRefExpr(DeclRefExpr *E);
174 Expr *VisitIntegerLiteral(IntegerLiteral *E);
175 Expr *VisitCharacterLiteral(CharacterLiteral *E);
176 Expr *VisitParenExpr(ParenExpr *E);
177 Expr *VisitUnaryOperator(UnaryOperator *E);
178 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
179 Expr *VisitBinaryOperator(BinaryOperator *E);
180 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
181 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
182 Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
185 using namespace clang;
187 //----------------------------------------------------------------------------
188 // Structural Equivalence
189 //----------------------------------------------------------------------------
192 struct StructuralEquivalenceContext {
193 /// \brief AST contexts for which we are checking structural equivalence.
196 /// \brief The set of "tentative" equivalences between two canonical
197 /// declarations, mapping from a declaration in the first context to the
198 /// declaration in the second context that we believe to be equivalent.
199 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
201 /// \brief Queue of declarations in the first context whose equivalence
202 /// with a declaration in the second context still needs to be verified.
203 std::deque<Decl *> DeclsToCheck;
205 /// \brief Declaration (from, to) pairs that are known not to be equivalent
206 /// (which we have already complained about).
207 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
209 /// \brief Whether we're being strict about the spelling of types when
210 /// unifying two types.
211 bool StrictTypeSpelling;
213 /// \brief Whether to complain about failures.
216 /// \brief \c true if the last diagnostic came from C2.
219 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
220 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
221 bool StrictTypeSpelling = false,
222 bool Complain = true)
223 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
224 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
225 LastDiagFromC2(false) {}
227 /// \brief Determine whether the two declarations are structurally
229 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
231 /// \brief Determine whether the two types are structurally equivalent.
232 bool IsStructurallyEquivalent(QualType T1, QualType T2);
235 /// \brief Finish checking all of the structural equivalences.
237 /// \returns true if an error occurred, false otherwise.
241 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
242 assert(Complain && "Not allowed to complain");
244 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
245 LastDiagFromC2 = false;
246 return C1.getDiagnostics().Report(Loc, DiagID);
249 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
250 assert(Complain && "Not allowed to complain");
252 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
253 LastDiagFromC2 = true;
254 return C2.getDiagnostics().Report(Loc, DiagID);
259 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
260 QualType T1, QualType T2);
261 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
264 /// \brief Determine structural equivalence of two expressions.
265 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
266 Expr *E1, Expr *E2) {
270 // FIXME: Actually perform a structural comparison!
274 /// \brief Determine whether two identifiers are equivalent.
275 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
276 const IdentifierInfo *Name2) {
277 if (!Name1 || !Name2)
278 return Name1 == Name2;
280 return Name1->getName() == Name2->getName();
283 /// \brief Determine whether two nested-name-specifiers are equivalent.
284 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
285 NestedNameSpecifier *NNS1,
286 NestedNameSpecifier *NNS2) {
291 /// \brief Determine whether two template arguments are equivalent.
292 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
293 const TemplateArgument &Arg1,
294 const TemplateArgument &Arg2) {
295 if (Arg1.getKind() != Arg2.getKind())
298 switch (Arg1.getKind()) {
299 case TemplateArgument::Null:
302 case TemplateArgument::Type:
303 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
305 case TemplateArgument::Integral:
306 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
307 Arg2.getIntegralType()))
310 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
312 case TemplateArgument::Declaration:
313 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
315 case TemplateArgument::NullPtr:
316 return true; // FIXME: Is this correct?
318 case TemplateArgument::Template:
319 return IsStructurallyEquivalent(Context,
320 Arg1.getAsTemplate(),
321 Arg2.getAsTemplate());
323 case TemplateArgument::TemplateExpansion:
324 return IsStructurallyEquivalent(Context,
325 Arg1.getAsTemplateOrTemplatePattern(),
326 Arg2.getAsTemplateOrTemplatePattern());
328 case TemplateArgument::Expression:
329 return IsStructurallyEquivalent(Context,
330 Arg1.getAsExpr(), Arg2.getAsExpr());
332 case TemplateArgument::Pack:
333 if (Arg1.pack_size() != Arg2.pack_size())
336 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
337 if (!IsStructurallyEquivalent(Context,
338 Arg1.pack_begin()[I],
339 Arg2.pack_begin()[I]))
345 llvm_unreachable("Invalid template argument kind");
348 /// \brief Determine structural equivalence for the common part of array
350 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
351 const ArrayType *Array1,
352 const ArrayType *Array2) {
353 if (!IsStructurallyEquivalent(Context,
354 Array1->getElementType(),
355 Array2->getElementType()))
357 if (Array1->getSizeModifier() != Array2->getSizeModifier())
359 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
365 /// \brief Determine structural equivalence of two types.
366 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
367 QualType T1, QualType T2) {
368 if (T1.isNull() || T2.isNull())
369 return T1.isNull() && T2.isNull();
371 if (!Context.StrictTypeSpelling) {
372 // We aren't being strict about token-to-token equivalence of types,
373 // so map down to the canonical type.
374 T1 = Context.C1.getCanonicalType(T1);
375 T2 = Context.C2.getCanonicalType(T2);
378 if (T1.getQualifiers() != T2.getQualifiers())
381 Type::TypeClass TC = T1->getTypeClass();
383 if (T1->getTypeClass() != T2->getTypeClass()) {
384 // Compare function types with prototypes vs. without prototypes as if
385 // both did not have prototypes.
386 if (T1->getTypeClass() == Type::FunctionProto &&
387 T2->getTypeClass() == Type::FunctionNoProto)
388 TC = Type::FunctionNoProto;
389 else if (T1->getTypeClass() == Type::FunctionNoProto &&
390 T2->getTypeClass() == Type::FunctionProto)
391 TC = Type::FunctionNoProto;
398 // FIXME: Deal with Char_S/Char_U.
399 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
404 if (!IsStructurallyEquivalent(Context,
405 cast<ComplexType>(T1)->getElementType(),
406 cast<ComplexType>(T2)->getElementType()))
412 if (!IsStructurallyEquivalent(Context,
413 cast<AdjustedType>(T1)->getOriginalType(),
414 cast<AdjustedType>(T2)->getOriginalType()))
419 if (!IsStructurallyEquivalent(Context,
420 cast<PointerType>(T1)->getPointeeType(),
421 cast<PointerType>(T2)->getPointeeType()))
425 case Type::BlockPointer:
426 if (!IsStructurallyEquivalent(Context,
427 cast<BlockPointerType>(T1)->getPointeeType(),
428 cast<BlockPointerType>(T2)->getPointeeType()))
432 case Type::LValueReference:
433 case Type::RValueReference: {
434 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
435 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
436 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
438 if (Ref1->isInnerRef() != Ref2->isInnerRef())
440 if (!IsStructurallyEquivalent(Context,
441 Ref1->getPointeeTypeAsWritten(),
442 Ref2->getPointeeTypeAsWritten()))
447 case Type::MemberPointer: {
448 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
449 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
450 if (!IsStructurallyEquivalent(Context,
451 MemPtr1->getPointeeType(),
452 MemPtr2->getPointeeType()))
454 if (!IsStructurallyEquivalent(Context,
455 QualType(MemPtr1->getClass(), 0),
456 QualType(MemPtr2->getClass(), 0)))
461 case Type::ConstantArray: {
462 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
463 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
464 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
467 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
472 case Type::IncompleteArray:
473 if (!IsArrayStructurallyEquivalent(Context,
475 cast<ArrayType>(T2)))
479 case Type::VariableArray: {
480 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
481 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
482 if (!IsStructurallyEquivalent(Context,
483 Array1->getSizeExpr(), Array2->getSizeExpr()))
486 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
492 case Type::DependentSizedArray: {
493 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
494 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
495 if (!IsStructurallyEquivalent(Context,
496 Array1->getSizeExpr(), Array2->getSizeExpr()))
499 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
505 case Type::DependentSizedExtVector: {
506 const DependentSizedExtVectorType *Vec1
507 = cast<DependentSizedExtVectorType>(T1);
508 const DependentSizedExtVectorType *Vec2
509 = cast<DependentSizedExtVectorType>(T2);
510 if (!IsStructurallyEquivalent(Context,
511 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
513 if (!IsStructurallyEquivalent(Context,
514 Vec1->getElementType(),
515 Vec2->getElementType()))
521 case Type::ExtVector: {
522 const VectorType *Vec1 = cast<VectorType>(T1);
523 const VectorType *Vec2 = cast<VectorType>(T2);
524 if (!IsStructurallyEquivalent(Context,
525 Vec1->getElementType(),
526 Vec2->getElementType()))
528 if (Vec1->getNumElements() != Vec2->getNumElements())
530 if (Vec1->getVectorKind() != Vec2->getVectorKind())
535 case Type::FunctionProto: {
536 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
537 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
538 if (Proto1->getNumParams() != Proto2->getNumParams())
540 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
541 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
542 Proto2->getParamType(I)))
545 if (Proto1->isVariadic() != Proto2->isVariadic())
547 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
549 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
550 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
552 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
553 if (!IsStructurallyEquivalent(Context,
554 Proto1->getExceptionType(I),
555 Proto2->getExceptionType(I)))
558 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
559 if (!IsStructurallyEquivalent(Context,
560 Proto1->getNoexceptExpr(),
561 Proto2->getNoexceptExpr()))
564 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
567 // Fall through to check the bits common with FunctionNoProtoType.
570 case Type::FunctionNoProto: {
571 const FunctionType *Function1 = cast<FunctionType>(T1);
572 const FunctionType *Function2 = cast<FunctionType>(T2);
573 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
574 Function2->getReturnType()))
576 if (Function1->getExtInfo() != Function2->getExtInfo())
581 case Type::UnresolvedUsing:
582 if (!IsStructurallyEquivalent(Context,
583 cast<UnresolvedUsingType>(T1)->getDecl(),
584 cast<UnresolvedUsingType>(T2)->getDecl()))
589 case Type::Attributed:
590 if (!IsStructurallyEquivalent(Context,
591 cast<AttributedType>(T1)->getModifiedType(),
592 cast<AttributedType>(T2)->getModifiedType()))
594 if (!IsStructurallyEquivalent(Context,
595 cast<AttributedType>(T1)->getEquivalentType(),
596 cast<AttributedType>(T2)->getEquivalentType()))
601 if (!IsStructurallyEquivalent(Context,
602 cast<ParenType>(T1)->getInnerType(),
603 cast<ParenType>(T2)->getInnerType()))
608 if (!IsStructurallyEquivalent(Context,
609 cast<TypedefType>(T1)->getDecl(),
610 cast<TypedefType>(T2)->getDecl()))
614 case Type::TypeOfExpr:
615 if (!IsStructurallyEquivalent(Context,
616 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
617 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
622 if (!IsStructurallyEquivalent(Context,
623 cast<TypeOfType>(T1)->getUnderlyingType(),
624 cast<TypeOfType>(T2)->getUnderlyingType()))
628 case Type::UnaryTransform:
629 if (!IsStructurallyEquivalent(Context,
630 cast<UnaryTransformType>(T1)->getUnderlyingType(),
631 cast<UnaryTransformType>(T1)->getUnderlyingType()))
636 if (!IsStructurallyEquivalent(Context,
637 cast<DecltypeType>(T1)->getUnderlyingExpr(),
638 cast<DecltypeType>(T2)->getUnderlyingExpr()))
643 if (!IsStructurallyEquivalent(Context,
644 cast<AutoType>(T1)->getDeducedType(),
645 cast<AutoType>(T2)->getDeducedType()))
651 if (!IsStructurallyEquivalent(Context,
652 cast<TagType>(T1)->getDecl(),
653 cast<TagType>(T2)->getDecl()))
657 case Type::TemplateTypeParm: {
658 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
659 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
660 if (Parm1->getDepth() != Parm2->getDepth())
662 if (Parm1->getIndex() != Parm2->getIndex())
664 if (Parm1->isParameterPack() != Parm2->isParameterPack())
667 // Names of template type parameters are never significant.
671 case Type::SubstTemplateTypeParm: {
672 const SubstTemplateTypeParmType *Subst1
673 = cast<SubstTemplateTypeParmType>(T1);
674 const SubstTemplateTypeParmType *Subst2
675 = cast<SubstTemplateTypeParmType>(T2);
676 if (!IsStructurallyEquivalent(Context,
677 QualType(Subst1->getReplacedParameter(), 0),
678 QualType(Subst2->getReplacedParameter(), 0)))
680 if (!IsStructurallyEquivalent(Context,
681 Subst1->getReplacementType(),
682 Subst2->getReplacementType()))
687 case Type::SubstTemplateTypeParmPack: {
688 const SubstTemplateTypeParmPackType *Subst1
689 = cast<SubstTemplateTypeParmPackType>(T1);
690 const SubstTemplateTypeParmPackType *Subst2
691 = cast<SubstTemplateTypeParmPackType>(T2);
692 if (!IsStructurallyEquivalent(Context,
693 QualType(Subst1->getReplacedParameter(), 0),
694 QualType(Subst2->getReplacedParameter(), 0)))
696 if (!IsStructurallyEquivalent(Context,
697 Subst1->getArgumentPack(),
698 Subst2->getArgumentPack()))
702 case Type::TemplateSpecialization: {
703 const TemplateSpecializationType *Spec1
704 = cast<TemplateSpecializationType>(T1);
705 const TemplateSpecializationType *Spec2
706 = cast<TemplateSpecializationType>(T2);
707 if (!IsStructurallyEquivalent(Context,
708 Spec1->getTemplateName(),
709 Spec2->getTemplateName()))
711 if (Spec1->getNumArgs() != Spec2->getNumArgs())
713 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
714 if (!IsStructurallyEquivalent(Context,
715 Spec1->getArg(I), Spec2->getArg(I)))
721 case Type::Elaborated: {
722 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
723 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
724 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
725 if (Elab1->getKeyword() != Elab2->getKeyword())
727 if (!IsStructurallyEquivalent(Context,
728 Elab1->getQualifier(),
729 Elab2->getQualifier()))
731 if (!IsStructurallyEquivalent(Context,
732 Elab1->getNamedType(),
733 Elab2->getNamedType()))
738 case Type::InjectedClassName: {
739 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
740 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
741 if (!IsStructurallyEquivalent(Context,
742 Inj1->getInjectedSpecializationType(),
743 Inj2->getInjectedSpecializationType()))
748 case Type::DependentName: {
749 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
750 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
751 if (!IsStructurallyEquivalent(Context,
752 Typename1->getQualifier(),
753 Typename2->getQualifier()))
755 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
756 Typename2->getIdentifier()))
762 case Type::DependentTemplateSpecialization: {
763 const DependentTemplateSpecializationType *Spec1 =
764 cast<DependentTemplateSpecializationType>(T1);
765 const DependentTemplateSpecializationType *Spec2 =
766 cast<DependentTemplateSpecializationType>(T2);
767 if (!IsStructurallyEquivalent(Context,
768 Spec1->getQualifier(),
769 Spec2->getQualifier()))
771 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
772 Spec2->getIdentifier()))
774 if (Spec1->getNumArgs() != Spec2->getNumArgs())
776 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
777 if (!IsStructurallyEquivalent(Context,
778 Spec1->getArg(I), Spec2->getArg(I)))
784 case Type::PackExpansion:
785 if (!IsStructurallyEquivalent(Context,
786 cast<PackExpansionType>(T1)->getPattern(),
787 cast<PackExpansionType>(T2)->getPattern()))
791 case Type::ObjCInterface: {
792 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
793 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
794 if (!IsStructurallyEquivalent(Context,
795 Iface1->getDecl(), Iface2->getDecl()))
800 case Type::ObjCObject: {
801 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
802 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
803 if (!IsStructurallyEquivalent(Context,
805 Obj2->getBaseType()))
807 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
809 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
810 if (!IsStructurallyEquivalent(Context,
811 Obj1->getProtocol(I),
812 Obj2->getProtocol(I)))
818 case Type::ObjCObjectPointer: {
819 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
820 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
821 if (!IsStructurallyEquivalent(Context,
822 Ptr1->getPointeeType(),
823 Ptr2->getPointeeType()))
829 if (!IsStructurallyEquivalent(Context,
830 cast<AtomicType>(T1)->getValueType(),
831 cast<AtomicType>(T2)->getValueType()))
841 /// \brief Determine structural equivalence of two fields.
842 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
843 FieldDecl *Field1, FieldDecl *Field2) {
844 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
846 // For anonymous structs/unions, match up the anonymous struct/union type
847 // declarations directly, so that we don't go off searching for anonymous
849 if (Field1->isAnonymousStructOrUnion() &&
850 Field2->isAnonymousStructOrUnion()) {
851 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
852 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
853 return IsStructurallyEquivalent(Context, D1, D2);
856 // Check for equivalent field names.
857 IdentifierInfo *Name1 = Field1->getIdentifier();
858 IdentifierInfo *Name2 = Field2->getIdentifier();
859 if (!::IsStructurallyEquivalent(Name1, Name2))
862 if (!IsStructurallyEquivalent(Context,
863 Field1->getType(), Field2->getType())) {
864 if (Context.Complain) {
865 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
866 << Context.C2.getTypeDeclType(Owner2);
867 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
868 << Field2->getDeclName() << Field2->getType();
869 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
870 << Field1->getDeclName() << Field1->getType();
875 if (Field1->isBitField() != Field2->isBitField()) {
876 if (Context.Complain) {
877 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
878 << Context.C2.getTypeDeclType(Owner2);
879 if (Field1->isBitField()) {
880 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
881 << Field1->getDeclName() << Field1->getType()
882 << Field1->getBitWidthValue(Context.C1);
883 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
884 << Field2->getDeclName();
886 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
887 << Field2->getDeclName() << Field2->getType()
888 << Field2->getBitWidthValue(Context.C2);
889 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
890 << Field1->getDeclName();
896 if (Field1->isBitField()) {
897 // Make sure that the bit-fields are the same length.
898 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
899 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
901 if (Bits1 != Bits2) {
902 if (Context.Complain) {
903 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
904 << Context.C2.getTypeDeclType(Owner2);
905 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
906 << Field2->getDeclName() << Field2->getType() << Bits2;
907 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
908 << Field1->getDeclName() << Field1->getType() << Bits1;
917 /// \brief Find the index of the given anonymous struct/union within its
920 /// \returns Returns the index of this anonymous struct/union in its context,
921 /// including the next assigned index (if none of them match). Returns an
922 /// empty option if the context is not a record, i.e.. if the anonymous
923 /// struct/union is at namespace or block scope.
924 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
925 ASTContext &Context = Anon->getASTContext();
926 QualType AnonTy = Context.getRecordType(Anon);
928 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
933 for (const auto *D : Owner->noload_decls()) {
934 const auto *F = dyn_cast<FieldDecl>(D);
935 if (!F || !F->isAnonymousStructOrUnion())
938 if (Context.hasSameType(F->getType(), AnonTy))
947 /// \brief Determine structural equivalence of two records.
948 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
949 RecordDecl *D1, RecordDecl *D2) {
950 if (D1->isUnion() != D2->isUnion()) {
951 if (Context.Complain) {
952 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
953 << Context.C2.getTypeDeclType(D2);
954 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
955 << D1->getDeclName() << (unsigned)D1->getTagKind();
960 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
961 // If both anonymous structs/unions are in a record context, make sure
962 // they occur in the same location in the context records.
963 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
964 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
965 if (*Index1 != *Index2)
971 // If both declarations are class template specializations, we know
972 // the ODR applies, so check the template and template arguments.
973 ClassTemplateSpecializationDecl *Spec1
974 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
975 ClassTemplateSpecializationDecl *Spec2
976 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
977 if (Spec1 && Spec2) {
978 // Check that the specialized templates are the same.
979 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
980 Spec2->getSpecializedTemplate()))
983 // Check that the template arguments are the same.
984 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
987 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
988 if (!IsStructurallyEquivalent(Context,
989 Spec1->getTemplateArgs().get(I),
990 Spec2->getTemplateArgs().get(I)))
993 // If one is a class template specialization and the other is not, these
994 // structures are different.
995 else if (Spec1 || Spec2)
998 // Compare the definitions of these two records. If either or both are
999 // incomplete, we assume that they are equivalent.
1000 D1 = D1->getDefinition();
1001 D2 = D2->getDefinition();
1005 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1006 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1007 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1008 if (Context.Complain) {
1009 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1010 << Context.C2.getTypeDeclType(D2);
1011 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1012 << D2CXX->getNumBases();
1013 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1014 << D1CXX->getNumBases();
1019 // Check the base classes.
1020 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1021 BaseEnd1 = D1CXX->bases_end(),
1022 Base2 = D2CXX->bases_begin();
1025 if (!IsStructurallyEquivalent(Context,
1026 Base1->getType(), Base2->getType())) {
1027 if (Context.Complain) {
1028 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1029 << Context.C2.getTypeDeclType(D2);
1030 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1032 << Base2->getSourceRange();
1033 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1035 << Base1->getSourceRange();
1040 // Check virtual vs. non-virtual inheritance mismatch.
1041 if (Base1->isVirtual() != Base2->isVirtual()) {
1042 if (Context.Complain) {
1043 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1044 << Context.C2.getTypeDeclType(D2);
1045 Context.Diag2(Base2->getLocStart(),
1046 diag::note_odr_virtual_base)
1047 << Base2->isVirtual() << Base2->getSourceRange();
1048 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1049 << Base1->isVirtual()
1050 << Base1->getSourceRange();
1055 } else if (D1CXX->getNumBases() > 0) {
1056 if (Context.Complain) {
1057 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1058 << Context.C2.getTypeDeclType(D2);
1059 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1060 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1062 << Base1->getSourceRange();
1063 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1069 // Check the fields for consistency.
1070 RecordDecl::field_iterator Field2 = D2->field_begin(),
1071 Field2End = D2->field_end();
1072 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1073 Field1End = D1->field_end();
1074 Field1 != Field1End;
1075 ++Field1, ++Field2) {
1076 if (Field2 == Field2End) {
1077 if (Context.Complain) {
1078 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1079 << Context.C2.getTypeDeclType(D2);
1080 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1081 << Field1->getDeclName() << Field1->getType();
1082 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1087 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1091 if (Field2 != Field2End) {
1092 if (Context.Complain) {
1093 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1094 << Context.C2.getTypeDeclType(D2);
1095 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1096 << Field2->getDeclName() << Field2->getType();
1097 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1105 /// \brief Determine structural equivalence of two enums.
1106 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1107 EnumDecl *D1, EnumDecl *D2) {
1108 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1109 EC2End = D2->enumerator_end();
1110 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1111 EC1End = D1->enumerator_end();
1112 EC1 != EC1End; ++EC1, ++EC2) {
1113 if (EC2 == EC2End) {
1114 if (Context.Complain) {
1115 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1116 << Context.C2.getTypeDeclType(D2);
1117 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1118 << EC1->getDeclName()
1119 << EC1->getInitVal().toString(10);
1120 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1125 llvm::APSInt Val1 = EC1->getInitVal();
1126 llvm::APSInt Val2 = EC2->getInitVal();
1127 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1128 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1129 if (Context.Complain) {
1130 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1131 << Context.C2.getTypeDeclType(D2);
1132 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1133 << EC2->getDeclName()
1134 << EC2->getInitVal().toString(10);
1135 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1136 << EC1->getDeclName()
1137 << EC1->getInitVal().toString(10);
1143 if (EC2 != EC2End) {
1144 if (Context.Complain) {
1145 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1146 << Context.C2.getTypeDeclType(D2);
1147 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1148 << EC2->getDeclName()
1149 << EC2->getInitVal().toString(10);
1150 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1158 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1159 TemplateParameterList *Params1,
1160 TemplateParameterList *Params2) {
1161 if (Params1->size() != Params2->size()) {
1162 if (Context.Complain) {
1163 Context.Diag2(Params2->getTemplateLoc(),
1164 diag::err_odr_different_num_template_parameters)
1165 << Params1->size() << Params2->size();
1166 Context.Diag1(Params1->getTemplateLoc(),
1167 diag::note_odr_template_parameter_list);
1172 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1173 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1174 if (Context.Complain) {
1175 Context.Diag2(Params2->getParam(I)->getLocation(),
1176 diag::err_odr_different_template_parameter_kind);
1177 Context.Diag1(Params1->getParam(I)->getLocation(),
1178 diag::note_odr_template_parameter_here);
1183 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1184 Params2->getParam(I))) {
1193 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1194 TemplateTypeParmDecl *D1,
1195 TemplateTypeParmDecl *D2) {
1196 if (D1->isParameterPack() != D2->isParameterPack()) {
1197 if (Context.Complain) {
1198 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1199 << D2->isParameterPack();
1200 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1201 << D1->isParameterPack();
1209 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1210 NonTypeTemplateParmDecl *D1,
1211 NonTypeTemplateParmDecl *D2) {
1212 if (D1->isParameterPack() != D2->isParameterPack()) {
1213 if (Context.Complain) {
1214 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1215 << D2->isParameterPack();
1216 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1217 << D1->isParameterPack();
1223 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1224 if (Context.Complain) {
1225 Context.Diag2(D2->getLocation(),
1226 diag::err_odr_non_type_parameter_type_inconsistent)
1227 << D2->getType() << D1->getType();
1228 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1237 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1238 TemplateTemplateParmDecl *D1,
1239 TemplateTemplateParmDecl *D2) {
1240 if (D1->isParameterPack() != D2->isParameterPack()) {
1241 if (Context.Complain) {
1242 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1243 << D2->isParameterPack();
1244 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1245 << D1->isParameterPack();
1250 // Check template parameter lists.
1251 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1252 D2->getTemplateParameters());
1255 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1256 ClassTemplateDecl *D1,
1257 ClassTemplateDecl *D2) {
1258 // Check template parameters.
1259 if (!IsStructurallyEquivalent(Context,
1260 D1->getTemplateParameters(),
1261 D2->getTemplateParameters()))
1264 // Check the templated declaration.
1265 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1266 D2->getTemplatedDecl());
1269 /// \brief Determine structural equivalence of two declarations.
1270 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1271 Decl *D1, Decl *D2) {
1272 // FIXME: Check for known structural equivalences via a callback of some sort.
1274 // Check whether we already know that these two declarations are not
1275 // structurally equivalent.
1276 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1277 D2->getCanonicalDecl())))
1280 // Determine whether we've already produced a tentative equivalence for D1.
1281 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1283 return EquivToD1 == D2->getCanonicalDecl();
1285 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1286 EquivToD1 = D2->getCanonicalDecl();
1287 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1291 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1293 if (!::IsStructurallyEquivalent(*this, D1, D2))
1299 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1301 if (!::IsStructurallyEquivalent(*this, T1, T2))
1307 bool StructuralEquivalenceContext::Finish() {
1308 while (!DeclsToCheck.empty()) {
1309 // Check the next declaration.
1310 Decl *D1 = DeclsToCheck.front();
1311 DeclsToCheck.pop_front();
1313 Decl *D2 = TentativeEquivalences[D1];
1314 assert(D2 && "Unrecorded tentative equivalence?");
1316 bool Equivalent = true;
1318 // FIXME: Switch on all declaration kinds. For now, we're just going to
1319 // check the obvious ones.
1320 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1321 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1322 // Check for equivalent structure names.
1323 IdentifierInfo *Name1 = Record1->getIdentifier();
1324 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1325 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1326 IdentifierInfo *Name2 = Record2->getIdentifier();
1327 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1328 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1329 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1330 !::IsStructurallyEquivalent(*this, Record1, Record2))
1333 // Record/non-record mismatch.
1336 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1337 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1338 // Check for equivalent enum names.
1339 IdentifierInfo *Name1 = Enum1->getIdentifier();
1340 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1341 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1342 IdentifierInfo *Name2 = Enum2->getIdentifier();
1343 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1344 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1345 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1346 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1349 // Enum/non-enum mismatch
1352 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1353 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1354 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1355 Typedef2->getIdentifier()) ||
1356 !::IsStructurallyEquivalent(*this,
1357 Typedef1->getUnderlyingType(),
1358 Typedef2->getUnderlyingType()))
1361 // Typedef/non-typedef mismatch.
1364 } else if (ClassTemplateDecl *ClassTemplate1
1365 = dyn_cast<ClassTemplateDecl>(D1)) {
1366 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1367 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1368 ClassTemplate2->getIdentifier()) ||
1369 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1372 // Class template/non-class-template mismatch.
1375 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1376 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1377 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1383 } else if (NonTypeTemplateParmDecl *NTTP1
1384 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1385 if (NonTypeTemplateParmDecl *NTTP2
1386 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1387 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1393 } else if (TemplateTemplateParmDecl *TTP1
1394 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1395 if (TemplateTemplateParmDecl *TTP2
1396 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1397 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1406 // Note that these two declarations are not equivalent (and we already
1408 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1409 D2->getCanonicalDecl()));
1412 // FIXME: Check other declaration kinds!
1418 //----------------------------------------------------------------------------
1420 //----------------------------------------------------------------------------
1422 QualType ASTNodeImporter::VisitType(const Type *T) {
1423 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1424 << T->getTypeClassName();
1428 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1429 switch (T->getKind()) {
1430 #define SHARED_SINGLETON_TYPE(Expansion)
1431 #define BUILTIN_TYPE(Id, SingletonId) \
1432 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1433 #include "clang/AST/BuiltinTypes.def"
1435 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1436 // context supports C++.
1438 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1439 // context supports ObjC.
1441 case BuiltinType::Char_U:
1442 // The context we're importing from has an unsigned 'char'. If we're
1443 // importing into a context with a signed 'char', translate to
1444 // 'unsigned char' instead.
1445 if (Importer.getToContext().getLangOpts().CharIsSigned)
1446 return Importer.getToContext().UnsignedCharTy;
1448 return Importer.getToContext().CharTy;
1450 case BuiltinType::Char_S:
1451 // The context we're importing from has an unsigned 'char'. If we're
1452 // importing into a context with a signed 'char', translate to
1453 // 'unsigned char' instead.
1454 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1455 return Importer.getToContext().SignedCharTy;
1457 return Importer.getToContext().CharTy;
1459 case BuiltinType::WChar_S:
1460 case BuiltinType::WChar_U:
1461 // FIXME: If not in C++, shall we translate to the C equivalent of
1463 return Importer.getToContext().WCharTy;
1466 llvm_unreachable("Invalid BuiltinType Kind!");
1469 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1470 QualType ToElementType = Importer.Import(T->getElementType());
1471 if (ToElementType.isNull())
1474 return Importer.getToContext().getComplexType(ToElementType);
1477 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1478 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1479 if (ToPointeeType.isNull())
1482 return Importer.getToContext().getPointerType(ToPointeeType);
1485 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1486 // FIXME: Check for blocks support in "to" context.
1487 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1488 if (ToPointeeType.isNull())
1491 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1495 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1496 // FIXME: Check for C++ support in "to" context.
1497 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1498 if (ToPointeeType.isNull())
1501 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1505 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1506 // FIXME: Check for C++0x support in "to" context.
1507 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1508 if (ToPointeeType.isNull())
1511 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1514 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1515 // FIXME: Check for C++ support in "to" context.
1516 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1517 if (ToPointeeType.isNull())
1520 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1521 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1522 ClassType.getTypePtr());
1525 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1526 QualType ToElementType = Importer.Import(T->getElementType());
1527 if (ToElementType.isNull())
1530 return Importer.getToContext().getConstantArrayType(ToElementType,
1532 T->getSizeModifier(),
1533 T->getIndexTypeCVRQualifiers());
1537 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1538 QualType ToElementType = Importer.Import(T->getElementType());
1539 if (ToElementType.isNull())
1542 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1543 T->getSizeModifier(),
1544 T->getIndexTypeCVRQualifiers());
1547 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1548 QualType ToElementType = Importer.Import(T->getElementType());
1549 if (ToElementType.isNull())
1552 Expr *Size = Importer.Import(T->getSizeExpr());
1556 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1557 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1558 T->getSizeModifier(),
1559 T->getIndexTypeCVRQualifiers(),
1563 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1564 QualType ToElementType = Importer.Import(T->getElementType());
1565 if (ToElementType.isNull())
1568 return Importer.getToContext().getVectorType(ToElementType,
1569 T->getNumElements(),
1570 T->getVectorKind());
1573 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1574 QualType ToElementType = Importer.Import(T->getElementType());
1575 if (ToElementType.isNull())
1578 return Importer.getToContext().getExtVectorType(ToElementType,
1579 T->getNumElements());
1583 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1584 // FIXME: What happens if we're importing a function without a prototype
1585 // into C++? Should we make it variadic?
1586 QualType ToResultType = Importer.Import(T->getReturnType());
1587 if (ToResultType.isNull())
1590 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1594 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1595 QualType ToResultType = Importer.Import(T->getReturnType());
1596 if (ToResultType.isNull())
1599 // Import argument types
1600 SmallVector<QualType, 4> ArgTypes;
1601 for (FunctionProtoType::param_type_iterator A = T->param_type_begin(),
1602 AEnd = T->param_type_end();
1604 QualType ArgType = Importer.Import(*A);
1605 if (ArgType.isNull())
1607 ArgTypes.push_back(ArgType);
1610 // Import exception types
1611 SmallVector<QualType, 4> ExceptionTypes;
1612 for (FunctionProtoType::exception_iterator E = T->exception_begin(),
1613 EEnd = T->exception_end();
1615 QualType ExceptionType = Importer.Import(*E);
1616 if (ExceptionType.isNull())
1618 ExceptionTypes.push_back(ExceptionType);
1621 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1622 FunctionProtoType::ExtProtoInfo ToEPI;
1624 ToEPI.ExtInfo = FromEPI.ExtInfo;
1625 ToEPI.Variadic = FromEPI.Variadic;
1626 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1627 ToEPI.TypeQuals = FromEPI.TypeQuals;
1628 ToEPI.RefQualifier = FromEPI.RefQualifier;
1629 ToEPI.NumExceptions = ExceptionTypes.size();
1630 ToEPI.Exceptions = ExceptionTypes.data();
1631 ToEPI.ConsumedParameters = FromEPI.ConsumedParameters;
1632 ToEPI.ExceptionSpecType = FromEPI.ExceptionSpecType;
1633 ToEPI.NoexceptExpr = Importer.Import(FromEPI.NoexceptExpr);
1634 ToEPI.ExceptionSpecDecl = cast_or_null<FunctionDecl>(
1635 Importer.Import(FromEPI.ExceptionSpecDecl));
1636 ToEPI.ExceptionSpecTemplate = cast_or_null<FunctionDecl>(
1637 Importer.Import(FromEPI.ExceptionSpecTemplate));
1639 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1642 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1643 QualType ToInnerType = Importer.Import(T->getInnerType());
1644 if (ToInnerType.isNull())
1647 return Importer.getToContext().getParenType(ToInnerType);
1650 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1651 TypedefNameDecl *ToDecl
1652 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1656 return Importer.getToContext().getTypeDeclType(ToDecl);
1659 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1660 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1664 return Importer.getToContext().getTypeOfExprType(ToExpr);
1667 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1668 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1669 if (ToUnderlyingType.isNull())
1672 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1675 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1676 // FIXME: Make sure that the "to" context supports C++0x!
1677 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1681 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1682 if (UnderlyingType.isNull())
1685 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1688 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1689 QualType ToBaseType = Importer.Import(T->getBaseType());
1690 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1691 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1694 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1699 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1700 // FIXME: Make sure that the "to" context supports C++11!
1701 QualType FromDeduced = T->getDeducedType();
1703 if (!FromDeduced.isNull()) {
1704 ToDeduced = Importer.Import(FromDeduced);
1705 if (ToDeduced.isNull())
1709 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto(),
1710 /*IsDependent*/false);
1713 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1715 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1719 return Importer.getToContext().getTagDeclType(ToDecl);
1722 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1724 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1728 return Importer.getToContext().getTagDeclType(ToDecl);
1731 QualType ASTNodeImporter::VisitTemplateSpecializationType(
1732 const TemplateSpecializationType *T) {
1733 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1734 if (ToTemplate.isNull())
1737 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1738 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1741 QualType ToCanonType;
1742 if (!QualType(T, 0).isCanonical()) {
1743 QualType FromCanonType
1744 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1745 ToCanonType =Importer.Import(FromCanonType);
1746 if (ToCanonType.isNull())
1749 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1750 ToTemplateArgs.data(),
1751 ToTemplateArgs.size(),
1755 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1756 NestedNameSpecifier *ToQualifier = 0;
1757 // Note: the qualifier in an ElaboratedType is optional.
1758 if (T->getQualifier()) {
1759 ToQualifier = Importer.Import(T->getQualifier());
1764 QualType ToNamedType = Importer.Import(T->getNamedType());
1765 if (ToNamedType.isNull())
1768 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1769 ToQualifier, ToNamedType);
1772 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1773 ObjCInterfaceDecl *Class
1774 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1778 return Importer.getToContext().getObjCInterfaceType(Class);
1781 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1782 QualType ToBaseType = Importer.Import(T->getBaseType());
1783 if (ToBaseType.isNull())
1786 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1787 for (ObjCObjectType::qual_iterator P = T->qual_begin(),
1788 PEnd = T->qual_end();
1790 ObjCProtocolDecl *Protocol
1791 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(*P));
1794 Protocols.push_back(Protocol);
1797 return Importer.getToContext().getObjCObjectType(ToBaseType,
1803 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1804 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1805 if (ToPointeeType.isNull())
1808 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1811 //----------------------------------------------------------------------------
1812 // Import Declarations
1813 //----------------------------------------------------------------------------
1814 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1815 DeclContext *&LexicalDC,
1816 DeclarationName &Name,
1817 SourceLocation &Loc) {
1818 // Import the context of this declaration.
1819 DC = Importer.ImportContext(D->getDeclContext());
1824 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1825 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1830 // Import the name of this declaration.
1831 Name = Importer.Import(D->getDeclName());
1832 if (D->getDeclName() && !Name)
1835 // Import the location of this declaration.
1836 Loc = Importer.Import(D->getLocation());
1840 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1845 ToD = Importer.Import(FromD);
1850 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1851 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1852 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1853 ImportDefinition(FromRecord, ToRecord);
1859 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1860 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1861 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1862 ImportDefinition(FromEnum, ToEnum);
1870 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1871 DeclarationNameInfo& To) {
1872 // NOTE: To.Name and To.Loc are already imported.
1873 // We only have to import To.LocInfo.
1874 switch (To.getName().getNameKind()) {
1875 case DeclarationName::Identifier:
1876 case DeclarationName::ObjCZeroArgSelector:
1877 case DeclarationName::ObjCOneArgSelector:
1878 case DeclarationName::ObjCMultiArgSelector:
1879 case DeclarationName::CXXUsingDirective:
1882 case DeclarationName::CXXOperatorName: {
1883 SourceRange Range = From.getCXXOperatorNameRange();
1884 To.setCXXOperatorNameRange(Importer.Import(Range));
1887 case DeclarationName::CXXLiteralOperatorName: {
1888 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1889 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1892 case DeclarationName::CXXConstructorName:
1893 case DeclarationName::CXXDestructorName:
1894 case DeclarationName::CXXConversionFunctionName: {
1895 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1896 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1900 llvm_unreachable("Unknown name kind.");
1903 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1904 if (Importer.isMinimalImport() && !ForceImport) {
1905 Importer.ImportContext(FromDC);
1909 for (auto *From : FromDC->decls())
1910 Importer.Import(From);
1913 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1914 ImportDefinitionKind Kind) {
1915 if (To->getDefinition() || To->isBeingDefined()) {
1916 if (Kind == IDK_Everything)
1917 ImportDeclContext(From, /*ForceImport=*/true);
1922 To->startDefinition();
1924 // Add base classes.
1925 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1926 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
1928 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1929 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1930 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1931 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1932 ToData.Aggregate = FromData.Aggregate;
1933 ToData.PlainOldData = FromData.PlainOldData;
1934 ToData.Empty = FromData.Empty;
1935 ToData.Polymorphic = FromData.Polymorphic;
1936 ToData.Abstract = FromData.Abstract;
1937 ToData.IsStandardLayout = FromData.IsStandardLayout;
1938 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
1939 ToData.HasPrivateFields = FromData.HasPrivateFields;
1940 ToData.HasProtectedFields = FromData.HasProtectedFields;
1941 ToData.HasPublicFields = FromData.HasPublicFields;
1942 ToData.HasMutableFields = FromData.HasMutableFields;
1943 ToData.HasVariantMembers = FromData.HasVariantMembers;
1944 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1945 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1946 ToData.HasUninitializedReferenceMember
1947 = FromData.HasUninitializedReferenceMember;
1948 ToData.NeedOverloadResolutionForMoveConstructor
1949 = FromData.NeedOverloadResolutionForMoveConstructor;
1950 ToData.NeedOverloadResolutionForMoveAssignment
1951 = FromData.NeedOverloadResolutionForMoveAssignment;
1952 ToData.NeedOverloadResolutionForDestructor
1953 = FromData.NeedOverloadResolutionForDestructor;
1954 ToData.DefaultedMoveConstructorIsDeleted
1955 = FromData.DefaultedMoveConstructorIsDeleted;
1956 ToData.DefaultedMoveAssignmentIsDeleted
1957 = FromData.DefaultedMoveAssignmentIsDeleted;
1958 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1959 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1960 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1961 ToData.HasConstexprNonCopyMoveConstructor
1962 = FromData.HasConstexprNonCopyMoveConstructor;
1963 ToData.DefaultedDefaultConstructorIsConstexpr
1964 = FromData.DefaultedDefaultConstructorIsConstexpr;
1965 ToData.HasConstexprDefaultConstructor
1966 = FromData.HasConstexprDefaultConstructor;
1967 ToData.HasNonLiteralTypeFieldsOrBases
1968 = FromData.HasNonLiteralTypeFieldsOrBases;
1969 // ComputedVisibleConversions not imported.
1970 ToData.UserProvidedDefaultConstructor
1971 = FromData.UserProvidedDefaultConstructor;
1972 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1973 ToData.ImplicitCopyConstructorHasConstParam
1974 = FromData.ImplicitCopyConstructorHasConstParam;
1975 ToData.ImplicitCopyAssignmentHasConstParam
1976 = FromData.ImplicitCopyAssignmentHasConstParam;
1977 ToData.HasDeclaredCopyConstructorWithConstParam
1978 = FromData.HasDeclaredCopyConstructorWithConstParam;
1979 ToData.HasDeclaredCopyAssignmentWithConstParam
1980 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1981 ToData.IsLambda = FromData.IsLambda;
1983 SmallVector<CXXBaseSpecifier *, 4> Bases;
1984 for (CXXRecordDecl::base_class_iterator
1985 Base1 = FromCXX->bases_begin(),
1986 FromBaseEnd = FromCXX->bases_end();
1987 Base1 != FromBaseEnd;
1989 QualType T = Importer.Import(Base1->getType());
1993 SourceLocation EllipsisLoc;
1994 if (Base1->isPackExpansion())
1995 EllipsisLoc = Importer.Import(Base1->getEllipsisLoc());
1997 // Ensure that we have a definition for the base.
1998 ImportDefinitionIfNeeded(Base1->getType()->getAsCXXRecordDecl());
2001 new (Importer.getToContext())
2002 CXXBaseSpecifier(Importer.Import(Base1->getSourceRange()),
2004 Base1->isBaseOfClass(),
2005 Base1->getAccessSpecifierAsWritten(),
2006 Importer.Import(Base1->getTypeSourceInfo()),
2010 ToCXX->setBases(Bases.data(), Bases.size());
2013 if (shouldForceImportDeclContext(Kind))
2014 ImportDeclContext(From, /*ForceImport=*/true);
2016 To->completeDefinition();
2020 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2021 ImportDefinitionKind Kind) {
2022 if (To->getDefinition())
2025 // FIXME: Can we really import any initializer? Alternatively, we could force
2026 // ourselves to import every declaration of a variable and then only use
2028 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2030 // FIXME: Other bits to merge?
2035 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2036 ImportDefinitionKind Kind) {
2037 if (To->getDefinition() || To->isBeingDefined()) {
2038 if (Kind == IDK_Everything)
2039 ImportDeclContext(From, /*ForceImport=*/true);
2043 To->startDefinition();
2045 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2049 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2050 if (ToPromotionType.isNull())
2053 if (shouldForceImportDeclContext(Kind))
2054 ImportDeclContext(From, /*ForceImport=*/true);
2056 // FIXME: we might need to merge the number of positive or negative bits
2057 // if the enumerator lists don't match.
2058 To->completeDefinition(T, ToPromotionType,
2059 From->getNumPositiveBits(),
2060 From->getNumNegativeBits());
2064 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2065 TemplateParameterList *Params) {
2066 SmallVector<NamedDecl *, 4> ToParams;
2067 ToParams.reserve(Params->size());
2068 for (TemplateParameterList::iterator P = Params->begin(),
2069 PEnd = Params->end();
2071 Decl *To = Importer.Import(*P);
2075 ToParams.push_back(cast<NamedDecl>(To));
2078 return TemplateParameterList::Create(Importer.getToContext(),
2079 Importer.Import(Params->getTemplateLoc()),
2080 Importer.Import(Params->getLAngleLoc()),
2081 ToParams.data(), ToParams.size(),
2082 Importer.Import(Params->getRAngleLoc()));
2086 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2087 switch (From.getKind()) {
2088 case TemplateArgument::Null:
2089 return TemplateArgument();
2091 case TemplateArgument::Type: {
2092 QualType ToType = Importer.Import(From.getAsType());
2093 if (ToType.isNull())
2094 return TemplateArgument();
2095 return TemplateArgument(ToType);
2098 case TemplateArgument::Integral: {
2099 QualType ToType = Importer.Import(From.getIntegralType());
2100 if (ToType.isNull())
2101 return TemplateArgument();
2102 return TemplateArgument(From, ToType);
2105 case TemplateArgument::Declaration: {
2106 ValueDecl *FromD = From.getAsDecl();
2107 if (ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(FromD)))
2108 return TemplateArgument(To, From.isDeclForReferenceParam());
2109 return TemplateArgument();
2112 case TemplateArgument::NullPtr: {
2113 QualType ToType = Importer.Import(From.getNullPtrType());
2114 if (ToType.isNull())
2115 return TemplateArgument();
2116 return TemplateArgument(ToType, /*isNullPtr*/true);
2119 case TemplateArgument::Template: {
2120 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2121 if (ToTemplate.isNull())
2122 return TemplateArgument();
2124 return TemplateArgument(ToTemplate);
2127 case TemplateArgument::TemplateExpansion: {
2128 TemplateName ToTemplate
2129 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2130 if (ToTemplate.isNull())
2131 return TemplateArgument();
2133 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2136 case TemplateArgument::Expression:
2137 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2138 return TemplateArgument(ToExpr);
2139 return TemplateArgument();
2141 case TemplateArgument::Pack: {
2142 SmallVector<TemplateArgument, 2> ToPack;
2143 ToPack.reserve(From.pack_size());
2144 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2145 return TemplateArgument();
2147 TemplateArgument *ToArgs
2148 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2149 std::copy(ToPack.begin(), ToPack.end(), ToArgs);
2150 return TemplateArgument(ToArgs, ToPack.size());
2154 llvm_unreachable("Invalid template argument kind");
2157 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2158 unsigned NumFromArgs,
2159 SmallVectorImpl<TemplateArgument> &ToArgs) {
2160 for (unsigned I = 0; I != NumFromArgs; ++I) {
2161 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2162 if (To.isNull() && !FromArgs[I].isNull())
2165 ToArgs.push_back(To);
2171 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2172 RecordDecl *ToRecord, bool Complain) {
2173 // Eliminate a potential failure point where we attempt to re-import
2174 // something we're trying to import while completing ToRecord.
2175 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2177 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2179 ToRecord = ToOriginRecord;
2182 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2183 ToRecord->getASTContext(),
2184 Importer.getNonEquivalentDecls(),
2186 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2189 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2191 StructuralEquivalenceContext Ctx(
2192 Importer.getFromContext(), Importer.getToContext(),
2193 Importer.getNonEquivalentDecls(), false, Complain);
2194 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2197 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2198 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2199 Importer.getToContext(),
2200 Importer.getNonEquivalentDecls());
2201 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2204 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2205 EnumConstantDecl *ToEC)
2207 const llvm::APSInt &FromVal = FromEC->getInitVal();
2208 const llvm::APSInt &ToVal = ToEC->getInitVal();
2210 return FromVal.isSigned() == ToVal.isSigned() &&
2211 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2215 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2216 ClassTemplateDecl *To) {
2217 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2218 Importer.getToContext(),
2219 Importer.getNonEquivalentDecls());
2220 return Ctx.IsStructurallyEquivalent(From, To);
2223 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2224 VarTemplateDecl *To) {
2225 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2226 Importer.getToContext(),
2227 Importer.getNonEquivalentDecls());
2228 return Ctx.IsStructurallyEquivalent(From, To);
2231 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2232 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2233 << D->getDeclKindName();
2237 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2238 TranslationUnitDecl *ToD =
2239 Importer.getToContext().getTranslationUnitDecl();
2241 Importer.Imported(D, ToD);
2246 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2247 // Import the major distinguishing characteristics of this namespace.
2248 DeclContext *DC, *LexicalDC;
2249 DeclarationName Name;
2251 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2254 NamespaceDecl *MergeWithNamespace = 0;
2256 // This is an anonymous namespace. Adopt an existing anonymous
2257 // namespace if we can.
2258 // FIXME: Not testable.
2259 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2260 MergeWithNamespace = TU->getAnonymousNamespace();
2262 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2264 SmallVector<NamedDecl *, 4> ConflictingDecls;
2265 SmallVector<NamedDecl *, 2> FoundDecls;
2266 DC->localUncachedLookup(Name, FoundDecls);
2267 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2268 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2271 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2272 MergeWithNamespace = FoundNS;
2273 ConflictingDecls.clear();
2277 ConflictingDecls.push_back(FoundDecls[I]);
2280 if (!ConflictingDecls.empty()) {
2281 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2282 ConflictingDecls.data(),
2283 ConflictingDecls.size());
2287 // Create the "to" namespace, if needed.
2288 NamespaceDecl *ToNamespace = MergeWithNamespace;
2290 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2292 Importer.Import(D->getLocStart()),
2293 Loc, Name.getAsIdentifierInfo(),
2295 ToNamespace->setLexicalDeclContext(LexicalDC);
2296 LexicalDC->addDeclInternal(ToNamespace);
2298 // If this is an anonymous namespace, register it as the anonymous
2299 // namespace within its context.
2301 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2302 TU->setAnonymousNamespace(ToNamespace);
2304 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2307 Importer.Imported(D, ToNamespace);
2309 ImportDeclContext(D);
2314 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2315 // Import the major distinguishing characteristics of this typedef.
2316 DeclContext *DC, *LexicalDC;
2317 DeclarationName Name;
2319 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2322 // If this typedef is not in block scope, determine whether we've
2323 // seen a typedef with the same name (that we can merge with) or any
2324 // other entity by that name (which name lookup could conflict with).
2325 if (!DC->isFunctionOrMethod()) {
2326 SmallVector<NamedDecl *, 4> ConflictingDecls;
2327 unsigned IDNS = Decl::IDNS_Ordinary;
2328 SmallVector<NamedDecl *, 2> FoundDecls;
2329 DC->localUncachedLookup(Name, FoundDecls);
2330 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2331 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2333 if (TypedefNameDecl *FoundTypedef =
2334 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2335 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2336 FoundTypedef->getUnderlyingType()))
2337 return Importer.Imported(D, FoundTypedef);
2340 ConflictingDecls.push_back(FoundDecls[I]);
2343 if (!ConflictingDecls.empty()) {
2344 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2345 ConflictingDecls.data(),
2346 ConflictingDecls.size());
2352 // Import the underlying type of this typedef;
2353 QualType T = Importer.Import(D->getUnderlyingType());
2357 // Create the new typedef node.
2358 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2359 SourceLocation StartL = Importer.Import(D->getLocStart());
2360 TypedefNameDecl *ToTypedef;
2362 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2364 Name.getAsIdentifierInfo(),
2367 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2369 Name.getAsIdentifierInfo(),
2372 ToTypedef->setAccess(D->getAccess());
2373 ToTypedef->setLexicalDeclContext(LexicalDC);
2374 Importer.Imported(D, ToTypedef);
2375 LexicalDC->addDeclInternal(ToTypedef);
2380 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2381 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2384 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2385 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2388 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2389 // Import the major distinguishing characteristics of this enum.
2390 DeclContext *DC, *LexicalDC;
2391 DeclarationName Name;
2393 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2396 // Figure out what enum name we're looking for.
2397 unsigned IDNS = Decl::IDNS_Tag;
2398 DeclarationName SearchName = Name;
2399 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2400 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2401 IDNS = Decl::IDNS_Ordinary;
2402 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2403 IDNS |= Decl::IDNS_Ordinary;
2405 // We may already have an enum of the same name; try to find and match it.
2406 if (!DC->isFunctionOrMethod() && SearchName) {
2407 SmallVector<NamedDecl *, 4> ConflictingDecls;
2408 SmallVector<NamedDecl *, 2> FoundDecls;
2409 DC->localUncachedLookup(SearchName, FoundDecls);
2410 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2411 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2414 Decl *Found = FoundDecls[I];
2415 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2416 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2417 Found = Tag->getDecl();
2420 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2421 if (IsStructuralMatch(D, FoundEnum))
2422 return Importer.Imported(D, FoundEnum);
2425 ConflictingDecls.push_back(FoundDecls[I]);
2428 if (!ConflictingDecls.empty()) {
2429 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2430 ConflictingDecls.data(),
2431 ConflictingDecls.size());
2435 // Create the enum declaration.
2436 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2437 Importer.Import(D->getLocStart()),
2438 Loc, Name.getAsIdentifierInfo(), 0,
2439 D->isScoped(), D->isScopedUsingClassTag(),
2441 // Import the qualifier, if any.
2442 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2443 D2->setAccess(D->getAccess());
2444 D2->setLexicalDeclContext(LexicalDC);
2445 Importer.Imported(D, D2);
2446 LexicalDC->addDeclInternal(D2);
2448 // Import the integer type.
2449 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2450 if (ToIntegerType.isNull())
2452 D2->setIntegerType(ToIntegerType);
2454 // Import the definition
2455 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2461 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2462 // If this record has a definition in the translation unit we're coming from,
2463 // but this particular declaration is not that definition, import the
2464 // definition and map to that.
2465 TagDecl *Definition = D->getDefinition();
2466 if (Definition && Definition != D) {
2467 Decl *ImportedDef = Importer.Import(Definition);
2471 return Importer.Imported(D, ImportedDef);
2474 // Import the major distinguishing characteristics of this record.
2475 DeclContext *DC, *LexicalDC;
2476 DeclarationName Name;
2478 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2481 // Figure out what structure name we're looking for.
2482 unsigned IDNS = Decl::IDNS_Tag;
2483 DeclarationName SearchName = Name;
2484 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2485 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2486 IDNS = Decl::IDNS_Ordinary;
2487 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2488 IDNS |= Decl::IDNS_Ordinary;
2490 // We may already have a record of the same name; try to find and match it.
2491 RecordDecl *AdoptDecl = 0;
2492 if (!DC->isFunctionOrMethod()) {
2493 SmallVector<NamedDecl *, 4> ConflictingDecls;
2494 SmallVector<NamedDecl *, 2> FoundDecls;
2495 DC->localUncachedLookup(SearchName, FoundDecls);
2496 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2497 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2500 Decl *Found = FoundDecls[I];
2501 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2502 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2503 Found = Tag->getDecl();
2506 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2507 if (D->isAnonymousStructOrUnion() &&
2508 FoundRecord->isAnonymousStructOrUnion()) {
2509 // If both anonymous structs/unions are in a record context, make sure
2510 // they occur in the same location in the context records.
2511 if (Optional<unsigned> Index1
2512 = findAnonymousStructOrUnionIndex(D)) {
2513 if (Optional<unsigned> Index2 =
2514 findAnonymousStructOrUnionIndex(FoundRecord)) {
2515 if (*Index1 != *Index2)
2521 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2522 if ((SearchName && !D->isCompleteDefinition())
2523 || (D->isCompleteDefinition() &&
2524 D->isAnonymousStructOrUnion()
2525 == FoundDef->isAnonymousStructOrUnion() &&
2526 IsStructuralMatch(D, FoundDef))) {
2527 // The record types structurally match, or the "from" translation
2528 // unit only had a forward declaration anyway; call it the same
2530 // FIXME: For C++, we should also merge methods here.
2531 return Importer.Imported(D, FoundDef);
2533 } else if (!D->isCompleteDefinition()) {
2534 // We have a forward declaration of this type, so adopt that forward
2535 // declaration rather than building a new one.
2537 // If one or both can be completed from external storage then try one
2538 // last time to complete and compare them before doing this.
2540 if (FoundRecord->hasExternalLexicalStorage() &&
2541 !FoundRecord->isCompleteDefinition())
2542 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2543 if (D->hasExternalLexicalStorage())
2544 D->getASTContext().getExternalSource()->CompleteType(D);
2546 if (FoundRecord->isCompleteDefinition() &&
2547 D->isCompleteDefinition() &&
2548 !IsStructuralMatch(D, FoundRecord))
2551 AdoptDecl = FoundRecord;
2553 } else if (!SearchName) {
2558 ConflictingDecls.push_back(FoundDecls[I]);
2561 if (!ConflictingDecls.empty() && SearchName) {
2562 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2563 ConflictingDecls.data(),
2564 ConflictingDecls.size());
2568 // Create the record declaration.
2569 RecordDecl *D2 = AdoptDecl;
2570 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2572 if (isa<CXXRecordDecl>(D)) {
2573 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2576 Name.getAsIdentifierInfo());
2578 D2->setAccess(D->getAccess());
2580 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2581 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2584 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2585 D2->setLexicalDeclContext(LexicalDC);
2586 LexicalDC->addDeclInternal(D2);
2587 if (D->isAnonymousStructOrUnion())
2588 D2->setAnonymousStructOrUnion(true);
2591 Importer.Imported(D, D2);
2593 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2599 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2600 // Import the major distinguishing characteristics of this enumerator.
2601 DeclContext *DC, *LexicalDC;
2602 DeclarationName Name;
2604 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2607 QualType T = Importer.Import(D->getType());
2611 // Determine whether there are any other declarations with the same name and
2612 // in the same context.
2613 if (!LexicalDC->isFunctionOrMethod()) {
2614 SmallVector<NamedDecl *, 4> ConflictingDecls;
2615 unsigned IDNS = Decl::IDNS_Ordinary;
2616 SmallVector<NamedDecl *, 2> FoundDecls;
2617 DC->localUncachedLookup(Name, FoundDecls);
2618 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2619 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2622 if (EnumConstantDecl *FoundEnumConstant
2623 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2624 if (IsStructuralMatch(D, FoundEnumConstant))
2625 return Importer.Imported(D, FoundEnumConstant);
2628 ConflictingDecls.push_back(FoundDecls[I]);
2631 if (!ConflictingDecls.empty()) {
2632 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2633 ConflictingDecls.data(),
2634 ConflictingDecls.size());
2640 Expr *Init = Importer.Import(D->getInitExpr());
2641 if (D->getInitExpr() && !Init)
2644 EnumConstantDecl *ToEnumerator
2645 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2646 Name.getAsIdentifierInfo(), T,
2647 Init, D->getInitVal());
2648 ToEnumerator->setAccess(D->getAccess());
2649 ToEnumerator->setLexicalDeclContext(LexicalDC);
2650 Importer.Imported(D, ToEnumerator);
2651 LexicalDC->addDeclInternal(ToEnumerator);
2652 return ToEnumerator;
2655 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2656 // Import the major distinguishing characteristics of this function.
2657 DeclContext *DC, *LexicalDC;
2658 DeclarationName Name;
2660 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2663 // Try to find a function in our own ("to") context with the same name, same
2664 // type, and in the same context as the function we're importing.
2665 if (!LexicalDC->isFunctionOrMethod()) {
2666 SmallVector<NamedDecl *, 4> ConflictingDecls;
2667 unsigned IDNS = Decl::IDNS_Ordinary;
2668 SmallVector<NamedDecl *, 2> FoundDecls;
2669 DC->localUncachedLookup(Name, FoundDecls);
2670 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2671 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2674 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2675 if (FoundFunction->hasExternalFormalLinkage() &&
2676 D->hasExternalFormalLinkage()) {
2677 if (Importer.IsStructurallyEquivalent(D->getType(),
2678 FoundFunction->getType())) {
2679 // FIXME: Actually try to merge the body and other attributes.
2680 return Importer.Imported(D, FoundFunction);
2683 // FIXME: Check for overloading more carefully, e.g., by boosting
2684 // Sema::IsOverload out to the AST library.
2686 // Function overloading is okay in C++.
2687 if (Importer.getToContext().getLangOpts().CPlusPlus)
2690 // Complain about inconsistent function types.
2691 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2692 << Name << D->getType() << FoundFunction->getType();
2693 Importer.ToDiag(FoundFunction->getLocation(),
2694 diag::note_odr_value_here)
2695 << FoundFunction->getType();
2699 ConflictingDecls.push_back(FoundDecls[I]);
2702 if (!ConflictingDecls.empty()) {
2703 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2704 ConflictingDecls.data(),
2705 ConflictingDecls.size());
2711 DeclarationNameInfo NameInfo(Name, Loc);
2712 // Import additional name location/type info.
2713 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2715 QualType FromTy = D->getType();
2716 bool usedDifferentExceptionSpec = false;
2718 if (const FunctionProtoType *
2719 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2720 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2721 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2722 // FunctionDecl that we are importing the FunctionProtoType for.
2723 // To avoid an infinite recursion when importing, create the FunctionDecl
2724 // with a simplified function type and update it afterwards.
2725 if (FromEPI.ExceptionSpecDecl || FromEPI.ExceptionSpecTemplate ||
2726 FromEPI.NoexceptExpr) {
2727 FunctionProtoType::ExtProtoInfo DefaultEPI;
2728 FromTy = Importer.getFromContext().getFunctionType(
2729 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2730 usedDifferentExceptionSpec = true;
2735 QualType T = Importer.Import(FromTy);
2739 // Import the function parameters.
2740 SmallVector<ParmVarDecl *, 8> Parameters;
2741 for (auto P : D->params()) {
2742 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2746 Parameters.push_back(ToP);
2749 // Create the imported function.
2750 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2751 FunctionDecl *ToFunction = 0;
2752 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2753 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2754 cast<CXXRecordDecl>(DC),
2755 D->getInnerLocStart(),
2757 FromConstructor->isExplicit(),
2758 D->isInlineSpecified(),
2761 } else if (isa<CXXDestructorDecl>(D)) {
2762 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2763 cast<CXXRecordDecl>(DC),
2764 D->getInnerLocStart(),
2766 D->isInlineSpecified(),
2768 } else if (CXXConversionDecl *FromConversion
2769 = dyn_cast<CXXConversionDecl>(D)) {
2770 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2771 cast<CXXRecordDecl>(DC),
2772 D->getInnerLocStart(),
2774 D->isInlineSpecified(),
2775 FromConversion->isExplicit(),
2777 Importer.Import(D->getLocEnd()));
2778 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2779 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2780 cast<CXXRecordDecl>(DC),
2781 D->getInnerLocStart(),
2783 Method->getStorageClass(),
2784 Method->isInlineSpecified(),
2786 Importer.Import(D->getLocEnd()));
2788 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2789 D->getInnerLocStart(),
2790 NameInfo, T, TInfo, D->getStorageClass(),
2791 D->isInlineSpecified(),
2792 D->hasWrittenPrototype(),
2796 // Import the qualifier, if any.
2797 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2798 ToFunction->setAccess(D->getAccess());
2799 ToFunction->setLexicalDeclContext(LexicalDC);
2800 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2801 ToFunction->setTrivial(D->isTrivial());
2802 ToFunction->setPure(D->isPure());
2803 Importer.Imported(D, ToFunction);
2805 // Set the parameters.
2806 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2807 Parameters[I]->setOwningFunction(ToFunction);
2808 ToFunction->addDeclInternal(Parameters[I]);
2810 ToFunction->setParams(Parameters);
2812 if (usedDifferentExceptionSpec) {
2813 // Update FunctionProtoType::ExtProtoInfo.
2814 QualType T = Importer.Import(D->getType());
2817 ToFunction->setType(T);
2820 // FIXME: Other bits to merge?
2822 // Add this function to the lexical context.
2823 LexicalDC->addDeclInternal(ToFunction);
2828 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2829 return VisitFunctionDecl(D);
2832 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2833 return VisitCXXMethodDecl(D);
2836 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2837 return VisitCXXMethodDecl(D);
2840 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2841 return VisitCXXMethodDecl(D);
2844 static unsigned getFieldIndex(Decl *F) {
2845 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2850 for (const auto *D : Owner->noload_decls()) {
2854 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2861 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *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 (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2874 // For anonymous fields, match up by index.
2875 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2878 if (Importer.IsStructurallyEquivalent(D->getType(),
2879 FoundField->getType())) {
2880 Importer.Imported(D, FoundField);
2884 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2885 << Name << D->getType() << FoundField->getType();
2886 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2887 << FoundField->getType();
2893 QualType T = Importer.Import(D->getType());
2897 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2898 Expr *BitWidth = Importer.Import(D->getBitWidth());
2899 if (!BitWidth && D->getBitWidth())
2902 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2903 Importer.Import(D->getInnerLocStart()),
2904 Loc, Name.getAsIdentifierInfo(),
2905 T, TInfo, BitWidth, D->isMutable(),
2906 D->getInClassInitStyle());
2907 ToField->setAccess(D->getAccess());
2908 ToField->setLexicalDeclContext(LexicalDC);
2909 if (ToField->hasInClassInitializer())
2910 ToField->setInClassInitializer(D->getInClassInitializer());
2911 ToField->setImplicit(D->isImplicit());
2912 Importer.Imported(D, ToField);
2913 LexicalDC->addDeclInternal(ToField);
2917 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2918 // Import the major distinguishing characteristics of a variable.
2919 DeclContext *DC, *LexicalDC;
2920 DeclarationName Name;
2922 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2925 // Determine whether we've already imported this field.
2926 SmallVector<NamedDecl *, 2> FoundDecls;
2927 DC->localUncachedLookup(Name, FoundDecls);
2928 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2929 if (IndirectFieldDecl *FoundField
2930 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2931 // For anonymous indirect fields, match up by index.
2932 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2935 if (Importer.IsStructurallyEquivalent(D->getType(),
2936 FoundField->getType(),
2938 Importer.Imported(D, FoundField);
2942 // If there are more anonymous fields to check, continue.
2943 if (!Name && I < N-1)
2946 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2947 << Name << D->getType() << FoundField->getType();
2948 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2949 << FoundField->getType();
2955 QualType T = Importer.Import(D->getType());
2959 NamedDecl **NamedChain =
2960 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2963 for (auto *PI : D->chain()) {
2964 Decl *D = Importer.Import(PI);
2967 NamedChain[i++] = cast<NamedDecl>(D);
2970 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
2971 Importer.getToContext(), DC,
2972 Loc, Name.getAsIdentifierInfo(), T,
2973 NamedChain, D->getChainingSize());
2974 ToIndirectField->setAccess(D->getAccess());
2975 ToIndirectField->setLexicalDeclContext(LexicalDC);
2976 Importer.Imported(D, ToIndirectField);
2977 LexicalDC->addDeclInternal(ToIndirectField);
2978 return ToIndirectField;
2981 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
2982 // Import the major distinguishing characteristics of an ivar.
2983 DeclContext *DC, *LexicalDC;
2984 DeclarationName Name;
2986 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
2989 // Determine whether we've already imported this ivar
2990 SmallVector<NamedDecl *, 2> FoundDecls;
2991 DC->localUncachedLookup(Name, FoundDecls);
2992 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2993 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
2994 if (Importer.IsStructurallyEquivalent(D->getType(),
2995 FoundIvar->getType())) {
2996 Importer.Imported(D, FoundIvar);
3000 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3001 << Name << D->getType() << FoundIvar->getType();
3002 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3003 << FoundIvar->getType();
3009 QualType T = Importer.Import(D->getType());
3013 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3014 Expr *BitWidth = Importer.Import(D->getBitWidth());
3015 if (!BitWidth && D->getBitWidth())
3018 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3019 cast<ObjCContainerDecl>(DC),
3020 Importer.Import(D->getInnerLocStart()),
3021 Loc, Name.getAsIdentifierInfo(),
3022 T, TInfo, D->getAccessControl(),
3023 BitWidth, D->getSynthesize());
3024 ToIvar->setLexicalDeclContext(LexicalDC);
3025 Importer.Imported(D, ToIvar);
3026 LexicalDC->addDeclInternal(ToIvar);
3031 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3032 // Import the major distinguishing characteristics of a variable.
3033 DeclContext *DC, *LexicalDC;
3034 DeclarationName Name;
3036 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3039 // Try to find a variable in our own ("to") context with the same name and
3040 // in the same context as the variable we're importing.
3041 if (D->isFileVarDecl()) {
3042 VarDecl *MergeWithVar = 0;
3043 SmallVector<NamedDecl *, 4> ConflictingDecls;
3044 unsigned IDNS = Decl::IDNS_Ordinary;
3045 SmallVector<NamedDecl *, 2> FoundDecls;
3046 DC->localUncachedLookup(Name, FoundDecls);
3047 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3048 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3051 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3052 // We have found a variable that we may need to merge with. Check it.
3053 if (FoundVar->hasExternalFormalLinkage() &&
3054 D->hasExternalFormalLinkage()) {
3055 if (Importer.IsStructurallyEquivalent(D->getType(),
3056 FoundVar->getType())) {
3057 MergeWithVar = FoundVar;
3061 const ArrayType *FoundArray
3062 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3063 const ArrayType *TArray
3064 = Importer.getToContext().getAsArrayType(D->getType());
3065 if (FoundArray && TArray) {
3066 if (isa<IncompleteArrayType>(FoundArray) &&
3067 isa<ConstantArrayType>(TArray)) {
3069 QualType T = Importer.Import(D->getType());
3073 FoundVar->setType(T);
3074 MergeWithVar = FoundVar;
3076 } else if (isa<IncompleteArrayType>(TArray) &&
3077 isa<ConstantArrayType>(FoundArray)) {
3078 MergeWithVar = FoundVar;
3083 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3084 << Name << D->getType() << FoundVar->getType();
3085 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3086 << FoundVar->getType();
3090 ConflictingDecls.push_back(FoundDecls[I]);
3094 // An equivalent variable with external linkage has been found. Link
3095 // the two declarations, then merge them.
3096 Importer.Imported(D, MergeWithVar);
3098 if (VarDecl *DDef = D->getDefinition()) {
3099 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3100 Importer.ToDiag(ExistingDef->getLocation(),
3101 diag::err_odr_variable_multiple_def)
3103 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3105 Expr *Init = Importer.Import(DDef->getInit());
3106 MergeWithVar->setInit(Init);
3107 if (DDef->isInitKnownICE()) {
3108 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3109 Eval->CheckedICE = true;
3110 Eval->IsICE = DDef->isInitICE();
3115 return MergeWithVar;
3118 if (!ConflictingDecls.empty()) {
3119 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3120 ConflictingDecls.data(),
3121 ConflictingDecls.size());
3128 QualType T = Importer.Import(D->getType());
3132 // Create the imported variable.
3133 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3134 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3135 Importer.Import(D->getInnerLocStart()),
3136 Loc, Name.getAsIdentifierInfo(),
3138 D->getStorageClass());
3139 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3140 ToVar->setAccess(D->getAccess());
3141 ToVar->setLexicalDeclContext(LexicalDC);
3142 Importer.Imported(D, ToVar);
3143 LexicalDC->addDeclInternal(ToVar);
3145 // Merge the initializer.
3146 if (ImportDefinition(D, ToVar))
3152 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3153 // Parameters are created in the translation unit's context, then moved
3154 // into the function declaration's context afterward.
3155 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3157 // Import the name of this declaration.
3158 DeclarationName Name = Importer.Import(D->getDeclName());
3159 if (D->getDeclName() && !Name)
3162 // Import the location of this declaration.
3163 SourceLocation Loc = Importer.Import(D->getLocation());
3165 // Import the parameter's type.
3166 QualType T = Importer.Import(D->getType());
3170 // Create the imported parameter.
3171 ImplicitParamDecl *ToParm
3172 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3173 Loc, Name.getAsIdentifierInfo(),
3175 return Importer.Imported(D, ToParm);
3178 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3179 // Parameters are created in the translation unit's context, then moved
3180 // into the function declaration's context afterward.
3181 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3183 // Import the name of this declaration.
3184 DeclarationName Name = Importer.Import(D->getDeclName());
3185 if (D->getDeclName() && !Name)
3188 // Import the location of this declaration.
3189 SourceLocation Loc = Importer.Import(D->getLocation());
3191 // Import the parameter's type.
3192 QualType T = Importer.Import(D->getType());
3196 // Create the imported parameter.
3197 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3198 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3199 Importer.Import(D->getInnerLocStart()),
3200 Loc, Name.getAsIdentifierInfo(),
3201 T, TInfo, D->getStorageClass(),
3202 /*FIXME: Default argument*/ 0);
3203 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3204 return Importer.Imported(D, ToParm);
3207 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3208 // Import the major distinguishing characteristics of a method.
3209 DeclContext *DC, *LexicalDC;
3210 DeclarationName Name;
3212 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3215 SmallVector<NamedDecl *, 2> FoundDecls;
3216 DC->localUncachedLookup(Name, FoundDecls);
3217 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3218 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3219 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3222 // Check return types.
3223 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3224 FoundMethod->getReturnType())) {
3225 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3226 << D->isInstanceMethod() << Name << D->getReturnType()
3227 << FoundMethod->getReturnType();
3228 Importer.ToDiag(FoundMethod->getLocation(),
3229 diag::note_odr_objc_method_here)
3230 << D->isInstanceMethod() << Name;
3234 // Check the number of parameters.
3235 if (D->param_size() != FoundMethod->param_size()) {
3236 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3237 << D->isInstanceMethod() << Name
3238 << D->param_size() << FoundMethod->param_size();
3239 Importer.ToDiag(FoundMethod->getLocation(),
3240 diag::note_odr_objc_method_here)
3241 << D->isInstanceMethod() << Name;
3245 // Check parameter types.
3246 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3247 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3248 P != PEnd; ++P, ++FoundP) {
3249 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3250 (*FoundP)->getType())) {
3251 Importer.FromDiag((*P)->getLocation(),
3252 diag::err_odr_objc_method_param_type_inconsistent)
3253 << D->isInstanceMethod() << Name
3254 << (*P)->getType() << (*FoundP)->getType();
3255 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3256 << (*FoundP)->getType();
3261 // Check variadic/non-variadic.
3262 // Check the number of parameters.
3263 if (D->isVariadic() != FoundMethod->isVariadic()) {
3264 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3265 << D->isInstanceMethod() << Name;
3266 Importer.ToDiag(FoundMethod->getLocation(),
3267 diag::note_odr_objc_method_here)
3268 << D->isInstanceMethod() << Name;
3272 // FIXME: Any other bits we need to merge?
3273 return Importer.Imported(D, FoundMethod);
3277 // Import the result type.
3278 QualType ResultTy = Importer.Import(D->getReturnType());
3279 if (ResultTy.isNull())
3282 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3284 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3285 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3286 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3287 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3288 D->getImplementationControl(), D->hasRelatedResultType());
3290 // FIXME: When we decide to merge method definitions, we'll need to
3291 // deal with implicit parameters.
3293 // Import the parameters
3294 SmallVector<ParmVarDecl *, 5> ToParams;
3295 for (auto *FromP : D->params()) {
3296 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3300 ToParams.push_back(ToP);
3303 // Set the parameters.
3304 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3305 ToParams[I]->setOwningFunction(ToMethod);
3306 ToMethod->addDeclInternal(ToParams[I]);
3308 SmallVector<SourceLocation, 12> SelLocs;
3309 D->getSelectorLocs(SelLocs);
3310 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3312 ToMethod->setLexicalDeclContext(LexicalDC);
3313 Importer.Imported(D, ToMethod);
3314 LexicalDC->addDeclInternal(ToMethod);
3318 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3319 // Import the major distinguishing characteristics of a category.
3320 DeclContext *DC, *LexicalDC;
3321 DeclarationName Name;
3323 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3326 ObjCInterfaceDecl *ToInterface
3327 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3331 // Determine if we've already encountered this category.
3332 ObjCCategoryDecl *MergeWithCategory
3333 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3334 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3336 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3337 Importer.Import(D->getAtStartLoc()),
3339 Importer.Import(D->getCategoryNameLoc()),
3340 Name.getAsIdentifierInfo(),
3342 Importer.Import(D->getIvarLBraceLoc()),
3343 Importer.Import(D->getIvarRBraceLoc()));
3344 ToCategory->setLexicalDeclContext(LexicalDC);
3345 LexicalDC->addDeclInternal(ToCategory);
3346 Importer.Imported(D, ToCategory);
3349 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3350 SmallVector<SourceLocation, 4> ProtocolLocs;
3351 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3352 = D->protocol_loc_begin();
3353 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3354 FromProtoEnd = D->protocol_end();
3355 FromProto != FromProtoEnd;
3356 ++FromProto, ++FromProtoLoc) {
3357 ObjCProtocolDecl *ToProto
3358 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3361 Protocols.push_back(ToProto);
3362 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3365 // FIXME: If we're merging, make sure that the protocol list is the same.
3366 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3367 ProtocolLocs.data(), Importer.getToContext());
3370 Importer.Imported(D, ToCategory);
3373 // Import all of the members of this category.
3374 ImportDeclContext(D);
3376 // If we have an implementation, import it as well.
3377 if (D->getImplementation()) {
3378 ObjCCategoryImplDecl *Impl
3379 = cast_or_null<ObjCCategoryImplDecl>(
3380 Importer.Import(D->getImplementation()));
3384 ToCategory->setImplementation(Impl);
3390 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3391 ObjCProtocolDecl *To,
3392 ImportDefinitionKind Kind) {
3393 if (To->getDefinition()) {
3394 if (shouldForceImportDeclContext(Kind))
3395 ImportDeclContext(From);
3399 // Start the protocol definition
3400 To->startDefinition();
3403 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3404 SmallVector<SourceLocation, 4> ProtocolLocs;
3405 ObjCProtocolDecl::protocol_loc_iterator
3406 FromProtoLoc = From->protocol_loc_begin();
3407 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3408 FromProtoEnd = From->protocol_end();
3409 FromProto != FromProtoEnd;
3410 ++FromProto, ++FromProtoLoc) {
3411 ObjCProtocolDecl *ToProto
3412 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3415 Protocols.push_back(ToProto);
3416 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3419 // FIXME: If we're merging, make sure that the protocol list is the same.
3420 To->setProtocolList(Protocols.data(), Protocols.size(),
3421 ProtocolLocs.data(), Importer.getToContext());
3423 if (shouldForceImportDeclContext(Kind)) {
3424 // Import all of the members of this protocol.
3425 ImportDeclContext(From, /*ForceImport=*/true);
3430 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3431 // If this protocol has a definition in the translation unit we're coming
3432 // from, but this particular declaration is not that definition, import the
3433 // definition and map to that.
3434 ObjCProtocolDecl *Definition = D->getDefinition();
3435 if (Definition && Definition != D) {
3436 Decl *ImportedDef = Importer.Import(Definition);
3440 return Importer.Imported(D, ImportedDef);
3443 // Import the major distinguishing characteristics of a protocol.
3444 DeclContext *DC, *LexicalDC;
3445 DeclarationName Name;
3447 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3450 ObjCProtocolDecl *MergeWithProtocol = 0;
3451 SmallVector<NamedDecl *, 2> FoundDecls;
3452 DC->localUncachedLookup(Name, FoundDecls);
3453 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3454 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3457 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3461 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3463 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3464 Name.getAsIdentifierInfo(), Loc,
3465 Importer.Import(D->getAtStartLoc()),
3467 ToProto->setLexicalDeclContext(LexicalDC);
3468 LexicalDC->addDeclInternal(ToProto);
3471 Importer.Imported(D, ToProto);
3473 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3479 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3480 ObjCInterfaceDecl *To,
3481 ImportDefinitionKind Kind) {
3482 if (To->getDefinition()) {
3483 // Check consistency of superclass.
3484 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3486 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3491 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3492 if ((bool)FromSuper != (bool)ToSuper ||
3493 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3494 Importer.ToDiag(To->getLocation(),
3495 diag::err_odr_objc_superclass_inconsistent)
3496 << To->getDeclName();
3498 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3499 << To->getSuperClass()->getDeclName();
3501 Importer.ToDiag(To->getLocation(),
3502 diag::note_odr_objc_missing_superclass);
3503 if (From->getSuperClass())
3504 Importer.FromDiag(From->getSuperClassLoc(),
3505 diag::note_odr_objc_superclass)
3506 << From->getSuperClass()->getDeclName();
3508 Importer.FromDiag(From->getLocation(),
3509 diag::note_odr_objc_missing_superclass);
3512 if (shouldForceImportDeclContext(Kind))
3513 ImportDeclContext(From);
3517 // Start the definition.
3518 To->startDefinition();
3520 // If this class has a superclass, import it.
3521 if (From->getSuperClass()) {
3522 ObjCInterfaceDecl *Super = cast_or_null<ObjCInterfaceDecl>(
3523 Importer.Import(From->getSuperClass()));
3527 To->setSuperClass(Super);
3528 To->setSuperClassLoc(Importer.Import(From->getSuperClassLoc()));
3532 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3533 SmallVector<SourceLocation, 4> ProtocolLocs;
3534 ObjCInterfaceDecl::protocol_loc_iterator
3535 FromProtoLoc = From->protocol_loc_begin();
3537 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3538 FromProtoEnd = From->protocol_end();
3539 FromProto != FromProtoEnd;
3540 ++FromProto, ++FromProtoLoc) {
3541 ObjCProtocolDecl *ToProto
3542 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3545 Protocols.push_back(ToProto);
3546 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3549 // FIXME: If we're merging, make sure that the protocol list is the same.
3550 To->setProtocolList(Protocols.data(), Protocols.size(),
3551 ProtocolLocs.data(), Importer.getToContext());
3553 // Import categories. When the categories themselves are imported, they'll
3554 // hook themselves into this interface.
3555 for (ObjCInterfaceDecl::known_categories_iterator
3556 Cat = From->known_categories_begin(),
3557 CatEnd = From->known_categories_end();
3558 Cat != CatEnd; ++Cat) {
3559 Importer.Import(*Cat);
3562 // If we have an @implementation, import it as well.
3563 if (From->getImplementation()) {
3564 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3565 Importer.Import(From->getImplementation()));
3569 To->setImplementation(Impl);
3572 if (shouldForceImportDeclContext(Kind)) {
3573 // Import all of the members of this class.
3574 ImportDeclContext(From, /*ForceImport=*/true);
3579 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3580 // If this class has a definition in the translation unit we're coming from,
3581 // but this particular declaration is not that definition, import the
3582 // definition and map to that.
3583 ObjCInterfaceDecl *Definition = D->getDefinition();
3584 if (Definition && Definition != D) {
3585 Decl *ImportedDef = Importer.Import(Definition);
3589 return Importer.Imported(D, ImportedDef);
3592 // Import the major distinguishing characteristics of an @interface.
3593 DeclContext *DC, *LexicalDC;
3594 DeclarationName Name;
3596 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3599 // Look for an existing interface with the same name.
3600 ObjCInterfaceDecl *MergeWithIface = 0;
3601 SmallVector<NamedDecl *, 2> FoundDecls;
3602 DC->localUncachedLookup(Name, FoundDecls);
3603 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3604 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3607 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3611 // Create an interface declaration, if one does not already exist.
3612 ObjCInterfaceDecl *ToIface = MergeWithIface;
3614 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3615 Importer.Import(D->getAtStartLoc()),
3616 Name.getAsIdentifierInfo(),
3618 D->isImplicitInterfaceDecl());
3619 ToIface->setLexicalDeclContext(LexicalDC);
3620 LexicalDC->addDeclInternal(ToIface);
3622 Importer.Imported(D, ToIface);
3624 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3630 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3631 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3632 Importer.Import(D->getCategoryDecl()));
3636 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3638 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3642 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3643 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3644 Importer.Import(D->getIdentifier()),
3645 Category->getClassInterface(),
3646 Importer.Import(D->getLocation()),
3647 Importer.Import(D->getAtStartLoc()),
3650 DeclContext *LexicalDC = DC;
3651 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3652 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3656 ToImpl->setLexicalDeclContext(LexicalDC);
3659 LexicalDC->addDeclInternal(ToImpl);
3660 Category->setImplementation(ToImpl);
3663 Importer.Imported(D, ToImpl);
3664 ImportDeclContext(D);
3668 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3669 // Find the corresponding interface.
3670 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3671 Importer.Import(D->getClassInterface()));
3675 // Import the superclass, if any.
3676 ObjCInterfaceDecl *Super = 0;
3677 if (D->getSuperClass()) {
3678 Super = cast_or_null<ObjCInterfaceDecl>(
3679 Importer.Import(D->getSuperClass()));
3684 ObjCImplementationDecl *Impl = Iface->getImplementation();
3686 // We haven't imported an implementation yet. Create a new @implementation
3688 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3689 Importer.ImportContext(D->getDeclContext()),
3691 Importer.Import(D->getLocation()),
3692 Importer.Import(D->getAtStartLoc()),
3693 Importer.Import(D->getSuperClassLoc()),
3694 Importer.Import(D->getIvarLBraceLoc()),
3695 Importer.Import(D->getIvarRBraceLoc()));
3697 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3698 DeclContext *LexicalDC
3699 = Importer.ImportContext(D->getLexicalDeclContext());
3702 Impl->setLexicalDeclContext(LexicalDC);
3705 // Associate the implementation with the class it implements.
3706 Iface->setImplementation(Impl);
3707 Importer.Imported(D, Iface->getImplementation());
3709 Importer.Imported(D, Iface->getImplementation());
3711 // Verify that the existing @implementation has the same superclass.
3712 if ((Super && !Impl->getSuperClass()) ||
3713 (!Super && Impl->getSuperClass()) ||
3714 (Super && Impl->getSuperClass() &&
3715 !declaresSameEntity(Super->getCanonicalDecl(), Impl->getSuperClass()))) {
3716 Importer.ToDiag(Impl->getLocation(),
3717 diag::err_odr_objc_superclass_inconsistent)
3718 << Iface->getDeclName();
3719 // FIXME: It would be nice to have the location of the superclass
3721 if (Impl->getSuperClass())
3722 Importer.ToDiag(Impl->getLocation(),
3723 diag::note_odr_objc_superclass)
3724 << Impl->getSuperClass()->getDeclName();
3726 Importer.ToDiag(Impl->getLocation(),
3727 diag::note_odr_objc_missing_superclass);
3728 if (D->getSuperClass())
3729 Importer.FromDiag(D->getLocation(),
3730 diag::note_odr_objc_superclass)
3731 << D->getSuperClass()->getDeclName();
3733 Importer.FromDiag(D->getLocation(),
3734 diag::note_odr_objc_missing_superclass);
3739 // Import all of the members of this @implementation.
3740 ImportDeclContext(D);
3745 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3746 // Import the major distinguishing characteristics of an @property.
3747 DeclContext *DC, *LexicalDC;
3748 DeclarationName Name;
3750 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3753 // Check whether we have already imported this property.
3754 SmallVector<NamedDecl *, 2> FoundDecls;
3755 DC->localUncachedLookup(Name, FoundDecls);
3756 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3757 if (ObjCPropertyDecl *FoundProp
3758 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3759 // Check property types.
3760 if (!Importer.IsStructurallyEquivalent(D->getType(),
3761 FoundProp->getType())) {
3762 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3763 << Name << D->getType() << FoundProp->getType();
3764 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3765 << FoundProp->getType();
3769 // FIXME: Check property attributes, getters, setters, etc.?
3771 // Consider these properties to be equivalent.
3772 Importer.Imported(D, FoundProp);
3778 TypeSourceInfo *T = Importer.Import(D->getTypeSourceInfo());
3782 // Create the new property.
3783 ObjCPropertyDecl *ToProperty
3784 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3785 Name.getAsIdentifierInfo(),
3786 Importer.Import(D->getAtLoc()),
3787 Importer.Import(D->getLParenLoc()),
3789 D->getPropertyImplementation());
3790 Importer.Imported(D, ToProperty);
3791 ToProperty->setLexicalDeclContext(LexicalDC);
3792 LexicalDC->addDeclInternal(ToProperty);
3794 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3795 ToProperty->setPropertyAttributesAsWritten(
3796 D->getPropertyAttributesAsWritten());
3797 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
3798 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
3799 ToProperty->setGetterMethodDecl(
3800 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3801 ToProperty->setSetterMethodDecl(
3802 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3803 ToProperty->setPropertyIvarDecl(
3804 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3808 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3809 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3810 Importer.Import(D->getPropertyDecl()));
3814 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3818 // Import the lexical declaration context.
3819 DeclContext *LexicalDC = DC;
3820 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3821 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3826 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3830 // Import the ivar (for an @synthesize).
3831 ObjCIvarDecl *Ivar = 0;
3832 if (D->getPropertyIvarDecl()) {
3833 Ivar = cast_or_null<ObjCIvarDecl>(
3834 Importer.Import(D->getPropertyIvarDecl()));
3839 ObjCPropertyImplDecl *ToImpl
3840 = InImpl->FindPropertyImplDecl(Property->getIdentifier());
3842 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3843 Importer.Import(D->getLocStart()),
3844 Importer.Import(D->getLocation()),
3846 D->getPropertyImplementation(),
3848 Importer.Import(D->getPropertyIvarDeclLoc()));
3849 ToImpl->setLexicalDeclContext(LexicalDC);
3850 Importer.Imported(D, ToImpl);
3851 LexicalDC->addDeclInternal(ToImpl);
3853 // Check that we have the same kind of property implementation (@synthesize
3855 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3856 Importer.ToDiag(ToImpl->getLocation(),
3857 diag::err_odr_objc_property_impl_kind_inconsistent)
3858 << Property->getDeclName()
3859 << (ToImpl->getPropertyImplementation()
3860 == ObjCPropertyImplDecl::Dynamic);
3861 Importer.FromDiag(D->getLocation(),
3862 diag::note_odr_objc_property_impl_kind)
3863 << D->getPropertyDecl()->getDeclName()
3864 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3868 // For @synthesize, check that we have the same
3869 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3870 Ivar != ToImpl->getPropertyIvarDecl()) {
3871 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3872 diag::err_odr_objc_synthesize_ivar_inconsistent)
3873 << Property->getDeclName()
3874 << ToImpl->getPropertyIvarDecl()->getDeclName()
3875 << Ivar->getDeclName();
3876 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3877 diag::note_odr_objc_synthesize_ivar_here)
3878 << D->getPropertyIvarDecl()->getDeclName();
3882 // Merge the existing implementation with the new implementation.
3883 Importer.Imported(D, ToImpl);
3889 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3890 // For template arguments, we adopt the translation unit as our declaration
3891 // context. This context will be fixed when the actual template declaration
3894 // FIXME: Import default argument.
3895 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3896 Importer.getToContext().getTranslationUnitDecl(),
3897 Importer.Import(D->getLocStart()),
3898 Importer.Import(D->getLocation()),
3901 Importer.Import(D->getIdentifier()),
3902 D->wasDeclaredWithTypename(),
3903 D->isParameterPack());
3907 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3908 // Import the name of this declaration.
3909 DeclarationName Name = Importer.Import(D->getDeclName());
3910 if (D->getDeclName() && !Name)
3913 // Import the location of this declaration.
3914 SourceLocation Loc = Importer.Import(D->getLocation());
3916 // Import the type of this declaration.
3917 QualType T = Importer.Import(D->getType());
3921 // Import type-source information.
3922 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3923 if (D->getTypeSourceInfo() && !TInfo)
3926 // FIXME: Import default argument.
3928 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3929 Importer.getToContext().getTranslationUnitDecl(),
3930 Importer.Import(D->getInnerLocStart()),
3931 Loc, D->getDepth(), D->getPosition(),
3932 Name.getAsIdentifierInfo(),
3933 T, D->isParameterPack(), TInfo);
3937 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3938 // Import the name of this declaration.
3939 DeclarationName Name = Importer.Import(D->getDeclName());
3940 if (D->getDeclName() && !Name)
3943 // Import the location of this declaration.
3944 SourceLocation Loc = Importer.Import(D->getLocation());
3946 // Import template parameters.
3947 TemplateParameterList *TemplateParams
3948 = ImportTemplateParameterList(D->getTemplateParameters());
3949 if (!TemplateParams)
3952 // FIXME: Import default argument.
3954 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3955 Importer.getToContext().getTranslationUnitDecl(),
3956 Loc, D->getDepth(), D->getPosition(),
3957 D->isParameterPack(),
3958 Name.getAsIdentifierInfo(),
3962 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
3963 // If this record has a definition in the translation unit we're coming from,
3964 // but this particular declaration is not that definition, import the
3965 // definition and map to that.
3966 CXXRecordDecl *Definition
3967 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
3968 if (Definition && Definition != D->getTemplatedDecl()) {
3970 = Importer.Import(Definition->getDescribedClassTemplate());
3974 return Importer.Imported(D, ImportedDef);
3977 // Import the major distinguishing characteristics of this class template.
3978 DeclContext *DC, *LexicalDC;
3979 DeclarationName Name;
3981 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
3984 // We may already have a template of the same name; try to find and match it.
3985 if (!DC->isFunctionOrMethod()) {
3986 SmallVector<NamedDecl *, 4> ConflictingDecls;
3987 SmallVector<NamedDecl *, 2> FoundDecls;
3988 DC->localUncachedLookup(Name, FoundDecls);
3989 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3990 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3993 Decl *Found = FoundDecls[I];
3994 if (ClassTemplateDecl *FoundTemplate
3995 = dyn_cast<ClassTemplateDecl>(Found)) {
3996 if (IsStructuralMatch(D, FoundTemplate)) {
3997 // The class templates structurally match; call it the same template.
3998 // FIXME: We may be filling in a forward declaration here. Handle
4000 Importer.Imported(D->getTemplatedDecl(),
4001 FoundTemplate->getTemplatedDecl());
4002 return Importer.Imported(D, FoundTemplate);
4006 ConflictingDecls.push_back(FoundDecls[I]);
4009 if (!ConflictingDecls.empty()) {
4010 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4011 ConflictingDecls.data(),
4012 ConflictingDecls.size());
4019 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4021 // Create the declaration that is being templated.
4022 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4023 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4024 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4025 DTemplated->getTagKind(),
4026 DC, StartLoc, IdLoc,
4027 Name.getAsIdentifierInfo());
4028 D2Templated->setAccess(DTemplated->getAccess());
4029 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4030 D2Templated->setLexicalDeclContext(LexicalDC);
4032 // Create the class template declaration itself.
4033 TemplateParameterList *TemplateParams
4034 = ImportTemplateParameterList(D->getTemplateParameters());
4035 if (!TemplateParams)
4038 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4039 Loc, Name, TemplateParams,
4042 D2Templated->setDescribedClassTemplate(D2);
4044 D2->setAccess(D->getAccess());
4045 D2->setLexicalDeclContext(LexicalDC);
4046 LexicalDC->addDeclInternal(D2);
4048 // Note the relationship between the class templates.
4049 Importer.Imported(D, D2);
4050 Importer.Imported(DTemplated, D2Templated);
4052 if (DTemplated->isCompleteDefinition() &&
4053 !D2Templated->isCompleteDefinition()) {
4054 // FIXME: Import definition!
4060 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4061 ClassTemplateSpecializationDecl *D) {
4062 // If this record has a definition in the translation unit we're coming from,
4063 // but this particular declaration is not that definition, import the
4064 // definition and map to that.
4065 TagDecl *Definition = D->getDefinition();
4066 if (Definition && Definition != D) {
4067 Decl *ImportedDef = Importer.Import(Definition);
4071 return Importer.Imported(D, ImportedDef);
4074 ClassTemplateDecl *ClassTemplate
4075 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4076 D->getSpecializedTemplate()));
4080 // Import the context of this declaration.
4081 DeclContext *DC = ClassTemplate->getDeclContext();
4085 DeclContext *LexicalDC = DC;
4086 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4087 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4092 // Import the location of this declaration.
4093 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4094 SourceLocation IdLoc = Importer.Import(D->getLocation());
4096 // Import template arguments.
4097 SmallVector<TemplateArgument, 2> TemplateArgs;
4098 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4099 D->getTemplateArgs().size(),
4103 // Try to find an existing specialization with these template arguments.
4104 void *InsertPos = 0;
4105 ClassTemplateSpecializationDecl *D2
4106 = ClassTemplate->findSpecialization(TemplateArgs.data(),
4107 TemplateArgs.size(), InsertPos);
4109 // We already have a class template specialization with these template
4112 // FIXME: Check for specialization vs. instantiation errors.
4114 if (RecordDecl *FoundDef = D2->getDefinition()) {
4115 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4116 // The record types structurally match, or the "from" translation
4117 // unit only had a forward declaration anyway; call it the same
4119 return Importer.Imported(D, FoundDef);
4123 // Create a new specialization.
4124 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4125 D->getTagKind(), DC,
4128 TemplateArgs.data(),
4129 TemplateArgs.size(),
4131 D2->setSpecializationKind(D->getSpecializationKind());
4133 // Add this specialization to the class template.
4134 ClassTemplate->AddSpecialization(D2, InsertPos);
4136 // Import the qualifier, if any.
4137 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4139 // Add the specialization to this context.
4140 D2->setLexicalDeclContext(LexicalDC);
4141 LexicalDC->addDeclInternal(D2);
4143 Importer.Imported(D, D2);
4145 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4151 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4152 // If this variable has a definition in the translation unit we're coming
4154 // but this particular declaration is not that definition, import the
4155 // definition and map to that.
4156 VarDecl *Definition =
4157 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4158 if (Definition && Definition != D->getTemplatedDecl()) {
4159 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4163 return Importer.Imported(D, ImportedDef);
4166 // Import the major distinguishing characteristics of this variable template.
4167 DeclContext *DC, *LexicalDC;
4168 DeclarationName Name;
4170 if (ImportDeclParts(D, DC, LexicalDC, Name, Loc))
4173 // We may already have a template of the same name; try to find and match it.
4174 assert(!DC->isFunctionOrMethod() &&
4175 "Variable templates cannot be declared at function scope");
4176 SmallVector<NamedDecl *, 4> ConflictingDecls;
4177 SmallVector<NamedDecl *, 2> FoundDecls;
4178 DC->localUncachedLookup(Name, FoundDecls);
4179 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4180 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4183 Decl *Found = FoundDecls[I];
4184 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4185 if (IsStructuralMatch(D, FoundTemplate)) {
4186 // The variable templates structurally match; call it the same template.
4187 Importer.Imported(D->getTemplatedDecl(),
4188 FoundTemplate->getTemplatedDecl());
4189 return Importer.Imported(D, FoundTemplate);
4193 ConflictingDecls.push_back(FoundDecls[I]);
4196 if (!ConflictingDecls.empty()) {
4197 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4198 ConflictingDecls.data(),
4199 ConflictingDecls.size());
4205 VarDecl *DTemplated = D->getTemplatedDecl();
4208 QualType T = Importer.Import(DTemplated->getType());
4212 // Create the declaration that is being templated.
4213 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4214 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4215 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4216 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4217 IdLoc, Name.getAsIdentifierInfo(), T,
4218 TInfo, DTemplated->getStorageClass());
4219 D2Templated->setAccess(DTemplated->getAccess());
4220 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4221 D2Templated->setLexicalDeclContext(LexicalDC);
4223 // Importer.Imported(DTemplated, D2Templated);
4224 // LexicalDC->addDeclInternal(D2Templated);
4226 // Merge the initializer.
4227 if (ImportDefinition(DTemplated, D2Templated))
4230 // Create the variable template declaration itself.
4231 TemplateParameterList *TemplateParams =
4232 ImportTemplateParameterList(D->getTemplateParameters());
4233 if (!TemplateParams)
4236 VarTemplateDecl *D2 = VarTemplateDecl::Create(
4237 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4238 D2Templated->setDescribedVarTemplate(D2);
4240 D2->setAccess(D->getAccess());
4241 D2->setLexicalDeclContext(LexicalDC);
4242 LexicalDC->addDeclInternal(D2);
4244 // Note the relationship between the variable templates.
4245 Importer.Imported(D, D2);
4246 Importer.Imported(DTemplated, D2Templated);
4248 if (DTemplated->isThisDeclarationADefinition() &&
4249 !D2Templated->isThisDeclarationADefinition()) {
4250 // FIXME: Import definition!
4256 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4257 VarTemplateSpecializationDecl *D) {
4258 // If this record has a definition in the translation unit we're coming from,
4259 // but this particular declaration is not that definition, import the
4260 // definition and map to that.
4261 VarDecl *Definition = D->getDefinition();
4262 if (Definition && Definition != D) {
4263 Decl *ImportedDef = Importer.Import(Definition);
4267 return Importer.Imported(D, ImportedDef);
4270 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4271 Importer.Import(D->getSpecializedTemplate()));
4275 // Import the context of this declaration.
4276 DeclContext *DC = VarTemplate->getDeclContext();
4280 DeclContext *LexicalDC = DC;
4281 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4282 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4287 // Import the location of this declaration.
4288 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4289 SourceLocation IdLoc = Importer.Import(D->getLocation());
4291 // Import template arguments.
4292 SmallVector<TemplateArgument, 2> TemplateArgs;
4293 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4294 D->getTemplateArgs().size(), TemplateArgs))
4297 // Try to find an existing specialization with these template arguments.
4298 void *InsertPos = 0;
4299 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4300 TemplateArgs.data(), TemplateArgs.size(), InsertPos);
4302 // We already have a variable template specialization with these template
4305 // FIXME: Check for specialization vs. instantiation errors.
4307 if (VarDecl *FoundDef = D2->getDefinition()) {
4308 if (!D->isThisDeclarationADefinition() ||
4309 IsStructuralMatch(D, FoundDef)) {
4310 // The record types structurally match, or the "from" translation
4311 // unit only had a forward declaration anyway; call it the same
4313 return Importer.Imported(D, FoundDef);
4319 QualType T = Importer.Import(D->getType());
4322 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4324 // Create a new specialization.
4325 D2 = VarTemplateSpecializationDecl::Create(
4326 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4327 D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size());
4328 D2->setSpecializationKind(D->getSpecializationKind());
4329 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4331 // Add this specialization to the class template.
4332 VarTemplate->AddSpecialization(D2, InsertPos);
4334 // Import the qualifier, if any.
4335 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4337 // Add the specialization to this context.
4338 D2->setLexicalDeclContext(LexicalDC);
4339 LexicalDC->addDeclInternal(D2);
4341 Importer.Imported(D, D2);
4343 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4349 //----------------------------------------------------------------------------
4350 // Import Statements
4351 //----------------------------------------------------------------------------
4353 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4354 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4355 << S->getStmtClassName();
4359 //----------------------------------------------------------------------------
4360 // Import Expressions
4361 //----------------------------------------------------------------------------
4362 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
4363 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4364 << E->getStmtClassName();
4368 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
4369 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4373 NamedDecl *FoundD = 0;
4374 if (E->getDecl() != E->getFoundDecl()) {
4375 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4380 QualType T = Importer.Import(E->getType());
4384 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4385 Importer.Import(E->getQualifierLoc()),
4386 Importer.Import(E->getTemplateKeywordLoc()),
4388 E->refersToEnclosingLocal(),
4389 Importer.Import(E->getLocation()),
4390 T, E->getValueKind(),
4392 /*FIXME:TemplateArgs=*/0);
4393 if (E->hadMultipleCandidates())
4394 DRE->setHadMultipleCandidates(true);
4398 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
4399 QualType T = Importer.Import(E->getType());
4403 return IntegerLiteral::Create(Importer.getToContext(),
4405 Importer.Import(E->getLocation()));
4408 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
4409 QualType T = Importer.Import(E->getType());
4413 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
4415 Importer.Import(E->getLocation()));
4418 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
4419 Expr *SubExpr = Importer.Import(E->getSubExpr());
4423 return new (Importer.getToContext())
4424 ParenExpr(Importer.Import(E->getLParen()),
4425 Importer.Import(E->getRParen()),
4429 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
4430 QualType T = Importer.Import(E->getType());
4434 Expr *SubExpr = Importer.Import(E->getSubExpr());
4438 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
4439 T, E->getValueKind(),
4441 Importer.Import(E->getOperatorLoc()));
4444 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
4445 UnaryExprOrTypeTraitExpr *E) {
4446 QualType ResultType = Importer.Import(E->getType());
4448 if (E->isArgumentType()) {
4449 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
4453 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4455 Importer.Import(E->getOperatorLoc()),
4456 Importer.Import(E->getRParenLoc()));
4459 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
4463 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
4464 SubExpr, ResultType,
4465 Importer.Import(E->getOperatorLoc()),
4466 Importer.Import(E->getRParenLoc()));
4469 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
4470 QualType T = Importer.Import(E->getType());
4474 Expr *LHS = Importer.Import(E->getLHS());
4478 Expr *RHS = Importer.Import(E->getRHS());
4482 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
4483 T, E->getValueKind(),
4485 Importer.Import(E->getOperatorLoc()),
4486 E->isFPContractable());
4489 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
4490 QualType T = Importer.Import(E->getType());
4494 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
4495 if (CompLHSType.isNull())
4498 QualType CompResultType = Importer.Import(E->getComputationResultType());
4499 if (CompResultType.isNull())
4502 Expr *LHS = Importer.Import(E->getLHS());
4506 Expr *RHS = Importer.Import(E->getRHS());
4510 return new (Importer.getToContext())
4511 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
4512 T, E->getValueKind(),
4514 CompLHSType, CompResultType,
4515 Importer.Import(E->getOperatorLoc()),
4516 E->isFPContractable());
4519 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
4520 if (E->path_empty()) return false;
4522 // TODO: import cast paths
4526 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
4527 QualType T = Importer.Import(E->getType());
4531 Expr *SubExpr = Importer.Import(E->getSubExpr());
4535 CXXCastPath BasePath;
4536 if (ImportCastPath(E, BasePath))
4539 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
4540 SubExpr, &BasePath, E->getValueKind());
4543 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
4544 QualType T = Importer.Import(E->getType());
4548 Expr *SubExpr = Importer.Import(E->getSubExpr());
4552 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
4553 if (!TInfo && E->getTypeInfoAsWritten())
4556 CXXCastPath BasePath;
4557 if (ImportCastPath(E, BasePath))
4560 return CStyleCastExpr::Create(Importer.getToContext(), T,
4561 E->getValueKind(), E->getCastKind(),
4562 SubExpr, &BasePath, TInfo,
4563 Importer.Import(E->getLParenLoc()),
4564 Importer.Import(E->getRParenLoc()));
4567 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
4568 ASTContext &FromContext, FileManager &FromFileManager,
4570 : ToContext(ToContext), FromContext(FromContext),
4571 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
4572 Minimal(MinimalImport), LastDiagFromFrom(false)
4574 ImportedDecls[FromContext.getTranslationUnitDecl()]
4575 = ToContext.getTranslationUnitDecl();
4578 ASTImporter::~ASTImporter() { }
4580 QualType ASTImporter::Import(QualType FromT) {
4584 const Type *fromTy = FromT.getTypePtr();
4586 // Check whether we've already imported this type.
4587 llvm::DenseMap<const Type *, const Type *>::iterator Pos
4588 = ImportedTypes.find(fromTy);
4589 if (Pos != ImportedTypes.end())
4590 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
4593 ASTNodeImporter Importer(*this);
4594 QualType ToT = Importer.Visit(fromTy);
4598 // Record the imported type.
4599 ImportedTypes[fromTy] = ToT.getTypePtr();
4601 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
4604 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
4608 // FIXME: For now we just create a "trivial" type source info based
4609 // on the type and a single location. Implement a real version of this.
4610 QualType T = Import(FromTSI->getType());
4614 return ToContext.getTrivialTypeSourceInfo(T,
4615 FromTSI->getTypeLoc().getLocStart());
4618 Decl *ASTImporter::Import(Decl *FromD) {
4622 ASTNodeImporter Importer(*this);
4624 // Check whether we've already imported this declaration.
4625 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
4626 if (Pos != ImportedDecls.end()) {
4627 Decl *ToD = Pos->second;
4628 Importer.ImportDefinitionIfNeeded(FromD, ToD);
4633 Decl *ToD = Importer.Visit(FromD);
4637 // Record the imported declaration.
4638 ImportedDecls[FromD] = ToD;
4640 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
4641 // Keep track of anonymous tags that have an associated typedef.
4642 if (FromTag->getTypedefNameForAnonDecl())
4643 AnonTagsWithPendingTypedefs.push_back(FromTag);
4644 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
4645 // When we've finished transforming a typedef, see whether it was the
4646 // typedef for an anonymous tag.
4647 for (SmallVectorImpl<TagDecl *>::iterator
4648 FromTag = AnonTagsWithPendingTypedefs.begin(),
4649 FromTagEnd = AnonTagsWithPendingTypedefs.end();
4650 FromTag != FromTagEnd; ++FromTag) {
4651 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
4652 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
4653 // We found the typedef for an anonymous tag; link them.
4654 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
4655 AnonTagsWithPendingTypedefs.erase(FromTag);
4665 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
4669 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
4673 // When we're using a record/enum/Objective-C class/protocol as a context, we
4674 // need it to have a definition.
4675 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
4676 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
4677 if (ToRecord->isCompleteDefinition()) {
4679 } else if (FromRecord->isCompleteDefinition()) {
4680 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
4681 ASTNodeImporter::IDK_Basic);
4683 CompleteDecl(ToRecord);
4685 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
4686 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
4687 if (ToEnum->isCompleteDefinition()) {
4689 } else if (FromEnum->isCompleteDefinition()) {
4690 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
4691 ASTNodeImporter::IDK_Basic);
4693 CompleteDecl(ToEnum);
4695 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
4696 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
4697 if (ToClass->getDefinition()) {
4699 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
4700 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
4701 ASTNodeImporter::IDK_Basic);
4703 CompleteDecl(ToClass);
4705 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
4706 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
4707 if (ToProto->getDefinition()) {
4709 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
4710 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
4711 ASTNodeImporter::IDK_Basic);
4713 CompleteDecl(ToProto);
4720 Expr *ASTImporter::Import(Expr *FromE) {
4724 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
4727 Stmt *ASTImporter::Import(Stmt *FromS) {
4731 // Check whether we've already imported this declaration.
4732 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
4733 if (Pos != ImportedStmts.end())
4737 ASTNodeImporter Importer(*this);
4738 Stmt *ToS = Importer.Visit(FromS);
4742 // Record the imported declaration.
4743 ImportedStmts[FromS] = ToS;
4747 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
4751 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
4753 switch (FromNNS->getKind()) {
4754 case NestedNameSpecifier::Identifier:
4755 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
4756 return NestedNameSpecifier::Create(ToContext, prefix, II);
4760 case NestedNameSpecifier::Namespace:
4761 if (NamespaceDecl *NS =
4762 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
4763 return NestedNameSpecifier::Create(ToContext, prefix, NS);
4767 case NestedNameSpecifier::NamespaceAlias:
4768 if (NamespaceAliasDecl *NSAD =
4769 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
4770 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
4774 case NestedNameSpecifier::Global:
4775 return NestedNameSpecifier::GlobalSpecifier(ToContext);
4777 case NestedNameSpecifier::TypeSpec:
4778 case NestedNameSpecifier::TypeSpecWithTemplate: {
4779 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
4781 bool bTemplate = FromNNS->getKind() ==
4782 NestedNameSpecifier::TypeSpecWithTemplate;
4783 return NestedNameSpecifier::Create(ToContext, prefix,
4784 bTemplate, T.getTypePtr());
4790 llvm_unreachable("Invalid nested name specifier kind");
4793 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
4794 // FIXME: Implement!
4795 return NestedNameSpecifierLoc();
4798 TemplateName ASTImporter::Import(TemplateName From) {
4799 switch (From.getKind()) {
4800 case TemplateName::Template:
4801 if (TemplateDecl *ToTemplate
4802 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4803 return TemplateName(ToTemplate);
4805 return TemplateName();
4807 case TemplateName::OverloadedTemplate: {
4808 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
4809 UnresolvedSet<2> ToTemplates;
4810 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
4811 E = FromStorage->end();
4813 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
4814 ToTemplates.addDecl(To);
4816 return TemplateName();
4818 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
4822 case TemplateName::QualifiedTemplate: {
4823 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
4824 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
4826 return TemplateName();
4828 if (TemplateDecl *ToTemplate
4829 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
4830 return ToContext.getQualifiedTemplateName(Qualifier,
4831 QTN->hasTemplateKeyword(),
4834 return TemplateName();
4837 case TemplateName::DependentTemplate: {
4838 DependentTemplateName *DTN = From.getAsDependentTemplateName();
4839 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
4841 return TemplateName();
4843 if (DTN->isIdentifier()) {
4844 return ToContext.getDependentTemplateName(Qualifier,
4845 Import(DTN->getIdentifier()));
4848 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
4851 case TemplateName::SubstTemplateTemplateParm: {
4852 SubstTemplateTemplateParmStorage *subst
4853 = From.getAsSubstTemplateTemplateParm();
4854 TemplateTemplateParmDecl *param
4855 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
4857 return TemplateName();
4859 TemplateName replacement = Import(subst->getReplacement());
4860 if (replacement.isNull()) return TemplateName();
4862 return ToContext.getSubstTemplateTemplateParm(param, replacement);
4865 case TemplateName::SubstTemplateTemplateParmPack: {
4866 SubstTemplateTemplateParmPackStorage *SubstPack
4867 = From.getAsSubstTemplateTemplateParmPack();
4868 TemplateTemplateParmDecl *Param
4869 = cast_or_null<TemplateTemplateParmDecl>(
4870 Import(SubstPack->getParameterPack()));
4872 return TemplateName();
4874 ASTNodeImporter Importer(*this);
4875 TemplateArgument ArgPack
4876 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
4877 if (ArgPack.isNull())
4878 return TemplateName();
4880 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
4884 llvm_unreachable("Invalid template name kind");
4887 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
4888 if (FromLoc.isInvalid())
4889 return SourceLocation();
4891 SourceManager &FromSM = FromContext.getSourceManager();
4893 // For now, map everything down to its spelling location, so that we
4894 // don't have to import macro expansions.
4895 // FIXME: Import macro expansions!
4896 FromLoc = FromSM.getSpellingLoc(FromLoc);
4897 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
4898 SourceManager &ToSM = ToContext.getSourceManager();
4899 return ToSM.getLocForStartOfFile(Import(Decomposed.first))
4900 .getLocWithOffset(Decomposed.second);
4903 SourceRange ASTImporter::Import(SourceRange FromRange) {
4904 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
4907 FileID ASTImporter::Import(FileID FromID) {
4908 llvm::DenseMap<FileID, FileID>::iterator Pos
4909 = ImportedFileIDs.find(FromID);
4910 if (Pos != ImportedFileIDs.end())
4913 SourceManager &FromSM = FromContext.getSourceManager();
4914 SourceManager &ToSM = ToContext.getSourceManager();
4915 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
4916 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
4918 // Include location of this file.
4919 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
4921 // Map the FileID for to the "to" source manager.
4923 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
4924 if (Cache->OrigEntry) {
4925 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
4927 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
4928 // than mmap the files several times.
4929 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
4930 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
4931 FromSLoc.getFile().getFileCharacteristic());
4933 // FIXME: We want to re-use the existing MemoryBuffer!
4934 const llvm::MemoryBuffer *
4935 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
4936 llvm::MemoryBuffer *ToBuf
4937 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
4938 FromBuf->getBufferIdentifier());
4939 ToID = ToSM.createFileIDForMemBuffer(ToBuf,
4940 FromSLoc.getFile().getFileCharacteristic());
4944 ImportedFileIDs[FromID] = ToID;
4948 void ASTImporter::ImportDefinition(Decl *From) {
4949 Decl *To = Import(From);
4953 if (DeclContext *FromDC = cast<DeclContext>(From)) {
4954 ASTNodeImporter Importer(*this);
4956 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
4957 if (!ToRecord->getDefinition()) {
4958 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
4959 ASTNodeImporter::IDK_Everything);
4964 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
4965 if (!ToEnum->getDefinition()) {
4966 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
4967 ASTNodeImporter::IDK_Everything);
4972 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
4973 if (!ToIFace->getDefinition()) {
4974 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
4975 ASTNodeImporter::IDK_Everything);
4980 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
4981 if (!ToProto->getDefinition()) {
4982 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
4983 ASTNodeImporter::IDK_Everything);
4988 Importer.ImportDeclContext(FromDC, true);
4992 DeclarationName ASTImporter::Import(DeclarationName FromName) {
4994 return DeclarationName();
4996 switch (FromName.getNameKind()) {
4997 case DeclarationName::Identifier:
4998 return Import(FromName.getAsIdentifierInfo());
5000 case DeclarationName::ObjCZeroArgSelector:
5001 case DeclarationName::ObjCOneArgSelector:
5002 case DeclarationName::ObjCMultiArgSelector:
5003 return Import(FromName.getObjCSelector());
5005 case DeclarationName::CXXConstructorName: {
5006 QualType T = Import(FromName.getCXXNameType());
5008 return DeclarationName();
5010 return ToContext.DeclarationNames.getCXXConstructorName(
5011 ToContext.getCanonicalType(T));
5014 case DeclarationName::CXXDestructorName: {
5015 QualType T = Import(FromName.getCXXNameType());
5017 return DeclarationName();
5019 return ToContext.DeclarationNames.getCXXDestructorName(
5020 ToContext.getCanonicalType(T));
5023 case DeclarationName::CXXConversionFunctionName: {
5024 QualType T = Import(FromName.getCXXNameType());
5026 return DeclarationName();
5028 return ToContext.DeclarationNames.getCXXConversionFunctionName(
5029 ToContext.getCanonicalType(T));
5032 case DeclarationName::CXXOperatorName:
5033 return ToContext.DeclarationNames.getCXXOperatorName(
5034 FromName.getCXXOverloadedOperator());
5036 case DeclarationName::CXXLiteralOperatorName:
5037 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
5038 Import(FromName.getCXXLiteralIdentifier()));
5040 case DeclarationName::CXXUsingDirective:
5042 return DeclarationName::getUsingDirectiveName();
5045 llvm_unreachable("Invalid DeclarationName Kind!");
5048 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
5052 return &ToContext.Idents.get(FromId->getName());
5055 Selector ASTImporter::Import(Selector FromSel) {
5056 if (FromSel.isNull())
5059 SmallVector<IdentifierInfo *, 4> Idents;
5060 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
5061 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
5062 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
5063 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
5066 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
5070 unsigned NumDecls) {
5074 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
5075 if (LastDiagFromFrom)
5076 ToContext.getDiagnostics().notePriorDiagnosticFrom(
5077 FromContext.getDiagnostics());
5078 LastDiagFromFrom = false;
5079 return ToContext.getDiagnostics().Report(Loc, DiagID);
5082 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
5083 if (!LastDiagFromFrom)
5084 FromContext.getDiagnostics().notePriorDiagnosticFrom(
5085 ToContext.getDiagnostics());
5086 LastDiagFromFrom = true;
5087 return FromContext.getDiagnostics().Report(Loc, DiagID);
5090 void ASTImporter::CompleteDecl (Decl *D) {
5091 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
5092 if (!ID->getDefinition())
5093 ID->startDefinition();
5095 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
5096 if (!PD->getDefinition())
5097 PD->startDefinition();
5099 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
5100 if (!TD->getDefinition() && !TD->isBeingDefined()) {
5101 TD->startDefinition();
5102 TD->setCompleteDefinition(true);
5106 assert (0 && "CompleteDecl called on a Decl that can't be completed");
5110 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
5111 ImportedDecls[From] = To;
5115 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
5117 llvm::DenseMap<const Type *, const Type *>::iterator Pos
5118 = ImportedTypes.find(From.getTypePtr());
5119 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
5122 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
5124 return Ctx.IsStructurallyEquivalent(From, To);