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/ASTStructuralEquivalence.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclVisitor.h"
21 #include "clang/AST/StmtVisitor.h"
22 #include "clang/AST/TypeVisitor.h"
23 #include "clang/Basic/FileManager.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "llvm/Support/MemoryBuffer.h"
29 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
30 public DeclVisitor<ASTNodeImporter, Decl *>,
31 public StmtVisitor<ASTNodeImporter, Stmt *> {
32 ASTImporter &Importer;
35 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { }
37 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
38 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
39 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
42 QualType VisitType(const Type *T);
43 QualType VisitAtomicType(const AtomicType *T);
44 QualType VisitBuiltinType(const BuiltinType *T);
45 QualType VisitDecayedType(const DecayedType *T);
46 QualType VisitComplexType(const ComplexType *T);
47 QualType VisitPointerType(const PointerType *T);
48 QualType VisitBlockPointerType(const BlockPointerType *T);
49 QualType VisitLValueReferenceType(const LValueReferenceType *T);
50 QualType VisitRValueReferenceType(const RValueReferenceType *T);
51 QualType VisitMemberPointerType(const MemberPointerType *T);
52 QualType VisitConstantArrayType(const ConstantArrayType *T);
53 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
54 QualType VisitVariableArrayType(const VariableArrayType *T);
55 // FIXME: DependentSizedArrayType
56 // FIXME: DependentSizedExtVectorType
57 QualType VisitVectorType(const VectorType *T);
58 QualType VisitExtVectorType(const ExtVectorType *T);
59 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
60 QualType VisitFunctionProtoType(const FunctionProtoType *T);
61 QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
62 QualType VisitParenType(const ParenType *T);
63 QualType VisitTypedefType(const TypedefType *T);
64 QualType VisitTypeOfExprType(const TypeOfExprType *T);
65 // FIXME: DependentTypeOfExprType
66 QualType VisitTypeOfType(const TypeOfType *T);
67 QualType VisitDecltypeType(const DecltypeType *T);
68 QualType VisitUnaryTransformType(const UnaryTransformType *T);
69 QualType VisitAutoType(const AutoType *T);
70 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
71 // FIXME: DependentDecltypeType
72 QualType VisitRecordType(const RecordType *T);
73 QualType VisitEnumType(const EnumType *T);
74 QualType VisitAttributedType(const AttributedType *T);
75 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
76 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
77 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
78 QualType VisitElaboratedType(const ElaboratedType *T);
79 // FIXME: DependentNameType
80 QualType VisitPackExpansionType(const PackExpansionType *T);
81 // FIXME: DependentTemplateSpecializationType
82 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
83 QualType VisitObjCObjectType(const ObjCObjectType *T);
84 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
86 // Importing declarations
87 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
88 DeclContext *&LexicalDC, DeclarationName &Name,
89 NamedDecl *&ToD, SourceLocation &Loc);
90 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
91 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
92 DeclarationNameInfo& To);
93 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
95 bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
97 typedef DesignatedInitExpr::Designator Designator;
98 Designator ImportDesignator(const Designator &D);
101 /// \brief What we should import from the definition.
102 enum ImportDefinitionKind {
103 /// \brief Import the default subset of the definition, which might be
104 /// nothing (if minimal import is set) or might be everything (if minimal
105 /// import is not set).
107 /// \brief Import everything.
109 /// \brief Import only the bare bones needed to establish a valid
114 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
115 return IDK == IDK_Everything ||
116 (IDK == IDK_Default && !Importer.isMinimalImport());
119 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
120 ImportDefinitionKind Kind = IDK_Default);
121 bool ImportDefinition(VarDecl *From, VarDecl *To,
122 ImportDefinitionKind Kind = IDK_Default);
123 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
124 ImportDefinitionKind Kind = IDK_Default);
125 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
126 ImportDefinitionKind Kind = IDK_Default);
127 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
128 ImportDefinitionKind Kind = IDK_Default);
129 TemplateParameterList *ImportTemplateParameterList(
130 TemplateParameterList *Params);
131 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
132 Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc(
133 const TemplateArgumentLoc &TALoc);
134 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
135 unsigned NumFromArgs,
136 SmallVectorImpl<TemplateArgument> &ToArgs);
137 template <typename InContainerTy>
138 bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
139 TemplateArgumentListInfo &ToTAInfo);
140 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
141 bool Complain = true);
142 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
143 bool Complain = true);
144 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
145 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
146 bool IsStructuralMatch(FunctionTemplateDecl *From,
147 FunctionTemplateDecl *To);
148 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
149 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
150 Decl *VisitDecl(Decl *D);
151 Decl *VisitEmptyDecl(EmptyDecl *D);
152 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
153 Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
154 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
155 Decl *VisitNamespaceDecl(NamespaceDecl *D);
156 Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
157 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
158 Decl *VisitTypedefDecl(TypedefDecl *D);
159 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
160 Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
161 Decl *VisitLabelDecl(LabelDecl *D);
162 Decl *VisitEnumDecl(EnumDecl *D);
163 Decl *VisitRecordDecl(RecordDecl *D);
164 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
165 Decl *VisitFunctionDecl(FunctionDecl *D);
166 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
167 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
168 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
169 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
170 Decl *VisitFieldDecl(FieldDecl *D);
171 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
172 Decl *VisitFriendDecl(FriendDecl *D);
173 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
174 Decl *VisitVarDecl(VarDecl *D);
175 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
176 Decl *VisitParmVarDecl(ParmVarDecl *D);
177 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
178 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
179 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
180 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
181 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
182 Decl *VisitUsingDecl(UsingDecl *D);
183 Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
184 Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
185 Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
186 Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
189 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
190 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
191 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
192 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
193 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
194 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
195 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
196 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
197 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
198 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
199 Decl *VisitClassTemplateSpecializationDecl(
200 ClassTemplateSpecializationDecl *D);
201 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
202 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
203 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
205 // Importing statements
206 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
208 Stmt *VisitStmt(Stmt *S);
209 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
210 Stmt *VisitDeclStmt(DeclStmt *S);
211 Stmt *VisitNullStmt(NullStmt *S);
212 Stmt *VisitCompoundStmt(CompoundStmt *S);
213 Stmt *VisitCaseStmt(CaseStmt *S);
214 Stmt *VisitDefaultStmt(DefaultStmt *S);
215 Stmt *VisitLabelStmt(LabelStmt *S);
216 Stmt *VisitAttributedStmt(AttributedStmt *S);
217 Stmt *VisitIfStmt(IfStmt *S);
218 Stmt *VisitSwitchStmt(SwitchStmt *S);
219 Stmt *VisitWhileStmt(WhileStmt *S);
220 Stmt *VisitDoStmt(DoStmt *S);
221 Stmt *VisitForStmt(ForStmt *S);
222 Stmt *VisitGotoStmt(GotoStmt *S);
223 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
224 Stmt *VisitContinueStmt(ContinueStmt *S);
225 Stmt *VisitBreakStmt(BreakStmt *S);
226 Stmt *VisitReturnStmt(ReturnStmt *S);
228 // FIXME: SEHExceptStmt
229 // FIXME: SEHFinallyStmt
231 // FIXME: SEHLeaveStmt
232 // FIXME: CapturedStmt
233 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
234 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
235 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
236 // FIXME: MSDependentExistsStmt
237 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
238 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
239 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
240 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
241 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
242 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
243 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
245 // Importing expressions
246 Expr *VisitExpr(Expr *E);
247 Expr *VisitVAArgExpr(VAArgExpr *E);
248 Expr *VisitGNUNullExpr(GNUNullExpr *E);
249 Expr *VisitPredefinedExpr(PredefinedExpr *E);
250 Expr *VisitDeclRefExpr(DeclRefExpr *E);
251 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
252 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
253 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
254 Expr *VisitIntegerLiteral(IntegerLiteral *E);
255 Expr *VisitFloatingLiteral(FloatingLiteral *E);
256 Expr *VisitCharacterLiteral(CharacterLiteral *E);
257 Expr *VisitStringLiteral(StringLiteral *E);
258 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
259 Expr *VisitAtomicExpr(AtomicExpr *E);
260 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
261 Expr *VisitParenExpr(ParenExpr *E);
262 Expr *VisitParenListExpr(ParenListExpr *E);
263 Expr *VisitStmtExpr(StmtExpr *E);
264 Expr *VisitUnaryOperator(UnaryOperator *E);
265 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
266 Expr *VisitBinaryOperator(BinaryOperator *E);
267 Expr *VisitConditionalOperator(ConditionalOperator *E);
268 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
269 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
270 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
271 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
272 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
273 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
274 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
275 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
276 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
277 Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
278 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
279 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
280 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
281 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
282 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
283 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
284 Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
285 Expr *VisitCXXNewExpr(CXXNewExpr *CE);
286 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
287 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
288 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
289 Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
290 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
291 Expr *VisitCXXThisExpr(CXXThisExpr *E);
292 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
293 Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
294 Expr *VisitMemberExpr(MemberExpr *E);
295 Expr *VisitCallExpr(CallExpr *E);
296 Expr *VisitInitListExpr(InitListExpr *E);
297 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
298 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
299 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
300 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
301 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
302 Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
305 template<typename IIter, typename OIter>
306 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
307 typedef typename std::remove_reference<decltype(*Obegin)>::type ItemT;
308 ASTImporter &ImporterRef = Importer;
309 std::transform(Ibegin, Iend, Obegin,
310 [&ImporterRef](ItemT From) -> ItemT {
311 return ImporterRef.Import(From);
315 template<typename IIter, typename OIter>
316 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
317 typedef typename std::remove_reference<decltype(**Obegin)>::type ItemT;
318 ASTImporter &ImporterRef = Importer;
320 std::transform(Ibegin, Iend, Obegin,
321 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
322 ItemT *To = cast_or_null<ItemT>(
323 ImporterRef.Import(From));
331 template<typename InContainerTy, typename OutContainerTy>
332 bool ImportContainerChecked(const InContainerTy &InContainer,
333 OutContainerTy &OutContainer) {
334 return ImportArrayChecked(InContainer.begin(), InContainer.end(),
335 OutContainer.begin());
338 template<typename InContainerTy, typename OIter>
339 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
340 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
343 // Importing overrides.
344 void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
348 //----------------------------------------------------------------------------
350 //----------------------------------------------------------------------------
352 using namespace clang;
354 QualType ASTNodeImporter::VisitType(const Type *T) {
355 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
356 << T->getTypeClassName();
360 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
361 QualType UnderlyingType = Importer.Import(T->getValueType());
362 if(UnderlyingType.isNull())
365 return Importer.getToContext().getAtomicType(UnderlyingType);
368 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
369 switch (T->getKind()) {
370 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
371 case BuiltinType::Id: \
372 return Importer.getToContext().SingletonId;
373 #include "clang/Basic/OpenCLImageTypes.def"
374 #define SHARED_SINGLETON_TYPE(Expansion)
375 #define BUILTIN_TYPE(Id, SingletonId) \
376 case BuiltinType::Id: return Importer.getToContext().SingletonId;
377 #include "clang/AST/BuiltinTypes.def"
379 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
380 // context supports C++.
382 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
383 // context supports ObjC.
385 case BuiltinType::Char_U:
386 // The context we're importing from has an unsigned 'char'. If we're
387 // importing into a context with a signed 'char', translate to
388 // 'unsigned char' instead.
389 if (Importer.getToContext().getLangOpts().CharIsSigned)
390 return Importer.getToContext().UnsignedCharTy;
392 return Importer.getToContext().CharTy;
394 case BuiltinType::Char_S:
395 // The context we're importing from has an unsigned 'char'. If we're
396 // importing into a context with a signed 'char', translate to
397 // 'unsigned char' instead.
398 if (!Importer.getToContext().getLangOpts().CharIsSigned)
399 return Importer.getToContext().SignedCharTy;
401 return Importer.getToContext().CharTy;
403 case BuiltinType::WChar_S:
404 case BuiltinType::WChar_U:
405 // FIXME: If not in C++, shall we translate to the C equivalent of
407 return Importer.getToContext().WCharTy;
410 llvm_unreachable("Invalid BuiltinType Kind!");
413 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
414 QualType OrigT = Importer.Import(T->getOriginalType());
418 return Importer.getToContext().getDecayedType(OrigT);
421 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
422 QualType ToElementType = Importer.Import(T->getElementType());
423 if (ToElementType.isNull())
426 return Importer.getToContext().getComplexType(ToElementType);
429 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
430 QualType ToPointeeType = Importer.Import(T->getPointeeType());
431 if (ToPointeeType.isNull())
434 return Importer.getToContext().getPointerType(ToPointeeType);
437 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
438 // FIXME: Check for blocks support in "to" context.
439 QualType ToPointeeType = Importer.Import(T->getPointeeType());
440 if (ToPointeeType.isNull())
443 return Importer.getToContext().getBlockPointerType(ToPointeeType);
447 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
448 // FIXME: Check for C++ support in "to" context.
449 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
450 if (ToPointeeType.isNull())
453 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
457 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
458 // FIXME: Check for C++0x support in "to" context.
459 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
460 if (ToPointeeType.isNull())
463 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
466 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
467 // FIXME: Check for C++ support in "to" context.
468 QualType ToPointeeType = Importer.Import(T->getPointeeType());
469 if (ToPointeeType.isNull())
472 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
473 return Importer.getToContext().getMemberPointerType(ToPointeeType,
474 ClassType.getTypePtr());
477 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
478 QualType ToElementType = Importer.Import(T->getElementType());
479 if (ToElementType.isNull())
482 return Importer.getToContext().getConstantArrayType(ToElementType,
484 T->getSizeModifier(),
485 T->getIndexTypeCVRQualifiers());
489 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
490 QualType ToElementType = Importer.Import(T->getElementType());
491 if (ToElementType.isNull())
494 return Importer.getToContext().getIncompleteArrayType(ToElementType,
495 T->getSizeModifier(),
496 T->getIndexTypeCVRQualifiers());
499 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
500 QualType ToElementType = Importer.Import(T->getElementType());
501 if (ToElementType.isNull())
504 Expr *Size = Importer.Import(T->getSizeExpr());
508 SourceRange Brackets = Importer.Import(T->getBracketsRange());
509 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
510 T->getSizeModifier(),
511 T->getIndexTypeCVRQualifiers(),
515 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
516 QualType ToElementType = Importer.Import(T->getElementType());
517 if (ToElementType.isNull())
520 return Importer.getToContext().getVectorType(ToElementType,
525 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
526 QualType ToElementType = Importer.Import(T->getElementType());
527 if (ToElementType.isNull())
530 return Importer.getToContext().getExtVectorType(ToElementType,
531 T->getNumElements());
535 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
536 // FIXME: What happens if we're importing a function without a prototype
537 // into C++? Should we make it variadic?
538 QualType ToResultType = Importer.Import(T->getReturnType());
539 if (ToResultType.isNull())
542 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
546 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
547 QualType ToResultType = Importer.Import(T->getReturnType());
548 if (ToResultType.isNull())
551 // Import argument types
552 SmallVector<QualType, 4> ArgTypes;
553 for (const auto &A : T->param_types()) {
554 QualType ArgType = Importer.Import(A);
555 if (ArgType.isNull())
557 ArgTypes.push_back(ArgType);
560 // Import exception types
561 SmallVector<QualType, 4> ExceptionTypes;
562 for (const auto &E : T->exceptions()) {
563 QualType ExceptionType = Importer.Import(E);
564 if (ExceptionType.isNull())
566 ExceptionTypes.push_back(ExceptionType);
569 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
570 FunctionProtoType::ExtProtoInfo ToEPI;
572 ToEPI.ExtInfo = FromEPI.ExtInfo;
573 ToEPI.Variadic = FromEPI.Variadic;
574 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
575 ToEPI.TypeQuals = FromEPI.TypeQuals;
576 ToEPI.RefQualifier = FromEPI.RefQualifier;
577 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
578 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
579 ToEPI.ExceptionSpec.NoexceptExpr =
580 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
581 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
582 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
583 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
584 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
586 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
589 QualType ASTNodeImporter::VisitUnresolvedUsingType(
590 const UnresolvedUsingType *T) {
591 UnresolvedUsingTypenameDecl *ToD = cast_or_null<UnresolvedUsingTypenameDecl>(
592 Importer.Import(T->getDecl()));
596 UnresolvedUsingTypenameDecl *ToPrevD =
597 cast_or_null<UnresolvedUsingTypenameDecl>(
598 Importer.Import(T->getDecl()->getPreviousDecl()));
599 if (!ToPrevD && T->getDecl()->getPreviousDecl())
602 return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
605 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
606 QualType ToInnerType = Importer.Import(T->getInnerType());
607 if (ToInnerType.isNull())
610 return Importer.getToContext().getParenType(ToInnerType);
613 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
614 TypedefNameDecl *ToDecl
615 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
619 return Importer.getToContext().getTypeDeclType(ToDecl);
622 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
623 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
627 return Importer.getToContext().getTypeOfExprType(ToExpr);
630 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
631 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
632 if (ToUnderlyingType.isNull())
635 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
638 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
639 // FIXME: Make sure that the "to" context supports C++0x!
640 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
644 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
645 if (UnderlyingType.isNull())
648 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
651 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
652 QualType ToBaseType = Importer.Import(T->getBaseType());
653 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
654 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
657 return Importer.getToContext().getUnaryTransformType(ToBaseType,
662 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
663 // FIXME: Make sure that the "to" context supports C++11!
664 QualType FromDeduced = T->getDeducedType();
666 if (!FromDeduced.isNull()) {
667 ToDeduced = Importer.Import(FromDeduced);
668 if (ToDeduced.isNull())
672 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
673 /*IsDependent*/false);
676 QualType ASTNodeImporter::VisitInjectedClassNameType(
677 const InjectedClassNameType *T) {
678 CXXRecordDecl *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
682 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
683 if (InjType.isNull())
686 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
687 // See comments in InjectedClassNameType definition for details
688 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
690 TypeAlignmentInBits = 4,
691 TypeAlignment = 1 << TypeAlignmentInBits
694 return QualType(new (Importer.getToContext(), TypeAlignment)
695 InjectedClassNameType(D, InjType), 0);
698 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
700 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
704 return Importer.getToContext().getTagDeclType(ToDecl);
707 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
709 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
713 return Importer.getToContext().getTagDeclType(ToDecl);
716 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
717 QualType FromModifiedType = T->getModifiedType();
718 QualType FromEquivalentType = T->getEquivalentType();
719 QualType ToModifiedType;
720 QualType ToEquivalentType;
722 if (!FromModifiedType.isNull()) {
723 ToModifiedType = Importer.Import(FromModifiedType);
724 if (ToModifiedType.isNull())
727 if (!FromEquivalentType.isNull()) {
728 ToEquivalentType = Importer.Import(FromEquivalentType);
729 if (ToEquivalentType.isNull())
733 return Importer.getToContext().getAttributedType(T->getAttrKind(),
734 ToModifiedType, ToEquivalentType);
738 QualType ASTNodeImporter::VisitTemplateTypeParmType(
739 const TemplateTypeParmType *T) {
740 TemplateTypeParmDecl *ParmDecl =
741 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
742 if (!ParmDecl && T->getDecl())
745 return Importer.getToContext().getTemplateTypeParmType(
746 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
749 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
750 const SubstTemplateTypeParmType *T) {
751 const TemplateTypeParmType *Replaced =
752 cast_or_null<TemplateTypeParmType>(Importer.Import(
753 QualType(T->getReplacedParameter(), 0)).getTypePtr());
757 QualType Replacement = Importer.Import(T->getReplacementType());
758 if (Replacement.isNull())
760 Replacement = Replacement.getCanonicalType();
762 return Importer.getToContext().getSubstTemplateTypeParmType(
763 Replaced, Replacement);
766 QualType ASTNodeImporter::VisitTemplateSpecializationType(
767 const TemplateSpecializationType *T) {
768 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
769 if (ToTemplate.isNull())
772 SmallVector<TemplateArgument, 2> ToTemplateArgs;
773 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
776 QualType ToCanonType;
777 if (!QualType(T, 0).isCanonical()) {
778 QualType FromCanonType
779 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
780 ToCanonType =Importer.Import(FromCanonType);
781 if (ToCanonType.isNull())
784 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
789 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
790 NestedNameSpecifier *ToQualifier = nullptr;
791 // Note: the qualifier in an ElaboratedType is optional.
792 if (T->getQualifier()) {
793 ToQualifier = Importer.Import(T->getQualifier());
798 QualType ToNamedType = Importer.Import(T->getNamedType());
799 if (ToNamedType.isNull())
802 return Importer.getToContext().getElaboratedType(T->getKeyword(),
803 ToQualifier, ToNamedType);
806 QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
807 QualType Pattern = Importer.Import(T->getPattern());
808 if (Pattern.isNull())
811 return Importer.getToContext().getPackExpansionType(Pattern,
812 T->getNumExpansions());
815 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
816 ObjCInterfaceDecl *Class
817 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
821 return Importer.getToContext().getObjCInterfaceType(Class);
824 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
825 QualType ToBaseType = Importer.Import(T->getBaseType());
826 if (ToBaseType.isNull())
829 SmallVector<QualType, 4> TypeArgs;
830 for (auto TypeArg : T->getTypeArgsAsWritten()) {
831 QualType ImportedTypeArg = Importer.Import(TypeArg);
832 if (ImportedTypeArg.isNull())
835 TypeArgs.push_back(ImportedTypeArg);
838 SmallVector<ObjCProtocolDecl *, 4> Protocols;
839 for (auto *P : T->quals()) {
840 ObjCProtocolDecl *Protocol
841 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
844 Protocols.push_back(Protocol);
847 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
849 T->isKindOfTypeAsWritten());
853 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
854 QualType ToPointeeType = Importer.Import(T->getPointeeType());
855 if (ToPointeeType.isNull())
858 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
861 //----------------------------------------------------------------------------
862 // Import Declarations
863 //----------------------------------------------------------------------------
864 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
865 DeclContext *&LexicalDC,
866 DeclarationName &Name,
868 SourceLocation &Loc) {
869 // Import the context of this declaration.
870 DC = Importer.ImportContext(D->getDeclContext());
875 if (D->getDeclContext() != D->getLexicalDeclContext()) {
876 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
881 // Import the name of this declaration.
882 Name = Importer.Import(D->getDeclName());
883 if (D->getDeclName() && !Name)
886 // Import the location of this declaration.
887 Loc = Importer.Import(D->getLocation());
888 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
892 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
897 ToD = Importer.Import(FromD);
902 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
903 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) {
904 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
905 ImportDefinition(FromRecord, ToRecord);
911 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
912 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) {
913 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
914 ImportDefinition(FromEnum, ToEnum);
922 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
923 DeclarationNameInfo& To) {
924 // NOTE: To.Name and To.Loc are already imported.
925 // We only have to import To.LocInfo.
926 switch (To.getName().getNameKind()) {
927 case DeclarationName::Identifier:
928 case DeclarationName::ObjCZeroArgSelector:
929 case DeclarationName::ObjCOneArgSelector:
930 case DeclarationName::ObjCMultiArgSelector:
931 case DeclarationName::CXXUsingDirective:
932 case DeclarationName::CXXDeductionGuideName:
935 case DeclarationName::CXXOperatorName: {
936 SourceRange Range = From.getCXXOperatorNameRange();
937 To.setCXXOperatorNameRange(Importer.Import(Range));
940 case DeclarationName::CXXLiteralOperatorName: {
941 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
942 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
945 case DeclarationName::CXXConstructorName:
946 case DeclarationName::CXXDestructorName:
947 case DeclarationName::CXXConversionFunctionName: {
948 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
949 To.setNamedTypeInfo(Importer.Import(FromTInfo));
953 llvm_unreachable("Unknown name kind.");
956 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
957 if (Importer.isMinimalImport() && !ForceImport) {
958 Importer.ImportContext(FromDC);
962 for (auto *From : FromDC->decls())
963 Importer.Import(From);
966 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
967 ImportDefinitionKind Kind) {
968 if (To->getDefinition() || To->isBeingDefined()) {
969 if (Kind == IDK_Everything)
970 ImportDeclContext(From, /*ForceImport=*/true);
975 To->startDefinition();
978 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
979 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From);
981 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
982 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
983 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
984 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
985 ToData.Aggregate = FromData.Aggregate;
986 ToData.PlainOldData = FromData.PlainOldData;
987 ToData.Empty = FromData.Empty;
988 ToData.Polymorphic = FromData.Polymorphic;
989 ToData.Abstract = FromData.Abstract;
990 ToData.IsStandardLayout = FromData.IsStandardLayout;
991 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases;
992 ToData.HasPrivateFields = FromData.HasPrivateFields;
993 ToData.HasProtectedFields = FromData.HasProtectedFields;
994 ToData.HasPublicFields = FromData.HasPublicFields;
995 ToData.HasMutableFields = FromData.HasMutableFields;
996 ToData.HasVariantMembers = FromData.HasVariantMembers;
997 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
998 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
999 ToData.HasUninitializedReferenceMember
1000 = FromData.HasUninitializedReferenceMember;
1001 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
1002 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
1003 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
1004 ToData.NeedOverloadResolutionForCopyConstructor
1005 = FromData.NeedOverloadResolutionForCopyConstructor;
1006 ToData.NeedOverloadResolutionForMoveConstructor
1007 = FromData.NeedOverloadResolutionForMoveConstructor;
1008 ToData.NeedOverloadResolutionForMoveAssignment
1009 = FromData.NeedOverloadResolutionForMoveAssignment;
1010 ToData.NeedOverloadResolutionForDestructor
1011 = FromData.NeedOverloadResolutionForDestructor;
1012 ToData.DefaultedCopyConstructorIsDeleted
1013 = FromData.DefaultedCopyConstructorIsDeleted;
1014 ToData.DefaultedMoveConstructorIsDeleted
1015 = FromData.DefaultedMoveConstructorIsDeleted;
1016 ToData.DefaultedMoveAssignmentIsDeleted
1017 = FromData.DefaultedMoveAssignmentIsDeleted;
1018 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1019 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1020 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1021 ToData.HasConstexprNonCopyMoveConstructor
1022 = FromData.HasConstexprNonCopyMoveConstructor;
1023 ToData.HasDefaultedDefaultConstructor
1024 = FromData.HasDefaultedDefaultConstructor;
1025 ToData.CanPassInRegisters = FromData.CanPassInRegisters;
1026 ToData.DefaultedDefaultConstructorIsConstexpr
1027 = FromData.DefaultedDefaultConstructorIsConstexpr;
1028 ToData.HasConstexprDefaultConstructor
1029 = FromData.HasConstexprDefaultConstructor;
1030 ToData.HasNonLiteralTypeFieldsOrBases
1031 = FromData.HasNonLiteralTypeFieldsOrBases;
1032 // ComputedVisibleConversions not imported.
1033 ToData.UserProvidedDefaultConstructor
1034 = FromData.UserProvidedDefaultConstructor;
1035 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1036 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
1037 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
1038 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
1039 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
1040 ToData.ImplicitCopyAssignmentHasConstParam
1041 = FromData.ImplicitCopyAssignmentHasConstParam;
1042 ToData.HasDeclaredCopyConstructorWithConstParam
1043 = FromData.HasDeclaredCopyConstructorWithConstParam;
1044 ToData.HasDeclaredCopyAssignmentWithConstParam
1045 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1046 ToData.IsLambda = FromData.IsLambda;
1048 SmallVector<CXXBaseSpecifier *, 4> Bases;
1049 for (const auto &Base1 : FromCXX->bases()) {
1050 QualType T = Importer.Import(Base1.getType());
1054 SourceLocation EllipsisLoc;
1055 if (Base1.isPackExpansion())
1056 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
1058 // Ensure that we have a definition for the base.
1059 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
1062 new (Importer.getToContext())
1063 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1065 Base1.isBaseOfClass(),
1066 Base1.getAccessSpecifierAsWritten(),
1067 Importer.Import(Base1.getTypeSourceInfo()),
1071 ToCXX->setBases(Bases.data(), Bases.size());
1074 if (shouldForceImportDeclContext(Kind))
1075 ImportDeclContext(From, /*ForceImport=*/true);
1077 To->completeDefinition();
1081 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
1082 ImportDefinitionKind Kind) {
1083 if (To->getAnyInitializer())
1086 // FIXME: Can we really import any initializer? Alternatively, we could force
1087 // ourselves to import every declaration of a variable and then only use
1089 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
1091 // FIXME: Other bits to merge?
1096 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
1097 ImportDefinitionKind Kind) {
1098 if (To->getDefinition() || To->isBeingDefined()) {
1099 if (Kind == IDK_Everything)
1100 ImportDeclContext(From, /*ForceImport=*/true);
1104 To->startDefinition();
1106 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1110 QualType ToPromotionType = Importer.Import(From->getPromotionType());
1111 if (ToPromotionType.isNull())
1114 if (shouldForceImportDeclContext(Kind))
1115 ImportDeclContext(From, /*ForceImport=*/true);
1117 // FIXME: we might need to merge the number of positive or negative bits
1118 // if the enumerator lists don't match.
1119 To->completeDefinition(T, ToPromotionType,
1120 From->getNumPositiveBits(),
1121 From->getNumNegativeBits());
1125 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
1126 TemplateParameterList *Params) {
1127 SmallVector<NamedDecl *, 4> ToParams(Params->size());
1128 if (ImportContainerChecked(*Params, ToParams))
1131 Expr *ToRequiresClause;
1132 if (Expr *const R = Params->getRequiresClause()) {
1133 ToRequiresClause = Importer.Import(R);
1134 if (!ToRequiresClause)
1137 ToRequiresClause = nullptr;
1140 return TemplateParameterList::Create(Importer.getToContext(),
1141 Importer.Import(Params->getTemplateLoc()),
1142 Importer.Import(Params->getLAngleLoc()),
1144 Importer.Import(Params->getRAngleLoc()),
1149 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
1150 switch (From.getKind()) {
1151 case TemplateArgument::Null:
1152 return TemplateArgument();
1154 case TemplateArgument::Type: {
1155 QualType ToType = Importer.Import(From.getAsType());
1156 if (ToType.isNull())
1157 return TemplateArgument();
1158 return TemplateArgument(ToType);
1161 case TemplateArgument::Integral: {
1162 QualType ToType = Importer.Import(From.getIntegralType());
1163 if (ToType.isNull())
1164 return TemplateArgument();
1165 return TemplateArgument(From, ToType);
1168 case TemplateArgument::Declaration: {
1169 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
1170 QualType ToType = Importer.Import(From.getParamTypeForDecl());
1171 if (!To || ToType.isNull())
1172 return TemplateArgument();
1173 return TemplateArgument(To, ToType);
1176 case TemplateArgument::NullPtr: {
1177 QualType ToType = Importer.Import(From.getNullPtrType());
1178 if (ToType.isNull())
1179 return TemplateArgument();
1180 return TemplateArgument(ToType, /*isNullPtr*/true);
1183 case TemplateArgument::Template: {
1184 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1185 if (ToTemplate.isNull())
1186 return TemplateArgument();
1188 return TemplateArgument(ToTemplate);
1191 case TemplateArgument::TemplateExpansion: {
1192 TemplateName ToTemplate
1193 = Importer.Import(From.getAsTemplateOrTemplatePattern());
1194 if (ToTemplate.isNull())
1195 return TemplateArgument();
1197 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
1200 case TemplateArgument::Expression:
1201 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1202 return TemplateArgument(ToExpr);
1203 return TemplateArgument();
1205 case TemplateArgument::Pack: {
1206 SmallVector<TemplateArgument, 2> ToPack;
1207 ToPack.reserve(From.pack_size());
1208 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
1209 return TemplateArgument();
1211 return TemplateArgument(
1212 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
1216 llvm_unreachable("Invalid template argument kind");
1219 Optional<TemplateArgumentLoc>
1220 ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) {
1221 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
1222 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
1223 TemplateArgumentLocInfo ToInfo;
1224 if (Arg.getKind() == TemplateArgument::Expression) {
1225 Expr *E = Importer.Import(FromInfo.getAsExpr());
1226 ToInfo = TemplateArgumentLocInfo(E);
1229 } else if (Arg.getKind() == TemplateArgument::Type) {
1230 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
1231 ToInfo = TemplateArgumentLocInfo(TSI);
1235 ToInfo = TemplateArgumentLocInfo(
1236 Importer.Import(FromInfo.getTemplateQualifierLoc()),
1237 Importer.Import(FromInfo.getTemplateNameLoc()),
1238 Importer.Import(FromInfo.getTemplateEllipsisLoc()));
1240 return TemplateArgumentLoc(Arg, ToInfo);
1243 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
1244 unsigned NumFromArgs,
1245 SmallVectorImpl<TemplateArgument> &ToArgs) {
1246 for (unsigned I = 0; I != NumFromArgs; ++I) {
1247 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
1248 if (To.isNull() && !FromArgs[I].isNull())
1251 ToArgs.push_back(To);
1257 template <typename InContainerTy>
1258 bool ASTNodeImporter::ImportTemplateArgumentListInfo(
1259 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
1260 for (const auto &FromLoc : Container) {
1261 if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
1262 ToTAInfo.addArgument(*ToLoc);
1269 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
1270 RecordDecl *ToRecord, bool Complain) {
1271 // Eliminate a potential failure point where we attempt to re-import
1272 // something we're trying to import while completing ToRecord.
1273 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
1275 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
1277 ToRecord = ToOriginRecord;
1280 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1281 ToRecord->getASTContext(),
1282 Importer.getNonEquivalentDecls(),
1284 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord);
1287 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
1289 StructuralEquivalenceContext Ctx(
1290 Importer.getFromContext(), Importer.getToContext(),
1291 Importer.getNonEquivalentDecls(), false, Complain);
1292 return Ctx.IsStructurallyEquivalent(FromVar, ToVar);
1295 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
1296 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1297 Importer.getToContext(),
1298 Importer.getNonEquivalentDecls());
1299 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum);
1302 bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
1303 FunctionTemplateDecl *To) {
1304 StructuralEquivalenceContext Ctx(
1305 Importer.getFromContext(), Importer.getToContext(),
1306 Importer.getNonEquivalentDecls(), false, false);
1307 return Ctx.IsStructurallyEquivalent(From, To);
1310 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
1311 EnumConstantDecl *ToEC)
1313 const llvm::APSInt &FromVal = FromEC->getInitVal();
1314 const llvm::APSInt &ToVal = ToEC->getInitVal();
1316 return FromVal.isSigned() == ToVal.isSigned() &&
1317 FromVal.getBitWidth() == ToVal.getBitWidth() &&
1321 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
1322 ClassTemplateDecl *To) {
1323 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1324 Importer.getToContext(),
1325 Importer.getNonEquivalentDecls());
1326 return Ctx.IsStructurallyEquivalent(From, To);
1329 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
1330 VarTemplateDecl *To) {
1331 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1332 Importer.getToContext(),
1333 Importer.getNonEquivalentDecls());
1334 return Ctx.IsStructurallyEquivalent(From, To);
1337 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
1338 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1339 << D->getDeclKindName();
1343 Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
1344 // Import the context of this declaration.
1345 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1349 DeclContext *LexicalDC = DC;
1350 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1351 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1356 // Import the location of this declaration.
1357 SourceLocation Loc = Importer.Import(D->getLocation());
1359 EmptyDecl *ToD = EmptyDecl::Create(Importer.getToContext(), DC, Loc);
1360 ToD->setLexicalDeclContext(LexicalDC);
1361 Importer.Imported(D, ToD);
1362 LexicalDC->addDeclInternal(ToD);
1366 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
1367 TranslationUnitDecl *ToD =
1368 Importer.getToContext().getTranslationUnitDecl();
1370 Importer.Imported(D, ToD);
1375 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1377 SourceLocation Loc = Importer.Import(D->getLocation());
1378 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
1380 // Import the context of this declaration.
1381 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1385 AccessSpecDecl *accessSpecDecl
1386 = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(),
1389 if (!accessSpecDecl)
1392 // Lexical DeclContext and Semantic DeclContext
1393 // is always the same for the accessSpec.
1394 accessSpecDecl->setLexicalDeclContext(DC);
1395 DC->addDeclInternal(accessSpecDecl);
1397 return accessSpecDecl;
1400 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1401 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1405 DeclContext *LexicalDC = DC;
1407 // Import the location of this declaration.
1408 SourceLocation Loc = Importer.Import(D->getLocation());
1410 Expr *AssertExpr = Importer.Import(D->getAssertExpr());
1414 StringLiteral *FromMsg = D->getMessage();
1415 StringLiteral *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
1416 if (!ToMsg && FromMsg)
1419 StaticAssertDecl *ToD = StaticAssertDecl::Create(
1420 Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
1421 Importer.Import(D->getRParenLoc()), D->isFailed());
1423 ToD->setLexicalDeclContext(LexicalDC);
1424 LexicalDC->addDeclInternal(ToD);
1425 Importer.Imported(D, ToD);
1429 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
1430 // Import the major distinguishing characteristics of this namespace.
1431 DeclContext *DC, *LexicalDC;
1432 DeclarationName Name;
1435 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1440 NamespaceDecl *MergeWithNamespace = nullptr;
1442 // This is an anonymous namespace. Adopt an existing anonymous
1443 // namespace if we can.
1444 // FIXME: Not testable.
1445 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
1446 MergeWithNamespace = TU->getAnonymousNamespace();
1448 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
1450 SmallVector<NamedDecl *, 4> ConflictingDecls;
1451 SmallVector<NamedDecl *, 2> FoundDecls;
1452 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1453 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
1454 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace))
1457 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) {
1458 MergeWithNamespace = FoundNS;
1459 ConflictingDecls.clear();
1463 ConflictingDecls.push_back(FoundDecls[I]);
1466 if (!ConflictingDecls.empty()) {
1467 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
1468 ConflictingDecls.data(),
1469 ConflictingDecls.size());
1473 // Create the "to" namespace, if needed.
1474 NamespaceDecl *ToNamespace = MergeWithNamespace;
1476 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC,
1478 Importer.Import(D->getLocStart()),
1479 Loc, Name.getAsIdentifierInfo(),
1480 /*PrevDecl=*/nullptr);
1481 ToNamespace->setLexicalDeclContext(LexicalDC);
1482 LexicalDC->addDeclInternal(ToNamespace);
1484 // If this is an anonymous namespace, register it as the anonymous
1485 // namespace within its context.
1487 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC))
1488 TU->setAnonymousNamespace(ToNamespace);
1490 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
1493 Importer.Imported(D, ToNamespace);
1495 ImportDeclContext(D);
1500 Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1501 // Import the major distinguishing characteristics of this namespace.
1502 DeclContext *DC, *LexicalDC;
1503 DeclarationName Name;
1506 if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
1511 // NOTE: No conflict resolution is done for namespace aliases now.
1513 NamespaceDecl *TargetDecl = cast_or_null<NamespaceDecl>(
1514 Importer.Import(D->getNamespace()));
1518 IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
1522 NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
1523 if (D->getQualifierLoc() && !ToQLoc)
1526 NamespaceAliasDecl *ToD = NamespaceAliasDecl::Create(
1527 Importer.getToContext(), DC, Importer.Import(D->getNamespaceLoc()),
1528 Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
1529 Importer.Import(D->getTargetNameLoc()), TargetDecl);
1531 ToD->setLexicalDeclContext(LexicalDC);
1532 Importer.Imported(D, ToD);
1533 LexicalDC->addDeclInternal(ToD);
1538 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
1539 // Import the major distinguishing characteristics of this typedef.
1540 DeclContext *DC, *LexicalDC;
1541 DeclarationName Name;
1544 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1549 // If this typedef is not in block scope, determine whether we've
1550 // seen a typedef with the same name (that we can merge with) or any
1551 // other entity by that name (which name lookup could conflict with).
1552 if (!DC->isFunctionOrMethod()) {
1553 SmallVector<NamedDecl *, 4> ConflictingDecls;
1554 unsigned IDNS = Decl::IDNS_Ordinary;
1555 SmallVector<NamedDecl *, 2> FoundDecls;
1556 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1557 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
1558 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
1560 if (TypedefNameDecl *FoundTypedef =
1561 dyn_cast<TypedefNameDecl>(FoundDecls[I])) {
1562 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
1563 FoundTypedef->getUnderlyingType()))
1564 return Importer.Imported(D, FoundTypedef);
1567 ConflictingDecls.push_back(FoundDecls[I]);
1570 if (!ConflictingDecls.empty()) {
1571 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1572 ConflictingDecls.data(),
1573 ConflictingDecls.size());
1579 // Import the underlying type of this typedef;
1580 QualType T = Importer.Import(D->getUnderlyingType());
1584 // Create the new typedef node.
1585 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
1586 SourceLocation StartL = Importer.Import(D->getLocStart());
1587 TypedefNameDecl *ToTypedef;
1589 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC,
1591 Name.getAsIdentifierInfo(),
1594 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC,
1596 Name.getAsIdentifierInfo(),
1599 ToTypedef->setAccess(D->getAccess());
1600 ToTypedef->setLexicalDeclContext(LexicalDC);
1601 Importer.Imported(D, ToTypedef);
1602 LexicalDC->addDeclInternal(ToTypedef);
1607 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
1608 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1611 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
1612 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1615 Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1616 // Import the major distinguishing characteristics of this typedef.
1617 DeclContext *DC, *LexicalDC;
1618 DeclarationName Name;
1621 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1626 // If this typedef is not in block scope, determine whether we've
1627 // seen a typedef with the same name (that we can merge with) or any
1628 // other entity by that name (which name lookup could conflict with).
1629 if (!DC->isFunctionOrMethod()) {
1630 SmallVector<NamedDecl *, 4> ConflictingDecls;
1631 unsigned IDNS = Decl::IDNS_Ordinary;
1632 SmallVector<NamedDecl *, 2> FoundDecls;
1633 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1634 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
1635 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
1637 if (auto *FoundAlias =
1638 dyn_cast<TypeAliasTemplateDecl>(FoundDecls[I]))
1639 return Importer.Imported(D, FoundAlias);
1640 ConflictingDecls.push_back(FoundDecls[I]);
1643 if (!ConflictingDecls.empty()) {
1644 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1645 ConflictingDecls.data(),
1646 ConflictingDecls.size());
1652 TemplateParameterList *Params = ImportTemplateParameterList(
1653 D->getTemplateParameters());
1657 NamedDecl *TemplDecl = cast_or_null<NamedDecl>(
1658 Importer.Import(D->getTemplatedDecl()));
1662 TypeAliasTemplateDecl *ToAlias = TypeAliasTemplateDecl::Create(
1663 Importer.getToContext(), DC, Loc, Name, Params, TemplDecl);
1665 ToAlias->setAccess(D->getAccess());
1666 ToAlias->setLexicalDeclContext(LexicalDC);
1667 Importer.Imported(D, ToAlias);
1668 LexicalDC->addDeclInternal(ToAlias);
1672 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
1673 // Import the major distinguishing characteristics of this label.
1674 DeclContext *DC, *LexicalDC;
1675 DeclarationName Name;
1678 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1683 assert(LexicalDC->isFunctionOrMethod());
1685 LabelDecl *ToLabel = D->isGnuLocal()
1686 ? LabelDecl::Create(Importer.getToContext(),
1687 DC, Importer.Import(D->getLocation()),
1688 Name.getAsIdentifierInfo(),
1689 Importer.Import(D->getLocStart()))
1690 : LabelDecl::Create(Importer.getToContext(),
1691 DC, Importer.Import(D->getLocation()),
1692 Name.getAsIdentifierInfo());
1693 Importer.Imported(D, ToLabel);
1695 LabelStmt *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
1699 ToLabel->setStmt(Label);
1700 ToLabel->setLexicalDeclContext(LexicalDC);
1701 LexicalDC->addDeclInternal(ToLabel);
1705 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
1706 // Import the major distinguishing characteristics of this enum.
1707 DeclContext *DC, *LexicalDC;
1708 DeclarationName Name;
1711 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1716 // Figure out what enum name we're looking for.
1717 unsigned IDNS = Decl::IDNS_Tag;
1718 DeclarationName SearchName = Name;
1719 if (!SearchName && D->getTypedefNameForAnonDecl()) {
1720 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
1721 IDNS = Decl::IDNS_Ordinary;
1722 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
1723 IDNS |= Decl::IDNS_Ordinary;
1725 // We may already have an enum of the same name; try to find and match it.
1726 if (!DC->isFunctionOrMethod() && SearchName) {
1727 SmallVector<NamedDecl *, 4> ConflictingDecls;
1728 SmallVector<NamedDecl *, 2> FoundDecls;
1729 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
1730 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
1731 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
1734 Decl *Found = FoundDecls[I];
1735 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
1736 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
1737 Found = Tag->getDecl();
1740 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) {
1741 if (IsStructuralMatch(D, FoundEnum))
1742 return Importer.Imported(D, FoundEnum);
1745 ConflictingDecls.push_back(FoundDecls[I]);
1748 if (!ConflictingDecls.empty()) {
1749 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1750 ConflictingDecls.data(),
1751 ConflictingDecls.size());
1755 // Create the enum declaration.
1756 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC,
1757 Importer.Import(D->getLocStart()),
1758 Loc, Name.getAsIdentifierInfo(), nullptr,
1759 D->isScoped(), D->isScopedUsingClassTag(),
1761 // Import the qualifier, if any.
1762 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
1763 D2->setAccess(D->getAccess());
1764 D2->setLexicalDeclContext(LexicalDC);
1765 Importer.Imported(D, D2);
1766 LexicalDC->addDeclInternal(D2);
1768 // Import the integer type.
1769 QualType ToIntegerType = Importer.Import(D->getIntegerType());
1770 if (ToIntegerType.isNull())
1772 D2->setIntegerType(ToIntegerType);
1774 // Import the definition
1775 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
1781 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
1782 // If this record has a definition in the translation unit we're coming from,
1783 // but this particular declaration is not that definition, import the
1784 // definition and map to that.
1785 TagDecl *Definition = D->getDefinition();
1786 if (Definition && Definition != D) {
1787 Decl *ImportedDef = Importer.Import(Definition);
1791 return Importer.Imported(D, ImportedDef);
1794 // Import the major distinguishing characteristics of this record.
1795 DeclContext *DC, *LexicalDC;
1796 DeclarationName Name;
1799 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1804 // Figure out what structure name we're looking for.
1805 unsigned IDNS = Decl::IDNS_Tag;
1806 DeclarationName SearchName = Name;
1807 if (!SearchName && D->getTypedefNameForAnonDecl()) {
1808 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
1809 IDNS = Decl::IDNS_Ordinary;
1810 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
1811 IDNS |= Decl::IDNS_Ordinary;
1813 // We may already have a record of the same name; try to find and match it.
1814 RecordDecl *AdoptDecl = nullptr;
1815 RecordDecl *PrevDecl = nullptr;
1816 if (!DC->isFunctionOrMethod()) {
1817 SmallVector<NamedDecl *, 4> ConflictingDecls;
1818 SmallVector<NamedDecl *, 2> FoundDecls;
1819 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
1821 if (!FoundDecls.empty()) {
1822 // We're going to have to compare D against potentially conflicting Decls, so complete it.
1823 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
1824 D->getASTContext().getExternalSource()->CompleteType(D);
1827 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
1828 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
1831 Decl *Found = FoundDecls[I];
1832 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
1833 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
1834 Found = Tag->getDecl();
1837 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) {
1838 if (D->isAnonymousStructOrUnion() &&
1839 FoundRecord->isAnonymousStructOrUnion()) {
1840 // If both anonymous structs/unions are in a record context, make sure
1841 // they occur in the same location in the context records.
1842 if (Optional<unsigned> Index1 =
1843 StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(
1845 if (Optional<unsigned> Index2 = StructuralEquivalenceContext::
1846 findUntaggedStructOrUnionIndex(FoundRecord)) {
1847 if (*Index1 != *Index2)
1853 PrevDecl = FoundRecord;
1855 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
1856 if ((SearchName && !D->isCompleteDefinition())
1857 || (D->isCompleteDefinition() &&
1858 D->isAnonymousStructOrUnion()
1859 == FoundDef->isAnonymousStructOrUnion() &&
1860 IsStructuralMatch(D, FoundDef))) {
1861 // The record types structurally match, or the "from" translation
1862 // unit only had a forward declaration anyway; call it the same
1864 // FIXME: For C++, we should also merge methods here.
1865 return Importer.Imported(D, FoundDef);
1867 } else if (!D->isCompleteDefinition()) {
1868 // We have a forward declaration of this type, so adopt that forward
1869 // declaration rather than building a new one.
1871 // If one or both can be completed from external storage then try one
1872 // last time to complete and compare them before doing this.
1874 if (FoundRecord->hasExternalLexicalStorage() &&
1875 !FoundRecord->isCompleteDefinition())
1876 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
1877 if (D->hasExternalLexicalStorage())
1878 D->getASTContext().getExternalSource()->CompleteType(D);
1880 if (FoundRecord->isCompleteDefinition() &&
1881 D->isCompleteDefinition() &&
1882 !IsStructuralMatch(D, FoundRecord))
1885 AdoptDecl = FoundRecord;
1887 } else if (!SearchName) {
1892 ConflictingDecls.push_back(FoundDecls[I]);
1895 if (!ConflictingDecls.empty() && SearchName) {
1896 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1897 ConflictingDecls.data(),
1898 ConflictingDecls.size());
1902 // Create the record declaration.
1903 RecordDecl *D2 = AdoptDecl;
1904 SourceLocation StartLoc = Importer.Import(D->getLocStart());
1906 CXXRecordDecl *D2CXX = nullptr;
1907 if (CXXRecordDecl *DCXX = llvm::dyn_cast<CXXRecordDecl>(D)) {
1908 if (DCXX->isLambda()) {
1909 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
1910 D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(),
1912 DCXX->isDependentLambda(),
1913 DCXX->isGenericLambda(),
1914 DCXX->getLambdaCaptureDefault());
1915 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
1916 if (DCXX->getLambdaContextDecl() && !CDecl)
1918 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
1919 } else if (DCXX->isInjectedClassName()) {
1920 // We have to be careful to do a similar dance to the one in
1921 // Sema::ActOnStartCXXMemberDeclarations
1922 CXXRecordDecl *const PrevDecl = nullptr;
1923 const bool DelayTypeCreation = true;
1924 D2CXX = CXXRecordDecl::Create(
1925 Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc,
1926 Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation);
1927 Importer.getToContext().getTypeDeclType(
1928 D2CXX, llvm::dyn_cast<CXXRecordDecl>(DC));
1930 D2CXX = CXXRecordDecl::Create(Importer.getToContext(),
1933 Name.getAsIdentifierInfo());
1936 D2->setAccess(D->getAccess());
1938 Importer.Imported(D, D2);
1940 if (ClassTemplateDecl *FromDescribed =
1941 DCXX->getDescribedClassTemplate()) {
1942 ClassTemplateDecl *ToDescribed = cast_or_null<ClassTemplateDecl>(
1943 Importer.Import(FromDescribed));
1946 D2CXX->setDescribedClassTemplate(ToDescribed);
1948 } else if (MemberSpecializationInfo *MemberInfo =
1949 DCXX->getMemberSpecializationInfo()) {
1950 TemplateSpecializationKind SK =
1951 MemberInfo->getTemplateSpecializationKind();
1952 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
1953 CXXRecordDecl *ToInst =
1954 cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
1955 if (FromInst && !ToInst)
1957 D2CXX->setInstantiationOfMemberClass(ToInst, SK);
1958 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
1959 Importer.Import(MemberInfo->getPointOfInstantiation()));
1963 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(),
1964 DC, StartLoc, Loc, Name.getAsIdentifierInfo());
1967 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
1968 D2->setLexicalDeclContext(LexicalDC);
1969 LexicalDC->addDeclInternal(D2);
1970 if (D->isAnonymousStructOrUnion())
1971 D2->setAnonymousStructOrUnion(true);
1973 // FIXME: do this for all Redeclarables, not just RecordDecls.
1974 D2->setPreviousDecl(PrevDecl);
1978 Importer.Imported(D, D2);
1980 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
1986 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
1987 // Import the major distinguishing characteristics of this enumerator.
1988 DeclContext *DC, *LexicalDC;
1989 DeclarationName Name;
1992 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1997 QualType T = Importer.Import(D->getType());
2001 // Determine whether there are any other declarations with the same name and
2002 // in the same context.
2003 if (!LexicalDC->isFunctionOrMethod()) {
2004 SmallVector<NamedDecl *, 4> ConflictingDecls;
2005 unsigned IDNS = Decl::IDNS_Ordinary;
2006 SmallVector<NamedDecl *, 2> FoundDecls;
2007 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2008 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2009 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2012 if (EnumConstantDecl *FoundEnumConstant
2013 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) {
2014 if (IsStructuralMatch(D, FoundEnumConstant))
2015 return Importer.Imported(D, FoundEnumConstant);
2018 ConflictingDecls.push_back(FoundDecls[I]);
2021 if (!ConflictingDecls.empty()) {
2022 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2023 ConflictingDecls.data(),
2024 ConflictingDecls.size());
2030 Expr *Init = Importer.Import(D->getInitExpr());
2031 if (D->getInitExpr() && !Init)
2034 EnumConstantDecl *ToEnumerator
2035 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2036 Name.getAsIdentifierInfo(), T,
2037 Init, D->getInitVal());
2038 ToEnumerator->setAccess(D->getAccess());
2039 ToEnumerator->setLexicalDeclContext(LexicalDC);
2040 Importer.Imported(D, ToEnumerator);
2041 LexicalDC->addDeclInternal(ToEnumerator);
2042 return ToEnumerator;
2045 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2046 // Import the major distinguishing characteristics of this function.
2047 DeclContext *DC, *LexicalDC;
2048 DeclarationName Name;
2051 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2056 const FunctionDecl *FoundWithoutBody = nullptr;
2058 // Try to find a function in our own ("to") context with the same name, same
2059 // type, and in the same context as the function we're importing.
2060 if (!LexicalDC->isFunctionOrMethod()) {
2061 SmallVector<NamedDecl *, 4> ConflictingDecls;
2062 unsigned IDNS = Decl::IDNS_Ordinary;
2063 SmallVector<NamedDecl *, 2> FoundDecls;
2064 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2065 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2066 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2069 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) {
2070 if (FoundFunction->hasExternalFormalLinkage() &&
2071 D->hasExternalFormalLinkage()) {
2072 if (Importer.IsStructurallyEquivalent(D->getType(),
2073 FoundFunction->getType())) {
2074 // FIXME: Actually try to merge the body and other attributes.
2075 const FunctionDecl *FromBodyDecl = nullptr;
2076 D->hasBody(FromBodyDecl);
2077 if (D == FromBodyDecl && !FoundFunction->hasBody()) {
2078 // This function is needed to merge completely.
2079 FoundWithoutBody = FoundFunction;
2082 return Importer.Imported(D, FoundFunction);
2085 // FIXME: Check for overloading more carefully, e.g., by boosting
2086 // Sema::IsOverload out to the AST library.
2088 // Function overloading is okay in C++.
2089 if (Importer.getToContext().getLangOpts().CPlusPlus)
2092 // Complain about inconsistent function types.
2093 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2094 << Name << D->getType() << FoundFunction->getType();
2095 Importer.ToDiag(FoundFunction->getLocation(),
2096 diag::note_odr_value_here)
2097 << FoundFunction->getType();
2101 ConflictingDecls.push_back(FoundDecls[I]);
2104 if (!ConflictingDecls.empty()) {
2105 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2106 ConflictingDecls.data(),
2107 ConflictingDecls.size());
2113 DeclarationNameInfo NameInfo(Name, Loc);
2114 // Import additional name location/type info.
2115 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2117 QualType FromTy = D->getType();
2118 bool usedDifferentExceptionSpec = false;
2120 if (const FunctionProtoType *
2121 FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2122 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2123 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2124 // FunctionDecl that we are importing the FunctionProtoType for.
2125 // To avoid an infinite recursion when importing, create the FunctionDecl
2126 // with a simplified function type and update it afterwards.
2127 if (FromEPI.ExceptionSpec.SourceDecl ||
2128 FromEPI.ExceptionSpec.SourceTemplate ||
2129 FromEPI.ExceptionSpec.NoexceptExpr) {
2130 FunctionProtoType::ExtProtoInfo DefaultEPI;
2131 FromTy = Importer.getFromContext().getFunctionType(
2132 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2133 usedDifferentExceptionSpec = true;
2138 QualType T = Importer.Import(FromTy);
2142 // Import the function parameters.
2143 SmallVector<ParmVarDecl *, 8> Parameters;
2144 for (auto P : D->parameters()) {
2145 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2149 Parameters.push_back(ToP);
2152 // Create the imported function.
2153 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2154 FunctionDecl *ToFunction = nullptr;
2155 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2156 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2157 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(),
2158 cast<CXXRecordDecl>(DC),
2161 FromConstructor->isExplicit(),
2162 D->isInlineSpecified(),
2165 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
2166 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
2167 for (CXXCtorInitializer *I : FromConstructor->inits()) {
2168 CXXCtorInitializer *ToI =
2169 cast_or_null<CXXCtorInitializer>(Importer.Import(I));
2172 CtorInitializers.push_back(ToI);
2174 CXXCtorInitializer **Memory =
2175 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
2176 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
2177 CXXConstructorDecl *ToCtor = llvm::cast<CXXConstructorDecl>(ToFunction);
2178 ToCtor->setCtorInitializers(Memory);
2179 ToCtor->setNumCtorInitializers(NumInitializers);
2181 } else if (isa<CXXDestructorDecl>(D)) {
2182 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(),
2183 cast<CXXRecordDecl>(DC),
2186 D->isInlineSpecified(),
2188 } else if (CXXConversionDecl *FromConversion
2189 = dyn_cast<CXXConversionDecl>(D)) {
2190 ToFunction = CXXConversionDecl::Create(Importer.getToContext(),
2191 cast<CXXRecordDecl>(DC),
2194 D->isInlineSpecified(),
2195 FromConversion->isExplicit(),
2197 Importer.Import(D->getLocEnd()));
2198 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
2199 ToFunction = CXXMethodDecl::Create(Importer.getToContext(),
2200 cast<CXXRecordDecl>(DC),
2203 Method->getStorageClass(),
2204 Method->isInlineSpecified(),
2206 Importer.Import(D->getLocEnd()));
2208 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
2210 NameInfo, T, TInfo, D->getStorageClass(),
2211 D->isInlineSpecified(),
2212 D->hasWrittenPrototype(),
2216 // Import the qualifier, if any.
2217 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2218 ToFunction->setAccess(D->getAccess());
2219 ToFunction->setLexicalDeclContext(LexicalDC);
2220 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2221 ToFunction->setTrivial(D->isTrivial());
2222 ToFunction->setPure(D->isPure());
2223 Importer.Imported(D, ToFunction);
2225 // Set the parameters.
2226 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) {
2227 Parameters[I]->setOwningFunction(ToFunction);
2228 ToFunction->addDeclInternal(Parameters[I]);
2230 ToFunction->setParams(Parameters);
2232 if (FoundWithoutBody) {
2233 auto *Recent = const_cast<FunctionDecl *>(
2234 FoundWithoutBody->getMostRecentDecl());
2235 ToFunction->setPreviousDecl(Recent);
2238 if (usedDifferentExceptionSpec) {
2239 // Update FunctionProtoType::ExtProtoInfo.
2240 QualType T = Importer.Import(D->getType());
2243 ToFunction->setType(T);
2246 // Import the body, if any.
2247 if (Stmt *FromBody = D->getBody()) {
2248 if (Stmt *ToBody = Importer.Import(FromBody)) {
2249 ToFunction->setBody(ToBody);
2253 // FIXME: Other bits to merge?
2255 // Add this function to the lexical context.
2256 LexicalDC->addDeclInternal(ToFunction);
2258 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
2259 ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
2264 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2265 return VisitFunctionDecl(D);
2268 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2269 return VisitCXXMethodDecl(D);
2272 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2273 return VisitCXXMethodDecl(D);
2276 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2277 return VisitCXXMethodDecl(D);
2280 static unsigned getFieldIndex(Decl *F) {
2281 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2286 for (const auto *D : Owner->noload_decls()) {
2290 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2297 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2298 // Import the major distinguishing characteristics of a variable.
2299 DeclContext *DC, *LexicalDC;
2300 DeclarationName Name;
2303 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2308 // Determine whether we've already imported this field.
2309 SmallVector<NamedDecl *, 2> FoundDecls;
2310 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2311 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2312 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) {
2313 // For anonymous fields, match up by index.
2314 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2317 if (Importer.IsStructurallyEquivalent(D->getType(),
2318 FoundField->getType())) {
2319 Importer.Imported(D, FoundField);
2323 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2324 << Name << D->getType() << FoundField->getType();
2325 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2326 << FoundField->getType();
2332 QualType T = Importer.Import(D->getType());
2336 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2337 Expr *BitWidth = Importer.Import(D->getBitWidth());
2338 if (!BitWidth && D->getBitWidth())
2341 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC,
2342 Importer.Import(D->getInnerLocStart()),
2343 Loc, Name.getAsIdentifierInfo(),
2344 T, TInfo, BitWidth, D->isMutable(),
2345 D->getInClassInitStyle());
2346 ToField->setAccess(D->getAccess());
2347 ToField->setLexicalDeclContext(LexicalDC);
2348 if (Expr *FromInitializer = D->getInClassInitializer()) {
2349 Expr *ToInitializer = Importer.Import(FromInitializer);
2351 ToField->setInClassInitializer(ToInitializer);
2355 ToField->setImplicit(D->isImplicit());
2356 Importer.Imported(D, ToField);
2357 LexicalDC->addDeclInternal(ToField);
2361 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2362 // Import the major distinguishing characteristics of a variable.
2363 DeclContext *DC, *LexicalDC;
2364 DeclarationName Name;
2367 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2372 // Determine whether we've already imported this field.
2373 SmallVector<NamedDecl *, 2> FoundDecls;
2374 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2375 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2376 if (IndirectFieldDecl *FoundField
2377 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2378 // For anonymous indirect fields, match up by index.
2379 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2382 if (Importer.IsStructurallyEquivalent(D->getType(),
2383 FoundField->getType(),
2385 Importer.Imported(D, FoundField);
2389 // If there are more anonymous fields to check, continue.
2390 if (!Name && I < N-1)
2393 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2394 << Name << D->getType() << FoundField->getType();
2395 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2396 << FoundField->getType();
2402 QualType T = Importer.Import(D->getType());
2406 NamedDecl **NamedChain =
2407 new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
2410 for (auto *PI : D->chain()) {
2411 Decl *D = Importer.Import(PI);
2414 NamedChain[i++] = cast<NamedDecl>(D);
2417 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create(
2418 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T,
2419 {NamedChain, D->getChainingSize()});
2421 for (const auto *Attr : D->attrs())
2422 ToIndirectField->addAttr(Attr->clone(Importer.getToContext()));
2424 ToIndirectField->setAccess(D->getAccess());
2425 ToIndirectField->setLexicalDeclContext(LexicalDC);
2426 Importer.Imported(D, ToIndirectField);
2427 LexicalDC->addDeclInternal(ToIndirectField);
2428 return ToIndirectField;
2431 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
2432 // Import the major distinguishing characteristics of a declaration.
2433 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2434 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
2435 ? DC : Importer.ImportContext(D->getLexicalDeclContext());
2436 if (!DC || !LexicalDC)
2439 // Determine whether we've already imported this decl.
2440 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
2441 auto *RD = cast<CXXRecordDecl>(DC);
2442 FriendDecl *ImportedFriend = RD->getFirstFriend();
2443 StructuralEquivalenceContext Context(
2444 Importer.getFromContext(), Importer.getToContext(),
2445 Importer.getNonEquivalentDecls(), false, false);
2447 while (ImportedFriend) {
2448 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
2449 if (Context.IsStructurallyEquivalent(D->getFriendDecl(),
2450 ImportedFriend->getFriendDecl()))
2451 return Importer.Imported(D, ImportedFriend);
2453 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
2454 if (Importer.IsStructurallyEquivalent(
2455 D->getFriendType()->getType(),
2456 ImportedFriend->getFriendType()->getType(), true))
2457 return Importer.Imported(D, ImportedFriend);
2459 ImportedFriend = ImportedFriend->getNextFriend();
2462 // Not found. Create it.
2463 FriendDecl::FriendUnion ToFU;
2464 if (NamedDecl *FriendD = D->getFriendDecl())
2465 ToFU = cast_or_null<NamedDecl>(Importer.Import(FriendD));
2467 ToFU = Importer.Import(D->getFriendType());
2471 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
2472 TemplateParameterList **FromTPLists =
2473 D->getTrailingObjects<TemplateParameterList *>();
2474 for (unsigned I = 0; I < D->NumTPLists; I++) {
2475 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
2478 ToTPLists[I] = List;
2481 FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC,
2482 Importer.Import(D->getLocation()),
2483 ToFU, Importer.Import(D->getFriendLoc()),
2486 Importer.Imported(D, FrD);
2487 RD->pushFriendDecl(FrD);
2489 FrD->setAccess(D->getAccess());
2490 FrD->setLexicalDeclContext(LexicalDC);
2491 LexicalDC->addDeclInternal(FrD);
2495 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
2496 // Import the major distinguishing characteristics of an ivar.
2497 DeclContext *DC, *LexicalDC;
2498 DeclarationName Name;
2501 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2506 // Determine whether we've already imported this ivar
2507 SmallVector<NamedDecl *, 2> FoundDecls;
2508 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2509 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2510 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) {
2511 if (Importer.IsStructurallyEquivalent(D->getType(),
2512 FoundIvar->getType())) {
2513 Importer.Imported(D, FoundIvar);
2517 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
2518 << Name << D->getType() << FoundIvar->getType();
2519 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
2520 << FoundIvar->getType();
2526 QualType T = Importer.Import(D->getType());
2530 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2531 Expr *BitWidth = Importer.Import(D->getBitWidth());
2532 if (!BitWidth && D->getBitWidth())
2535 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(),
2536 cast<ObjCContainerDecl>(DC),
2537 Importer.Import(D->getInnerLocStart()),
2538 Loc, Name.getAsIdentifierInfo(),
2539 T, TInfo, D->getAccessControl(),
2540 BitWidth, D->getSynthesize());
2541 ToIvar->setLexicalDeclContext(LexicalDC);
2542 Importer.Imported(D, ToIvar);
2543 LexicalDC->addDeclInternal(ToIvar);
2548 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
2549 // Import the major distinguishing characteristics of a variable.
2550 DeclContext *DC, *LexicalDC;
2551 DeclarationName Name;
2554 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2559 // Try to find a variable in our own ("to") context with the same name and
2560 // in the same context as the variable we're importing.
2561 if (D->isFileVarDecl()) {
2562 VarDecl *MergeWithVar = nullptr;
2563 SmallVector<NamedDecl *, 4> ConflictingDecls;
2564 unsigned IDNS = Decl::IDNS_Ordinary;
2565 SmallVector<NamedDecl *, 2> FoundDecls;
2566 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2567 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2568 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
2571 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) {
2572 // We have found a variable that we may need to merge with. Check it.
2573 if (FoundVar->hasExternalFormalLinkage() &&
2574 D->hasExternalFormalLinkage()) {
2575 if (Importer.IsStructurallyEquivalent(D->getType(),
2576 FoundVar->getType())) {
2577 MergeWithVar = FoundVar;
2581 const ArrayType *FoundArray
2582 = Importer.getToContext().getAsArrayType(FoundVar->getType());
2583 const ArrayType *TArray
2584 = Importer.getToContext().getAsArrayType(D->getType());
2585 if (FoundArray && TArray) {
2586 if (isa<IncompleteArrayType>(FoundArray) &&
2587 isa<ConstantArrayType>(TArray)) {
2589 QualType T = Importer.Import(D->getType());
2593 FoundVar->setType(T);
2594 MergeWithVar = FoundVar;
2596 } else if (isa<IncompleteArrayType>(TArray) &&
2597 isa<ConstantArrayType>(FoundArray)) {
2598 MergeWithVar = FoundVar;
2603 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
2604 << Name << D->getType() << FoundVar->getType();
2605 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
2606 << FoundVar->getType();
2610 ConflictingDecls.push_back(FoundDecls[I]);
2614 // An equivalent variable with external linkage has been found. Link
2615 // the two declarations, then merge them.
2616 Importer.Imported(D, MergeWithVar);
2618 if (VarDecl *DDef = D->getDefinition()) {
2619 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
2620 Importer.ToDiag(ExistingDef->getLocation(),
2621 diag::err_odr_variable_multiple_def)
2623 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
2625 Expr *Init = Importer.Import(DDef->getInit());
2626 MergeWithVar->setInit(Init);
2627 if (DDef->isInitKnownICE()) {
2628 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
2629 Eval->CheckedICE = true;
2630 Eval->IsICE = DDef->isInitICE();
2635 return MergeWithVar;
2638 if (!ConflictingDecls.empty()) {
2639 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2640 ConflictingDecls.data(),
2641 ConflictingDecls.size());
2648 QualType T = Importer.Import(D->getType());
2652 // Create the imported variable.
2653 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2654 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC,
2655 Importer.Import(D->getInnerLocStart()),
2656 Loc, Name.getAsIdentifierInfo(),
2658 D->getStorageClass());
2659 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2660 ToVar->setAccess(D->getAccess());
2661 ToVar->setLexicalDeclContext(LexicalDC);
2662 Importer.Imported(D, ToVar);
2663 LexicalDC->addDeclInternal(ToVar);
2665 if (!D->isFileVarDecl() &&
2669 // Merge the initializer.
2670 if (ImportDefinition(D, ToVar))
2673 if (D->isConstexpr())
2674 ToVar->setConstexpr(true);
2679 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
2680 // Parameters are created in the translation unit's context, then moved
2681 // into the function declaration's context afterward.
2682 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
2684 // Import the name of this declaration.
2685 DeclarationName Name = Importer.Import(D->getDeclName());
2686 if (D->getDeclName() && !Name)
2689 // Import the location of this declaration.
2690 SourceLocation Loc = Importer.Import(D->getLocation());
2692 // Import the parameter's type.
2693 QualType T = Importer.Import(D->getType());
2697 // Create the imported parameter.
2698 auto *ToParm = ImplicitParamDecl::Create(Importer.getToContext(), DC, Loc,
2699 Name.getAsIdentifierInfo(), T,
2700 D->getParameterKind());
2701 return Importer.Imported(D, ToParm);
2704 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
2705 // Parameters are created in the translation unit's context, then moved
2706 // into the function declaration's context afterward.
2707 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
2709 // Import the name of this declaration.
2710 DeclarationName Name = Importer.Import(D->getDeclName());
2711 if (D->getDeclName() && !Name)
2714 // Import the location of this declaration.
2715 SourceLocation Loc = Importer.Import(D->getLocation());
2717 // Import the parameter's type.
2718 QualType T = Importer.Import(D->getType());
2722 // Create the imported parameter.
2723 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2724 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC,
2725 Importer.Import(D->getInnerLocStart()),
2726 Loc, Name.getAsIdentifierInfo(),
2727 T, TInfo, D->getStorageClass(),
2728 /*DefaultArg*/ nullptr);
2730 // Set the default argument.
2731 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
2732 ToParm->setKNRPromoted(D->isKNRPromoted());
2734 Expr *ToDefArg = nullptr;
2735 Expr *FromDefArg = nullptr;
2736 if (D->hasUninstantiatedDefaultArg()) {
2737 FromDefArg = D->getUninstantiatedDefaultArg();
2738 ToDefArg = Importer.Import(FromDefArg);
2739 ToParm->setUninstantiatedDefaultArg(ToDefArg);
2740 } else if (D->hasUnparsedDefaultArg()) {
2741 ToParm->setUnparsedDefaultArg();
2742 } else if (D->hasDefaultArg()) {
2743 FromDefArg = D->getDefaultArg();
2744 ToDefArg = Importer.Import(FromDefArg);
2745 ToParm->setDefaultArg(ToDefArg);
2747 if (FromDefArg && !ToDefArg)
2751 ToParm->setIsUsed();
2753 return Importer.Imported(D, ToParm);
2756 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
2757 // Import the major distinguishing characteristics of a method.
2758 DeclContext *DC, *LexicalDC;
2759 DeclarationName Name;
2762 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2767 SmallVector<NamedDecl *, 2> FoundDecls;
2768 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2769 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2770 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) {
2771 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
2774 // Check return types.
2775 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
2776 FoundMethod->getReturnType())) {
2777 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
2778 << D->isInstanceMethod() << Name << D->getReturnType()
2779 << FoundMethod->getReturnType();
2780 Importer.ToDiag(FoundMethod->getLocation(),
2781 diag::note_odr_objc_method_here)
2782 << D->isInstanceMethod() << Name;
2786 // Check the number of parameters.
2787 if (D->param_size() != FoundMethod->param_size()) {
2788 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
2789 << D->isInstanceMethod() << Name
2790 << D->param_size() << FoundMethod->param_size();
2791 Importer.ToDiag(FoundMethod->getLocation(),
2792 diag::note_odr_objc_method_here)
2793 << D->isInstanceMethod() << Name;
2797 // Check parameter types.
2798 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
2799 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
2800 P != PEnd; ++P, ++FoundP) {
2801 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
2802 (*FoundP)->getType())) {
2803 Importer.FromDiag((*P)->getLocation(),
2804 diag::err_odr_objc_method_param_type_inconsistent)
2805 << D->isInstanceMethod() << Name
2806 << (*P)->getType() << (*FoundP)->getType();
2807 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
2808 << (*FoundP)->getType();
2813 // Check variadic/non-variadic.
2814 // Check the number of parameters.
2815 if (D->isVariadic() != FoundMethod->isVariadic()) {
2816 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
2817 << D->isInstanceMethod() << Name;
2818 Importer.ToDiag(FoundMethod->getLocation(),
2819 diag::note_odr_objc_method_here)
2820 << D->isInstanceMethod() << Name;
2824 // FIXME: Any other bits we need to merge?
2825 return Importer.Imported(D, FoundMethod);
2829 // Import the result type.
2830 QualType ResultTy = Importer.Import(D->getReturnType());
2831 if (ResultTy.isNull())
2834 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
2836 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create(
2837 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()),
2838 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(),
2839 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
2840 D->getImplementationControl(), D->hasRelatedResultType());
2842 // FIXME: When we decide to merge method definitions, we'll need to
2843 // deal with implicit parameters.
2845 // Import the parameters
2846 SmallVector<ParmVarDecl *, 5> ToParams;
2847 for (auto *FromP : D->parameters()) {
2848 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
2852 ToParams.push_back(ToP);
2855 // Set the parameters.
2856 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) {
2857 ToParams[I]->setOwningFunction(ToMethod);
2858 ToMethod->addDeclInternal(ToParams[I]);
2860 SmallVector<SourceLocation, 12> SelLocs;
2861 D->getSelectorLocs(SelLocs);
2862 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
2864 ToMethod->setLexicalDeclContext(LexicalDC);
2865 Importer.Imported(D, ToMethod);
2866 LexicalDC->addDeclInternal(ToMethod);
2870 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
2871 // Import the major distinguishing characteristics of a category.
2872 DeclContext *DC, *LexicalDC;
2873 DeclarationName Name;
2876 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2881 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
2885 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create(
2886 Importer.getToContext(), DC,
2888 Importer.Import(D->getVarianceLoc()),
2890 Importer.Import(D->getLocation()),
2891 Name.getAsIdentifierInfo(),
2892 Importer.Import(D->getColonLoc()),
2894 Importer.Imported(D, Result);
2895 Result->setLexicalDeclContext(LexicalDC);
2899 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
2900 // Import the major distinguishing characteristics of a category.
2901 DeclContext *DC, *LexicalDC;
2902 DeclarationName Name;
2905 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2910 ObjCInterfaceDecl *ToInterface
2911 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
2915 // Determine if we've already encountered this category.
2916 ObjCCategoryDecl *MergeWithCategory
2917 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
2918 ObjCCategoryDecl *ToCategory = MergeWithCategory;
2920 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC,
2921 Importer.Import(D->getAtStartLoc()),
2923 Importer.Import(D->getCategoryNameLoc()),
2924 Name.getAsIdentifierInfo(),
2926 /*TypeParamList=*/nullptr,
2927 Importer.Import(D->getIvarLBraceLoc()),
2928 Importer.Import(D->getIvarRBraceLoc()));
2929 ToCategory->setLexicalDeclContext(LexicalDC);
2930 LexicalDC->addDeclInternal(ToCategory);
2931 Importer.Imported(D, ToCategory);
2932 // Import the type parameter list after calling Imported, to avoid
2933 // loops when bringing in their DeclContext.
2934 ToCategory->setTypeParamList(ImportObjCTypeParamList(
2935 D->getTypeParamList()));
2938 SmallVector<ObjCProtocolDecl *, 4> Protocols;
2939 SmallVector<SourceLocation, 4> ProtocolLocs;
2940 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
2941 = D->protocol_loc_begin();
2942 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
2943 FromProtoEnd = D->protocol_end();
2944 FromProto != FromProtoEnd;
2945 ++FromProto, ++FromProtoLoc) {
2946 ObjCProtocolDecl *ToProto
2947 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
2950 Protocols.push_back(ToProto);
2951 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
2954 // FIXME: If we're merging, make sure that the protocol list is the same.
2955 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
2956 ProtocolLocs.data(), Importer.getToContext());
2959 Importer.Imported(D, ToCategory);
2962 // Import all of the members of this category.
2963 ImportDeclContext(D);
2965 // If we have an implementation, import it as well.
2966 if (D->getImplementation()) {
2967 ObjCCategoryImplDecl *Impl
2968 = cast_or_null<ObjCCategoryImplDecl>(
2969 Importer.Import(D->getImplementation()));
2973 ToCategory->setImplementation(Impl);
2979 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
2980 ObjCProtocolDecl *To,
2981 ImportDefinitionKind Kind) {
2982 if (To->getDefinition()) {
2983 if (shouldForceImportDeclContext(Kind))
2984 ImportDeclContext(From);
2988 // Start the protocol definition
2989 To->startDefinition();
2992 SmallVector<ObjCProtocolDecl *, 4> Protocols;
2993 SmallVector<SourceLocation, 4> ProtocolLocs;
2994 ObjCProtocolDecl::protocol_loc_iterator
2995 FromProtoLoc = From->protocol_loc_begin();
2996 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
2997 FromProtoEnd = From->protocol_end();
2998 FromProto != FromProtoEnd;
2999 ++FromProto, ++FromProtoLoc) {
3000 ObjCProtocolDecl *ToProto
3001 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3004 Protocols.push_back(ToProto);
3005 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3008 // FIXME: If we're merging, make sure that the protocol list is the same.
3009 To->setProtocolList(Protocols.data(), Protocols.size(),
3010 ProtocolLocs.data(), Importer.getToContext());
3012 if (shouldForceImportDeclContext(Kind)) {
3013 // Import all of the members of this protocol.
3014 ImportDeclContext(From, /*ForceImport=*/true);
3019 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3020 // If this protocol has a definition in the translation unit we're coming
3021 // from, but this particular declaration is not that definition, import the
3022 // definition and map to that.
3023 ObjCProtocolDecl *Definition = D->getDefinition();
3024 if (Definition && Definition != D) {
3025 Decl *ImportedDef = Importer.Import(Definition);
3029 return Importer.Imported(D, ImportedDef);
3032 // Import the major distinguishing characteristics of a protocol.
3033 DeclContext *DC, *LexicalDC;
3034 DeclarationName Name;
3037 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3042 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3043 SmallVector<NamedDecl *, 2> FoundDecls;
3044 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3045 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3046 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3049 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I])))
3053 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3055 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC,
3056 Name.getAsIdentifierInfo(), Loc,
3057 Importer.Import(D->getAtStartLoc()),
3058 /*PrevDecl=*/nullptr);
3059 ToProto->setLexicalDeclContext(LexicalDC);
3060 LexicalDC->addDeclInternal(ToProto);
3063 Importer.Imported(D, ToProto);
3065 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3071 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3072 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3073 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3075 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3076 SourceLocation LangLoc = Importer.Import(D->getLocation());
3078 bool HasBraces = D->hasBraces();
3080 LinkageSpecDecl *ToLinkageSpec =
3081 LinkageSpecDecl::Create(Importer.getToContext(),
3089 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3090 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3093 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3094 LexicalDC->addDeclInternal(ToLinkageSpec);
3096 Importer.Imported(D, ToLinkageSpec);
3098 return ToLinkageSpec;
3101 Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
3102 DeclContext *DC, *LexicalDC;
3103 DeclarationName Name;
3105 NamedDecl *ToD = nullptr;
3106 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3111 DeclarationNameInfo NameInfo(Name,
3112 Importer.Import(D->getNameInfo().getLoc()));
3113 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3115 UsingDecl *ToUsing = UsingDecl::Create(Importer.getToContext(), DC,
3116 Importer.Import(D->getUsingLoc()),
3117 Importer.Import(D->getQualifierLoc()),
3118 NameInfo, D->hasTypename());
3119 ToUsing->setLexicalDeclContext(LexicalDC);
3120 LexicalDC->addDeclInternal(ToUsing);
3121 Importer.Imported(D, ToUsing);
3123 if (NamedDecl *FromPattern =
3124 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
3125 if (NamedDecl *ToPattern =
3126 dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
3127 Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
3132 for (UsingShadowDecl *FromShadow : D->shadows()) {
3133 if (UsingShadowDecl *ToShadow =
3134 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
3135 ToUsing->addShadowDecl(ToShadow);
3137 // FIXME: We return a nullptr here but the definition is already created
3138 // and available with lookups. How to fix this?..
3144 Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
3145 DeclContext *DC, *LexicalDC;
3146 DeclarationName Name;
3148 NamedDecl *ToD = nullptr;
3149 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3154 UsingDecl *ToUsing = dyn_cast_or_null<UsingDecl>(
3155 Importer.Import(D->getUsingDecl()));
3159 NamedDecl *ToTarget = dyn_cast_or_null<NamedDecl>(
3160 Importer.Import(D->getTargetDecl()));
3164 UsingShadowDecl *ToShadow = UsingShadowDecl::Create(
3165 Importer.getToContext(), DC, Loc, ToUsing, ToTarget);
3167 ToShadow->setLexicalDeclContext(LexicalDC);
3168 ToShadow->setAccess(D->getAccess());
3169 Importer.Imported(D, ToShadow);
3171 if (UsingShadowDecl *FromPattern =
3172 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
3173 if (UsingShadowDecl *ToPattern =
3174 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
3175 Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
3178 // FIXME: We return a nullptr here but the definition is already created
3179 // and available with lookups. How to fix this?..
3183 LexicalDC->addDeclInternal(ToShadow);
3189 Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
3190 DeclContext *DC, *LexicalDC;
3191 DeclarationName Name;
3193 NamedDecl *ToD = nullptr;
3194 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3199 DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
3203 NamespaceDecl *ToNominated = cast_or_null<NamespaceDecl>(
3204 Importer.Import(D->getNominatedNamespace()));
3208 UsingDirectiveDecl *ToUsingDir = UsingDirectiveDecl::Create(
3209 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()),
3210 Importer.Import(D->getNamespaceKeyLocation()),
3211 Importer.Import(D->getQualifierLoc()),
3212 Importer.Import(D->getIdentLocation()), ToNominated, ToComAncestor);
3213 ToUsingDir->setLexicalDeclContext(LexicalDC);
3214 LexicalDC->addDeclInternal(ToUsingDir);
3215 Importer.Imported(D, ToUsingDir);
3220 Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
3221 UnresolvedUsingValueDecl *D) {
3222 DeclContext *DC, *LexicalDC;
3223 DeclarationName Name;
3225 NamedDecl *ToD = nullptr;
3226 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3231 DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
3232 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3234 UnresolvedUsingValueDecl *ToUsingValue = UnresolvedUsingValueDecl::Create(
3235 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()),
3236 Importer.Import(D->getQualifierLoc()), NameInfo,
3237 Importer.Import(D->getEllipsisLoc()));
3239 Importer.Imported(D, ToUsingValue);
3240 ToUsingValue->setAccess(D->getAccess());
3241 ToUsingValue->setLexicalDeclContext(LexicalDC);
3242 LexicalDC->addDeclInternal(ToUsingValue);
3244 return ToUsingValue;
3247 Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
3248 UnresolvedUsingTypenameDecl *D) {
3249 DeclContext *DC, *LexicalDC;
3250 DeclarationName Name;
3252 NamedDecl *ToD = nullptr;
3253 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3258 UnresolvedUsingTypenameDecl *ToUsing = UnresolvedUsingTypenameDecl::Create(
3259 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()),
3260 Importer.Import(D->getTypenameLoc()),
3261 Importer.Import(D->getQualifierLoc()), Loc, Name,
3262 Importer.Import(D->getEllipsisLoc()));
3264 Importer.Imported(D, ToUsing);
3265 ToUsing->setAccess(D->getAccess());
3266 ToUsing->setLexicalDeclContext(LexicalDC);
3267 LexicalDC->addDeclInternal(ToUsing);
3273 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3274 ObjCInterfaceDecl *To,
3275 ImportDefinitionKind Kind) {
3276 if (To->getDefinition()) {
3277 // Check consistency of superclass.
3278 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3280 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3285 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3286 if ((bool)FromSuper != (bool)ToSuper ||
3287 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3288 Importer.ToDiag(To->getLocation(),
3289 diag::err_odr_objc_superclass_inconsistent)
3290 << To->getDeclName();
3292 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3293 << To->getSuperClass()->getDeclName();
3295 Importer.ToDiag(To->getLocation(),
3296 diag::note_odr_objc_missing_superclass);
3297 if (From->getSuperClass())
3298 Importer.FromDiag(From->getSuperClassLoc(),
3299 diag::note_odr_objc_superclass)
3300 << From->getSuperClass()->getDeclName();
3302 Importer.FromDiag(From->getLocation(),
3303 diag::note_odr_objc_missing_superclass);
3306 if (shouldForceImportDeclContext(Kind))
3307 ImportDeclContext(From);
3311 // Start the definition.
3312 To->startDefinition();
3314 // If this class has a superclass, import it.
3315 if (From->getSuperClass()) {
3316 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3320 To->setSuperClass(SuperTInfo);
3324 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3325 SmallVector<SourceLocation, 4> ProtocolLocs;
3326 ObjCInterfaceDecl::protocol_loc_iterator
3327 FromProtoLoc = From->protocol_loc_begin();
3329 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3330 FromProtoEnd = From->protocol_end();
3331 FromProto != FromProtoEnd;
3332 ++FromProto, ++FromProtoLoc) {
3333 ObjCProtocolDecl *ToProto
3334 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3337 Protocols.push_back(ToProto);
3338 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3341 // FIXME: If we're merging, make sure that the protocol list is the same.
3342 To->setProtocolList(Protocols.data(), Protocols.size(),
3343 ProtocolLocs.data(), Importer.getToContext());
3345 // Import categories. When the categories themselves are imported, they'll
3346 // hook themselves into this interface.
3347 for (auto *Cat : From->known_categories())
3348 Importer.Import(Cat);
3350 // If we have an @implementation, import it as well.
3351 if (From->getImplementation()) {
3352 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>(
3353 Importer.Import(From->getImplementation()));
3357 To->setImplementation(Impl);
3360 if (shouldForceImportDeclContext(Kind)) {
3361 // Import all of the members of this class.
3362 ImportDeclContext(From, /*ForceImport=*/true);
3368 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3372 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3373 for (auto fromTypeParam : *list) {
3374 auto toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3375 Importer.Import(fromTypeParam));
3379 toTypeParams.push_back(toTypeParam);
3382 return ObjCTypeParamList::create(Importer.getToContext(),
3383 Importer.Import(list->getLAngleLoc()),
3385 Importer.Import(list->getRAngleLoc()));
3388 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3389 // If this class has a definition in the translation unit we're coming from,
3390 // but this particular declaration is not that definition, import the
3391 // definition and map to that.
3392 ObjCInterfaceDecl *Definition = D->getDefinition();
3393 if (Definition && Definition != D) {
3394 Decl *ImportedDef = Importer.Import(Definition);
3398 return Importer.Imported(D, ImportedDef);
3401 // Import the major distinguishing characteristics of an @interface.
3402 DeclContext *DC, *LexicalDC;
3403 DeclarationName Name;
3406 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3411 // Look for an existing interface with the same name.
3412 ObjCInterfaceDecl *MergeWithIface = nullptr;
3413 SmallVector<NamedDecl *, 2> FoundDecls;
3414 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3415 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3416 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3419 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I])))
3423 // Create an interface declaration, if one does not already exist.
3424 ObjCInterfaceDecl *ToIface = MergeWithIface;
3426 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC,
3427 Importer.Import(D->getAtStartLoc()),
3428 Name.getAsIdentifierInfo(),
3429 /*TypeParamList=*/nullptr,
3430 /*PrevDecl=*/nullptr, Loc,
3431 D->isImplicitInterfaceDecl());
3432 ToIface->setLexicalDeclContext(LexicalDC);
3433 LexicalDC->addDeclInternal(ToIface);
3435 Importer.Imported(D, ToIface);
3436 // Import the type parameter list after calling Imported, to avoid
3437 // loops when bringing in their DeclContext.
3438 ToIface->setTypeParamList(ImportObjCTypeParamList(
3439 D->getTypeParamListAsWritten()));
3441 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
3447 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
3448 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>(
3449 Importer.Import(D->getCategoryDecl()));
3453 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
3455 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3459 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
3460 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC,
3461 Importer.Import(D->getIdentifier()),
3462 Category->getClassInterface(),
3463 Importer.Import(D->getLocation()),
3464 Importer.Import(D->getAtStartLoc()),
3467 DeclContext *LexicalDC = DC;
3468 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3469 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3473 ToImpl->setLexicalDeclContext(LexicalDC);
3476 LexicalDC->addDeclInternal(ToImpl);
3477 Category->setImplementation(ToImpl);
3480 Importer.Imported(D, ToImpl);
3481 ImportDeclContext(D);
3485 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
3486 // Find the corresponding interface.
3487 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>(
3488 Importer.Import(D->getClassInterface()));
3492 // Import the superclass, if any.
3493 ObjCInterfaceDecl *Super = nullptr;
3494 if (D->getSuperClass()) {
3495 Super = cast_or_null<ObjCInterfaceDecl>(
3496 Importer.Import(D->getSuperClass()));
3501 ObjCImplementationDecl *Impl = Iface->getImplementation();
3503 // We haven't imported an implementation yet. Create a new @implementation
3505 Impl = ObjCImplementationDecl::Create(Importer.getToContext(),
3506 Importer.ImportContext(D->getDeclContext()),
3508 Importer.Import(D->getLocation()),
3509 Importer.Import(D->getAtStartLoc()),
3510 Importer.Import(D->getSuperClassLoc()),
3511 Importer.Import(D->getIvarLBraceLoc()),
3512 Importer.Import(D->getIvarRBraceLoc()));
3514 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3515 DeclContext *LexicalDC
3516 = Importer.ImportContext(D->getLexicalDeclContext());
3519 Impl->setLexicalDeclContext(LexicalDC);
3522 // Associate the implementation with the class it implements.
3523 Iface->setImplementation(Impl);
3524 Importer.Imported(D, Iface->getImplementation());
3526 Importer.Imported(D, Iface->getImplementation());
3528 // Verify that the existing @implementation has the same superclass.
3529 if ((Super && !Impl->getSuperClass()) ||
3530 (!Super && Impl->getSuperClass()) ||
3531 (Super && Impl->getSuperClass() &&
3532 !declaresSameEntity(Super->getCanonicalDecl(),
3533 Impl->getSuperClass()))) {
3534 Importer.ToDiag(Impl->getLocation(),
3535 diag::err_odr_objc_superclass_inconsistent)
3536 << Iface->getDeclName();
3537 // FIXME: It would be nice to have the location of the superclass
3539 if (Impl->getSuperClass())
3540 Importer.ToDiag(Impl->getLocation(),
3541 diag::note_odr_objc_superclass)
3542 << Impl->getSuperClass()->getDeclName();
3544 Importer.ToDiag(Impl->getLocation(),
3545 diag::note_odr_objc_missing_superclass);
3546 if (D->getSuperClass())
3547 Importer.FromDiag(D->getLocation(),
3548 diag::note_odr_objc_superclass)
3549 << D->getSuperClass()->getDeclName();
3551 Importer.FromDiag(D->getLocation(),
3552 diag::note_odr_objc_missing_superclass);
3557 // Import all of the members of this @implementation.
3558 ImportDeclContext(D);
3563 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
3564 // Import the major distinguishing characteristics of an @property.
3565 DeclContext *DC, *LexicalDC;
3566 DeclarationName Name;
3569 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3574 // Check whether we have already imported this property.
3575 SmallVector<NamedDecl *, 2> FoundDecls;
3576 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3577 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3578 if (ObjCPropertyDecl *FoundProp
3579 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) {
3580 // Check property types.
3581 if (!Importer.IsStructurallyEquivalent(D->getType(),
3582 FoundProp->getType())) {
3583 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
3584 << Name << D->getType() << FoundProp->getType();
3585 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
3586 << FoundProp->getType();
3590 // FIXME: Check property attributes, getters, setters, etc.?
3592 // Consider these properties to be equivalent.
3593 Importer.Imported(D, FoundProp);
3599 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
3603 // Create the new property.
3604 ObjCPropertyDecl *ToProperty
3605 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc,
3606 Name.getAsIdentifierInfo(),
3607 Importer.Import(D->getAtLoc()),
3608 Importer.Import(D->getLParenLoc()),
3609 Importer.Import(D->getType()),
3611 D->getPropertyImplementation());
3612 Importer.Imported(D, ToProperty);
3613 ToProperty->setLexicalDeclContext(LexicalDC);
3614 LexicalDC->addDeclInternal(ToProperty);
3616 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
3617 ToProperty->setPropertyAttributesAsWritten(
3618 D->getPropertyAttributesAsWritten());
3619 ToProperty->setGetterName(Importer.Import(D->getGetterName()),
3620 Importer.Import(D->getGetterNameLoc()));
3621 ToProperty->setSetterName(Importer.Import(D->getSetterName()),
3622 Importer.Import(D->getSetterNameLoc()));
3623 ToProperty->setGetterMethodDecl(
3624 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
3625 ToProperty->setSetterMethodDecl(
3626 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
3627 ToProperty->setPropertyIvarDecl(
3628 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
3632 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
3633 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>(
3634 Importer.Import(D->getPropertyDecl()));
3638 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3642 // Import the lexical declaration context.
3643 DeclContext *LexicalDC = DC;
3644 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3645 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3650 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
3654 // Import the ivar (for an @synthesize).
3655 ObjCIvarDecl *Ivar = nullptr;
3656 if (D->getPropertyIvarDecl()) {
3657 Ivar = cast_or_null<ObjCIvarDecl>(
3658 Importer.Import(D->getPropertyIvarDecl()));
3663 ObjCPropertyImplDecl *ToImpl
3664 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
3665 Property->getQueryKind());
3667 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC,
3668 Importer.Import(D->getLocStart()),
3669 Importer.Import(D->getLocation()),
3671 D->getPropertyImplementation(),
3673 Importer.Import(D->getPropertyIvarDeclLoc()));
3674 ToImpl->setLexicalDeclContext(LexicalDC);
3675 Importer.Imported(D, ToImpl);
3676 LexicalDC->addDeclInternal(ToImpl);
3678 // Check that we have the same kind of property implementation (@synthesize
3680 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
3681 Importer.ToDiag(ToImpl->getLocation(),
3682 diag::err_odr_objc_property_impl_kind_inconsistent)
3683 << Property->getDeclName()
3684 << (ToImpl->getPropertyImplementation()
3685 == ObjCPropertyImplDecl::Dynamic);
3686 Importer.FromDiag(D->getLocation(),
3687 diag::note_odr_objc_property_impl_kind)
3688 << D->getPropertyDecl()->getDeclName()
3689 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
3693 // For @synthesize, check that we have the same
3694 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
3695 Ivar != ToImpl->getPropertyIvarDecl()) {
3696 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
3697 diag::err_odr_objc_synthesize_ivar_inconsistent)
3698 << Property->getDeclName()
3699 << ToImpl->getPropertyIvarDecl()->getDeclName()
3700 << Ivar->getDeclName();
3701 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
3702 diag::note_odr_objc_synthesize_ivar_here)
3703 << D->getPropertyIvarDecl()->getDeclName();
3707 // Merge the existing implementation with the new implementation.
3708 Importer.Imported(D, ToImpl);
3714 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
3715 // For template arguments, we adopt the translation unit as our declaration
3716 // context. This context will be fixed when the actual template declaration
3719 // FIXME: Import default argument.
3720 return TemplateTypeParmDecl::Create(Importer.getToContext(),
3721 Importer.getToContext().getTranslationUnitDecl(),
3722 Importer.Import(D->getLocStart()),
3723 Importer.Import(D->getLocation()),
3726 Importer.Import(D->getIdentifier()),
3727 D->wasDeclaredWithTypename(),
3728 D->isParameterPack());
3732 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
3733 // Import the name of this declaration.
3734 DeclarationName Name = Importer.Import(D->getDeclName());
3735 if (D->getDeclName() && !Name)
3738 // Import the location of this declaration.
3739 SourceLocation Loc = Importer.Import(D->getLocation());
3741 // Import the type of this declaration.
3742 QualType T = Importer.Import(D->getType());
3746 // Import type-source information.
3747 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3748 if (D->getTypeSourceInfo() && !TInfo)
3751 // FIXME: Import default argument.
3753 return NonTypeTemplateParmDecl::Create(Importer.getToContext(),
3754 Importer.getToContext().getTranslationUnitDecl(),
3755 Importer.Import(D->getInnerLocStart()),
3756 Loc, D->getDepth(), D->getPosition(),
3757 Name.getAsIdentifierInfo(),
3758 T, D->isParameterPack(), TInfo);
3762 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
3763 // Import the name of this declaration.
3764 DeclarationName Name = Importer.Import(D->getDeclName());
3765 if (D->getDeclName() && !Name)
3768 // Import the location of this declaration.
3769 SourceLocation Loc = Importer.Import(D->getLocation());
3771 // Import template parameters.
3772 TemplateParameterList *TemplateParams
3773 = ImportTemplateParameterList(D->getTemplateParameters());
3774 if (!TemplateParams)
3777 // FIXME: Import default argument.
3779 return TemplateTemplateParmDecl::Create(Importer.getToContext(),
3780 Importer.getToContext().getTranslationUnitDecl(),
3781 Loc, D->getDepth(), D->getPosition(),
3782 D->isParameterPack(),
3783 Name.getAsIdentifierInfo(),
3787 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
3788 // If this record has a definition in the translation unit we're coming from,
3789 // but this particular declaration is not that definition, import the
3790 // definition and map to that.
3791 CXXRecordDecl *Definition
3792 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
3793 if (Definition && Definition != D->getTemplatedDecl()) {
3795 = Importer.Import(Definition->getDescribedClassTemplate());
3799 return Importer.Imported(D, ImportedDef);
3802 // Import the major distinguishing characteristics of this class template.
3803 DeclContext *DC, *LexicalDC;
3804 DeclarationName Name;
3807 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3812 // We may already have a template of the same name; try to find and match it.
3813 if (!DC->isFunctionOrMethod()) {
3814 SmallVector<NamedDecl *, 4> ConflictingDecls;
3815 SmallVector<NamedDecl *, 2> FoundDecls;
3816 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3817 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3818 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3821 Decl *Found = FoundDecls[I];
3822 if (ClassTemplateDecl *FoundTemplate
3823 = dyn_cast<ClassTemplateDecl>(Found)) {
3824 if (IsStructuralMatch(D, FoundTemplate)) {
3825 // The class templates structurally match; call it the same template.
3826 // FIXME: We may be filling in a forward declaration here. Handle
3828 Importer.Imported(D->getTemplatedDecl(),
3829 FoundTemplate->getTemplatedDecl());
3830 return Importer.Imported(D, FoundTemplate);
3834 ConflictingDecls.push_back(FoundDecls[I]);
3837 if (!ConflictingDecls.empty()) {
3838 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
3839 ConflictingDecls.data(),
3840 ConflictingDecls.size());
3847 CXXRecordDecl *DTemplated = D->getTemplatedDecl();
3849 // Create the declaration that is being templated.
3850 CXXRecordDecl *D2Templated = cast_or_null<CXXRecordDecl>(
3851 Importer.Import(DTemplated));
3855 // Resolve possible cyclic import.
3856 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D))
3857 return AlreadyImported;
3859 // Create the class template declaration itself.
3860 TemplateParameterList *TemplateParams
3861 = ImportTemplateParameterList(D->getTemplateParameters());
3862 if (!TemplateParams)
3865 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC,
3866 Loc, Name, TemplateParams,
3868 D2Templated->setDescribedClassTemplate(D2);
3870 D2->setAccess(D->getAccess());
3871 D2->setLexicalDeclContext(LexicalDC);
3872 LexicalDC->addDeclInternal(D2);
3874 // Note the relationship between the class templates.
3875 Importer.Imported(D, D2);
3876 Importer.Imported(DTemplated, D2Templated);
3878 if (DTemplated->isCompleteDefinition() &&
3879 !D2Templated->isCompleteDefinition()) {
3880 // FIXME: Import definition!
3886 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
3887 ClassTemplateSpecializationDecl *D) {
3888 // If this record has a definition in the translation unit we're coming from,
3889 // but this particular declaration is not that definition, import the
3890 // definition and map to that.
3891 TagDecl *Definition = D->getDefinition();
3892 if (Definition && Definition != D) {
3893 Decl *ImportedDef = Importer.Import(Definition);
3897 return Importer.Imported(D, ImportedDef);
3900 ClassTemplateDecl *ClassTemplate
3901 = cast_or_null<ClassTemplateDecl>(Importer.Import(
3902 D->getSpecializedTemplate()));
3906 // Import the context of this declaration.
3907 DeclContext *DC = ClassTemplate->getDeclContext();
3911 DeclContext *LexicalDC = DC;
3912 if (D->getDeclContext() != D->getLexicalDeclContext()) {
3913 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3918 // Import the location of this declaration.
3919 SourceLocation StartLoc = Importer.Import(D->getLocStart());
3920 SourceLocation IdLoc = Importer.Import(D->getLocation());
3922 // Import template arguments.
3923 SmallVector<TemplateArgument, 2> TemplateArgs;
3924 if (ImportTemplateArguments(D->getTemplateArgs().data(),
3925 D->getTemplateArgs().size(),
3929 // Try to find an existing specialization with these template arguments.
3930 void *InsertPos = nullptr;
3931 ClassTemplateSpecializationDecl *D2
3932 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
3934 // We already have a class template specialization with these template
3937 // FIXME: Check for specialization vs. instantiation errors.
3939 if (RecordDecl *FoundDef = D2->getDefinition()) {
3940 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
3941 // The record types structurally match, or the "from" translation
3942 // unit only had a forward declaration anyway; call it the same
3944 return Importer.Imported(D, FoundDef);
3948 // Create a new specialization.
3949 if (ClassTemplatePartialSpecializationDecl *PartialSpec =
3950 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
3952 // Import TemplateArgumentListInfo
3953 TemplateArgumentListInfo ToTAInfo;
3954 auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
3955 for (unsigned I = 0, E = ASTTemplateArgs.NumTemplateArgs; I < E; ++I) {
3956 if (auto ToLoc = ImportTemplateArgumentLoc(ASTTemplateArgs[I]))
3957 ToTAInfo.addArgument(*ToLoc);
3962 QualType CanonInjType = Importer.Import(
3963 PartialSpec->getInjectedSpecializationType());
3964 if (CanonInjType.isNull())
3966 CanonInjType = CanonInjType.getCanonicalType();
3968 TemplateParameterList *ToTPList = ImportTemplateParameterList(
3969 PartialSpec->getTemplateParameters());
3970 if (!ToTPList && PartialSpec->getTemplateParameters())
3973 D2 = ClassTemplatePartialSpecializationDecl::Create(
3974 Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc,
3975 ToTPList, ClassTemplate,
3976 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
3977 ToTAInfo, CanonInjType, nullptr);
3980 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(),
3981 D->getTagKind(), DC,
3985 /*PrevDecl=*/nullptr);
3988 D2->setSpecializationKind(D->getSpecializationKind());
3990 // Add this specialization to the class template.
3991 ClassTemplate->AddSpecialization(D2, InsertPos);
3993 // Import the qualifier, if any.
3994 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3996 Importer.Imported(D, D2);
3998 if (auto *TSI = D->getTypeAsWritten()) {
3999 TypeSourceInfo *TInfo = Importer.Import(TSI);
4002 D2->setTypeAsWritten(TInfo);
4003 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4004 D2->setExternLoc(Importer.Import(D->getExternLoc()));
4007 SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4009 D2->setPointOfInstantiation(POI);
4010 else if (D->getPointOfInstantiation().isValid())
4013 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4015 // Add the specialization to this context.
4016 D2->setLexicalDeclContext(LexicalDC);
4017 LexicalDC->addDeclInternal(D2);
4019 Importer.Imported(D, D2);
4020 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4026 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4027 // If this variable has a definition in the translation unit we're coming
4029 // but this particular declaration is not that definition, import the
4030 // definition and map to that.
4031 VarDecl *Definition =
4032 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4033 if (Definition && Definition != D->getTemplatedDecl()) {
4034 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4038 return Importer.Imported(D, ImportedDef);
4041 // Import the major distinguishing characteristics of this variable template.
4042 DeclContext *DC, *LexicalDC;
4043 DeclarationName Name;
4046 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4051 // We may already have a template of the same name; try to find and match it.
4052 assert(!DC->isFunctionOrMethod() &&
4053 "Variable templates cannot be declared at function scope");
4054 SmallVector<NamedDecl *, 4> ConflictingDecls;
4055 SmallVector<NamedDecl *, 2> FoundDecls;
4056 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4057 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4058 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4061 Decl *Found = FoundDecls[I];
4062 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4063 if (IsStructuralMatch(D, FoundTemplate)) {
4064 // The variable templates structurally match; call it the same template.
4065 Importer.Imported(D->getTemplatedDecl(),
4066 FoundTemplate->getTemplatedDecl());
4067 return Importer.Imported(D, FoundTemplate);
4071 ConflictingDecls.push_back(FoundDecls[I]);
4074 if (!ConflictingDecls.empty()) {
4075 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4076 ConflictingDecls.data(),
4077 ConflictingDecls.size());
4083 VarDecl *DTemplated = D->getTemplatedDecl();
4086 QualType T = Importer.Import(DTemplated->getType());
4090 // Create the declaration that is being templated.
4091 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart());
4092 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation());
4093 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo());
4094 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc,
4095 IdLoc, Name.getAsIdentifierInfo(), T,
4096 TInfo, DTemplated->getStorageClass());
4097 D2Templated->setAccess(DTemplated->getAccess());
4098 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc()));
4099 D2Templated->setLexicalDeclContext(LexicalDC);
4101 // Importer.Imported(DTemplated, D2Templated);
4102 // LexicalDC->addDeclInternal(D2Templated);
4104 // Merge the initializer.
4105 if (ImportDefinition(DTemplated, D2Templated))
4108 // Create the variable template declaration itself.
4109 TemplateParameterList *TemplateParams =
4110 ImportTemplateParameterList(D->getTemplateParameters());
4111 if (!TemplateParams)
4114 VarTemplateDecl *D2 = VarTemplateDecl::Create(
4115 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated);
4116 D2Templated->setDescribedVarTemplate(D2);
4118 D2->setAccess(D->getAccess());
4119 D2->setLexicalDeclContext(LexicalDC);
4120 LexicalDC->addDeclInternal(D2);
4122 // Note the relationship between the variable templates.
4123 Importer.Imported(D, D2);
4124 Importer.Imported(DTemplated, D2Templated);
4126 if (DTemplated->isThisDeclarationADefinition() &&
4127 !D2Templated->isThisDeclarationADefinition()) {
4128 // FIXME: Import definition!
4134 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4135 VarTemplateSpecializationDecl *D) {
4136 // If this record has a definition in the translation unit we're coming from,
4137 // but this particular declaration is not that definition, import the
4138 // definition and map to that.
4139 VarDecl *Definition = D->getDefinition();
4140 if (Definition && Definition != D) {
4141 Decl *ImportedDef = Importer.Import(Definition);
4145 return Importer.Imported(D, ImportedDef);
4148 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>(
4149 Importer.Import(D->getSpecializedTemplate()));
4153 // Import the context of this declaration.
4154 DeclContext *DC = VarTemplate->getDeclContext();
4158 DeclContext *LexicalDC = DC;
4159 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4160 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4165 // Import the location of this declaration.
4166 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4167 SourceLocation IdLoc = Importer.Import(D->getLocation());
4169 // Import template arguments.
4170 SmallVector<TemplateArgument, 2> TemplateArgs;
4171 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4172 D->getTemplateArgs().size(), TemplateArgs))
4175 // Try to find an existing specialization with these template arguments.
4176 void *InsertPos = nullptr;
4177 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4178 TemplateArgs, InsertPos);
4180 // We already have a variable template specialization with these template
4183 // FIXME: Check for specialization vs. instantiation errors.
4185 if (VarDecl *FoundDef = D2->getDefinition()) {
4186 if (!D->isThisDeclarationADefinition() ||
4187 IsStructuralMatch(D, FoundDef)) {
4188 // The record types structurally match, or the "from" translation
4189 // unit only had a forward declaration anyway; call it the same
4191 return Importer.Imported(D, FoundDef);
4197 QualType T = Importer.Import(D->getType());
4200 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4202 // Create a new specialization.
4203 D2 = VarTemplateSpecializationDecl::Create(
4204 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo,
4205 D->getStorageClass(), TemplateArgs);
4206 D2->setSpecializationKind(D->getSpecializationKind());
4207 D2->setTemplateArgsInfo(D->getTemplateArgsInfo());
4209 // Add this specialization to the class template.
4210 VarTemplate->AddSpecialization(D2, InsertPos);
4212 // Import the qualifier, if any.
4213 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4215 // Add the specialization to this context.
4216 D2->setLexicalDeclContext(LexicalDC);
4217 LexicalDC->addDeclInternal(D2);
4219 Importer.Imported(D, D2);
4221 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2))
4227 Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
4228 DeclContext *DC, *LexicalDC;
4229 DeclarationName Name;
4233 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4239 // Try to find a function in our own ("to") context with the same name, same
4240 // type, and in the same context as the function we're importing.
4241 if (!LexicalDC->isFunctionOrMethod()) {
4242 unsigned IDNS = Decl::IDNS_Ordinary;
4243 SmallVector<NamedDecl *, 2> FoundDecls;
4244 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4245 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4246 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS))
4249 if (FunctionTemplateDecl *FoundFunction =
4250 dyn_cast<FunctionTemplateDecl>(FoundDecls[I])) {
4251 if (FoundFunction->hasExternalFormalLinkage() &&
4252 D->hasExternalFormalLinkage()) {
4253 if (IsStructuralMatch(D, FoundFunction)) {
4254 Importer.Imported(D, FoundFunction);
4255 // FIXME: Actually try to merge the body and other attributes.
4256 return FoundFunction;
4263 TemplateParameterList *Params =
4264 ImportTemplateParameterList(D->getTemplateParameters());
4268 FunctionDecl *TemplatedFD =
4269 cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
4273 FunctionTemplateDecl *ToFunc = FunctionTemplateDecl::Create(
4274 Importer.getToContext(), DC, Loc, Name, Params, TemplatedFD);
4276 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
4277 ToFunc->setAccess(D->getAccess());
4278 ToFunc->setLexicalDeclContext(LexicalDC);
4279 Importer.Imported(D, ToFunc);
4281 LexicalDC->addDeclInternal(ToFunc);
4285 //----------------------------------------------------------------------------
4286 // Import Statements
4287 //----------------------------------------------------------------------------
4289 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4291 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4292 size_t NumDecls = DG.end() - DG.begin();
4293 SmallVector<Decl *, 1> ToDecls(NumDecls);
4294 auto &_Importer = this->Importer;
4295 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4296 [&_Importer](Decl *D) -> Decl * {
4297 return _Importer.Import(D);
4299 return DeclGroupRef::Create(Importer.getToContext(),
4304 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4305 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4306 << S->getStmtClassName();
4311 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
4312 SmallVector<IdentifierInfo *, 4> Names;
4313 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4314 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4315 // ToII is nullptr when no symbolic name is given for output operand
4316 // see ParseStmtAsm::ParseAsmOperandsOpt
4317 if (!ToII && S->getOutputIdentifier(I))
4319 Names.push_back(ToII);
4321 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4322 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4323 // ToII is nullptr when no symbolic name is given for input operand
4324 // see ParseStmtAsm::ParseAsmOperandsOpt
4325 if (!ToII && S->getInputIdentifier(I))
4327 Names.push_back(ToII);
4330 SmallVector<StringLiteral *, 4> Clobbers;
4331 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
4332 StringLiteral *Clobber = cast_or_null<StringLiteral>(
4333 Importer.Import(S->getClobberStringLiteral(I)));
4336 Clobbers.push_back(Clobber);
4339 SmallVector<StringLiteral *, 4> Constraints;
4340 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4341 StringLiteral *Output = cast_or_null<StringLiteral>(
4342 Importer.Import(S->getOutputConstraintLiteral(I)));
4345 Constraints.push_back(Output);
4348 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4349 StringLiteral *Input = cast_or_null<StringLiteral>(
4350 Importer.Import(S->getInputConstraintLiteral(I)));
4353 Constraints.push_back(Input);
4356 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
4357 if (ImportContainerChecked(S->outputs(), Exprs))
4360 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
4363 StringLiteral *AsmStr = cast_or_null<StringLiteral>(
4364 Importer.Import(S->getAsmString()));
4368 return new (Importer.getToContext()) GCCAsmStmt(
4369 Importer.getToContext(),
4370 Importer.Import(S->getAsmLoc()),
4379 S->getNumClobbers(),
4381 Importer.Import(S->getRParenLoc()));
4384 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
4385 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
4386 for (Decl *ToD : ToDG) {
4390 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4391 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
4392 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
4395 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
4396 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
4397 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
4398 S->hasLeadingEmptyMacro());
4401 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
4402 llvm::SmallVector<Stmt *, 8> ToStmts(S->size());
4404 if (ImportContainerChecked(S->body(), ToStmts))
4407 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
4408 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
4409 return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
4413 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
4414 Expr *ToLHS = Importer.Import(S->getLHS());
4417 Expr *ToRHS = Importer.Import(S->getRHS());
4418 if (!ToRHS && S->getRHS())
4420 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4421 if (!ToSubStmt && S->getSubStmt())
4423 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
4424 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
4425 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4426 CaseStmt *ToStmt = new (Importer.getToContext())
4427 CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
4428 ToStmt->setSubStmt(ToSubStmt);
4432 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
4433 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
4434 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4435 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4436 if (!ToSubStmt && S->getSubStmt())
4438 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
4442 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
4443 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
4444 LabelDecl *ToLabelDecl =
4445 cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
4446 if (!ToLabelDecl && S->getDecl())
4448 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4449 if (!ToSubStmt && S->getSubStmt())
4451 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
4455 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
4456 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
4457 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
4458 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
4459 ASTContext &_ToContext = Importer.getToContext();
4460 std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(),
4461 [&_ToContext](const Attr *A) -> const Attr * {
4462 return A->clone(_ToContext);
4464 for (const Attr *ToA : ToAttrs) {
4468 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4469 if (!ToSubStmt && S->getSubStmt())
4471 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
4472 ToAttrs, ToSubStmt);
4475 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
4476 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
4477 Stmt *ToInit = Importer.Import(S->getInit());
4478 if (!ToInit && S->getInit())
4480 VarDecl *ToConditionVariable = nullptr;
4481 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4482 ToConditionVariable =
4483 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4484 if (!ToConditionVariable)
4487 Expr *ToCondition = Importer.Import(S->getCond());
4488 if (!ToCondition && S->getCond())
4490 Stmt *ToThenStmt = Importer.Import(S->getThen());
4491 if (!ToThenStmt && S->getThen())
4493 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
4494 Stmt *ToElseStmt = Importer.Import(S->getElse());
4495 if (!ToElseStmt && S->getElse())
4497 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
4498 ToIfLoc, S->isConstexpr(),
4500 ToConditionVariable,
4501 ToCondition, ToThenStmt,
4502 ToElseLoc, ToElseStmt);
4505 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
4506 Stmt *ToInit = Importer.Import(S->getInit());
4507 if (!ToInit && S->getInit())
4509 VarDecl *ToConditionVariable = nullptr;
4510 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4511 ToConditionVariable =
4512 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4513 if (!ToConditionVariable)
4516 Expr *ToCondition = Importer.Import(S->getCond());
4517 if (!ToCondition && S->getCond())
4519 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
4520 Importer.getToContext(), ToInit,
4521 ToConditionVariable, ToCondition);
4522 Stmt *ToBody = Importer.Import(S->getBody());
4523 if (!ToBody && S->getBody())
4525 ToStmt->setBody(ToBody);
4526 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
4527 // Now we have to re-chain the cases.
4528 SwitchCase *LastChainedSwitchCase = nullptr;
4529 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
4530 SC = SC->getNextSwitchCase()) {
4531 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
4534 if (LastChainedSwitchCase)
4535 LastChainedSwitchCase->setNextSwitchCase(ToSC);
4537 ToStmt->setSwitchCaseList(ToSC);
4538 LastChainedSwitchCase = ToSC;
4543 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
4544 VarDecl *ToConditionVariable = nullptr;
4545 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4546 ToConditionVariable =
4547 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4548 if (!ToConditionVariable)
4551 Expr *ToCondition = Importer.Import(S->getCond());
4552 if (!ToCondition && S->getCond())
4554 Stmt *ToBody = Importer.Import(S->getBody());
4555 if (!ToBody && S->getBody())
4557 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4558 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
4559 ToConditionVariable,
4560 ToCondition, ToBody,
4564 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
4565 Stmt *ToBody = Importer.Import(S->getBody());
4566 if (!ToBody && S->getBody())
4568 Expr *ToCondition = Importer.Import(S->getCond());
4569 if (!ToCondition && S->getCond())
4571 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
4572 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
4573 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4574 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
4575 ToDoLoc, ToWhileLoc,
4579 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
4580 Stmt *ToInit = Importer.Import(S->getInit());
4581 if (!ToInit && S->getInit())
4583 Expr *ToCondition = Importer.Import(S->getCond());
4584 if (!ToCondition && S->getCond())
4586 VarDecl *ToConditionVariable = nullptr;
4587 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
4588 ToConditionVariable =
4589 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
4590 if (!ToConditionVariable)
4593 Expr *ToInc = Importer.Import(S->getInc());
4594 if (!ToInc && S->getInc())
4596 Stmt *ToBody = Importer.Import(S->getBody());
4597 if (!ToBody && S->getBody())
4599 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4600 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
4601 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4602 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
4603 ToInit, ToCondition,
4604 ToConditionVariable,
4606 ToForLoc, ToLParenLoc,
4610 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
4611 LabelDecl *ToLabel = nullptr;
4612 if (LabelDecl *FromLabel = S->getLabel()) {
4613 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
4617 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4618 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
4619 return new (Importer.getToContext()) GotoStmt(ToLabel,
4620 ToGotoLoc, ToLabelLoc);
4623 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
4624 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
4625 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
4626 Expr *ToTarget = Importer.Import(S->getTarget());
4627 if (!ToTarget && S->getTarget())
4629 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
4633 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
4634 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
4635 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
4638 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
4639 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
4640 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
4643 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
4644 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
4645 Expr *ToRetExpr = Importer.Import(S->getRetValue());
4646 if (!ToRetExpr && S->getRetValue())
4648 VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate());
4649 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
4650 if (!ToNRVOCandidate && NRVOCandidate)
4652 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
4656 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
4657 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
4658 VarDecl *ToExceptionDecl = nullptr;
4659 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
4661 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4662 if (!ToExceptionDecl)
4665 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
4666 if (!ToHandlerBlock && S->getHandlerBlock())
4668 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
4673 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
4674 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
4675 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
4676 if (!ToTryBlock && S->getTryBlock())
4678 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
4679 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
4680 CXXCatchStmt *FromHandler = S->getHandler(HI);
4681 if (Stmt *ToHandler = Importer.Import(FromHandler))
4682 ToHandlers[HI] = ToHandler;
4686 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
4690 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
4692 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
4693 if (!ToRange && S->getRangeStmt())
4696 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
4697 if (!ToBegin && S->getBeginStmt())
4700 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
4701 if (!ToEnd && S->getEndStmt())
4703 Expr *ToCond = Importer.Import(S->getCond());
4704 if (!ToCond && S->getCond())
4706 Expr *ToInc = Importer.Import(S->getInc());
4707 if (!ToInc && S->getInc())
4709 DeclStmt *ToLoopVar =
4710 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
4711 if (!ToLoopVar && S->getLoopVarStmt())
4713 Stmt *ToBody = Importer.Import(S->getBody());
4714 if (!ToBody && S->getBody())
4716 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4717 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
4718 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
4719 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4720 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
4723 ToForLoc, ToCoawaitLoc,
4724 ToColonLoc, ToRParenLoc);
4727 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
4728 Stmt *ToElem = Importer.Import(S->getElement());
4729 if (!ToElem && S->getElement())
4731 Expr *ToCollect = Importer.Import(S->getCollection());
4732 if (!ToCollect && S->getCollection())
4734 Stmt *ToBody = Importer.Import(S->getBody());
4735 if (!ToBody && S->getBody())
4737 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
4738 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4739 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
4745 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
4746 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
4747 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
4748 VarDecl *ToExceptionDecl = nullptr;
4749 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
4751 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
4752 if (!ToExceptionDecl)
4755 Stmt *ToBody = Importer.Import(S->getCatchBody());
4756 if (!ToBody && S->getCatchBody())
4758 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
4764 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
4765 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
4766 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
4767 if (!ToAtFinallyStmt && S->getFinallyBody())
4769 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
4773 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
4774 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
4775 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
4776 if (!ToAtTryStmt && S->getTryBody())
4778 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
4779 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
4780 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
4781 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
4782 ToCatchStmts[CI] = ToCatchStmt;
4786 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
4787 if (!ToAtFinallyStmt && S->getFinallyStmt())
4789 return ObjCAtTryStmt::Create(Importer.getToContext(),
4790 ToAtTryLoc, ToAtTryStmt,
4791 ToCatchStmts.begin(), ToCatchStmts.size(),
4795 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
4796 (ObjCAtSynchronizedStmt *S) {
4797 SourceLocation ToAtSynchronizedLoc =
4798 Importer.Import(S->getAtSynchronizedLoc());
4799 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
4800 if (!ToSynchExpr && S->getSynchExpr())
4802 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
4803 if (!ToSynchBody && S->getSynchBody())
4805 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
4806 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
4809 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
4810 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
4811 Expr *ToThrow = Importer.Import(S->getThrowExpr());
4812 if (!ToThrow && S->getThrowExpr())
4814 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
4817 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
4818 (ObjCAutoreleasePoolStmt *S) {
4819 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
4820 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
4821 if (!ToSubStmt && S->getSubStmt())
4823 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
4827 //----------------------------------------------------------------------------
4828 // Import Expressions
4829 //----------------------------------------------------------------------------
4830 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
4831 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
4832 << E->getStmtClassName();
4836 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
4837 QualType T = Importer.Import(E->getType());
4841 Expr *SubExpr = Importer.Import(E->getSubExpr());
4842 if (!SubExpr && E->getSubExpr())
4845 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
4849 return new (Importer.getToContext()) VAArgExpr(
4850 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
4851 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
4855 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
4856 QualType T = Importer.Import(E->getType());
4860 return new (Importer.getToContext()) GNUNullExpr(
4861 T, Importer.Import(E->getLocStart()));
4864 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
4865 QualType T = Importer.Import(E->getType());
4869 StringLiteral *SL = cast_or_null<StringLiteral>(
4870 Importer.Import(E->getFunctionName()));
4871 if (!SL && E->getFunctionName())
4874 return new (Importer.getToContext()) PredefinedExpr(
4875 Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
4878 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
4879 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
4883 NamedDecl *FoundD = nullptr;
4884 if (E->getDecl() != E->getFoundDecl()) {
4885 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
4890 QualType T = Importer.Import(E->getType());
4895 TemplateArgumentListInfo ToTAInfo;
4896 TemplateArgumentListInfo *ResInfo = nullptr;
4897 if (E->hasExplicitTemplateArgs()) {
4898 for (const auto &FromLoc : E->template_arguments()) {
4899 if (auto ToTALoc = ImportTemplateArgumentLoc(FromLoc))
4900 ToTAInfo.addArgument(*ToTALoc);
4904 ResInfo = &ToTAInfo;
4907 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
4908 Importer.Import(E->getQualifierLoc()),
4909 Importer.Import(E->getTemplateKeywordLoc()),
4911 E->refersToEnclosingVariableOrCapture(),
4912 Importer.Import(E->getLocation()),
4913 T, E->getValueKind(),
4915 if (E->hadMultipleCandidates())
4916 DRE->setHadMultipleCandidates(true);
4920 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
4921 QualType T = Importer.Import(E->getType());
4925 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
4928 ASTNodeImporter::Designator
4929 ASTNodeImporter::ImportDesignator(const Designator &D) {
4930 if (D.isFieldDesignator()) {
4931 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
4932 // Caller checks for import error
4933 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
4934 Importer.Import(D.getFieldLoc()));
4936 if (D.isArrayDesignator())
4937 return Designator(D.getFirstExprIndex(),
4938 Importer.Import(D.getLBracketLoc()),
4939 Importer.Import(D.getRBracketLoc()));
4941 assert(D.isArrayRangeDesignator());
4942 return Designator(D.getFirstExprIndex(),
4943 Importer.Import(D.getLBracketLoc()),
4944 Importer.Import(D.getEllipsisLoc()),
4945 Importer.Import(D.getRBracketLoc()));
4949 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
4950 Expr *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
4954 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
4955 // List elements from the second, the first is Init itself
4956 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
4957 if (Expr *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
4958 IndexExprs[I - 1] = Arg;
4963 SmallVector<Designator, 4> Designators(DIE->size());
4964 llvm::transform(DIE->designators(), Designators.begin(),
4965 [this](const Designator &D) -> Designator {
4966 return ImportDesignator(D);
4969 for (const Designator &D : DIE->designators())
4970 if (D.isFieldDesignator() && !D.getFieldName())
4973 return DesignatedInitExpr::Create(
4974 Importer.getToContext(), Designators,
4975 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
4976 DIE->usesGNUSyntax(), Init);
4979 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
4980 QualType T = Importer.Import(E->getType());
4984 return new (Importer.getToContext())
4985 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
4988 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
4989 QualType T = Importer.Import(E->getType());
4993 return IntegerLiteral::Create(Importer.getToContext(),
4995 Importer.Import(E->getLocation()));
4998 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
4999 QualType T = Importer.Import(E->getType());
5003 return FloatingLiteral::Create(Importer.getToContext(),
5004 E->getValue(), E->isExact(), T,
5005 Importer.Import(E->getLocation()));
5008 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5009 QualType T = Importer.Import(E->getType());
5013 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5015 Importer.Import(E->getLocation()));
5018 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5019 QualType T = Importer.Import(E->getType());
5023 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5024 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5026 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5027 E->getKind(), E->isPascal(), T,
5028 Locations.data(), Locations.size());
5031 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5032 QualType T = Importer.Import(E->getType());
5036 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5040 Expr *Init = Importer.Import(E->getInitializer());
5044 return new (Importer.getToContext()) CompoundLiteralExpr(
5045 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5046 Init, E->isFileScope());
5049 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5050 QualType T = Importer.Import(E->getType());
5054 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5055 if (ImportArrayChecked(
5056 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5060 return new (Importer.getToContext()) AtomicExpr(
5061 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5062 Importer.Import(E->getRParenLoc()));
5065 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5066 QualType T = Importer.Import(E->getType());
5070 LabelDecl *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5074 return new (Importer.getToContext()) AddrLabelExpr(
5075 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5079 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5080 Expr *SubExpr = Importer.Import(E->getSubExpr());
5084 return new (Importer.getToContext())
5085 ParenExpr(Importer.Import(E->getLParen()),
5086 Importer.Import(E->getRParen()),
5090 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5091 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5092 if (ImportContainerChecked(E->exprs(), Exprs))
5095 return new (Importer.getToContext()) ParenListExpr(
5096 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5097 Exprs, Importer.Import(E->getLParenLoc()));
5100 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5101 QualType T = Importer.Import(E->getType());
5105 CompoundStmt *ToSubStmt = cast_or_null<CompoundStmt>(
5106 Importer.Import(E->getSubStmt()));
5107 if (!ToSubStmt && E->getSubStmt())
5110 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5111 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5114 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5115 QualType T = Importer.Import(E->getType());
5119 Expr *SubExpr = Importer.Import(E->getSubExpr());
5123 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(),
5124 T, E->getValueKind(),
5126 Importer.Import(E->getOperatorLoc()));
5129 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(
5130 UnaryExprOrTypeTraitExpr *E) {
5131 QualType ResultType = Importer.Import(E->getType());
5133 if (E->isArgumentType()) {
5134 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5138 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5140 Importer.Import(E->getOperatorLoc()),
5141 Importer.Import(E->getRParenLoc()));
5144 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5148 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5149 SubExpr, ResultType,
5150 Importer.Import(E->getOperatorLoc()),
5151 Importer.Import(E->getRParenLoc()));
5154 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5155 QualType T = Importer.Import(E->getType());
5159 Expr *LHS = Importer.Import(E->getLHS());
5163 Expr *RHS = Importer.Import(E->getRHS());
5167 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5168 T, E->getValueKind(),
5170 Importer.Import(E->getOperatorLoc()),
5171 E->getFPFeatures());
5174 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
5175 QualType T = Importer.Import(E->getType());
5179 Expr *ToLHS = Importer.Import(E->getLHS());
5183 Expr *ToRHS = Importer.Import(E->getRHS());
5187 Expr *ToCond = Importer.Import(E->getCond());
5191 return new (Importer.getToContext()) ConditionalOperator(
5192 ToCond, Importer.Import(E->getQuestionLoc()),
5193 ToLHS, Importer.Import(E->getColonLoc()),
5194 ToRHS, T, E->getValueKind(), E->getObjectKind());
5197 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
5198 BinaryConditionalOperator *E) {
5199 QualType T = Importer.Import(E->getType());
5203 Expr *Common = Importer.Import(E->getCommon());
5207 Expr *Cond = Importer.Import(E->getCond());
5211 OpaqueValueExpr *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5212 Importer.Import(E->getOpaqueValue()));
5216 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5220 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5224 return new (Importer.getToContext()) BinaryConditionalOperator(
5225 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5226 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5227 T, E->getValueKind(), E->getObjectKind());
5230 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
5231 QualType T = Importer.Import(E->getType());
5235 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
5239 Expr *Dim = Importer.Import(E->getDimensionExpression());
5240 if (!Dim && E->getDimensionExpression())
5243 return new (Importer.getToContext()) ArrayTypeTraitExpr(
5244 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5245 E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
5248 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
5249 QualType T = Importer.Import(E->getType());
5253 Expr *ToQueried = Importer.Import(E->getQueriedExpression());
5257 return new (Importer.getToContext()) ExpressionTraitExpr(
5258 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5259 E->getValue(), Importer.Import(E->getLocEnd()), T);
5262 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
5263 QualType T = Importer.Import(E->getType());
5267 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5268 if (!SourceExpr && E->getSourceExpr())
5271 return new (Importer.getToContext()) OpaqueValueExpr(
5272 Importer.Import(E->getLocation()), T, E->getValueKind(),
5273 E->getObjectKind(), SourceExpr);
5276 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
5277 QualType T = Importer.Import(E->getType());
5281 Expr *ToLHS = Importer.Import(E->getLHS());
5285 Expr *ToRHS = Importer.Import(E->getRHS());
5289 return new (Importer.getToContext()) ArraySubscriptExpr(
5290 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
5291 Importer.Import(E->getRBracketLoc()));
5294 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5295 QualType T = Importer.Import(E->getType());
5299 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5300 if (CompLHSType.isNull())
5303 QualType CompResultType = Importer.Import(E->getComputationResultType());
5304 if (CompResultType.isNull())
5307 Expr *LHS = Importer.Import(E->getLHS());
5311 Expr *RHS = Importer.Import(E->getRHS());
5315 return new (Importer.getToContext())
5316 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5317 T, E->getValueKind(),
5319 CompLHSType, CompResultType,
5320 Importer.Import(E->getOperatorLoc()),
5321 E->getFPFeatures());
5324 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
5325 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
5326 if (CXXBaseSpecifier *Spec = Importer.Import(*I))
5327 Path.push_back(Spec);
5334 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
5335 QualType T = Importer.Import(E->getType());
5339 Expr *SubExpr = Importer.Import(E->getSubExpr());
5343 CXXCastPath BasePath;
5344 if (ImportCastPath(E, BasePath))
5347 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5348 SubExpr, &BasePath, E->getValueKind());
5351 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
5352 QualType T = Importer.Import(E->getType());
5356 Expr *SubExpr = Importer.Import(E->getSubExpr());
5360 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5361 if (!TInfo && E->getTypeInfoAsWritten())
5364 CXXCastPath BasePath;
5365 if (ImportCastPath(E, BasePath))
5368 switch (E->getStmtClass()) {
5369 case Stmt::CStyleCastExprClass: {
5370 CStyleCastExpr *CCE = cast<CStyleCastExpr>(E);
5371 return CStyleCastExpr::Create(Importer.getToContext(), T,
5372 E->getValueKind(), E->getCastKind(),
5373 SubExpr, &BasePath, TInfo,
5374 Importer.Import(CCE->getLParenLoc()),
5375 Importer.Import(CCE->getRParenLoc()));
5378 case Stmt::CXXFunctionalCastExprClass: {
5379 CXXFunctionalCastExpr *FCE = cast<CXXFunctionalCastExpr>(E);
5380 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
5381 E->getValueKind(), TInfo,
5382 E->getCastKind(), SubExpr, &BasePath,
5383 Importer.Import(FCE->getLParenLoc()),
5384 Importer.Import(FCE->getRParenLoc()));
5387 case Stmt::ObjCBridgedCastExprClass: {
5388 ObjCBridgedCastExpr *OCE = cast<ObjCBridgedCastExpr>(E);
5389 return new (Importer.getToContext()) ObjCBridgedCastExpr(
5390 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
5391 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
5395 break; // just fall through
5398 CXXNamedCastExpr *Named = cast<CXXNamedCastExpr>(E);
5399 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
5400 RParenLoc = Importer.Import(Named->getRParenLoc());
5401 SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
5403 switch (E->getStmtClass()) {
5404 case Stmt::CXXStaticCastExprClass:
5405 return CXXStaticCastExpr::Create(Importer.getToContext(), T,
5406 E->getValueKind(), E->getCastKind(),
5407 SubExpr, &BasePath, TInfo,
5408 ExprLoc, RParenLoc, Brackets);
5410 case Stmt::CXXDynamicCastExprClass:
5411 return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
5412 E->getValueKind(), E->getCastKind(),
5413 SubExpr, &BasePath, TInfo,
5414 ExprLoc, RParenLoc, Brackets);
5416 case Stmt::CXXReinterpretCastExprClass:
5417 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
5418 E->getValueKind(), E->getCastKind(),
5419 SubExpr, &BasePath, TInfo,
5420 ExprLoc, RParenLoc, Brackets);
5422 case Stmt::CXXConstCastExprClass:
5423 return CXXConstCastExpr::Create(Importer.getToContext(), T,
5424 E->getValueKind(), SubExpr, TInfo, ExprLoc,
5425 RParenLoc, Brackets);
5427 llvm_unreachable("Cast expression of unsupported type!");
5432 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
5433 QualType T = Importer.Import(OE->getType());
5437 SmallVector<OffsetOfNode, 4> Nodes;
5438 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
5439 const OffsetOfNode &Node = OE->getComponent(I);
5441 switch (Node.getKind()) {
5442 case OffsetOfNode::Array:
5443 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
5444 Node.getArrayExprIndex(),
5445 Importer.Import(Node.getLocEnd())));
5448 case OffsetOfNode::Base: {
5449 CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
5450 if (!BS && Node.getBase())
5452 Nodes.push_back(OffsetOfNode(BS));
5455 case OffsetOfNode::Field: {
5456 FieldDecl *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
5459 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
5460 Importer.Import(Node.getLocEnd())));
5463 case OffsetOfNode::Identifier: {
5464 IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
5467 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
5468 Importer.Import(Node.getLocEnd())));
5474 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
5475 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
5476 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
5479 Exprs[I] = ToIndexExpr;
5482 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
5483 if (!TInfo && OE->getTypeSourceInfo())
5486 return OffsetOfExpr::Create(Importer.getToContext(), T,
5487 Importer.Import(OE->getOperatorLoc()),
5488 TInfo, Nodes, Exprs,
5489 Importer.Import(OE->getRParenLoc()));
5492 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
5493 QualType T = Importer.Import(E->getType());
5497 Expr *Operand = Importer.Import(E->getOperand());
5501 CanThrowResult CanThrow;
5502 if (E->isValueDependent())
5503 CanThrow = CT_Dependent;
5505 CanThrow = E->getValue() ? CT_Can : CT_Cannot;
5507 return new (Importer.getToContext()) CXXNoexceptExpr(
5508 T, Operand, CanThrow,
5509 Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
5512 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
5513 QualType T = Importer.Import(E->getType());
5517 Expr *SubExpr = Importer.Import(E->getSubExpr());
5518 if (!SubExpr && E->getSubExpr())
5521 return new (Importer.getToContext()) CXXThrowExpr(
5522 SubExpr, T, Importer.Import(E->getThrowLoc()),
5523 E->isThrownVariableInScope());
5526 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
5527 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
5528 Importer.Import(E->getParam()));
5532 return CXXDefaultArgExpr::Create(
5533 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
5536 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
5537 QualType T = Importer.Import(E->getType());
5541 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
5545 return new (Importer.getToContext()) CXXScalarValueInitExpr(
5546 T, TypeInfo, Importer.Import(E->getRParenLoc()));
5549 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
5550 Expr *SubExpr = Importer.Import(E->getSubExpr());
5554 auto *Dtor = cast_or_null<CXXDestructorDecl>(
5555 Importer.Import(const_cast<CXXDestructorDecl *>(
5556 E->getTemporary()->getDestructor())));
5560 ASTContext &ToCtx = Importer.getToContext();
5561 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
5562 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
5565 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
5566 QualType T = Importer.Import(CE->getType());
5570 SmallVector<Expr *, 8> Args(CE->getNumArgs());
5571 if (ImportContainerChecked(CE->arguments(), Args))
5574 auto *Ctor = cast_or_null<CXXConstructorDecl>(
5575 Importer.Import(CE->getConstructor()));
5579 return CXXTemporaryObjectExpr::Create(
5580 Importer.getToContext(), T,
5581 Importer.Import(CE->getLocStart()),
5585 CE->hadMultipleCandidates(),
5586 CE->isListInitialization(),
5587 CE->isStdInitListInitialization(),
5588 CE->requiresZeroInitialization(),
5589 CE->getConstructionKind(),
5590 Importer.Import(CE->getParenOrBraceRange()));
5594 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
5595 QualType T = Importer.Import(E->getType());
5599 Expr *TempE = Importer.Import(E->GetTemporaryExpr());
5603 ValueDecl *ExtendedBy = cast_or_null<ValueDecl>(
5604 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
5605 if (!ExtendedBy && E->getExtendingDecl())
5608 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
5609 T, TempE, E->isBoundToLvalueReference());
5611 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
5612 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
5616 Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
5617 QualType T = Importer.Import(E->getType());
5621 Expr *Pattern = Importer.Import(E->getPattern());
5625 return new (Importer.getToContext()) PackExpansionExpr(
5626 T, Pattern, Importer.Import(E->getEllipsisLoc()),
5627 E->getNumExpansions());
5630 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
5631 QualType T = Importer.Import(CE->getType());
5635 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
5636 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
5639 FunctionDecl *OperatorNewDecl = cast_or_null<FunctionDecl>(
5640 Importer.Import(CE->getOperatorNew()));
5641 if (!OperatorNewDecl && CE->getOperatorNew())
5644 FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
5645 Importer.Import(CE->getOperatorDelete()));
5646 if (!OperatorDeleteDecl && CE->getOperatorDelete())
5649 Expr *ToInit = Importer.Import(CE->getInitializer());
5650 if (!ToInit && CE->getInitializer())
5653 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
5657 Expr *ToArrSize = Importer.Import(CE->getArraySize());
5658 if (!ToArrSize && CE->getArraySize())
5661 return new (Importer.getToContext()) CXXNewExpr(
5662 Importer.getToContext(),
5664 OperatorNewDecl, OperatorDeleteDecl,
5665 CE->passAlignment(),
5666 CE->doesUsualArrayDeleteWantSize(),
5668 Importer.Import(CE->getTypeIdParens()),
5669 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
5670 Importer.Import(CE->getSourceRange()),
5671 Importer.Import(CE->getDirectInitRange()));
5674 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
5675 QualType T = Importer.Import(E->getType());
5679 FunctionDecl *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
5680 Importer.Import(E->getOperatorDelete()));
5681 if (!OperatorDeleteDecl && E->getOperatorDelete())
5684 Expr *ToArg = Importer.Import(E->getArgument());
5685 if (!ToArg && E->getArgument())
5688 return new (Importer.getToContext()) CXXDeleteExpr(
5689 T, E->isGlobalDelete(),
5691 E->isArrayFormAsWritten(),
5692 E->doesUsualArrayDeleteWantSize(),
5695 Importer.Import(E->getLocStart()));
5698 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
5699 QualType T = Importer.Import(E->getType());
5703 CXXConstructorDecl *ToCCD =
5704 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
5708 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
5709 if (ImportContainerChecked(E->arguments(), ToArgs))
5712 return CXXConstructExpr::Create(Importer.getToContext(), T,
5713 Importer.Import(E->getLocation()),
5714 ToCCD, E->isElidable(),
5715 ToArgs, E->hadMultipleCandidates(),
5716 E->isListInitialization(),
5717 E->isStdInitListInitialization(),
5718 E->requiresZeroInitialization(),
5719 E->getConstructionKind(),
5720 Importer.Import(E->getParenOrBraceRange()));
5723 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
5724 Expr *SubExpr = Importer.Import(EWC->getSubExpr());
5725 if (!SubExpr && EWC->getSubExpr())
5728 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
5729 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
5730 if (ExprWithCleanups::CleanupObject Obj =
5731 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
5736 return ExprWithCleanups::Create(Importer.getToContext(),
5737 SubExpr, EWC->cleanupsHaveSideEffects(),
5741 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
5742 QualType T = Importer.Import(E->getType());
5746 Expr *ToFn = Importer.Import(E->getCallee());
5750 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
5751 if (ImportContainerChecked(E->arguments(), ToArgs))
5754 return new (Importer.getToContext()) CXXMemberCallExpr(
5755 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
5756 Importer.Import(E->getRParenLoc()));
5759 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
5760 QualType T = Importer.Import(E->getType());
5764 return new (Importer.getToContext())
5765 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
5768 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
5769 QualType T = Importer.Import(E->getType());
5773 return new (Importer.getToContext())
5774 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
5778 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
5779 QualType T = Importer.Import(E->getType());
5783 Expr *ToBase = Importer.Import(E->getBase());
5784 if (!ToBase && E->getBase())
5787 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
5788 if (!ToMember && E->getMemberDecl())
5791 DeclAccessPair ToFoundDecl = DeclAccessPair::make(
5792 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())),
5793 E->getFoundDecl().getAccess());
5795 DeclarationNameInfo ToMemberNameInfo(
5796 Importer.Import(E->getMemberNameInfo().getName()),
5797 Importer.Import(E->getMemberNameInfo().getLoc()));
5799 if (E->hasExplicitTemplateArgs()) {
5800 return nullptr; // FIXME: handle template arguments
5803 return MemberExpr::Create(Importer.getToContext(), ToBase,
5805 Importer.Import(E->getOperatorLoc()),
5806 Importer.Import(E->getQualifierLoc()),
5807 Importer.Import(E->getTemplateKeywordLoc()),
5808 ToMember, ToFoundDecl, ToMemberNameInfo,
5809 nullptr, T, E->getValueKind(),
5810 E->getObjectKind());
5813 Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
5814 CXXPseudoDestructorExpr *E) {
5816 Expr *BaseE = Importer.Import(E->getBase());
5820 TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo());
5821 if (!ScopeInfo && E->getScopeTypeInfo())
5824 PseudoDestructorTypeStorage Storage;
5825 if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
5826 IdentifierInfo *ToII = Importer.Import(FromII);
5829 Storage = PseudoDestructorTypeStorage(
5830 ToII, Importer.Import(E->getDestroyedTypeLoc()));
5832 TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo());
5835 Storage = PseudoDestructorTypeStorage(TI);
5838 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
5839 Importer.getToContext(), BaseE, E->isArrow(),
5840 Importer.Import(E->getOperatorLoc()),
5841 Importer.Import(E->getQualifierLoc()),
5842 ScopeInfo, Importer.Import(E->getColonColonLoc()),
5843 Importer.Import(E->getTildeLoc()), Storage);
5846 Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
5847 CXXDependentScopeMemberExpr *E) {
5848 Expr *Base = nullptr;
5849 if (!E->isImplicitAccess()) {
5850 Base = Importer.Import(E->getBase());
5855 QualType BaseType = Importer.Import(E->getBaseType());
5856 if (BaseType.isNull())
5859 TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
5860 Importer.Import(E->getRAngleLoc()));
5861 TemplateArgumentListInfo *ResInfo = nullptr;
5862 if (E->hasExplicitTemplateArgs()) {
5863 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
5865 ResInfo = &ToTAInfo;
5868 DeclarationName Name = Importer.Import(E->getMember());
5869 if (!E->getMember().isEmpty() && Name.isEmpty())
5872 DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
5873 // Import additional name location/type info.
5874 ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
5875 auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
5876 if (!ToFQ && E->getFirstQualifierFoundInScope())
5879 return CXXDependentScopeMemberExpr::Create(
5880 Importer.getToContext(), Base, BaseType, E->isArrow(),
5881 Importer.Import(E->getOperatorLoc()),
5882 Importer.Import(E->getQualifierLoc()),
5883 Importer.Import(E->getTemplateKeywordLoc()),
5884 cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
5887 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
5888 QualType T = Importer.Import(E->getType());
5892 Expr *ToCallee = Importer.Import(E->getCallee());
5893 if (!ToCallee && E->getCallee())
5896 unsigned NumArgs = E->getNumArgs();
5898 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
5900 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) {
5901 Expr *FromArg = E->getArg(ai);
5902 Expr *ToArg = Importer.Import(FromArg);
5908 Expr **ToArgs_Copied = new (Importer.getToContext())
5911 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
5912 ToArgs_Copied[ai] = ToArgs[ai];
5914 return new (Importer.getToContext())
5915 CallExpr(Importer.getToContext(), ToCallee,
5916 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
5917 Importer.Import(E->getRParenLoc()));
5920 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
5921 QualType T = Importer.Import(ILE->getType());
5925 llvm::SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
5926 if (ImportContainerChecked(ILE->inits(), Exprs))
5929 ASTContext &ToCtx = Importer.getToContext();
5930 InitListExpr *To = new (ToCtx) InitListExpr(
5931 ToCtx, Importer.Import(ILE->getLBraceLoc()),
5932 Exprs, Importer.Import(ILE->getLBraceLoc()));
5935 if (ILE->hasArrayFiller()) {
5936 Expr *Filler = Importer.Import(ILE->getArrayFiller());
5939 To->setArrayFiller(Filler);
5942 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
5943 FieldDecl *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
5946 To->setInitializedFieldInUnion(ToFD);
5949 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
5950 InitListExpr *ToSyntForm = cast_or_null<InitListExpr>(
5951 Importer.Import(SyntForm));
5954 To->setSyntacticForm(ToSyntForm);
5957 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
5958 To->setValueDependent(ILE->isValueDependent());
5959 To->setInstantiationDependent(ILE->isInstantiationDependent());
5964 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
5965 QualType ToType = Importer.Import(E->getType());
5966 if (ToType.isNull())
5969 Expr *ToCommon = Importer.Import(E->getCommonExpr());
5970 if (!ToCommon && E->getCommonExpr())
5973 Expr *ToSubExpr = Importer.Import(E->getSubExpr());
5974 if (!ToSubExpr && E->getSubExpr())
5977 return new (Importer.getToContext())
5978 ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
5981 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
5982 QualType ToType = Importer.Import(E->getType());
5983 if (ToType.isNull())
5985 return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
5988 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
5989 FieldDecl *ToField = llvm::dyn_cast_or_null<FieldDecl>(
5990 Importer.Import(DIE->getField()));
5991 if (!ToField && DIE->getField())
5994 return CXXDefaultInitExpr::Create(
5995 Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
5998 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
5999 QualType ToType = Importer.Import(E->getType());
6000 if (ToType.isNull() && !E->getType().isNull())
6002 ExprValueKind VK = E->getValueKind();
6003 CastKind CK = E->getCastKind();
6004 Expr *ToOp = Importer.Import(E->getSubExpr());
6005 if (!ToOp && E->getSubExpr())
6007 CXXCastPath BasePath;
6008 if (ImportCastPath(E, BasePath))
6010 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6011 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6012 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6013 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6015 if (isa<CXXStaticCastExpr>(E)) {
6016 return CXXStaticCastExpr::Create(
6017 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6018 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6019 } else if (isa<CXXDynamicCastExpr>(E)) {
6020 return CXXDynamicCastExpr::Create(
6021 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6022 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6023 } else if (isa<CXXReinterpretCastExpr>(E)) {
6024 return CXXReinterpretCastExpr::Create(
6025 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6026 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6033 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6034 SubstNonTypeTemplateParmExpr *E) {
6035 QualType T = Importer.Import(E->getType());
6039 NonTypeTemplateParmDecl *Param = cast_or_null<NonTypeTemplateParmDecl>(
6040 Importer.Import(E->getParameter()));
6044 Expr *Replacement = Importer.Import(E->getReplacement());
6048 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6049 T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6053 Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
6054 QualType ToType = Importer.Import(E->getType());
6055 if (ToType.isNull())
6058 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
6059 if (ImportContainerChecked(E->getArgs(), ToArgs))
6062 // According to Sema::BuildTypeTrait(), if E is value-dependent,
6063 // Value is always false.
6064 bool ToValue = false;
6065 if (!E->isValueDependent())
6066 ToValue = E->getValue();
6068 return TypeTraitExpr::Create(
6069 Importer.getToContext(), ToType, Importer.Import(E->getLocStart()),
6070 E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue);
6073 void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
6074 CXXMethodDecl *FromMethod) {
6075 for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
6076 ToMethod->addOverriddenMethod(
6077 cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
6078 FromOverriddenMethod))));
6081 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6082 ASTContext &FromContext, FileManager &FromFileManager,
6084 : ToContext(ToContext), FromContext(FromContext),
6085 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6086 Minimal(MinimalImport), LastDiagFromFrom(false)
6088 ImportedDecls[FromContext.getTranslationUnitDecl()]
6089 = ToContext.getTranslationUnitDecl();
6092 ASTImporter::~ASTImporter() { }
6094 QualType ASTImporter::Import(QualType FromT) {
6098 const Type *fromTy = FromT.getTypePtr();
6100 // Check whether we've already imported this type.
6101 llvm::DenseMap<const Type *, const Type *>::iterator Pos
6102 = ImportedTypes.find(fromTy);
6103 if (Pos != ImportedTypes.end())
6104 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6107 ASTNodeImporter Importer(*this);
6108 QualType ToT = Importer.Visit(fromTy);
6112 // Record the imported type.
6113 ImportedTypes[fromTy] = ToT.getTypePtr();
6115 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6118 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6122 // FIXME: For now we just create a "trivial" type source info based
6123 // on the type and a single location. Implement a real version of this.
6124 QualType T = Import(FromTSI->getType());
6128 return ToContext.getTrivialTypeSourceInfo(T,
6129 Import(FromTSI->getTypeLoc().getLocStart()));
6132 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6133 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6134 if (Pos != ImportedDecls.end()) {
6135 Decl *ToD = Pos->second;
6136 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6143 Decl *ASTImporter::Import(Decl *FromD) {
6147 ASTNodeImporter Importer(*this);
6149 // Check whether we've already imported this declaration.
6150 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6151 if (Pos != ImportedDecls.end()) {
6152 Decl *ToD = Pos->second;
6153 Importer.ImportDefinitionIfNeeded(FromD, ToD);
6158 Decl *ToD = Importer.Visit(FromD);
6162 // Record the imported declaration.
6163 ImportedDecls[FromD] = ToD;
6165 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) {
6166 // Keep track of anonymous tags that have an associated typedef.
6167 if (FromTag->getTypedefNameForAnonDecl())
6168 AnonTagsWithPendingTypedefs.push_back(FromTag);
6169 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) {
6170 // When we've finished transforming a typedef, see whether it was the
6171 // typedef for an anonymous tag.
6172 for (SmallVectorImpl<TagDecl *>::iterator
6173 FromTag = AnonTagsWithPendingTypedefs.begin(),
6174 FromTagEnd = AnonTagsWithPendingTypedefs.end();
6175 FromTag != FromTagEnd; ++FromTag) {
6176 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) {
6177 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) {
6178 // We found the typedef for an anonymous tag; link them.
6179 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD));
6180 AnonTagsWithPendingTypedefs.erase(FromTag);
6190 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
6194 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
6198 // When we're using a record/enum/Objective-C class/protocol as a context, we
6199 // need it to have a definition.
6200 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
6201 RecordDecl *FromRecord = cast<RecordDecl>(FromDC);
6202 if (ToRecord->isCompleteDefinition()) {
6204 } else if (FromRecord->isCompleteDefinition()) {
6205 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
6206 ASTNodeImporter::IDK_Basic);
6208 CompleteDecl(ToRecord);
6210 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
6211 EnumDecl *FromEnum = cast<EnumDecl>(FromDC);
6212 if (ToEnum->isCompleteDefinition()) {
6214 } else if (FromEnum->isCompleteDefinition()) {
6215 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
6216 ASTNodeImporter::IDK_Basic);
6218 CompleteDecl(ToEnum);
6220 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
6221 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC);
6222 if (ToClass->getDefinition()) {
6224 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
6225 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
6226 ASTNodeImporter::IDK_Basic);
6228 CompleteDecl(ToClass);
6230 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
6231 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC);
6232 if (ToProto->getDefinition()) {
6234 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
6235 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
6236 ASTNodeImporter::IDK_Basic);
6238 CompleteDecl(ToProto);
6245 Expr *ASTImporter::Import(Expr *FromE) {
6249 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
6252 Stmt *ASTImporter::Import(Stmt *FromS) {
6256 // Check whether we've already imported this declaration.
6257 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
6258 if (Pos != ImportedStmts.end())
6262 ASTNodeImporter Importer(*this);
6263 Stmt *ToS = Importer.Visit(FromS);
6267 // Record the imported declaration.
6268 ImportedStmts[FromS] = ToS;
6272 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
6276 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
6278 switch (FromNNS->getKind()) {
6279 case NestedNameSpecifier::Identifier:
6280 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
6281 return NestedNameSpecifier::Create(ToContext, prefix, II);
6285 case NestedNameSpecifier::Namespace:
6286 if (NamespaceDecl *NS =
6287 cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
6288 return NestedNameSpecifier::Create(ToContext, prefix, NS);
6292 case NestedNameSpecifier::NamespaceAlias:
6293 if (NamespaceAliasDecl *NSAD =
6294 cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
6295 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
6299 case NestedNameSpecifier::Global:
6300 return NestedNameSpecifier::GlobalSpecifier(ToContext);
6302 case NestedNameSpecifier::Super:
6303 if (CXXRecordDecl *RD =
6304 cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
6305 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
6309 case NestedNameSpecifier::TypeSpec:
6310 case NestedNameSpecifier::TypeSpecWithTemplate: {
6311 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
6313 bool bTemplate = FromNNS->getKind() ==
6314 NestedNameSpecifier::TypeSpecWithTemplate;
6315 return NestedNameSpecifier::Create(ToContext, prefix,
6316 bTemplate, T.getTypePtr());
6322 llvm_unreachable("Invalid nested name specifier kind");
6325 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
6326 // Copied from NestedNameSpecifier mostly.
6327 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
6328 NestedNameSpecifierLoc NNS = FromNNS;
6330 // Push each of the nested-name-specifiers's onto a stack for
6331 // serialization in reverse order.
6333 NestedNames.push_back(NNS);
6334 NNS = NNS.getPrefix();
6337 NestedNameSpecifierLocBuilder Builder;
6339 while (!NestedNames.empty()) {
6340 NNS = NestedNames.pop_back_val();
6341 NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
6343 return NestedNameSpecifierLoc();
6345 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
6347 case NestedNameSpecifier::Identifier:
6348 Builder.Extend(getToContext(),
6349 Spec->getAsIdentifier(),
6350 Import(NNS.getLocalBeginLoc()),
6351 Import(NNS.getLocalEndLoc()));
6354 case NestedNameSpecifier::Namespace:
6355 Builder.Extend(getToContext(),
6356 Spec->getAsNamespace(),
6357 Import(NNS.getLocalBeginLoc()),
6358 Import(NNS.getLocalEndLoc()));
6361 case NestedNameSpecifier::NamespaceAlias:
6362 Builder.Extend(getToContext(),
6363 Spec->getAsNamespaceAlias(),
6364 Import(NNS.getLocalBeginLoc()),
6365 Import(NNS.getLocalEndLoc()));
6368 case NestedNameSpecifier::TypeSpec:
6369 case NestedNameSpecifier::TypeSpecWithTemplate: {
6370 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
6371 QualType(Spec->getAsType(), 0));
6372 Builder.Extend(getToContext(),
6373 Import(NNS.getLocalBeginLoc()),
6375 Import(NNS.getLocalEndLoc()));
6379 case NestedNameSpecifier::Global:
6380 Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
6383 case NestedNameSpecifier::Super: {
6384 SourceRange ToRange = Import(NNS.getSourceRange());
6385 Builder.MakeSuper(getToContext(),
6386 Spec->getAsRecordDecl(),
6393 return Builder.getWithLocInContext(getToContext());
6396 TemplateName ASTImporter::Import(TemplateName From) {
6397 switch (From.getKind()) {
6398 case TemplateName::Template:
6399 if (TemplateDecl *ToTemplate
6400 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
6401 return TemplateName(ToTemplate);
6403 return TemplateName();
6405 case TemplateName::OverloadedTemplate: {
6406 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
6407 UnresolvedSet<2> ToTemplates;
6408 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(),
6409 E = FromStorage->end();
6411 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I)))
6412 ToTemplates.addDecl(To);
6414 return TemplateName();
6416 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
6420 case TemplateName::QualifiedTemplate: {
6421 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
6422 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
6424 return TemplateName();
6426 if (TemplateDecl *ToTemplate
6427 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
6428 return ToContext.getQualifiedTemplateName(Qualifier,
6429 QTN->hasTemplateKeyword(),
6432 return TemplateName();
6435 case TemplateName::DependentTemplate: {
6436 DependentTemplateName *DTN = From.getAsDependentTemplateName();
6437 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
6439 return TemplateName();
6441 if (DTN->isIdentifier()) {
6442 return ToContext.getDependentTemplateName(Qualifier,
6443 Import(DTN->getIdentifier()));
6446 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
6449 case TemplateName::SubstTemplateTemplateParm: {
6450 SubstTemplateTemplateParmStorage *subst
6451 = From.getAsSubstTemplateTemplateParm();
6452 TemplateTemplateParmDecl *param
6453 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
6455 return TemplateName();
6457 TemplateName replacement = Import(subst->getReplacement());
6458 if (replacement.isNull()) return TemplateName();
6460 return ToContext.getSubstTemplateTemplateParm(param, replacement);
6463 case TemplateName::SubstTemplateTemplateParmPack: {
6464 SubstTemplateTemplateParmPackStorage *SubstPack
6465 = From.getAsSubstTemplateTemplateParmPack();
6466 TemplateTemplateParmDecl *Param
6467 = cast_or_null<TemplateTemplateParmDecl>(
6468 Import(SubstPack->getParameterPack()));
6470 return TemplateName();
6472 ASTNodeImporter Importer(*this);
6473 TemplateArgument ArgPack
6474 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
6475 if (ArgPack.isNull())
6476 return TemplateName();
6478 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
6482 llvm_unreachable("Invalid template name kind");
6485 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
6486 if (FromLoc.isInvalid())
6487 return SourceLocation();
6489 SourceManager &FromSM = FromContext.getSourceManager();
6491 // For now, map everything down to its file location, so that we
6492 // don't have to import macro expansions.
6493 // FIXME: Import macro expansions!
6494 FromLoc = FromSM.getFileLoc(FromLoc);
6495 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
6496 SourceManager &ToSM = ToContext.getSourceManager();
6497 FileID ToFileID = Import(Decomposed.first);
6498 if (ToFileID.isInvalid())
6499 return SourceLocation();
6500 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID)
6501 .getLocWithOffset(Decomposed.second);
6505 SourceRange ASTImporter::Import(SourceRange FromRange) {
6506 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
6509 FileID ASTImporter::Import(FileID FromID) {
6510 llvm::DenseMap<FileID, FileID>::iterator Pos
6511 = ImportedFileIDs.find(FromID);
6512 if (Pos != ImportedFileIDs.end())
6515 SourceManager &FromSM = FromContext.getSourceManager();
6516 SourceManager &ToSM = ToContext.getSourceManager();
6517 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
6518 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet");
6520 // Include location of this file.
6521 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
6523 // Map the FileID for to the "to" source manager.
6525 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
6526 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
6527 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
6529 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
6530 // than mmap the files several times.
6531 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName());
6534 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
6535 FromSLoc.getFile().getFileCharacteristic());
6537 // FIXME: We want to re-use the existing MemoryBuffer!
6538 const llvm::MemoryBuffer *
6539 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
6540 std::unique_ptr<llvm::MemoryBuffer> ToBuf
6541 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
6542 FromBuf->getBufferIdentifier());
6543 ToID = ToSM.createFileID(std::move(ToBuf),
6544 FromSLoc.getFile().getFileCharacteristic());
6548 ImportedFileIDs[FromID] = ToID;
6552 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
6553 Expr *ToExpr = Import(From->getInit());
6554 if (!ToExpr && From->getInit())
6557 if (From->isBaseInitializer()) {
6558 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
6559 if (!ToTInfo && From->getTypeSourceInfo())
6562 return new (ToContext) CXXCtorInitializer(
6563 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
6564 ToExpr, Import(From->getRParenLoc()),
6565 From->isPackExpansion() ? Import(From->getEllipsisLoc())
6566 : SourceLocation());
6567 } else if (From->isMemberInitializer()) {
6568 FieldDecl *ToField =
6569 llvm::cast_or_null<FieldDecl>(Import(From->getMember()));
6570 if (!ToField && From->getMember())
6573 return new (ToContext) CXXCtorInitializer(
6574 ToContext, ToField, Import(From->getMemberLocation()),
6575 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
6576 } else if (From->isIndirectMemberInitializer()) {
6577 IndirectFieldDecl *ToIField = llvm::cast_or_null<IndirectFieldDecl>(
6578 Import(From->getIndirectMember()));
6579 if (!ToIField && From->getIndirectMember())
6582 return new (ToContext) CXXCtorInitializer(
6583 ToContext, ToIField, Import(From->getMemberLocation()),
6584 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
6585 } else if (From->isDelegatingInitializer()) {
6586 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
6587 if (!ToTInfo && From->getTypeSourceInfo())
6590 return new (ToContext)
6591 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
6592 ToExpr, Import(From->getRParenLoc()));
6599 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
6600 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
6601 if (Pos != ImportedCXXBaseSpecifiers.end())
6604 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
6605 Import(BaseSpec->getSourceRange()),
6606 BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
6607 BaseSpec->getAccessSpecifierAsWritten(),
6608 Import(BaseSpec->getTypeSourceInfo()),
6609 Import(BaseSpec->getEllipsisLoc()));
6610 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
6614 void ASTImporter::ImportDefinition(Decl *From) {
6615 Decl *To = Import(From);
6619 if (DeclContext *FromDC = cast<DeclContext>(From)) {
6620 ASTNodeImporter Importer(*this);
6622 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) {
6623 if (!ToRecord->getDefinition()) {
6624 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
6625 ASTNodeImporter::IDK_Everything);
6630 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) {
6631 if (!ToEnum->getDefinition()) {
6632 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
6633 ASTNodeImporter::IDK_Everything);
6638 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
6639 if (!ToIFace->getDefinition()) {
6640 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
6641 ASTNodeImporter::IDK_Everything);
6646 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
6647 if (!ToProto->getDefinition()) {
6648 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
6649 ASTNodeImporter::IDK_Everything);
6654 Importer.ImportDeclContext(FromDC, true);
6658 DeclarationName ASTImporter::Import(DeclarationName FromName) {
6660 return DeclarationName();
6662 switch (FromName.getNameKind()) {
6663 case DeclarationName::Identifier:
6664 return Import(FromName.getAsIdentifierInfo());
6666 case DeclarationName::ObjCZeroArgSelector:
6667 case DeclarationName::ObjCOneArgSelector:
6668 case DeclarationName::ObjCMultiArgSelector:
6669 return Import(FromName.getObjCSelector());
6671 case DeclarationName::CXXConstructorName: {
6672 QualType T = Import(FromName.getCXXNameType());
6674 return DeclarationName();
6676 return ToContext.DeclarationNames.getCXXConstructorName(
6677 ToContext.getCanonicalType(T));
6680 case DeclarationName::CXXDestructorName: {
6681 QualType T = Import(FromName.getCXXNameType());
6683 return DeclarationName();
6685 return ToContext.DeclarationNames.getCXXDestructorName(
6686 ToContext.getCanonicalType(T));
6689 case DeclarationName::CXXDeductionGuideName: {
6690 TemplateDecl *Template = cast_or_null<TemplateDecl>(
6691 Import(FromName.getCXXDeductionGuideTemplate()));
6693 return DeclarationName();
6694 return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
6697 case DeclarationName::CXXConversionFunctionName: {
6698 QualType T = Import(FromName.getCXXNameType());
6700 return DeclarationName();
6702 return ToContext.DeclarationNames.getCXXConversionFunctionName(
6703 ToContext.getCanonicalType(T));
6706 case DeclarationName::CXXOperatorName:
6707 return ToContext.DeclarationNames.getCXXOperatorName(
6708 FromName.getCXXOverloadedOperator());
6710 case DeclarationName::CXXLiteralOperatorName:
6711 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
6712 Import(FromName.getCXXLiteralIdentifier()));
6714 case DeclarationName::CXXUsingDirective:
6716 return DeclarationName::getUsingDirectiveName();
6719 llvm_unreachable("Invalid DeclarationName Kind!");
6722 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
6726 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
6728 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
6729 ToId->setBuiltinID(FromId->getBuiltinID());
6734 Selector ASTImporter::Import(Selector FromSel) {
6735 if (FromSel.isNull())
6738 SmallVector<IdentifierInfo *, 4> Idents;
6739 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
6740 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
6741 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
6742 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
6745 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
6749 unsigned NumDecls) {
6753 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
6754 if (LastDiagFromFrom)
6755 ToContext.getDiagnostics().notePriorDiagnosticFrom(
6756 FromContext.getDiagnostics());
6757 LastDiagFromFrom = false;
6758 return ToContext.getDiagnostics().Report(Loc, DiagID);
6761 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
6762 if (!LastDiagFromFrom)
6763 FromContext.getDiagnostics().notePriorDiagnosticFrom(
6764 ToContext.getDiagnostics());
6765 LastDiagFromFrom = true;
6766 return FromContext.getDiagnostics().Report(Loc, DiagID);
6769 void ASTImporter::CompleteDecl (Decl *D) {
6770 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
6771 if (!ID->getDefinition())
6772 ID->startDefinition();
6774 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
6775 if (!PD->getDefinition())
6776 PD->startDefinition();
6778 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
6779 if (!TD->getDefinition() && !TD->isBeingDefined()) {
6780 TD->startDefinition();
6781 TD->setCompleteDefinition(true);
6785 assert (0 && "CompleteDecl called on a Decl that can't be completed");
6789 Decl *ASTImporter::Imported(Decl *From, Decl *To) {
6790 if (From->hasAttrs()) {
6791 for (Attr *FromAttr : From->getAttrs())
6792 To->addAttr(FromAttr->clone(To->getASTContext()));
6794 if (From->isUsed()) {
6797 if (From->isImplicit()) {
6800 ImportedDecls[From] = To;
6804 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
6806 llvm::DenseMap<const Type *, const Type *>::iterator Pos
6807 = ImportedTypes.find(From.getTypePtr());
6808 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
6811 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
6813 return Ctx.IsStructurallyEquivalent(From, To);