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 QualType VisitAttributedType(const AttributedType *T);
71 // FIXME: TemplateTypeParmType
72 // FIXME: SubstTemplateTypeParmType
73 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
74 QualType VisitElaboratedType(const ElaboratedType *T);
75 // FIXME: DependentNameType
76 // FIXME: DependentTemplateSpecializationType
77 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
78 QualType VisitObjCObjectType(const ObjCObjectType *T);
79 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
81 // Importing declarations
82 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
83 DeclContext *&LexicalDC, DeclarationName &Name,
84 NamedDecl *&ToD, SourceLocation &Loc);
85 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
86 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
87 DeclarationNameInfo& To);
88 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
90 /// \brief What we should import from the definition.
91 enum ImportDefinitionKind {
92 /// \brief Import the default subset of the definition, which might be
93 /// nothing (if minimal import is set) or might be everything (if minimal
94 /// import is not set).
96 /// \brief Import everything.
98 /// \brief Import only the bare bones needed to establish a valid
103 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
104 return IDK == IDK_Everything ||
105 (IDK == IDK_Default && !Importer.isMinimalImport());
108 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
109 ImportDefinitionKind Kind = IDK_Default);
110 bool ImportDefinition(VarDecl *From, VarDecl *To,
111 ImportDefinitionKind Kind = IDK_Default);
112 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
113 ImportDefinitionKind Kind = IDK_Default);
114 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
115 ImportDefinitionKind Kind = IDK_Default);
116 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
117 ImportDefinitionKind Kind = IDK_Default);
118 TemplateParameterList *ImportTemplateParameterList(
119 TemplateParameterList *Params);
120 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
121 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
122 unsigned NumFromArgs,
123 SmallVectorImpl<TemplateArgument> &ToArgs);
124 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
125 bool Complain = true);
126 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
127 bool Complain = true);
128 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
129 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
130 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
131 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
132 Decl *VisitDecl(Decl *D);
133 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
134 Decl *VisitNamespaceDecl(NamespaceDecl *D);
135 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
136 Decl *VisitTypedefDecl(TypedefDecl *D);
137 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
138 Decl *VisitEnumDecl(EnumDecl *D);
139 Decl *VisitRecordDecl(RecordDecl *D);
140 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
141 Decl *VisitFunctionDecl(FunctionDecl *D);
142 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
143 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
144 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
145 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
146 Decl *VisitFieldDecl(FieldDecl *D);
147 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
148 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
149 Decl *VisitVarDecl(VarDecl *D);
150 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
151 Decl *VisitParmVarDecl(ParmVarDecl *D);
152 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
153 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
154 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
155 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
156 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
158 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
159 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
160 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
161 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
162 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
163 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
164 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
165 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
166 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
167 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
168 Decl *VisitClassTemplateSpecializationDecl(
169 ClassTemplateSpecializationDecl *D);
170 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
171 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
173 // Importing statements
174 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
176 Stmt *VisitStmt(Stmt *S);
177 Stmt *VisitDeclStmt(DeclStmt *S);
178 Stmt *VisitNullStmt(NullStmt *S);
179 Stmt *VisitCompoundStmt(CompoundStmt *S);
180 Stmt *VisitCaseStmt(CaseStmt *S);
181 Stmt *VisitDefaultStmt(DefaultStmt *S);
182 Stmt *VisitLabelStmt(LabelStmt *S);
183 Stmt *VisitAttributedStmt(AttributedStmt *S);
184 Stmt *VisitIfStmt(IfStmt *S);
185 Stmt *VisitSwitchStmt(SwitchStmt *S);
186 Stmt *VisitWhileStmt(WhileStmt *S);
187 Stmt *VisitDoStmt(DoStmt *S);
188 Stmt *VisitForStmt(ForStmt *S);
189 Stmt *VisitGotoStmt(GotoStmt *S);
190 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
191 Stmt *VisitContinueStmt(ContinueStmt *S);
192 Stmt *VisitBreakStmt(BreakStmt *S);
193 Stmt *VisitReturnStmt(ReturnStmt *S);
196 // FIXME: SEHExceptStmt
197 // FIXME: SEHFinallyStmt
199 // FIXME: SEHLeaveStmt
200 // FIXME: CapturedStmt
201 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
202 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
203 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
204 // FIXME: MSDependentExistsStmt
205 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
206 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
207 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
208 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
209 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
210 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
211 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
213 // Importing expressions
214 Expr *VisitExpr(Expr *E);
215 Expr *VisitDeclRefExpr(DeclRefExpr *E);
216 Expr *VisitIntegerLiteral(IntegerLiteral *E);
217 Expr *VisitCharacterLiteral(CharacterLiteral *E);
218 Expr *VisitParenExpr(ParenExpr *E);
219 Expr *VisitUnaryOperator(UnaryOperator *E);
220 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
221 Expr *VisitBinaryOperator(BinaryOperator *E);
222 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
223 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
224 Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
225 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
226 Expr *VisitMemberExpr(MemberExpr *E);
227 Expr *VisitCallExpr(CallExpr *E);
230 using namespace clang;
232 //----------------------------------------------------------------------------
233 // Structural Equivalence
234 //----------------------------------------------------------------------------
237 struct StructuralEquivalenceContext {
238 /// \brief AST contexts for which we are checking structural equivalence.
241 /// \brief The set of "tentative" equivalences between two canonical
242 /// declarations, mapping from a declaration in the first context to the
243 /// declaration in the second context that we believe to be equivalent.
244 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
246 /// \brief Queue of declarations in the first context whose equivalence
247 /// with a declaration in the second context still needs to be verified.
248 std::deque<Decl *> DeclsToCheck;
250 /// \brief Declaration (from, to) pairs that are known not to be equivalent
251 /// (which we have already complained about).
252 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
254 /// \brief Whether we're being strict about the spelling of types when
255 /// unifying two types.
256 bool StrictTypeSpelling;
258 /// \brief Whether to complain about failures.
261 /// \brief \c true if the last diagnostic came from C2.
264 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
265 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
266 bool StrictTypeSpelling = false,
267 bool Complain = true)
268 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
269 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
270 LastDiagFromC2(false) {}
272 /// \brief Determine whether the two declarations are structurally
274 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
276 /// \brief Determine whether the two types are structurally equivalent.
277 bool IsStructurallyEquivalent(QualType T1, QualType T2);
280 /// \brief Finish checking all of the structural equivalences.
282 /// \returns true if an error occurred, false otherwise.
286 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
287 assert(Complain && "Not allowed to complain");
289 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
290 LastDiagFromC2 = false;
291 return C1.getDiagnostics().Report(Loc, DiagID);
294 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
295 assert(Complain && "Not allowed to complain");
297 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
298 LastDiagFromC2 = true;
299 return C2.getDiagnostics().Report(Loc, DiagID);
304 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
305 QualType T1, QualType T2);
306 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
309 /// \brief Determine structural equivalence of two expressions.
310 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
311 Expr *E1, Expr *E2) {
315 // FIXME: Actually perform a structural comparison!
319 /// \brief Determine whether two identifiers are equivalent.
320 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
321 const IdentifierInfo *Name2) {
322 if (!Name1 || !Name2)
323 return Name1 == Name2;
325 return Name1->getName() == Name2->getName();
328 /// \brief Determine whether two nested-name-specifiers are equivalent.
329 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
330 NestedNameSpecifier *NNS1,
331 NestedNameSpecifier *NNS2) {
336 /// \brief Determine whether two template arguments are equivalent.
337 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
338 const TemplateArgument &Arg1,
339 const TemplateArgument &Arg2) {
340 if (Arg1.getKind() != Arg2.getKind())
343 switch (Arg1.getKind()) {
344 case TemplateArgument::Null:
347 case TemplateArgument::Type:
348 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
350 case TemplateArgument::Integral:
351 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
352 Arg2.getIntegralType()))
355 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
357 case TemplateArgument::Declaration:
358 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
360 case TemplateArgument::NullPtr:
361 return true; // FIXME: Is this correct?
363 case TemplateArgument::Template:
364 return IsStructurallyEquivalent(Context,
365 Arg1.getAsTemplate(),
366 Arg2.getAsTemplate());
368 case TemplateArgument::TemplateExpansion:
369 return IsStructurallyEquivalent(Context,
370 Arg1.getAsTemplateOrTemplatePattern(),
371 Arg2.getAsTemplateOrTemplatePattern());
373 case TemplateArgument::Expression:
374 return IsStructurallyEquivalent(Context,
375 Arg1.getAsExpr(), Arg2.getAsExpr());
377 case TemplateArgument::Pack:
378 if (Arg1.pack_size() != Arg2.pack_size())
381 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
382 if (!IsStructurallyEquivalent(Context,
383 Arg1.pack_begin()[I],
384 Arg2.pack_begin()[I]))
390 llvm_unreachable("Invalid template argument kind");
393 /// \brief Determine structural equivalence for the common part of array
395 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
396 const ArrayType *Array1,
397 const ArrayType *Array2) {
398 if (!IsStructurallyEquivalent(Context,
399 Array1->getElementType(),
400 Array2->getElementType()))
402 if (Array1->getSizeModifier() != Array2->getSizeModifier())
404 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
410 /// \brief Determine structural equivalence of two types.
411 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
412 QualType T1, QualType T2) {
413 if (T1.isNull() || T2.isNull())
414 return T1.isNull() && T2.isNull();
416 if (!Context.StrictTypeSpelling) {
417 // We aren't being strict about token-to-token equivalence of types,
418 // so map down to the canonical type.
419 T1 = Context.C1.getCanonicalType(T1);
420 T2 = Context.C2.getCanonicalType(T2);
423 if (T1.getQualifiers() != T2.getQualifiers())
426 Type::TypeClass TC = T1->getTypeClass();
428 if (T1->getTypeClass() != T2->getTypeClass()) {
429 // Compare function types with prototypes vs. without prototypes as if
430 // both did not have prototypes.
431 if (T1->getTypeClass() == Type::FunctionProto &&
432 T2->getTypeClass() == Type::FunctionNoProto)
433 TC = Type::FunctionNoProto;
434 else if (T1->getTypeClass() == Type::FunctionNoProto &&
435 T2->getTypeClass() == Type::FunctionProto)
436 TC = Type::FunctionNoProto;
443 // FIXME: Deal with Char_S/Char_U.
444 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
449 if (!IsStructurallyEquivalent(Context,
450 cast<ComplexType>(T1)->getElementType(),
451 cast<ComplexType>(T2)->getElementType()))
457 if (!IsStructurallyEquivalent(Context,
458 cast<AdjustedType>(T1)->getOriginalType(),
459 cast<AdjustedType>(T2)->getOriginalType()))
464 if (!IsStructurallyEquivalent(Context,
465 cast<PointerType>(T1)->getPointeeType(),
466 cast<PointerType>(T2)->getPointeeType()))
470 case Type::BlockPointer:
471 if (!IsStructurallyEquivalent(Context,
472 cast<BlockPointerType>(T1)->getPointeeType(),
473 cast<BlockPointerType>(T2)->getPointeeType()))
477 case Type::LValueReference:
478 case Type::RValueReference: {
479 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
480 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
481 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
483 if (Ref1->isInnerRef() != Ref2->isInnerRef())
485 if (!IsStructurallyEquivalent(Context,
486 Ref1->getPointeeTypeAsWritten(),
487 Ref2->getPointeeTypeAsWritten()))
492 case Type::MemberPointer: {
493 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
494 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
495 if (!IsStructurallyEquivalent(Context,
496 MemPtr1->getPointeeType(),
497 MemPtr2->getPointeeType()))
499 if (!IsStructurallyEquivalent(Context,
500 QualType(MemPtr1->getClass(), 0),
501 QualType(MemPtr2->getClass(), 0)))
506 case Type::ConstantArray: {
507 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
508 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
509 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
512 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
517 case Type::IncompleteArray:
518 if (!IsArrayStructurallyEquivalent(Context,
520 cast<ArrayType>(T2)))
524 case Type::VariableArray: {
525 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
526 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
527 if (!IsStructurallyEquivalent(Context,
528 Array1->getSizeExpr(), Array2->getSizeExpr()))
531 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
537 case Type::DependentSizedArray: {
538 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
539 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
540 if (!IsStructurallyEquivalent(Context,
541 Array1->getSizeExpr(), Array2->getSizeExpr()))
544 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
550 case Type::DependentSizedExtVector: {
551 const DependentSizedExtVectorType *Vec1
552 = cast<DependentSizedExtVectorType>(T1);
553 const DependentSizedExtVectorType *Vec2
554 = cast<DependentSizedExtVectorType>(T2);
555 if (!IsStructurallyEquivalent(Context,
556 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
558 if (!IsStructurallyEquivalent(Context,
559 Vec1->getElementType(),
560 Vec2->getElementType()))
566 case Type::ExtVector: {
567 const VectorType *Vec1 = cast<VectorType>(T1);
568 const VectorType *Vec2 = cast<VectorType>(T2);
569 if (!IsStructurallyEquivalent(Context,
570 Vec1->getElementType(),
571 Vec2->getElementType()))
573 if (Vec1->getNumElements() != Vec2->getNumElements())
575 if (Vec1->getVectorKind() != Vec2->getVectorKind())
580 case Type::FunctionProto: {
581 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
582 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
583 if (Proto1->getNumParams() != Proto2->getNumParams())
585 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
586 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
587 Proto2->getParamType(I)))
590 if (Proto1->isVariadic() != Proto2->isVariadic())
592 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
594 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
595 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
597 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
598 if (!IsStructurallyEquivalent(Context,
599 Proto1->getExceptionType(I),
600 Proto2->getExceptionType(I)))
603 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
604 if (!IsStructurallyEquivalent(Context,
605 Proto1->getNoexceptExpr(),
606 Proto2->getNoexceptExpr()))
609 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
612 // Fall through to check the bits common with FunctionNoProtoType.
615 case Type::FunctionNoProto: {
616 const FunctionType *Function1 = cast<FunctionType>(T1);
617 const FunctionType *Function2 = cast<FunctionType>(T2);
618 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
619 Function2->getReturnType()))
621 if (Function1->getExtInfo() != Function2->getExtInfo())
626 case Type::UnresolvedUsing:
627 if (!IsStructurallyEquivalent(Context,
628 cast<UnresolvedUsingType>(T1)->getDecl(),
629 cast<UnresolvedUsingType>(T2)->getDecl()))
634 case Type::Attributed:
635 if (!IsStructurallyEquivalent(Context,
636 cast<AttributedType>(T1)->getModifiedType(),
637 cast<AttributedType>(T2)->getModifiedType()))
639 if (!IsStructurallyEquivalent(Context,
640 cast<AttributedType>(T1)->getEquivalentType(),
641 cast<AttributedType>(T2)->getEquivalentType()))
646 if (!IsStructurallyEquivalent(Context,
647 cast<ParenType>(T1)->getInnerType(),
648 cast<ParenType>(T2)->getInnerType()))
653 if (!IsStructurallyEquivalent(Context,
654 cast<TypedefType>(T1)->getDecl(),
655 cast<TypedefType>(T2)->getDecl()))
659 case Type::TypeOfExpr:
660 if (!IsStructurallyEquivalent(Context,
661 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
662 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
667 if (!IsStructurallyEquivalent(Context,
668 cast<TypeOfType>(T1)->getUnderlyingType(),
669 cast<TypeOfType>(T2)->getUnderlyingType()))
673 case Type::UnaryTransform:
674 if (!IsStructurallyEquivalent(Context,
675 cast<UnaryTransformType>(T1)->getUnderlyingType(),
676 cast<UnaryTransformType>(T1)->getUnderlyingType()))
681 if (!IsStructurallyEquivalent(Context,
682 cast<DecltypeType>(T1)->getUnderlyingExpr(),
683 cast<DecltypeType>(T2)->getUnderlyingExpr()))
688 if (!IsStructurallyEquivalent(Context,
689 cast<AutoType>(T1)->getDeducedType(),
690 cast<AutoType>(T2)->getDeducedType()))
696 if (!IsStructurallyEquivalent(Context,
697 cast<TagType>(T1)->getDecl(),
698 cast<TagType>(T2)->getDecl()))
702 case Type::TemplateTypeParm: {
703 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
704 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
705 if (Parm1->getDepth() != Parm2->getDepth())
707 if (Parm1->getIndex() != Parm2->getIndex())
709 if (Parm1->isParameterPack() != Parm2->isParameterPack())
712 // Names of template type parameters are never significant.
716 case Type::SubstTemplateTypeParm: {
717 const SubstTemplateTypeParmType *Subst1
718 = cast<SubstTemplateTypeParmType>(T1);
719 const SubstTemplateTypeParmType *Subst2
720 = cast<SubstTemplateTypeParmType>(T2);
721 if (!IsStructurallyEquivalent(Context,
722 QualType(Subst1->getReplacedParameter(), 0),
723 QualType(Subst2->getReplacedParameter(), 0)))
725 if (!IsStructurallyEquivalent(Context,
726 Subst1->getReplacementType(),
727 Subst2->getReplacementType()))
732 case Type::SubstTemplateTypeParmPack: {
733 const SubstTemplateTypeParmPackType *Subst1
734 = cast<SubstTemplateTypeParmPackType>(T1);
735 const SubstTemplateTypeParmPackType *Subst2
736 = cast<SubstTemplateTypeParmPackType>(T2);
737 if (!IsStructurallyEquivalent(Context,
738 QualType(Subst1->getReplacedParameter(), 0),
739 QualType(Subst2->getReplacedParameter(), 0)))
741 if (!IsStructurallyEquivalent(Context,
742 Subst1->getArgumentPack(),
743 Subst2->getArgumentPack()))
747 case Type::TemplateSpecialization: {
748 const TemplateSpecializationType *Spec1
749 = cast<TemplateSpecializationType>(T1);
750 const TemplateSpecializationType *Spec2
751 = cast<TemplateSpecializationType>(T2);
752 if (!IsStructurallyEquivalent(Context,
753 Spec1->getTemplateName(),
754 Spec2->getTemplateName()))
756 if (Spec1->getNumArgs() != Spec2->getNumArgs())
758 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
759 if (!IsStructurallyEquivalent(Context,
760 Spec1->getArg(I), Spec2->getArg(I)))
766 case Type::Elaborated: {
767 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
768 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
769 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
770 if (Elab1->getKeyword() != Elab2->getKeyword())
772 if (!IsStructurallyEquivalent(Context,
773 Elab1->getQualifier(),
774 Elab2->getQualifier()))
776 if (!IsStructurallyEquivalent(Context,
777 Elab1->getNamedType(),
778 Elab2->getNamedType()))
783 case Type::InjectedClassName: {
784 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
785 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
786 if (!IsStructurallyEquivalent(Context,
787 Inj1->getInjectedSpecializationType(),
788 Inj2->getInjectedSpecializationType()))
793 case Type::DependentName: {
794 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
795 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
796 if (!IsStructurallyEquivalent(Context,
797 Typename1->getQualifier(),
798 Typename2->getQualifier()))
800 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
801 Typename2->getIdentifier()))
807 case Type::DependentTemplateSpecialization: {
808 const DependentTemplateSpecializationType *Spec1 =
809 cast<DependentTemplateSpecializationType>(T1);
810 const DependentTemplateSpecializationType *Spec2 =
811 cast<DependentTemplateSpecializationType>(T2);
812 if (!IsStructurallyEquivalent(Context,
813 Spec1->getQualifier(),
814 Spec2->getQualifier()))
816 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
817 Spec2->getIdentifier()))
819 if (Spec1->getNumArgs() != Spec2->getNumArgs())
821 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
822 if (!IsStructurallyEquivalent(Context,
823 Spec1->getArg(I), Spec2->getArg(I)))
829 case Type::PackExpansion:
830 if (!IsStructurallyEquivalent(Context,
831 cast<PackExpansionType>(T1)->getPattern(),
832 cast<PackExpansionType>(T2)->getPattern()))
836 case Type::ObjCInterface: {
837 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
838 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
839 if (!IsStructurallyEquivalent(Context,
840 Iface1->getDecl(), Iface2->getDecl()))
845 case Type::ObjCObject: {
846 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
847 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
848 if (!IsStructurallyEquivalent(Context,
850 Obj2->getBaseType()))
852 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
854 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
855 if (!IsStructurallyEquivalent(Context,
856 Obj1->getProtocol(I),
857 Obj2->getProtocol(I)))
863 case Type::ObjCObjectPointer: {
864 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
865 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
866 if (!IsStructurallyEquivalent(Context,
867 Ptr1->getPointeeType(),
868 Ptr2->getPointeeType()))
874 if (!IsStructurallyEquivalent(Context,
875 cast<AtomicType>(T1)->getValueType(),
876 cast<AtomicType>(T2)->getValueType()))
886 /// \brief Determine structural equivalence of two fields.
887 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
888 FieldDecl *Field1, FieldDecl *Field2) {
889 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
891 // For anonymous structs/unions, match up the anonymous struct/union type
892 // declarations directly, so that we don't go off searching for anonymous
894 if (Field1->isAnonymousStructOrUnion() &&
895 Field2->isAnonymousStructOrUnion()) {
896 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
897 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
898 return IsStructurallyEquivalent(Context, D1, D2);
901 // Check for equivalent field names.
902 IdentifierInfo *Name1 = Field1->getIdentifier();
903 IdentifierInfo *Name2 = Field2->getIdentifier();
904 if (!::IsStructurallyEquivalent(Name1, Name2))
907 if (!IsStructurallyEquivalent(Context,
908 Field1->getType(), Field2->getType())) {
909 if (Context.Complain) {
910 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
911 << Context.C2.getTypeDeclType(Owner2);
912 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
913 << Field2->getDeclName() << Field2->getType();
914 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
915 << Field1->getDeclName() << Field1->getType();
920 if (Field1->isBitField() != Field2->isBitField()) {
921 if (Context.Complain) {
922 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
923 << Context.C2.getTypeDeclType(Owner2);
924 if (Field1->isBitField()) {
925 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
926 << Field1->getDeclName() << Field1->getType()
927 << Field1->getBitWidthValue(Context.C1);
928 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
929 << Field2->getDeclName();
931 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
932 << Field2->getDeclName() << Field2->getType()
933 << Field2->getBitWidthValue(Context.C2);
934 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
935 << Field1->getDeclName();
941 if (Field1->isBitField()) {
942 // Make sure that the bit-fields are the same length.
943 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
944 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
946 if (Bits1 != Bits2) {
947 if (Context.Complain) {
948 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
949 << Context.C2.getTypeDeclType(Owner2);
950 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
951 << Field2->getDeclName() << Field2->getType() << Bits2;
952 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
953 << Field1->getDeclName() << Field1->getType() << Bits1;
962 /// \brief Find the index of the given anonymous struct/union within its
965 /// \returns Returns the index of this anonymous struct/union in its context,
966 /// including the next assigned index (if none of them match). Returns an
967 /// empty option if the context is not a record, i.e.. if the anonymous
968 /// struct/union is at namespace or block scope.
969 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
970 ASTContext &Context = Anon->getASTContext();
971 QualType AnonTy = Context.getRecordType(Anon);
973 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
978 for (const auto *D : Owner->noload_decls()) {
979 const auto *F = dyn_cast<FieldDecl>(D);
980 if (!F || !F->isAnonymousStructOrUnion())
983 if (Context.hasSameType(F->getType(), AnonTy))
992 /// \brief Determine structural equivalence of two records.
993 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
994 RecordDecl *D1, RecordDecl *D2) {
995 if (D1->isUnion() != D2->isUnion()) {
996 if (Context.Complain) {
997 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
998 << Context.C2.getTypeDeclType(D2);
999 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
1000 << D1->getDeclName() << (unsigned)D1->getTagKind();
1005 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
1006 // If both anonymous structs/unions are in a record context, make sure
1007 // they occur in the same location in the context records.
1008 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
1009 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
1010 if (*Index1 != *Index2)
1016 // If both declarations are class template specializations, we know
1017 // the ODR applies, so check the template and template arguments.
1018 ClassTemplateSpecializationDecl *Spec1
1019 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
1020 ClassTemplateSpecializationDecl *Spec2
1021 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
1022 if (Spec1 && Spec2) {
1023 // Check that the specialized templates are the same.
1024 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
1025 Spec2->getSpecializedTemplate()))
1028 // Check that the template arguments are the same.
1029 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
1032 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
1033 if (!IsStructurallyEquivalent(Context,
1034 Spec1->getTemplateArgs().get(I),
1035 Spec2->getTemplateArgs().get(I)))
1038 // If one is a class template specialization and the other is not, these
1039 // structures are different.
1040 else if (Spec1 || Spec2)
1043 // Compare the definitions of these two records. If either or both are
1044 // incomplete, we assume that they are equivalent.
1045 D1 = D1->getDefinition();
1046 D2 = D2->getDefinition();
1050 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1051 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1052 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1053 if (Context.Complain) {
1054 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1055 << Context.C2.getTypeDeclType(D2);
1056 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1057 << D2CXX->getNumBases();
1058 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1059 << D1CXX->getNumBases();
1064 // Check the base classes.
1065 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1066 BaseEnd1 = D1CXX->bases_end(),
1067 Base2 = D2CXX->bases_begin();
1070 if (!IsStructurallyEquivalent(Context,
1071 Base1->getType(), Base2->getType())) {
1072 if (Context.Complain) {
1073 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1074 << Context.C2.getTypeDeclType(D2);
1075 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1077 << Base2->getSourceRange();
1078 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1080 << Base1->getSourceRange();
1085 // Check virtual vs. non-virtual inheritance mismatch.
1086 if (Base1->isVirtual() != Base2->isVirtual()) {
1087 if (Context.Complain) {
1088 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1089 << Context.C2.getTypeDeclType(D2);
1090 Context.Diag2(Base2->getLocStart(),
1091 diag::note_odr_virtual_base)
1092 << Base2->isVirtual() << Base2->getSourceRange();
1093 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1094 << Base1->isVirtual()
1095 << Base1->getSourceRange();
1100 } else if (D1CXX->getNumBases() > 0) {
1101 if (Context.Complain) {
1102 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1103 << Context.C2.getTypeDeclType(D2);
1104 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1105 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1107 << Base1->getSourceRange();
1108 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1114 // Check the fields for consistency.
1115 RecordDecl::field_iterator Field2 = D2->field_begin(),
1116 Field2End = D2->field_end();
1117 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1118 Field1End = D1->field_end();
1119 Field1 != Field1End;
1120 ++Field1, ++Field2) {
1121 if (Field2 == Field2End) {
1122 if (Context.Complain) {
1123 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1124 << Context.C2.getTypeDeclType(D2);
1125 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1126 << Field1->getDeclName() << Field1->getType();
1127 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1132 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1136 if (Field2 != Field2End) {
1137 if (Context.Complain) {
1138 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1139 << Context.C2.getTypeDeclType(D2);
1140 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1141 << Field2->getDeclName() << Field2->getType();
1142 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1150 /// \brief Determine structural equivalence of two enums.
1151 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1152 EnumDecl *D1, EnumDecl *D2) {
1153 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1154 EC2End = D2->enumerator_end();
1155 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1156 EC1End = D1->enumerator_end();
1157 EC1 != EC1End; ++EC1, ++EC2) {
1158 if (EC2 == EC2End) {
1159 if (Context.Complain) {
1160 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1161 << Context.C2.getTypeDeclType(D2);
1162 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1163 << EC1->getDeclName()
1164 << EC1->getInitVal().toString(10);
1165 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1170 llvm::APSInt Val1 = EC1->getInitVal();
1171 llvm::APSInt Val2 = EC2->getInitVal();
1172 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1173 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1174 if (Context.Complain) {
1175 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1176 << Context.C2.getTypeDeclType(D2);
1177 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1178 << EC2->getDeclName()
1179 << EC2->getInitVal().toString(10);
1180 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1181 << EC1->getDeclName()
1182 << EC1->getInitVal().toString(10);
1188 if (EC2 != EC2End) {
1189 if (Context.Complain) {
1190 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1191 << Context.C2.getTypeDeclType(D2);
1192 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1193 << EC2->getDeclName()
1194 << EC2->getInitVal().toString(10);
1195 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1203 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1204 TemplateParameterList *Params1,
1205 TemplateParameterList *Params2) {
1206 if (Params1->size() != Params2->size()) {
1207 if (Context.Complain) {
1208 Context.Diag2(Params2->getTemplateLoc(),
1209 diag::err_odr_different_num_template_parameters)
1210 << Params1->size() << Params2->size();
1211 Context.Diag1(Params1->getTemplateLoc(),
1212 diag::note_odr_template_parameter_list);
1217 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1218 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1219 if (Context.Complain) {
1220 Context.Diag2(Params2->getParam(I)->getLocation(),
1221 diag::err_odr_different_template_parameter_kind);
1222 Context.Diag1(Params1->getParam(I)->getLocation(),
1223 diag::note_odr_template_parameter_here);
1228 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1229 Params2->getParam(I))) {
1238 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1239 TemplateTypeParmDecl *D1,
1240 TemplateTypeParmDecl *D2) {
1241 if (D1->isParameterPack() != D2->isParameterPack()) {
1242 if (Context.Complain) {
1243 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1244 << D2->isParameterPack();
1245 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1246 << D1->isParameterPack();
1254 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1255 NonTypeTemplateParmDecl *D1,
1256 NonTypeTemplateParmDecl *D2) {
1257 if (D1->isParameterPack() != D2->isParameterPack()) {
1258 if (Context.Complain) {
1259 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1260 << D2->isParameterPack();
1261 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1262 << D1->isParameterPack();
1268 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1269 if (Context.Complain) {
1270 Context.Diag2(D2->getLocation(),
1271 diag::err_odr_non_type_parameter_type_inconsistent)
1272 << D2->getType() << D1->getType();
1273 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1282 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1283 TemplateTemplateParmDecl *D1,
1284 TemplateTemplateParmDecl *D2) {
1285 if (D1->isParameterPack() != D2->isParameterPack()) {
1286 if (Context.Complain) {
1287 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1288 << D2->isParameterPack();
1289 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1290 << D1->isParameterPack();
1295 // Check template parameter lists.
1296 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1297 D2->getTemplateParameters());
1300 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1301 ClassTemplateDecl *D1,
1302 ClassTemplateDecl *D2) {
1303 // Check template parameters.
1304 if (!IsStructurallyEquivalent(Context,
1305 D1->getTemplateParameters(),
1306 D2->getTemplateParameters()))
1309 // Check the templated declaration.
1310 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1311 D2->getTemplatedDecl());
1314 /// \brief Determine structural equivalence of two declarations.
1315 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1316 Decl *D1, Decl *D2) {
1317 // FIXME: Check for known structural equivalences via a callback of some sort.
1319 // Check whether we already know that these two declarations are not
1320 // structurally equivalent.
1321 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1322 D2->getCanonicalDecl())))
1325 // Determine whether we've already produced a tentative equivalence for D1.
1326 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1328 return EquivToD1 == D2->getCanonicalDecl();
1330 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1331 EquivToD1 = D2->getCanonicalDecl();
1332 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1336 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1338 if (!::IsStructurallyEquivalent(*this, D1, D2))
1344 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1346 if (!::IsStructurallyEquivalent(*this, T1, T2))
1352 bool StructuralEquivalenceContext::Finish() {
1353 while (!DeclsToCheck.empty()) {
1354 // Check the next declaration.
1355 Decl *D1 = DeclsToCheck.front();
1356 DeclsToCheck.pop_front();
1358 Decl *D2 = TentativeEquivalences[D1];
1359 assert(D2 && "Unrecorded tentative equivalence?");
1361 bool Equivalent = true;
1363 // FIXME: Switch on all declaration kinds. For now, we're just going to
1364 // check the obvious ones.
1365 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1366 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1367 // Check for equivalent structure names.
1368 IdentifierInfo *Name1 = Record1->getIdentifier();
1369 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1370 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1371 IdentifierInfo *Name2 = Record2->getIdentifier();
1372 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1373 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1374 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1375 !::IsStructurallyEquivalent(*this, Record1, Record2))
1378 // Record/non-record mismatch.
1381 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1382 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1383 // Check for equivalent enum names.
1384 IdentifierInfo *Name1 = Enum1->getIdentifier();
1385 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1386 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1387 IdentifierInfo *Name2 = Enum2->getIdentifier();
1388 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1389 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1390 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1391 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1394 // Enum/non-enum mismatch
1397 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1398 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1399 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1400 Typedef2->getIdentifier()) ||
1401 !::IsStructurallyEquivalent(*this,
1402 Typedef1->getUnderlyingType(),
1403 Typedef2->getUnderlyingType()))
1406 // Typedef/non-typedef mismatch.
1409 } else if (ClassTemplateDecl *ClassTemplate1
1410 = dyn_cast<ClassTemplateDecl>(D1)) {
1411 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1412 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1413 ClassTemplate2->getIdentifier()) ||
1414 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1417 // Class template/non-class-template mismatch.
1420 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1421 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1422 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1428 } else if (NonTypeTemplateParmDecl *NTTP1
1429 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1430 if (NonTypeTemplateParmDecl *NTTP2
1431 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1432 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1438 } else if (TemplateTemplateParmDecl *TTP1
1439 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1440 if (TemplateTemplateParmDecl *TTP2
1441 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1442 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1451 // Note that these two declarations are not equivalent (and we already
1453 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1454 D2->getCanonicalDecl()));
1457 // FIXME: Check other declaration kinds!
1463 //----------------------------------------------------------------------------
1465 //----------------------------------------------------------------------------
1467 QualType ASTNodeImporter::VisitType(const Type *T) {
1468 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1469 << T->getTypeClassName();
1473 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1474 switch (T->getKind()) {
1475 #define SHARED_SINGLETON_TYPE(Expansion)
1476 #define BUILTIN_TYPE(Id, SingletonId) \
1477 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1478 #include "clang/AST/BuiltinTypes.def"
1480 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1481 // context supports C++.
1483 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1484 // context supports ObjC.
1486 case BuiltinType::Char_U:
1487 // The context we're importing from has an unsigned 'char'. If we're
1488 // importing into a context with a signed 'char', translate to
1489 // 'unsigned char' instead.
1490 if (Importer.getToContext().getLangOpts().CharIsSigned)
1491 return Importer.getToContext().UnsignedCharTy;
1493 return Importer.getToContext().CharTy;
1495 case BuiltinType::Char_S:
1496 // The context we're importing from has an unsigned 'char'. If we're
1497 // importing into a context with a signed 'char', translate to
1498 // 'unsigned char' instead.
1499 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1500 return Importer.getToContext().SignedCharTy;
1502 return Importer.getToContext().CharTy;
1504 case BuiltinType::WChar_S:
1505 case BuiltinType::WChar_U:
1506 // FIXME: If not in C++, shall we translate to the C equivalent of
1508 return Importer.getToContext().WCharTy;
1511 llvm_unreachable("Invalid BuiltinType Kind!");
1514 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1515 QualType ToElementType = Importer.Import(T->getElementType());
1516 if (ToElementType.isNull())
1519 return Importer.getToContext().getComplexType(ToElementType);
1522 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1523 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1524 if (ToPointeeType.isNull())
1527 return Importer.getToContext().getPointerType(ToPointeeType);
1530 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1531 // FIXME: Check for blocks support in "to" context.
1532 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1533 if (ToPointeeType.isNull())
1536 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1540 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1541 // FIXME: Check for C++ support in "to" context.
1542 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1543 if (ToPointeeType.isNull())
1546 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1550 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1551 // FIXME: Check for C++0x support in "to" context.
1552 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1553 if (ToPointeeType.isNull())
1556 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1559 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1560 // FIXME: Check for C++ support in "to" context.
1561 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1562 if (ToPointeeType.isNull())
1565 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1566 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1567 ClassType.getTypePtr());
1570 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1571 QualType ToElementType = Importer.Import(T->getElementType());
1572 if (ToElementType.isNull())
1575 return Importer.getToContext().getConstantArrayType(ToElementType,
1577 T->getSizeModifier(),
1578 T->getIndexTypeCVRQualifiers());
1582 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1583 QualType ToElementType = Importer.Import(T->getElementType());
1584 if (ToElementType.isNull())
1587 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1588 T->getSizeModifier(),
1589 T->getIndexTypeCVRQualifiers());
1592 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1593 QualType ToElementType = Importer.Import(T->getElementType());
1594 if (ToElementType.isNull())
1597 Expr *Size = Importer.Import(T->getSizeExpr());
1601 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1602 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1603 T->getSizeModifier(),
1604 T->getIndexTypeCVRQualifiers(),
1608 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1609 QualType ToElementType = Importer.Import(T->getElementType());
1610 if (ToElementType.isNull())
1613 return Importer.getToContext().getVectorType(ToElementType,
1614 T->getNumElements(),
1615 T->getVectorKind());
1618 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1619 QualType ToElementType = Importer.Import(T->getElementType());
1620 if (ToElementType.isNull())
1623 return Importer.getToContext().getExtVectorType(ToElementType,
1624 T->getNumElements());
1628 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1629 // FIXME: What happens if we're importing a function without a prototype
1630 // into C++? Should we make it variadic?
1631 QualType ToResultType = Importer.Import(T->getReturnType());
1632 if (ToResultType.isNull())
1635 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1639 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1640 QualType ToResultType = Importer.Import(T->getReturnType());
1641 if (ToResultType.isNull())
1644 // Import argument types
1645 SmallVector<QualType, 4> ArgTypes;
1646 for (const auto &A : T->param_types()) {
1647 QualType ArgType = Importer.Import(A);
1648 if (ArgType.isNull())
1650 ArgTypes.push_back(ArgType);
1653 // Import exception types
1654 SmallVector<QualType, 4> ExceptionTypes;
1655 for (const auto &E : T->exceptions()) {
1656 QualType ExceptionType = Importer.Import(E);
1657 if (ExceptionType.isNull())
1659 ExceptionTypes.push_back(ExceptionType);
1662 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1663 FunctionProtoType::ExtProtoInfo ToEPI;
1665 ToEPI.ExtInfo = FromEPI.ExtInfo;
1666 ToEPI.Variadic = FromEPI.Variadic;
1667 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1668 ToEPI.TypeQuals = FromEPI.TypeQuals;
1669 ToEPI.RefQualifier = FromEPI.RefQualifier;
1670 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1671 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1672 ToEPI.ExceptionSpec.NoexceptExpr =
1673 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1674 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1675 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1676 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1677 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1679 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1682 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1683 QualType ToInnerType = Importer.Import(T->getInnerType());
1684 if (ToInnerType.isNull())
1687 return Importer.getToContext().getParenType(ToInnerType);
1690 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1691 TypedefNameDecl *ToDecl
1692 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1696 return Importer.getToContext().getTypeDeclType(ToDecl);
1699 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1700 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1704 return Importer.getToContext().getTypeOfExprType(ToExpr);
1707 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1708 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1709 if (ToUnderlyingType.isNull())
1712 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1715 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1716 // FIXME: Make sure that the "to" context supports C++0x!
1717 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1721 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1722 if (UnderlyingType.isNull())
1725 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1728 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1729 QualType ToBaseType = Importer.Import(T->getBaseType());
1730 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1731 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1734 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1739 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1740 // FIXME: Make sure that the "to" context supports C++11!
1741 QualType FromDeduced = T->getDeducedType();
1743 if (!FromDeduced.isNull()) {
1744 ToDeduced = Importer.Import(FromDeduced);
1745 if (ToDeduced.isNull())
1749 return Importer.getToContext().getAutoType(ToDeduced, T->isDecltypeAuto(),
1750 /*IsDependent*/false);
1753 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1755 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1759 return Importer.getToContext().getTagDeclType(ToDecl);
1762 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1764 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1768 return Importer.getToContext().getTagDeclType(ToDecl);
1771 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1772 QualType FromModifiedType = T->getModifiedType();
1773 QualType FromEquivalentType = T->getEquivalentType();
1774 QualType ToModifiedType;
1775 QualType ToEquivalentType;
1777 if (!FromModifiedType.isNull()) {
1778 ToModifiedType = Importer.Import(FromModifiedType);
1779 if (ToModifiedType.isNull())
1782 if (!FromEquivalentType.isNull()) {
1783 ToEquivalentType = Importer.Import(FromEquivalentType);
1784 if (ToEquivalentType.isNull())
1788 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1789 ToModifiedType, ToEquivalentType);
1792 QualType ASTNodeImporter::VisitTemplateSpecializationType(
1793 const TemplateSpecializationType *T) {
1794 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1795 if (ToTemplate.isNull())
1798 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1799 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1802 QualType ToCanonType;
1803 if (!QualType(T, 0).isCanonical()) {
1804 QualType FromCanonType
1805 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1806 ToCanonType =Importer.Import(FromCanonType);
1807 if (ToCanonType.isNull())
1810 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1811 ToTemplateArgs.data(),
1812 ToTemplateArgs.size(),
1816 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1817 NestedNameSpecifier *ToQualifier = nullptr;
1818 // Note: the qualifier in an ElaboratedType is optional.
1819 if (T->getQualifier()) {
1820 ToQualifier = Importer.Import(T->getQualifier());
1825 QualType ToNamedType = Importer.Import(T->getNamedType());
1826 if (ToNamedType.isNull())
1829 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1830 ToQualifier, ToNamedType);
1833 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1834 ObjCInterfaceDecl *Class
1835 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1839 return Importer.getToContext().getObjCInterfaceType(Class);
1842 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1843 QualType ToBaseType = Importer.Import(T->getBaseType());
1844 if (ToBaseType.isNull())
1847 SmallVector<QualType, 4> TypeArgs;
1848 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1849 QualType ImportedTypeArg = Importer.Import(TypeArg);
1850 if (ImportedTypeArg.isNull())
1853 TypeArgs.push_back(ImportedTypeArg);
1856 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1857 for (auto *P : T->quals()) {
1858 ObjCProtocolDecl *Protocol
1859 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1862 Protocols.push_back(Protocol);
1865 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1867 T->isKindOfTypeAsWritten());
1871 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1872 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1873 if (ToPointeeType.isNull())
1876 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1879 //----------------------------------------------------------------------------
1880 // Import Declarations
1881 //----------------------------------------------------------------------------
1882 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1883 DeclContext *&LexicalDC,
1884 DeclarationName &Name,
1886 SourceLocation &Loc) {
1887 // Import the context of this declaration.
1888 DC = Importer.ImportContext(D->getDeclContext());
1893 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1894 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1899 // Import the name of this declaration.
1900 Name = Importer.Import(D->getDeclName());
1901 if (D->getDeclName() && !Name)
1904 // Import the location of this declaration.
1905 Loc = Importer.Import(D->getLocation());
1906 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1910 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1915 ToD = Importer.Import(FromD);
1920 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1921 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1922 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1923 ImportDefinition(FromRecord, ToRecord);
1929 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1930 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1931 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1932 ImportDefinition(FromEnum, ToEnum);
1940 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1941 DeclarationNameInfo& To) {
1942 // NOTE: To.Name and To.Loc are already imported.
1943 // We only have to import To.LocInfo.
1944 switch (To.getName().getNameKind()) {
1945 case DeclarationName::Identifier:
1946 case DeclarationName::ObjCZeroArgSelector:
1947 case DeclarationName::ObjCOneArgSelector:
1948 case DeclarationName::ObjCMultiArgSelector:
1949 case DeclarationName::CXXUsingDirective:
1952 case DeclarationName::CXXOperatorName: {
1953 SourceRange Range = From.getCXXOperatorNameRange();
1954 To.setCXXOperatorNameRange(Importer.Import(Range));
1957 case DeclarationName::CXXLiteralOperatorName: {
1958 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1959 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1962 case DeclarationName::CXXConstructorName:
1963 case DeclarationName::CXXDestructorName:
1964 case DeclarationName::CXXConversionFunctionName: {
1965 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1966 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1970 llvm_unreachable("Unknown name kind.");
1973 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1974 if (Importer.isMinimalImport() && !ForceImport) {
1975 Importer.ImportContext(FromDC);
1979 for (auto *From : FromDC->decls())
1980 Importer.Import(From);
1983 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1984 ImportDefinitionKind Kind) {
1985 if (To->getDefinition() || To->isBeingDefined()) {
1986 if (Kind == IDK_Everything)
1987 ImportDeclContext(From, /*ForceImport=*/true);
1992 To->startDefinition();
1994 // Add base classes.
1995 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1996 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
1998 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1999 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2000 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
2001 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
2002 ToData.Aggregate = FromData.Aggregate;
2003 ToData.PlainOldData = FromData.PlainOldData;
2004 ToData.Empty = FromData.Empty;
2005 ToData.Polymorphic = FromData.Polymorphic;
2006 ToData.Abstract = FromData.Abstract;
2007 ToData.IsStandardLayout = FromData.IsStandardLayout;
2008 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
2009 ToData.HasPrivateFields = FromData.HasPrivateFields;
2010 ToData.HasProtectedFields = FromData.HasProtectedFields;
2011 ToData.HasPublicFields = FromData.HasPublicFields;
2012 ToData.HasMutableFields = FromData.HasMutableFields;
2013 ToData.HasVariantMembers = FromData.HasVariantMembers;
2014 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
2015 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
2016 ToData.HasUninitializedReferenceMember
2017 = FromData.HasUninitializedReferenceMember;
2018 ToData.NeedOverloadResolutionForMoveConstructor
2019 = FromData.NeedOverloadResolutionForMoveConstructor;
2020 ToData.NeedOverloadResolutionForMoveAssignment
2021 = FromData.NeedOverloadResolutionForMoveAssignment;
2022 ToData.NeedOverloadResolutionForDestructor
2023 = FromData.NeedOverloadResolutionForDestructor;
2024 ToData.DefaultedMoveConstructorIsDeleted
2025 = FromData.DefaultedMoveConstructorIsDeleted;
2026 ToData.DefaultedMoveAssignmentIsDeleted
2027 = FromData.DefaultedMoveAssignmentIsDeleted;
2028 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
2029 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
2030 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
2031 ToData.HasConstexprNonCopyMoveConstructor
2032 = FromData.HasConstexprNonCopyMoveConstructor;
2033 ToData.DefaultedDefaultConstructorIsConstexpr
2034 = FromData.DefaultedDefaultConstructorIsConstexpr;
2035 ToData.HasConstexprDefaultConstructor
2036 = FromData.HasConstexprDefaultConstructor;
2037 ToData.HasNonLiteralTypeFieldsOrBases
2038 = FromData.HasNonLiteralTypeFieldsOrBases;
2039 // ComputedVisibleConversions not imported.
2040 ToData.UserProvidedDefaultConstructor
2041 = FromData.UserProvidedDefaultConstructor;
2042 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
2043 ToData.ImplicitCopyConstructorHasConstParam
2044 = FromData.ImplicitCopyConstructorHasConstParam;
2045 ToData.ImplicitCopyAssignmentHasConstParam
2046 = FromData.ImplicitCopyAssignmentHasConstParam;
2047 ToData.HasDeclaredCopyConstructorWithConstParam
2048 = FromData.HasDeclaredCopyConstructorWithConstParam;
2049 ToData.HasDeclaredCopyAssignmentWithConstParam
2050 = FromData.HasDeclaredCopyAssignmentWithConstParam;
2051 ToData.IsLambda = FromData.IsLambda;
2053 SmallVector<CXXBaseSpecifier *, 4> Bases;
2054 for (const auto &Base1 : FromCXX->bases()) {
2055 QualType T = Importer.Import(Base1.getType());
2059 SourceLocation EllipsisLoc;
2060 if (Base1.isPackExpansion())
2061 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2063 // Ensure that we have a definition for the base.
2064 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2067 new (Importer.getToContext())
2068 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2070 Base1.isBaseOfClass(),
2071 Base1.getAccessSpecifierAsWritten(),
2072 Importer.Import(Base1.getTypeSourceInfo()),
2076 ToCXX->setBases(Bases.data(), Bases.size());
2079 if (shouldForceImportDeclContext(Kind))
2080 ImportDeclContext(From, /*ForceImport=*/true);
2082 To->completeDefinition();
2086 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2087 ImportDefinitionKind Kind) {
2088 if (To->getAnyInitializer())
2091 // FIXME: Can we really import any initializer? Alternatively, we could force
2092 // ourselves to import every declaration of a variable and then only use
2094 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2096 // FIXME: Other bits to merge?
2101 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2102 ImportDefinitionKind Kind) {
2103 if (To->getDefinition() || To->isBeingDefined()) {
2104 if (Kind == IDK_Everything)
2105 ImportDeclContext(From, /*ForceImport=*/true);
2109 To->startDefinition();
2111 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2115 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2116 if (ToPromotionType.isNull())
2119 if (shouldForceImportDeclContext(Kind))
2120 ImportDeclContext(From, /*ForceImport=*/true);
2122 // FIXME: we might need to merge the number of positive or negative bits
2123 // if the enumerator lists don't match.
2124 To->completeDefinition(T, ToPromotionType,
2125 From->getNumPositiveBits(),
2126 From->getNumNegativeBits());
2130 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2131 TemplateParameterList *Params) {
2132 SmallVector<NamedDecl *, 4> ToParams;
2133 ToParams.reserve(Params->size());
2134 for (TemplateParameterList::iterator P = Params->begin(),
2135 PEnd = Params->end();
2137 Decl *To = Importer.Import(*P);
2141 ToParams.push_back(cast<NamedDecl>(To));
2144 return TemplateParameterList::Create(Importer.getToContext(),
2145 Importer.Import(Params->getTemplateLoc()),
2146 Importer.Import(Params->getLAngleLoc()),
2147 ToParams.data(), ToParams.size(),
2148 Importer.Import(Params->getRAngleLoc()));
2152 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2153 switch (From.getKind()) {
2154 case TemplateArgument::Null:
2155 return TemplateArgument();
2157 case TemplateArgument::Type: {
2158 QualType ToType = Importer.Import(From.getAsType());
2159 if (ToType.isNull())
2160 return TemplateArgument();
2161 return TemplateArgument(ToType);
2164 case TemplateArgument::Integral: {
2165 QualType ToType = Importer.Import(From.getIntegralType());
2166 if (ToType.isNull())
2167 return TemplateArgument();
2168 return TemplateArgument(From, ToType);
2171 case TemplateArgument::Declaration: {
2172 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2173 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2174 if (!To || ToType.isNull())
2175 return TemplateArgument();
2176 return TemplateArgument(To, ToType);
2179 case TemplateArgument::NullPtr: {
2180 QualType ToType = Importer.Import(From.getNullPtrType());
2181 if (ToType.isNull())
2182 return TemplateArgument();
2183 return TemplateArgument(ToType, /*isNullPtr*/true);
2186 case TemplateArgument::Template: {
2187 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2188 if (ToTemplate.isNull())
2189 return TemplateArgument();
2191 return TemplateArgument(ToTemplate);
2194 case TemplateArgument::TemplateExpansion: {
2195 TemplateName ToTemplate
2196 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2197 if (ToTemplate.isNull())
2198 return TemplateArgument();
2200 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2203 case TemplateArgument::Expression:
2204 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2205 return TemplateArgument(ToExpr);
2206 return TemplateArgument();
2208 case TemplateArgument::Pack: {
2209 SmallVector<TemplateArgument, 2> ToPack;
2210 ToPack.reserve(From.pack_size());
2211 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2212 return TemplateArgument();
2214 TemplateArgument *ToArgs
2215 = new (Importer.getToContext()) TemplateArgument[ToPack.size()];
2216 std::copy(ToPack.begin(), ToPack.end(), ToArgs);
2217 return TemplateArgument(ToArgs, ToPack.size());
2221 llvm_unreachable("Invalid template argument kind");
2224 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2225 unsigned NumFromArgs,
2226 SmallVectorImpl<TemplateArgument> &ToArgs) {
2227 for (unsigned I = 0; I != NumFromArgs; ++I) {
2228 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2229 if (To.isNull() && !FromArgs[I].isNull())
2232 ToArgs.push_back(To);
2238 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2239 RecordDecl *ToRecord, bool Complain) {
2240 // Eliminate a potential failure point where we attempt to re-import
2241 // something we're trying to import while completing ToRecord.
2242 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2244 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2246 ToRecord = ToOriginRecord;
2249 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2250 ToRecord->getASTContext(),
2251 Importer.getNonEquivalentDecls(),
2253 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2256 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2258 StructuralEquivalenceContext Ctx(
2259 Importer.getFromContext(), Importer.getToContext(),
2260 Importer.getNonEquivalentDecls(), false, Complain);
2261 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2264 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2265 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2266 Importer.getToContext(),
2267 Importer.getNonEquivalentDecls());
2268 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2271 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2272 EnumConstantDecl *ToEC)
2274 const llvm::APSInt &FromVal = FromEC->getInitVal();
2275 const llvm::APSInt &ToVal = ToEC->getInitVal();
2277 return FromVal.isSigned() == ToVal.isSigned() &&
2278 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2282 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2283 ClassTemplateDecl *To) {
2284 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2285 Importer.getToContext(),
2286 Importer.getNonEquivalentDecls());
2287 return Ctx.IsStructurallyEquivalent(From, To);
2290 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2291 VarTemplateDecl *To) {
2292 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2293 Importer.getToContext(),
2294 Importer.getNonEquivalentDecls());
2295 return Ctx.IsStructurallyEquivalent(From, To);
2298 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2299 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2300 << D->getDeclKindName();
2304 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2305 TranslationUnitDecl *ToD =
2306 Importer.getToContext().getTranslationUnitDecl();
2308 Importer.Imported(D, ToD);
2313 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2314 // Import the major distinguishing characteristics of this namespace.
2315 DeclContext *DC, *LexicalDC;
2316 DeclarationName Name;
2319 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2324 NamespaceDecl *MergeWithNamespace = nullptr;
2326 // This is an anonymous namespace. Adopt an existing anonymous
2327 // namespace if we can.
2328 // FIXME: Not testable.
2329 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2330 MergeWithNamespace = TU->getAnonymousNamespace();
2332 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2334 SmallVector<NamedDecl *, 4> ConflictingDecls;
2335 SmallVector<NamedDecl *, 2> FoundDecls;
2336 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2337 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2338 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2341 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2342 MergeWithNamespace = FoundNS;
2343 ConflictingDecls.clear();
2347 ConflictingDecls.push_back(FoundDecls[I]);
2350 if (!ConflictingDecls.empty()) {
2351 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2352 ConflictingDecls.data(),
2353 ConflictingDecls.size());
2357 // Create the "to" namespace, if needed.
2358 NamespaceDecl *ToNamespace = MergeWithNamespace;
2360 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2362 Importer.Import(D->getLocStart()),
2363 Loc, Name.getAsIdentifierInfo(),
2364 /*PrevDecl=*/nullptr);
2365 ToNamespace->setLexicalDeclContext(LexicalDC);
2366 LexicalDC->addDeclInternal(ToNamespace);
2368 // If this is an anonymous namespace, register it as the anonymous
2369 // namespace within its context.
2371 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2372 TU->setAnonymousNamespace(ToNamespace);
2374 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2377 Importer.Imported(D, ToNamespace);
2379 ImportDeclContext(D);
2384 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2385 // Import the major distinguishing characteristics of this typedef.
2386 DeclContext *DC, *LexicalDC;
2387 DeclarationName Name;
2390 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2395 // If this typedef is not in block scope, determine whether we've
2396 // seen a typedef with the same name (that we can merge with) or any
2397 // other entity by that name (which name lookup could conflict with).
2398 if (!DC->isFunctionOrMethod()) {
2399 SmallVector<NamedDecl *, 4> ConflictingDecls;
2400 unsigned IDNS = Decl::IDNS_Ordinary;
2401 SmallVector<NamedDecl *, 2> FoundDecls;
2402 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2403 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2404 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2406 if (TypedefNameDecl *FoundTypedef =
2407 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2408 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2409 FoundTypedef->getUnderlyingType()))
2410 return Importer.Imported(D, FoundTypedef);
2413 ConflictingDecls.push_back(FoundDecls[I]);
2416 if (!ConflictingDecls.empty()) {
2417 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2418 ConflictingDecls.data(),
2419 ConflictingDecls.size());
2425 // Import the underlying type of this typedef;
2426 QualType T = Importer.Import(D->getUnderlyingType());
2430 // Create the new typedef node.
2431 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2432 SourceLocation StartL = Importer.Import(D->getLocStart());
2433 TypedefNameDecl *ToTypedef;
2435 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2437 Name.getAsIdentifierInfo(),
2440 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2442 Name.getAsIdentifierInfo(),
2445 ToTypedef->setAccess(D->getAccess());
2446 ToTypedef->setLexicalDeclContext(LexicalDC);
2447 Importer.Imported(D, ToTypedef);
2448 LexicalDC->addDeclInternal(ToTypedef);
2453 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2454 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2457 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2458 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2461 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2462 // Import the major distinguishing characteristics of this enum.
2463 DeclContext *DC, *LexicalDC;
2464 DeclarationName Name;
2467 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2472 // Figure out what enum name we're looking for.
2473 unsigned IDNS = Decl::IDNS_Tag;
2474 DeclarationName SearchName = Name;
2475 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2476 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2477 IDNS = Decl::IDNS_Ordinary;
2478 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2479 IDNS |= Decl::IDNS_Ordinary;
2481 // We may already have an enum of the same name; try to find and match it.
2482 if (!DC->isFunctionOrMethod() && SearchName) {
2483 SmallVector<NamedDecl *, 4> ConflictingDecls;
2484 SmallVector<NamedDecl *, 2> FoundDecls;
2485 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2486 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2487 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2490 Decl *Found = FoundDecls[I];
2491 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2492 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2493 Found = Tag->getDecl();
2496 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2497 if (IsStructuralMatch(D, FoundEnum))
2498 return Importer.Imported(D, FoundEnum);
2501 ConflictingDecls.push_back(FoundDecls[I]);
2504 if (!ConflictingDecls.empty()) {
2505 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2506 ConflictingDecls.data(),
2507 ConflictingDecls.size());
2511 // Create the enum declaration.
2512 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2513 Importer.Import(D->getLocStart()),
2514 Loc, Name.getAsIdentifierInfo(), nullptr,
2515 D->isScoped(), D->isScopedUsingClassTag(),
2517 // Import the qualifier, if any.
2518 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2519 D2->setAccess(D->getAccess());
2520 D2->setLexicalDeclContext(LexicalDC);
2521 Importer.Imported(D, D2);
2522 LexicalDC->addDeclInternal(D2);
2524 // Import the integer type.
2525 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2526 if (ToIntegerType.isNull())
2528 D2->setIntegerType(ToIntegerType);
2530 // Import the definition
2531 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2537 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2538 // If this record has a definition in the translation unit we're coming from,
2539 // but this particular declaration is not that definition, import the
2540 // definition and map to that.
2541 TagDecl *Definition = D->getDefinition();
2542 if (Definition && Definition != D) {
2543 Decl *ImportedDef = Importer.Import(Definition);
2547 return Importer.Imported(D, ImportedDef);
2550 // Import the major distinguishing characteristics of this record.
2551 DeclContext *DC, *LexicalDC;
2552 DeclarationName Name;
2555 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2560 // Figure out what structure name we're looking for.
2561 unsigned IDNS = Decl::IDNS_Tag;
2562 DeclarationName SearchName = Name;
2563 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2564 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2565 IDNS = Decl::IDNS_Ordinary;
2566 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2567 IDNS |= Decl::IDNS_Ordinary;
2569 // We may already have a record of the same name; try to find and match it.
2570 RecordDecl *AdoptDecl = nullptr;
2571 if (!DC->isFunctionOrMethod()) {
2572 SmallVector<NamedDecl *, 4> ConflictingDecls;
2573 SmallVector<NamedDecl *, 2> FoundDecls;
2574 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2575 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2576 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2579 Decl *Found = FoundDecls[I];
2580 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2581 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2582 Found = Tag->getDecl();
2585 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2586 if (D->isAnonymousStructOrUnion() &&
2587 FoundRecord->isAnonymousStructOrUnion()) {
2588 // If both anonymous structs/unions are in a record context, make sure
2589 // they occur in the same location in the context records.
2590 if (Optional<unsigned> Index1
2591 = findAnonymousStructOrUnionIndex(D)) {
2592 if (Optional<unsigned> Index2 =
2593 findAnonymousStructOrUnionIndex(FoundRecord)) {
2594 if (*Index1 != *Index2)
2600 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2601 if ((SearchName && !D->isCompleteDefinition())
2602 || (D->isCompleteDefinition() &&
2603 D->isAnonymousStructOrUnion()
2604 == FoundDef->isAnonymousStructOrUnion() &&
2605 IsStructuralMatch(D, FoundDef))) {
2606 // The record types structurally match, or the "from" translation
2607 // unit only had a forward declaration anyway; call it the same
2609 // FIXME: For C++, we should also merge methods here.
2610 return Importer.Imported(D, FoundDef);
2612 } else if (!D->isCompleteDefinition()) {
2613 // We have a forward declaration of this type, so adopt that forward
2614 // declaration rather than building a new one.
2616 // If one or both can be completed from external storage then try one
2617 // last time to complete and compare them before doing this.
2619 if (FoundRecord->hasExternalLexicalStorage() &&
2620 !FoundRecord->isCompleteDefinition())
2621 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2622 if (D->hasExternalLexicalStorage())
2623 D->getASTContext().getExternalSource()->CompleteType(D);
2625 if (FoundRecord->isCompleteDefinition() &&
2626 D->isCompleteDefinition() &&
2627 !IsStructuralMatch(D, FoundRecord))
2630 AdoptDecl = FoundRecord;
2632 } else if (!SearchName) {
2637 ConflictingDecls.push_back(FoundDecls[I]);
2640 if (!ConflictingDecls.empty() && SearchName) {
2641 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2642 ConflictingDecls.data(),
2643 ConflictingDecls.size());
2647 // Create the record declaration.
2648 RecordDecl *D2 = AdoptDecl;
2649 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2651 if (isa<CXXRecordDecl>(D)) {
2652 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2655 Name.getAsIdentifierInfo());
2657 D2->setAccess(D->getAccess());
2659 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2660 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2663 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2664 D2->setLexicalDeclContext(LexicalDC);
2665 LexicalDC->addDeclInternal(D2);
2666 if (D->isAnonymousStructOrUnion())
2667 D2->setAnonymousStructOrUnion(true);
2670 Importer.Imported(D, D2);
2672 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2678 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2679 // Import the major distinguishing characteristics of this enumerator.
2680 DeclContext *DC, *LexicalDC;
2681 DeclarationName Name;
2684 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2689 QualType T = Importer.Import(D->getType());
2693 // Determine whether there are any other declarations with the same name and
2694 // in the same context.
2695 if (!LexicalDC->isFunctionOrMethod()) {
2696 SmallVector<NamedDecl *, 4> ConflictingDecls;
2697 unsigned IDNS = Decl::IDNS_Ordinary;
2698 SmallVector<NamedDecl *, 2> FoundDecls;
2699 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2700 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2701 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2704 if (EnumConstantDecl *FoundEnumConstant
2705 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2706 if (IsStructuralMatch(D, FoundEnumConstant))
2707 return Importer.Imported(D, FoundEnumConstant);
2710 ConflictingDecls.push_back(FoundDecls[I]);
2713 if (!ConflictingDecls.empty()) {
2714 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2715 ConflictingDecls.data(),
2716 ConflictingDecls.size());
2722 Expr *Init = Importer.Import(D->getInitExpr());
2723 if (D->getInitExpr() && !Init)
2726 EnumConstantDecl *ToEnumerator
2727 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2728 Name.getAsIdentifierInfo(), T,
2729 Init, D->getInitVal());
2730 ToEnumerator->setAccess(D->getAccess());
2731 ToEnumerator->setLexicalDeclContext(LexicalDC);
2732 Importer.Imported(D, ToEnumerator);
2733 LexicalDC->addDeclInternal(ToEnumerator);
2734 return ToEnumerator;
2737 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2738 // Import the major distinguishing characteristics of this function.
2739 DeclContext *DC, *LexicalDC;
2740 DeclarationName Name;
2743 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2748 // Try to find a function in our own ("to") context with the same name, same
2749 // type, and in the same context as the function we're importing.
2750 if (!LexicalDC->isFunctionOrMethod()) {
2751 SmallVector<NamedDecl *, 4> ConflictingDecls;
2752 unsigned IDNS = Decl::IDNS_Ordinary;
2753 SmallVector<NamedDecl *, 2> FoundDecls;
2754 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2755 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2756 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2759 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2760 if (FoundFunction->hasExternalFormalLinkage() &&
2761 D->hasExternalFormalLinkage()) {
2762 if (Importer.IsStructurallyEquivalent(D->getType(),
2763 FoundFunction->getType())) {
2764 // FIXME: Actually try to merge the body and other attributes.
2765 return Importer.Imported(D, FoundFunction);
2768 // FIXME: Check for overloading more carefully, e.g., by boosting
2769 // Sema::IsOverload out to the AST library.
2771 // Function overloading is okay in C++.
2772 if (Importer.getToContext().getLangOpts().CPlusPlus)
2775 // Complain about inconsistent function types.
2776 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2777 << Name << D->getType() << FoundFunction->getType();
2778 Importer.ToDiag(FoundFunction->getLocation(),
2779 diag::note_odr_value_here)
2780 << FoundFunction->getType();
2784 ConflictingDecls.push_back(FoundDecls[I]);
2787 if (!ConflictingDecls.empty()) {
2788 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2789 ConflictingDecls.data(),
2790 ConflictingDecls.size());
2796 DeclarationNameInfo NameInfo(Name, Loc);
2797 // Import additional name location/type info.
2798 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2800 QualType FromTy = D->getType();
2801 bool usedDifferentExceptionSpec = false;
2803 if (const FunctionProtoType *
2804 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2805 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2806 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2807 // FunctionDecl that we are importing the FunctionProtoType for.
2808 // To avoid an infinite recursion when importing, create the FunctionDecl
2809 // with a simplified function type and update it afterwards.
2810 if (FromEPI.ExceptionSpec.SourceDecl ||
2811 FromEPI.ExceptionSpec.SourceTemplate ||
2812 FromEPI.ExceptionSpec.NoexceptExpr) {
2813 FunctionProtoType::ExtProtoInfo DefaultEPI;
2814 FromTy = Importer.getFromContext().getFunctionType(
2815 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2816 usedDifferentExceptionSpec = true;
2821 QualType T = Importer.Import(FromTy);
2825 // Import the function parameters.
2826 SmallVector<ParmVarDecl *, 8> Parameters;
2827 for (auto P : D->params()) {
2828 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2832 Parameters.push_back(ToP);
2835 // Create the imported function.
2836 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2837 FunctionDecl *ToFunction = nullptr;
2838 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2839 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2840 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2841 cast<CXXRecordDecl>(DC),
2844 FromConstructor->isExplicit(),
2845 D->isInlineSpecified(),
2848 } else if (isa<CXXDestructorDecl>(D)) {
2849 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2850 cast<CXXRecordDecl>(DC),
2853 D->isInlineSpecified(),
2855 } else if (CXXConversionDecl *FromConversion
2856 = dyn_cast<CXXConversionDecl>(D)) {
2857 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2858 cast<CXXRecordDecl>(DC),
2861 D->isInlineSpecified(),
2862 FromConversion->isExplicit(),
2864 Importer.Import(D->getLocEnd()));
2865 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2866 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2867 cast<CXXRecordDecl>(DC),
2870 Method->getStorageClass(),
2871 Method->isInlineSpecified(),
2873 Importer.Import(D->getLocEnd()));
2875 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2877 NameInfo, T, TInfo, D->getStorageClass(),
2878 D->isInlineSpecified(),
2879 D->hasWrittenPrototype(),
2883 // Import the qualifier, if any.
2884 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2885 ToFunction->setAccess(D->getAccess());
2886 ToFunction->setLexicalDeclContext(LexicalDC);
2887 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2888 ToFunction->setTrivial(D->isTrivial());
2889 ToFunction->setPure(D->isPure());
2890 Importer.Imported(D, ToFunction);
2892 // Set the parameters.
2893 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2894 Parameters[I]->setOwningFunction(ToFunction);
2895 ToFunction->addDeclInternal(Parameters[I]);
2897 ToFunction->setParams(Parameters);
2899 if (usedDifferentExceptionSpec) {
2900 // Update FunctionProtoType::ExtProtoInfo.
2901 QualType T = Importer.Import(D->getType());
2904 ToFunction->setType(T);
2907 // Import the body, if any.
2908 if (Stmt *FromBody = D->getBody()) {
2909 if (Stmt *ToBody = Importer.Import(FromBody)) {
2910 ToFunction->setBody(ToBody);
2914 // FIXME: Other bits to merge?
2916 // Add this function to the lexical context.
2917 LexicalDC->addDeclInternal(ToFunction);
2922 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2923 return VisitFunctionDecl(D);
2926 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2927 return VisitCXXMethodDecl(D);
2930 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2931 return VisitCXXMethodDecl(D);
2934 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2935 return VisitCXXMethodDecl(D);
2938 static unsigned getFieldIndex(Decl *F) {
2939 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2944 for (const auto *D : Owner->noload_decls()) {
2948 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2955 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2956 // Import the major distinguishing characteristics of a variable.
2957 DeclContext *DC, *LexicalDC;
2958 DeclarationName Name;
2961 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2966 // Determine whether we've already imported this field.
2967 SmallVector<NamedDecl *, 2> FoundDecls;
2968 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2969 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2970 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2971 // For anonymous fields, match up by index.
2972 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2975 if (Importer.IsStructurallyEquivalent(D->getType(),
2976 FoundField->getType())) {
2977 Importer.Imported(D, FoundField);
2981 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2982 << Name << D->getType() << FoundField->getType();
2983 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2984 << FoundField->getType();
2990 QualType T = Importer.Import(D->getType());
2994 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2995 Expr *BitWidth = Importer.Import(D->getBitWidth());
2996 if (!BitWidth && D->getBitWidth())
2999 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3000 Importer.Import(D->getInnerLocStart()),
3001 Loc, Name.getAsIdentifierInfo(),
3002 T, TInfo, BitWidth, D->isMutable(),
3003 D->getInClassInitStyle());
3004 ToField->setAccess(D->getAccess());
3005 ToField->setLexicalDeclContext(LexicalDC);
3006 if (ToField->hasInClassInitializer())
3007 ToField->setInClassInitializer(D->getInClassInitializer());
3008 ToField->setImplicit(D->isImplicit());
3009 Importer.Imported(D, ToField);
3010 LexicalDC->addDeclInternal(ToField);
3014 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3015 // Import the major distinguishing characteristics of a variable.
3016 DeclContext *DC, *LexicalDC;
3017 DeclarationName Name;
3020 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3025 // Determine whether we've already imported this field.
3026 SmallVector<NamedDecl *, 2> FoundDecls;
3027 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3028 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3029 if (IndirectFieldDecl *FoundField
3030 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3031 // For anonymous indirect fields, match up by index.
3032 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3035 if (Importer.IsStructurallyEquivalent(D->getType(),
3036 FoundField->getType(),
3038 Importer.Imported(D, FoundField);
3042 // If there are more anonymous fields to check, continue.
3043 if (!Name && I < N-1)
3046 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3047 << Name << D->getType() << FoundField->getType();
3048 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3049 << FoundField->getType();
3055 QualType T = Importer.Import(D->getType());
3059 NamedDecl **NamedChain =
3060 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3063 for (auto *PI : D->chain()) {
3064 Decl *D = Importer.Import(PI);
3067 NamedChain[i++] = cast<NamedDecl>(D);
3070 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3071 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3072 NamedChain, D->getChainingSize());
3074 for (const auto *Attr : D->attrs())
3075 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3077 ToIndirectField->setAccess(D->getAccess());
3078 ToIndirectField->setLexicalDeclContext(LexicalDC);
3079 Importer.Imported(D, ToIndirectField);
3080 LexicalDC->addDeclInternal(ToIndirectField);
3081 return ToIndirectField;
3084 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3085 // Import the major distinguishing characteristics of an ivar.
3086 DeclContext *DC, *LexicalDC;
3087 DeclarationName Name;
3090 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3095 // Determine whether we've already imported this ivar
3096 SmallVector<NamedDecl *, 2> FoundDecls;
3097 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3098 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3099 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3100 if (Importer.IsStructurallyEquivalent(D->getType(),
3101 FoundIvar->getType())) {
3102 Importer.Imported(D, FoundIvar);
3106 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3107 << Name << D->getType() << FoundIvar->getType();
3108 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3109 << FoundIvar->getType();
3115 QualType T = Importer.Import(D->getType());
3119 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3120 Expr *BitWidth = Importer.Import(D->getBitWidth());
3121 if (!BitWidth && D->getBitWidth())
3124 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3125 cast<ObjCContainerDecl>(DC),
3126 Importer.Import(D->getInnerLocStart()),
3127 Loc, Name.getAsIdentifierInfo(),
3128 T, TInfo, D->getAccessControl(),
3129 BitWidth, D->getSynthesize());
3130 ToIvar->setLexicalDeclContext(LexicalDC);
3131 Importer.Imported(D, ToIvar);
3132 LexicalDC->addDeclInternal(ToIvar);
3137 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3138 // Import the major distinguishing characteristics of a variable.
3139 DeclContext *DC, *LexicalDC;
3140 DeclarationName Name;
3143 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3148 // Try to find a variable in our own ("to") context with the same name and
3149 // in the same context as the variable we're importing.
3150 if (D->isFileVarDecl()) {
3151 VarDecl *MergeWithVar = nullptr;
3152 SmallVector<NamedDecl *, 4> ConflictingDecls;
3153 unsigned IDNS = Decl::IDNS_Ordinary;
3154 SmallVector<NamedDecl *, 2> FoundDecls;
3155 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3156 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3157 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3160 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3161 // We have found a variable that we may need to merge with. Check it.
3162 if (FoundVar->hasExternalFormalLinkage() &&
3163 D->hasExternalFormalLinkage()) {
3164 if (Importer.IsStructurallyEquivalent(D->getType(),
3165 FoundVar->getType())) {
3166 MergeWithVar = FoundVar;
3170 const ArrayType *FoundArray
3171 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3172 const ArrayType *TArray
3173 = Importer.getToContext().getAsArrayType(D->getType());
3174 if (FoundArray && TArray) {
3175 if (isa<IncompleteArrayType>(FoundArray) &&
3176 isa<ConstantArrayType>(TArray)) {
3178 QualType T = Importer.Import(D->getType());
3182 FoundVar->setType(T);
3183 MergeWithVar = FoundVar;
3185 } else if (isa<IncompleteArrayType>(TArray) &&
3186 isa<ConstantArrayType>(FoundArray)) {
3187 MergeWithVar = FoundVar;
3192 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3193 << Name << D->getType() << FoundVar->getType();
3194 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3195 << FoundVar->getType();
3199 ConflictingDecls.push_back(FoundDecls[I]);
3203 // An equivalent variable with external linkage has been found. Link
3204 // the two declarations, then merge them.
3205 Importer.Imported(D, MergeWithVar);
3207 if (VarDecl *DDef = D->getDefinition()) {
3208 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3209 Importer.ToDiag(ExistingDef->getLocation(),
3210 diag::err_odr_variable_multiple_def)
3212 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3214 Expr *Init = Importer.Import(DDef->getInit());
3215 MergeWithVar->setInit(Init);
3216 if (DDef->isInitKnownICE()) {
3217 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3218 Eval->CheckedICE = true;
3219 Eval->IsICE = DDef->isInitICE();
3224 return MergeWithVar;
3227 if (!ConflictingDecls.empty()) {
3228 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3229 ConflictingDecls.data(),
3230 ConflictingDecls.size());
3237 QualType T = Importer.Import(D->getType());
3241 // Create the imported variable.
3242 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3243 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3244 Importer.Import(D->getInnerLocStart()),
3245 Loc, Name.getAsIdentifierInfo(),
3247 D->getStorageClass());
3248 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3249 ToVar->setAccess(D->getAccess());
3250 ToVar->setLexicalDeclContext(LexicalDC);
3251 Importer.Imported(D, ToVar);
3252 LexicalDC->addDeclInternal(ToVar);
3254 if (!D->isFileVarDecl() &&
3258 // Merge the initializer.
3259 if (ImportDefinition(D, ToVar))
3265 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3266 // Parameters are created in the translation unit's context, then moved
3267 // into the function declaration's context afterward.
3268 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3270 // Import the name of this declaration.
3271 DeclarationName Name = Importer.Import(D->getDeclName());
3272 if (D->getDeclName() && !Name)
3275 // Import the location of this declaration.
3276 SourceLocation Loc = Importer.Import(D->getLocation());
3278 // Import the parameter's type.
3279 QualType T = Importer.Import(D->getType());
3283 // Create the imported parameter.
3284 ImplicitParamDecl *ToParm
3285 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3286 Loc, Name.getAsIdentifierInfo(),
3288 return Importer.Imported(D, ToParm);
3291 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3292 // Parameters are created in the translation unit's context, then moved
3293 // into the function declaration's context afterward.
3294 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3296 // Import the name of this declaration.
3297 DeclarationName Name = Importer.Import(D->getDeclName());
3298 if (D->getDeclName() && !Name)
3301 // Import the location of this declaration.
3302 SourceLocation Loc = Importer.Import(D->getLocation());
3304 // Import the parameter's type.
3305 QualType T = Importer.Import(D->getType());
3309 // Create the imported parameter.
3310 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3311 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3312 Importer.Import(D->getInnerLocStart()),
3313 Loc, Name.getAsIdentifierInfo(),
3314 T, TInfo, D->getStorageClass(),
3315 /*FIXME: Default argument*/nullptr);
3316 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3319 ToParm->setIsUsed();
3321 return Importer.Imported(D, ToParm);
3324 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3325 // Import the major distinguishing characteristics of a method.
3326 DeclContext *DC, *LexicalDC;
3327 DeclarationName Name;
3330 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3335 SmallVector<NamedDecl *, 2> FoundDecls;
3336 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3337 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3338 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3339 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3342 // Check return types.
3343 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3344 FoundMethod->getReturnType())) {
3345 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3346 << D->isInstanceMethod() << Name << D->getReturnType()
3347 << FoundMethod->getReturnType();
3348 Importer.ToDiag(FoundMethod->getLocation(),
3349 diag::note_odr_objc_method_here)
3350 << D->isInstanceMethod() << Name;
3354 // Check the number of parameters.
3355 if (D->param_size() != FoundMethod->param_size()) {
3356 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3357 << D->isInstanceMethod() << Name
3358 << D->param_size() << FoundMethod->param_size();
3359 Importer.ToDiag(FoundMethod->getLocation(),
3360 diag::note_odr_objc_method_here)
3361 << D->isInstanceMethod() << Name;
3365 // Check parameter types.
3366 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3367 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3368 P != PEnd; ++P, ++FoundP) {
3369 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3370 (*FoundP)->getType())) {
3371 Importer.FromDiag((*P)->getLocation(),
3372 diag::err_odr_objc_method_param_type_inconsistent)
3373 << D->isInstanceMethod() << Name
3374 << (*P)->getType() << (*FoundP)->getType();
3375 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3376 << (*FoundP)->getType();
3381 // Check variadic/non-variadic.
3382 // Check the number of parameters.
3383 if (D->isVariadic() != FoundMethod->isVariadic()) {
3384 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3385 << D->isInstanceMethod() << Name;
3386 Importer.ToDiag(FoundMethod->getLocation(),
3387 diag::note_odr_objc_method_here)
3388 << D->isInstanceMethod() << Name;
3392 // FIXME: Any other bits we need to merge?
3393 return Importer.Imported(D, FoundMethod);
3397 // Import the result type.
3398 QualType ResultTy = Importer.Import(D->getReturnType());
3399 if (ResultTy.isNull())
3402 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3404 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3405 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3406 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3407 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3408 D->getImplementationControl(), D->hasRelatedResultType());
3410 // FIXME: When we decide to merge method definitions, we'll need to
3411 // deal with implicit parameters.
3413 // Import the parameters
3414 SmallVector<ParmVarDecl *, 5> ToParams;
3415 for (auto *FromP : D->params()) {
3416 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3420 ToParams.push_back(ToP);
3423 // Set the parameters.
3424 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3425 ToParams[I]->setOwningFunction(ToMethod);
3426 ToMethod->addDeclInternal(ToParams[I]);
3428 SmallVector<SourceLocation, 12> SelLocs;
3429 D->getSelectorLocs(SelLocs);
3430 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3432 ToMethod->setLexicalDeclContext(LexicalDC);
3433 Importer.Imported(D, ToMethod);
3434 LexicalDC->addDeclInternal(ToMethod);
3438 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3439 // Import the major distinguishing characteristics of a category.
3440 DeclContext *DC, *LexicalDC;
3441 DeclarationName Name;
3444 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3449 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3453 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
3454 Importer.getToContext(), DC,
3456 Importer.Import(D->getVarianceLoc()),
3458 Importer.Import(D->getLocation()),
3459 Name.getAsIdentifierInfo(),
3460 Importer.Import(D->getColonLoc()),
3462 Importer.Imported(D, Result);
3463 Result->setLexicalDeclContext(LexicalDC);
3467 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3468 // Import the major distinguishing characteristics of a category.
3469 DeclContext *DC, *LexicalDC;
3470 DeclarationName Name;
3473 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3478 ObjCInterfaceDecl *ToInterface
3479 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3483 // Determine if we've already encountered this category.
3484 ObjCCategoryDecl *MergeWithCategory
3485 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3486 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3488 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3489 Importer.Import(D->getAtStartLoc()),
3491 Importer.Import(D->getCategoryNameLoc()),
3492 Name.getAsIdentifierInfo(),
3494 /*TypeParamList=*/nullptr,
3495 Importer.Import(D->getIvarLBraceLoc()),
3496 Importer.Import(D->getIvarRBraceLoc()));
3497 ToCategory->setLexicalDeclContext(LexicalDC);
3498 LexicalDC->addDeclInternal(ToCategory);
3499 Importer.Imported(D, ToCategory);
3500 // Import the type parameter list after calling Imported, to avoid
3501 // loops when bringing in their DeclContext.
3502 ToCategory->setTypeParamList(ImportObjCTypeParamList(
3503 D->getTypeParamList()));
3506 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3507 SmallVector<SourceLocation, 4> ProtocolLocs;
3508 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3509 = D->protocol_loc_begin();
3510 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3511 FromProtoEnd = D->protocol_end();
3512 FromProto != FromProtoEnd;
3513 ++FromProto, ++FromProtoLoc) {
3514 ObjCProtocolDecl *ToProto
3515 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3518 Protocols.push_back(ToProto);
3519 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3522 // FIXME: If we're merging, make sure that the protocol list is the same.
3523 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3524 ProtocolLocs.data(), Importer.getToContext());
3527 Importer.Imported(D, ToCategory);
3530 // Import all of the members of this category.
3531 ImportDeclContext(D);
3533 // If we have an implementation, import it as well.
3534 if (D->getImplementation()) {
3535 ObjCCategoryImplDecl *Impl
3536 = cast_or_null<ObjCCategoryImplDecl>(
3537 Importer.Import(D->getImplementation()));
3541 ToCategory->setImplementation(Impl);
3547 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3548 ObjCProtocolDecl *To,
3549 ImportDefinitionKind Kind) {
3550 if (To->getDefinition()) {
3551 if (shouldForceImportDeclContext(Kind))
3552 ImportDeclContext(From);
3556 // Start the protocol definition
3557 To->startDefinition();
3560 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3561 SmallVector<SourceLocation, 4> ProtocolLocs;
3562 ObjCProtocolDecl::protocol_loc_iterator
3563 FromProtoLoc = From->protocol_loc_begin();
3564 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3565 FromProtoEnd = From->protocol_end();
3566 FromProto != FromProtoEnd;
3567 ++FromProto, ++FromProtoLoc) {
3568 ObjCProtocolDecl *ToProto
3569 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3572 Protocols.push_back(ToProto);
3573 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3576 // FIXME: If we're merging, make sure that the protocol list is the same.
3577 To->setProtocolList(Protocols.data(), Protocols.size(),
3578 ProtocolLocs.data(), Importer.getToContext());
3580 if (shouldForceImportDeclContext(Kind)) {
3581 // Import all of the members of this protocol.
3582 ImportDeclContext(From, /*ForceImport=*/true);
3587 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3588 // If this protocol has a definition in the translation unit we're coming
3589 // from, but this particular declaration is not that definition, import the
3590 // definition and map to that.
3591 ObjCProtocolDecl *Definition = D->getDefinition();
3592 if (Definition && Definition != D) {
3593 Decl *ImportedDef = Importer.Import(Definition);
3597 return Importer.Imported(D, ImportedDef);
3600 // Import the major distinguishing characteristics of a protocol.
3601 DeclContext *DC, *LexicalDC;
3602 DeclarationName Name;
3605 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3610 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3611 SmallVector<NamedDecl *, 2> FoundDecls;
3612 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3613 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3614 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3617 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3621 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3623 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3624 Name.getAsIdentifierInfo(), Loc,
3625 Importer.Import(D->getAtStartLoc()),
3626 /*PrevDecl=*/nullptr);
3627 ToProto->setLexicalDeclContext(LexicalDC);
3628 LexicalDC->addDeclInternal(ToProto);
3631 Importer.Imported(D, ToProto);
3633 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3639 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3640 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3641 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3643 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3644 SourceLocation LangLoc = Importer.Import(D->getLocation());
3646 bool HasBraces = D->hasBraces();
3648 LinkageSpecDecl *ToLinkageSpec =
3649 LinkageSpecDecl::Create(Importer.getToContext(),
3657 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3658 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3661 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3662 LexicalDC->addDeclInternal(ToLinkageSpec);
3664 Importer.Imported(D, ToLinkageSpec);
3666 return ToLinkageSpec;
3669 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3670 ObjCInterfaceDecl *To,
3671 ImportDefinitionKind Kind) {
3672 if (To->getDefinition()) {
3673 // Check consistency of superclass.
3674 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3676 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3681 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3682 if ((bool)FromSuper != (bool)ToSuper ||
3683 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3684 Importer.ToDiag(To->getLocation(),
3685 diag::err_odr_objc_superclass_inconsistent)
3686 << To->getDeclName();
3688 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3689 << To->getSuperClass()->getDeclName();
3691 Importer.ToDiag(To->getLocation(),
3692 diag::note_odr_objc_missing_superclass);
3693 if (From->getSuperClass())
3694 Importer.FromDiag(From->getSuperClassLoc(),
3695 diag::note_odr_objc_superclass)
3696 << From->getSuperClass()->getDeclName();
3698 Importer.FromDiag(From->getLocation(),
3699 diag::note_odr_objc_missing_superclass);
3702 if (shouldForceImportDeclContext(Kind))
3703 ImportDeclContext(From);
3707 // Start the definition.
3708 To->startDefinition();
3710 // If this class has a superclass, import it.
3711 if (From->getSuperClass()) {
3712 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3716 To->setSuperClass(SuperTInfo);
3720 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3721 SmallVector<SourceLocation, 4> ProtocolLocs;
3722 ObjCInterfaceDecl::protocol_loc_iterator
3723 FromProtoLoc = From->protocol_loc_begin();
3725 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3726 FromProtoEnd = From->protocol_end();
3727 FromProto != FromProtoEnd;
3728 ++FromProto, ++FromProtoLoc) {
3729 ObjCProtocolDecl *ToProto
3730 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3733 Protocols.push_back(ToProto);
3734 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3737 // FIXME: If we're merging, make sure that the protocol list is the same.
3738 To->setProtocolList(Protocols.data(), Protocols.size(),
3739 ProtocolLocs.data(), Importer.getToContext());
3741 // Import categories. When the categories themselves are imported, they'll
3742 // hook themselves into this interface.
3743 for (auto *Cat : From->known_categories())
3744 Importer.Import(Cat);
3746 // If we have an @implementation, import it as well.
3747 if (From->getImplementation()) {
3748 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3749 Importer.Import(From->getImplementation()));
3753 To->setImplementation(Impl);
3756 if (shouldForceImportDeclContext(Kind)) {
3757 // Import all of the members of this class.
3758 ImportDeclContext(From, /*ForceImport=*/true);
3764 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3768 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3769 for (auto fromTypeParam : *list) {
3770 auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3771 Importer.Import(fromTypeParam));
3775 toTypeParams.push_back(toTypeParam);
3778 return ObjCTypeParamList::create(Importer.getToContext(),
3779 Importer.Import(list->getLAngleLoc()),
3781 Importer.Import(list->getRAngleLoc()));
3784 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3785 // If this class has a definition in the translation unit we're coming from,
3786 // but this particular declaration is not that definition, import the
3787 // definition and map to that.
3788 ObjCInterfaceDecl *Definition = D->getDefinition();
3789 if (Definition && Definition != D) {
3790 Decl *ImportedDef = Importer.Import(Definition);
3794 return Importer.Imported(D, ImportedDef);
3797 // Import the major distinguishing characteristics of an @interface.
3798 DeclContext *DC, *LexicalDC;
3799 DeclarationName Name;
3802 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3807 // Look for an existing interface with the same name.
3808 ObjCInterfaceDecl *MergeWithIface = nullptr;
3809 SmallVector<NamedDecl *, 2> FoundDecls;
3810 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3811 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3812 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3815 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3819 // Create an interface declaration, if one does not already exist.
3820 ObjCInterfaceDecl *ToIface = MergeWithIface;
3822 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3823 Importer.Import(D->getAtStartLoc()),
3824 Name.getAsIdentifierInfo(),
3825 /*TypeParamList=*/nullptr,
3826 /*PrevDecl=*/nullptr, Loc,
3827 D->isImplicitInterfaceDecl());
3828 ToIface->setLexicalDeclContext(LexicalDC);
3829 LexicalDC->addDeclInternal(ToIface);
3831 Importer.Imported(D, ToIface);
3832 // Import the type parameter list after calling Imported, to avoid
3833 // loops when bringing in their DeclContext.
3834 ToIface->setTypeParamList(ImportObjCTypeParamList(
3835 D->getTypeParamListAsWritten()));
3837 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3843 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3844 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3845 Importer.Import(D->getCategoryDecl()));
3849 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3851 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3855 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3856 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3857 Importer.Import(D->getIdentifier()),
3858 Category->getClassInterface(),
3859 Importer.Import(D->getLocation()),
3860 Importer.Import(D->getAtStartLoc()),
3863 DeclContext *LexicalDC = DC;
3864 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3865 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3869 ToImpl->setLexicalDeclContext(LexicalDC);
3872 LexicalDC->addDeclInternal(ToImpl);
3873 Category->setImplementation(ToImpl);
3876 Importer.Imported(D, ToImpl);
3877 ImportDeclContext(D);
3881 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3882 // Find the corresponding interface.
3883 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3884 Importer.Import(D->getClassInterface()));
3888 // Import the superclass, if any.
3889 ObjCInterfaceDecl *Super = nullptr;
3890 if (D->getSuperClass()) {
3891 Super = cast_or_null<ObjCInterfaceDecl>(
3892 Importer.Import(D->getSuperClass()));
3897 ObjCImplementationDecl *Impl = Iface->getImplementation();
3899 // We haven't imported an implementation yet. Create a new @implementation
3901 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3902 Importer.ImportContext(D->getDeclContext()),
3904 Importer.Import(D->getLocation()),
3905 Importer.Import(D->getAtStartLoc()),
3906 Importer.Import(D->getSuperClassLoc()),
3907 Importer.Import(D->getIvarLBraceLoc()),
3908 Importer.Import(D->getIvarRBraceLoc()));
3910 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3911 DeclContext *LexicalDC
3912 = Importer.ImportContext(D->getLexicalDeclContext());
3915 Impl->setLexicalDeclContext(LexicalDC);
3918 // Associate the implementation with the class it implements.
3919 Iface->setImplementation(Impl);
3920 Importer.Imported(D, Iface->getImplementation());
3922 Importer.Imported(D, Iface->getImplementation());
3924 // Verify that the existing @implementation has the same superclass.
3925 if ((Super && !Impl->getSuperClass()) ||
3926 (!Super && Impl->getSuperClass()) ||
3927 (Super && Impl->getSuperClass() &&
3928 !declaresSameEntity(Super->getCanonicalDecl(),
3929 Impl->getSuperClass()))) {
3930 Importer.ToDiag(Impl->getLocation(),
3931 diag::err_odr_objc_superclass_inconsistent)
3932 << Iface->getDeclName();
3933 // FIXME: It would be nice to have the location of the superclass
3935 if (Impl->getSuperClass())
3936 Importer.ToDiag(Impl->getLocation(),
3937 diag::note_odr_objc_superclass)
3938 << Impl->getSuperClass()->getDeclName();
3940 Importer.ToDiag(Impl->getLocation(),
3941 diag::note_odr_objc_missing_superclass);
3942 if (D->getSuperClass())
3943 Importer.FromDiag(D->getLocation(),
3944 diag::note_odr_objc_superclass)
3945 << D->getSuperClass()->getDeclName();
3947 Importer.FromDiag(D->getLocation(),
3948 diag::note_odr_objc_missing_superclass);
3953 // Import all of the members of this @implementation.
3954 ImportDeclContext(D);
3959 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3960 // Import the major distinguishing characteristics of an @property.
3961 DeclContext *DC, *LexicalDC;
3962 DeclarationName Name;
3965 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3970 // Check whether we have already imported this property.
3971 SmallVector<NamedDecl *, 2> FoundDecls;
3972 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3973 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3974 if (ObjCPropertyDecl *FoundProp
3975 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3976 // Check property types.
3977 if (!Importer.IsStructurallyEquivalent(D->getType(),
3978 FoundProp->getType())) {
3979 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3980 << Name << D->getType() << FoundProp->getType();
3981 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3982 << FoundProp->getType();
3986 // FIXME: Check property attributes, getters, setters, etc.?
3988 // Consider these properties to be equivalent.
3989 Importer.Imported(D, FoundProp);
3995 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
3999 // Create the new property.
4000 ObjCPropertyDecl *ToProperty
4001 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4002 Name.getAsIdentifierInfo(),
4003 Importer.Import(D->getAtLoc()),
4004 Importer.Import(D->getLParenLoc()),
4005 Importer.Import(D->getType()),
4007 D->getPropertyImplementation());
4008 Importer.Imported(D, ToProperty);
4009 ToProperty->setLexicalDeclContext(LexicalDC);
4010 LexicalDC->addDeclInternal(ToProperty);
4012 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4013 ToProperty->setPropertyAttributesAsWritten(
4014 D->getPropertyAttributesAsWritten());
4015 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4016 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4017 ToProperty->setGetterMethodDecl(
4018 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4019 ToProperty->setSetterMethodDecl(
4020 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4021 ToProperty->setPropertyIvarDecl(
4022 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4026 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4027 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4028 Importer.Import(D->getPropertyDecl()));
4032 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4036 // Import the lexical declaration context.
4037 DeclContext *LexicalDC = DC;
4038 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4039 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4044 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4048 // Import the ivar (for an @synthesize).
4049 ObjCIvarDecl *Ivar = nullptr;
4050 if (D->getPropertyIvarDecl()) {
4051 Ivar = cast_or_null<ObjCIvarDecl>(
4052 Importer.Import(D->getPropertyIvarDecl()));
4057 ObjCPropertyImplDecl *ToImpl
4058 = InImpl->FindPropertyImplDecl(Property->getIdentifier());
4060 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4061 Importer.Import(D->getLocStart()),
4062 Importer.Import(D->getLocation()),
4064 D->getPropertyImplementation(),
4066 Importer.Import(D->getPropertyIvarDeclLoc()));
4067 ToImpl->setLexicalDeclContext(LexicalDC);
4068 Importer.Imported(D, ToImpl);
4069 LexicalDC->addDeclInternal(ToImpl);
4071 // Check that we have the same kind of property implementation (@synthesize
4073 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4074 Importer.ToDiag(ToImpl->getLocation(),
4075 diag::err_odr_objc_property_impl_kind_inconsistent)
4076 << Property->getDeclName()
4077 << (ToImpl->getPropertyImplementation()
4078 == ObjCPropertyImplDecl::Dynamic);
4079 Importer.FromDiag(D->getLocation(),
4080 diag::note_odr_objc_property_impl_kind)
4081 << D->getPropertyDecl()->getDeclName()
4082 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4086 // For @synthesize, check that we have the same
4087 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4088 Ivar != ToImpl->getPropertyIvarDecl()) {
4089 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4090 diag::err_odr_objc_synthesize_ivar_inconsistent)
4091 << Property->getDeclName()
4092 << ToImpl->getPropertyIvarDecl()->getDeclName()
4093 << Ivar->getDeclName();
4094 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4095 diag::note_odr_objc_synthesize_ivar_here)
4096 << D->getPropertyIvarDecl()->getDeclName();
4100 // Merge the existing implementation with the new implementation.
4101 Importer.Imported(D, ToImpl);
4107 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4108 // For template arguments, we adopt the translation unit as our declaration
4109 // context. This context will be fixed when the actual template declaration
4112 // FIXME: Import default argument.
4113 return TemplateTypeParmDecl::Create(Importer.getToContext(),
4114 Importer.getToContext().getTranslationUnitDecl(),
4115 Importer.Import(D->getLocStart()),
4116 Importer.Import(D->getLocation()),
4119 Importer.Import(D->getIdentifier()),
4120 D->wasDeclaredWithTypename(),
4121 D->isParameterPack());
4125 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4126 // Import the name of this declaration.
4127 DeclarationName Name = Importer.Import(D->getDeclName());
4128 if (D->getDeclName() && !Name)
4131 // Import the location of this declaration.
4132 SourceLocation Loc = Importer.Import(D->getLocation());
4134 // Import the type of this declaration.
4135 QualType T = Importer.Import(D->getType());
4139 // Import type-source information.
4140 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4141 if (D->getTypeSourceInfo() && !TInfo)
4144 // FIXME: Import default argument.
4146 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4147 Importer.getToContext().getTranslationUnitDecl(),
4148 Importer.Import(D->getInnerLocStart()),
4149 Loc, D->getDepth(), D->getPosition(),
4150 Name.getAsIdentifierInfo(),
4151 T, D->isParameterPack(), TInfo);
4155 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4156 // Import the name of this declaration.
4157 DeclarationName Name = Importer.Import(D->getDeclName());
4158 if (D->getDeclName() && !Name)
4161 // Import the location of this declaration.
4162 SourceLocation Loc = Importer.Import(D->getLocation());
4164 // Import template parameters.
4165 TemplateParameterList *TemplateParams
4166 = ImportTemplateParameterList(D->getTemplateParameters());
4167 if (!TemplateParams)
4170 // FIXME: Import default argument.
4172 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4173 Importer.getToContext().getTranslationUnitDecl(),
4174 Loc, D->getDepth(), D->getPosition(),
4175 D->isParameterPack(),
4176 Name.getAsIdentifierInfo(),
4180 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4181 // If this record has a definition in the translation unit we're coming from,
4182 // but this particular declaration is not that definition, import the
4183 // definition and map to that.
4184 CXXRecordDecl *Definition
4185 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4186 if (Definition && Definition != D->getTemplatedDecl()) {
4188 = Importer.Import(Definition->getDescribedClassTemplate());
4192 return Importer.Imported(D, ImportedDef);
4195 // Import the major distinguishing characteristics of this class template.
4196 DeclContext *DC, *LexicalDC;
4197 DeclarationName Name;
4200 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4205 // We may already have a template of the same name; try to find and match it.
4206 if (!DC->isFunctionOrMethod()) {
4207 SmallVector<NamedDecl *, 4> ConflictingDecls;
4208 SmallVector<NamedDecl *, 2> FoundDecls;
4209 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4210 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4211 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4214 Decl *Found = FoundDecls[I];
4215 if (ClassTemplateDecl *FoundTemplate
4216 = dyn_cast<ClassTemplateDecl>(Found)) {
4217 if (IsStructuralMatch(D, FoundTemplate)) {
4218 // The class templates structurally match; call it the same template.
4219 // FIXME: We may be filling in a forward declaration here. Handle
4221 Importer.Imported(D->getTemplatedDecl(),
4222 FoundTemplate->getTemplatedDecl());
4223 return Importer.Imported(D, FoundTemplate);
4227 ConflictingDecls.push_back(FoundDecls[I]);
4230 if (!ConflictingDecls.empty()) {
4231 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4232 ConflictingDecls.data(),
4233 ConflictingDecls.size());
4240 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4242 // Create the declaration that is being templated.
4243 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4244 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4245 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(),
4246 DTemplated->getTagKind(),
4247 DC, StartLoc, IdLoc,
4248 Name.getAsIdentifierInfo());
4249 D2Templated->setAccess(DTemplated->getAccess());
4250 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4251 D2Templated->setLexicalDeclContext(LexicalDC);
4253 // Create the class template declaration itself.
4254 TemplateParameterList *TemplateParams
4255 = ImportTemplateParameterList(D->getTemplateParameters());
4256 if (!TemplateParams)
4259 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4260 Loc, Name, TemplateParams,
4262 /*PrevDecl=*/nullptr);
4263 D2Templated->setDescribedClassTemplate(D2);
4265 D2->setAccess(D->getAccess());
4266 D2->setLexicalDeclContext(LexicalDC);
4267 LexicalDC->addDeclInternal(D2);
4269 // Note the relationship between the class templates.
4270 Importer.Imported(D, D2);
4271 Importer.Imported(DTemplated, D2Templated);
4273 if (DTemplated->isCompleteDefinition() &&
4274 !D2Templated->isCompleteDefinition()) {
4275 // FIXME: Import definition!
4281 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4282 ClassTemplateSpecializationDecl *D) {
4283 // If this record has a definition in the translation unit we're coming from,
4284 // but this particular declaration is not that definition, import the
4285 // definition and map to that.
4286 TagDecl *Definition = D->getDefinition();
4287 if (Definition && Definition != D) {
4288 Decl *ImportedDef = Importer.Import(Definition);
4292 return Importer.Imported(D, ImportedDef);
4295 ClassTemplateDecl *ClassTemplate
4296 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4297 D->getSpecializedTemplate()));
4301 // Import the context of this declaration.
4302 DeclContext *DC = ClassTemplate->getDeclContext();
4306 DeclContext *LexicalDC = DC;
4307 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4308 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4313 // Import the location of this declaration.
4314 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4315 SourceLocation IdLoc = Importer.Import(D->getLocation());
4317 // Import template arguments.
4318 SmallVector<TemplateArgument, 2> TemplateArgs;
4319 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4320 D->getTemplateArgs().size(),
4324 // Try to find an existing specialization with these template arguments.
4325 void *InsertPos = nullptr;
4326 ClassTemplateSpecializationDecl *D2
4327 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4329 // We already have a class template specialization with these template
4332 // FIXME: Check for specialization vs. instantiation errors.
4334 if (RecordDecl *FoundDef = D2->getDefinition()) {
4335 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4336 // The record types structurally match, or the "from" translation
4337 // unit only had a forward declaration anyway; call it the same
4339 return Importer.Imported(D, FoundDef);
4343 // Create a new specialization.
4344 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4345 D->getTagKind(), DC,
4348 TemplateArgs.data(),
4349 TemplateArgs.size(),
4350 /*PrevDecl=*/nullptr);
4351 D2->setSpecializationKind(D->getSpecializationKind());
4353 // Add this specialization to the class template.
4354 ClassTemplate->AddSpecialization(D2, InsertPos);
4356 // Import the qualifier, if any.
4357 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4359 // Add the specialization to this context.
4360 D2->setLexicalDeclContext(LexicalDC);
4361 LexicalDC->addDeclInternal(D2);
4363 Importer.Imported(D, D2);
4365 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4371 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4372 // If this variable has a definition in the translation unit we're coming
4374 // but this particular declaration is not that definition, import the
4375 // definition and map to that.
4376 VarDecl *Definition =
4377 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4378 if (Definition && Definition != D->getTemplatedDecl()) {
4379 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4383 return Importer.Imported(D, ImportedDef);
4386 // Import the major distinguishing characteristics of this variable template.
4387 DeclContext *DC, *LexicalDC;
4388 DeclarationName Name;
4391 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4396 // We may already have a template of the same name; try to find and match it.
4397 assert(!DC->isFunctionOrMethod() &&
4398 "Variable templates cannot be declared at function scope");
4399 SmallVector<NamedDecl *, 4> ConflictingDecls;
4400 SmallVector<NamedDecl *, 2> FoundDecls;
4401 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4402 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4403 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4406 Decl *Found = FoundDecls[I];
4407 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4408 if (IsStructuralMatch(D, FoundTemplate)) {
4409 // The variable templates structurally match; call it the same template.
4410 Importer.Imported(D->getTemplatedDecl(),
4411 FoundTemplate->getTemplatedDecl());
4412 return Importer.Imported(D, FoundTemplate);
4416 ConflictingDecls.push_back(FoundDecls[I]);
4419 if (!ConflictingDecls.empty()) {
4420 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4421 ConflictingDecls.data(),
4422 ConflictingDecls.size());
4428 VarDecl *DTemplated = D->getTemplatedDecl();
4431 QualType T = Importer.Import(DTemplated->getType());
4435 // Create the declaration that is being templated.
4436 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4437 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4438 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4439 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4440 IdLoc, Name.getAsIdentifierInfo(), T,
4441 TInfo, DTemplated->getStorageClass());
4442 D2Templated->setAccess(DTemplated->getAccess());
4443 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4444 D2Templated->setLexicalDeclContext(LexicalDC);
4446 // Importer.Imported(DTemplated, D2Templated);
4447 // LexicalDC->addDeclInternal(D2Templated);
4449 // Merge the initializer.
4450 if (ImportDefinition(DTemplated, D2Templated))
4453 // Create the variable template declaration itself.
4454 TemplateParameterList *TemplateParams =
4455 ImportTemplateParameterList(D->getTemplateParameters());
4456 if (!TemplateParams)
4459 VarTemplateDecl *D2 = VarTemplateDecl::Create(
4460 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4461 D2Templated->setDescribedVarTemplate(D2);
4463 D2->setAccess(D->getAccess());
4464 D2->setLexicalDeclContext(LexicalDC);
4465 LexicalDC->addDeclInternal(D2);
4467 // Note the relationship between the variable templates.
4468 Importer.Imported(D, D2);
4469 Importer.Imported(DTemplated, D2Templated);
4471 if (DTemplated->isThisDeclarationADefinition() &&
4472 !D2Templated->isThisDeclarationADefinition()) {
4473 // FIXME: Import definition!
4479 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4480 VarTemplateSpecializationDecl *D) {
4481 // If this record has a definition in the translation unit we're coming from,
4482 // but this particular declaration is not that definition, import the
4483 // definition and map to that.
4484 VarDecl *Definition = D->getDefinition();
4485 if (Definition && Definition != D) {
4486 Decl *ImportedDef = Importer.Import(Definition);
4490 return Importer.Imported(D, ImportedDef);
4493 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4494 Importer.Import(D->getSpecializedTemplate()));
4498 // Import the context of this declaration.
4499 DeclContext *DC = VarTemplate->getDeclContext();
4503 DeclContext *LexicalDC = DC;
4504 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4505 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4510 // Import the location of this declaration.
4511 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4512 SourceLocation IdLoc = Importer.Import(D->getLocation());
4514 // Import template arguments.
4515 SmallVector<TemplateArgument, 2> TemplateArgs;
4516 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4517 D->getTemplateArgs().size(), TemplateArgs))
4520 // Try to find an existing specialization with these template arguments.
4521 void *InsertPos = nullptr;
4522 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4523 TemplateArgs, InsertPos);
4525 // We already have a variable template specialization with these template
4528 // FIXME: Check for specialization vs. instantiation errors.
4530 if (VarDecl *FoundDef = D2->getDefinition()) {
4531 if (!D->isThisDeclarationADefinition() ||
4532 IsStructuralMatch(D, FoundDef)) {
4533 // The record types structurally match, or the "from" translation
4534 // unit only had a forward declaration anyway; call it the same
4536 return Importer.Imported(D, FoundDef);
4542 QualType T = Importer.Import(D->getType());
4545 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4547 // Create a new specialization.
4548 D2 = VarTemplateSpecializationDecl::Create(
4549 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4550 D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size());
4551 D2->setSpecializationKind(D->getSpecializationKind());
4552 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4554 // Add this specialization to the class template.
4555 VarTemplate->AddSpecialization(D2, InsertPos);
4557 // Import the qualifier, if any.
4558 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4560 // Add the specialization to this context.
4561 D2->setLexicalDeclContext(LexicalDC);
4562 LexicalDC->addDeclInternal(D2);
4564 Importer.Imported(D, D2);
4566 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4572 //----------------------------------------------------------------------------
4573 // Import Statements
4574 //----------------------------------------------------------------------------
4576 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4578 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4579 size_t NumDecls = DG.end() - DG.begin();
4580 SmallVector<Decl *, 1> ToDecls(NumDecls);
4581 auto &_Importer = this->Importer;
4582 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4583 [&_Importer](Decl *D) -> Decl * {
4584 return _Importer.Import(D);
4586 return DeclGroupRef::Create(Importer.getToContext(),
4591 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4592 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4593 << S->getStmtClassName();
4597 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
4598 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
4599 for (Decl *ToD : ToDG) {
4603 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4604 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4605 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
4608 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
4609 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4610 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
4611 S->hasLeadingEmptyMacro());
4614 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
4615 SmallVector<Stmt *, 4> ToStmts(S->size());
4616 auto &_Importer = this->Importer;
4617 std::transform(S->body_begin(), S->body_end(), ToStmts.begin(),
4618 [&_Importer](Stmt *CS) -> Stmt * {
4619 return _Importer.Import(CS);
4621 for (Stmt *ToS : ToStmts) {
4625 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4626 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4627 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
4629 ToLBraceLoc, ToRBraceLoc);
4632 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
4633 Expr *ToLHS = Importer.Import(S->getLHS());
4636 Expr *ToRHS = Importer.Import(S->getRHS());
4637 if (!ToRHS && S->getRHS())
4639 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4640 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4641 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4642 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
4643 ToCaseLoc, ToEllipsisLoc,
4647 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
4648 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4649 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4650 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4651 if (!ToSubStmt && S->getSubStmt())
4653 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
4657 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
4658 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4659 LabelDecl *ToLabelDecl =
4660 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4661 if (!ToLabelDecl && S->getDecl())
4663 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4664 if (!ToSubStmt && S->getSubStmt())
4666 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
4670 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
4671 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4672 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
4673 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
4674 ASTContext &_ToContext = Importer.getToContext();
4675 std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
4676 [&_ToContext](const Attr *A) -> const Attr * {
4677 return A->clone(_ToContext);
4679 for (const Attr *ToA : ToAttrs) {
4683 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4684 if (!ToSubStmt && S->getSubStmt())
4686 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
4687 ToAttrs, ToSubStmt);
4690 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
4691 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4692 VarDecl *ToConditionVariable = nullptr;
4693 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4694 ToConditionVariable =
4695 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4696 if (!ToConditionVariable)
4699 Expr *ToCondition = Importer.Import(S->getCond());
4700 if (!ToCondition && S->getCond())
4702 Stmt *ToThenStmt = Importer.Import(S->getThen());
4703 if (!ToThenStmt && S->getThen())
4705 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4706 Stmt *ToElseStmt = Importer.Import(S->getElse());
4707 if (!ToElseStmt && S->getElse())
4709 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
4710 ToIfLoc, ToConditionVariable,
4711 ToCondition, ToThenStmt,
4712 ToElseLoc, ToElseStmt);
4715 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
4716 VarDecl *ToConditionVariable = nullptr;
4717 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4718 ToConditionVariable =
4719 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4720 if (!ToConditionVariable)
4723 Expr *ToCondition = Importer.Import(S->getCond());
4724 if (!ToCondition && S->getCond())
4726 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
4727 Importer.getToContext(), ToConditionVariable,
4729 Stmt *ToBody = Importer.Import(S->getBody());
4730 if (!ToBody && S->getBody())
4732 ToStmt->setBody(ToBody);
4733 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
4734 // Now we have to re-chain the cases.
4735 SwitchCase *LastChainedSwitchCase = nullptr;
4736 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
4737 SC = SC->getNextSwitchCase()) {
4738 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
4741 if (LastChainedSwitchCase)
4742 LastChainedSwitchCase->setNextSwitchCase(ToSC);
4744 ToStmt->setSwitchCaseList(ToSC);
4745 LastChainedSwitchCase = ToSC;
4750 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
4751 VarDecl *ToConditionVariable = nullptr;
4752 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4753 ToConditionVariable =
4754 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4755 if (!ToConditionVariable)
4758 Expr *ToCondition = Importer.Import(S->getCond());
4759 if (!ToCondition && S->getCond())
4761 Stmt *ToBody = Importer.Import(S->getBody());
4762 if (!ToBody && S->getBody())
4764 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4765 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
4766 ToConditionVariable,
4767 ToCondition, ToBody,
4771 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
4772 Stmt *ToBody = Importer.Import(S->getBody());
4773 if (!ToBody && S->getBody())
4775 Expr *ToCondition = Importer.Import(S->getCond());
4776 if (!ToCondition && S->getCond())
4778 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
4779 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4780 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4781 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
4782 ToDoLoc, ToWhileLoc,
4786 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
4787 Stmt *ToInit = Importer.Import(S->getInit());
4788 if (!ToInit && S->getInit())
4790 Expr *ToCondition = Importer.Import(S->getCond());
4791 if (!ToCondition && S->getCond())
4793 VarDecl *ToConditionVariable = nullptr;
4794 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4795 ToConditionVariable =
4796 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4797 if (!ToConditionVariable)
4800 Expr *ToInc = Importer.Import(S->getInc());
4801 if (!ToInc && S->getInc())
4803 Stmt *ToBody = Importer.Import(S->getBody());
4804 if (!ToBody && S->getBody())
4806 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4807 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
4808 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4809 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
4810 ToInit, ToCondition,
4811 ToConditionVariable,
4813 ToForLoc, ToLParenLoc,
4817 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
4818 LabelDecl *ToLabel = nullptr;
4819 if (LabelDecl *FromLabel = S->getLabel()) {
4820 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
4824 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4825 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
4826 return new (Importer.getToContext()) GotoStmt(ToLabel,
4827 ToGotoLoc, ToLabelLoc);
4830 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
4831 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4832 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
4833 Expr *ToTarget = Importer.Import(S->getTarget());
4834 if (!ToTarget && S->getTarget())
4836 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
4840 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
4841 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
4842 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
4845 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
4846 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
4847 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
4850 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
4851 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
4852 Expr *ToRetExpr = Importer.Import(S->getRetValue());
4853 if (!ToRetExpr && S->getRetValue())
4855 VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
4856 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
4857 if (!ToNRVOCandidate && NRVOCandidate)
4859 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
4863 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
4864 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
4865 VarDecl *ToExceptionDecl = nullptr;
4866 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
4868 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4869 if (!ToExceptionDecl)
4872 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
4873 if (!ToHandlerBlock && S->getHandlerBlock())
4875 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
4880 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
4881 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
4882 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
4883 if (!ToTryBlock && S->getTryBlock())
4885 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
4886 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
4887 CXXCatchStmt *FromHandler = S->getHandler(HI);
4888 if (Stmt *ToHandler = Importer.Import(FromHandler))
4889 ToHandlers[HI] = ToHandler;
4893 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
4897 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
4899 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
4900 if (!ToRange && S->getRangeStmt())
4902 DeclStmt *ToBeginEnd =
4903 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginEndStmt()));
4904 if (!ToBeginEnd && S->getBeginEndStmt())
4906 Expr *ToCond = Importer.Import(S->getCond());
4907 if (!ToCond && S->getCond())
4909 Expr *ToInc = Importer.Import(S->getInc());
4910 if (!ToInc && S->getInc())
4912 DeclStmt *ToLoopVar =
4913 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
4914 if (!ToLoopVar && S->getLoopVarStmt())
4916 Stmt *ToBody = Importer.Import(S->getBody());
4917 if (!ToBody && S->getBody())
4919 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4920 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4921 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4922 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBeginEnd,
4925 ToForLoc, ToColonLoc,
4929 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
4930 Stmt *ToElem = Importer.Import(S->getElement());
4931 if (!ToElem && S->getElement())
4933 Expr *ToCollect = Importer.Import(S->getCollection());
4934 if (!ToCollect && S->getCollection())
4936 Stmt *ToBody = Importer.Import(S->getBody());
4937 if (!ToBody && S->getBody())
4939 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4940 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4941 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
4947 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
4948 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
4949 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4950 VarDecl *ToExceptionDecl = nullptr;
4951 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
4953 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4954 if (!ToExceptionDecl)
4957 Stmt *ToBody = Importer.Import(S->getCatchBody());
4958 if (!ToBody && S->getCatchBody())
4960 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
4966 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
4967 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
4968 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
4969 if (!ToAtFinallyStmt && S->getFinallyBody())
4971 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
4975 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
4976 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
4977 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
4978 if (!ToAtTryStmt && S->getTryBody())
4980 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
4981 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
4982 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
4983 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
4984 ToCatchStmts[CI] = ToCatchStmt;
4988 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
4989 if (!ToAtFinallyStmt && S->getFinallyStmt())
4991 return ObjCAtTryStmt::Create(Importer.getToContext(),
4992 ToAtTryLoc, ToAtTryStmt,
4993 ToCatchStmts.begin(), ToCatchStmts.size(),
4997 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
4998 (ObjCAtSynchronizedStmt *S) {
4999 SourceLocation ToAtSynchronizedLoc =
5000 Importer.Import(S->getAtSynchronizedLoc());
5001 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5002 if (!ToSynchExpr && S->getSynchExpr())
5004 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5005 if (!ToSynchBody && S->getSynchBody())
5007 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5008 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5011 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5012 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5013 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5014 if (!ToThrow && S->getThrowExpr())
5016 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5019 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5020 (ObjCAutoreleasePoolStmt *S) {
5021 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5022 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5023 if (!ToSubStmt && S->getSubStmt())
5025 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5029 //----------------------------------------------------------------------------
5030 // Import Expressions
5031 //----------------------------------------------------------------------------
5032 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5033 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5034 << E->getStmtClassName();
5038 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5039 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5043 NamedDecl *FoundD = nullptr;
5044 if (E->getDecl() != E->getFoundDecl()) {
5045 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5050 QualType T = Importer.Import(E->getType());
5054 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5055 Importer.Import(E->getQualifierLoc()),
5056 Importer.Import(E->getTemplateKeywordLoc()),
5058 E->refersToEnclosingVariableOrCapture(),
5059 Importer.Import(E->getLocation()),
5060 T, E->getValueKind(),
5062 /*FIXME:TemplateArgs=*/nullptr);
5063 if (E->hadMultipleCandidates())
5064 DRE->setHadMultipleCandidates(true);
5068 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5069 QualType T = Importer.Import(E->getType());
5073 return IntegerLiteral::Create(Importer.getToContext(),
5075 Importer.Import(E->getLocation()));
5078 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5079 QualType T = Importer.Import(E->getType());
5083 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5085 Importer.Import(E->getLocation()));
5088 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5089 Expr *SubExpr = Importer.Import(E->getSubExpr());
5093 return new (Importer.getToContext())
5094 ParenExpr(Importer.Import(E->getLParen()),
5095 Importer.Import(E->getRParen()),
5099 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5100 QualType T = Importer.Import(E->getType());
5104 Expr *SubExpr = Importer.Import(E->getSubExpr());
5108 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
5109 T, E->getValueKind(),
5111 Importer.Import(E->getOperatorLoc()));
5114 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
5115 UnaryExprOrTypeTraitExpr *E) {
5116 QualType ResultType = Importer.Import(E->getType());
5118 if (E->isArgumentType()) {
5119 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5123 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5125 Importer.Import(E->getOperatorLoc()),
5126 Importer.Import(E->getRParenLoc()));
5129 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5133 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5134 SubExpr, ResultType,
5135 Importer.Import(E->getOperatorLoc()),
5136 Importer.Import(E->getRParenLoc()));
5139 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5140 QualType T = Importer.Import(E->getType());
5144 Expr *LHS = Importer.Import(E->getLHS());
5148 Expr *RHS = Importer.Import(E->getRHS());
5152 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5153 T, E->getValueKind(),
5155 Importer.Import(E->getOperatorLoc()),
5156 E->isFPContractable());
5159 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5160 QualType T = Importer.Import(E->getType());
5164 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5165 if (CompLHSType.isNull())
5168 QualType CompResultType = Importer.Import(E->getComputationResultType());
5169 if (CompResultType.isNull())
5172 Expr *LHS = Importer.Import(E->getLHS());
5176 Expr *RHS = Importer.Import(E->getRHS());
5180 return new (Importer.getToContext())
5181 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5182 T, E->getValueKind(),
5184 CompLHSType, CompResultType,
5185 Importer.Import(E->getOperatorLoc()),
5186 E->isFPContractable());
5189 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
5190 if (E->path_empty()) return false;
5192 // TODO: import cast paths
5196 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
5197 QualType T = Importer.Import(E->getType());
5201 Expr *SubExpr = Importer.Import(E->getSubExpr());
5205 CXXCastPath BasePath;
5206 if (ImportCastPath(E, BasePath))
5209 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5210 SubExpr, &BasePath, E->getValueKind());
5213 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
5214 QualType T = Importer.Import(E->getType());
5218 Expr *SubExpr = Importer.Import(E->getSubExpr());
5222 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5223 if (!TInfo && E->getTypeInfoAsWritten())
5226 CXXCastPath BasePath;
5227 if (ImportCastPath(E, BasePath))
5230 return CStyleCastExpr::Create(Importer.getToContext(), T,
5231 E->getValueKind(), E->getCastKind(),
5232 SubExpr, &BasePath, TInfo,
5233 Importer.Import(E->getLParenLoc()),
5234 Importer.Import(E->getRParenLoc()));
5237 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
5238 QualType T = Importer.Import(E->getType());
5242 CXXConstructorDecl *ToCCD =
5243 dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5244 if (!ToCCD && E->getConstructor())
5247 size_t NumArgs = E->getNumArgs();
5248 SmallVector<Expr *, 1> ToArgs(NumArgs);
5249 ASTImporter &_Importer = Importer;
5250 std::transform(E->arg_begin(), E->arg_end(), ToArgs.begin(),
5251 [&_Importer](Expr *AE) -> Expr * {
5252 return _Importer.Import(AE);
5254 for (Expr *ToA : ToArgs) {
5259 return CXXConstructExpr::Create(Importer.getToContext(), T,
5260 Importer.Import(E->getLocation()),
5261 ToCCD, E->isElidable(),
5262 ToArgs, E->hadMultipleCandidates(),
5263 E->isListInitialization(),
5264 E->isStdInitListInitialization(),
5265 E->requiresZeroInitialization(),
5266 E->getConstructionKind(),
5267 Importer.Import(E->getParenOrBraceRange()));
5270 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
5271 QualType T = Importer.Import(E->getType());
5275 Expr *ToBase = Importer.Import(E->getBase());
5276 if (!ToBase && E->getBase())
5279 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5280 if (!ToMember && E->getMemberDecl())
5283 DeclAccessPair ToFoundDecl = DeclAccessPair::make(
5284 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5285 E->getFoundDecl().getAccess());
5287 DeclarationNameInfo ToMemberNameInfo(
5288 Importer.Import(E->getMemberNameInfo().getName()),
5289 Importer.Import(E->getMemberNameInfo().getLoc()));
5291 if (E->hasExplicitTemplateArgs()) {
5292 return nullptr; // FIXME: handle template arguments
5295 return MemberExpr::Create(Importer.getToContext(), ToBase,
5297 Importer.Import(E->getOperatorLoc()),
5298 Importer.Import(E->getQualifierLoc()),
5299 Importer.Import(E->getTemplateKeywordLoc()),
5300 ToMember, ToFoundDecl, ToMemberNameInfo,
5301 nullptr, T, E->getValueKind(),
5302 E->getObjectKind());
5305 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
5306 QualType T = Importer.Import(E->getType());
5310 Expr *ToCallee = Importer.Import(E->getCallee());
5311 if (!ToCallee && E->getCallee())
5314 unsigned NumArgs = E->getNumArgs();
5316 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
5318 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
5319 Expr *FromArg = E->getArg(ai);
5320 Expr *ToArg = Importer.Import(FromArg);
5326 Expr **ToArgs_Copied = new (Importer.getToContext())
5329 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
5330 ToArgs_Copied[ai] = ToArgs[ai];
5332 return new (Importer.getToContext())
5333 CallExpr(Importer.getToContext(), ToCallee,
5334 ArrayRef<Expr*>(ToArgs_Copied, NumArgs), T, E->getValueKind(),
5335 Importer.Import(E->getRParenLoc()));
5338 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
5339 ASTContext &FromContext, FileManager &FromFileManager,
5341 : ToContext(ToContext), FromContext(FromContext),
5342 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
5343 Minimal(MinimalImport), LastDiagFromFrom(false)
5345 ImportedDecls[FromContext.getTranslationUnitDecl()]
5346 = ToContext.getTranslationUnitDecl();
5349 ASTImporter::~ASTImporter() { }
5351 QualType ASTImporter::Import(QualType FromT) {
5355 const Type *fromTy = FromT.getTypePtr();
5357 // Check whether we've already imported this type.
5358 llvm::DenseMap<const Type *, const Type *>::iterator Pos
5359 = ImportedTypes.find(fromTy);
5360 if (Pos != ImportedTypes.end())
5361 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
5364 ASTNodeImporter Importer(*this);
5365 QualType ToT = Importer.Visit(fromTy);
5369 // Record the imported type.
5370 ImportedTypes[fromTy] = ToT.getTypePtr();
5372 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
5375 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
5379 // FIXME: For now we just create a "trivial" type source info based
5380 // on the type and a single location. Implement a real version of this.
5381 QualType T = Import(FromTSI->getType());
5385 return ToContext.getTrivialTypeSourceInfo(T,
5386 Import(FromTSI->getTypeLoc().getLocStart()));
5389 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
5390 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
5391 if (Pos != ImportedDecls.end()) {
5392 Decl *ToD = Pos->second;
5393 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
5400 Decl *ASTImporter::Import(Decl *FromD) {
5404 ASTNodeImporter Importer(*this);
5406 // Check whether we've already imported this declaration.
5407 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
5408 if (Pos != ImportedDecls.end()) {
5409 Decl *ToD = Pos->second;
5410 Importer.ImportDefinitionIfNeeded(FromD, ToD);
5415 Decl *ToD = Importer.Visit(FromD);
5419 // Record the imported declaration.
5420 ImportedDecls[FromD] = ToD;
5422 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
5423 // Keep track of anonymous tags that have an associated typedef.
5424 if (FromTag->getTypedefNameForAnonDecl())
5425 AnonTagsWithPendingTypedefs.push_back(FromTag);
5426 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
5427 // When we've finished transforming a typedef, see whether it was the
5428 // typedef for an anonymous tag.
5429 for (SmallVectorImpl<TagDecl *>::iterator
5430 FromTag = AnonTagsWithPendingTypedefs.begin(),
5431 FromTagEnd = AnonTagsWithPendingTypedefs.end();
5432 FromTag != FromTagEnd; ++FromTag) {
5433 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
5434 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
5435 // We found the typedef for an anonymous tag; link them.
5436 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
5437 AnonTagsWithPendingTypedefs.erase(FromTag);
5447 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
5451 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
5455 // When we're using a record/enum/Objective-C class/protocol as a context, we
5456 // need it to have a definition.
5457 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
5458 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
5459 if (ToRecord->isCompleteDefinition()) {
5461 } else if (FromRecord->isCompleteDefinition()) {
5462 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
5463 ASTNodeImporter::IDK_Basic);
5465 CompleteDecl(ToRecord);
5467 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
5468 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
5469 if (ToEnum->isCompleteDefinition()) {
5471 } else if (FromEnum->isCompleteDefinition()) {
5472 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
5473 ASTNodeImporter::IDK_Basic);
5475 CompleteDecl(ToEnum);
5477 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
5478 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
5479 if (ToClass->getDefinition()) {
5481 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
5482 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
5483 ASTNodeImporter::IDK_Basic);
5485 CompleteDecl(ToClass);
5487 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
5488 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
5489 if (ToProto->getDefinition()) {
5491 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
5492 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
5493 ASTNodeImporter::IDK_Basic);
5495 CompleteDecl(ToProto);
5502 Expr *ASTImporter::Import(Expr *FromE) {
5506 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
5509 Stmt *ASTImporter::Import(Stmt *FromS) {
5513 // Check whether we've already imported this declaration.
5514 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
5515 if (Pos != ImportedStmts.end())
5519 ASTNodeImporter Importer(*this);
5520 Stmt *ToS = Importer.Visit(FromS);
5524 // Record the imported declaration.
5525 ImportedStmts[FromS] = ToS;
5529 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
5533 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
5535 switch (FromNNS->getKind()) {
5536 case NestedNameSpecifier::Identifier:
5537 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
5538 return NestedNameSpecifier::Create(ToContext, prefix, II);
5542 case NestedNameSpecifier::Namespace:
5543 if (NamespaceDecl *NS =
5544 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
5545 return NestedNameSpecifier::Create(ToContext, prefix, NS);
5549 case NestedNameSpecifier::NamespaceAlias:
5550 if (NamespaceAliasDecl *NSAD =
5551 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
5552 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
5556 case NestedNameSpecifier::Global:
5557 return NestedNameSpecifier::GlobalSpecifier(ToContext);
5559 case NestedNameSpecifier::Super:
5560 if (CXXRecordDecl *RD =
5561 cast<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
5562 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
5566 case NestedNameSpecifier::TypeSpec:
5567 case NestedNameSpecifier::TypeSpecWithTemplate: {
5568 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
5570 bool bTemplate = FromNNS->getKind() ==
5571 NestedNameSpecifier::TypeSpecWithTemplate;
5572 return NestedNameSpecifier::Create(ToContext, prefix,
5573 bTemplate, T.getTypePtr());
5579 llvm_unreachable("Invalid nested name specifier kind");
5582 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
5583 // FIXME: Implement!
5584 return NestedNameSpecifierLoc();
5587 TemplateName ASTImporter::Import(TemplateName From) {
5588 switch (From.getKind()) {
5589 case TemplateName::Template:
5590 if (TemplateDecl *ToTemplate
5591 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
5592 return TemplateName(ToTemplate);
5594 return TemplateName();
5596 case TemplateName::OverloadedTemplate: {
5597 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
5598 UnresolvedSet<2> ToTemplates;
5599 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
5600 E = FromStorage->end();
5602 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
5603 ToTemplates.addDecl(To);
5605 return TemplateName();
5607 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
5611 case TemplateName::QualifiedTemplate: {
5612 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
5613 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
5615 return TemplateName();
5617 if (TemplateDecl *ToTemplate
5618 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
5619 return ToContext.getQualifiedTemplateName(Qualifier,
5620 QTN->hasTemplateKeyword(),
5623 return TemplateName();
5626 case TemplateName::DependentTemplate: {
5627 DependentTemplateName *DTN = From.getAsDependentTemplateName();
5628 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
5630 return TemplateName();
5632 if (DTN->isIdentifier()) {
5633 return ToContext.getDependentTemplateName(Qualifier,
5634 Import(DTN->getIdentifier()));
5637 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
5640 case TemplateName::SubstTemplateTemplateParm: {
5641 SubstTemplateTemplateParmStorage *subst
5642 = From.getAsSubstTemplateTemplateParm();
5643 TemplateTemplateParmDecl *param
5644 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
5646 return TemplateName();
5648 TemplateName replacement = Import(subst->getReplacement());
5649 if (replacement.isNull()) return TemplateName();
5651 return ToContext.getSubstTemplateTemplateParm(param, replacement);
5654 case TemplateName::SubstTemplateTemplateParmPack: {
5655 SubstTemplateTemplateParmPackStorage *SubstPack
5656 = From.getAsSubstTemplateTemplateParmPack();
5657 TemplateTemplateParmDecl *Param
5658 = cast_or_null<TemplateTemplateParmDecl>(
5659 Import(SubstPack->getParameterPack()));
5661 return TemplateName();
5663 ASTNodeImporter Importer(*this);
5664 TemplateArgument ArgPack
5665 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
5666 if (ArgPack.isNull())
5667 return TemplateName();
5669 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
5673 llvm_unreachable("Invalid template name kind");
5676 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
5677 if (FromLoc.isInvalid())
5678 return SourceLocation();
5680 SourceManager &FromSM = FromContext.getSourceManager();
5682 // For now, map everything down to its spelling location, so that we
5683 // don't have to import macro expansions.
5684 // FIXME: Import macro expansions!
5685 FromLoc = FromSM.getSpellingLoc(FromLoc);
5686 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
5687 SourceManager &ToSM = ToContext.getSourceManager();
5688 FileID ToFileID = Import(Decomposed.first);
5689 if (ToFileID.isInvalid())
5690 return SourceLocation();
5691 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
5692 .getLocWithOffset(Decomposed.second);
5696 SourceRange ASTImporter::Import(SourceRange FromRange) {
5697 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
5700 FileID ASTImporter::Import(FileID FromID) {
5701 llvm::DenseMap<FileID, FileID>::iterator Pos
5702 = ImportedFileIDs.find(FromID);
5703 if (Pos != ImportedFileIDs.end())
5706 SourceManager &FromSM = FromContext.getSourceManager();
5707 SourceManager &ToSM = ToContext.getSourceManager();
5708 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
5709 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
5711 // Include location of this file.
5712 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
5714 // Map the FileID for to the "to" source manager.
5716 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
5717 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
5718 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
5720 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
5721 // than mmap the files several times.
5722 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
5725 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
5726 FromSLoc.getFile().getFileCharacteristic());
5728 // FIXME: We want to re-use the existing MemoryBuffer!
5729 const llvm::MemoryBuffer *
5730 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
5731 std::unique_ptr<llvm::MemoryBuffer> ToBuf
5732 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
5733 FromBuf->getBufferIdentifier());
5734 ToID = ToSM.createFileID(std::move(ToBuf),
5735 FromSLoc.getFile().getFileCharacteristic());
5739 ImportedFileIDs[FromID] = ToID;
5743 void ASTImporter::ImportDefinition(Decl *From) {
5744 Decl *To = Import(From);
5748 if (DeclContext *FromDC = cast<DeclContext>(From)) {
5749 ASTNodeImporter Importer(*this);
5751 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
5752 if (!ToRecord->getDefinition()) {
5753 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
5754 ASTNodeImporter::IDK_Everything);
5759 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
5760 if (!ToEnum->getDefinition()) {
5761 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
5762 ASTNodeImporter::IDK_Everything);
5767 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
5768 if (!ToIFace->getDefinition()) {
5769 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
5770 ASTNodeImporter::IDK_Everything);
5775 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
5776 if (!ToProto->getDefinition()) {
5777 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
5778 ASTNodeImporter::IDK_Everything);
5783 Importer.ImportDeclContext(FromDC, true);
5787 DeclarationName ASTImporter::Import(DeclarationName FromName) {
5789 return DeclarationName();
5791 switch (FromName.getNameKind()) {
5792 case DeclarationName::Identifier:
5793 return Import(FromName.getAsIdentifierInfo());
5795 case DeclarationName::ObjCZeroArgSelector:
5796 case DeclarationName::ObjCOneArgSelector:
5797 case DeclarationName::ObjCMultiArgSelector:
5798 return Import(FromName.getObjCSelector());
5800 case DeclarationName::CXXConstructorName: {
5801 QualType T = Import(FromName.getCXXNameType());
5803 return DeclarationName();
5805 return ToContext.DeclarationNames.getCXXConstructorName(
5806 ToContext.getCanonicalType(T));
5809 case DeclarationName::CXXDestructorName: {
5810 QualType T = Import(FromName.getCXXNameType());
5812 return DeclarationName();
5814 return ToContext.DeclarationNames.getCXXDestructorName(
5815 ToContext.getCanonicalType(T));
5818 case DeclarationName::CXXConversionFunctionName: {
5819 QualType T = Import(FromName.getCXXNameType());
5821 return DeclarationName();
5823 return ToContext.DeclarationNames.getCXXConversionFunctionName(
5824 ToContext.getCanonicalType(T));
5827 case DeclarationName::CXXOperatorName:
5828 return ToContext.DeclarationNames.getCXXOperatorName(
5829 FromName.getCXXOverloadedOperator());
5831 case DeclarationName::CXXLiteralOperatorName:
5832 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
5833 Import(FromName.getCXXLiteralIdentifier()));
5835 case DeclarationName::CXXUsingDirective:
5837 return DeclarationName::getUsingDirectiveName();
5840 llvm_unreachable("Invalid DeclarationName Kind!");
5843 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
5847 return &ToContext.Idents.get(FromId->getName());
5850 Selector ASTImporter::Import(Selector FromSel) {
5851 if (FromSel.isNull())
5854 SmallVector<IdentifierInfo *, 4> Idents;
5855 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
5856 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
5857 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
5858 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
5861 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
5865 unsigned NumDecls) {
5869 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
5870 if (LastDiagFromFrom)
5871 ToContext.getDiagnostics().notePriorDiagnosticFrom(
5872 FromContext.getDiagnostics());
5873 LastDiagFromFrom = false;
5874 return ToContext.getDiagnostics().Report(Loc, DiagID);
5877 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
5878 if (!LastDiagFromFrom)
5879 FromContext.getDiagnostics().notePriorDiagnosticFrom(
5880 ToContext.getDiagnostics());
5881 LastDiagFromFrom = true;
5882 return FromContext.getDiagnostics().Report(Loc, DiagID);
5885 void ASTImporter::CompleteDecl (Decl *D) {
5886 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
5887 if (!ID->getDefinition())
5888 ID->startDefinition();
5890 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
5891 if (!PD->getDefinition())
5892 PD->startDefinition();
5894 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
5895 if (!TD->getDefinition() && !TD->isBeingDefined()) {
5896 TD->startDefinition();
5897 TD->setCompleteDefinition(true);
5901 assert (0 && "CompleteDecl called on a Decl that can't be completed");
5905 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
5906 ImportedDecls[From] = To;
5910 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
5912 llvm::DenseMap<const Type *, const Type *>::iterator Pos
5913 = ImportedTypes.find(From.getTypePtr());
5914 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
5917 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
5919 return Ctx.IsStructurallyEquivalent(From, To);