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 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
68 // FIXME: DependentDecltypeType
69 QualType VisitRecordType(const RecordType *T);
70 QualType VisitEnumType(const EnumType *T);
71 QualType VisitAttributedType(const AttributedType *T);
72 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
73 // FIXME: SubstTemplateTypeParmType
74 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
75 QualType VisitElaboratedType(const ElaboratedType *T);
76 // FIXME: DependentNameType
77 // FIXME: DependentTemplateSpecializationType
78 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
79 QualType VisitObjCObjectType(const ObjCObjectType *T);
80 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
82 // Importing declarations
83 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
84 DeclContext *&LexicalDC, DeclarationName &Name,
85 NamedDecl *&ToD, SourceLocation &Loc);
86 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
87 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
88 DeclarationNameInfo& To);
89 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
91 typedef DesignatedInitExpr::Designator Designator;
92 Designator ImportDesignator(const Designator &D);
95 /// \brief What we should import from the definition.
96 enum ImportDefinitionKind {
97 /// \brief Import the default subset of the definition, which might be
98 /// nothing (if minimal import is set) or might be everything (if minimal
99 /// import is not set).
101 /// \brief Import everything.
103 /// \brief Import only the bare bones needed to establish a valid
108 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
109 return IDK == IDK_Everything ||
110 (IDK == IDK_Default && !Importer.isMinimalImport());
113 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
114 ImportDefinitionKind Kind = IDK_Default);
115 bool ImportDefinition(VarDecl *From, VarDecl *To,
116 ImportDefinitionKind Kind = IDK_Default);
117 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
118 ImportDefinitionKind Kind = IDK_Default);
119 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
120 ImportDefinitionKind Kind = IDK_Default);
121 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
122 ImportDefinitionKind Kind = IDK_Default);
123 TemplateParameterList *ImportTemplateParameterList(
124 TemplateParameterList *Params);
125 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
126 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
127 unsigned NumFromArgs,
128 SmallVectorImpl<TemplateArgument> &ToArgs);
129 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
130 bool Complain = true);
131 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
132 bool Complain = true);
133 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
134 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
135 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
136 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
137 Decl *VisitDecl(Decl *D);
138 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
139 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
140 Decl *VisitNamespaceDecl(NamespaceDecl *D);
141 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
142 Decl *VisitTypedefDecl(TypedefDecl *D);
143 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
144 Decl *VisitLabelDecl(LabelDecl *D);
145 Decl *VisitEnumDecl(EnumDecl *D);
146 Decl *VisitRecordDecl(RecordDecl *D);
147 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
148 Decl *VisitFunctionDecl(FunctionDecl *D);
149 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
150 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
151 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
152 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
153 Decl *VisitFieldDecl(FieldDecl *D);
154 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
155 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
156 Decl *VisitVarDecl(VarDecl *D);
157 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
158 Decl *VisitParmVarDecl(ParmVarDecl *D);
159 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
160 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
161 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
162 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
163 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
165 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
166 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
167 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
168 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
169 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
170 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
171 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
172 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
173 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
174 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
175 Decl *VisitClassTemplateSpecializationDecl(
176 ClassTemplateSpecializationDecl *D);
177 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
178 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
180 // Importing statements
181 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
183 Stmt *VisitStmt(Stmt *S);
184 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
185 Stmt *VisitDeclStmt(DeclStmt *S);
186 Stmt *VisitNullStmt(NullStmt *S);
187 Stmt *VisitCompoundStmt(CompoundStmt *S);
188 Stmt *VisitCaseStmt(CaseStmt *S);
189 Stmt *VisitDefaultStmt(DefaultStmt *S);
190 Stmt *VisitLabelStmt(LabelStmt *S);
191 Stmt *VisitAttributedStmt(AttributedStmt *S);
192 Stmt *VisitIfStmt(IfStmt *S);
193 Stmt *VisitSwitchStmt(SwitchStmt *S);
194 Stmt *VisitWhileStmt(WhileStmt *S);
195 Stmt *VisitDoStmt(DoStmt *S);
196 Stmt *VisitForStmt(ForStmt *S);
197 Stmt *VisitGotoStmt(GotoStmt *S);
198 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
199 Stmt *VisitContinueStmt(ContinueStmt *S);
200 Stmt *VisitBreakStmt(BreakStmt *S);
201 Stmt *VisitReturnStmt(ReturnStmt *S);
203 // FIXME: SEHExceptStmt
204 // FIXME: SEHFinallyStmt
206 // FIXME: SEHLeaveStmt
207 // FIXME: CapturedStmt
208 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
209 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
210 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
211 // FIXME: MSDependentExistsStmt
212 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
213 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
214 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
215 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
216 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
217 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
218 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
220 // Importing expressions
221 Expr *VisitExpr(Expr *E);
222 Expr *VisitVAArgExpr(VAArgExpr *E);
223 Expr *VisitGNUNullExpr(GNUNullExpr *E);
224 Expr *VisitPredefinedExpr(PredefinedExpr *E);
225 Expr *VisitDeclRefExpr(DeclRefExpr *E);
226 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
227 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
228 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
229 Expr *VisitIntegerLiteral(IntegerLiteral *E);
230 Expr *VisitFloatingLiteral(FloatingLiteral *E);
231 Expr *VisitCharacterLiteral(CharacterLiteral *E);
232 Expr *VisitStringLiteral(StringLiteral *E);
233 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
234 Expr *VisitAtomicExpr(AtomicExpr *E);
235 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
236 Expr *VisitParenExpr(ParenExpr *E);
237 Expr *VisitParenListExpr(ParenListExpr *E);
238 Expr *VisitStmtExpr(StmtExpr *E);
239 Expr *VisitUnaryOperator(UnaryOperator *E);
240 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
241 Expr *VisitBinaryOperator(BinaryOperator *E);
242 Expr *VisitConditionalOperator(ConditionalOperator *E);
243 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
244 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
245 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
246 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
247 Expr *VisitCStyleCastExpr(CStyleCastExpr *E);
248 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
249 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
250 Expr *VisitCXXThisExpr(CXXThisExpr *E);
251 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
252 Expr *VisitMemberExpr(MemberExpr *E);
253 Expr *VisitCallExpr(CallExpr *E);
254 Expr *VisitInitListExpr(InitListExpr *E);
256 template<typename IIter, typename OIter>
257 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
258 typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
259 ASTImporter &ImporterRef = Importer;
260 std::transform(Ibegin, Iend, Obegin,
261 [&ImporterRef](ItemT From) -> ItemT {
262 return ImporterRef.Import(From);
266 template<typename IIter, typename OIter>
267 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
268 typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
269 ASTImporter &ImporterRef = Importer;
271 std::transform(Ibegin, Iend, Obegin,
272 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
273 ItemT *To = ImporterRef.Import(From);
283 using namespace clang;
285 //----------------------------------------------------------------------------
286 // Structural Equivalence
287 //----------------------------------------------------------------------------
290 struct StructuralEquivalenceContext {
291 /// \brief AST contexts for which we are checking structural equivalence.
294 /// \brief The set of "tentative" equivalences between two canonical
295 /// declarations, mapping from a declaration in the first context to the
296 /// declaration in the second context that we believe to be equivalent.
297 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences;
299 /// \brief Queue of declarations in the first context whose equivalence
300 /// with a declaration in the second context still needs to be verified.
301 std::deque<Decl *> DeclsToCheck;
303 /// \brief Declaration (from, to) pairs that are known not to be equivalent
304 /// (which we have already complained about).
305 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls;
307 /// \brief Whether we're being strict about the spelling of types when
308 /// unifying two types.
309 bool StrictTypeSpelling;
311 /// \brief Whether to complain about failures.
314 /// \brief \c true if the last diagnostic came from C2.
317 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2,
318 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls,
319 bool StrictTypeSpelling = false,
320 bool Complain = true)
321 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls),
322 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain),
323 LastDiagFromC2(false) {}
325 /// \brief Determine whether the two declarations are structurally
327 bool IsStructurallyEquivalent(Decl *D1, Decl *D2);
329 /// \brief Determine whether the two types are structurally equivalent.
330 bool IsStructurallyEquivalent(QualType T1, QualType T2);
333 /// \brief Finish checking all of the structural equivalences.
335 /// \returns true if an error occurred, false otherwise.
339 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) {
340 assert(Complain && "Not allowed to complain");
342 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics());
343 LastDiagFromC2 = false;
344 return C1.getDiagnostics().Report(Loc, DiagID);
347 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) {
348 assert(Complain && "Not allowed to complain");
350 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics());
351 LastDiagFromC2 = true;
352 return C2.getDiagnostics().Report(Loc, DiagID);
357 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
358 QualType T1, QualType T2);
359 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
362 /// \brief Determine structural equivalence of two expressions.
363 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
364 Expr *E1, Expr *E2) {
368 // FIXME: Actually perform a structural comparison!
372 /// \brief Determine whether two identifiers are equivalent.
373 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
374 const IdentifierInfo *Name2) {
375 if (!Name1 || !Name2)
376 return Name1 == Name2;
378 return Name1->getName() == Name2->getName();
381 /// \brief Determine whether two nested-name-specifiers are equivalent.
382 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
383 NestedNameSpecifier *NNS1,
384 NestedNameSpecifier *NNS2) {
389 /// \brief Determine whether two template arguments are equivalent.
390 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
391 const TemplateArgument &Arg1,
392 const TemplateArgument &Arg2) {
393 if (Arg1.getKind() != Arg2.getKind())
396 switch (Arg1.getKind()) {
397 case TemplateArgument::Null:
400 case TemplateArgument::Type:
401 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType());
403 case TemplateArgument::Integral:
404 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(),
405 Arg2.getIntegralType()))
408 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral());
410 case TemplateArgument::Declaration:
411 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl());
413 case TemplateArgument::NullPtr:
414 return true; // FIXME: Is this correct?
416 case TemplateArgument::Template:
417 return IsStructurallyEquivalent(Context,
418 Arg1.getAsTemplate(),
419 Arg2.getAsTemplate());
421 case TemplateArgument::TemplateExpansion:
422 return IsStructurallyEquivalent(Context,
423 Arg1.getAsTemplateOrTemplatePattern(),
424 Arg2.getAsTemplateOrTemplatePattern());
426 case TemplateArgument::Expression:
427 return IsStructurallyEquivalent(Context,
428 Arg1.getAsExpr(), Arg2.getAsExpr());
430 case TemplateArgument::Pack:
431 if (Arg1.pack_size() != Arg2.pack_size())
434 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I)
435 if (!IsStructurallyEquivalent(Context,
436 Arg1.pack_begin()[I],
437 Arg2.pack_begin()[I]))
443 llvm_unreachable("Invalid template argument kind");
446 /// \brief Determine structural equivalence for the common part of array
448 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
449 const ArrayType *Array1,
450 const ArrayType *Array2) {
451 if (!IsStructurallyEquivalent(Context,
452 Array1->getElementType(),
453 Array2->getElementType()))
455 if (Array1->getSizeModifier() != Array2->getSizeModifier())
457 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers())
463 /// \brief Determine structural equivalence of two types.
464 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
465 QualType T1, QualType T2) {
466 if (T1.isNull() || T2.isNull())
467 return T1.isNull() && T2.isNull();
469 if (!Context.StrictTypeSpelling) {
470 // We aren't being strict about token-to-token equivalence of types,
471 // so map down to the canonical type.
472 T1 = Context.C1.getCanonicalType(T1);
473 T2 = Context.C2.getCanonicalType(T2);
476 if (T1.getQualifiers() != T2.getQualifiers())
479 Type::TypeClass TC = T1->getTypeClass();
481 if (T1->getTypeClass() != T2->getTypeClass()) {
482 // Compare function types with prototypes vs. without prototypes as if
483 // both did not have prototypes.
484 if (T1->getTypeClass() == Type::FunctionProto &&
485 T2->getTypeClass() == Type::FunctionNoProto)
486 TC = Type::FunctionNoProto;
487 else if (T1->getTypeClass() == Type::FunctionNoProto &&
488 T2->getTypeClass() == Type::FunctionProto)
489 TC = Type::FunctionNoProto;
496 // FIXME: Deal with Char_S/Char_U.
497 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind())
502 if (!IsStructurallyEquivalent(Context,
503 cast<ComplexType>(T1)->getElementType(),
504 cast<ComplexType>(T2)->getElementType()))
510 if (!IsStructurallyEquivalent(Context,
511 cast<AdjustedType>(T1)->getOriginalType(),
512 cast<AdjustedType>(T2)->getOriginalType()))
517 if (!IsStructurallyEquivalent(Context,
518 cast<PointerType>(T1)->getPointeeType(),
519 cast<PointerType>(T2)->getPointeeType()))
523 case Type::BlockPointer:
524 if (!IsStructurallyEquivalent(Context,
525 cast<BlockPointerType>(T1)->getPointeeType(),
526 cast<BlockPointerType>(T2)->getPointeeType()))
530 case Type::LValueReference:
531 case Type::RValueReference: {
532 const ReferenceType *Ref1 = cast<ReferenceType>(T1);
533 const ReferenceType *Ref2 = cast<ReferenceType>(T2);
534 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
536 if (Ref1->isInnerRef() != Ref2->isInnerRef())
538 if (!IsStructurallyEquivalent(Context,
539 Ref1->getPointeeTypeAsWritten(),
540 Ref2->getPointeeTypeAsWritten()))
545 case Type::MemberPointer: {
546 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
547 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
548 if (!IsStructurallyEquivalent(Context,
549 MemPtr1->getPointeeType(),
550 MemPtr2->getPointeeType()))
552 if (!IsStructurallyEquivalent(Context,
553 QualType(MemPtr1->getClass(), 0),
554 QualType(MemPtr2->getClass(), 0)))
559 case Type::ConstantArray: {
560 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
561 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
562 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
565 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
570 case Type::IncompleteArray:
571 if (!IsArrayStructurallyEquivalent(Context,
573 cast<ArrayType>(T2)))
577 case Type::VariableArray: {
578 const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
579 const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
580 if (!IsStructurallyEquivalent(Context,
581 Array1->getSizeExpr(), Array2->getSizeExpr()))
584 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
590 case Type::DependentSizedArray: {
591 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
592 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
593 if (!IsStructurallyEquivalent(Context,
594 Array1->getSizeExpr(), Array2->getSizeExpr()))
597 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2))
603 case Type::DependentSizedExtVector: {
604 const DependentSizedExtVectorType *Vec1
605 = cast<DependentSizedExtVectorType>(T1);
606 const DependentSizedExtVectorType *Vec2
607 = cast<DependentSizedExtVectorType>(T2);
608 if (!IsStructurallyEquivalent(Context,
609 Vec1->getSizeExpr(), Vec2->getSizeExpr()))
611 if (!IsStructurallyEquivalent(Context,
612 Vec1->getElementType(),
613 Vec2->getElementType()))
619 case Type::ExtVector: {
620 const VectorType *Vec1 = cast<VectorType>(T1);
621 const VectorType *Vec2 = cast<VectorType>(T2);
622 if (!IsStructurallyEquivalent(Context,
623 Vec1->getElementType(),
624 Vec2->getElementType()))
626 if (Vec1->getNumElements() != Vec2->getNumElements())
628 if (Vec1->getVectorKind() != Vec2->getVectorKind())
633 case Type::FunctionProto: {
634 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
635 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
636 if (Proto1->getNumParams() != Proto2->getNumParams())
638 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
639 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I),
640 Proto2->getParamType(I)))
643 if (Proto1->isVariadic() != Proto2->isVariadic())
645 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType())
647 if (Proto1->getExceptionSpecType() == EST_Dynamic) {
648 if (Proto1->getNumExceptions() != Proto2->getNumExceptions())
650 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) {
651 if (!IsStructurallyEquivalent(Context,
652 Proto1->getExceptionType(I),
653 Proto2->getExceptionType(I)))
656 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) {
657 if (!IsStructurallyEquivalent(Context,
658 Proto1->getNoexceptExpr(),
659 Proto2->getNoexceptExpr()))
662 if (Proto1->getTypeQuals() != Proto2->getTypeQuals())
665 // Fall through to check the bits common with FunctionNoProtoType.
668 case Type::FunctionNoProto: {
669 const FunctionType *Function1 = cast<FunctionType>(T1);
670 const FunctionType *Function2 = cast<FunctionType>(T2);
671 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
672 Function2->getReturnType()))
674 if (Function1->getExtInfo() != Function2->getExtInfo())
679 case Type::UnresolvedUsing:
680 if (!IsStructurallyEquivalent(Context,
681 cast<UnresolvedUsingType>(T1)->getDecl(),
682 cast<UnresolvedUsingType>(T2)->getDecl()))
687 case Type::Attributed:
688 if (!IsStructurallyEquivalent(Context,
689 cast<AttributedType>(T1)->getModifiedType(),
690 cast<AttributedType>(T2)->getModifiedType()))
692 if (!IsStructurallyEquivalent(Context,
693 cast<AttributedType>(T1)->getEquivalentType(),
694 cast<AttributedType>(T2)->getEquivalentType()))
699 if (!IsStructurallyEquivalent(Context,
700 cast<ParenType>(T1)->getInnerType(),
701 cast<ParenType>(T2)->getInnerType()))
706 if (!IsStructurallyEquivalent(Context,
707 cast<TypedefType>(T1)->getDecl(),
708 cast<TypedefType>(T2)->getDecl()))
712 case Type::TypeOfExpr:
713 if (!IsStructurallyEquivalent(Context,
714 cast<TypeOfExprType>(T1)->getUnderlyingExpr(),
715 cast<TypeOfExprType>(T2)->getUnderlyingExpr()))
720 if (!IsStructurallyEquivalent(Context,
721 cast<TypeOfType>(T1)->getUnderlyingType(),
722 cast<TypeOfType>(T2)->getUnderlyingType()))
726 case Type::UnaryTransform:
727 if (!IsStructurallyEquivalent(Context,
728 cast<UnaryTransformType>(T1)->getUnderlyingType(),
729 cast<UnaryTransformType>(T1)->getUnderlyingType()))
734 if (!IsStructurallyEquivalent(Context,
735 cast<DecltypeType>(T1)->getUnderlyingExpr(),
736 cast<DecltypeType>(T2)->getUnderlyingExpr()))
741 if (!IsStructurallyEquivalent(Context,
742 cast<AutoType>(T1)->getDeducedType(),
743 cast<AutoType>(T2)->getDeducedType()))
749 if (!IsStructurallyEquivalent(Context,
750 cast<TagType>(T1)->getDecl(),
751 cast<TagType>(T2)->getDecl()))
755 case Type::TemplateTypeParm: {
756 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
757 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
758 if (Parm1->getDepth() != Parm2->getDepth())
760 if (Parm1->getIndex() != Parm2->getIndex())
762 if (Parm1->isParameterPack() != Parm2->isParameterPack())
765 // Names of template type parameters are never significant.
769 case Type::SubstTemplateTypeParm: {
770 const SubstTemplateTypeParmType *Subst1
771 = cast<SubstTemplateTypeParmType>(T1);
772 const SubstTemplateTypeParmType *Subst2
773 = cast<SubstTemplateTypeParmType>(T2);
774 if (!IsStructurallyEquivalent(Context,
775 QualType(Subst1->getReplacedParameter(), 0),
776 QualType(Subst2->getReplacedParameter(), 0)))
778 if (!IsStructurallyEquivalent(Context,
779 Subst1->getReplacementType(),
780 Subst2->getReplacementType()))
785 case Type::SubstTemplateTypeParmPack: {
786 const SubstTemplateTypeParmPackType *Subst1
787 = cast<SubstTemplateTypeParmPackType>(T1);
788 const SubstTemplateTypeParmPackType *Subst2
789 = cast<SubstTemplateTypeParmPackType>(T2);
790 if (!IsStructurallyEquivalent(Context,
791 QualType(Subst1->getReplacedParameter(), 0),
792 QualType(Subst2->getReplacedParameter(), 0)))
794 if (!IsStructurallyEquivalent(Context,
795 Subst1->getArgumentPack(),
796 Subst2->getArgumentPack()))
800 case Type::TemplateSpecialization: {
801 const TemplateSpecializationType *Spec1
802 = cast<TemplateSpecializationType>(T1);
803 const TemplateSpecializationType *Spec2
804 = cast<TemplateSpecializationType>(T2);
805 if (!IsStructurallyEquivalent(Context,
806 Spec1->getTemplateName(),
807 Spec2->getTemplateName()))
809 if (Spec1->getNumArgs() != Spec2->getNumArgs())
811 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
812 if (!IsStructurallyEquivalent(Context,
813 Spec1->getArg(I), Spec2->getArg(I)))
819 case Type::Elaborated: {
820 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
821 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
822 // CHECKME: what if a keyword is ETK_None or ETK_typename ?
823 if (Elab1->getKeyword() != Elab2->getKeyword())
825 if (!IsStructurallyEquivalent(Context,
826 Elab1->getQualifier(),
827 Elab2->getQualifier()))
829 if (!IsStructurallyEquivalent(Context,
830 Elab1->getNamedType(),
831 Elab2->getNamedType()))
836 case Type::InjectedClassName: {
837 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
838 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
839 if (!IsStructurallyEquivalent(Context,
840 Inj1->getInjectedSpecializationType(),
841 Inj2->getInjectedSpecializationType()))
846 case Type::DependentName: {
847 const DependentNameType *Typename1 = cast<DependentNameType>(T1);
848 const DependentNameType *Typename2 = cast<DependentNameType>(T2);
849 if (!IsStructurallyEquivalent(Context,
850 Typename1->getQualifier(),
851 Typename2->getQualifier()))
853 if (!IsStructurallyEquivalent(Typename1->getIdentifier(),
854 Typename2->getIdentifier()))
860 case Type::DependentTemplateSpecialization: {
861 const DependentTemplateSpecializationType *Spec1 =
862 cast<DependentTemplateSpecializationType>(T1);
863 const DependentTemplateSpecializationType *Spec2 =
864 cast<DependentTemplateSpecializationType>(T2);
865 if (!IsStructurallyEquivalent(Context,
866 Spec1->getQualifier(),
867 Spec2->getQualifier()))
869 if (!IsStructurallyEquivalent(Spec1->getIdentifier(),
870 Spec2->getIdentifier()))
872 if (Spec1->getNumArgs() != Spec2->getNumArgs())
874 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) {
875 if (!IsStructurallyEquivalent(Context,
876 Spec1->getArg(I), Spec2->getArg(I)))
882 case Type::PackExpansion:
883 if (!IsStructurallyEquivalent(Context,
884 cast<PackExpansionType>(T1)->getPattern(),
885 cast<PackExpansionType>(T2)->getPattern()))
889 case Type::ObjCInterface: {
890 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
891 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
892 if (!IsStructurallyEquivalent(Context,
893 Iface1->getDecl(), Iface2->getDecl()))
898 case Type::ObjCObject: {
899 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
900 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
901 if (!IsStructurallyEquivalent(Context,
903 Obj2->getBaseType()))
905 if (Obj1->getNumProtocols() != Obj2->getNumProtocols())
907 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) {
908 if (!IsStructurallyEquivalent(Context,
909 Obj1->getProtocol(I),
910 Obj2->getProtocol(I)))
916 case Type::ObjCObjectPointer: {
917 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
918 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
919 if (!IsStructurallyEquivalent(Context,
920 Ptr1->getPointeeType(),
921 Ptr2->getPointeeType()))
927 if (!IsStructurallyEquivalent(Context,
928 cast<AtomicType>(T1)->getValueType(),
929 cast<AtomicType>(T2)->getValueType()))
935 if (!IsStructurallyEquivalent(Context,
936 cast<PipeType>(T1)->getElementType(),
937 cast<PipeType>(T2)->getElementType()))
947 /// \brief Determine structural equivalence of two fields.
948 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
949 FieldDecl *Field1, FieldDecl *Field2) {
950 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
952 // For anonymous structs/unions, match up the anonymous struct/union type
953 // declarations directly, so that we don't go off searching for anonymous
955 if (Field1->isAnonymousStructOrUnion() &&
956 Field2->isAnonymousStructOrUnion()) {
957 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl();
958 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl();
959 return IsStructurallyEquivalent(Context, D1, D2);
962 // Check for equivalent field names.
963 IdentifierInfo *Name1 = Field1->getIdentifier();
964 IdentifierInfo *Name2 = Field2->getIdentifier();
965 if (!::IsStructurallyEquivalent(Name1, Name2))
968 if (!IsStructurallyEquivalent(Context,
969 Field1->getType(), Field2->getType())) {
970 if (Context.Complain) {
971 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
972 << Context.C2.getTypeDeclType(Owner2);
973 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
974 << Field2->getDeclName() << Field2->getType();
975 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
976 << Field1->getDeclName() << Field1->getType();
981 if (Field1->isBitField() != Field2->isBitField()) {
982 if (Context.Complain) {
983 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
984 << Context.C2.getTypeDeclType(Owner2);
985 if (Field1->isBitField()) {
986 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
987 << Field1->getDeclName() << Field1->getType()
988 << Field1->getBitWidthValue(Context.C1);
989 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field)
990 << Field2->getDeclName();
992 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
993 << Field2->getDeclName() << Field2->getType()
994 << Field2->getBitWidthValue(Context.C2);
995 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field)
996 << Field1->getDeclName();
1002 if (Field1->isBitField()) {
1003 // Make sure that the bit-fields are the same length.
1004 unsigned Bits1 = Field1->getBitWidthValue(Context.C1);
1005 unsigned Bits2 = Field2->getBitWidthValue(Context.C2);
1007 if (Bits1 != Bits2) {
1008 if (Context.Complain) {
1009 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1010 << Context.C2.getTypeDeclType(Owner2);
1011 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field)
1012 << Field2->getDeclName() << Field2->getType() << Bits2;
1013 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field)
1014 << Field1->getDeclName() << Field1->getType() << Bits1;
1023 /// \brief Find the index of the given anonymous struct/union within its
1026 /// \returns Returns the index of this anonymous struct/union in its context,
1027 /// including the next assigned index (if none of them match). Returns an
1028 /// empty option if the context is not a record, i.e.. if the anonymous
1029 /// struct/union is at namespace or block scope.
1030 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) {
1031 ASTContext &Context = Anon->getASTContext();
1032 QualType AnonTy = Context.getRecordType(Anon);
1034 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
1039 for (const auto *D : Owner->noload_decls()) {
1040 const auto *F = dyn_cast<FieldDecl>(D);
1041 if (!F || !F->isAnonymousStructOrUnion())
1044 if (Context.hasSameType(F->getType(), AnonTy))
1053 /// \brief Determine structural equivalence of two records.
1054 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1055 RecordDecl *D1, RecordDecl *D2) {
1056 if (D1->isUnion() != D2->isUnion()) {
1057 if (Context.Complain) {
1058 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1059 << Context.C2.getTypeDeclType(D2);
1060 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here)
1061 << D1->getDeclName() << (unsigned)D1->getTagKind();
1066 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) {
1067 // If both anonymous structs/unions are in a record context, make sure
1068 // they occur in the same location in the context records.
1069 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) {
1070 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) {
1071 if (*Index1 != *Index2)
1077 // If both declarations are class template specializations, we know
1078 // the ODR applies, so check the template and template arguments.
1079 ClassTemplateSpecializationDecl *Spec1
1080 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
1081 ClassTemplateSpecializationDecl *Spec2
1082 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
1083 if (Spec1 && Spec2) {
1084 // Check that the specialized templates are the same.
1085 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
1086 Spec2->getSpecializedTemplate()))
1089 // Check that the template arguments are the same.
1090 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size())
1093 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I)
1094 if (!IsStructurallyEquivalent(Context,
1095 Spec1->getTemplateArgs().get(I),
1096 Spec2->getTemplateArgs().get(I)))
1099 // If one is a class template specialization and the other is not, these
1100 // structures are different.
1101 else if (Spec1 || Spec2)
1104 // Compare the definitions of these two records. If either or both are
1105 // incomplete, we assume that they are equivalent.
1106 D1 = D1->getDefinition();
1107 D2 = D2->getDefinition();
1111 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
1112 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
1113 if (D1CXX->getNumBases() != D2CXX->getNumBases()) {
1114 if (Context.Complain) {
1115 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1116 << Context.C2.getTypeDeclType(D2);
1117 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases)
1118 << D2CXX->getNumBases();
1119 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases)
1120 << D1CXX->getNumBases();
1125 // Check the base classes.
1126 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(),
1127 BaseEnd1 = D1CXX->bases_end(),
1128 Base2 = D2CXX->bases_begin();
1131 if (!IsStructurallyEquivalent(Context,
1132 Base1->getType(), Base2->getType())) {
1133 if (Context.Complain) {
1134 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1135 << Context.C2.getTypeDeclType(D2);
1136 Context.Diag2(Base2->getLocStart(), diag::note_odr_base)
1138 << Base2->getSourceRange();
1139 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1141 << Base1->getSourceRange();
1146 // Check virtual vs. non-virtual inheritance mismatch.
1147 if (Base1->isVirtual() != Base2->isVirtual()) {
1148 if (Context.Complain) {
1149 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1150 << Context.C2.getTypeDeclType(D2);
1151 Context.Diag2(Base2->getLocStart(),
1152 diag::note_odr_virtual_base)
1153 << Base2->isVirtual() << Base2->getSourceRange();
1154 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1155 << Base1->isVirtual()
1156 << Base1->getSourceRange();
1161 } else if (D1CXX->getNumBases() > 0) {
1162 if (Context.Complain) {
1163 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1164 << Context.C2.getTypeDeclType(D2);
1165 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
1166 Context.Diag1(Base1->getLocStart(), diag::note_odr_base)
1168 << Base1->getSourceRange();
1169 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
1175 // Check the fields for consistency.
1176 RecordDecl::field_iterator Field2 = D2->field_begin(),
1177 Field2End = D2->field_end();
1178 for (RecordDecl::field_iterator Field1 = D1->field_begin(),
1179 Field1End = D1->field_end();
1180 Field1 != Field1End;
1181 ++Field1, ++Field2) {
1182 if (Field2 == Field2End) {
1183 if (Context.Complain) {
1184 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1185 << Context.C2.getTypeDeclType(D2);
1186 Context.Diag1(Field1->getLocation(), diag::note_odr_field)
1187 << Field1->getDeclName() << Field1->getType();
1188 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field);
1193 if (!IsStructurallyEquivalent(Context, *Field1, *Field2))
1197 if (Field2 != Field2End) {
1198 if (Context.Complain) {
1199 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1200 << Context.C2.getTypeDeclType(D2);
1201 Context.Diag2(Field2->getLocation(), diag::note_odr_field)
1202 << Field2->getDeclName() << Field2->getType();
1203 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field);
1211 /// \brief Determine structural equivalence of two enums.
1212 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1213 EnumDecl *D1, EnumDecl *D2) {
1214 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(),
1215 EC2End = D2->enumerator_end();
1216 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(),
1217 EC1End = D1->enumerator_end();
1218 EC1 != EC1End; ++EC1, ++EC2) {
1219 if (EC2 == EC2End) {
1220 if (Context.Complain) {
1221 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1222 << Context.C2.getTypeDeclType(D2);
1223 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1224 << EC1->getDeclName()
1225 << EC1->getInitVal().toString(10);
1226 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator);
1231 llvm::APSInt Val1 = EC1->getInitVal();
1232 llvm::APSInt Val2 = EC2->getInitVal();
1233 if (!llvm::APSInt::isSameValue(Val1, Val2) ||
1234 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) {
1235 if (Context.Complain) {
1236 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1237 << Context.C2.getTypeDeclType(D2);
1238 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1239 << EC2->getDeclName()
1240 << EC2->getInitVal().toString(10);
1241 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator)
1242 << EC1->getDeclName()
1243 << EC1->getInitVal().toString(10);
1249 if (EC2 != EC2End) {
1250 if (Context.Complain) {
1251 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent)
1252 << Context.C2.getTypeDeclType(D2);
1253 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator)
1254 << EC2->getDeclName()
1255 << EC2->getInitVal().toString(10);
1256 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator);
1264 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1265 TemplateParameterList *Params1,
1266 TemplateParameterList *Params2) {
1267 if (Params1->size() != Params2->size()) {
1268 if (Context.Complain) {
1269 Context.Diag2(Params2->getTemplateLoc(),
1270 diag::err_odr_different_num_template_parameters)
1271 << Params1->size() << Params2->size();
1272 Context.Diag1(Params1->getTemplateLoc(),
1273 diag::note_odr_template_parameter_list);
1278 for (unsigned I = 0, N = Params1->size(); I != N; ++I) {
1279 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) {
1280 if (Context.Complain) {
1281 Context.Diag2(Params2->getParam(I)->getLocation(),
1282 diag::err_odr_different_template_parameter_kind);
1283 Context.Diag1(Params1->getParam(I)->getLocation(),
1284 diag::note_odr_template_parameter_here);
1289 if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
1290 Params2->getParam(I))) {
1299 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1300 TemplateTypeParmDecl *D1,
1301 TemplateTypeParmDecl *D2) {
1302 if (D1->isParameterPack() != D2->isParameterPack()) {
1303 if (Context.Complain) {
1304 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1305 << D2->isParameterPack();
1306 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1307 << D1->isParameterPack();
1315 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1316 NonTypeTemplateParmDecl *D1,
1317 NonTypeTemplateParmDecl *D2) {
1318 if (D1->isParameterPack() != D2->isParameterPack()) {
1319 if (Context.Complain) {
1320 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1321 << D2->isParameterPack();
1322 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1323 << D1->isParameterPack();
1329 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) {
1330 if (Context.Complain) {
1331 Context.Diag2(D2->getLocation(),
1332 diag::err_odr_non_type_parameter_type_inconsistent)
1333 << D2->getType() << D1->getType();
1334 Context.Diag1(D1->getLocation(), diag::note_odr_value_here)
1343 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1344 TemplateTemplateParmDecl *D1,
1345 TemplateTemplateParmDecl *D2) {
1346 if (D1->isParameterPack() != D2->isParameterPack()) {
1347 if (Context.Complain) {
1348 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack)
1349 << D2->isParameterPack();
1350 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack)
1351 << D1->isParameterPack();
1356 // Check template parameter lists.
1357 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(),
1358 D2->getTemplateParameters());
1361 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1362 ClassTemplateDecl *D1,
1363 ClassTemplateDecl *D2) {
1364 // Check template parameters.
1365 if (!IsStructurallyEquivalent(Context,
1366 D1->getTemplateParameters(),
1367 D2->getTemplateParameters()))
1370 // Check the templated declaration.
1371 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(),
1372 D2->getTemplatedDecl());
1375 /// \brief Determine structural equivalence of two declarations.
1376 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
1377 Decl *D1, Decl *D2) {
1378 // FIXME: Check for known structural equivalences via a callback of some sort.
1380 // Check whether we already know that these two declarations are not
1381 // structurally equivalent.
1382 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(),
1383 D2->getCanonicalDecl())))
1386 // Determine whether we've already produced a tentative equivalence for D1.
1387 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()];
1389 return EquivToD1 == D2->getCanonicalDecl();
1391 // Produce a tentative equivalence D1 <-> D2, which will be checked later.
1392 EquivToD1 = D2->getCanonicalDecl();
1393 Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
1397 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1,
1399 if (!::IsStructurallyEquivalent(*this, D1, D2))
1405 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1,
1407 if (!::IsStructurallyEquivalent(*this, T1, T2))
1413 bool StructuralEquivalenceContext::Finish() {
1414 while (!DeclsToCheck.empty()) {
1415 // Check the next declaration.
1416 Decl *D1 = DeclsToCheck.front();
1417 DeclsToCheck.pop_front();
1419 Decl *D2 = TentativeEquivalences[D1];
1420 assert(D2 && "Unrecorded tentative equivalence?");
1422 bool Equivalent = true;
1424 // FIXME: Switch on all declaration kinds. For now, we're just going to
1425 // check the obvious ones.
1426 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
1427 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
1428 // Check for equivalent structure names.
1429 IdentifierInfo *Name1 = Record1->getIdentifier();
1430 if (!Name1 && Record1->getTypedefNameForAnonDecl())
1431 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier();
1432 IdentifierInfo *Name2 = Record2->getIdentifier();
1433 if (!Name2 && Record2->getTypedefNameForAnonDecl())
1434 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier();
1435 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1436 !::IsStructurallyEquivalent(*this, Record1, Record2))
1439 // Record/non-record mismatch.
1442 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
1443 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
1444 // Check for equivalent enum names.
1445 IdentifierInfo *Name1 = Enum1->getIdentifier();
1446 if (!Name1 && Enum1->getTypedefNameForAnonDecl())
1447 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier();
1448 IdentifierInfo *Name2 = Enum2->getIdentifier();
1449 if (!Name2 && Enum2->getTypedefNameForAnonDecl())
1450 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier();
1451 if (!::IsStructurallyEquivalent(Name1, Name2) ||
1452 !::IsStructurallyEquivalent(*this, Enum1, Enum2))
1455 // Enum/non-enum mismatch
1458 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
1459 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
1460 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
1461 Typedef2->getIdentifier()) ||
1462 !::IsStructurallyEquivalent(*this,
1463 Typedef1->getUnderlyingType(),
1464 Typedef2->getUnderlyingType()))
1467 // Typedef/non-typedef mismatch.
1470 } else if (ClassTemplateDecl *ClassTemplate1
1471 = dyn_cast<ClassTemplateDecl>(D1)) {
1472 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
1473 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(),
1474 ClassTemplate2->getIdentifier()) ||
1475 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2))
1478 // Class template/non-class-template mismatch.
1481 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) {
1482 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
1483 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1489 } else if (NonTypeTemplateParmDecl *NTTP1
1490 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
1491 if (NonTypeTemplateParmDecl *NTTP2
1492 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
1493 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
1499 } else if (TemplateTemplateParmDecl *TTP1
1500 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
1501 if (TemplateTemplateParmDecl *TTP2
1502 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
1503 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
1512 // Note that these two declarations are not equivalent (and we already
1514 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(),
1515 D2->getCanonicalDecl()));
1518 // FIXME: Check other declaration kinds!
1524 //----------------------------------------------------------------------------
1526 //----------------------------------------------------------------------------
1528 QualType ASTNodeImporter::VisitType(const Type *T) {
1529 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1530 << T->getTypeClassName();
1534 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1535 switch (T->getKind()) {
1536 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1537 case BuiltinType::Id: \
1538 return Importer.getToContext().SingletonId;
1539 #include "clang/Basic/OpenCLImageTypes.def"
1540 #define SHARED_SINGLETON_TYPE(Expansion)
1541 #define BUILTIN_TYPE(Id, SingletonId) \
1542 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1543 #include "clang/AST/BuiltinTypes.def"
1545 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1546 // context supports C++.
1548 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1549 // context supports ObjC.
1551 case BuiltinType::Char_U:
1552 // The context we're importing from has an unsigned 'char'. If we're
1553 // importing into a context with a signed 'char', translate to
1554 // 'unsigned char' instead.
1555 if (Importer.getToContext().getLangOpts().CharIsSigned)
1556 return Importer.getToContext().UnsignedCharTy;
1558 return Importer.getToContext().CharTy;
1560 case BuiltinType::Char_S:
1561 // The context we're importing from has an unsigned 'char'. If we're
1562 // importing into a context with a signed 'char', translate to
1563 // 'unsigned char' instead.
1564 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1565 return Importer.getToContext().SignedCharTy;
1567 return Importer.getToContext().CharTy;
1569 case BuiltinType::WChar_S:
1570 case BuiltinType::WChar_U:
1571 // FIXME: If not in C++, shall we translate to the C equivalent of
1573 return Importer.getToContext().WCharTy;
1576 llvm_unreachable("Invalid BuiltinType Kind!");
1579 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1580 QualType ToElementType = Importer.Import(T->getElementType());
1581 if (ToElementType.isNull())
1584 return Importer.getToContext().getComplexType(ToElementType);
1587 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1588 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1589 if (ToPointeeType.isNull())
1592 return Importer.getToContext().getPointerType(ToPointeeType);
1595 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1596 // FIXME: Check for blocks support in "to" context.
1597 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1598 if (ToPointeeType.isNull())
1601 return Importer.getToContext().getBlockPointerType(ToPointeeType);
1605 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1606 // FIXME: Check for C++ support in "to" context.
1607 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1608 if (ToPointeeType.isNull())
1611 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
1615 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1616 // FIXME: Check for C++0x support in "to" context.
1617 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
1618 if (ToPointeeType.isNull())
1621 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
1624 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1625 // FIXME: Check for C++ support in "to" context.
1626 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1627 if (ToPointeeType.isNull())
1630 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
1631 return Importer.getToContext().getMemberPointerType(ToPointeeType,
1632 ClassType.getTypePtr());
1635 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1636 QualType ToElementType = Importer.Import(T->getElementType());
1637 if (ToElementType.isNull())
1640 return Importer.getToContext().getConstantArrayType(ToElementType,
1642 T->getSizeModifier(),
1643 T->getIndexTypeCVRQualifiers());
1647 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1648 QualType ToElementType = Importer.Import(T->getElementType());
1649 if (ToElementType.isNull())
1652 return Importer.getToContext().getIncompleteArrayType(ToElementType,
1653 T->getSizeModifier(),
1654 T->getIndexTypeCVRQualifiers());
1657 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1658 QualType ToElementType = Importer.Import(T->getElementType());
1659 if (ToElementType.isNull())
1662 Expr *Size = Importer.Import(T->getSizeExpr());
1666 SourceRange Brackets = Importer.Import(T->getBracketsRange());
1667 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
1668 T->getSizeModifier(),
1669 T->getIndexTypeCVRQualifiers(),
1673 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1674 QualType ToElementType = Importer.Import(T->getElementType());
1675 if (ToElementType.isNull())
1678 return Importer.getToContext().getVectorType(ToElementType,
1679 T->getNumElements(),
1680 T->getVectorKind());
1683 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1684 QualType ToElementType = Importer.Import(T->getElementType());
1685 if (ToElementType.isNull())
1688 return Importer.getToContext().getExtVectorType(ToElementType,
1689 T->getNumElements());
1693 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1694 // FIXME: What happens if we're importing a function without a prototype
1695 // into C++? Should we make it variadic?
1696 QualType ToResultType = Importer.Import(T->getReturnType());
1697 if (ToResultType.isNull())
1700 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
1704 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1705 QualType ToResultType = Importer.Import(T->getReturnType());
1706 if (ToResultType.isNull())
1709 // Import argument types
1710 SmallVector<QualType, 4> ArgTypes;
1711 for (const auto &A : T->param_types()) {
1712 QualType ArgType = Importer.Import(A);
1713 if (ArgType.isNull())
1715 ArgTypes.push_back(ArgType);
1718 // Import exception types
1719 SmallVector<QualType, 4> ExceptionTypes;
1720 for (const auto &E : T->exceptions()) {
1721 QualType ExceptionType = Importer.Import(E);
1722 if (ExceptionType.isNull())
1724 ExceptionTypes.push_back(ExceptionType);
1727 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1728 FunctionProtoType::ExtProtoInfo ToEPI;
1730 ToEPI.ExtInfo = FromEPI.ExtInfo;
1731 ToEPI.Variadic = FromEPI.Variadic;
1732 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1733 ToEPI.TypeQuals = FromEPI.TypeQuals;
1734 ToEPI.RefQualifier = FromEPI.RefQualifier;
1735 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1736 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1737 ToEPI.ExceptionSpec.NoexceptExpr =
1738 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
1739 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
1740 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
1741 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
1742 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
1744 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
1747 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
1748 QualType ToInnerType = Importer.Import(T->getInnerType());
1749 if (ToInnerType.isNull())
1752 return Importer.getToContext().getParenType(ToInnerType);
1755 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1756 TypedefNameDecl *ToDecl
1757 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
1761 return Importer.getToContext().getTypeDeclType(ToDecl);
1764 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1765 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1769 return Importer.getToContext().getTypeOfExprType(ToExpr);
1772 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1773 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1774 if (ToUnderlyingType.isNull())
1777 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
1780 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1781 // FIXME: Make sure that the "to" context supports C++0x!
1782 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
1786 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
1787 if (UnderlyingType.isNull())
1790 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
1793 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1794 QualType ToBaseType = Importer.Import(T->getBaseType());
1795 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
1796 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
1799 return Importer.getToContext().getUnaryTransformType(ToBaseType,
1804 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1805 // FIXME: Make sure that the "to" context supports C++11!
1806 QualType FromDeduced = T->getDeducedType();
1808 if (!FromDeduced.isNull()) {
1809 ToDeduced = Importer.Import(FromDeduced);
1810 if (ToDeduced.isNull())
1814 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
1815 /*IsDependent*/false);
1818 QualType ASTNodeImporter::VisitInjectedClassNameType(
1819 const InjectedClassNameType *T) {
1820 CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
1824 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
1825 if (InjType.isNull())
1828 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
1829 // See comments in InjectedClassNameType definition for details
1830 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
1832 TypeAlignmentInBits = 4,
1833 TypeAlignment = 1 << TypeAlignmentInBits
1836 return QualType(new (Importer.getToContext(), TypeAlignment)
1837 InjectedClassNameType(D, InjType), 0);
1840 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1842 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
1846 return Importer.getToContext().getTagDeclType(ToDecl);
1849 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1851 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
1855 return Importer.getToContext().getTagDeclType(ToDecl);
1858 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1859 QualType FromModifiedType = T->getModifiedType();
1860 QualType FromEquivalentType = T->getEquivalentType();
1861 QualType ToModifiedType;
1862 QualType ToEquivalentType;
1864 if (!FromModifiedType.isNull()) {
1865 ToModifiedType = Importer.Import(FromModifiedType);
1866 if (ToModifiedType.isNull())
1869 if (!FromEquivalentType.isNull()) {
1870 ToEquivalentType = Importer.Import(FromEquivalentType);
1871 if (ToEquivalentType.isNull())
1875 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1876 ToModifiedType, ToEquivalentType);
1880 QualType ASTNodeImporter::VisitTemplateTypeParmType(
1881 const TemplateTypeParmType *T) {
1882 TemplateTypeParmDecl *ParmDecl =
1883 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
1884 if (!ParmDecl && T->getDecl())
1887 return Importer.getToContext().getTemplateTypeParmType(
1888 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
1891 QualType ASTNodeImporter::VisitTemplateSpecializationType(
1892 const TemplateSpecializationType *T) {
1893 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1894 if (ToTemplate.isNull())
1897 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1898 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1901 QualType ToCanonType;
1902 if (!QualType(T, 0).isCanonical()) {
1903 QualType FromCanonType
1904 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1905 ToCanonType =Importer.Import(FromCanonType);
1906 if (ToCanonType.isNull())
1909 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1910 ToTemplateArgs.data(),
1911 ToTemplateArgs.size(),
1915 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1916 NestedNameSpecifier *ToQualifier = nullptr;
1917 // Note: the qualifier in an ElaboratedType is optional.
1918 if (T->getQualifier()) {
1919 ToQualifier = Importer.Import(T->getQualifier());
1924 QualType ToNamedType = Importer.Import(T->getNamedType());
1925 if (ToNamedType.isNull())
1928 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1929 ToQualifier, ToNamedType);
1932 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1933 ObjCInterfaceDecl *Class
1934 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1938 return Importer.getToContext().getObjCInterfaceType(Class);
1941 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1942 QualType ToBaseType = Importer.Import(T->getBaseType());
1943 if (ToBaseType.isNull())
1946 SmallVector<QualType, 4> TypeArgs;
1947 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1948 QualType ImportedTypeArg = Importer.Import(TypeArg);
1949 if (ImportedTypeArg.isNull())
1952 TypeArgs.push_back(ImportedTypeArg);
1955 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1956 for (auto *P : T->quals()) {
1957 ObjCProtocolDecl *Protocol
1958 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1961 Protocols.push_back(Protocol);
1964 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1966 T->isKindOfTypeAsWritten());
1970 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1971 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1972 if (ToPointeeType.isNull())
1975 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1978 //----------------------------------------------------------------------------
1979 // Import Declarations
1980 //----------------------------------------------------------------------------
1981 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1982 DeclContext *&LexicalDC,
1983 DeclarationName &Name,
1985 SourceLocation &Loc) {
1986 // Import the context of this declaration.
1987 DC = Importer.ImportContext(D->getDeclContext());
1992 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1993 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1998 // Import the name of this declaration.
1999 Name = Importer.Import(D->getDeclName());
2000 if (D->getDeclName() && !Name)
2003 // Import the location of this declaration.
2004 Loc = Importer.Import(D->getLocation());
2005 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
2009 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2014 ToD = Importer.Import(FromD);
2019 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
2020 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
2021 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
2022 ImportDefinition(FromRecord, ToRecord);
2028 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
2029 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
2030 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2031 ImportDefinition(FromEnum, ToEnum);
2039 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
2040 DeclarationNameInfo& To) {
2041 // NOTE: To.Name and To.Loc are already imported.
2042 // We only have to import To.LocInfo.
2043 switch (To.getName().getNameKind()) {
2044 case DeclarationName::Identifier:
2045 case DeclarationName::ObjCZeroArgSelector:
2046 case DeclarationName::ObjCOneArgSelector:
2047 case DeclarationName::ObjCMultiArgSelector:
2048 case DeclarationName::CXXUsingDirective:
2051 case DeclarationName::CXXOperatorName: {
2052 SourceRange Range = From.getCXXOperatorNameRange();
2053 To.setCXXOperatorNameRange(Importer.Import(Range));
2056 case DeclarationName::CXXLiteralOperatorName: {
2057 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
2058 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
2061 case DeclarationName::CXXConstructorName:
2062 case DeclarationName::CXXDestructorName:
2063 case DeclarationName::CXXConversionFunctionName: {
2064 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
2065 To.setNamedTypeInfo(Importer.Import(FromTInfo));
2069 llvm_unreachable("Unknown name kind.");
2072 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2073 if (Importer.isMinimalImport() && !ForceImport) {
2074 Importer.ImportContext(FromDC);
2078 for (auto *From : FromDC->decls())
2079 Importer.Import(From);
2082 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
2083 ImportDefinitionKind Kind) {
2084 if (To->getDefinition() || To->isBeingDefined()) {
2085 if (Kind == IDK_Everything)
2086 ImportDeclContext(From, /*ForceImport=*/true);
2091 To->startDefinition();
2093 // Add base classes.
2094 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
2095 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
2097 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2098 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2099 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
2100 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
2101 ToData.Aggregate = FromData.Aggregate;
2102 ToData.PlainOldData = FromData.PlainOldData;
2103 ToData.Empty = FromData.Empty;
2104 ToData.Polymorphic = FromData.Polymorphic;
2105 ToData.Abstract = FromData.Abstract;
2106 ToData.IsStandardLayout = FromData.IsStandardLayout;
2107 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
2108 ToData.HasPrivateFields = FromData.HasPrivateFields;
2109 ToData.HasProtectedFields = FromData.HasProtectedFields;
2110 ToData.HasPublicFields = FromData.HasPublicFields;
2111 ToData.HasMutableFields = FromData.HasMutableFields;
2112 ToData.HasVariantMembers = FromData.HasVariantMembers;
2113 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
2114 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
2115 ToData.HasUninitializedReferenceMember
2116 = FromData.HasUninitializedReferenceMember;
2117 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
2118 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
2119 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
2120 ToData.NeedOverloadResolutionForMoveConstructor
2121 = FromData.NeedOverloadResolutionForMoveConstructor;
2122 ToData.NeedOverloadResolutionForMoveAssignment
2123 = FromData.NeedOverloadResolutionForMoveAssignment;
2124 ToData.NeedOverloadResolutionForDestructor
2125 = FromData.NeedOverloadResolutionForDestructor;
2126 ToData.DefaultedMoveConstructorIsDeleted
2127 = FromData.DefaultedMoveConstructorIsDeleted;
2128 ToData.DefaultedMoveAssignmentIsDeleted
2129 = FromData.DefaultedMoveAssignmentIsDeleted;
2130 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
2131 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
2132 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
2133 ToData.HasConstexprNonCopyMoveConstructor
2134 = FromData.HasConstexprNonCopyMoveConstructor;
2135 ToData.HasDefaultedDefaultConstructor
2136 = FromData.HasDefaultedDefaultConstructor;
2137 ToData.DefaultedDefaultConstructorIsConstexpr
2138 = FromData.DefaultedDefaultConstructorIsConstexpr;
2139 ToData.HasConstexprDefaultConstructor
2140 = FromData.HasConstexprDefaultConstructor;
2141 ToData.HasNonLiteralTypeFieldsOrBases
2142 = FromData.HasNonLiteralTypeFieldsOrBases;
2143 // ComputedVisibleConversions not imported.
2144 ToData.UserProvidedDefaultConstructor
2145 = FromData.UserProvidedDefaultConstructor;
2146 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
2147 ToData.ImplicitCopyConstructorHasConstParam
2148 = FromData.ImplicitCopyConstructorHasConstParam;
2149 ToData.ImplicitCopyAssignmentHasConstParam
2150 = FromData.ImplicitCopyAssignmentHasConstParam;
2151 ToData.HasDeclaredCopyConstructorWithConstParam
2152 = FromData.HasDeclaredCopyConstructorWithConstParam;
2153 ToData.HasDeclaredCopyAssignmentWithConstParam
2154 = FromData.HasDeclaredCopyAssignmentWithConstParam;
2155 ToData.IsLambda = FromData.IsLambda;
2157 SmallVector<CXXBaseSpecifier *, 4> Bases;
2158 for (const auto &Base1 : FromCXX->bases()) {
2159 QualType T = Importer.Import(Base1.getType());
2163 SourceLocation EllipsisLoc;
2164 if (Base1.isPackExpansion())
2165 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
2167 // Ensure that we have a definition for the base.
2168 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
2171 new (Importer.getToContext())
2172 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
2174 Base1.isBaseOfClass(),
2175 Base1.getAccessSpecifierAsWritten(),
2176 Importer.Import(Base1.getTypeSourceInfo()),
2180 ToCXX->setBases(Bases.data(), Bases.size());
2183 if (shouldForceImportDeclContext(Kind))
2184 ImportDeclContext(From, /*ForceImport=*/true);
2186 To->completeDefinition();
2190 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
2191 ImportDefinitionKind Kind) {
2192 if (To->getAnyInitializer())
2195 // FIXME: Can we really import any initializer? Alternatively, we could force
2196 // ourselves to import every declaration of a variable and then only use
2198 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
2200 // FIXME: Other bits to merge?
2205 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
2206 ImportDefinitionKind Kind) {
2207 if (To->getDefinition() || To->isBeingDefined()) {
2208 if (Kind == IDK_Everything)
2209 ImportDeclContext(From, /*ForceImport=*/true);
2213 To->startDefinition();
2215 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
2219 QualType ToPromotionType = Importer.Import(From->getPromotionType());
2220 if (ToPromotionType.isNull())
2223 if (shouldForceImportDeclContext(Kind))
2224 ImportDeclContext(From, /*ForceImport=*/true);
2226 // FIXME: we might need to merge the number of positive or negative bits
2227 // if the enumerator lists don't match.
2228 To->completeDefinition(T, ToPromotionType,
2229 From->getNumPositiveBits(),
2230 From->getNumNegativeBits());
2234 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
2235 TemplateParameterList *Params) {
2236 SmallVector<NamedDecl *, 4> ToParams;
2237 ToParams.reserve(Params->size());
2238 for (TemplateParameterList::iterator P = Params->begin(),
2239 PEnd = Params->end();
2241 Decl *To = Importer.Import(*P);
2245 ToParams.push_back(cast<NamedDecl>(To));
2248 return TemplateParameterList::Create(Importer.getToContext(),
2249 Importer.Import(Params->getTemplateLoc()),
2250 Importer.Import(Params->getLAngleLoc()),
2252 Importer.Import(Params->getRAngleLoc()));
2256 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2257 switch (From.getKind()) {
2258 case TemplateArgument::Null:
2259 return TemplateArgument();
2261 case TemplateArgument::Type: {
2262 QualType ToType = Importer.Import(From.getAsType());
2263 if (ToType.isNull())
2264 return TemplateArgument();
2265 return TemplateArgument(ToType);
2268 case TemplateArgument::Integral: {
2269 QualType ToType = Importer.Import(From.getIntegralType());
2270 if (ToType.isNull())
2271 return TemplateArgument();
2272 return TemplateArgument(From, ToType);
2275 case TemplateArgument::Declaration: {
2276 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
2277 QualType ToType = Importer.Import(From.getParamTypeForDecl());
2278 if (!To || ToType.isNull())
2279 return TemplateArgument();
2280 return TemplateArgument(To, ToType);
2283 case TemplateArgument::NullPtr: {
2284 QualType ToType = Importer.Import(From.getNullPtrType());
2285 if (ToType.isNull())
2286 return TemplateArgument();
2287 return TemplateArgument(ToType, /*isNullPtr*/true);
2290 case TemplateArgument::Template: {
2291 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
2292 if (ToTemplate.isNull())
2293 return TemplateArgument();
2295 return TemplateArgument(ToTemplate);
2298 case TemplateArgument::TemplateExpansion: {
2299 TemplateName ToTemplate
2300 = Importer.Import(From.getAsTemplateOrTemplatePattern());
2301 if (ToTemplate.isNull())
2302 return TemplateArgument();
2304 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
2307 case TemplateArgument::Expression:
2308 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
2309 return TemplateArgument(ToExpr);
2310 return TemplateArgument();
2312 case TemplateArgument::Pack: {
2313 SmallVector<TemplateArgument, 2> ToPack;
2314 ToPack.reserve(From.pack_size());
2315 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
2316 return TemplateArgument();
2318 return TemplateArgument(
2319 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
2323 llvm_unreachable("Invalid template argument kind");
2326 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
2327 unsigned NumFromArgs,
2328 SmallVectorImpl<TemplateArgument> &ToArgs) {
2329 for (unsigned I = 0; I != NumFromArgs; ++I) {
2330 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
2331 if (To.isNull() && !FromArgs[I].isNull())
2334 ToArgs.push_back(To);
2340 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2341 RecordDecl *ToRecord, bool Complain) {
2342 // Eliminate a potential failure point where we attempt to re-import
2343 // something we're trying to import while completing ToRecord.
2344 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2346 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2348 ToRecord = ToOriginRecord;
2351 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2352 ToRecord->getASTContext(),
2353 Importer.getNonEquivalentDecls(),
2355 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
2358 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2360 StructuralEquivalenceContext Ctx(
2361 Importer.getFromContext(), Importer.getToContext(),
2362 Importer.getNonEquivalentDecls(), false, Complain);
2363 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
2366 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2367 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2368 Importer.getToContext(),
2369 Importer.getNonEquivalentDecls());
2370 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
2373 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2374 EnumConstantDecl *ToEC)
2376 const llvm::APSInt &FromVal = FromEC->getInitVal();
2377 const llvm::APSInt &ToVal = ToEC->getInitVal();
2379 return FromVal.isSigned() == ToVal.isSigned() &&
2380 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2384 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2385 ClassTemplateDecl *To) {
2386 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2387 Importer.getToContext(),
2388 Importer.getNonEquivalentDecls());
2389 return Ctx.IsStructurallyEquivalent(From, To);
2392 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2393 VarTemplateDecl *To) {
2394 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2395 Importer.getToContext(),
2396 Importer.getNonEquivalentDecls());
2397 return Ctx.IsStructurallyEquivalent(From, To);
2400 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
2401 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2402 << D->getDeclKindName();
2406 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2407 TranslationUnitDecl *ToD =
2408 Importer.getToContext().getTranslationUnitDecl();
2410 Importer.Imported(D, ToD);
2415 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2417 SourceLocation Loc = Importer.Import(D->getLocation());
2418 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
2420 // Import the context of this declaration.
2421 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2425 AccessSpecDecl *accessSpecDecl
2426 = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
2429 if (!accessSpecDecl)
2432 // Lexical DeclContext and Semantic DeclContext
2433 // is always the same for the accessSpec.
2434 accessSpecDecl->setLexicalDeclContext(DC);
2435 DC->addDeclInternal(accessSpecDecl);
2437 return accessSpecDecl;
2440 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2441 // Import the major distinguishing characteristics of this namespace.
2442 DeclContext *DC, *LexicalDC;
2443 DeclarationName Name;
2446 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2451 NamespaceDecl *MergeWithNamespace = nullptr;
2453 // This is an anonymous namespace. Adopt an existing anonymous
2454 // namespace if we can.
2455 // FIXME: Not testable.
2456 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2457 MergeWithNamespace = TU->getAnonymousNamespace();
2459 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2461 SmallVector<NamedDecl *, 4> ConflictingDecls;
2462 SmallVector<NamedDecl *, 2> FoundDecls;
2463 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2464 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2465 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
2468 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
2469 MergeWithNamespace = FoundNS;
2470 ConflictingDecls.clear();
2474 ConflictingDecls.push_back(FoundDecls[I]);
2477 if (!ConflictingDecls.empty()) {
2478 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
2479 ConflictingDecls.data(),
2480 ConflictingDecls.size());
2484 // Create the "to" namespace, if needed.
2485 NamespaceDecl *ToNamespace = MergeWithNamespace;
2487 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
2489 Importer.Import(D->getLocStart()),
2490 Loc, Name.getAsIdentifierInfo(),
2491 /*PrevDecl=*/nullptr);
2492 ToNamespace->setLexicalDeclContext(LexicalDC);
2493 LexicalDC->addDeclInternal(ToNamespace);
2495 // If this is an anonymous namespace, register it as the anonymous
2496 // namespace within its context.
2498 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
2499 TU->setAnonymousNamespace(ToNamespace);
2501 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2504 Importer.Imported(D, ToNamespace);
2506 ImportDeclContext(D);
2511 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2512 // Import the major distinguishing characteristics of this typedef.
2513 DeclContext *DC, *LexicalDC;
2514 DeclarationName Name;
2517 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2522 // If this typedef is not in block scope, determine whether we've
2523 // seen a typedef with the same name (that we can merge with) or any
2524 // other entity by that name (which name lookup could conflict with).
2525 if (!DC->isFunctionOrMethod()) {
2526 SmallVector<NamedDecl *, 4> ConflictingDecls;
2527 unsigned IDNS = Decl::IDNS_Ordinary;
2528 SmallVector<NamedDecl *, 2> FoundDecls;
2529 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2530 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2531 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2533 if (TypedefNameDecl *FoundTypedef =
2534 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
2535 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
2536 FoundTypedef->getUnderlyingType()))
2537 return Importer.Imported(D, FoundTypedef);
2540 ConflictingDecls.push_back(FoundDecls[I]);
2543 if (!ConflictingDecls.empty()) {
2544 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2545 ConflictingDecls.data(),
2546 ConflictingDecls.size());
2552 // Import the underlying type of this typedef;
2553 QualType T = Importer.Import(D->getUnderlyingType());
2557 // Create the new typedef node.
2558 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2559 SourceLocation StartL = Importer.Import(D->getLocStart());
2560 TypedefNameDecl *ToTypedef;
2562 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
2564 Name.getAsIdentifierInfo(),
2567 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
2569 Name.getAsIdentifierInfo(),
2572 ToTypedef->setAccess(D->getAccess());
2573 ToTypedef->setLexicalDeclContext(LexicalDC);
2574 Importer.Imported(D, ToTypedef);
2575 LexicalDC->addDeclInternal(ToTypedef);
2580 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2581 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2584 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2585 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2588 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2589 // Import the major distinguishing characteristics of this label.
2590 DeclContext *DC, *LexicalDC;
2591 DeclarationName Name;
2594 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2599 assert(LexicalDC->isFunctionOrMethod());
2601 LabelDecl *ToLabel = D->isGnuLocal()
2602 ? LabelDecl::Create(Importer.getToContext(),
2603 DC, Importer.Import(D->getLocation()),
2604 Name.getAsIdentifierInfo(),
2605 Importer.Import(D->getLocStart()))
2606 : LabelDecl::Create(Importer.getToContext(),
2607 DC, Importer.Import(D->getLocation()),
2608 Name.getAsIdentifierInfo());
2609 Importer.Imported(D, ToLabel);
2611 LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2615 ToLabel->setStmt(Label);
2616 ToLabel->setLexicalDeclContext(LexicalDC);
2617 LexicalDC->addDeclInternal(ToLabel);
2621 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2622 // Import the major distinguishing characteristics of this enum.
2623 DeclContext *DC, *LexicalDC;
2624 DeclarationName Name;
2627 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2632 // Figure out what enum name we're looking for.
2633 unsigned IDNS = Decl::IDNS_Tag;
2634 DeclarationName SearchName = Name;
2635 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2636 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2637 IDNS = Decl::IDNS_Ordinary;
2638 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2639 IDNS |= Decl::IDNS_Ordinary;
2641 // We may already have an enum of the same name; try to find and match it.
2642 if (!DC->isFunctionOrMethod() && SearchName) {
2643 SmallVector<NamedDecl *, 4> ConflictingDecls;
2644 SmallVector<NamedDecl *, 2> FoundDecls;
2645 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2646 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2647 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2650 Decl *Found = FoundDecls[I];
2651 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2652 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2653 Found = Tag->getDecl();
2656 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2657 if (IsStructuralMatch(D, FoundEnum))
2658 return Importer.Imported(D, FoundEnum);
2661 ConflictingDecls.push_back(FoundDecls[I]);
2664 if (!ConflictingDecls.empty()) {
2665 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2666 ConflictingDecls.data(),
2667 ConflictingDecls.size());
2671 // Create the enum declaration.
2672 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
2673 Importer.Import(D->getLocStart()),
2674 Loc, Name.getAsIdentifierInfo(), nullptr,
2675 D->isScoped(), D->isScopedUsingClassTag(),
2677 // Import the qualifier, if any.
2678 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2679 D2->setAccess(D->getAccess());
2680 D2->setLexicalDeclContext(LexicalDC);
2681 Importer.Imported(D, D2);
2682 LexicalDC->addDeclInternal(D2);
2684 // Import the integer type.
2685 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2686 if (ToIntegerType.isNull())
2688 D2->setIntegerType(ToIntegerType);
2690 // Import the definition
2691 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2697 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2698 // If this record has a definition in the translation unit we're coming from,
2699 // but this particular declaration is not that definition, import the
2700 // definition and map to that.
2701 TagDecl *Definition = D->getDefinition();
2702 if (Definition && Definition != D) {
2703 Decl *ImportedDef = Importer.Import(Definition);
2707 return Importer.Imported(D, ImportedDef);
2710 // Import the major distinguishing characteristics of this record.
2711 DeclContext *DC, *LexicalDC;
2712 DeclarationName Name;
2715 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2720 // Figure out what structure name we're looking for.
2721 unsigned IDNS = Decl::IDNS_Tag;
2722 DeclarationName SearchName = Name;
2723 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2724 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2725 IDNS = Decl::IDNS_Ordinary;
2726 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2727 IDNS |= Decl::IDNS_Ordinary;
2729 // We may already have a record of the same name; try to find and match it.
2730 RecordDecl *AdoptDecl = nullptr;
2731 if (!DC->isFunctionOrMethod()) {
2732 SmallVector<NamedDecl *, 4> ConflictingDecls;
2733 SmallVector<NamedDecl *, 2> FoundDecls;
2734 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2735 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2736 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2739 Decl *Found = FoundDecls[I];
2740 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2741 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2742 Found = Tag->getDecl();
2745 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2746 if (D->isAnonymousStructOrUnion() &&
2747 FoundRecord->isAnonymousStructOrUnion()) {
2748 // If both anonymous structs/unions are in a record context, make sure
2749 // they occur in the same location in the context records.
2750 if (Optional<unsigned> Index1
2751 = findAnonymousStructOrUnionIndex(D)) {
2752 if (Optional<unsigned> Index2 =
2753 findAnonymousStructOrUnionIndex(FoundRecord)) {
2754 if (*Index1 != *Index2)
2760 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2761 if ((SearchName && !D->isCompleteDefinition())
2762 || (D->isCompleteDefinition() &&
2763 D->isAnonymousStructOrUnion()
2764 == FoundDef->isAnonymousStructOrUnion() &&
2765 IsStructuralMatch(D, FoundDef))) {
2766 // The record types structurally match, or the "from" translation
2767 // unit only had a forward declaration anyway; call it the same
2769 // FIXME: For C++, we should also merge methods here.
2770 return Importer.Imported(D, FoundDef);
2772 } else if (!D->isCompleteDefinition()) {
2773 // We have a forward declaration of this type, so adopt that forward
2774 // declaration rather than building a new one.
2776 // If one or both can be completed from external storage then try one
2777 // last time to complete and compare them before doing this.
2779 if (FoundRecord->hasExternalLexicalStorage() &&
2780 !FoundRecord->isCompleteDefinition())
2781 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2782 if (D->hasExternalLexicalStorage())
2783 D->getASTContext().getExternalSource()->CompleteType(D);
2785 if (FoundRecord->isCompleteDefinition() &&
2786 D->isCompleteDefinition() &&
2787 !IsStructuralMatch(D, FoundRecord))
2790 AdoptDecl = FoundRecord;
2792 } else if (!SearchName) {
2797 ConflictingDecls.push_back(FoundDecls[I]);
2800 if (!ConflictingDecls.empty() && SearchName) {
2801 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2802 ConflictingDecls.data(),
2803 ConflictingDecls.size());
2807 // Create the record declaration.
2808 RecordDecl *D2 = AdoptDecl;
2809 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2811 CXXRecordDecl *D2CXX = nullptr;
2812 if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
2813 if (DCXX->isLambda()) {
2814 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
2815 D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
2817 DCXX->isDependentLambda(),
2818 DCXX->isGenericLambda(),
2819 DCXX->getLambdaCaptureDefault());
2820 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2821 if (DCXX->getLambdaContextDecl() && !CDecl)
2823 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
2824 } else if (DCXX->isInjectedClassName()) {
2825 // We have to be careful to do a similar dance to the one in
2826 // Sema::ActOnStartCXXMemberDeclarations
2827 CXXRecordDecl *const PrevDecl = nullptr;
2828 const bool DelayTypeCreation = true;
2829 D2CXX = CXXRecordDecl::Create(
2830 Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
2831 Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
2832 Importer.getToContext().getTypeDeclType(
2833 D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
2835 D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
2838 Name.getAsIdentifierInfo());
2841 D2->setAccess(D->getAccess());
2843 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
2844 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
2847 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2848 D2->setLexicalDeclContext(LexicalDC);
2849 LexicalDC->addDeclInternal(D2);
2850 if (D->isAnonymousStructOrUnion())
2851 D2->setAnonymousStructOrUnion(true);
2854 Importer.Imported(D, D2);
2856 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2862 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2863 // Import the major distinguishing characteristics of this enumerator.
2864 DeclContext *DC, *LexicalDC;
2865 DeclarationName Name;
2868 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2873 QualType T = Importer.Import(D->getType());
2877 // Determine whether there are any other declarations with the same name and
2878 // in the same context.
2879 if (!LexicalDC->isFunctionOrMethod()) {
2880 SmallVector<NamedDecl *, 4> ConflictingDecls;
2881 unsigned IDNS = Decl::IDNS_Ordinary;
2882 SmallVector<NamedDecl *, 2> FoundDecls;
2883 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2884 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2885 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2888 if (EnumConstantDecl *FoundEnumConstant
2889 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2890 if (IsStructuralMatch(D, FoundEnumConstant))
2891 return Importer.Imported(D, FoundEnumConstant);
2894 ConflictingDecls.push_back(FoundDecls[I]);
2897 if (!ConflictingDecls.empty()) {
2898 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2899 ConflictingDecls.data(),
2900 ConflictingDecls.size());
2906 Expr *Init = Importer.Import(D->getInitExpr());
2907 if (D->getInitExpr() && !Init)
2910 EnumConstantDecl *ToEnumerator
2911 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2912 Name.getAsIdentifierInfo(), T,
2913 Init, D->getInitVal());
2914 ToEnumerator->setAccess(D->getAccess());
2915 ToEnumerator->setLexicalDeclContext(LexicalDC);
2916 Importer.Imported(D, ToEnumerator);
2917 LexicalDC->addDeclInternal(ToEnumerator);
2918 return ToEnumerator;
2921 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2922 // Import the major distinguishing characteristics of this function.
2923 DeclContext *DC, *LexicalDC;
2924 DeclarationName Name;
2927 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2932 // Try to find a function in our own ("to") context with the same name, same
2933 // type, and in the same context as the function we're importing.
2934 if (!LexicalDC->isFunctionOrMethod()) {
2935 SmallVector<NamedDecl *, 4> ConflictingDecls;
2936 unsigned IDNS = Decl::IDNS_Ordinary;
2937 SmallVector<NamedDecl *, 2> FoundDecls;
2938 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2939 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2940 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2943 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2944 if (FoundFunction->hasExternalFormalLinkage() &&
2945 D->hasExternalFormalLinkage()) {
2946 if (Importer.IsStructurallyEquivalent(D->getType(),
2947 FoundFunction->getType())) {
2948 // FIXME: Actually try to merge the body and other attributes.
2949 return Importer.Imported(D, FoundFunction);
2952 // FIXME: Check for overloading more carefully, e.g., by boosting
2953 // Sema::IsOverload out to the AST library.
2955 // Function overloading is okay in C++.
2956 if (Importer.getToContext().getLangOpts().CPlusPlus)
2959 // Complain about inconsistent function types.
2960 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2961 << Name << D->getType() << FoundFunction->getType();
2962 Importer.ToDiag(FoundFunction->getLocation(),
2963 diag::note_odr_value_here)
2964 << FoundFunction->getType();
2968 ConflictingDecls.push_back(FoundDecls[I]);
2971 if (!ConflictingDecls.empty()) {
2972 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2973 ConflictingDecls.data(),
2974 ConflictingDecls.size());
2980 DeclarationNameInfo NameInfo(Name, Loc);
2981 // Import additional name location/type info.
2982 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2984 QualType FromTy = D->getType();
2985 bool usedDifferentExceptionSpec = false;
2987 if (const FunctionProtoType *
2988 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2989 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2990 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2991 // FunctionDecl that we are importing the FunctionProtoType for.
2992 // To avoid an infinite recursion when importing, create the FunctionDecl
2993 // with a simplified function type and update it afterwards.
2994 if (FromEPI.ExceptionSpec.SourceDecl ||
2995 FromEPI.ExceptionSpec.SourceTemplate ||
2996 FromEPI.ExceptionSpec.NoexceptExpr) {
2997 FunctionProtoType::ExtProtoInfo DefaultEPI;
2998 FromTy = Importer.getFromContext().getFunctionType(
2999 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
3000 usedDifferentExceptionSpec = true;
3005 QualType T = Importer.Import(FromTy);
3009 // Import the function parameters.
3010 SmallVector<ParmVarDecl *, 8> Parameters;
3011 for (auto P : D->params()) {
3012 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
3016 Parameters.push_back(ToP);
3019 // Create the imported function.
3020 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3021 FunctionDecl *ToFunction = nullptr;
3022 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
3023 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3024 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
3025 cast<CXXRecordDecl>(DC),
3028 FromConstructor->isExplicit(),
3029 D->isInlineSpecified(),
3032 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3033 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
3034 for (CXXCtorInitializer *I : FromConstructor->inits()) {
3035 CXXCtorInitializer *ToI =
3036 cast_or_null<CXXCtorInitializer>(Importer.Import(I));
3039 CtorInitializers.push_back(ToI);
3041 CXXCtorInitializer **Memory =
3042 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3043 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3044 CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
3045 ToCtor->setCtorInitializers(Memory);
3046 ToCtor->setNumCtorInitializers(NumInitializers);
3048 } else if (isa<CXXDestructorDecl>(D)) {
3049 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
3050 cast<CXXRecordDecl>(DC),
3053 D->isInlineSpecified(),
3055 } else if (CXXConversionDecl *FromConversion
3056 = dyn_cast<CXXConversionDecl>(D)) {
3057 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
3058 cast<CXXRecordDecl>(DC),
3061 D->isInlineSpecified(),
3062 FromConversion->isExplicit(),
3064 Importer.Import(D->getLocEnd()));
3065 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
3066 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
3067 cast<CXXRecordDecl>(DC),
3070 Method->getStorageClass(),
3071 Method->isInlineSpecified(),
3073 Importer.Import(D->getLocEnd()));
3075 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
3077 NameInfo, T, TInfo, D->getStorageClass(),
3078 D->isInlineSpecified(),
3079 D->hasWrittenPrototype(),
3083 // Import the qualifier, if any.
3084 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3085 ToFunction->setAccess(D->getAccess());
3086 ToFunction->setLexicalDeclContext(LexicalDC);
3087 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3088 ToFunction->setTrivial(D->isTrivial());
3089 ToFunction->setPure(D->isPure());
3090 Importer.Imported(D, ToFunction);
3092 // Set the parameters.
3093 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
3094 Parameters[I]->setOwningFunction(ToFunction);
3095 ToFunction->addDeclInternal(Parameters[I]);
3097 ToFunction->setParams(Parameters);
3099 if (usedDifferentExceptionSpec) {
3100 // Update FunctionProtoType::ExtProtoInfo.
3101 QualType T = Importer.Import(D->getType());
3104 ToFunction->setType(T);
3107 // Import the body, if any.
3108 if (Stmt *FromBody = D->getBody()) {
3109 if (Stmt *ToBody = Importer.Import(FromBody)) {
3110 ToFunction->setBody(ToBody);
3114 // FIXME: Other bits to merge?
3116 // Add this function to the lexical context.
3117 LexicalDC->addDeclInternal(ToFunction);
3122 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3123 return VisitFunctionDecl(D);
3126 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3127 return VisitCXXMethodDecl(D);
3130 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3131 return VisitCXXMethodDecl(D);
3134 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3135 return VisitCXXMethodDecl(D);
3138 static unsigned getFieldIndex(Decl *F) {
3139 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
3144 for (const auto *D : Owner->noload_decls()) {
3148 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
3155 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3156 // Import the major distinguishing characteristics of a variable.
3157 DeclContext *DC, *LexicalDC;
3158 DeclarationName Name;
3161 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3166 // Determine whether we've already imported this field.
3167 SmallVector<NamedDecl *, 2> FoundDecls;
3168 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3169 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3170 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
3171 // For anonymous fields, match up by index.
3172 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3175 if (Importer.IsStructurallyEquivalent(D->getType(),
3176 FoundField->getType())) {
3177 Importer.Imported(D, FoundField);
3181 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3182 << Name << D->getType() << FoundField->getType();
3183 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3184 << FoundField->getType();
3190 QualType T = Importer.Import(D->getType());
3194 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3195 Expr *BitWidth = Importer.Import(D->getBitWidth());
3196 if (!BitWidth && D->getBitWidth())
3199 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
3200 Importer.Import(D->getInnerLocStart()),
3201 Loc, Name.getAsIdentifierInfo(),
3202 T, TInfo, BitWidth, D->isMutable(),
3203 D->getInClassInitStyle());
3204 ToField->setAccess(D->getAccess());
3205 ToField->setLexicalDeclContext(LexicalDC);
3206 if (Expr *FromInitializer = D->getInClassInitializer()) {
3207 Expr *ToInitializer = Importer.Import(FromInitializer);
3209 ToField->setInClassInitializer(ToInitializer);
3213 ToField->setImplicit(D->isImplicit());
3214 Importer.Imported(D, ToField);
3215 LexicalDC->addDeclInternal(ToField);
3219 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3220 // Import the major distinguishing characteristics of a variable.
3221 DeclContext *DC, *LexicalDC;
3222 DeclarationName Name;
3225 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3230 // Determine whether we've already imported this field.
3231 SmallVector<NamedDecl *, 2> FoundDecls;
3232 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3233 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3234 if (IndirectFieldDecl *FoundField
3235 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3236 // For anonymous indirect fields, match up by index.
3237 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
3240 if (Importer.IsStructurallyEquivalent(D->getType(),
3241 FoundField->getType(),
3243 Importer.Imported(D, FoundField);
3247 // If there are more anonymous fields to check, continue.
3248 if (!Name && I < N-1)
3251 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
3252 << Name << D->getType() << FoundField->getType();
3253 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3254 << FoundField->getType();
3260 QualType T = Importer.Import(D->getType());
3264 NamedDecl **NamedChain =
3265 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
3268 for (auto *PI : D->chain()) {
3269 Decl *D = Importer.Import(PI);
3272 NamedChain[i++] = cast<NamedDecl>(D);
3275 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
3276 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
3277 NamedChain, D->getChainingSize());
3279 for (const auto *Attr : D->attrs())
3280 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
3282 ToIndirectField->setAccess(D->getAccess());
3283 ToIndirectField->setLexicalDeclContext(LexicalDC);
3284 Importer.Imported(D, ToIndirectField);
3285 LexicalDC->addDeclInternal(ToIndirectField);
3286 return ToIndirectField;
3289 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3290 // Import the major distinguishing characteristics of an ivar.
3291 DeclContext *DC, *LexicalDC;
3292 DeclarationName Name;
3295 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3300 // Determine whether we've already imported this ivar
3301 SmallVector<NamedDecl *, 2> FoundDecls;
3302 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3303 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3304 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
3305 if (Importer.IsStructurallyEquivalent(D->getType(),
3306 FoundIvar->getType())) {
3307 Importer.Imported(D, FoundIvar);
3311 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3312 << Name << D->getType() << FoundIvar->getType();
3313 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3314 << FoundIvar->getType();
3320 QualType T = Importer.Import(D->getType());
3324 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3325 Expr *BitWidth = Importer.Import(D->getBitWidth());
3326 if (!BitWidth && D->getBitWidth())
3329 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
3330 cast<ObjCContainerDecl>(DC),
3331 Importer.Import(D->getInnerLocStart()),
3332 Loc, Name.getAsIdentifierInfo(),
3333 T, TInfo, D->getAccessControl(),
3334 BitWidth, D->getSynthesize());
3335 ToIvar->setLexicalDeclContext(LexicalDC);
3336 Importer.Imported(D, ToIvar);
3337 LexicalDC->addDeclInternal(ToIvar);
3342 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3343 // Import the major distinguishing characteristics of a variable.
3344 DeclContext *DC, *LexicalDC;
3345 DeclarationName Name;
3348 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3353 // Try to find a variable in our own ("to") context with the same name and
3354 // in the same context as the variable we're importing.
3355 if (D->isFileVarDecl()) {
3356 VarDecl *MergeWithVar = nullptr;
3357 SmallVector<NamedDecl *, 4> ConflictingDecls;
3358 unsigned IDNS = Decl::IDNS_Ordinary;
3359 SmallVector<NamedDecl *, 2> FoundDecls;
3360 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3361 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3362 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
3365 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
3366 // We have found a variable that we may need to merge with. Check it.
3367 if (FoundVar->hasExternalFormalLinkage() &&
3368 D->hasExternalFormalLinkage()) {
3369 if (Importer.IsStructurallyEquivalent(D->getType(),
3370 FoundVar->getType())) {
3371 MergeWithVar = FoundVar;
3375 const ArrayType *FoundArray
3376 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3377 const ArrayType *TArray
3378 = Importer.getToContext().getAsArrayType(D->getType());
3379 if (FoundArray && TArray) {
3380 if (isa<IncompleteArrayType>(FoundArray) &&
3381 isa<ConstantArrayType>(TArray)) {
3383 QualType T = Importer.Import(D->getType());
3387 FoundVar->setType(T);
3388 MergeWithVar = FoundVar;
3390 } else if (isa<IncompleteArrayType>(TArray) &&
3391 isa<ConstantArrayType>(FoundArray)) {
3392 MergeWithVar = FoundVar;
3397 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3398 << Name << D->getType() << FoundVar->getType();
3399 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3400 << FoundVar->getType();
3404 ConflictingDecls.push_back(FoundDecls[I]);
3408 // An equivalent variable with external linkage has been found. Link
3409 // the two declarations, then merge them.
3410 Importer.Imported(D, MergeWithVar);
3412 if (VarDecl *DDef = D->getDefinition()) {
3413 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3414 Importer.ToDiag(ExistingDef->getLocation(),
3415 diag::err_odr_variable_multiple_def)
3417 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3419 Expr *Init = Importer.Import(DDef->getInit());
3420 MergeWithVar->setInit(Init);
3421 if (DDef->isInitKnownICE()) {
3422 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3423 Eval->CheckedICE = true;
3424 Eval->IsICE = DDef->isInitICE();
3429 return MergeWithVar;
3432 if (!ConflictingDecls.empty()) {
3433 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3434 ConflictingDecls.data(),
3435 ConflictingDecls.size());
3442 QualType T = Importer.Import(D->getType());
3446 // Create the imported variable.
3447 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3448 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
3449 Importer.Import(D->getInnerLocStart()),
3450 Loc, Name.getAsIdentifierInfo(),
3452 D->getStorageClass());
3453 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3454 ToVar->setAccess(D->getAccess());
3455 ToVar->setLexicalDeclContext(LexicalDC);
3456 Importer.Imported(D, ToVar);
3457 LexicalDC->addDeclInternal(ToVar);
3459 if (!D->isFileVarDecl() &&
3463 // Merge the initializer.
3464 if (ImportDefinition(D, ToVar))
3470 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3471 // Parameters are created in the translation unit's context, then moved
3472 // into the function declaration's context afterward.
3473 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3475 // Import the name of this declaration.
3476 DeclarationName Name = Importer.Import(D->getDeclName());
3477 if (D->getDeclName() && !Name)
3480 // Import the location of this declaration.
3481 SourceLocation Loc = Importer.Import(D->getLocation());
3483 // Import the parameter's type.
3484 QualType T = Importer.Import(D->getType());
3488 // Create the imported parameter.
3489 ImplicitParamDecl *ToParm
3490 = ImplicitParamDecl::Create(Importer.getToContext(), DC,
3491 Loc, Name.getAsIdentifierInfo(),
3493 return Importer.Imported(D, ToParm);
3496 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3497 // Parameters are created in the translation unit's context, then moved
3498 // into the function declaration's context afterward.
3499 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3501 // Import the name of this declaration.
3502 DeclarationName Name = Importer.Import(D->getDeclName());
3503 if (D->getDeclName() && !Name)
3506 // Import the location of this declaration.
3507 SourceLocation Loc = Importer.Import(D->getLocation());
3509 // Import the parameter's type.
3510 QualType T = Importer.Import(D->getType());
3514 // Create the imported parameter.
3515 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3516 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
3517 Importer.Import(D->getInnerLocStart()),
3518 Loc, Name.getAsIdentifierInfo(),
3519 T, TInfo, D->getStorageClass(),
3520 /*FIXME: Default argument*/nullptr);
3521 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3524 ToParm->setIsUsed();
3526 return Importer.Imported(D, ToParm);
3529 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3530 // Import the major distinguishing characteristics of a method.
3531 DeclContext *DC, *LexicalDC;
3532 DeclarationName Name;
3535 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3540 SmallVector<NamedDecl *, 2> FoundDecls;
3541 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3542 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3543 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
3544 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3547 // Check return types.
3548 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3549 FoundMethod->getReturnType())) {
3550 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3551 << D->isInstanceMethod() << Name << D->getReturnType()
3552 << FoundMethod->getReturnType();
3553 Importer.ToDiag(FoundMethod->getLocation(),
3554 diag::note_odr_objc_method_here)
3555 << D->isInstanceMethod() << Name;
3559 // Check the number of parameters.
3560 if (D->param_size() != FoundMethod->param_size()) {
3561 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3562 << D->isInstanceMethod() << Name
3563 << D->param_size() << FoundMethod->param_size();
3564 Importer.ToDiag(FoundMethod->getLocation(),
3565 diag::note_odr_objc_method_here)
3566 << D->isInstanceMethod() << Name;
3570 // Check parameter types.
3571 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3572 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3573 P != PEnd; ++P, ++FoundP) {
3574 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3575 (*FoundP)->getType())) {
3576 Importer.FromDiag((*P)->getLocation(),
3577 diag::err_odr_objc_method_param_type_inconsistent)
3578 << D->isInstanceMethod() << Name
3579 << (*P)->getType() << (*FoundP)->getType();
3580 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3581 << (*FoundP)->getType();
3586 // Check variadic/non-variadic.
3587 // Check the number of parameters.
3588 if (D->isVariadic() != FoundMethod->isVariadic()) {
3589 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3590 << D->isInstanceMethod() << Name;
3591 Importer.ToDiag(FoundMethod->getLocation(),
3592 diag::note_odr_objc_method_here)
3593 << D->isInstanceMethod() << Name;
3597 // FIXME: Any other bits we need to merge?
3598 return Importer.Imported(D, FoundMethod);
3602 // Import the result type.
3603 QualType ResultTy = Importer.Import(D->getReturnType());
3604 if (ResultTy.isNull())
3607 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3609 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
3610 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
3611 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
3612 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3613 D->getImplementationControl(), D->hasRelatedResultType());
3615 // FIXME: When we decide to merge method definitions, we'll need to
3616 // deal with implicit parameters.
3618 // Import the parameters
3619 SmallVector<ParmVarDecl *, 5> ToParams;
3620 for (auto *FromP : D->params()) {
3621 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3625 ToParams.push_back(ToP);
3628 // Set the parameters.
3629 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
3630 ToParams[I]->setOwningFunction(ToMethod);
3631 ToMethod->addDeclInternal(ToParams[I]);
3633 SmallVector<SourceLocation, 12> SelLocs;
3634 D->getSelectorLocs(SelLocs);
3635 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3637 ToMethod->setLexicalDeclContext(LexicalDC);
3638 Importer.Imported(D, ToMethod);
3639 LexicalDC->addDeclInternal(ToMethod);
3643 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3644 // Import the major distinguishing characteristics of a category.
3645 DeclContext *DC, *LexicalDC;
3646 DeclarationName Name;
3649 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3654 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3658 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
3659 Importer.getToContext(), DC,
3661 Importer.Import(D->getVarianceLoc()),
3663 Importer.Import(D->getLocation()),
3664 Name.getAsIdentifierInfo(),
3665 Importer.Import(D->getColonLoc()),
3667 Importer.Imported(D, Result);
3668 Result->setLexicalDeclContext(LexicalDC);
3672 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3673 // Import the major distinguishing characteristics of a category.
3674 DeclContext *DC, *LexicalDC;
3675 DeclarationName Name;
3678 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3683 ObjCInterfaceDecl *ToInterface
3684 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3688 // Determine if we've already encountered this category.
3689 ObjCCategoryDecl *MergeWithCategory
3690 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3691 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3693 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
3694 Importer.Import(D->getAtStartLoc()),
3696 Importer.Import(D->getCategoryNameLoc()),
3697 Name.getAsIdentifierInfo(),
3699 /*TypeParamList=*/nullptr,
3700 Importer.Import(D->getIvarLBraceLoc()),
3701 Importer.Import(D->getIvarRBraceLoc()));
3702 ToCategory->setLexicalDeclContext(LexicalDC);
3703 LexicalDC->addDeclInternal(ToCategory);
3704 Importer.Imported(D, ToCategory);
3705 // Import the type parameter list after calling Imported, to avoid
3706 // loops when bringing in their DeclContext.
3707 ToCategory->setTypeParamList(ImportObjCTypeParamList(
3708 D->getTypeParamList()));
3711 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3712 SmallVector<SourceLocation, 4> ProtocolLocs;
3713 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3714 = D->protocol_loc_begin();
3715 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3716 FromProtoEnd = D->protocol_end();
3717 FromProto != FromProtoEnd;
3718 ++FromProto, ++FromProtoLoc) {
3719 ObjCProtocolDecl *ToProto
3720 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3723 Protocols.push_back(ToProto);
3724 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3727 // FIXME: If we're merging, make sure that the protocol list is the same.
3728 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3729 ProtocolLocs.data(), Importer.getToContext());
3732 Importer.Imported(D, ToCategory);
3735 // Import all of the members of this category.
3736 ImportDeclContext(D);
3738 // If we have an implementation, import it as well.
3739 if (D->getImplementation()) {
3740 ObjCCategoryImplDecl *Impl
3741 = cast_or_null<ObjCCategoryImplDecl>(
3742 Importer.Import(D->getImplementation()));
3746 ToCategory->setImplementation(Impl);
3752 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3753 ObjCProtocolDecl *To,
3754 ImportDefinitionKind Kind) {
3755 if (To->getDefinition()) {
3756 if (shouldForceImportDeclContext(Kind))
3757 ImportDeclContext(From);
3761 // Start the protocol definition
3762 To->startDefinition();
3765 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3766 SmallVector<SourceLocation, 4> ProtocolLocs;
3767 ObjCProtocolDecl::protocol_loc_iterator
3768 FromProtoLoc = From->protocol_loc_begin();
3769 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3770 FromProtoEnd = From->protocol_end();
3771 FromProto != FromProtoEnd;
3772 ++FromProto, ++FromProtoLoc) {
3773 ObjCProtocolDecl *ToProto
3774 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3777 Protocols.push_back(ToProto);
3778 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3781 // FIXME: If we're merging, make sure that the protocol list is the same.
3782 To->setProtocolList(Protocols.data(), Protocols.size(),
3783 ProtocolLocs.data(), Importer.getToContext());
3785 if (shouldForceImportDeclContext(Kind)) {
3786 // Import all of the members of this protocol.
3787 ImportDeclContext(From, /*ForceImport=*/true);
3792 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3793 // If this protocol has a definition in the translation unit we're coming
3794 // from, but this particular declaration is not that definition, import the
3795 // definition and map to that.
3796 ObjCProtocolDecl *Definition = D->getDefinition();
3797 if (Definition && Definition != D) {
3798 Decl *ImportedDef = Importer.Import(Definition);
3802 return Importer.Imported(D, ImportedDef);
3805 // Import the major distinguishing characteristics of a protocol.
3806 DeclContext *DC, *LexicalDC;
3807 DeclarationName Name;
3810 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3815 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3816 SmallVector<NamedDecl *, 2> FoundDecls;
3817 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3818 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3819 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3822 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3826 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3828 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3829 Name.getAsIdentifierInfo(), Loc,
3830 Importer.Import(D->getAtStartLoc()),
3831 /*PrevDecl=*/nullptr);
3832 ToProto->setLexicalDeclContext(LexicalDC);
3833 LexicalDC->addDeclInternal(ToProto);
3836 Importer.Imported(D, ToProto);
3838 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3844 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3845 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3846 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3848 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3849 SourceLocation LangLoc = Importer.Import(D->getLocation());
3851 bool HasBraces = D->hasBraces();
3853 LinkageSpecDecl *ToLinkageSpec =
3854 LinkageSpecDecl::Create(Importer.getToContext(),
3862 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3863 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3866 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3867 LexicalDC->addDeclInternal(ToLinkageSpec);
3869 Importer.Imported(D, ToLinkageSpec);
3871 return ToLinkageSpec;
3874 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3875 ObjCInterfaceDecl *To,
3876 ImportDefinitionKind Kind) {
3877 if (To->getDefinition()) {
3878 // Check consistency of superclass.
3879 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3881 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3886 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3887 if ((bool)FromSuper != (bool)ToSuper ||
3888 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3889 Importer.ToDiag(To->getLocation(),
3890 diag::err_odr_objc_superclass_inconsistent)
3891 << To->getDeclName();
3893 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3894 << To->getSuperClass()->getDeclName();
3896 Importer.ToDiag(To->getLocation(),
3897 diag::note_odr_objc_missing_superclass);
3898 if (From->getSuperClass())
3899 Importer.FromDiag(From->getSuperClassLoc(),
3900 diag::note_odr_objc_superclass)
3901 << From->getSuperClass()->getDeclName();
3903 Importer.FromDiag(From->getLocation(),
3904 diag::note_odr_objc_missing_superclass);
3907 if (shouldForceImportDeclContext(Kind))
3908 ImportDeclContext(From);
3912 // Start the definition.
3913 To->startDefinition();
3915 // If this class has a superclass, import it.
3916 if (From->getSuperClass()) {
3917 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3921 To->setSuperClass(SuperTInfo);
3925 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3926 SmallVector<SourceLocation, 4> ProtocolLocs;
3927 ObjCInterfaceDecl::protocol_loc_iterator
3928 FromProtoLoc = From->protocol_loc_begin();
3930 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3931 FromProtoEnd = From->protocol_end();
3932 FromProto != FromProtoEnd;
3933 ++FromProto, ++FromProtoLoc) {
3934 ObjCProtocolDecl *ToProto
3935 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3938 Protocols.push_back(ToProto);
3939 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3942 // FIXME: If we're merging, make sure that the protocol list is the same.
3943 To->setProtocolList(Protocols.data(), Protocols.size(),
3944 ProtocolLocs.data(), Importer.getToContext());
3946 // Import categories. When the categories themselves are imported, they'll
3947 // hook themselves into this interface.
3948 for (auto *Cat : From->known_categories())
3949 Importer.Import(Cat);
3951 // If we have an @implementation, import it as well.
3952 if (From->getImplementation()) {
3953 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3954 Importer.Import(From->getImplementation()));
3958 To->setImplementation(Impl);
3961 if (shouldForceImportDeclContext(Kind)) {
3962 // Import all of the members of this class.
3963 ImportDeclContext(From, /*ForceImport=*/true);
3969 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3973 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3974 for (auto fromTypeParam : *list) {
3975 auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3976 Importer.Import(fromTypeParam));
3980 toTypeParams.push_back(toTypeParam);
3983 return ObjCTypeParamList::create(Importer.getToContext(),
3984 Importer.Import(list->getLAngleLoc()),
3986 Importer.Import(list->getRAngleLoc()));
3989 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3990 // If this class has a definition in the translation unit we're coming from,
3991 // but this particular declaration is not that definition, import the
3992 // definition and map to that.
3993 ObjCInterfaceDecl *Definition = D->getDefinition();
3994 if (Definition && Definition != D) {
3995 Decl *ImportedDef = Importer.Import(Definition);
3999 return Importer.Imported(D, ImportedDef);
4002 // Import the major distinguishing characteristics of an @interface.
4003 DeclContext *DC, *LexicalDC;
4004 DeclarationName Name;
4007 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4012 // Look for an existing interface with the same name.
4013 ObjCInterfaceDecl *MergeWithIface = nullptr;
4014 SmallVector<NamedDecl *, 2> FoundDecls;
4015 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4016 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4017 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4020 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
4024 // Create an interface declaration, if one does not already exist.
4025 ObjCInterfaceDecl *ToIface = MergeWithIface;
4027 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
4028 Importer.Import(D->getAtStartLoc()),
4029 Name.getAsIdentifierInfo(),
4030 /*TypeParamList=*/nullptr,
4031 /*PrevDecl=*/nullptr, Loc,
4032 D->isImplicitInterfaceDecl());
4033 ToIface->setLexicalDeclContext(LexicalDC);
4034 LexicalDC->addDeclInternal(ToIface);
4036 Importer.Imported(D, ToIface);
4037 // Import the type parameter list after calling Imported, to avoid
4038 // loops when bringing in their DeclContext.
4039 ToIface->setTypeParamList(ImportObjCTypeParamList(
4040 D->getTypeParamListAsWritten()));
4042 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4048 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4049 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
4050 Importer.Import(D->getCategoryDecl()));
4054 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4056 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4060 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4061 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
4062 Importer.Import(D->getIdentifier()),
4063 Category->getClassInterface(),
4064 Importer.Import(D->getLocation()),
4065 Importer.Import(D->getAtStartLoc()),
4068 DeclContext *LexicalDC = DC;
4069 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4070 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4074 ToImpl->setLexicalDeclContext(LexicalDC);
4077 LexicalDC->addDeclInternal(ToImpl);
4078 Category->setImplementation(ToImpl);
4081 Importer.Imported(D, ToImpl);
4082 ImportDeclContext(D);
4086 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4087 // Find the corresponding interface.
4088 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
4089 Importer.Import(D->getClassInterface()));
4093 // Import the superclass, if any.
4094 ObjCInterfaceDecl *Super = nullptr;
4095 if (D->getSuperClass()) {
4096 Super = cast_or_null<ObjCInterfaceDecl>(
4097 Importer.Import(D->getSuperClass()));
4102 ObjCImplementationDecl *Impl = Iface->getImplementation();
4104 // We haven't imported an implementation yet. Create a new @implementation
4106 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
4107 Importer.ImportContext(D->getDeclContext()),
4109 Importer.Import(D->getLocation()),
4110 Importer.Import(D->getAtStartLoc()),
4111 Importer.Import(D->getSuperClassLoc()),
4112 Importer.Import(D->getIvarLBraceLoc()),
4113 Importer.Import(D->getIvarRBraceLoc()));
4115 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4116 DeclContext *LexicalDC
4117 = Importer.ImportContext(D->getLexicalDeclContext());
4120 Impl->setLexicalDeclContext(LexicalDC);
4123 // Associate the implementation with the class it implements.
4124 Iface->setImplementation(Impl);
4125 Importer.Imported(D, Iface->getImplementation());
4127 Importer.Imported(D, Iface->getImplementation());
4129 // Verify that the existing @implementation has the same superclass.
4130 if ((Super && !Impl->getSuperClass()) ||
4131 (!Super && Impl->getSuperClass()) ||
4132 (Super && Impl->getSuperClass() &&
4133 !declaresSameEntity(Super->getCanonicalDecl(),
4134 Impl->getSuperClass()))) {
4135 Importer.ToDiag(Impl->getLocation(),
4136 diag::err_odr_objc_superclass_inconsistent)
4137 << Iface->getDeclName();
4138 // FIXME: It would be nice to have the location of the superclass
4140 if (Impl->getSuperClass())
4141 Importer.ToDiag(Impl->getLocation(),
4142 diag::note_odr_objc_superclass)
4143 << Impl->getSuperClass()->getDeclName();
4145 Importer.ToDiag(Impl->getLocation(),
4146 diag::note_odr_objc_missing_superclass);
4147 if (D->getSuperClass())
4148 Importer.FromDiag(D->getLocation(),
4149 diag::note_odr_objc_superclass)
4150 << D->getSuperClass()->getDeclName();
4152 Importer.FromDiag(D->getLocation(),
4153 diag::note_odr_objc_missing_superclass);
4158 // Import all of the members of this @implementation.
4159 ImportDeclContext(D);
4164 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4165 // Import the major distinguishing characteristics of an @property.
4166 DeclContext *DC, *LexicalDC;
4167 DeclarationName Name;
4170 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4175 // Check whether we have already imported this property.
4176 SmallVector<NamedDecl *, 2> FoundDecls;
4177 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4178 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4179 if (ObjCPropertyDecl *FoundProp
4180 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
4181 // Check property types.
4182 if (!Importer.IsStructurallyEquivalent(D->getType(),
4183 FoundProp->getType())) {
4184 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4185 << Name << D->getType() << FoundProp->getType();
4186 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4187 << FoundProp->getType();
4191 // FIXME: Check property attributes, getters, setters, etc.?
4193 // Consider these properties to be equivalent.
4194 Importer.Imported(D, FoundProp);
4200 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4204 // Create the new property.
4205 ObjCPropertyDecl *ToProperty
4206 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
4207 Name.getAsIdentifierInfo(),
4208 Importer.Import(D->getAtLoc()),
4209 Importer.Import(D->getLParenLoc()),
4210 Importer.Import(D->getType()),
4212 D->getPropertyImplementation());
4213 Importer.Imported(D, ToProperty);
4214 ToProperty->setLexicalDeclContext(LexicalDC);
4215 LexicalDC->addDeclInternal(ToProperty);
4217 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4218 ToProperty->setPropertyAttributesAsWritten(
4219 D->getPropertyAttributesAsWritten());
4220 ToProperty->setGetterName(Importer.Import(D->getGetterName()));
4221 ToProperty->setSetterName(Importer.Import(D->getSetterName()));
4222 ToProperty->setGetterMethodDecl(
4223 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4224 ToProperty->setSetterMethodDecl(
4225 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4226 ToProperty->setPropertyIvarDecl(
4227 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4231 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4232 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
4233 Importer.Import(D->getPropertyDecl()));
4237 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4241 // Import the lexical declaration context.
4242 DeclContext *LexicalDC = DC;
4243 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4244 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4249 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4253 // Import the ivar (for an @synthesize).
4254 ObjCIvarDecl *Ivar = nullptr;
4255 if (D->getPropertyIvarDecl()) {
4256 Ivar = cast_or_null<ObjCIvarDecl>(
4257 Importer.Import(D->getPropertyIvarDecl()));
4262 ObjCPropertyImplDecl *ToImpl
4263 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4264 Property->getQueryKind());
4266 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
4267 Importer.Import(D->getLocStart()),
4268 Importer.Import(D->getLocation()),
4270 D->getPropertyImplementation(),
4272 Importer.Import(D->getPropertyIvarDeclLoc()));
4273 ToImpl->setLexicalDeclContext(LexicalDC);
4274 Importer.Imported(D, ToImpl);
4275 LexicalDC->addDeclInternal(ToImpl);
4277 // Check that we have the same kind of property implementation (@synthesize
4279 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4280 Importer.ToDiag(ToImpl->getLocation(),
4281 diag::err_odr_objc_property_impl_kind_inconsistent)
4282 << Property->getDeclName()
4283 << (ToImpl->getPropertyImplementation()
4284 == ObjCPropertyImplDecl::Dynamic);
4285 Importer.FromDiag(D->getLocation(),
4286 diag::note_odr_objc_property_impl_kind)
4287 << D->getPropertyDecl()->getDeclName()
4288 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4292 // For @synthesize, check that we have the same
4293 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4294 Ivar != ToImpl->getPropertyIvarDecl()) {
4295 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4296 diag::err_odr_objc_synthesize_ivar_inconsistent)
4297 << Property->getDeclName()
4298 << ToImpl->getPropertyIvarDecl()->getDeclName()
4299 << Ivar->getDeclName();
4300 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4301 diag::note_odr_objc_synthesize_ivar_here)
4302 << D->getPropertyIvarDecl()->getDeclName();
4306 // Merge the existing implementation with the new implementation.
4307 Importer.Imported(D, ToImpl);
4313 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4314 // For template arguments, we adopt the translation unit as our declaration
4315 // context. This context will be fixed when the actual template declaration
4318 // FIXME: Import default argument.
4319 return TemplateTypeParmDecl::Create(Importer.getToContext(),
4320 Importer.getToContext().getTranslationUnitDecl(),
4321 Importer.Import(D->getLocStart()),
4322 Importer.Import(D->getLocation()),
4325 Importer.Import(D->getIdentifier()),
4326 D->wasDeclaredWithTypename(),
4327 D->isParameterPack());
4331 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4332 // Import the name of this declaration.
4333 DeclarationName Name = Importer.Import(D->getDeclName());
4334 if (D->getDeclName() && !Name)
4337 // Import the location of this declaration.
4338 SourceLocation Loc = Importer.Import(D->getLocation());
4340 // Import the type of this declaration.
4341 QualType T = Importer.Import(D->getType());
4345 // Import type-source information.
4346 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4347 if (D->getTypeSourceInfo() && !TInfo)
4350 // FIXME: Import default argument.
4352 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
4353 Importer.getToContext().getTranslationUnitDecl(),
4354 Importer.Import(D->getInnerLocStart()),
4355 Loc, D->getDepth(), D->getPosition(),
4356 Name.getAsIdentifierInfo(),
4357 T, D->isParameterPack(), TInfo);
4361 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4362 // Import the name of this declaration.
4363 DeclarationName Name = Importer.Import(D->getDeclName());
4364 if (D->getDeclName() && !Name)
4367 // Import the location of this declaration.
4368 SourceLocation Loc = Importer.Import(D->getLocation());
4370 // Import template parameters.
4371 TemplateParameterList *TemplateParams
4372 = ImportTemplateParameterList(D->getTemplateParameters());
4373 if (!TemplateParams)
4376 // FIXME: Import default argument.
4378 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
4379 Importer.getToContext().getTranslationUnitDecl(),
4380 Loc, D->getDepth(), D->getPosition(),
4381 D->isParameterPack(),
4382 Name.getAsIdentifierInfo(),
4386 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4387 // If this record has a definition in the translation unit we're coming from,
4388 // but this particular declaration is not that definition, import the
4389 // definition and map to that.
4390 CXXRecordDecl *Definition
4391 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4392 if (Definition && Definition != D->getTemplatedDecl()) {
4394 = Importer.Import(Definition->getDescribedClassTemplate());
4398 return Importer.Imported(D, ImportedDef);
4401 // Import the major distinguishing characteristics of this class template.
4402 DeclContext *DC, *LexicalDC;
4403 DeclarationName Name;
4406 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4411 // We may already have a template of the same name; try to find and match it.
4412 if (!DC->isFunctionOrMethod()) {
4413 SmallVector<NamedDecl *, 4> ConflictingDecls;
4414 SmallVector<NamedDecl *, 2> FoundDecls;
4415 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4416 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4417 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4420 Decl *Found = FoundDecls[I];
4421 if (ClassTemplateDecl *FoundTemplate
4422 = dyn_cast<ClassTemplateDecl>(Found)) {
4423 if (IsStructuralMatch(D, FoundTemplate)) {
4424 // The class templates structurally match; call it the same template.
4425 // FIXME: We may be filling in a forward declaration here. Handle
4427 Importer.Imported(D->getTemplatedDecl(),
4428 FoundTemplate->getTemplatedDecl());
4429 return Importer.Imported(D, FoundTemplate);
4433 ConflictingDecls.push_back(FoundDecls[I]);
4436 if (!ConflictingDecls.empty()) {
4437 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4438 ConflictingDecls.data(),
4439 ConflictingDecls.size());
4446 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
4448 // Create the declaration that is being templated.
4449 // Create the declaration that is being templated.
4450 CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
4451 Importer.Import(DTemplated));
4455 // Resolve possible cyclic import.
4456 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
4457 return AlreadyImported;
4459 // Create the class template declaration itself.
4460 TemplateParameterList *TemplateParams
4461 = ImportTemplateParameterList(D->getTemplateParameters());
4462 if (!TemplateParams)
4465 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
4466 Loc, Name, TemplateParams,
4468 /*PrevDecl=*/nullptr);
4469 D2Templated->setDescribedClassTemplate(D2);
4471 D2->setAccess(D->getAccess());
4472 D2->setLexicalDeclContext(LexicalDC);
4473 LexicalDC->addDeclInternal(D2);
4475 // Note the relationship between the class templates.
4476 Importer.Imported(D, D2);
4477 Importer.Imported(DTemplated, D2Templated);
4479 if (DTemplated->isCompleteDefinition() &&
4480 !D2Templated->isCompleteDefinition()) {
4481 // FIXME: Import definition!
4487 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4488 ClassTemplateSpecializationDecl *D) {
4489 // If this record has a definition in the translation unit we're coming from,
4490 // but this particular declaration is not that definition, import the
4491 // definition and map to that.
4492 TagDecl *Definition = D->getDefinition();
4493 if (Definition && Definition != D) {
4494 Decl *ImportedDef = Importer.Import(Definition);
4498 return Importer.Imported(D, ImportedDef);
4501 ClassTemplateDecl *ClassTemplate
4502 = cast_or_null<ClassTemplateDecl>(Importer.Import(
4503 D->getSpecializedTemplate()));
4507 // Import the context of this declaration.
4508 DeclContext *DC = ClassTemplate->getDeclContext();
4512 DeclContext *LexicalDC = DC;
4513 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4514 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4519 // Import the location of this declaration.
4520 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4521 SourceLocation IdLoc = Importer.Import(D->getLocation());
4523 // Import template arguments.
4524 SmallVector<TemplateArgument, 2> TemplateArgs;
4525 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4526 D->getTemplateArgs().size(),
4530 // Try to find an existing specialization with these template arguments.
4531 void *InsertPos = nullptr;
4532 ClassTemplateSpecializationDecl *D2
4533 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4535 // We already have a class template specialization with these template
4538 // FIXME: Check for specialization vs. instantiation errors.
4540 if (RecordDecl *FoundDef = D2->getDefinition()) {
4541 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4542 // The record types structurally match, or the "from" translation
4543 // unit only had a forward declaration anyway; call it the same
4545 return Importer.Imported(D, FoundDef);
4549 // Create a new specialization.
4550 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
4551 D->getTagKind(), DC,
4554 TemplateArgs.data(),
4555 TemplateArgs.size(),
4556 /*PrevDecl=*/nullptr);
4557 D2->setSpecializationKind(D->getSpecializationKind());
4559 // Add this specialization to the class template.
4560 ClassTemplate->AddSpecialization(D2, InsertPos);
4562 // Import the qualifier, if any.
4563 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4565 // Add the specialization to this context.
4566 D2->setLexicalDeclContext(LexicalDC);
4567 LexicalDC->addDeclInternal(D2);
4569 Importer.Imported(D, D2);
4571 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4577 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4578 // If this variable has a definition in the translation unit we're coming
4580 // but this particular declaration is not that definition, import the
4581 // definition and map to that.
4582 VarDecl *Definition =
4583 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4584 if (Definition && Definition != D->getTemplatedDecl()) {
4585 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4589 return Importer.Imported(D, ImportedDef);
4592 // Import the major distinguishing characteristics of this variable template.
4593 DeclContext *DC, *LexicalDC;
4594 DeclarationName Name;
4597 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4602 // We may already have a template of the same name; try to find and match it.
4603 assert(!DC->isFunctionOrMethod() &&
4604 "Variable templates cannot be declared at function scope");
4605 SmallVector<NamedDecl *, 4> ConflictingDecls;
4606 SmallVector<NamedDecl *, 2> FoundDecls;
4607 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4608 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4609 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4612 Decl *Found = FoundDecls[I];
4613 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4614 if (IsStructuralMatch(D, FoundTemplate)) {
4615 // The variable templates structurally match; call it the same template.
4616 Importer.Imported(D->getTemplatedDecl(),
4617 FoundTemplate->getTemplatedDecl());
4618 return Importer.Imported(D, FoundTemplate);
4622 ConflictingDecls.push_back(FoundDecls[I]);
4625 if (!ConflictingDecls.empty()) {
4626 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4627 ConflictingDecls.data(),
4628 ConflictingDecls.size());
4634 VarDecl *DTemplated = D->getTemplatedDecl();
4637 QualType T = Importer.Import(DTemplated->getType());
4641 // Create the declaration that is being templated.
4642 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4643 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4644 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4645 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4646 IdLoc, Name.getAsIdentifierInfo(), T,
4647 TInfo, DTemplated->getStorageClass());
4648 D2Templated->setAccess(DTemplated->getAccess());
4649 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4650 D2Templated->setLexicalDeclContext(LexicalDC);
4652 // Importer.Imported(DTemplated, D2Templated);
4653 // LexicalDC->addDeclInternal(D2Templated);
4655 // Merge the initializer.
4656 if (ImportDefinition(DTemplated, D2Templated))
4659 // Create the variable template declaration itself.
4660 TemplateParameterList *TemplateParams =
4661 ImportTemplateParameterList(D->getTemplateParameters());
4662 if (!TemplateParams)
4665 VarTemplateDecl *D2 = VarTemplateDecl::Create(
4666 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4667 D2Templated->setDescribedVarTemplate(D2);
4669 D2->setAccess(D->getAccess());
4670 D2->setLexicalDeclContext(LexicalDC);
4671 LexicalDC->addDeclInternal(D2);
4673 // Note the relationship between the variable templates.
4674 Importer.Imported(D, D2);
4675 Importer.Imported(DTemplated, D2Templated);
4677 if (DTemplated->isThisDeclarationADefinition() &&
4678 !D2Templated->isThisDeclarationADefinition()) {
4679 // FIXME: Import definition!
4685 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4686 VarTemplateSpecializationDecl *D) {
4687 // If this record has a definition in the translation unit we're coming from,
4688 // but this particular declaration is not that definition, import the
4689 // definition and map to that.
4690 VarDecl *Definition = D->getDefinition();
4691 if (Definition && Definition != D) {
4692 Decl *ImportedDef = Importer.Import(Definition);
4696 return Importer.Imported(D, ImportedDef);
4699 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4700 Importer.Import(D->getSpecializedTemplate()));
4704 // Import the context of this declaration.
4705 DeclContext *DC = VarTemplate->getDeclContext();
4709 DeclContext *LexicalDC = DC;
4710 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4711 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4716 // Import the location of this declaration.
4717 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4718 SourceLocation IdLoc = Importer.Import(D->getLocation());
4720 // Import template arguments.
4721 SmallVector<TemplateArgument, 2> TemplateArgs;
4722 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4723 D->getTemplateArgs().size(), TemplateArgs))
4726 // Try to find an existing specialization with these template arguments.
4727 void *InsertPos = nullptr;
4728 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4729 TemplateArgs, InsertPos);
4731 // We already have a variable template specialization with these template
4734 // FIXME: Check for specialization vs. instantiation errors.
4736 if (VarDecl *FoundDef = D2->getDefinition()) {
4737 if (!D->isThisDeclarationADefinition() ||
4738 IsStructuralMatch(D, FoundDef)) {
4739 // The record types structurally match, or the "from" translation
4740 // unit only had a forward declaration anyway; call it the same
4742 return Importer.Imported(D, FoundDef);
4748 QualType T = Importer.Import(D->getType());
4751 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4753 // Create a new specialization.
4754 D2 = VarTemplateSpecializationDecl::Create(
4755 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4756 D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size());
4757 D2->setSpecializationKind(D->getSpecializationKind());
4758 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4760 // Add this specialization to the class template.
4761 VarTemplate->AddSpecialization(D2, InsertPos);
4763 // Import the qualifier, if any.
4764 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4766 // Add the specialization to this context.
4767 D2->setLexicalDeclContext(LexicalDC);
4768 LexicalDC->addDeclInternal(D2);
4770 Importer.Imported(D, D2);
4772 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4778 //----------------------------------------------------------------------------
4779 // Import Statements
4780 //----------------------------------------------------------------------------
4782 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4784 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4785 size_t NumDecls = DG.end() - DG.begin();
4786 SmallVector<Decl *, 1> ToDecls(NumDecls);
4787 auto &_Importer = this->Importer;
4788 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4789 [&_Importer](Decl *D) -> Decl * {
4790 return _Importer.Import(D);
4792 return DeclGroupRef::Create(Importer.getToContext(),
4797 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4798 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4799 << S->getStmtClassName();
4804 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
4805 SmallVector<IdentifierInfo *, 4> Names;
4806 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4807 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4810 Names.push_back(ToII);
4812 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4813 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4816 Names.push_back(ToII);
4819 SmallVector<StringLiteral *, 4> Clobbers;
4820 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
4821 StringLiteral *Clobber = cast_or_null<StringLiteral>(
4822 Importer.Import(S->getClobberStringLiteral(I)));
4825 Clobbers.push_back(Clobber);
4828 SmallVector<StringLiteral *, 4> Constraints;
4829 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4830 StringLiteral *Output = cast_or_null<StringLiteral>(
4831 Importer.Import(S->getOutputConstraintLiteral(I)));
4834 Constraints.push_back(Output);
4837 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4838 StringLiteral *Input = cast_or_null<StringLiteral>(
4839 Importer.Import(S->getInputConstraintLiteral(I)));
4842 Constraints.push_back(Input);
4845 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
4846 if (ImportArrayChecked(S->begin_outputs(), S->end_outputs(), Exprs.begin()))
4849 if (ImportArrayChecked(S->begin_inputs(), S->end_inputs(),
4850 Exprs.begin() + S->getNumOutputs()))
4853 StringLiteral *AsmStr = cast_or_null<StringLiteral>(
4854 Importer.Import(S->getAsmString()));
4858 return new (Importer.getToContext()) GCCAsmStmt(
4859 Importer.getToContext(),
4860 Importer.Import(S->getAsmLoc()),
4869 S->getNumClobbers(),
4871 Importer.Import(S->getRParenLoc()));
4874 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
4875 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
4876 for (Decl *ToD : ToDG) {
4880 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4881 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4882 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
4885 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
4886 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4887 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
4888 S->hasLeadingEmptyMacro());
4891 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
4892 llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
4894 if (ImportArrayChecked(S->body_begin(), S->body_end(), ToStmts.begin()))
4897 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4898 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4899 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(),
4901 ToLBraceLoc, ToRBraceLoc);
4904 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
4905 Expr *ToLHS = Importer.Import(S->getLHS());
4908 Expr *ToRHS = Importer.Import(S->getRHS());
4909 if (!ToRHS && S->getRHS())
4911 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4912 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4913 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4914 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS,
4915 ToCaseLoc, ToEllipsisLoc,
4919 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
4920 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4921 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4922 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4923 if (!ToSubStmt && S->getSubStmt())
4925 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
4929 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
4930 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4931 LabelDecl *ToLabelDecl =
4932 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4933 if (!ToLabelDecl && S->getDecl())
4935 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4936 if (!ToSubStmt && S->getSubStmt())
4938 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
4942 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
4943 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4944 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
4945 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
4946 ASTContext &_ToContext = Importer.getToContext();
4947 std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
4948 [&_ToContext](const Attr *A) -> const Attr * {
4949 return A->clone(_ToContext);
4951 for (const Attr *ToA : ToAttrs) {
4955 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4956 if (!ToSubStmt && S->getSubStmt())
4958 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
4959 ToAttrs, ToSubStmt);
4962 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
4963 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4964 VarDecl *ToConditionVariable = nullptr;
4965 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4966 ToConditionVariable =
4967 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4968 if (!ToConditionVariable)
4971 Expr *ToCondition = Importer.Import(S->getCond());
4972 if (!ToCondition && S->getCond())
4974 Stmt *ToThenStmt = Importer.Import(S->getThen());
4975 if (!ToThenStmt && S->getThen())
4977 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4978 Stmt *ToElseStmt = Importer.Import(S->getElse());
4979 if (!ToElseStmt && S->getElse())
4981 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
4982 ToIfLoc, ToConditionVariable,
4983 ToCondition, ToThenStmt,
4984 ToElseLoc, ToElseStmt);
4987 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
4988 VarDecl *ToConditionVariable = nullptr;
4989 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4990 ToConditionVariable =
4991 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4992 if (!ToConditionVariable)
4995 Expr *ToCondition = Importer.Import(S->getCond());
4996 if (!ToCondition && S->getCond())
4998 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
4999 Importer.getToContext(), ToConditionVariable,
5001 Stmt *ToBody = Importer.Import(S->getBody());
5002 if (!ToBody && S->getBody())
5004 ToStmt->setBody(ToBody);
5005 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5006 // Now we have to re-chain the cases.
5007 SwitchCase *LastChainedSwitchCase = nullptr;
5008 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5009 SC = SC->getNextSwitchCase()) {
5010 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5013 if (LastChainedSwitchCase)
5014 LastChainedSwitchCase->setNextSwitchCase(ToSC);
5016 ToStmt->setSwitchCaseList(ToSC);
5017 LastChainedSwitchCase = ToSC;
5022 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5023 VarDecl *ToConditionVariable = nullptr;
5024 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5025 ToConditionVariable =
5026 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5027 if (!ToConditionVariable)
5030 Expr *ToCondition = Importer.Import(S->getCond());
5031 if (!ToCondition && S->getCond())
5033 Stmt *ToBody = Importer.Import(S->getBody());
5034 if (!ToBody && S->getBody())
5036 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5037 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5038 ToConditionVariable,
5039 ToCondition, ToBody,
5043 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5044 Stmt *ToBody = Importer.Import(S->getBody());
5045 if (!ToBody && S->getBody())
5047 Expr *ToCondition = Importer.Import(S->getCond());
5048 if (!ToCondition && S->getCond())
5050 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5051 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5052 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5053 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5054 ToDoLoc, ToWhileLoc,
5058 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5059 Stmt *ToInit = Importer.Import(S->getInit());
5060 if (!ToInit && S->getInit())
5062 Expr *ToCondition = Importer.Import(S->getCond());
5063 if (!ToCondition && S->getCond())
5065 VarDecl *ToConditionVariable = nullptr;
5066 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5067 ToConditionVariable =
5068 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5069 if (!ToConditionVariable)
5072 Expr *ToInc = Importer.Import(S->getInc());
5073 if (!ToInc && S->getInc())
5075 Stmt *ToBody = Importer.Import(S->getBody());
5076 if (!ToBody && S->getBody())
5078 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5079 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5080 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5081 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5082 ToInit, ToCondition,
5083 ToConditionVariable,
5085 ToForLoc, ToLParenLoc,
5089 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5090 LabelDecl *ToLabel = nullptr;
5091 if (LabelDecl *FromLabel = S->getLabel()) {
5092 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5096 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5097 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5098 return new (Importer.getToContext()) GotoStmt(ToLabel,
5099 ToGotoLoc, ToLabelLoc);
5102 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5103 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5104 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5105 Expr *ToTarget = Importer.Import(S->getTarget());
5106 if (!ToTarget && S->getTarget())
5108 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5112 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5113 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5114 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5117 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5118 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5119 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5122 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5123 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5124 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5125 if (!ToRetExpr && S->getRetValue())
5127 VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
5128 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5129 if (!ToNRVOCandidate && NRVOCandidate)
5131 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5135 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5136 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5137 VarDecl *ToExceptionDecl = nullptr;
5138 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5140 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5141 if (!ToExceptionDecl)
5144 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5145 if (!ToHandlerBlock && S->getHandlerBlock())
5147 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5152 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5153 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5154 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5155 if (!ToTryBlock && S->getTryBlock())
5157 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5158 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5159 CXXCatchStmt *FromHandler = S->getHandler(HI);
5160 if (Stmt *ToHandler = Importer.Import(FromHandler))
5161 ToHandlers[HI] = ToHandler;
5165 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5169 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5171 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5172 if (!ToRange && S->getRangeStmt())
5175 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5176 if (!ToBegin && S->getBeginStmt())
5179 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5180 if (!ToEnd && S->getEndStmt())
5182 Expr *ToCond = Importer.Import(S->getCond());
5183 if (!ToCond && S->getCond())
5185 Expr *ToInc = Importer.Import(S->getInc());
5186 if (!ToInc && S->getInc())
5188 DeclStmt *ToLoopVar =
5189 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5190 if (!ToLoopVar && S->getLoopVarStmt())
5192 Stmt *ToBody = Importer.Import(S->getBody());
5193 if (!ToBody && S->getBody())
5195 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5196 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5197 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5198 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5199 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5202 ToForLoc, ToCoawaitLoc,
5203 ToColonLoc, ToRParenLoc);
5206 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5207 Stmt *ToElem = Importer.Import(S->getElement());
5208 if (!ToElem && S->getElement())
5210 Expr *ToCollect = Importer.Import(S->getCollection());
5211 if (!ToCollect && S->getCollection())
5213 Stmt *ToBody = Importer.Import(S->getBody());
5214 if (!ToBody && S->getBody())
5216 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5217 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5218 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5224 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5225 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5226 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5227 VarDecl *ToExceptionDecl = nullptr;
5228 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5230 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5231 if (!ToExceptionDecl)
5234 Stmt *ToBody = Importer.Import(S->getCatchBody());
5235 if (!ToBody && S->getCatchBody())
5237 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5243 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5244 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5245 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5246 if (!ToAtFinallyStmt && S->getFinallyBody())
5248 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5252 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5253 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5254 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5255 if (!ToAtTryStmt && S->getTryBody())
5257 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5258 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5259 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5260 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5261 ToCatchStmts[CI] = ToCatchStmt;
5265 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5266 if (!ToAtFinallyStmt && S->getFinallyStmt())
5268 return ObjCAtTryStmt::Create(Importer.getToContext(),
5269 ToAtTryLoc, ToAtTryStmt,
5270 ToCatchStmts.begin(), ToCatchStmts.size(),
5274 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5275 (ObjCAtSynchronizedStmt *S) {
5276 SourceLocation ToAtSynchronizedLoc =
5277 Importer.Import(S->getAtSynchronizedLoc());
5278 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5279 if (!ToSynchExpr && S->getSynchExpr())
5281 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5282 if (!ToSynchBody && S->getSynchBody())
5284 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5285 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5288 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5289 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5290 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5291 if (!ToThrow && S->getThrowExpr())
5293 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5296 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5297 (ObjCAutoreleasePoolStmt *S) {
5298 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5299 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5300 if (!ToSubStmt && S->getSubStmt())
5302 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5306 //----------------------------------------------------------------------------
5307 // Import Expressions
5308 //----------------------------------------------------------------------------
5309 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5310 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5311 << E->getStmtClassName();
5315 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5316 QualType T = Importer.Import(E->getType());
5320 Expr *SubExpr = Importer.Import(E->getSubExpr());
5321 if (!SubExpr && E->getSubExpr())
5324 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5328 return new (Importer.getToContext()) VAArgExpr(
5329 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5330 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5334 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5335 QualType T = Importer.Import(E->getType());
5339 return new (Importer.getToContext()) GNUNullExpr(
5340 T, Importer.Import(E->getExprLoc()));
5343 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5344 QualType T = Importer.Import(E->getType());
5348 StringLiteral *SL = cast_or_null<StringLiteral>(
5349 Importer.Import(E->getFunctionName()));
5350 if (!SL && E->getFunctionName())
5353 return new (Importer.getToContext()) PredefinedExpr(
5354 Importer.Import(E->getExprLoc()), T, E->getIdentType(), SL);
5357 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5358 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5362 NamedDecl *FoundD = nullptr;
5363 if (E->getDecl() != E->getFoundDecl()) {
5364 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5369 QualType T = Importer.Import(E->getType());
5373 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5374 Importer.Import(E->getQualifierLoc()),
5375 Importer.Import(E->getTemplateKeywordLoc()),
5377 E->refersToEnclosingVariableOrCapture(),
5378 Importer.Import(E->getLocation()),
5379 T, E->getValueKind(),
5381 /*FIXME:TemplateArgs=*/nullptr);
5382 if (E->hadMultipleCandidates())
5383 DRE->setHadMultipleCandidates(true);
5387 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5388 QualType T = Importer.Import(E->getType());
5392 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5395 ASTNodeImporter::Designator
5396 ASTNodeImporter::ImportDesignator(const Designator &D) {
5397 if (D.isFieldDesignator()) {
5398 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5399 // Caller checks for import error
5400 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5401 Importer.Import(D.getFieldLoc()));
5403 if (D.isArrayDesignator())
5404 return Designator(D.getFirstExprIndex(),
5405 Importer.Import(D.getLBracketLoc()),
5406 Importer.Import(D.getRBracketLoc()));
5408 assert(D.isArrayRangeDesignator());
5409 return Designator(D.getFirstExprIndex(),
5410 Importer.Import(D.getLBracketLoc()),
5411 Importer.Import(D.getEllipsisLoc()),
5412 Importer.Import(D.getRBracketLoc()));
5416 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5417 Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5421 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5422 // List elements from the second, the first is Init itself
5423 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5424 if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5425 IndexExprs[I - 1] = Arg;
5430 SmallVector<Designator, 4> Designators(DIE->size());
5431 std::transform(DIE->designators_begin(), DIE->designators_end(),
5432 Designators.begin(),
5433 [this](const Designator &D) -> Designator {
5434 return ImportDesignator(D);
5437 for (auto I = DIE->designators_begin(), E = DIE->designators_end(); I != E;
5439 if (I->isFieldDesignator() && !I->getFieldName())
5442 return DesignatedInitExpr::Create(
5443 Importer.getToContext(), Designators.data(), Designators.size(),
5444 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5445 DIE->usesGNUSyntax(), Init);
5448 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5449 QualType T = Importer.Import(E->getType());
5453 return new (Importer.getToContext())
5454 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5457 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5458 QualType T = Importer.Import(E->getType());
5462 return IntegerLiteral::Create(Importer.getToContext(),
5464 Importer.Import(E->getLocation()));
5467 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5468 QualType T = Importer.Import(E->getType());
5472 return FloatingLiteral::Create(Importer.getToContext(),
5473 E->getValue(), E->isExact(), T,
5474 Importer.Import(E->getLocation()));
5477 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5478 QualType T = Importer.Import(E->getType());
5482 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5484 Importer.Import(E->getLocation()));
5487 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5488 QualType T = Importer.Import(E->getType());
5492 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5493 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5495 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5496 E->getKind(), E->isPascal(), T,
5497 Locations.data(), Locations.size());
5500 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5501 QualType T = Importer.Import(E->getType());
5505 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5509 Expr *Init = Importer.Import(E->getInitializer());
5513 return new (Importer.getToContext()) CompoundLiteralExpr(
5514 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5515 Init, E->isFileScope());
5518 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5519 QualType T = Importer.Import(E->getType());
5523 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5524 if (ImportArrayChecked(
5525 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5529 return new (Importer.getToContext()) AtomicExpr(
5530 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5531 Importer.Import(E->getRParenLoc()));
5534 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5535 QualType T = Importer.Import(E->getType());
5539 LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5543 return new (Importer.getToContext()) AddrLabelExpr(
5544 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5548 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5549 Expr *SubExpr = Importer.Import(E->getSubExpr());
5553 return new (Importer.getToContext())
5554 ParenExpr(Importer.Import(E->getLParen()),
5555 Importer.Import(E->getRParen()),
5559 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5560 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5561 if (ImportArrayChecked(
5562 E->getExprs(), E->getExprs() + E->getNumExprs(), Exprs.begin()))
5565 return new (Importer.getToContext()) ParenListExpr(
5566 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5567 Exprs, Importer.Import(E->getLParenLoc()));
5570 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5571 QualType T = Importer.Import(E->getType());
5575 CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
5576 Importer.Import(E->getSubStmt()));
5577 if (!ToSubStmt && E->getSubStmt())
5580 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5581 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5584 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5585 QualType T = Importer.Import(E->getType());
5589 Expr *SubExpr = Importer.Import(E->getSubExpr());
5593 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
5594 T, E->getValueKind(),
5596 Importer.Import(E->getOperatorLoc()));
5599 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
5600 UnaryExprOrTypeTraitExpr *E) {
5601 QualType ResultType = Importer.Import(E->getType());
5603 if (E->isArgumentType()) {
5604 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5608 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5610 Importer.Import(E->getOperatorLoc()),
5611 Importer.Import(E->getRParenLoc()));
5614 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5618 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5619 SubExpr, ResultType,
5620 Importer.Import(E->getOperatorLoc()),
5621 Importer.Import(E->getRParenLoc()));
5624 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5625 QualType T = Importer.Import(E->getType());
5629 Expr *LHS = Importer.Import(E->getLHS());
5633 Expr *RHS = Importer.Import(E->getRHS());
5637 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5638 T, E->getValueKind(),
5640 Importer.Import(E->getOperatorLoc()),
5641 E->isFPContractable());
5644 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
5645 QualType T = Importer.Import(E->getType());
5649 Expr *ToLHS = Importer.Import(E->getLHS());
5653 Expr *ToRHS = Importer.Import(E->getRHS());
5657 Expr *ToCond = Importer.Import(E->getCond());
5661 return new (Importer.getToContext()) ConditionalOperator(
5662 ToCond, Importer.Import(E->getQuestionLoc()),
5663 ToLHS, Importer.Import(E->getColonLoc()),
5664 ToRHS, T, E->getValueKind(), E->getObjectKind());
5667 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
5668 BinaryConditionalOperator *E) {
5669 QualType T = Importer.Import(E->getType());
5673 Expr *Common = Importer.Import(E->getCommon());
5677 Expr *Cond = Importer.Import(E->getCond());
5681 OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5682 Importer.Import(E->getOpaqueValue()));
5686 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5690 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5694 return new (Importer.getToContext()) BinaryConditionalOperator(
5695 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5696 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5697 T, E->getValueKind(), E->getObjectKind());
5700 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
5701 QualType T = Importer.Import(E->getType());
5705 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5706 if (!SourceExpr && E->getSourceExpr())
5709 return new (Importer.getToContext()) OpaqueValueExpr(
5710 Importer.Import(E->getExprLoc()), T, E->getValueKind(),
5711 E->getObjectKind(), SourceExpr);
5714 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5715 QualType T = Importer.Import(E->getType());
5719 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5720 if (CompLHSType.isNull())
5723 QualType CompResultType = Importer.Import(E->getComputationResultType());
5724 if (CompResultType.isNull())
5727 Expr *LHS = Importer.Import(E->getLHS());
5731 Expr *RHS = Importer.Import(E->getRHS());
5735 return new (Importer.getToContext())
5736 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5737 T, E->getValueKind(),
5739 CompLHSType, CompResultType,
5740 Importer.Import(E->getOperatorLoc()),
5741 E->isFPContractable());
5744 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) {
5745 if (E->path_empty()) return false;
5747 // TODO: import cast paths
5751 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
5752 QualType T = Importer.Import(E->getType());
5756 Expr *SubExpr = Importer.Import(E->getSubExpr());
5760 CXXCastPath BasePath;
5761 if (ImportCastPath(E, BasePath))
5764 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5765 SubExpr, &BasePath, E->getValueKind());
5768 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) {
5769 QualType T = Importer.Import(E->getType());
5773 Expr *SubExpr = Importer.Import(E->getSubExpr());
5777 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5778 if (!TInfo && E->getTypeInfoAsWritten())
5781 CXXCastPath BasePath;
5782 if (ImportCastPath(E, BasePath))
5785 return CStyleCastExpr::Create(Importer.getToContext(), T,
5786 E->getValueKind(), E->getCastKind(),
5787 SubExpr, &BasePath, TInfo,
5788 Importer.Import(E->getLParenLoc()),
5789 Importer.Import(E->getRParenLoc()));
5792 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
5793 QualType T = Importer.Import(E->getType());
5797 NamedDecl *ToFound =
5798 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl()));
5802 CXXConstructorDecl *ToCCD =
5803 dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5807 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
5808 if (ImportArrayChecked(E->getArgs(), E->getArgs() + E->getNumArgs(),
5812 return CXXConstructExpr::Create(Importer.getToContext(), T,
5813 Importer.Import(E->getLocation()),
5814 ToFound, ToCCD, E->isElidable(),
5815 ToArgs, E->hadMultipleCandidates(),
5816 E->isListInitialization(),
5817 E->isStdInitListInitialization(),
5818 E->requiresZeroInitialization(),
5819 E->getConstructionKind(),
5820 Importer.Import(E->getParenOrBraceRange()));
5823 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
5824 QualType T = Importer.Import(E->getType());
5828 Expr *ToFn = Importer.Import(E->getCallee());
5832 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
5834 if (ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
5837 return new (Importer.getToContext()) CXXMemberCallExpr(
5838 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
5839 Importer.Import(E->getRParenLoc()));
5842 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
5843 QualType T = Importer.Import(E->getType());
5847 return new (Importer.getToContext())
5848 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
5851 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
5852 QualType T = Importer.Import(E->getType());
5856 return new (Importer.getToContext())
5857 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
5861 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
5862 QualType T = Importer.Import(E->getType());
5866 Expr *ToBase = Importer.Import(E->getBase());
5867 if (!ToBase && E->getBase())
5870 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5871 if (!ToMember && E->getMemberDecl())
5874 DeclAccessPair ToFoundDecl = DeclAccessPair::make(
5875 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5876 E->getFoundDecl().getAccess());
5878 DeclarationNameInfo ToMemberNameInfo(
5879 Importer.Import(E->getMemberNameInfo().getName()),
5880 Importer.Import(E->getMemberNameInfo().getLoc()));
5882 if (E->hasExplicitTemplateArgs()) {
5883 return nullptr; // FIXME: handle template arguments
5886 return MemberExpr::Create(Importer.getToContext(), ToBase,
5888 Importer.Import(E->getOperatorLoc()),
5889 Importer.Import(E->getQualifierLoc()),
5890 Importer.Import(E->getTemplateKeywordLoc()),
5891 ToMember, ToFoundDecl, ToMemberNameInfo,
5892 nullptr, T, E->getValueKind(),
5893 E->getObjectKind());
5896 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
5897 QualType T = Importer.Import(E->getType());
5901 Expr *ToCallee = Importer.Import(E->getCallee());
5902 if (!ToCallee && E->getCallee())
5905 unsigned NumArgs = E->getNumArgs();
5907 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
5909 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
5910 Expr *FromArg = E->getArg(ai);
5911 Expr *ToArg = Importer.Import(FromArg);
5917 Expr **ToArgs_Copied = new (Importer.getToContext())
5920 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
5921 ToArgs_Copied[ai] = ToArgs[ai];
5923 return new (Importer.getToContext())
5924 CallExpr(Importer.getToContext(), ToCallee,
5925 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
5926 Importer.Import(E->getRParenLoc()));
5929 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
5930 QualType T = Importer.Import(ILE->getType());
5934 llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
5935 if (ImportArrayChecked(
5936 ILE->getInits(), ILE->getInits() + ILE->getNumInits(), Exprs.begin()))
5939 ASTContext &ToCtx = Importer.getToContext();
5940 InitListExpr *To = new (ToCtx) InitListExpr(
5941 ToCtx, Importer.Import(ILE->getLBraceLoc()),
5942 Exprs, Importer.Import(ILE->getLBraceLoc()));
5945 if (ILE->hasArrayFiller()) {
5946 Expr *Filler = Importer.Import(ILE->getArrayFiller());
5949 To->setArrayFiller(Filler);
5952 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
5953 FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
5956 To->setInitializedFieldInUnion(ToFD);
5959 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
5960 InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
5961 Importer.Import(SyntForm));
5964 To->setSyntacticForm(ToSyntForm);
5967 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
5968 To->setValueDependent(ILE->isValueDependent());
5969 To->setInstantiationDependent(ILE->isInstantiationDependent());
5974 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
5975 ASTContext &FromContext, FileManager &FromFileManager,
5977 : ToContext(ToContext), FromContext(FromContext),
5978 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
5979 Minimal(MinimalImport), LastDiagFromFrom(false)
5981 ImportedDecls[FromContext.getTranslationUnitDecl()]
5982 = ToContext.getTranslationUnitDecl();
5985 ASTImporter::~ASTImporter() { }
5987 QualType ASTImporter::Import(QualType FromT) {
5991 const Type *fromTy = FromT.getTypePtr();
5993 // Check whether we've already imported this type.
5994 llvm::DenseMap<const Type *, const Type *>::iterator Pos
5995 = ImportedTypes.find(fromTy);
5996 if (Pos != ImportedTypes.end())
5997 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6000 ASTNodeImporter Importer(*this);
6001 QualType ToT = Importer.Visit(fromTy);
6005 // Record the imported type.
6006 ImportedTypes[fromTy] = ToT.getTypePtr();
6008 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6011 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6015 // FIXME: For now we just create a "trivial" type source info based
6016 // on the type and a single location. Implement a real version of this.
6017 QualType T = Import(FromTSI->getType());
6021 return ToContext.getTrivialTypeSourceInfo(T,
6022 Import(FromTSI->getTypeLoc().getLocStart()));
6025 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6026 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6027 if (Pos != ImportedDecls.end()) {
6028 Decl *ToD = Pos->second;
6029 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6036 Decl *ASTImporter::Import(Decl *FromD) {
6040 ASTNodeImporter Importer(*this);
6042 // Check whether we've already imported this declaration.
6043 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6044 if (Pos != ImportedDecls.end()) {
6045 Decl *ToD = Pos->second;
6046 Importer.ImportDefinitionIfNeeded(FromD, ToD);
6051 Decl *ToD = Importer.Visit(FromD);
6055 // Record the imported declaration.
6056 ImportedDecls[FromD] = ToD;
6058 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6059 // Keep track of anonymous tags that have an associated typedef.
6060 if (FromTag->getTypedefNameForAnonDecl())
6061 AnonTagsWithPendingTypedefs.push_back(FromTag);
6062 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6063 // When we've finished transforming a typedef, see whether it was the
6064 // typedef for an anonymous tag.
6065 for (SmallVectorImpl<TagDecl *>::iterator
6066 FromTag = AnonTagsWithPendingTypedefs.begin(),
6067 FromTagEnd = AnonTagsWithPendingTypedefs.end();
6068 FromTag != FromTagEnd; ++FromTag) {
6069 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6070 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6071 // We found the typedef for an anonymous tag; link them.
6072 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6073 AnonTagsWithPendingTypedefs.erase(FromTag);
6083 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6087 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6091 // When we're using a record/enum/Objective-C class/protocol as a context, we
6092 // need it to have a definition.
6093 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6094 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6095 if (ToRecord->isCompleteDefinition()) {
6097 } else if (FromRecord->isCompleteDefinition()) {
6098 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6099 ASTNodeImporter::IDK_Basic);
6101 CompleteDecl(ToRecord);
6103 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
6104 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
6105 if (ToEnum->isCompleteDefinition()) {
6107 } else if (FromEnum->isCompleteDefinition()) {
6108 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
6109 ASTNodeImporter::IDK_Basic);
6111 CompleteDecl(ToEnum);
6113 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
6114 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
6115 if (ToClass->getDefinition()) {
6117 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
6118 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
6119 ASTNodeImporter::IDK_Basic);
6121 CompleteDecl(ToClass);
6123 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
6124 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
6125 if (ToProto->getDefinition()) {
6127 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
6128 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
6129 ASTNodeImporter::IDK_Basic);
6131 CompleteDecl(ToProto);
6138 Expr *ASTImporter::Import(Expr *FromE) {
6142 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
6145 Stmt *ASTImporter::Import(Stmt *FromS) {
6149 // Check whether we've already imported this declaration.
6150 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
6151 if (Pos != ImportedStmts.end())
6155 ASTNodeImporter Importer(*this);
6156 Stmt *ToS = Importer.Visit(FromS);
6160 // Record the imported declaration.
6161 ImportedStmts[FromS] = ToS;
6165 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
6169 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
6171 switch (FromNNS->getKind()) {
6172 case NestedNameSpecifier::Identifier:
6173 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
6174 return NestedNameSpecifier::Create(ToContext, prefix, II);
6178 case NestedNameSpecifier::Namespace:
6179 if (NamespaceDecl *NS =
6180 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
6181 return NestedNameSpecifier::Create(ToContext, prefix, NS);
6185 case NestedNameSpecifier::NamespaceAlias:
6186 if (NamespaceAliasDecl *NSAD =
6187 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
6188 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
6192 case NestedNameSpecifier::Global:
6193 return NestedNameSpecifier::GlobalSpecifier(ToContext);
6195 case NestedNameSpecifier::Super:
6196 if (CXXRecordDecl *RD =
6197 cast<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
6198 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
6202 case NestedNameSpecifier::TypeSpec:
6203 case NestedNameSpecifier::TypeSpecWithTemplate: {
6204 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
6206 bool bTemplate = FromNNS->getKind() ==
6207 NestedNameSpecifier::TypeSpecWithTemplate;
6208 return NestedNameSpecifier::Create(ToContext, prefix,
6209 bTemplate, T.getTypePtr());
6215 llvm_unreachable("Invalid nested name specifier kind");
6218 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
6219 // FIXME: Implement!
6220 return NestedNameSpecifierLoc();
6223 TemplateName ASTImporter::Import(TemplateName From) {
6224 switch (From.getKind()) {
6225 case TemplateName::Template:
6226 if (TemplateDecl *ToTemplate
6227 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
6228 return TemplateName(ToTemplate);
6230 return TemplateName();
6232 case TemplateName::OverloadedTemplate: {
6233 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
6234 UnresolvedSet<2> ToTemplates;
6235 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
6236 E = FromStorage->end();
6238 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
6239 ToTemplates.addDecl(To);
6241 return TemplateName();
6243 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
6247 case TemplateName::QualifiedTemplate: {
6248 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
6249 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
6251 return TemplateName();
6253 if (TemplateDecl *ToTemplate
6254 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
6255 return ToContext.getQualifiedTemplateName(Qualifier,
6256 QTN->hasTemplateKeyword(),
6259 return TemplateName();
6262 case TemplateName::DependentTemplate: {
6263 DependentTemplateName *DTN = From.getAsDependentTemplateName();
6264 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
6266 return TemplateName();
6268 if (DTN->isIdentifier()) {
6269 return ToContext.getDependentTemplateName(Qualifier,
6270 Import(DTN->getIdentifier()));
6273 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
6276 case TemplateName::SubstTemplateTemplateParm: {
6277 SubstTemplateTemplateParmStorage *subst
6278 = From.getAsSubstTemplateTemplateParm();
6279 TemplateTemplateParmDecl *param
6280 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
6282 return TemplateName();
6284 TemplateName replacement = Import(subst->getReplacement());
6285 if (replacement.isNull()) return TemplateName();
6287 return ToContext.getSubstTemplateTemplateParm(param, replacement);
6290 case TemplateName::SubstTemplateTemplateParmPack: {
6291 SubstTemplateTemplateParmPackStorage *SubstPack
6292 = From.getAsSubstTemplateTemplateParmPack();
6293 TemplateTemplateParmDecl *Param
6294 = cast_or_null<TemplateTemplateParmDecl>(
6295 Import(SubstPack->getParameterPack()));
6297 return TemplateName();
6299 ASTNodeImporter Importer(*this);
6300 TemplateArgument ArgPack
6301 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
6302 if (ArgPack.isNull())
6303 return TemplateName();
6305 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
6309 llvm_unreachable("Invalid template name kind");
6312 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
6313 if (FromLoc.isInvalid())
6314 return SourceLocation();
6316 SourceManager &FromSM = FromContext.getSourceManager();
6318 // For now, map everything down to its spelling location, so that we
6319 // don't have to import macro expansions.
6320 // FIXME: Import macro expansions!
6321 FromLoc = FromSM.getSpellingLoc(FromLoc);
6322 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
6323 SourceManager &ToSM = ToContext.getSourceManager();
6324 FileID ToFileID = Import(Decomposed.first);
6325 if (ToFileID.isInvalid())
6326 return SourceLocation();
6327 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
6328 .getLocWithOffset(Decomposed.second);
6332 SourceRange ASTImporter::Import(SourceRange FromRange) {
6333 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
6336 FileID ASTImporter::Import(FileID FromID) {
6337 llvm::DenseMap<FileID, FileID>::iterator Pos
6338 = ImportedFileIDs.find(FromID);
6339 if (Pos != ImportedFileIDs.end())
6342 SourceManager &FromSM = FromContext.getSourceManager();
6343 SourceManager &ToSM = ToContext.getSourceManager();
6344 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
6345 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
6347 // Include location of this file.
6348 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
6350 // Map the FileID for to the "to" source manager.
6352 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
6353 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
6354 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
6356 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
6357 // than mmap the files several times.
6358 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
6361 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
6362 FromSLoc.getFile().getFileCharacteristic());
6364 // FIXME: We want to re-use the existing MemoryBuffer!
6365 const llvm::MemoryBuffer *
6366 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
6367 std::unique_ptr<llvm::MemoryBuffer> ToBuf
6368 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
6369 FromBuf->getBufferIdentifier());
6370 ToID = ToSM.createFileID(std::move(ToBuf),
6371 FromSLoc.getFile().getFileCharacteristic());
6375 ImportedFileIDs[FromID] = ToID;
6379 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
6380 Expr *ToExpr = Import(From->getInit());
6381 if (!ToExpr && From->getInit())
6384 if (From->isBaseInitializer()) {
6385 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
6386 if (!ToTInfo && From->getTypeSourceInfo())
6389 return new (ToContext) CXXCtorInitializer(
6390 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
6391 ToExpr, Import(From->getRParenLoc()),
6392 From->isPackExpansion() ? Import(From->getEllipsisLoc())
6393 : SourceLocation());
6394 } else if (From->isMemberInitializer()) {
6395 FieldDecl *ToField =
6396 llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
6397 if (!ToField && From->getMember())
6400 return new (ToContext) CXXCtorInitializer(
6401 ToContext, ToField, Import(From->getMemberLocation()),
6402 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
6403 } else if (From->isIndirectMemberInitializer()) {
6404 IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
6405 Import(From->getIndirectMember()));
6406 if (!ToIField && From->getIndirectMember())
6409 return new (ToContext) CXXCtorInitializer(
6410 ToContext, ToIField, Import(From->getMemberLocation()),
6411 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
6412 } else if (From->isDelegatingInitializer()) {
6413 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
6414 if (!ToTInfo && From->getTypeSourceInfo())
6417 return new (ToContext)
6418 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
6419 ToExpr, Import(From->getRParenLoc()));
6420 } else if (unsigned NumArrayIndices = From->getNumArrayIndices()) {
6421 FieldDecl *ToField =
6422 llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
6423 if (!ToField && From->getMember())
6426 SmallVector<VarDecl *, 4> ToAIs(NumArrayIndices);
6428 for (unsigned AII = 0; AII < NumArrayIndices; ++AII) {
6429 VarDecl *ToArrayIndex =
6430 dyn_cast_or_null<VarDecl>(Import(From->getArrayIndex(AII)));
6431 if (!ToArrayIndex && From->getArrayIndex(AII))
6435 return CXXCtorInitializer::Create(
6436 ToContext, ToField, Import(From->getMemberLocation()),
6437 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()),
6438 ToAIs.data(), NumArrayIndices);
6445 void ASTImporter::ImportDefinition(Decl *From) {
6446 Decl *To = Import(From);
6450 if (DeclContext *FromDC = cast<DeclContext>(From)) {
6451 ASTNodeImporter Importer(*this);
6453 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
6454 if (!ToRecord->getDefinition()) {
6455 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
6456 ASTNodeImporter::IDK_Everything);
6461 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
6462 if (!ToEnum->getDefinition()) {
6463 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
6464 ASTNodeImporter::IDK_Everything);
6469 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
6470 if (!ToIFace->getDefinition()) {
6471 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
6472 ASTNodeImporter::IDK_Everything);
6477 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
6478 if (!ToProto->getDefinition()) {
6479 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
6480 ASTNodeImporter::IDK_Everything);
6485 Importer.ImportDeclContext(FromDC, true);
6489 DeclarationName ASTImporter::Import(DeclarationName FromName) {
6491 return DeclarationName();
6493 switch (FromName.getNameKind()) {
6494 case DeclarationName::Identifier:
6495 return Import(FromName.getAsIdentifierInfo());
6497 case DeclarationName::ObjCZeroArgSelector:
6498 case DeclarationName::ObjCOneArgSelector:
6499 case DeclarationName::ObjCMultiArgSelector:
6500 return Import(FromName.getObjCSelector());
6502 case DeclarationName::CXXConstructorName: {
6503 QualType T = Import(FromName.getCXXNameType());
6505 return DeclarationName();
6507 return ToContext.DeclarationNames.getCXXConstructorName(
6508 ToContext.getCanonicalType(T));
6511 case DeclarationName::CXXDestructorName: {
6512 QualType T = Import(FromName.getCXXNameType());
6514 return DeclarationName();
6516 return ToContext.DeclarationNames.getCXXDestructorName(
6517 ToContext.getCanonicalType(T));
6520 case DeclarationName::CXXConversionFunctionName: {
6521 QualType T = Import(FromName.getCXXNameType());
6523 return DeclarationName();
6525 return ToContext.DeclarationNames.getCXXConversionFunctionName(
6526 ToContext.getCanonicalType(T));
6529 case DeclarationName::CXXOperatorName:
6530 return ToContext.DeclarationNames.getCXXOperatorName(
6531 FromName.getCXXOverloadedOperator());
6533 case DeclarationName::CXXLiteralOperatorName:
6534 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
6535 Import(FromName.getCXXLiteralIdentifier()));
6537 case DeclarationName::CXXUsingDirective:
6539 return DeclarationName::getUsingDirectiveName();
6542 llvm_unreachable("Invalid DeclarationName Kind!");
6545 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
6549 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
6551 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
6552 ToId->setBuiltinID(FromId->getBuiltinID());
6557 Selector ASTImporter::Import(Selector FromSel) {
6558 if (FromSel.isNull())
6561 SmallVector<IdentifierInfo *, 4> Idents;
6562 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
6563 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
6564 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
6565 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
6568 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
6572 unsigned NumDecls) {
6576 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
6577 if (LastDiagFromFrom)
6578 ToContext.getDiagnostics().notePriorDiagnosticFrom(
6579 FromContext.getDiagnostics());
6580 LastDiagFromFrom = false;
6581 return ToContext.getDiagnostics().Report(Loc, DiagID);
6584 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
6585 if (!LastDiagFromFrom)
6586 FromContext.getDiagnostics().notePriorDiagnosticFrom(
6587 ToContext.getDiagnostics());
6588 LastDiagFromFrom = true;
6589 return FromContext.getDiagnostics().Report(Loc, DiagID);
6592 void ASTImporter::CompleteDecl (Decl *D) {
6593 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
6594 if (!ID->getDefinition())
6595 ID->startDefinition();
6597 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
6598 if (!PD->getDefinition())
6599 PD->startDefinition();
6601 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
6602 if (!TD->getDefinition() && !TD->isBeingDefined()) {
6603 TD->startDefinition();
6604 TD->setCompleteDefinition(true);
6608 assert (0 && "CompleteDecl called on a Decl that can't be completed");
6612 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
6613 if (From->hasAttrs()) {
6614 for (Attr *FromAttr : From->getAttrs())
6615 To->addAttr(FromAttr->clone(To->getASTContext()));
6617 if (From->isUsed()) {
6620 ImportedDecls[From] = To;
6624 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
6626 llvm::DenseMap<const Type *, const Type *>::iterator Pos
6627 = ImportedTypes.find(From.getTypePtr());
6628 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
6631 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
6633 return Ctx.IsStructurallyEquivalent(From, To);