1 //===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
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 //===----------------------------------------------------------------------===//
15 #include "clang/AST/ASTImporter.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTDiagnostic.h"
18 #include "clang/AST/ASTStructuralEquivalence.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclAccessPair.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclVisitor.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExprObjC.h"
33 #include "clang/AST/ExternalASTSource.h"
34 #include "clang/AST/LambdaCapture.h"
35 #include "clang/AST/NestedNameSpecifier.h"
36 #include "clang/AST/OperationKinds.h"
37 #include "clang/AST/Stmt.h"
38 #include "clang/AST/StmtCXX.h"
39 #include "clang/AST/StmtObjC.h"
40 #include "clang/AST/StmtVisitor.h"
41 #include "clang/AST/TemplateBase.h"
42 #include "clang/AST/TemplateName.h"
43 #include "clang/AST/Type.h"
44 #include "clang/AST/TypeLoc.h"
45 #include "clang/AST/TypeVisitor.h"
46 #include "clang/AST/UnresolvedSet.h"
47 #include "clang/Basic/ExceptionSpecificationType.h"
48 #include "clang/Basic/FileManager.h"
49 #include "clang/Basic/IdentifierTable.h"
50 #include "clang/Basic/LLVM.h"
51 #include "clang/Basic/LangOptions.h"
52 #include "clang/Basic/SourceLocation.h"
53 #include "clang/Basic/SourceManager.h"
54 #include "clang/Basic/Specifiers.h"
55 #include "llvm/ADT/APSInt.h"
56 #include "llvm/ADT/ArrayRef.h"
57 #include "llvm/ADT/DenseMap.h"
58 #include "llvm/ADT/None.h"
59 #include "llvm/ADT/Optional.h"
60 #include "llvm/ADT/STLExtras.h"
61 #include "llvm/ADT/SmallVector.h"
62 #include "llvm/Support/Casting.h"
63 #include "llvm/Support/ErrorHandling.h"
64 #include "llvm/Support/MemoryBuffer.h"
69 #include <type_traits>
76 getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
77 SmallVector<Decl*, 2> Redecls;
78 for (auto *R : D->getFirstDecl()->redecls()) {
79 if (R != D->getFirstDecl())
82 Redecls.push_back(D->getFirstDecl());
83 std::reverse(Redecls.begin(), Redecls.end());
87 SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
88 // Currently only FunctionDecl is supported
89 auto FD = cast<FunctionDecl>(D);
90 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
93 void updateFlags(const Decl *From, Decl *To) {
94 // Check if some flags or attrs are new in 'From' and copy into 'To'.
95 // FIXME: Other flags or attrs?
96 if (From->isUsed(false) && !To->isUsed(false))
100 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
101 public DeclVisitor<ASTNodeImporter, Decl *>,
102 public StmtVisitor<ASTNodeImporter, Stmt *> {
103 ASTImporter &Importer;
105 // Wrapper for an overload set.
106 template <typename ToDeclT> struct CallOverloadedCreateFun {
107 template <typename... Args>
108 auto operator()(Args &&... args)
109 -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
110 return ToDeclT::Create(std::forward<Args>(args)...);
114 // Always use these functions to create a Decl during import. There are
115 // certain tasks which must be done after the Decl was created, e.g. we
116 // must immediately register that as an imported Decl. The parameter `ToD`
117 // will be set to the newly created Decl or if had been imported before
118 // then to the already imported Decl. Returns a bool value set to true if
119 // the `FromD` had been imported before.
120 template <typename ToDeclT, typename FromDeclT, typename... Args>
121 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
123 // There may be several overloads of ToDeclT::Create. We must make sure
124 // to call the one which would be chosen by the arguments, thus we use a
125 // wrapper for the overload set.
126 CallOverloadedCreateFun<ToDeclT> OC;
127 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
128 std::forward<Args>(args)...);
130 // Use this overload if a special Type is needed to be created. E.g if we
131 // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
133 // TypedefNameDecl *ToTypedef;
134 // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
135 template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
137 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
139 CallOverloadedCreateFun<NewDeclT> OC;
140 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
141 std::forward<Args>(args)...);
143 // Use this version if a special create function must be
144 // used, e.g. CXXRecordDecl::CreateLambda .
145 template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
148 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
149 FromDeclT *FromD, Args &&... args) {
150 ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
152 return true; // Already imported.
153 ToD = CreateFun(std::forward<Args>(args)...);
154 InitializeImportedDecl(FromD, ToD);
155 return false; // A new Decl is created.
158 void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
159 Importer.MapImported(FromD, ToD);
160 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
161 if (FromD->hasAttrs())
162 for (const Attr *FromAttr : FromD->getAttrs())
163 ToD->addAttr(Importer.Import(FromAttr));
166 if (FromD->isImplicit())
171 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
173 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
174 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
175 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
178 QualType VisitType(const Type *T);
179 QualType VisitAtomicType(const AtomicType *T);
180 QualType VisitBuiltinType(const BuiltinType *T);
181 QualType VisitDecayedType(const DecayedType *T);
182 QualType VisitComplexType(const ComplexType *T);
183 QualType VisitPointerType(const PointerType *T);
184 QualType VisitBlockPointerType(const BlockPointerType *T);
185 QualType VisitLValueReferenceType(const LValueReferenceType *T);
186 QualType VisitRValueReferenceType(const RValueReferenceType *T);
187 QualType VisitMemberPointerType(const MemberPointerType *T);
188 QualType VisitConstantArrayType(const ConstantArrayType *T);
189 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
190 QualType VisitVariableArrayType(const VariableArrayType *T);
191 QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
192 // FIXME: DependentSizedExtVectorType
193 QualType VisitVectorType(const VectorType *T);
194 QualType VisitExtVectorType(const ExtVectorType *T);
195 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
196 QualType VisitFunctionProtoType(const FunctionProtoType *T);
197 QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
198 QualType VisitParenType(const ParenType *T);
199 QualType VisitTypedefType(const TypedefType *T);
200 QualType VisitTypeOfExprType(const TypeOfExprType *T);
201 // FIXME: DependentTypeOfExprType
202 QualType VisitTypeOfType(const TypeOfType *T);
203 QualType VisitDecltypeType(const DecltypeType *T);
204 QualType VisitUnaryTransformType(const UnaryTransformType *T);
205 QualType VisitAutoType(const AutoType *T);
206 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
207 // FIXME: DependentDecltypeType
208 QualType VisitRecordType(const RecordType *T);
209 QualType VisitEnumType(const EnumType *T);
210 QualType VisitAttributedType(const AttributedType *T);
211 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
212 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
213 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
214 QualType VisitElaboratedType(const ElaboratedType *T);
215 QualType VisitDependentNameType(const DependentNameType *T);
216 QualType VisitPackExpansionType(const PackExpansionType *T);
217 QualType VisitDependentTemplateSpecializationType(
218 const DependentTemplateSpecializationType *T);
219 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
220 QualType VisitObjCObjectType(const ObjCObjectType *T);
221 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
223 // Importing declarations
224 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
225 DeclContext *&LexicalDC, DeclarationName &Name,
226 NamedDecl *&ToD, SourceLocation &Loc);
227 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
228 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
229 DeclarationNameInfo& To);
230 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
231 void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
233 bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
235 using Designator = DesignatedInitExpr::Designator;
237 Designator ImportDesignator(const Designator &D);
239 Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From);
241 /// What we should import from the definition.
242 enum ImportDefinitionKind {
243 /// Import the default subset of the definition, which might be
244 /// nothing (if minimal import is set) or might be everything (if minimal
245 /// import is not set).
248 /// Import everything.
251 /// Import only the bare bones needed to establish a valid
256 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
257 return IDK == IDK_Everything ||
258 (IDK == IDK_Default && !Importer.isMinimalImport());
261 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
262 ImportDefinitionKind Kind = IDK_Default);
263 bool ImportDefinition(VarDecl *From, VarDecl *To,
264 ImportDefinitionKind Kind = IDK_Default);
265 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
266 ImportDefinitionKind Kind = IDK_Default);
267 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
268 ImportDefinitionKind Kind = IDK_Default);
269 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
270 ImportDefinitionKind Kind = IDK_Default);
271 TemplateParameterList *ImportTemplateParameterList(
272 TemplateParameterList *Params);
273 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
274 Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc(
275 const TemplateArgumentLoc &TALoc);
276 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
277 unsigned NumFromArgs,
278 SmallVectorImpl<TemplateArgument> &ToArgs);
280 template <typename InContainerTy>
281 bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
282 TemplateArgumentListInfo &ToTAInfo);
284 template<typename InContainerTy>
285 bool ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,
286 SourceLocation FromRAngleLoc,
287 const InContainerTy &Container,
288 TemplateArgumentListInfo &Result);
290 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
291 using OptionalTemplateArgsTy = Optional<TemplateArgsTy>;
292 std::tuple<FunctionTemplateDecl *, OptionalTemplateArgsTy>
293 ImportFunctionTemplateWithTemplateArgsFromSpecialization(
294 FunctionDecl *FromFD);
296 bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
298 bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
299 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
300 bool Complain = true);
301 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
302 bool Complain = true);
303 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
304 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
305 bool IsStructuralMatch(FunctionTemplateDecl *From,
306 FunctionTemplateDecl *To);
307 bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
308 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
309 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
310 Decl *VisitDecl(Decl *D);
311 Decl *VisitEmptyDecl(EmptyDecl *D);
312 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
313 Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
314 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
315 Decl *VisitNamespaceDecl(NamespaceDecl *D);
316 Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
317 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
318 Decl *VisitTypedefDecl(TypedefDecl *D);
319 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
320 Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
321 Decl *VisitLabelDecl(LabelDecl *D);
322 Decl *VisitEnumDecl(EnumDecl *D);
323 Decl *VisitRecordDecl(RecordDecl *D);
324 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
325 Decl *VisitFunctionDecl(FunctionDecl *D);
326 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
327 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
328 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
329 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
330 Decl *VisitFieldDecl(FieldDecl *D);
331 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
332 Decl *VisitFriendDecl(FriendDecl *D);
333 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
334 Decl *VisitVarDecl(VarDecl *D);
335 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
336 Decl *VisitParmVarDecl(ParmVarDecl *D);
337 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
338 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
339 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
340 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
341 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
342 Decl *VisitUsingDecl(UsingDecl *D);
343 Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
344 Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
345 Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
346 Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
348 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
349 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
350 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
351 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
352 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
353 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
354 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
355 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
356 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
357 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
358 Decl *VisitClassTemplateSpecializationDecl(
359 ClassTemplateSpecializationDecl *D);
360 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
361 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
362 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
364 // Importing statements
365 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
367 Stmt *VisitStmt(Stmt *S);
368 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
369 Stmt *VisitDeclStmt(DeclStmt *S);
370 Stmt *VisitNullStmt(NullStmt *S);
371 Stmt *VisitCompoundStmt(CompoundStmt *S);
372 Stmt *VisitCaseStmt(CaseStmt *S);
373 Stmt *VisitDefaultStmt(DefaultStmt *S);
374 Stmt *VisitLabelStmt(LabelStmt *S);
375 Stmt *VisitAttributedStmt(AttributedStmt *S);
376 Stmt *VisitIfStmt(IfStmt *S);
377 Stmt *VisitSwitchStmt(SwitchStmt *S);
378 Stmt *VisitWhileStmt(WhileStmt *S);
379 Stmt *VisitDoStmt(DoStmt *S);
380 Stmt *VisitForStmt(ForStmt *S);
381 Stmt *VisitGotoStmt(GotoStmt *S);
382 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
383 Stmt *VisitContinueStmt(ContinueStmt *S);
384 Stmt *VisitBreakStmt(BreakStmt *S);
385 Stmt *VisitReturnStmt(ReturnStmt *S);
387 // FIXME: SEHExceptStmt
388 // FIXME: SEHFinallyStmt
390 // FIXME: SEHLeaveStmt
391 // FIXME: CapturedStmt
392 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
393 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
394 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
395 // FIXME: MSDependentExistsStmt
396 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
397 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
398 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
399 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
400 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
401 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
402 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
404 // Importing expressions
405 Expr *VisitExpr(Expr *E);
406 Expr *VisitVAArgExpr(VAArgExpr *E);
407 Expr *VisitGNUNullExpr(GNUNullExpr *E);
408 Expr *VisitPredefinedExpr(PredefinedExpr *E);
409 Expr *VisitDeclRefExpr(DeclRefExpr *E);
410 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
411 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
412 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
413 Expr *VisitIntegerLiteral(IntegerLiteral *E);
414 Expr *VisitFloatingLiteral(FloatingLiteral *E);
415 Expr *VisitCharacterLiteral(CharacterLiteral *E);
416 Expr *VisitStringLiteral(StringLiteral *E);
417 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
418 Expr *VisitAtomicExpr(AtomicExpr *E);
419 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
420 Expr *VisitParenExpr(ParenExpr *E);
421 Expr *VisitParenListExpr(ParenListExpr *E);
422 Expr *VisitStmtExpr(StmtExpr *E);
423 Expr *VisitUnaryOperator(UnaryOperator *E);
424 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
425 Expr *VisitBinaryOperator(BinaryOperator *E);
426 Expr *VisitConditionalOperator(ConditionalOperator *E);
427 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
428 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
429 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
430 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
431 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
432 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
433 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
434 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
435 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
436 Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
437 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
438 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
439 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
440 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
441 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
442 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
443 Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
444 Expr *VisitSizeOfPackExpr(SizeOfPackExpr *E);
445 Expr *VisitCXXNewExpr(CXXNewExpr *CE);
446 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
447 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
448 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
449 Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
450 Expr *VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
451 Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE);
452 Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
453 Expr *VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
454 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
455 Expr *VisitCXXThisExpr(CXXThisExpr *E);
456 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
457 Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
458 Expr *VisitMemberExpr(MemberExpr *E);
459 Expr *VisitCallExpr(CallExpr *E);
460 Expr *VisitLambdaExpr(LambdaExpr *LE);
461 Expr *VisitInitListExpr(InitListExpr *E);
462 Expr *VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
463 Expr *VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
464 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
465 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
466 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
467 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
468 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
469 Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
470 Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E);
472 template<typename IIter, typename OIter>
473 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
474 using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
476 ASTImporter &ImporterRef = Importer;
477 std::transform(Ibegin, Iend, Obegin,
478 [&ImporterRef](ItemT From) -> ItemT {
479 return ImporterRef.Import(From);
483 template<typename IIter, typename OIter>
484 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
485 using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;
487 ASTImporter &ImporterRef = Importer;
489 std::transform(Ibegin, Iend, Obegin,
490 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
491 auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
499 template<typename InContainerTy, typename OutContainerTy>
500 bool ImportContainerChecked(const InContainerTy &InContainer,
501 OutContainerTy &OutContainer) {
502 return ImportArrayChecked(InContainer.begin(), InContainer.end(),
503 OutContainer.begin());
506 template<typename InContainerTy, typename OIter>
507 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
508 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
511 // Importing overrides.
512 void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
514 FunctionDecl *FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
517 template <typename InContainerTy>
518 bool ASTNodeImporter::ImportTemplateArgumentListInfo(
519 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
520 const InContainerTy &Container, TemplateArgumentListInfo &Result) {
521 TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
522 Importer.Import(FromRAngleLoc));
523 if (ImportTemplateArgumentListInfo(Container, ToTAInfo))
530 bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
531 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
532 return ImportTemplateArgumentListInfo(
533 From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
537 bool ASTNodeImporter::ImportTemplateArgumentListInfo<
538 ASTTemplateArgumentListInfo>(const ASTTemplateArgumentListInfo &From,
539 TemplateArgumentListInfo &Result) {
540 return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
541 From.arguments(), Result);
544 std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
545 ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
546 FunctionDecl *FromFD) {
547 assert(FromFD->getTemplatedKind() ==
548 FunctionDecl::TK_FunctionTemplateSpecialization);
549 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
550 auto *Template = cast_or_null<FunctionTemplateDecl>(
551 Importer.Import(FTSInfo->getTemplate()));
553 // Import template arguments.
554 auto TemplArgs = FTSInfo->TemplateArguments->asArray();
555 TemplateArgsTy ToTemplArgs;
556 if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
557 ToTemplArgs)) // Error during import.
558 return std::make_tuple(Template, OptionalTemplateArgsTy());
560 return std::make_tuple(Template, ToTemplArgs);
565 //----------------------------------------------------------------------------
567 //----------------------------------------------------------------------------
569 using namespace clang;
571 QualType ASTNodeImporter::VisitType(const Type *T) {
572 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
573 << T->getTypeClassName();
577 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
578 QualType UnderlyingType = Importer.Import(T->getValueType());
579 if(UnderlyingType.isNull())
582 return Importer.getToContext().getAtomicType(UnderlyingType);
585 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
586 switch (T->getKind()) {
587 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
588 case BuiltinType::Id: \
589 return Importer.getToContext().SingletonId;
590 #include "clang/Basic/OpenCLImageTypes.def"
591 #define SHARED_SINGLETON_TYPE(Expansion)
592 #define BUILTIN_TYPE(Id, SingletonId) \
593 case BuiltinType::Id: return Importer.getToContext().SingletonId;
594 #include "clang/AST/BuiltinTypes.def"
596 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
597 // context supports C++.
599 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
600 // context supports ObjC.
602 case BuiltinType::Char_U:
603 // The context we're importing from has an unsigned 'char'. If we're
604 // importing into a context with a signed 'char', translate to
605 // 'unsigned char' instead.
606 if (Importer.getToContext().getLangOpts().CharIsSigned)
607 return Importer.getToContext().UnsignedCharTy;
609 return Importer.getToContext().CharTy;
611 case BuiltinType::Char_S:
612 // The context we're importing from has an unsigned 'char'. If we're
613 // importing into a context with a signed 'char', translate to
614 // 'unsigned char' instead.
615 if (!Importer.getToContext().getLangOpts().CharIsSigned)
616 return Importer.getToContext().SignedCharTy;
618 return Importer.getToContext().CharTy;
620 case BuiltinType::WChar_S:
621 case BuiltinType::WChar_U:
622 // FIXME: If not in C++, shall we translate to the C equivalent of
624 return Importer.getToContext().WCharTy;
627 llvm_unreachable("Invalid BuiltinType Kind!");
630 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
631 QualType OrigT = Importer.Import(T->getOriginalType());
635 return Importer.getToContext().getDecayedType(OrigT);
638 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
639 QualType ToElementType = Importer.Import(T->getElementType());
640 if (ToElementType.isNull())
643 return Importer.getToContext().getComplexType(ToElementType);
646 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
647 QualType ToPointeeType = Importer.Import(T->getPointeeType());
648 if (ToPointeeType.isNull())
651 return Importer.getToContext().getPointerType(ToPointeeType);
654 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
655 // FIXME: Check for blocks support in "to" context.
656 QualType ToPointeeType = Importer.Import(T->getPointeeType());
657 if (ToPointeeType.isNull())
660 return Importer.getToContext().getBlockPointerType(ToPointeeType);
664 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
665 // FIXME: Check for C++ support in "to" context.
666 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
667 if (ToPointeeType.isNull())
670 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
674 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
675 // FIXME: Check for C++0x support in "to" context.
676 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
677 if (ToPointeeType.isNull())
680 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
683 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
684 // FIXME: Check for C++ support in "to" context.
685 QualType ToPointeeType = Importer.Import(T->getPointeeType());
686 if (ToPointeeType.isNull())
689 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
690 return Importer.getToContext().getMemberPointerType(ToPointeeType,
691 ClassType.getTypePtr());
694 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
695 QualType ToElementType = Importer.Import(T->getElementType());
696 if (ToElementType.isNull())
699 return Importer.getToContext().getConstantArrayType(ToElementType,
701 T->getSizeModifier(),
702 T->getIndexTypeCVRQualifiers());
706 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
707 QualType ToElementType = Importer.Import(T->getElementType());
708 if (ToElementType.isNull())
711 return Importer.getToContext().getIncompleteArrayType(ToElementType,
712 T->getSizeModifier(),
713 T->getIndexTypeCVRQualifiers());
716 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
717 QualType ToElementType = Importer.Import(T->getElementType());
718 if (ToElementType.isNull())
721 Expr *Size = Importer.Import(T->getSizeExpr());
725 SourceRange Brackets = Importer.Import(T->getBracketsRange());
726 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
727 T->getSizeModifier(),
728 T->getIndexTypeCVRQualifiers(),
732 QualType ASTNodeImporter::VisitDependentSizedArrayType(
733 const DependentSizedArrayType *T) {
734 QualType ToElementType = Importer.Import(T->getElementType());
735 if (ToElementType.isNull())
738 // SizeExpr may be null if size is not specified directly.
739 // For example, 'int a[]'.
740 Expr *Size = Importer.Import(T->getSizeExpr());
741 if (!Size && T->getSizeExpr())
744 SourceRange Brackets = Importer.Import(T->getBracketsRange());
745 return Importer.getToContext().getDependentSizedArrayType(
746 ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(),
750 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
751 QualType ToElementType = Importer.Import(T->getElementType());
752 if (ToElementType.isNull())
755 return Importer.getToContext().getVectorType(ToElementType,
760 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
761 QualType ToElementType = Importer.Import(T->getElementType());
762 if (ToElementType.isNull())
765 return Importer.getToContext().getExtVectorType(ToElementType,
766 T->getNumElements());
770 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
771 // FIXME: What happens if we're importing a function without a prototype
772 // into C++? Should we make it variadic?
773 QualType ToResultType = Importer.Import(T->getReturnType());
774 if (ToResultType.isNull())
777 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
781 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
782 QualType ToResultType = Importer.Import(T->getReturnType());
783 if (ToResultType.isNull())
786 // Import argument types
787 SmallVector<QualType, 4> ArgTypes;
788 for (const auto &A : T->param_types()) {
789 QualType ArgType = Importer.Import(A);
790 if (ArgType.isNull())
792 ArgTypes.push_back(ArgType);
795 // Import exception types
796 SmallVector<QualType, 4> ExceptionTypes;
797 for (const auto &E : T->exceptions()) {
798 QualType ExceptionType = Importer.Import(E);
799 if (ExceptionType.isNull())
801 ExceptionTypes.push_back(ExceptionType);
804 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
805 FunctionProtoType::ExtProtoInfo ToEPI;
807 ToEPI.ExtInfo = FromEPI.ExtInfo;
808 ToEPI.Variadic = FromEPI.Variadic;
809 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
810 ToEPI.TypeQuals = FromEPI.TypeQuals;
811 ToEPI.RefQualifier = FromEPI.RefQualifier;
812 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
813 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
814 ToEPI.ExceptionSpec.NoexceptExpr =
815 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
816 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
817 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
818 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
819 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
821 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
824 QualType ASTNodeImporter::VisitUnresolvedUsingType(
825 const UnresolvedUsingType *T) {
827 cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
832 cast_or_null<UnresolvedUsingTypenameDecl>(
833 Importer.Import(T->getDecl()->getPreviousDecl()));
834 if (!ToPrevD && T->getDecl()->getPreviousDecl())
837 return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
840 QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
841 QualType ToInnerType = Importer.Import(T->getInnerType());
842 if (ToInnerType.isNull())
845 return Importer.getToContext().getParenType(ToInnerType);
848 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
850 dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
854 return Importer.getToContext().getTypeDeclType(ToDecl);
857 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
858 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
862 return Importer.getToContext().getTypeOfExprType(ToExpr);
865 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
866 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
867 if (ToUnderlyingType.isNull())
870 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
873 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
874 // FIXME: Make sure that the "to" context supports C++0x!
875 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
879 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
880 if (UnderlyingType.isNull())
883 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
886 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
887 QualType ToBaseType = Importer.Import(T->getBaseType());
888 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
889 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
892 return Importer.getToContext().getUnaryTransformType(ToBaseType,
897 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
898 // FIXME: Make sure that the "to" context supports C++11!
899 QualType FromDeduced = T->getDeducedType();
901 if (!FromDeduced.isNull()) {
902 ToDeduced = Importer.Import(FromDeduced);
903 if (ToDeduced.isNull())
907 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
908 /*IsDependent*/false);
911 QualType ASTNodeImporter::VisitInjectedClassNameType(
912 const InjectedClassNameType *T) {
913 auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
917 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
918 if (InjType.isNull())
921 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
922 // See comments in InjectedClassNameType definition for details
923 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
925 TypeAlignmentInBits = 4,
926 TypeAlignment = 1 << TypeAlignmentInBits
929 return QualType(new (Importer.getToContext(), TypeAlignment)
930 InjectedClassNameType(D, InjType), 0);
933 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
934 auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
938 return Importer.getToContext().getTagDeclType(ToDecl);
941 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
942 auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
946 return Importer.getToContext().getTagDeclType(ToDecl);
949 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
950 QualType FromModifiedType = T->getModifiedType();
951 QualType FromEquivalentType = T->getEquivalentType();
952 QualType ToModifiedType;
953 QualType ToEquivalentType;
955 if (!FromModifiedType.isNull()) {
956 ToModifiedType = Importer.Import(FromModifiedType);
957 if (ToModifiedType.isNull())
960 if (!FromEquivalentType.isNull()) {
961 ToEquivalentType = Importer.Import(FromEquivalentType);
962 if (ToEquivalentType.isNull())
966 return Importer.getToContext().getAttributedType(T->getAttrKind(),
967 ToModifiedType, ToEquivalentType);
970 QualType ASTNodeImporter::VisitTemplateTypeParmType(
971 const TemplateTypeParmType *T) {
973 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
974 if (!ParmDecl && T->getDecl())
977 return Importer.getToContext().getTemplateTypeParmType(
978 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
981 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
982 const SubstTemplateTypeParmType *T) {
983 const auto *Replaced =
984 cast_or_null<TemplateTypeParmType>(Importer.Import(
985 QualType(T->getReplacedParameter(), 0)).getTypePtr());
989 QualType Replacement = Importer.Import(T->getReplacementType());
990 if (Replacement.isNull())
992 Replacement = Replacement.getCanonicalType();
994 return Importer.getToContext().getSubstTemplateTypeParmType(
995 Replaced, Replacement);
998 QualType ASTNodeImporter::VisitTemplateSpecializationType(
999 const TemplateSpecializationType *T) {
1000 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1001 if (ToTemplate.isNull())
1004 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1005 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1008 QualType ToCanonType;
1009 if (!QualType(T, 0).isCanonical()) {
1010 QualType FromCanonType
1011 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1012 ToCanonType =Importer.Import(FromCanonType);
1013 if (ToCanonType.isNull())
1016 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
1021 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1022 NestedNameSpecifier *ToQualifier = nullptr;
1023 // Note: the qualifier in an ElaboratedType is optional.
1024 if (T->getQualifier()) {
1025 ToQualifier = Importer.Import(T->getQualifier());
1030 QualType ToNamedType = Importer.Import(T->getNamedType());
1031 if (ToNamedType.isNull())
1034 TagDecl *OwnedTagDecl =
1035 cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
1036 if (!OwnedTagDecl && T->getOwnedTagDecl())
1039 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1040 ToQualifier, ToNamedType,
1044 QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1045 QualType Pattern = Importer.Import(T->getPattern());
1046 if (Pattern.isNull())
1049 return Importer.getToContext().getPackExpansionType(Pattern,
1050 T->getNumExpansions());
1053 QualType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1054 const DependentTemplateSpecializationType *T) {
1055 NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
1056 if (!Qualifier && T->getQualifier())
1059 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1060 if (!Name && T->getIdentifier())
1063 SmallVector<TemplateArgument, 2> ToPack;
1064 ToPack.reserve(T->getNumArgs());
1065 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
1068 return Importer.getToContext().getDependentTemplateSpecializationType(
1069 T->getKeyword(), Qualifier, Name, ToPack);
1072 QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1073 NestedNameSpecifier *NNS = Importer.Import(T->getQualifier());
1074 if (!NNS && T->getQualifier())
1077 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1078 if (!Name && T->getIdentifier())
1081 QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr())
1083 : Importer.Import(T->getCanonicalTypeInternal());
1084 if (!Canon.isNull())
1085 Canon = Canon.getCanonicalType();
1087 return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
1091 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1093 dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
1097 return Importer.getToContext().getObjCInterfaceType(Class);
1100 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1101 QualType ToBaseType = Importer.Import(T->getBaseType());
1102 if (ToBaseType.isNull())
1105 SmallVector<QualType, 4> TypeArgs;
1106 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1107 QualType ImportedTypeArg = Importer.Import(TypeArg);
1108 if (ImportedTypeArg.isNull())
1111 TypeArgs.push_back(ImportedTypeArg);
1114 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1115 for (auto *P : T->quals()) {
1116 auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
1119 Protocols.push_back(Protocol);
1122 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
1124 T->isKindOfTypeAsWritten());
1128 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1129 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1130 if (ToPointeeType.isNull())
1133 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
1136 //----------------------------------------------------------------------------
1137 // Import Declarations
1138 //----------------------------------------------------------------------------
1139 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1140 DeclContext *&LexicalDC,
1141 DeclarationName &Name,
1143 SourceLocation &Loc) {
1144 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1145 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1146 DeclContext *OrigDC = D->getDeclContext();
1147 FunctionDecl *FunDecl;
1148 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1149 FunDecl->hasBody()) {
1150 SourceRange RecR = D->getSourceRange();
1151 SourceRange BodyR = FunDecl->getBody()->getSourceRange();
1152 // If RecordDecl is not in Body (it is a param), we bail out.
1153 if (RecR.isValid() && BodyR.isValid() &&
1154 (RecR.getBegin() < BodyR.getBegin() ||
1155 BodyR.getEnd() < RecR.getEnd())) {
1156 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1157 << D->getDeclKindName();
1162 // Import the context of this declaration.
1163 DC = Importer.ImportContext(OrigDC);
1168 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1169 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1174 // Import the name of this declaration.
1175 Name = Importer.Import(D->getDeclName());
1176 if (D->getDeclName() && !Name)
1179 // Import the location of this declaration.
1180 Loc = Importer.Import(D->getLocation());
1181 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1185 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1190 ToD = Importer.Import(FromD);
1195 if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1196 if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
1197 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
1198 ImportDefinition(FromRecord, ToRecord);
1204 if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1205 if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
1206 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1207 ImportDefinition(FromEnum, ToEnum);
1215 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1216 DeclarationNameInfo& To) {
1217 // NOTE: To.Name and To.Loc are already imported.
1218 // We only have to import To.LocInfo.
1219 switch (To.getName().getNameKind()) {
1220 case DeclarationName::Identifier:
1221 case DeclarationName::ObjCZeroArgSelector:
1222 case DeclarationName::ObjCOneArgSelector:
1223 case DeclarationName::ObjCMultiArgSelector:
1224 case DeclarationName::CXXUsingDirective:
1225 case DeclarationName::CXXDeductionGuideName:
1228 case DeclarationName::CXXOperatorName: {
1229 SourceRange Range = From.getCXXOperatorNameRange();
1230 To.setCXXOperatorNameRange(Importer.Import(Range));
1233 case DeclarationName::CXXLiteralOperatorName: {
1234 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1235 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1238 case DeclarationName::CXXConstructorName:
1239 case DeclarationName::CXXDestructorName:
1240 case DeclarationName::CXXConversionFunctionName: {
1241 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1242 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1246 llvm_unreachable("Unknown name kind.");
1249 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1250 if (Importer.isMinimalImport() && !ForceImport) {
1251 Importer.ImportContext(FromDC);
1255 for (auto *From : FromDC->decls())
1256 Importer.Import(From);
1259 void ASTNodeImporter::ImportImplicitMethods(
1260 const CXXRecordDecl *From, CXXRecordDecl *To) {
1261 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1262 "Import implicit methods to or from non-definition");
1264 for (CXXMethodDecl *FromM : From->methods())
1265 if (FromM->isImplicit())
1266 Importer.Import(FromM);
1269 static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1270 ASTImporter &Importer) {
1271 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1273 cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
1274 assert (ToTypedef && "Failed to import typedef of an anonymous structure");
1276 To->setTypedefNameForAnonDecl(ToTypedef);
1280 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
1281 ImportDefinitionKind Kind) {
1282 if (To->getDefinition() || To->isBeingDefined()) {
1283 if (Kind == IDK_Everything)
1284 ImportDeclContext(From, /*ForceImport=*/true);
1289 To->startDefinition();
1291 setTypedefNameForAnonDecl(From, To, Importer);
1293 // Add base classes.
1294 if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1295 auto *FromCXX = cast<CXXRecordDecl>(From);
1297 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1298 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1299 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
1300 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
1301 ToData.Aggregate = FromData.Aggregate;
1302 ToData.PlainOldData = FromData.PlainOldData;
1303 ToData.Empty = FromData.Empty;
1304 ToData.Polymorphic = FromData.Polymorphic;
1305 ToData.Abstract = FromData.Abstract;
1306 ToData.IsStandardLayout = FromData.IsStandardLayout;
1307 ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
1308 ToData.HasBasesWithFields = FromData.HasBasesWithFields;
1309 ToData.HasBasesWithNonStaticDataMembers =
1310 FromData.HasBasesWithNonStaticDataMembers;
1311 ToData.HasPrivateFields = FromData.HasPrivateFields;
1312 ToData.HasProtectedFields = FromData.HasProtectedFields;
1313 ToData.HasPublicFields = FromData.HasPublicFields;
1314 ToData.HasMutableFields = FromData.HasMutableFields;
1315 ToData.HasVariantMembers = FromData.HasVariantMembers;
1316 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
1317 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
1318 ToData.HasUninitializedReferenceMember
1319 = FromData.HasUninitializedReferenceMember;
1320 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
1321 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
1322 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
1323 ToData.NeedOverloadResolutionForCopyConstructor
1324 = FromData.NeedOverloadResolutionForCopyConstructor;
1325 ToData.NeedOverloadResolutionForMoveConstructor
1326 = FromData.NeedOverloadResolutionForMoveConstructor;
1327 ToData.NeedOverloadResolutionForMoveAssignment
1328 = FromData.NeedOverloadResolutionForMoveAssignment;
1329 ToData.NeedOverloadResolutionForDestructor
1330 = FromData.NeedOverloadResolutionForDestructor;
1331 ToData.DefaultedCopyConstructorIsDeleted
1332 = FromData.DefaultedCopyConstructorIsDeleted;
1333 ToData.DefaultedMoveConstructorIsDeleted
1334 = FromData.DefaultedMoveConstructorIsDeleted;
1335 ToData.DefaultedMoveAssignmentIsDeleted
1336 = FromData.DefaultedMoveAssignmentIsDeleted;
1337 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
1338 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1339 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
1340 ToData.HasConstexprNonCopyMoveConstructor
1341 = FromData.HasConstexprNonCopyMoveConstructor;
1342 ToData.HasDefaultedDefaultConstructor
1343 = FromData.HasDefaultedDefaultConstructor;
1344 ToData.DefaultedDefaultConstructorIsConstexpr
1345 = FromData.DefaultedDefaultConstructorIsConstexpr;
1346 ToData.HasConstexprDefaultConstructor
1347 = FromData.HasConstexprDefaultConstructor;
1348 ToData.HasNonLiteralTypeFieldsOrBases
1349 = FromData.HasNonLiteralTypeFieldsOrBases;
1350 // ComputedVisibleConversions not imported.
1351 ToData.UserProvidedDefaultConstructor
1352 = FromData.UserProvidedDefaultConstructor;
1353 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
1354 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
1355 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
1356 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
1357 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
1358 ToData.ImplicitCopyAssignmentHasConstParam
1359 = FromData.ImplicitCopyAssignmentHasConstParam;
1360 ToData.HasDeclaredCopyConstructorWithConstParam
1361 = FromData.HasDeclaredCopyConstructorWithConstParam;
1362 ToData.HasDeclaredCopyAssignmentWithConstParam
1363 = FromData.HasDeclaredCopyAssignmentWithConstParam;
1365 SmallVector<CXXBaseSpecifier *, 4> Bases;
1366 for (const auto &Base1 : FromCXX->bases()) {
1367 QualType T = Importer.Import(Base1.getType());
1371 SourceLocation EllipsisLoc;
1372 if (Base1.isPackExpansion())
1373 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
1375 // Ensure that we have a definition for the base.
1376 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
1379 new (Importer.getToContext())
1380 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1382 Base1.isBaseOfClass(),
1383 Base1.getAccessSpecifierAsWritten(),
1384 Importer.Import(Base1.getTypeSourceInfo()),
1388 ToCXX->setBases(Bases.data(), Bases.size());
1391 if (shouldForceImportDeclContext(Kind))
1392 ImportDeclContext(From, /*ForceImport=*/true);
1394 To->completeDefinition();
1398 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
1399 ImportDefinitionKind Kind) {
1400 if (To->getAnyInitializer())
1403 // FIXME: Can we really import any initializer? Alternatively, we could force
1404 // ourselves to import every declaration of a variable and then only use
1406 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
1408 // FIXME: Other bits to merge?
1413 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
1414 ImportDefinitionKind Kind) {
1415 if (To->getDefinition() || To->isBeingDefined()) {
1416 if (Kind == IDK_Everything)
1417 ImportDeclContext(From, /*ForceImport=*/true);
1421 To->startDefinition();
1423 setTypedefNameForAnonDecl(From, To, Importer);
1425 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1429 QualType ToPromotionType = Importer.Import(From->getPromotionType());
1430 if (ToPromotionType.isNull())
1433 if (shouldForceImportDeclContext(Kind))
1434 ImportDeclContext(From, /*ForceImport=*/true);
1436 // FIXME: we might need to merge the number of positive or negative bits
1437 // if the enumerator lists don't match.
1438 To->completeDefinition(T, ToPromotionType,
1439 From->getNumPositiveBits(),
1440 From->getNumNegativeBits());
1444 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
1445 TemplateParameterList *Params) {
1446 SmallVector<NamedDecl *, 4> ToParams(Params->size());
1447 if (ImportContainerChecked(*Params, ToParams))
1450 Expr *ToRequiresClause;
1451 if (Expr *const R = Params->getRequiresClause()) {
1452 ToRequiresClause = Importer.Import(R);
1453 if (!ToRequiresClause)
1456 ToRequiresClause = nullptr;
1459 return TemplateParameterList::Create(Importer.getToContext(),
1460 Importer.Import(Params->getTemplateLoc()),
1461 Importer.Import(Params->getLAngleLoc()),
1463 Importer.Import(Params->getRAngleLoc()),
1468 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
1469 switch (From.getKind()) {
1470 case TemplateArgument::Null:
1471 return TemplateArgument();
1473 case TemplateArgument::Type: {
1474 QualType ToType = Importer.Import(From.getAsType());
1475 if (ToType.isNull())
1477 return TemplateArgument(ToType);
1480 case TemplateArgument::Integral: {
1481 QualType ToType = Importer.Import(From.getIntegralType());
1482 if (ToType.isNull())
1484 return TemplateArgument(From, ToType);
1487 case TemplateArgument::Declaration: {
1488 auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
1489 QualType ToType = Importer.Import(From.getParamTypeForDecl());
1490 if (!To || ToType.isNull())
1492 return TemplateArgument(To, ToType);
1495 case TemplateArgument::NullPtr: {
1496 QualType ToType = Importer.Import(From.getNullPtrType());
1497 if (ToType.isNull())
1499 return TemplateArgument(ToType, /*isNullPtr*/true);
1502 case TemplateArgument::Template: {
1503 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1504 if (ToTemplate.isNull())
1507 return TemplateArgument(ToTemplate);
1510 case TemplateArgument::TemplateExpansion: {
1511 TemplateName ToTemplate
1512 = Importer.Import(From.getAsTemplateOrTemplatePattern());
1513 if (ToTemplate.isNull())
1516 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
1519 case TemplateArgument::Expression:
1520 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1521 return TemplateArgument(ToExpr);
1522 return TemplateArgument();
1524 case TemplateArgument::Pack: {
1525 SmallVector<TemplateArgument, 2> ToPack;
1526 ToPack.reserve(From.pack_size());
1527 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
1530 return TemplateArgument(
1531 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
1535 llvm_unreachable("Invalid template argument kind");
1538 Optional<TemplateArgumentLoc>
1539 ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) {
1540 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
1541 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
1542 TemplateArgumentLocInfo ToInfo;
1543 if (Arg.getKind() == TemplateArgument::Expression) {
1544 Expr *E = Importer.Import(FromInfo.getAsExpr());
1545 ToInfo = TemplateArgumentLocInfo(E);
1548 } else if (Arg.getKind() == TemplateArgument::Type) {
1549 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
1550 ToInfo = TemplateArgumentLocInfo(TSI);
1554 ToInfo = TemplateArgumentLocInfo(
1555 Importer.Import(FromInfo.getTemplateQualifierLoc()),
1556 Importer.Import(FromInfo.getTemplateNameLoc()),
1557 Importer.Import(FromInfo.getTemplateEllipsisLoc()));
1559 return TemplateArgumentLoc(Arg, ToInfo);
1562 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
1563 unsigned NumFromArgs,
1564 SmallVectorImpl<TemplateArgument> &ToArgs) {
1565 for (unsigned I = 0; I != NumFromArgs; ++I) {
1566 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
1567 if (To.isNull() && !FromArgs[I].isNull())
1570 ToArgs.push_back(To);
1576 // We cannot use Optional<> pattern here and below because
1577 // TemplateArgumentListInfo's operator new is declared as deleted so it cannot
1578 // be stored in Optional.
1579 template <typename InContainerTy>
1580 bool ASTNodeImporter::ImportTemplateArgumentListInfo(
1581 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
1582 for (const auto &FromLoc : Container) {
1583 if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
1584 ToTAInfo.addArgument(*ToLoc);
1591 static StructuralEquivalenceKind
1592 getStructuralEquivalenceKind(const ASTImporter &Importer) {
1593 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
1594 : StructuralEquivalenceKind::Default;
1597 bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
1598 StructuralEquivalenceContext Ctx(
1599 Importer.getFromContext(), Importer.getToContext(),
1600 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1602 return Ctx.IsEquivalent(From, To);
1605 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
1606 RecordDecl *ToRecord, bool Complain) {
1607 // Eliminate a potential failure point where we attempt to re-import
1608 // something we're trying to import while completing ToRecord.
1609 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
1611 auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
1613 ToRecord = ToOriginRecord;
1616 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1617 ToRecord->getASTContext(),
1618 Importer.getNonEquivalentDecls(),
1619 getStructuralEquivalenceKind(Importer),
1621 return Ctx.IsEquivalent(FromRecord, ToRecord);
1624 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
1626 StructuralEquivalenceContext Ctx(
1627 Importer.getFromContext(), Importer.getToContext(),
1628 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1630 return Ctx.IsEquivalent(FromVar, ToVar);
1633 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
1634 StructuralEquivalenceContext Ctx(
1635 Importer.getFromContext(), Importer.getToContext(),
1636 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
1637 return Ctx.IsEquivalent(FromEnum, ToEnum);
1640 bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
1641 FunctionTemplateDecl *To) {
1642 StructuralEquivalenceContext Ctx(
1643 Importer.getFromContext(), Importer.getToContext(),
1644 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1646 return Ctx.IsEquivalent(From, To);
1649 bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
1650 StructuralEquivalenceContext Ctx(
1651 Importer.getFromContext(), Importer.getToContext(),
1652 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1654 return Ctx.IsEquivalent(From, To);
1657 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
1658 EnumConstantDecl *ToEC) {
1659 const llvm::APSInt &FromVal = FromEC->getInitVal();
1660 const llvm::APSInt &ToVal = ToEC->getInitVal();
1662 return FromVal.isSigned() == ToVal.isSigned() &&
1663 FromVal.getBitWidth() == ToVal.getBitWidth() &&
1667 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
1668 ClassTemplateDecl *To) {
1669 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1670 Importer.getToContext(),
1671 Importer.getNonEquivalentDecls(),
1672 getStructuralEquivalenceKind(Importer));
1673 return Ctx.IsEquivalent(From, To);
1676 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
1677 VarTemplateDecl *To) {
1678 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1679 Importer.getToContext(),
1680 Importer.getNonEquivalentDecls(),
1681 getStructuralEquivalenceKind(Importer));
1682 return Ctx.IsEquivalent(From, To);
1685 Decl *ASTNodeImporter::VisitDecl(Decl *D) {
1686 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1687 << D->getDeclKindName();
1691 Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
1692 // Import the context of this declaration.
1693 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1697 DeclContext *LexicalDC = DC;
1698 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1699 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1704 // Import the location of this declaration.
1705 SourceLocation Loc = Importer.Import(D->getLocation());
1708 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
1711 ToD->setLexicalDeclContext(LexicalDC);
1712 LexicalDC->addDeclInternal(ToD);
1716 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
1717 TranslationUnitDecl *ToD =
1718 Importer.getToContext().getTranslationUnitDecl();
1720 Importer.MapImported(D, ToD);
1725 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
1726 SourceLocation Loc = Importer.Import(D->getLocation());
1727 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
1729 // Import the context of this declaration.
1730 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1734 AccessSpecDecl *ToD;
1735 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
1739 // Lexical DeclContext and Semantic DeclContext
1740 // is always the same for the accessSpec.
1741 ToD->setLexicalDeclContext(DC);
1742 DC->addDeclInternal(ToD);
1747 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1748 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1752 DeclContext *LexicalDC = DC;
1754 // Import the location of this declaration.
1755 SourceLocation Loc = Importer.Import(D->getLocation());
1757 Expr *AssertExpr = Importer.Import(D->getAssertExpr());
1761 StringLiteral *FromMsg = D->getMessage();
1762 auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
1763 if (!ToMsg && FromMsg)
1766 StaticAssertDecl *ToD;
1767 if (GetImportedOrCreateDecl(
1768 ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
1769 Importer.Import(D->getRParenLoc()), D->isFailed()))
1772 ToD->setLexicalDeclContext(LexicalDC);
1773 LexicalDC->addDeclInternal(ToD);
1777 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
1778 // Import the major distinguishing characteristics of this namespace.
1779 DeclContext *DC, *LexicalDC;
1780 DeclarationName Name;
1783 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1788 NamespaceDecl *MergeWithNamespace = nullptr;
1790 // This is an anonymous namespace. Adopt an existing anonymous
1791 // namespace if we can.
1792 // FIXME: Not testable.
1793 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1794 MergeWithNamespace = TU->getAnonymousNamespace();
1796 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
1798 SmallVector<NamedDecl *, 4> ConflictingDecls;
1799 SmallVector<NamedDecl *, 2> FoundDecls;
1800 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1801 for (auto *FoundDecl : FoundDecls) {
1802 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
1805 if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
1806 MergeWithNamespace = FoundNS;
1807 ConflictingDecls.clear();
1811 ConflictingDecls.push_back(FoundDecl);
1814 if (!ConflictingDecls.empty()) {
1815 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
1816 ConflictingDecls.data(),
1817 ConflictingDecls.size());
1821 // Create the "to" namespace, if needed.
1822 NamespaceDecl *ToNamespace = MergeWithNamespace;
1824 if (GetImportedOrCreateDecl(
1825 ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
1826 Importer.Import(D->getLocStart()), Loc, Name.getAsIdentifierInfo(),
1827 /*PrevDecl=*/nullptr))
1829 ToNamespace->setLexicalDeclContext(LexicalDC);
1830 LexicalDC->addDeclInternal(ToNamespace);
1832 // If this is an anonymous namespace, register it as the anonymous
1833 // namespace within its context.
1835 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
1836 TU->setAnonymousNamespace(ToNamespace);
1838 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
1841 Importer.MapImported(D, ToNamespace);
1843 ImportDeclContext(D);
1848 Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1849 // Import the major distinguishing characteristics of this namespace.
1850 DeclContext *DC, *LexicalDC;
1851 DeclarationName Name;
1854 if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
1859 // NOTE: No conflict resolution is done for namespace aliases now.
1861 auto *TargetDecl = cast_or_null<NamespaceDecl>(
1862 Importer.Import(D->getNamespace()));
1866 IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
1870 NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
1871 if (D->getQualifierLoc() && !ToQLoc)
1874 NamespaceAliasDecl *ToD;
1875 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
1876 Importer.Import(D->getNamespaceLoc()),
1877 Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
1878 Importer.Import(D->getTargetNameLoc()),
1882 ToD->setLexicalDeclContext(LexicalDC);
1883 LexicalDC->addDeclInternal(ToD);
1888 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
1889 // Import the major distinguishing characteristics of this typedef.
1890 DeclContext *DC, *LexicalDC;
1891 DeclarationName Name;
1894 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
1899 // If this typedef is not in block scope, determine whether we've
1900 // seen a typedef with the same name (that we can merge with) or any
1901 // other entity by that name (which name lookup could conflict with).
1902 if (!DC->isFunctionOrMethod()) {
1903 SmallVector<NamedDecl *, 4> ConflictingDecls;
1904 unsigned IDNS = Decl::IDNS_Ordinary;
1905 SmallVector<NamedDecl *, 2> FoundDecls;
1906 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1907 for (auto *FoundDecl : FoundDecls) {
1908 if (!FoundDecl->isInIdentifierNamespace(IDNS))
1910 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
1911 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
1912 FoundTypedef->getUnderlyingType()))
1913 return Importer.MapImported(D, FoundTypedef);
1916 ConflictingDecls.push_back(FoundDecl);
1919 if (!ConflictingDecls.empty()) {
1920 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1921 ConflictingDecls.data(),
1922 ConflictingDecls.size());
1928 // Import the underlying type of this typedef;
1929 QualType T = Importer.Import(D->getUnderlyingType());
1933 // Create the new typedef node.
1934 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
1935 SourceLocation StartL = Importer.Import(D->getLocStart());
1937 TypedefNameDecl *ToTypedef;
1939 if (GetImportedOrCreateDecl<TypeAliasDecl>(
1940 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1941 Name.getAsIdentifierInfo(), TInfo))
1943 } else if (GetImportedOrCreateDecl<TypedefDecl>(
1944 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1945 Name.getAsIdentifierInfo(), TInfo))
1948 ToTypedef->setAccess(D->getAccess());
1949 ToTypedef->setLexicalDeclContext(LexicalDC);
1951 // Templated declarations should not appear in DeclContext.
1952 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
1953 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
1954 LexicalDC->addDeclInternal(ToTypedef);
1959 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
1960 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1963 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
1964 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1967 Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1968 // Import the major distinguishing characteristics of this typedef.
1969 DeclContext *DC, *LexicalDC;
1970 DeclarationName Name;
1973 if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
1978 // If this typedef is not in block scope, determine whether we've
1979 // seen a typedef with the same name (that we can merge with) or any
1980 // other entity by that name (which name lookup could conflict with).
1981 if (!DC->isFunctionOrMethod()) {
1982 SmallVector<NamedDecl *, 4> ConflictingDecls;
1983 unsigned IDNS = Decl::IDNS_Ordinary;
1984 SmallVector<NamedDecl *, 2> FoundDecls;
1985 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
1986 for (auto *FoundDecl : FoundDecls) {
1987 if (!FoundDecl->isInIdentifierNamespace(IDNS))
1989 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
1990 return Importer.MapImported(D, FoundAlias);
1991 ConflictingDecls.push_back(FoundDecl);
1994 if (!ConflictingDecls.empty()) {
1995 Name = Importer.HandleNameConflict(Name, DC, IDNS,
1996 ConflictingDecls.data(),
1997 ConflictingDecls.size());
2003 TemplateParameterList *Params = ImportTemplateParameterList(
2004 D->getTemplateParameters());
2008 auto *TemplDecl = cast_or_null<TypeAliasDecl>(
2009 Importer.Import(D->getTemplatedDecl()));
2013 TypeAliasTemplateDecl *ToAlias;
2014 if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2015 Name, Params, TemplDecl))
2018 TemplDecl->setDescribedAliasTemplate(ToAlias);
2020 ToAlias->setAccess(D->getAccess());
2021 ToAlias->setLexicalDeclContext(LexicalDC);
2022 LexicalDC->addDeclInternal(ToAlias);
2026 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2027 // Import the major distinguishing characteristics of this label.
2028 DeclContext *DC, *LexicalDC;
2029 DeclarationName Name;
2032 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2037 assert(LexicalDC->isFunctionOrMethod());
2041 ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2042 Importer.Import(D->getLocation()),
2043 Name.getAsIdentifierInfo(),
2044 Importer.Import(D->getLocStart()))
2045 : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2046 Importer.Import(D->getLocation()),
2047 Name.getAsIdentifierInfo()))
2050 auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
2054 ToLabel->setStmt(Label);
2055 ToLabel->setLexicalDeclContext(LexicalDC);
2056 LexicalDC->addDeclInternal(ToLabel);
2060 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2061 // Import the major distinguishing characteristics of this enum.
2062 DeclContext *DC, *LexicalDC;
2063 DeclarationName Name;
2066 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2071 // Figure out what enum name we're looking for.
2072 unsigned IDNS = Decl::IDNS_Tag;
2073 DeclarationName SearchName = Name;
2074 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2075 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2076 IDNS = Decl::IDNS_Ordinary;
2077 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2078 IDNS |= Decl::IDNS_Ordinary;
2080 // We may already have an enum of the same name; try to find and match it.
2081 if (!DC->isFunctionOrMethod() && SearchName) {
2082 SmallVector<NamedDecl *, 4> ConflictingDecls;
2083 SmallVector<NamedDecl *, 2> FoundDecls;
2084 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2085 for (auto *FoundDecl : FoundDecls) {
2086 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2089 Decl *Found = FoundDecl;
2090 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2091 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2092 Found = Tag->getDecl();
2095 if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
2096 if (IsStructuralMatch(D, FoundEnum))
2097 return Importer.MapImported(D, FoundEnum);
2100 ConflictingDecls.push_back(FoundDecl);
2103 if (!ConflictingDecls.empty()) {
2104 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2105 ConflictingDecls.data(),
2106 ConflictingDecls.size());
2110 // Create the enum declaration.
2112 if (GetImportedOrCreateDecl(
2113 D2, D, Importer.getToContext(), DC, Importer.Import(D->getLocStart()),
2114 Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(),
2115 D->isScopedUsingClassTag(), D->isFixed()))
2118 // Import the qualifier, if any.
2119 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2120 D2->setAccess(D->getAccess());
2121 D2->setLexicalDeclContext(LexicalDC);
2122 LexicalDC->addDeclInternal(D2);
2124 // Import the integer type.
2125 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2126 if (ToIntegerType.isNull())
2128 D2->setIntegerType(ToIntegerType);
2130 // Import the definition
2131 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
2137 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2138 // If this record has a definition in the translation unit we're coming from,
2139 // but this particular declaration is not that definition, import the
2140 // definition and map to that.
2141 TagDecl *Definition = D->getDefinition();
2142 if (Definition && Definition != D &&
2143 // In contrast to a normal CXXRecordDecl, the implicit
2144 // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
2145 // The definition of the implicit CXXRecordDecl in this case is the
2146 // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
2147 // condition in order to be able to import the implict Decl.
2149 Decl *ImportedDef = Importer.Import(Definition);
2153 return Importer.MapImported(D, ImportedDef);
2156 // Import the major distinguishing characteristics of this record.
2157 DeclContext *DC, *LexicalDC;
2158 DeclarationName Name;
2161 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2166 // Figure out what structure name we're looking for.
2167 unsigned IDNS = Decl::IDNS_Tag;
2168 DeclarationName SearchName = Name;
2169 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2170 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
2171 IDNS = Decl::IDNS_Ordinary;
2172 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2173 IDNS |= Decl::IDNS_Ordinary;
2175 // We may already have a record of the same name; try to find and match it.
2176 RecordDecl *AdoptDecl = nullptr;
2177 RecordDecl *PrevDecl = nullptr;
2178 if (!DC->isFunctionOrMethod()) {
2179 SmallVector<NamedDecl *, 4> ConflictingDecls;
2180 SmallVector<NamedDecl *, 2> FoundDecls;
2181 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
2183 if (!FoundDecls.empty()) {
2184 // We're going to have to compare D against potentially conflicting Decls, so complete it.
2185 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2186 D->getASTContext().getExternalSource()->CompleteType(D);
2189 for (auto *FoundDecl : FoundDecls) {
2190 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2193 Decl *Found = FoundDecl;
2194 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2195 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2196 Found = Tag->getDecl();
2199 if (D->getDescribedTemplate()) {
2200 if (auto *Template = dyn_cast<ClassTemplateDecl>(Found))
2201 Found = Template->getTemplatedDecl();
2206 if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2208 if (!IsStructuralMatch(D, FoundRecord, false))
2212 PrevDecl = FoundRecord;
2214 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
2215 if ((SearchName && !D->isCompleteDefinition())
2216 || (D->isCompleteDefinition() &&
2217 D->isAnonymousStructOrUnion()
2218 == FoundDef->isAnonymousStructOrUnion() &&
2219 IsStructuralMatch(D, FoundDef))) {
2220 // The record types structurally match, or the "from" translation
2221 // unit only had a forward declaration anyway; call it the same
2223 // FIXME: Structural equivalence check should check for same
2224 // user-defined methods.
2225 Importer.MapImported(D, FoundDef);
2226 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2227 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2228 assert(FoundCXX && "Record type mismatch");
2230 if (D->isCompleteDefinition() && !Importer.isMinimalImport())
2231 // FoundDef may not have every implicit method that D has
2232 // because implicit methods are created only if they are used.
2233 ImportImplicitMethods(DCXX, FoundCXX);
2237 } else if (!D->isCompleteDefinition()) {
2238 // We have a forward declaration of this type, so adopt that forward
2239 // declaration rather than building a new one.
2241 // If one or both can be completed from external storage then try one
2242 // last time to complete and compare them before doing this.
2244 if (FoundRecord->hasExternalLexicalStorage() &&
2245 !FoundRecord->isCompleteDefinition())
2246 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2247 if (D->hasExternalLexicalStorage())
2248 D->getASTContext().getExternalSource()->CompleteType(D);
2250 if (FoundRecord->isCompleteDefinition() &&
2251 D->isCompleteDefinition() &&
2252 !IsStructuralMatch(D, FoundRecord))
2255 AdoptDecl = FoundRecord;
2257 } else if (!SearchName) {
2262 ConflictingDecls.push_back(FoundDecl);
2265 if (!ConflictingDecls.empty() && SearchName) {
2266 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2267 ConflictingDecls.data(),
2268 ConflictingDecls.size());
2272 // Create the record declaration.
2273 RecordDecl *D2 = AdoptDecl;
2274 SourceLocation StartLoc = Importer.Import(D->getLocStart());
2276 CXXRecordDecl *D2CXX = nullptr;
2277 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2278 if (DCXX->isLambda()) {
2279 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
2280 if (GetImportedOrCreateSpecialDecl(
2281 D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2282 DC, TInfo, Loc, DCXX->isDependentLambda(),
2283 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2285 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2286 if (DCXX->getLambdaContextDecl() && !CDecl)
2288 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
2289 } else if (DCXX->isInjectedClassName()) {
2290 // We have to be careful to do a similar dance to the one in
2291 // Sema::ActOnStartCXXMemberDeclarations
2292 CXXRecordDecl *const PrevDecl = nullptr;
2293 const bool DelayTypeCreation = true;
2294 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2295 D->getTagKind(), DC, StartLoc, Loc,
2296 Name.getAsIdentifierInfo(), PrevDecl,
2299 Importer.getToContext().getTypeDeclType(
2300 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2302 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2303 D->getTagKind(), DC, StartLoc, Loc,
2304 Name.getAsIdentifierInfo(),
2305 cast_or_null<CXXRecordDecl>(PrevDecl)))
2310 D2->setAccess(D->getAccess());
2311 D2->setLexicalDeclContext(LexicalDC);
2312 if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
2313 LexicalDC->addDeclInternal(D2);
2315 if (ClassTemplateDecl *FromDescribed =
2316 DCXX->getDescribedClassTemplate()) {
2317 auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
2318 Importer.Import(FromDescribed));
2321 D2CXX->setDescribedClassTemplate(ToDescribed);
2322 if (!DCXX->isInjectedClassName()) {
2323 // In a record describing a template the type should be an
2324 // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2325 // previously set type to the correct value here (ToDescribed is not
2326 // available at record create).
2327 // FIXME: The previous type is cleared but not removed from
2328 // ASTContext's internal storage.
2329 CXXRecordDecl *Injected = nullptr;
2330 for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2331 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2332 if (Record && Record->isInjectedClassName()) {
2337 D2CXX->setTypeForDecl(nullptr);
2338 Importer.getToContext().getInjectedClassNameType(D2CXX,
2339 ToDescribed->getInjectedClassNameSpecialization());
2341 Injected->setTypeForDecl(nullptr);
2342 Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2345 } else if (MemberSpecializationInfo *MemberInfo =
2346 DCXX->getMemberSpecializationInfo()) {
2347 TemplateSpecializationKind SK =
2348 MemberInfo->getTemplateSpecializationKind();
2349 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
2351 cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
2352 if (FromInst && !ToInst)
2354 D2CXX->setInstantiationOfMemberClass(ToInst, SK);
2355 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
2356 Importer.Import(MemberInfo->getPointOfInstantiation()));
2359 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2360 D->getTagKind(), DC, StartLoc, Loc,
2361 Name.getAsIdentifierInfo(), PrevDecl))
2363 D2->setLexicalDeclContext(LexicalDC);
2364 LexicalDC->addDeclInternal(D2);
2367 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2368 if (D->isAnonymousStructOrUnion())
2369 D2->setAnonymousStructOrUnion(true);
2372 Importer.MapImported(D, D2);
2374 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
2380 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2381 // Import the major distinguishing characteristics of this enumerator.
2382 DeclContext *DC, *LexicalDC;
2383 DeclarationName Name;
2386 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2391 QualType T = Importer.Import(D->getType());
2395 // Determine whether there are any other declarations with the same name and
2396 // in the same context.
2397 if (!LexicalDC->isFunctionOrMethod()) {
2398 SmallVector<NamedDecl *, 4> ConflictingDecls;
2399 unsigned IDNS = Decl::IDNS_Ordinary;
2400 SmallVector<NamedDecl *, 2> FoundDecls;
2401 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2402 for (auto *FoundDecl : FoundDecls) {
2403 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2406 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
2407 if (IsStructuralMatch(D, FoundEnumConstant))
2408 return Importer.MapImported(D, FoundEnumConstant);
2411 ConflictingDecls.push_back(FoundDecl);
2414 if (!ConflictingDecls.empty()) {
2415 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2416 ConflictingDecls.data(),
2417 ConflictingDecls.size());
2423 Expr *Init = Importer.Import(D->getInitExpr());
2424 if (D->getInitExpr() && !Init)
2427 EnumConstantDecl *ToEnumerator;
2428 if (GetImportedOrCreateDecl(
2429 ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2430 Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
2431 return ToEnumerator;
2433 ToEnumerator->setAccess(D->getAccess());
2434 ToEnumerator->setLexicalDeclContext(LexicalDC);
2435 LexicalDC->addDeclInternal(ToEnumerator);
2436 return ToEnumerator;
2439 bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
2440 FunctionDecl *ToFD) {
2441 switch (FromFD->getTemplatedKind()) {
2442 case FunctionDecl::TK_NonTemplate:
2443 case FunctionDecl::TK_FunctionTemplate:
2446 case FunctionDecl::TK_MemberSpecialization: {
2447 auto *InstFD = cast_or_null<FunctionDecl>(
2448 Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
2452 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
2453 SourceLocation POI = Importer.Import(
2454 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation());
2455 ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
2456 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
2460 case FunctionDecl::TK_FunctionTemplateSpecialization: {
2461 FunctionTemplateDecl* Template;
2462 OptionalTemplateArgsTy ToTemplArgs;
2463 std::tie(Template, ToTemplArgs) =
2464 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2465 if (!Template || !ToTemplArgs)
2468 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
2469 Importer.getToContext(), *ToTemplArgs);
2471 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
2472 TemplateArgumentListInfo ToTAInfo;
2473 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
2474 if (FromTAArgsAsWritten)
2475 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
2478 SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation());
2480 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
2481 ToFD->setFunctionTemplateSpecialization(
2482 Template, ToTAList, /* InsertPos= */ nullptr,
2483 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI);
2487 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
2488 auto *FromInfo = FromFD->getDependentSpecializationInfo();
2489 UnresolvedSet<8> TemplDecls;
2490 unsigned NumTemplates = FromInfo->getNumTemplates();
2491 for (unsigned I = 0; I < NumTemplates; I++) {
2492 if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
2493 Importer.Import(FromInfo->getTemplate(I))))
2494 TemplDecls.addDecl(ToFTD);
2499 // Import TemplateArgumentListInfo.
2500 TemplateArgumentListInfo ToTAInfo;
2501 if (ImportTemplateArgumentListInfo(
2502 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
2503 llvm::makeArrayRef(FromInfo->getTemplateArgs(),
2504 FromInfo->getNumTemplateArgs()),
2508 ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
2509 TemplDecls, ToTAInfo);
2513 llvm_unreachable("All cases should be covered!");
2517 ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
2518 FunctionTemplateDecl* Template;
2519 OptionalTemplateArgsTy ToTemplArgs;
2520 std::tie(Template, ToTemplArgs) =
2521 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2522 if (!Template || !ToTemplArgs)
2525 void *InsertPos = nullptr;
2526 auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
2530 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
2532 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
2533 auto RedeclIt = Redecls.begin();
2534 // Import the first part of the decl chain. I.e. import all previous
2535 // declarations starting from the canonical decl.
2536 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
2537 if (!Importer.Import(*RedeclIt))
2539 assert(*RedeclIt == D);
2541 // Import the major distinguishing characteristics of this function.
2542 DeclContext *DC, *LexicalDC;
2543 DeclarationName Name;
2546 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2551 const FunctionDecl *FoundByLookup = nullptr;
2552 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
2554 // If this is a function template specialization, then try to find the same
2555 // existing specialization in the "to" context. The localUncachedLookup
2556 // below will not find any specialization, but would find the primary
2557 // template; thus, we have to skip normal lookup in case of specializations.
2558 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
2559 if (D->getTemplatedKind() ==
2560 FunctionDecl::TK_FunctionTemplateSpecialization) {
2561 if (FunctionDecl *FoundFunction = FindFunctionTemplateSpecialization(D)) {
2562 if (D->doesThisDeclarationHaveABody() &&
2563 FoundFunction->hasBody())
2564 return Importer.Imported(D, FoundFunction);
2565 FoundByLookup = FoundFunction;
2568 // Try to find a function in our own ("to") context with the same name, same
2569 // type, and in the same context as the function we're importing.
2570 else if (!LexicalDC->isFunctionOrMethod()) {
2571 SmallVector<NamedDecl *, 4> ConflictingDecls;
2572 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
2573 SmallVector<NamedDecl *, 2> FoundDecls;
2574 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2575 for (auto *FoundDecl : FoundDecls) {
2576 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2579 // If template was found, look at the templated function.
2581 if (auto *Template = dyn_cast<FunctionTemplateDecl>(FoundDecl))
2582 FoundDecl = Template->getTemplatedDecl();
2587 if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
2588 if (FoundFunction->hasExternalFormalLinkage() &&
2589 D->hasExternalFormalLinkage()) {
2590 if (IsStructuralMatch(D, FoundFunction)) {
2591 const FunctionDecl *Definition = nullptr;
2592 if (D->doesThisDeclarationHaveABody() &&
2593 FoundFunction->hasBody(Definition)) {
2594 return Importer.MapImported(
2595 D, const_cast<FunctionDecl *>(Definition));
2597 FoundByLookup = FoundFunction;
2601 // FIXME: Check for overloading more carefully, e.g., by boosting
2602 // Sema::IsOverload out to the AST library.
2604 // Function overloading is okay in C++.
2605 if (Importer.getToContext().getLangOpts().CPlusPlus)
2608 // Complain about inconsistent function types.
2609 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
2610 << Name << D->getType() << FoundFunction->getType();
2611 Importer.ToDiag(FoundFunction->getLocation(),
2612 diag::note_odr_value_here)
2613 << FoundFunction->getType();
2617 ConflictingDecls.push_back(FoundDecl);
2620 if (!ConflictingDecls.empty()) {
2621 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2622 ConflictingDecls.data(),
2623 ConflictingDecls.size());
2629 DeclarationNameInfo NameInfo(Name, Loc);
2630 // Import additional name location/type info.
2631 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2633 QualType FromTy = D->getType();
2634 bool usedDifferentExceptionSpec = false;
2636 if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
2637 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2638 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2639 // FunctionDecl that we are importing the FunctionProtoType for.
2640 // To avoid an infinite recursion when importing, create the FunctionDecl
2641 // with a simplified function type and update it afterwards.
2642 if (FromEPI.ExceptionSpec.SourceDecl ||
2643 FromEPI.ExceptionSpec.SourceTemplate ||
2644 FromEPI.ExceptionSpec.NoexceptExpr) {
2645 FunctionProtoType::ExtProtoInfo DefaultEPI;
2646 FromTy = Importer.getFromContext().getFunctionType(
2647 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
2648 usedDifferentExceptionSpec = true;
2653 QualType T = Importer.Import(FromTy);
2657 // Import the function parameters.
2658 SmallVector<ParmVarDecl *, 8> Parameters;
2659 for (auto P : D->parameters()) {
2660 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
2664 Parameters.push_back(ToP);
2667 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2668 if (D->getTypeSourceInfo() && !TInfo)
2671 // Create the imported function.
2672 FunctionDecl *ToFunction = nullptr;
2673 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
2674 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
2675 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
2676 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2677 InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
2678 D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
2680 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
2681 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
2682 for (auto *I : FromConstructor->inits()) {
2683 auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
2686 CtorInitializers.push_back(ToI);
2689 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
2690 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
2691 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
2692 ToCtor->setCtorInitializers(Memory);
2693 ToCtor->setNumCtorInitializers(NumInitializers);
2695 } else if (isa<CXXDestructorDecl>(D)) {
2696 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
2697 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2698 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2701 } else if (CXXConversionDecl *FromConversion =
2702 dyn_cast<CXXConversionDecl>(D)) {
2703 if (GetImportedOrCreateDecl<CXXConversionDecl>(
2704 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2705 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2706 FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
2708 } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
2709 if (GetImportedOrCreateDecl<CXXMethodDecl>(
2710 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2711 InnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
2712 Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
2715 if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
2716 InnerLocStart, NameInfo, T, TInfo,
2717 D->getStorageClass(), D->isInlineSpecified(),
2718 D->hasWrittenPrototype(), D->isConstexpr()))
2722 // Import the qualifier, if any.
2723 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
2724 ToFunction->setAccess(D->getAccess());
2725 ToFunction->setLexicalDeclContext(LexicalDC);
2726 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2727 ToFunction->setTrivial(D->isTrivial());
2728 ToFunction->setPure(D->isPure());
2729 ToFunction->setRangeEnd(Importer.Import(D->getLocEnd()));
2731 // Set the parameters.
2732 for (auto *Param : Parameters) {
2733 Param->setOwningFunction(ToFunction);
2734 ToFunction->addDeclInternal(Param);
2736 ToFunction->setParams(Parameters);
2738 if (FoundByLookup) {
2739 auto *Recent = const_cast<FunctionDecl *>(
2740 FoundByLookup->getMostRecentDecl());
2741 ToFunction->setPreviousDecl(Recent);
2744 // We need to complete creation of FunctionProtoTypeLoc manually with setting
2745 // params it refers to.
2748 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
2749 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
2750 ProtoLoc.setParam(I, Parameters[I]);
2754 if (usedDifferentExceptionSpec) {
2755 // Update FunctionProtoType::ExtProtoInfo.
2756 QualType T = Importer.Import(D->getType());
2759 ToFunction->setType(T);
2762 // Import the describing template function, if any.
2764 if (!Importer.Import(FromFT))
2767 if (D->doesThisDeclarationHaveABody()) {
2768 if (Stmt *FromBody = D->getBody()) {
2769 if (Stmt *ToBody = Importer.Import(FromBody)) {
2770 ToFunction->setBody(ToBody);
2775 // FIXME: Other bits to merge?
2777 // If it is a template, import all related things.
2778 if (ImportTemplateInformation(D, ToFunction))
2781 bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);
2783 // TODO Can we generalize this approach to other AST nodes as well?
2784 if (D->getDeclContext()->containsDeclAndLoad(D))
2785 DC->addDeclInternal(ToFunction);
2786 if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
2787 LexicalDC->addDeclInternal(ToFunction);
2789 // Friend declaration's lexical context is the befriending class, but the
2790 // semantic context is the enclosing scope of the befriending class.
2791 // We want the friend functions to be found in the semantic context by lookup.
2792 // FIXME should we handle this generically in VisitFriendDecl?
2793 // In Other cases when LexicalDC != DC we don't want it to be added,
2794 // e.g out-of-class definitions like void B::f() {} .
2795 if (LexicalDC != DC && IsFriend) {
2796 DC->makeDeclVisibleInContext(ToFunction);
2799 // Import the rest of the chain. I.e. import all subsequent declarations.
2800 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
2801 if (!Importer.Import(*RedeclIt))
2804 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
2805 ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
2810 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2811 return VisitFunctionDecl(D);
2814 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2815 return VisitCXXMethodDecl(D);
2818 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2819 return VisitCXXMethodDecl(D);
2822 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2823 return VisitCXXMethodDecl(D);
2826 static unsigned getFieldIndex(Decl *F) {
2827 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
2832 for (const auto *D : Owner->noload_decls()) {
2836 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
2843 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2844 // Import the major distinguishing characteristics of a variable.
2845 DeclContext *DC, *LexicalDC;
2846 DeclarationName Name;
2849 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2854 // Determine whether we've already imported this field.
2855 SmallVector<NamedDecl *, 2> FoundDecls;
2856 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2857 for (auto *FoundDecl : FoundDecls) {
2858 if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
2859 // For anonymous fields, match up by index.
2860 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2863 if (Importer.IsStructurallyEquivalent(D->getType(),
2864 FoundField->getType())) {
2865 Importer.MapImported(D, FoundField);
2869 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2870 << Name << D->getType() << FoundField->getType();
2871 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2872 << FoundField->getType();
2878 QualType T = Importer.Import(D->getType());
2882 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2883 Expr *BitWidth = Importer.Import(D->getBitWidth());
2884 if (!BitWidth && D->getBitWidth())
2888 if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
2889 Importer.Import(D->getInnerLocStart()), Loc,
2890 Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
2891 D->isMutable(), D->getInClassInitStyle()))
2894 ToField->setAccess(D->getAccess());
2895 ToField->setLexicalDeclContext(LexicalDC);
2896 if (Expr *FromInitializer = D->getInClassInitializer()) {
2897 Expr *ToInitializer = Importer.Import(FromInitializer);
2899 ToField->setInClassInitializer(ToInitializer);
2903 ToField->setImplicit(D->isImplicit());
2904 LexicalDC->addDeclInternal(ToField);
2908 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2909 // Import the major distinguishing characteristics of a variable.
2910 DeclContext *DC, *LexicalDC;
2911 DeclarationName Name;
2914 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2919 // Determine whether we've already imported this field.
2920 SmallVector<NamedDecl *, 2> FoundDecls;
2921 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
2922 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
2923 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
2924 // For anonymous indirect fields, match up by index.
2925 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField))
2928 if (Importer.IsStructurallyEquivalent(D->getType(),
2929 FoundField->getType(),
2931 Importer.MapImported(D, FoundField);
2935 // If there are more anonymous fields to check, continue.
2936 if (!Name && I < N-1)
2939 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2940 << Name << D->getType() << FoundField->getType();
2941 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2942 << FoundField->getType();
2948 QualType T = Importer.Import(D->getType());
2953 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
2956 for (auto *PI : D->chain()) {
2957 Decl *D = Importer.Import(PI);
2960 NamedChain[i++] = cast<NamedDecl>(D);
2963 llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
2964 IndirectFieldDecl *ToIndirectField;
2965 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
2966 Loc, Name.getAsIdentifierInfo(), T, CH))
2967 // FIXME here we leak `NamedChain` which is allocated before
2968 return ToIndirectField;
2970 for (const auto *A : D->attrs())
2971 ToIndirectField->addAttr(Importer.Import(A));
2973 ToIndirectField->setAccess(D->getAccess());
2974 ToIndirectField->setLexicalDeclContext(LexicalDC);
2975 LexicalDC->addDeclInternal(ToIndirectField);
2976 return ToIndirectField;
2979 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
2980 // Import the major distinguishing characteristics of a declaration.
2981 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
2982 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
2983 ? DC : Importer.ImportContext(D->getLexicalDeclContext());
2984 if (!DC || !LexicalDC)
2987 // Determine whether we've already imported this decl.
2988 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
2989 auto *RD = cast<CXXRecordDecl>(DC);
2990 FriendDecl *ImportedFriend = RD->getFirstFriend();
2992 while (ImportedFriend) {
2993 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
2994 if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
2995 /*Complain=*/false))
2996 return Importer.MapImported(D, ImportedFriend);
2998 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
2999 if (Importer.IsStructurallyEquivalent(
3000 D->getFriendType()->getType(),
3001 ImportedFriend->getFriendType()->getType(), true))
3002 return Importer.MapImported(D, ImportedFriend);
3004 ImportedFriend = ImportedFriend->getNextFriend();
3007 // Not found. Create it.
3008 FriendDecl::FriendUnion ToFU;
3009 if (NamedDecl *FriendD = D->getFriendDecl()) {
3010 auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3011 if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
3012 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3013 ToFriendD->setObjectOfFriendDecl(false);
3016 } else // The friend is a type, not a decl.
3017 ToFU = Importer.Import(D->getFriendType());
3021 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3022 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3023 for (unsigned I = 0; I < D->NumTPLists; I++) {
3024 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3027 ToTPLists[I] = List;
3031 if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3032 Importer.Import(D->getLocation()), ToFU,
3033 Importer.Import(D->getFriendLoc()), ToTPLists))
3036 FrD->setAccess(D->getAccess());
3037 FrD->setLexicalDeclContext(LexicalDC);
3038 LexicalDC->addDeclInternal(FrD);
3042 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3043 // Import the major distinguishing characteristics of an ivar.
3044 DeclContext *DC, *LexicalDC;
3045 DeclarationName Name;
3048 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3053 // Determine whether we've already imported this ivar
3054 SmallVector<NamedDecl *, 2> FoundDecls;
3055 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3056 for (auto *FoundDecl : FoundDecls) {
3057 if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3058 if (Importer.IsStructurallyEquivalent(D->getType(),
3059 FoundIvar->getType())) {
3060 Importer.MapImported(D, FoundIvar);
3064 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3065 << Name << D->getType() << FoundIvar->getType();
3066 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3067 << FoundIvar->getType();
3073 QualType T = Importer.Import(D->getType());
3077 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3078 Expr *BitWidth = Importer.Import(D->getBitWidth());
3079 if (!BitWidth && D->getBitWidth())
3082 ObjCIvarDecl *ToIvar;
3083 if (GetImportedOrCreateDecl(
3084 ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3085 Importer.Import(D->getInnerLocStart()), Loc,
3086 Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
3087 D->getSynthesize()))
3090 ToIvar->setLexicalDeclContext(LexicalDC);
3091 LexicalDC->addDeclInternal(ToIvar);
3095 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3096 // Import the major distinguishing characteristics of a variable.
3097 DeclContext *DC, *LexicalDC;
3098 DeclarationName Name;
3101 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3106 // Try to find a variable in our own ("to") context with the same name and
3107 // in the same context as the variable we're importing.
3108 if (D->isFileVarDecl()) {
3109 VarDecl *MergeWithVar = nullptr;
3110 SmallVector<NamedDecl *, 4> ConflictingDecls;
3111 unsigned IDNS = Decl::IDNS_Ordinary;
3112 SmallVector<NamedDecl *, 2> FoundDecls;
3113 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3114 for (auto *FoundDecl : FoundDecls) {
3115 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3118 if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
3119 // We have found a variable that we may need to merge with. Check it.
3120 if (FoundVar->hasExternalFormalLinkage() &&
3121 D->hasExternalFormalLinkage()) {
3122 if (Importer.IsStructurallyEquivalent(D->getType(),
3123 FoundVar->getType())) {
3124 MergeWithVar = FoundVar;
3128 const ArrayType *FoundArray
3129 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3130 const ArrayType *TArray
3131 = Importer.getToContext().getAsArrayType(D->getType());
3132 if (FoundArray && TArray) {
3133 if (isa<IncompleteArrayType>(FoundArray) &&
3134 isa<ConstantArrayType>(TArray)) {
3136 QualType T = Importer.Import(D->getType());
3140 FoundVar->setType(T);
3141 MergeWithVar = FoundVar;
3143 } else if (isa<IncompleteArrayType>(TArray) &&
3144 isa<ConstantArrayType>(FoundArray)) {
3145 MergeWithVar = FoundVar;
3150 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
3151 << Name << D->getType() << FoundVar->getType();
3152 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3153 << FoundVar->getType();
3157 ConflictingDecls.push_back(FoundDecl);
3161 // An equivalent variable with external linkage has been found. Link
3162 // the two declarations, then merge them.
3163 Importer.MapImported(D, MergeWithVar);
3164 updateFlags(D, MergeWithVar);
3166 if (VarDecl *DDef = D->getDefinition()) {
3167 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
3168 Importer.ToDiag(ExistingDef->getLocation(),
3169 diag::err_odr_variable_multiple_def)
3171 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3173 Expr *Init = Importer.Import(DDef->getInit());
3174 MergeWithVar->setInit(Init);
3175 if (DDef->isInitKnownICE()) {
3176 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3177 Eval->CheckedICE = true;
3178 Eval->IsICE = DDef->isInitICE();
3183 return MergeWithVar;
3186 if (!ConflictingDecls.empty()) {
3187 Name = Importer.HandleNameConflict(Name, DC, IDNS,
3188 ConflictingDecls.data(),
3189 ConflictingDecls.size());
3196 QualType T = Importer.Import(D->getType());
3200 // Create the imported variable.
3201 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3203 if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
3204 Importer.Import(D->getInnerLocStart()), Loc,
3205 Name.getAsIdentifierInfo(), T, TInfo,
3206 D->getStorageClass()))
3209 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
3210 ToVar->setAccess(D->getAccess());
3211 ToVar->setLexicalDeclContext(LexicalDC);
3213 // Templated declarations should never appear in the enclosing DeclContext.
3214 if (!D->getDescribedVarTemplate())
3215 LexicalDC->addDeclInternal(ToVar);
3217 // Merge the initializer.
3218 if (ImportDefinition(D, ToVar))
3221 if (D->isConstexpr())
3222 ToVar->setConstexpr(true);
3227 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3228 // Parameters are created in the translation unit's context, then moved
3229 // into the function declaration's context afterward.
3230 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3232 // Import the name of this declaration.
3233 DeclarationName Name = Importer.Import(D->getDeclName());
3234 if (D->getDeclName() && !Name)
3237 // Import the location of this declaration.
3238 SourceLocation Loc = Importer.Import(D->getLocation());
3240 // Import the parameter's type.
3241 QualType T = Importer.Import(D->getType());
3245 // Create the imported parameter.
3246 ImplicitParamDecl *ToParm = nullptr;
3247 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
3248 Name.getAsIdentifierInfo(), T,
3249 D->getParameterKind()))
3254 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3255 // Parameters are created in the translation unit's context, then moved
3256 // into the function declaration's context afterward.
3257 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
3259 // Import the name of this declaration.
3260 DeclarationName Name = Importer.Import(D->getDeclName());
3261 if (D->getDeclName() && !Name)
3264 // Import the location of this declaration.
3265 SourceLocation Loc = Importer.Import(D->getLocation());
3267 // Import the parameter's type.
3268 QualType T = Importer.Import(D->getType());
3272 // Create the imported parameter.
3273 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3274 ParmVarDecl *ToParm;
3275 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
3276 Importer.Import(D->getInnerLocStart()), Loc,
3277 Name.getAsIdentifierInfo(), T, TInfo,
3278 D->getStorageClass(),
3279 /*DefaultArg*/ nullptr))
3282 // Set the default argument.
3283 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
3284 ToParm->setKNRPromoted(D->isKNRPromoted());
3286 Expr *ToDefArg = nullptr;
3287 Expr *FromDefArg = nullptr;
3288 if (D->hasUninstantiatedDefaultArg()) {
3289 FromDefArg = D->getUninstantiatedDefaultArg();
3290 ToDefArg = Importer.Import(FromDefArg);
3291 ToParm->setUninstantiatedDefaultArg(ToDefArg);
3292 } else if (D->hasUnparsedDefaultArg()) {
3293 ToParm->setUnparsedDefaultArg();
3294 } else if (D->hasDefaultArg()) {
3295 FromDefArg = D->getDefaultArg();
3296 ToDefArg = Importer.Import(FromDefArg);
3297 ToParm->setDefaultArg(ToDefArg);
3299 if (FromDefArg && !ToDefArg)
3302 if (D->isObjCMethodParameter()) {
3303 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
3304 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
3306 ToParm->setScopeInfo(D->getFunctionScopeDepth(),
3307 D->getFunctionScopeIndex());
3313 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3314 // Import the major distinguishing characteristics of a method.
3315 DeclContext *DC, *LexicalDC;
3316 DeclarationName Name;
3319 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3324 SmallVector<NamedDecl *, 2> FoundDecls;
3325 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3326 for (auto *FoundDecl : FoundDecls) {
3327 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
3328 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3331 // Check return types.
3332 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3333 FoundMethod->getReturnType())) {
3334 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
3335 << D->isInstanceMethod() << Name << D->getReturnType()
3336 << FoundMethod->getReturnType();
3337 Importer.ToDiag(FoundMethod->getLocation(),
3338 diag::note_odr_objc_method_here)
3339 << D->isInstanceMethod() << Name;
3343 // Check the number of parameters.
3344 if (D->param_size() != FoundMethod->param_size()) {
3345 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3346 << D->isInstanceMethod() << Name
3347 << D->param_size() << FoundMethod->param_size();
3348 Importer.ToDiag(FoundMethod->getLocation(),
3349 diag::note_odr_objc_method_here)
3350 << D->isInstanceMethod() << Name;
3354 // Check parameter types.
3355 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
3356 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3357 P != PEnd; ++P, ++FoundP) {
3358 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
3359 (*FoundP)->getType())) {
3360 Importer.FromDiag((*P)->getLocation(),
3361 diag::err_odr_objc_method_param_type_inconsistent)
3362 << D->isInstanceMethod() << Name
3363 << (*P)->getType() << (*FoundP)->getType();
3364 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3365 << (*FoundP)->getType();
3370 // Check variadic/non-variadic.
3371 // Check the number of parameters.
3372 if (D->isVariadic() != FoundMethod->isVariadic()) {
3373 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3374 << D->isInstanceMethod() << Name;
3375 Importer.ToDiag(FoundMethod->getLocation(),
3376 diag::note_odr_objc_method_here)
3377 << D->isInstanceMethod() << Name;
3381 // FIXME: Any other bits we need to merge?
3382 return Importer.MapImported(D, FoundMethod);
3386 // Import the result type.
3387 QualType ResultTy = Importer.Import(D->getReturnType());
3388 if (ResultTy.isNull())
3391 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
3393 ObjCMethodDecl *ToMethod;
3394 if (GetImportedOrCreateDecl(
3395 ToMethod, D, Importer.getToContext(), Loc,
3396 Importer.Import(D->getLocEnd()), Name.getObjCSelector(), ResultTy,
3397 ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
3398 D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3399 D->getImplementationControl(), D->hasRelatedResultType()))
3402 // FIXME: When we decide to merge method definitions, we'll need to
3403 // deal with implicit parameters.
3405 // Import the parameters
3406 SmallVector<ParmVarDecl *, 5> ToParams;
3407 for (auto *FromP : D->parameters()) {
3408 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
3412 ToParams.push_back(ToP);
3415 // Set the parameters.
3416 for (auto *ToParam : ToParams) {
3417 ToParam->setOwningFunction(ToMethod);
3418 ToMethod->addDeclInternal(ToParam);
3421 SmallVector<SourceLocation, 12> SelLocs;
3422 D->getSelectorLocs(SelLocs);
3423 for (auto &Loc : SelLocs)
3424 Loc = Importer.Import(Loc);
3426 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
3428 ToMethod->setLexicalDeclContext(LexicalDC);
3429 LexicalDC->addDeclInternal(ToMethod);
3433 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3434 // Import the major distinguishing characteristics of a category.
3435 DeclContext *DC, *LexicalDC;
3436 DeclarationName Name;
3439 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3444 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3448 ObjCTypeParamDecl *Result;
3449 if (GetImportedOrCreateDecl(
3450 Result, D, Importer.getToContext(), DC, D->getVariance(),
3451 Importer.Import(D->getVarianceLoc()), D->getIndex(),
3452 Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
3453 Importer.Import(D->getColonLoc()), BoundInfo))
3456 Result->setLexicalDeclContext(LexicalDC);
3460 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3461 // Import the major distinguishing characteristics of a category.
3462 DeclContext *DC, *LexicalDC;
3463 DeclarationName Name;
3466 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3472 cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
3476 // Determine if we've already encountered this category.
3477 ObjCCategoryDecl *MergeWithCategory
3478 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3479 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3482 if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
3483 Importer.Import(D->getAtStartLoc()), Loc,
3484 Importer.Import(D->getCategoryNameLoc()),
3485 Name.getAsIdentifierInfo(), ToInterface,
3486 /*TypeParamList=*/nullptr,
3487 Importer.Import(D->getIvarLBraceLoc()),
3488 Importer.Import(D->getIvarRBraceLoc())))
3491 ToCategory->setLexicalDeclContext(LexicalDC);
3492 LexicalDC->addDeclInternal(ToCategory);
3493 // Import the type parameter list after calling Imported, to avoid
3494 // loops when bringing in their DeclContext.
3495 ToCategory->setTypeParamList(ImportObjCTypeParamList(
3496 D->getTypeParamList()));
3499 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3500 SmallVector<SourceLocation, 4> ProtocolLocs;
3501 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3502 = D->protocol_loc_begin();
3503 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3504 FromProtoEnd = D->protocol_end();
3505 FromProto != FromProtoEnd;
3506 ++FromProto, ++FromProtoLoc) {
3508 cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3511 Protocols.push_back(ToProto);
3512 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3515 // FIXME: If we're merging, make sure that the protocol list is the same.
3516 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3517 ProtocolLocs.data(), Importer.getToContext());
3519 Importer.MapImported(D, ToCategory);
3522 // Import all of the members of this category.
3523 ImportDeclContext(D);
3525 // If we have an implementation, import it as well.
3526 if (D->getImplementation()) {
3528 cast_or_null<ObjCCategoryImplDecl>(
3529 Importer.Import(D->getImplementation()));
3533 ToCategory->setImplementation(Impl);
3539 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
3540 ObjCProtocolDecl *To,
3541 ImportDefinitionKind Kind) {
3542 if (To->getDefinition()) {
3543 if (shouldForceImportDeclContext(Kind))
3544 ImportDeclContext(From);
3548 // Start the protocol definition
3549 To->startDefinition();
3552 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3553 SmallVector<SourceLocation, 4> ProtocolLocs;
3554 ObjCProtocolDecl::protocol_loc_iterator
3555 FromProtoLoc = From->protocol_loc_begin();
3556 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3557 FromProtoEnd = From->protocol_end();
3558 FromProto != FromProtoEnd;
3559 ++FromProto, ++FromProtoLoc) {
3560 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3563 Protocols.push_back(ToProto);
3564 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3567 // FIXME: If we're merging, make sure that the protocol list is the same.
3568 To->setProtocolList(Protocols.data(), Protocols.size(),
3569 ProtocolLocs.data(), Importer.getToContext());
3571 if (shouldForceImportDeclContext(Kind)) {
3572 // Import all of the members of this protocol.
3573 ImportDeclContext(From, /*ForceImport=*/true);
3578 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
3579 // If this protocol has a definition in the translation unit we're coming
3580 // from, but this particular declaration is not that definition, import the
3581 // definition and map to that.
3582 ObjCProtocolDecl *Definition = D->getDefinition();
3583 if (Definition && Definition != D) {
3584 Decl *ImportedDef = Importer.Import(Definition);
3588 return Importer.MapImported(D, ImportedDef);
3591 // Import the major distinguishing characteristics of a protocol.
3592 DeclContext *DC, *LexicalDC;
3593 DeclarationName Name;
3596 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3601 ObjCProtocolDecl *MergeWithProtocol = nullptr;
3602 SmallVector<NamedDecl *, 2> FoundDecls;
3603 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3604 for (auto *FoundDecl : FoundDecls) {
3605 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
3608 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
3612 ObjCProtocolDecl *ToProto = MergeWithProtocol;
3614 if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
3615 Name.getAsIdentifierInfo(), Loc,
3616 Importer.Import(D->getAtStartLoc()),
3617 /*PrevDecl=*/nullptr))
3619 ToProto->setLexicalDeclContext(LexicalDC);
3620 LexicalDC->addDeclInternal(ToProto);
3623 Importer.MapImported(D, ToProto);
3625 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
3631 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3632 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3633 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3635 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3636 SourceLocation LangLoc = Importer.Import(D->getLocation());
3638 bool HasBraces = D->hasBraces();
3640 LinkageSpecDecl *ToLinkageSpec;
3641 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
3642 ExternLoc, LangLoc, D->getLanguage(), HasBraces))
3643 return ToLinkageSpec;
3646 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3647 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3650 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3651 LexicalDC->addDeclInternal(ToLinkageSpec);
3653 return ToLinkageSpec;
3656 Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
3657 DeclContext *DC, *LexicalDC;
3658 DeclarationName Name;
3660 NamedDecl *ToD = nullptr;
3661 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3666 DeclarationNameInfo NameInfo(Name,
3667 Importer.Import(D->getNameInfo().getLoc()));
3668 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3671 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3672 Importer.Import(D->getUsingLoc()),
3673 Importer.Import(D->getQualifierLoc()), NameInfo,
3677 ToUsing->setLexicalDeclContext(LexicalDC);
3678 LexicalDC->addDeclInternal(ToUsing);
3680 if (NamedDecl *FromPattern =
3681 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
3682 if (auto *ToPattern =
3683 dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
3684 Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
3689 for (auto *FromShadow : D->shadows()) {
3690 if (auto *ToShadow =
3691 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
3692 ToUsing->addShadowDecl(ToShadow);
3694 // FIXME: We return a nullptr here but the definition is already created
3695 // and available with lookups. How to fix this?..
3701 Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
3702 DeclContext *DC, *LexicalDC;
3703 DeclarationName Name;
3705 NamedDecl *ToD = nullptr;
3706 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3711 auto *ToUsing = dyn_cast_or_null<UsingDecl>(
3712 Importer.Import(D->getUsingDecl()));
3716 auto *ToTarget = dyn_cast_or_null<NamedDecl>(
3717 Importer.Import(D->getTargetDecl()));
3721 UsingShadowDecl *ToShadow;
3722 if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
3726 ToShadow->setLexicalDeclContext(LexicalDC);
3727 ToShadow->setAccess(D->getAccess());
3729 if (UsingShadowDecl *FromPattern =
3730 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
3731 if (auto *ToPattern =
3732 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
3733 Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
3736 // FIXME: We return a nullptr here but the definition is already created
3737 // and available with lookups. How to fix this?..
3741 LexicalDC->addDeclInternal(ToShadow);
3746 Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
3747 DeclContext *DC, *LexicalDC;
3748 DeclarationName Name;
3750 NamedDecl *ToD = nullptr;
3751 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3756 DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
3760 auto *ToNominated = cast_or_null<NamespaceDecl>(
3761 Importer.Import(D->getNominatedNamespace()));
3765 UsingDirectiveDecl *ToUsingDir;
3766 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
3767 Importer.Import(D->getUsingLoc()),
3768 Importer.Import(D->getNamespaceKeyLocation()),
3769 Importer.Import(D->getQualifierLoc()),
3770 Importer.Import(D->getIdentLocation()),
3771 ToNominated, ToComAncestor))
3774 ToUsingDir->setLexicalDeclContext(LexicalDC);
3775 LexicalDC->addDeclInternal(ToUsingDir);
3780 Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
3781 UnresolvedUsingValueDecl *D) {
3782 DeclContext *DC, *LexicalDC;
3783 DeclarationName Name;
3785 NamedDecl *ToD = nullptr;
3786 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3791 DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
3792 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3794 UnresolvedUsingValueDecl *ToUsingValue;
3795 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
3796 Importer.Import(D->getUsingLoc()),
3797 Importer.Import(D->getQualifierLoc()), NameInfo,
3798 Importer.Import(D->getEllipsisLoc())))
3799 return ToUsingValue;
3801 ToUsingValue->setAccess(D->getAccess());
3802 ToUsingValue->setLexicalDeclContext(LexicalDC);
3803 LexicalDC->addDeclInternal(ToUsingValue);
3805 return ToUsingValue;
3808 Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
3809 UnresolvedUsingTypenameDecl *D) {
3810 DeclContext *DC, *LexicalDC;
3811 DeclarationName Name;
3813 NamedDecl *ToD = nullptr;
3814 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3819 UnresolvedUsingTypenameDecl *ToUsing;
3820 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3821 Importer.Import(D->getUsingLoc()),
3822 Importer.Import(D->getTypenameLoc()),
3823 Importer.Import(D->getQualifierLoc()), Loc, Name,
3824 Importer.Import(D->getEllipsisLoc())))
3827 ToUsing->setAccess(D->getAccess());
3828 ToUsing->setLexicalDeclContext(LexicalDC);
3829 LexicalDC->addDeclInternal(ToUsing);
3834 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
3835 ObjCInterfaceDecl *To,
3836 ImportDefinitionKind Kind) {
3837 if (To->getDefinition()) {
3838 // Check consistency of superclass.
3839 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3841 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3846 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
3847 if ((bool)FromSuper != (bool)ToSuper ||
3848 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
3849 Importer.ToDiag(To->getLocation(),
3850 diag::err_odr_objc_superclass_inconsistent)
3851 << To->getDeclName();
3853 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3854 << To->getSuperClass()->getDeclName();
3856 Importer.ToDiag(To->getLocation(),
3857 diag::note_odr_objc_missing_superclass);
3858 if (From->getSuperClass())
3859 Importer.FromDiag(From->getSuperClassLoc(),
3860 diag::note_odr_objc_superclass)
3861 << From->getSuperClass()->getDeclName();
3863 Importer.FromDiag(From->getLocation(),
3864 diag::note_odr_objc_missing_superclass);
3867 if (shouldForceImportDeclContext(Kind))
3868 ImportDeclContext(From);
3872 // Start the definition.
3873 To->startDefinition();
3875 // If this class has a superclass, import it.
3876 if (From->getSuperClass()) {
3877 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3881 To->setSuperClass(SuperTInfo);
3885 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3886 SmallVector<SourceLocation, 4> ProtocolLocs;
3887 ObjCInterfaceDecl::protocol_loc_iterator
3888 FromProtoLoc = From->protocol_loc_begin();
3890 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3891 FromProtoEnd = From->protocol_end();
3892 FromProto != FromProtoEnd;
3893 ++FromProto, ++FromProtoLoc) {
3894 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
3897 Protocols.push_back(ToProto);
3898 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3901 // FIXME: If we're merging, make sure that the protocol list is the same.
3902 To->setProtocolList(Protocols.data(), Protocols.size(),
3903 ProtocolLocs.data(), Importer.getToContext());
3905 // Import categories. When the categories themselves are imported, they'll
3906 // hook themselves into this interface.
3907 for (auto *Cat : From->known_categories())
3908 Importer.Import(Cat);
3910 // If we have an @implementation, import it as well.
3911 if (From->getImplementation()) {
3912 auto *Impl = cast_or_null<ObjCImplementationDecl>(
3913 Importer.Import(From->getImplementation()));
3917 To->setImplementation(Impl);
3920 if (shouldForceImportDeclContext(Kind)) {
3921 // Import all of the members of this class.
3922 ImportDeclContext(From, /*ForceImport=*/true);
3928 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3932 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3933 for (auto fromTypeParam : *list) {
3934 auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3935 Importer.Import(fromTypeParam));
3939 toTypeParams.push_back(toTypeParam);
3942 return ObjCTypeParamList::create(Importer.getToContext(),
3943 Importer.Import(list->getLAngleLoc()),
3945 Importer.Import(list->getRAngleLoc()));
3948 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
3949 // If this class has a definition in the translation unit we're coming from,
3950 // but this particular declaration is not that definition, import the
3951 // definition and map to that.
3952 ObjCInterfaceDecl *Definition = D->getDefinition();
3953 if (Definition && Definition != D) {
3954 Decl *ImportedDef = Importer.Import(Definition);
3958 return Importer.MapImported(D, ImportedDef);
3961 // Import the major distinguishing characteristics of an @interface.
3962 DeclContext *DC, *LexicalDC;
3963 DeclarationName Name;
3966 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3971 // Look for an existing interface with the same name.
3972 ObjCInterfaceDecl *MergeWithIface = nullptr;
3973 SmallVector<NamedDecl *, 2> FoundDecls;
3974 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
3975 for (auto *FoundDecl : FoundDecls) {
3976 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
3979 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
3983 // Create an interface declaration, if one does not already exist.
3984 ObjCInterfaceDecl *ToIface = MergeWithIface;
3986 if (GetImportedOrCreateDecl(
3987 ToIface, D, Importer.getToContext(), DC,
3988 Importer.Import(D->getAtStartLoc()), Name.getAsIdentifierInfo(),
3989 /*TypeParamList=*/nullptr,
3990 /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
3992 ToIface->setLexicalDeclContext(LexicalDC);
3993 LexicalDC->addDeclInternal(ToIface);
3995 Importer.MapImported(D, ToIface);
3996 // Import the type parameter list after calling Imported, to avoid
3997 // loops when bringing in their DeclContext.
3998 ToIface->setTypeParamList(ImportObjCTypeParamList(
3999 D->getTypeParamListAsWritten()));
4001 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
4007 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4008 auto *Category = cast_or_null<ObjCCategoryDecl>(
4009 Importer.Import(D->getCategoryDecl()));
4013 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4015 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4019 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
4020 if (GetImportedOrCreateDecl(
4021 ToImpl, D, Importer.getToContext(), DC,
4022 Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4023 Importer.Import(D->getLocation()),
4024 Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
4027 DeclContext *LexicalDC = DC;
4028 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4029 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4033 ToImpl->setLexicalDeclContext(LexicalDC);
4036 LexicalDC->addDeclInternal(ToImpl);
4037 Category->setImplementation(ToImpl);
4040 Importer.MapImported(D, ToImpl);
4041 ImportDeclContext(D);
4045 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4046 // Find the corresponding interface.
4047 auto *Iface = cast_or_null<ObjCInterfaceDecl>(
4048 Importer.Import(D->getClassInterface()));
4052 // Import the superclass, if any.
4053 ObjCInterfaceDecl *Super = nullptr;
4054 if (D->getSuperClass()) {
4055 Super = cast_or_null<ObjCInterfaceDecl>(
4056 Importer.Import(D->getSuperClass()));
4061 ObjCImplementationDecl *Impl = Iface->getImplementation();
4063 // We haven't imported an implementation yet. Create a new @implementation
4065 if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
4066 Importer.ImportContext(D->getDeclContext()),
4067 Iface, Super, Importer.Import(D->getLocation()),
4068 Importer.Import(D->getAtStartLoc()),
4069 Importer.Import(D->getSuperClassLoc()),
4070 Importer.Import(D->getIvarLBraceLoc()),
4071 Importer.Import(D->getIvarRBraceLoc())))
4074 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4075 DeclContext *LexicalDC
4076 = Importer.ImportContext(D->getLexicalDeclContext());
4079 Impl->setLexicalDeclContext(LexicalDC);
4082 // Associate the implementation with the class it implements.
4083 Iface->setImplementation(Impl);
4084 Importer.MapImported(D, Iface->getImplementation());
4086 Importer.MapImported(D, Iface->getImplementation());
4088 // Verify that the existing @implementation has the same superclass.
4089 if ((Super && !Impl->getSuperClass()) ||
4090 (!Super && Impl->getSuperClass()) ||
4091 (Super && Impl->getSuperClass() &&
4092 !declaresSameEntity(Super->getCanonicalDecl(),
4093 Impl->getSuperClass()))) {
4094 Importer.ToDiag(Impl->getLocation(),
4095 diag::err_odr_objc_superclass_inconsistent)
4096 << Iface->getDeclName();
4097 // FIXME: It would be nice to have the location of the superclass
4099 if (Impl->getSuperClass())
4100 Importer.ToDiag(Impl->getLocation(),
4101 diag::note_odr_objc_superclass)
4102 << Impl->getSuperClass()->getDeclName();
4104 Importer.ToDiag(Impl->getLocation(),
4105 diag::note_odr_objc_missing_superclass);
4106 if (D->getSuperClass())
4107 Importer.FromDiag(D->getLocation(),
4108 diag::note_odr_objc_superclass)
4109 << D->getSuperClass()->getDeclName();
4111 Importer.FromDiag(D->getLocation(),
4112 diag::note_odr_objc_missing_superclass);
4117 // Import all of the members of this @implementation.
4118 ImportDeclContext(D);
4123 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4124 // Import the major distinguishing characteristics of an @property.
4125 DeclContext *DC, *LexicalDC;
4126 DeclarationName Name;
4129 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4134 // Check whether we have already imported this property.
4135 SmallVector<NamedDecl *, 2> FoundDecls;
4136 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4137 for (auto *FoundDecl : FoundDecls) {
4138 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
4139 // Check property types.
4140 if (!Importer.IsStructurallyEquivalent(D->getType(),
4141 FoundProp->getType())) {
4142 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4143 << Name << D->getType() << FoundProp->getType();
4144 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4145 << FoundProp->getType();
4149 // FIXME: Check property attributes, getters, setters, etc.?
4151 // Consider these properties to be equivalent.
4152 Importer.MapImported(D, FoundProp);
4158 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4162 // Create the new property.
4163 ObjCPropertyDecl *ToProperty;
4164 if (GetImportedOrCreateDecl(
4165 ToProperty, D, Importer.getToContext(), DC, Loc,
4166 Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
4167 Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
4168 TSI, D->getPropertyImplementation()))
4171 ToProperty->setLexicalDeclContext(LexicalDC);
4172 LexicalDC->addDeclInternal(ToProperty);
4174 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
4175 ToProperty->setPropertyAttributesAsWritten(
4176 D->getPropertyAttributesAsWritten());
4177 ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4178 Importer.Import(D->getGetterNameLoc()));
4179 ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4180 Importer.Import(D->getSetterNameLoc()));
4181 ToProperty->setGetterMethodDecl(
4182 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4183 ToProperty->setSetterMethodDecl(
4184 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4185 ToProperty->setPropertyIvarDecl(
4186 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4190 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
4191 auto *Property = cast_or_null<ObjCPropertyDecl>(
4192 Importer.Import(D->getPropertyDecl()));
4196 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4200 // Import the lexical declaration context.
4201 DeclContext *LexicalDC = DC;
4202 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4203 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4208 auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
4212 // Import the ivar (for an @synthesize).
4213 ObjCIvarDecl *Ivar = nullptr;
4214 if (D->getPropertyIvarDecl()) {
4215 Ivar = cast_or_null<ObjCIvarDecl>(
4216 Importer.Import(D->getPropertyIvarDecl()));
4221 ObjCPropertyImplDecl *ToImpl
4222 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4223 Property->getQueryKind());
4225 if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
4226 Importer.Import(D->getLocStart()),
4227 Importer.Import(D->getLocation()), Property,
4228 D->getPropertyImplementation(), Ivar,
4229 Importer.Import(D->getPropertyIvarDeclLoc())))
4232 ToImpl->setLexicalDeclContext(LexicalDC);
4233 LexicalDC->addDeclInternal(ToImpl);
4235 // Check that we have the same kind of property implementation (@synthesize
4237 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
4238 Importer.ToDiag(ToImpl->getLocation(),
4239 diag::err_odr_objc_property_impl_kind_inconsistent)
4240 << Property->getDeclName()
4241 << (ToImpl->getPropertyImplementation()
4242 == ObjCPropertyImplDecl::Dynamic);
4243 Importer.FromDiag(D->getLocation(),
4244 diag::note_odr_objc_property_impl_kind)
4245 << D->getPropertyDecl()->getDeclName()
4246 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
4250 // For @synthesize, check that we have the same
4251 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4252 Ivar != ToImpl->getPropertyIvarDecl()) {
4253 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
4254 diag::err_odr_objc_synthesize_ivar_inconsistent)
4255 << Property->getDeclName()
4256 << ToImpl->getPropertyIvarDecl()->getDeclName()
4257 << Ivar->getDeclName();
4258 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
4259 diag::note_odr_objc_synthesize_ivar_here)
4260 << D->getPropertyIvarDecl()->getDeclName();
4264 // Merge the existing implementation with the new implementation.
4265 Importer.MapImported(D, ToImpl);
4271 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4272 // For template arguments, we adopt the translation unit as our declaration
4273 // context. This context will be fixed when the actual template declaration
4276 // FIXME: Import default argument.
4277 TemplateTypeParmDecl *ToD = nullptr;
4278 (void)GetImportedOrCreateDecl(
4279 ToD, D, Importer.getToContext(),
4280 Importer.getToContext().getTranslationUnitDecl(),
4281 Importer.Import(D->getLocStart()), Importer.Import(D->getLocation()),
4282 D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
4283 D->wasDeclaredWithTypename(), D->isParameterPack());
4288 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4289 // Import the name of this declaration.
4290 DeclarationName Name = Importer.Import(D->getDeclName());
4291 if (D->getDeclName() && !Name)
4294 // Import the location of this declaration.
4295 SourceLocation Loc = Importer.Import(D->getLocation());
4297 // Import the type of this declaration.
4298 QualType T = Importer.Import(D->getType());
4302 // Import type-source information.
4303 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4304 if (D->getTypeSourceInfo() && !TInfo)
4307 // FIXME: Import default argument.
4309 NonTypeTemplateParmDecl *ToD = nullptr;
4310 (void)GetImportedOrCreateDecl(
4311 ToD, D, Importer.getToContext(),
4312 Importer.getToContext().getTranslationUnitDecl(),
4313 Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
4314 D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
4320 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4321 // Import the name of this declaration.
4322 DeclarationName Name = Importer.Import(D->getDeclName());
4323 if (D->getDeclName() && !Name)
4326 // Import the location of this declaration.
4327 SourceLocation Loc = Importer.Import(D->getLocation());
4329 // Import template parameters.
4330 TemplateParameterList *TemplateParams
4331 = ImportTemplateParameterList(D->getTemplateParameters());
4332 if (!TemplateParams)
4335 // FIXME: Import default argument.
4337 TemplateTemplateParmDecl *ToD = nullptr;
4338 (void)GetImportedOrCreateDecl(
4339 ToD, D, Importer.getToContext(),
4340 Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
4341 D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
4346 // Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
4347 // it has any definition in the redecl chain.
4348 static ClassTemplateDecl *getDefinition(ClassTemplateDecl *D) {
4349 CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
4350 if (!ToTemplatedDef)
4352 ClassTemplateDecl *TemplateWithDef =
4353 ToTemplatedDef->getDescribedClassTemplate();
4354 return TemplateWithDef;
4357 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
4358 // If this record has a definition in the translation unit we're coming from,
4359 // but this particular declaration is not that definition, import the
4360 // definition and map to that.
4362 cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
4363 if (Definition && Definition != D->getTemplatedDecl()) {
4365 = Importer.Import(Definition->getDescribedClassTemplate());
4369 return Importer.MapImported(D, ImportedDef);
4372 // Import the major distinguishing characteristics of this class template.
4373 DeclContext *DC, *LexicalDC;
4374 DeclarationName Name;
4377 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4382 // We may already have a template of the same name; try to find and match it.
4383 if (!DC->isFunctionOrMethod()) {
4384 SmallVector<NamedDecl *, 4> ConflictingDecls;
4385 SmallVector<NamedDecl *, 2> FoundDecls;
4386 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4387 for (auto *FoundDecl : FoundDecls) {
4388 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4391 Decl *Found = FoundDecl;
4392 if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {
4394 // The class to be imported is a definition.
4395 if (D->isThisDeclarationADefinition()) {
4396 // Lookup will find the fwd decl only if that is more recent than the
4397 // definition. So, try to get the definition if that is available in
4398 // the redecl chain.
4399 ClassTemplateDecl *TemplateWithDef = getDefinition(FoundTemplate);
4400 if (!TemplateWithDef)
4402 FoundTemplate = TemplateWithDef; // Continue with the definition.
4405 if (IsStructuralMatch(D, FoundTemplate)) {
4406 // The class templates structurally match; call it the same template.
4408 Importer.MapImported(D->getTemplatedDecl(),
4409 FoundTemplate->getTemplatedDecl());
4410 return Importer.MapImported(D, FoundTemplate);
4414 ConflictingDecls.push_back(FoundDecl);
4417 if (!ConflictingDecls.empty()) {
4418 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4419 ConflictingDecls.data(),
4420 ConflictingDecls.size());
4427 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
4429 // Create the declaration that is being templated.
4430 auto *ToTemplated = cast_or_null<CXXRecordDecl>(
4431 Importer.Import(FromTemplated));
4435 // Create the class template declaration itself.
4436 TemplateParameterList *TemplateParams =
4437 ImportTemplateParameterList(D->getTemplateParameters());
4438 if (!TemplateParams)
4441 ClassTemplateDecl *D2;
4442 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
4443 TemplateParams, ToTemplated))
4446 ToTemplated->setDescribedClassTemplate(D2);
4448 D2->setAccess(D->getAccess());
4449 D2->setLexicalDeclContext(LexicalDC);
4450 LexicalDC->addDeclInternal(D2);
4452 if (FromTemplated->isCompleteDefinition() &&
4453 !ToTemplated->isCompleteDefinition()) {
4454 // FIXME: Import definition!
4460 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4461 ClassTemplateSpecializationDecl *D) {
4462 // If this record has a definition in the translation unit we're coming from,
4463 // but this particular declaration is not that definition, import the
4464 // definition and map to that.
4465 TagDecl *Definition = D->getDefinition();
4466 if (Definition && Definition != D) {
4467 Decl *ImportedDef = Importer.Import(Definition);
4471 return Importer.MapImported(D, ImportedDef);
4474 auto *ClassTemplate =
4475 cast_or_null<ClassTemplateDecl>(Importer.Import(
4476 D->getSpecializedTemplate()));
4480 // Import the context of this declaration.
4481 DeclContext *DC = ClassTemplate->getDeclContext();
4485 DeclContext *LexicalDC = DC;
4486 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4487 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4492 // Import the location of this declaration.
4493 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4494 SourceLocation IdLoc = Importer.Import(D->getLocation());
4496 // Import template arguments.
4497 SmallVector<TemplateArgument, 2> TemplateArgs;
4498 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4499 D->getTemplateArgs().size(),
4503 // Try to find an existing specialization with these template arguments.
4504 void *InsertPos = nullptr;
4505 ClassTemplateSpecializationDecl *D2
4506 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4508 // We already have a class template specialization with these template
4511 // FIXME: Check for specialization vs. instantiation errors.
4513 if (RecordDecl *FoundDef = D2->getDefinition()) {
4514 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) {
4515 // The record types structurally match, or the "from" translation
4516 // unit only had a forward declaration anyway; call it the same
4518 return Importer.MapImported(D, FoundDef);
4522 // Create a new specialization.
4523 if (auto *PartialSpec =
4524 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
4525 // Import TemplateArgumentListInfo
4526 TemplateArgumentListInfo ToTAInfo;
4527 const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4528 if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
4531 QualType CanonInjType = Importer.Import(
4532 PartialSpec->getInjectedSpecializationType());
4533 if (CanonInjType.isNull())
4535 CanonInjType = CanonInjType.getCanonicalType();
4537 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4538 PartialSpec->getTemplateParameters());
4539 if (!ToTPList && PartialSpec->getTemplateParameters())
4542 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
4543 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4544 IdLoc, ToTPList, ClassTemplate,
4545 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
4546 ToTAInfo, CanonInjType, nullptr))
4550 if (GetImportedOrCreateDecl(
4551 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4552 IdLoc, ClassTemplate, TemplateArgs, /*PrevDecl=*/nullptr))
4556 D2->setSpecializationKind(D->getSpecializationKind());
4558 // Add this specialization to the class template.
4559 ClassTemplate->AddSpecialization(D2, InsertPos);
4561 // Import the qualifier, if any.
4562 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4564 if (auto *TSI = D->getTypeAsWritten()) {
4565 TypeSourceInfo *TInfo = Importer.Import(TSI);
4568 D2->setTypeAsWritten(TInfo);
4569 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4570 D2->setExternLoc(Importer.Import(D->getExternLoc()));
4573 SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4575 D2->setPointOfInstantiation(POI);
4576 else if (D->getPointOfInstantiation().isValid())
4579 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4581 // Set the context of this specialization/instantiation.
4582 D2->setLexicalDeclContext(LexicalDC);
4584 // Add to the DC only if it was an explicit specialization/instantiation.
4585 if (D2->isExplicitInstantiationOrSpecialization()) {
4586 LexicalDC->addDeclInternal(D2);
4589 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
4595 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4596 // If this variable has a definition in the translation unit we're coming
4598 // but this particular declaration is not that definition, import the
4599 // definition and map to that.
4601 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4602 if (Definition && Definition != D->getTemplatedDecl()) {
4603 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4607 return Importer.MapImported(D, ImportedDef);
4610 // Import the major distinguishing characteristics of this variable template.
4611 DeclContext *DC, *LexicalDC;
4612 DeclarationName Name;
4615 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4620 // We may already have a template of the same name; try to find and match it.
4621 assert(!DC->isFunctionOrMethod() &&
4622 "Variable templates cannot be declared at function scope");
4623 SmallVector<NamedDecl *, 4> ConflictingDecls;
4624 SmallVector<NamedDecl *, 2> FoundDecls;
4625 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4626 for (auto *FoundDecl : FoundDecls) {
4627 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4630 Decl *Found = FoundDecl;
4631 if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
4632 if (IsStructuralMatch(D, FoundTemplate)) {
4633 // The variable templates structurally match; call it the same template.
4634 Importer.MapImported(D->getTemplatedDecl(),
4635 FoundTemplate->getTemplatedDecl());
4636 return Importer.MapImported(D, FoundTemplate);
4640 ConflictingDecls.push_back(FoundDecl);
4643 if (!ConflictingDecls.empty()) {
4644 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4645 ConflictingDecls.data(),
4646 ConflictingDecls.size());
4652 VarDecl *DTemplated = D->getTemplatedDecl();
4655 QualType T = Importer.Import(DTemplated->getType());
4659 // Create the declaration that is being templated.
4660 auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
4664 // Create the variable template declaration itself.
4665 TemplateParameterList *TemplateParams =
4666 ImportTemplateParameterList(D->getTemplateParameters());
4667 if (!TemplateParams)
4670 VarTemplateDecl *ToVarTD;
4671 if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
4672 Name, TemplateParams, ToTemplated))
4675 ToTemplated->setDescribedVarTemplate(ToVarTD);
4677 ToVarTD->setAccess(D->getAccess());
4678 ToVarTD->setLexicalDeclContext(LexicalDC);
4679 LexicalDC->addDeclInternal(ToVarTD);
4681 if (DTemplated->isThisDeclarationADefinition() &&
4682 !ToTemplated->isThisDeclarationADefinition()) {
4683 // FIXME: Import definition!
4689 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4690 VarTemplateSpecializationDecl *D) {
4691 // If this record has a definition in the translation unit we're coming from,
4692 // but this particular declaration is not that definition, import the
4693 // definition and map to that.
4694 VarDecl *Definition = D->getDefinition();
4695 if (Definition && Definition != D) {
4696 Decl *ImportedDef = Importer.Import(Definition);
4700 return Importer.MapImported(D, ImportedDef);
4703 auto *VarTemplate = cast_or_null<VarTemplateDecl>(
4704 Importer.Import(D->getSpecializedTemplate()));
4708 // Import the context of this declaration.
4709 DeclContext *DC = VarTemplate->getDeclContext();
4713 DeclContext *LexicalDC = DC;
4714 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4715 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4720 // Import the location of this declaration.
4721 SourceLocation StartLoc = Importer.Import(D->getLocStart());
4722 SourceLocation IdLoc = Importer.Import(D->getLocation());
4724 // Import template arguments.
4725 SmallVector<TemplateArgument, 2> TemplateArgs;
4726 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4727 D->getTemplateArgs().size(), TemplateArgs))
4730 // Try to find an existing specialization with these template arguments.
4731 void *InsertPos = nullptr;
4732 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
4733 TemplateArgs, InsertPos);
4735 // We already have a variable template specialization with these template
4738 // FIXME: Check for specialization vs. instantiation errors.
4740 if (VarDecl *FoundDef = D2->getDefinition()) {
4741 if (!D->isThisDeclarationADefinition() ||
4742 IsStructuralMatch(D, FoundDef)) {
4743 // The record types structurally match, or the "from" translation
4744 // unit only had a forward declaration anyway; call it the same
4746 return Importer.MapImported(D, FoundDef);
4751 QualType T = Importer.Import(D->getType());
4755 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4756 if (D->getTypeSourceInfo() && !TInfo)
4759 TemplateArgumentListInfo ToTAInfo;
4760 if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
4763 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
4764 // Create a new specialization.
4765 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
4766 // Import TemplateArgumentListInfo
4767 TemplateArgumentListInfo ArgInfos;
4768 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
4769 // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
4770 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
4773 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4774 FromPartial->getTemplateParameters());
4778 PartVarSpecDecl *ToPartial;
4779 if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
4780 StartLoc, IdLoc, ToTPList, VarTemplate, T,
4781 TInfo, D->getStorageClass(), TemplateArgs,
4785 auto *FromInst = FromPartial->getInstantiatedFromMember();
4786 auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
4787 if (FromInst && !ToInst)
4790 ToPartial->setInstantiatedFromMember(ToInst);
4791 if (FromPartial->isMemberSpecialization())
4792 ToPartial->setMemberSpecialization();
4795 } else { // Full specialization
4796 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
4797 IdLoc, VarTemplate, T, TInfo,
4798 D->getStorageClass(), TemplateArgs))
4802 SourceLocation POI = D->getPointOfInstantiation();
4804 D2->setPointOfInstantiation(Importer.Import(POI));
4806 D2->setSpecializationKind(D->getSpecializationKind());
4807 D2->setTemplateArgsInfo(ToTAInfo);
4809 // Add this specialization to the class template.
4810 VarTemplate->AddSpecialization(D2, InsertPos);
4812 // Import the qualifier, if any.
4813 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4815 if (D->isConstexpr())
4816 D2->setConstexpr(true);
4818 // Add the specialization to this context.
4819 D2->setLexicalDeclContext(LexicalDC);
4820 LexicalDC->addDeclInternal(D2);
4822 D2->setAccess(D->getAccess());
4825 // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
4826 // declaration has initializer. Should this be fixed in the AST?.. Anyway,
4827 // we have to check the declaration for initializer - otherwise, it won't be
4829 if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
4830 ImportDefinition(D, D2))
4836 Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
4837 DeclContext *DC, *LexicalDC;
4838 DeclarationName Name;
4842 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4848 // Try to find a function in our own ("to") context with the same name, same
4849 // type, and in the same context as the function we're importing.
4850 if (!LexicalDC->isFunctionOrMethod()) {
4851 unsigned IDNS = Decl::IDNS_Ordinary;
4852 SmallVector<NamedDecl *, 2> FoundDecls;
4853 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
4854 for (auto *FoundDecl : FoundDecls) {
4855 if (!FoundDecl->isInIdentifierNamespace(IDNS))
4858 if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
4859 if (FoundFunction->hasExternalFormalLinkage() &&
4860 D->hasExternalFormalLinkage()) {
4861 if (IsStructuralMatch(D, FoundFunction)) {
4862 Importer.MapImported(D, FoundFunction);
4863 // FIXME: Actually try to merge the body and other attributes.
4864 return FoundFunction;
4871 TemplateParameterList *Params =
4872 ImportTemplateParameterList(D->getTemplateParameters());
4877 cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
4881 FunctionTemplateDecl *ToFunc;
4882 if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
4883 Params, TemplatedFD))
4886 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
4887 ToFunc->setAccess(D->getAccess());
4888 ToFunc->setLexicalDeclContext(LexicalDC);
4890 LexicalDC->addDeclInternal(ToFunc);
4894 //----------------------------------------------------------------------------
4895 // Import Statements
4896 //----------------------------------------------------------------------------
4898 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4900 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4901 size_t NumDecls = DG.end() - DG.begin();
4902 SmallVector<Decl *, 1> ToDecls(NumDecls);
4903 auto &_Importer = this->Importer;
4904 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4905 [&_Importer](Decl *D) -> Decl * {
4906 return _Importer.Import(D);
4908 return DeclGroupRef::Create(Importer.getToContext(),
4913 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
4914 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node)
4915 << S->getStmtClassName();
4919 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
4920 SmallVector<IdentifierInfo *, 4> Names;
4921 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4922 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
4923 // ToII is nullptr when no symbolic name is given for output operand
4924 // see ParseStmtAsm::ParseAsmOperandsOpt
4925 if (!ToII && S->getOutputIdentifier(I))
4927 Names.push_back(ToII);
4929 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4930 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
4931 // ToII is nullptr when no symbolic name is given for input operand
4932 // see ParseStmtAsm::ParseAsmOperandsOpt
4933 if (!ToII && S->getInputIdentifier(I))
4935 Names.push_back(ToII);
4938 SmallVector<StringLiteral *, 4> Clobbers;
4939 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
4940 auto *Clobber = cast_or_null<StringLiteral>(
4941 Importer.Import(S->getClobberStringLiteral(I)));
4944 Clobbers.push_back(Clobber);
4947 SmallVector<StringLiteral *, 4> Constraints;
4948 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
4949 auto *Output = cast_or_null<StringLiteral>(
4950 Importer.Import(S->getOutputConstraintLiteral(I)));
4953 Constraints.push_back(Output);
4956 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
4957 auto *Input = cast_or_null<StringLiteral>(
4958 Importer.Import(S->getInputConstraintLiteral(I)));
4961 Constraints.push_back(Input);
4964 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
4965 if (ImportContainerChecked(S->outputs(), Exprs))
4968 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
4971 auto *AsmStr = cast_or_null<StringLiteral>(
4972 Importer.Import(S->getAsmString()));
4976 return new (Importer.getToContext()) GCCAsmStmt(
4977 Importer.getToContext(),
4978 Importer.Import(S->getAsmLoc()),
4987 S->getNumClobbers(),
4989 Importer.Import(S->getRParenLoc()));
4992 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
4993 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
4994 for (auto *ToD : ToDG) {
4998 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc());
4999 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5000 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5003 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5004 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5005 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5006 S->hasLeadingEmptyMacro());
5009 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
5010 SmallVector<Stmt *, 8> ToStmts(S->size());
5012 if (ImportContainerChecked(S->body(), ToStmts))
5015 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5016 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
5017 return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
5021 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5022 Expr *ToLHS = Importer.Import(S->getLHS());
5025 Expr *ToRHS = Importer.Import(S->getRHS());
5026 if (!ToRHS && S->getRHS())
5028 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5029 if (!ToSubStmt && S->getSubStmt())
5031 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5032 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5033 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5034 auto *ToStmt = new (Importer.getToContext())
5035 CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
5036 ToStmt->setSubStmt(ToSubStmt);
5040 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5041 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5042 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5043 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5044 if (!ToSubStmt && S->getSubStmt())
5046 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5050 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5051 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
5052 auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
5053 if (!ToLabelDecl && S->getDecl())
5055 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5056 if (!ToSubStmt && S->getSubStmt())
5058 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5062 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5063 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5064 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5065 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
5066 if (ImportContainerChecked(FromAttrs, ToAttrs))
5068 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5069 if (!ToSubStmt && S->getSubStmt())
5071 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5072 ToAttrs, ToSubStmt);
5075 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5076 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
5077 Stmt *ToInit = Importer.Import(S->getInit());
5078 if (!ToInit && S->getInit())
5080 VarDecl *ToConditionVariable = nullptr;
5081 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5082 ToConditionVariable =
5083 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5084 if (!ToConditionVariable)
5087 Expr *ToCondition = Importer.Import(S->getCond());
5088 if (!ToCondition && S->getCond())
5090 Stmt *ToThenStmt = Importer.Import(S->getThen());
5091 if (!ToThenStmt && S->getThen())
5093 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5094 Stmt *ToElseStmt = Importer.Import(S->getElse());
5095 if (!ToElseStmt && S->getElse())
5097 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
5098 ToIfLoc, S->isConstexpr(),
5100 ToConditionVariable,
5101 ToCondition, ToThenStmt,
5102 ToElseLoc, ToElseStmt);
5105 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
5106 Stmt *ToInit = Importer.Import(S->getInit());
5107 if (!ToInit && S->getInit())
5109 VarDecl *ToConditionVariable = nullptr;
5110 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5111 ToConditionVariable =
5112 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5113 if (!ToConditionVariable)
5116 Expr *ToCondition = Importer.Import(S->getCond());
5117 if (!ToCondition && S->getCond())
5119 auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
5120 Importer.getToContext(), ToInit,
5121 ToConditionVariable, ToCondition);
5122 Stmt *ToBody = Importer.Import(S->getBody());
5123 if (!ToBody && S->getBody())
5125 ToStmt->setBody(ToBody);
5126 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5127 // Now we have to re-chain the cases.
5128 SwitchCase *LastChainedSwitchCase = nullptr;
5129 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5130 SC = SC->getNextSwitchCase()) {
5131 auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
5134 if (LastChainedSwitchCase)
5135 LastChainedSwitchCase->setNextSwitchCase(ToSC);
5137 ToStmt->setSwitchCaseList(ToSC);
5138 LastChainedSwitchCase = ToSC;
5143 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5144 VarDecl *ToConditionVariable = nullptr;
5145 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5146 ToConditionVariable =
5147 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5148 if (!ToConditionVariable)
5151 Expr *ToCondition = Importer.Import(S->getCond());
5152 if (!ToCondition && S->getCond())
5154 Stmt *ToBody = Importer.Import(S->getBody());
5155 if (!ToBody && S->getBody())
5157 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5158 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5159 ToConditionVariable,
5160 ToCondition, ToBody,
5164 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5165 Stmt *ToBody = Importer.Import(S->getBody());
5166 if (!ToBody && S->getBody())
5168 Expr *ToCondition = Importer.Import(S->getCond());
5169 if (!ToCondition && S->getCond())
5171 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5172 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5173 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5174 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5175 ToDoLoc, ToWhileLoc,
5179 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5180 Stmt *ToInit = Importer.Import(S->getInit());
5181 if (!ToInit && S->getInit())
5183 Expr *ToCondition = Importer.Import(S->getCond());
5184 if (!ToCondition && S->getCond())
5186 VarDecl *ToConditionVariable = nullptr;
5187 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5188 ToConditionVariable =
5189 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5190 if (!ToConditionVariable)
5193 Expr *ToInc = Importer.Import(S->getInc());
5194 if (!ToInc && S->getInc())
5196 Stmt *ToBody = Importer.Import(S->getBody());
5197 if (!ToBody && S->getBody())
5199 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5200 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5201 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5202 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5203 ToInit, ToCondition,
5204 ToConditionVariable,
5206 ToForLoc, ToLParenLoc,
5210 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5211 LabelDecl *ToLabel = nullptr;
5212 if (LabelDecl *FromLabel = S->getLabel()) {
5213 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5217 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5218 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5219 return new (Importer.getToContext()) GotoStmt(ToLabel,
5220 ToGotoLoc, ToLabelLoc);
5223 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5224 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5225 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5226 Expr *ToTarget = Importer.Import(S->getTarget());
5227 if (!ToTarget && S->getTarget())
5229 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5233 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5234 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5235 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5238 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5239 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5240 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5243 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5244 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5245 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5246 if (!ToRetExpr && S->getRetValue())
5248 auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
5249 auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
5250 if (!ToNRVOCandidate && NRVOCandidate)
5252 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5256 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5257 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5258 VarDecl *ToExceptionDecl = nullptr;
5259 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5261 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5262 if (!ToExceptionDecl)
5265 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5266 if (!ToHandlerBlock && S->getHandlerBlock())
5268 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5273 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5274 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5275 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5276 if (!ToTryBlock && S->getTryBlock())
5278 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5279 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5280 CXXCatchStmt *FromHandler = S->getHandler(HI);
5281 if (Stmt *ToHandler = Importer.Import(FromHandler))
5282 ToHandlers[HI] = ToHandler;
5286 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5290 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
5292 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5293 if (!ToRange && S->getRangeStmt())
5296 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5297 if (!ToBegin && S->getBeginStmt())
5300 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5301 if (!ToEnd && S->getEndStmt())
5303 Expr *ToCond = Importer.Import(S->getCond());
5304 if (!ToCond && S->getCond())
5306 Expr *ToInc = Importer.Import(S->getInc());
5307 if (!ToInc && S->getInc())
5310 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5311 if (!ToLoopVar && S->getLoopVarStmt())
5313 Stmt *ToBody = Importer.Import(S->getBody());
5314 if (!ToBody && S->getBody())
5316 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5317 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
5318 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5319 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5320 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
5323 ToForLoc, ToCoawaitLoc,
5324 ToColonLoc, ToRParenLoc);
5327 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5328 Stmt *ToElem = Importer.Import(S->getElement());
5329 if (!ToElem && S->getElement())
5331 Expr *ToCollect = Importer.Import(S->getCollection());
5332 if (!ToCollect && S->getCollection())
5334 Stmt *ToBody = Importer.Import(S->getBody());
5335 if (!ToBody && S->getBody())
5337 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5338 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5339 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5345 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5346 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5347 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5348 VarDecl *ToExceptionDecl = nullptr;
5349 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5351 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5352 if (!ToExceptionDecl)
5355 Stmt *ToBody = Importer.Import(S->getCatchBody());
5356 if (!ToBody && S->getCatchBody())
5358 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5364 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5365 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5366 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5367 if (!ToAtFinallyStmt && S->getFinallyBody())
5369 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5373 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5374 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5375 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5376 if (!ToAtTryStmt && S->getTryBody())
5378 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5379 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5380 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5381 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5382 ToCatchStmts[CI] = ToCatchStmt;
5386 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5387 if (!ToAtFinallyStmt && S->getFinallyStmt())
5389 return ObjCAtTryStmt::Create(Importer.getToContext(),
5390 ToAtTryLoc, ToAtTryStmt,
5391 ToCatchStmts.begin(), ToCatchStmts.size(),
5395 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5396 (ObjCAtSynchronizedStmt *S) {
5397 SourceLocation ToAtSynchronizedLoc =
5398 Importer.Import(S->getAtSynchronizedLoc());
5399 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5400 if (!ToSynchExpr && S->getSynchExpr())
5402 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5403 if (!ToSynchBody && S->getSynchBody())
5405 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5406 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5409 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5410 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5411 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5412 if (!ToThrow && S->getThrowExpr())
5414 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5417 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5418 (ObjCAutoreleasePoolStmt *S) {
5419 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5420 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5421 if (!ToSubStmt && S->getSubStmt())
5423 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5427 //----------------------------------------------------------------------------
5428 // Import Expressions
5429 //----------------------------------------------------------------------------
5430 Expr *ASTNodeImporter::VisitExpr(Expr *E) {
5431 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node)
5432 << E->getStmtClassName();
5436 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5437 QualType T = Importer.Import(E->getType());
5441 Expr *SubExpr = Importer.Import(E->getSubExpr());
5442 if (!SubExpr && E->getSubExpr())
5445 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5449 return new (Importer.getToContext()) VAArgExpr(
5450 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5451 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5454 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5455 QualType T = Importer.Import(E->getType());
5459 return new (Importer.getToContext()) GNUNullExpr(
5460 T, Importer.Import(E->getLocStart()));
5463 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5464 QualType T = Importer.Import(E->getType());
5468 auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
5469 if (!SL && E->getFunctionName())
5472 return new (Importer.getToContext()) PredefinedExpr(
5473 Importer.Import(E->getLocStart()), T, E->getIdentType(), SL);
5476 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
5477 auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
5481 NamedDecl *FoundD = nullptr;
5482 if (E->getDecl() != E->getFoundDecl()) {
5483 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5488 QualType T = Importer.Import(E->getType());
5492 TemplateArgumentListInfo ToTAInfo;
5493 TemplateArgumentListInfo *ResInfo = nullptr;
5494 if (E->hasExplicitTemplateArgs()) {
5495 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
5497 ResInfo = &ToTAInfo;
5500 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
5501 Importer.Import(E->getQualifierLoc()),
5502 Importer.Import(E->getTemplateKeywordLoc()),
5504 E->refersToEnclosingVariableOrCapture(),
5505 Importer.Import(E->getLocation()),
5506 T, E->getValueKind(),
5508 if (E->hadMultipleCandidates())
5509 DRE->setHadMultipleCandidates(true);
5513 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5514 QualType T = Importer.Import(E->getType());
5518 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5521 ASTNodeImporter::Designator
5522 ASTNodeImporter::ImportDesignator(const Designator &D) {
5523 if (D.isFieldDesignator()) {
5524 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5525 // Caller checks for import error
5526 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5527 Importer.Import(D.getFieldLoc()));
5529 if (D.isArrayDesignator())
5530 return Designator(D.getFirstExprIndex(),
5531 Importer.Import(D.getLBracketLoc()),
5532 Importer.Import(D.getRBracketLoc()));
5534 assert(D.isArrayRangeDesignator());
5535 return Designator(D.getFirstExprIndex(),
5536 Importer.Import(D.getLBracketLoc()),
5537 Importer.Import(D.getEllipsisLoc()),
5538 Importer.Import(D.getRBracketLoc()));
5542 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
5543 auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
5547 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5548 // List elements from the second, the first is Init itself
5549 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
5550 if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
5551 IndexExprs[I - 1] = Arg;
5556 SmallVector<Designator, 4> Designators(DIE->size());
5557 llvm::transform(DIE->designators(), Designators.begin(),
5558 [this](const Designator &D) -> Designator {
5559 return ImportDesignator(D);
5562 for (const auto &D : DIE->designators())
5563 if (D.isFieldDesignator() && !D.getFieldName())
5566 return DesignatedInitExpr::Create(
5567 Importer.getToContext(), Designators,
5568 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5569 DIE->usesGNUSyntax(), Init);
5572 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5573 QualType T = Importer.Import(E->getType());
5577 return new (Importer.getToContext())
5578 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5581 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5582 QualType T = Importer.Import(E->getType());
5586 return IntegerLiteral::Create(Importer.getToContext(),
5588 Importer.Import(E->getLocation()));
5591 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5592 QualType T = Importer.Import(E->getType());
5596 return FloatingLiteral::Create(Importer.getToContext(),
5597 E->getValue(), E->isExact(), T,
5598 Importer.Import(E->getLocation()));
5601 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5602 QualType T = Importer.Import(E->getType());
5606 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5608 Importer.Import(E->getLocation()));
5611 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5612 QualType T = Importer.Import(E->getType());
5616 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5617 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5619 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5620 E->getKind(), E->isPascal(), T,
5621 Locations.data(), Locations.size());
5624 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5625 QualType T = Importer.Import(E->getType());
5629 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5633 Expr *Init = Importer.Import(E->getInitializer());
5637 return new (Importer.getToContext()) CompoundLiteralExpr(
5638 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5639 Init, E->isFileScope());
5642 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5643 QualType T = Importer.Import(E->getType());
5647 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5648 if (ImportArrayChecked(
5649 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5653 return new (Importer.getToContext()) AtomicExpr(
5654 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5655 Importer.Import(E->getRParenLoc()));
5658 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5659 QualType T = Importer.Import(E->getType());
5663 auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
5667 return new (Importer.getToContext()) AddrLabelExpr(
5668 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5672 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5673 Expr *SubExpr = Importer.Import(E->getSubExpr());
5677 return new (Importer.getToContext())
5678 ParenExpr(Importer.Import(E->getLParen()),
5679 Importer.Import(E->getRParen()),
5683 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5684 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
5685 if (ImportContainerChecked(E->exprs(), Exprs))
5688 return new (Importer.getToContext()) ParenListExpr(
5689 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5690 Exprs, Importer.Import(E->getLParenLoc()));
5693 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5694 QualType T = Importer.Import(E->getType());
5698 auto *ToSubStmt = cast_or_null<CompoundStmt>(
5699 Importer.Import(E->getSubStmt()));
5700 if (!ToSubStmt && E->getSubStmt())
5703 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5704 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5707 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5708 QualType T = Importer.Import(E->getType());
5712 Expr *SubExpr = Importer.Import(E->getSubExpr());
5716 return new (Importer.getToContext()) UnaryOperator(
5717 SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
5718 Importer.Import(E->getOperatorLoc()), E->canOverflow());
5722 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
5723 QualType ResultType = Importer.Import(E->getType());
5725 if (E->isArgumentType()) {
5726 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5730 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5732 Importer.Import(E->getOperatorLoc()),
5733 Importer.Import(E->getRParenLoc()));
5736 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5740 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5741 SubExpr, ResultType,
5742 Importer.Import(E->getOperatorLoc()),
5743 Importer.Import(E->getRParenLoc()));
5746 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5747 QualType T = Importer.Import(E->getType());
5751 Expr *LHS = Importer.Import(E->getLHS());
5755 Expr *RHS = Importer.Import(E->getRHS());
5759 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
5760 T, E->getValueKind(),
5762 Importer.Import(E->getOperatorLoc()),
5763 E->getFPFeatures());
5766 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
5767 QualType T = Importer.Import(E->getType());
5771 Expr *ToLHS = Importer.Import(E->getLHS());
5775 Expr *ToRHS = Importer.Import(E->getRHS());
5779 Expr *ToCond = Importer.Import(E->getCond());
5783 return new (Importer.getToContext()) ConditionalOperator(
5784 ToCond, Importer.Import(E->getQuestionLoc()),
5785 ToLHS, Importer.Import(E->getColonLoc()),
5786 ToRHS, T, E->getValueKind(), E->getObjectKind());
5789 Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
5790 BinaryConditionalOperator *E) {
5791 QualType T = Importer.Import(E->getType());
5795 Expr *Common = Importer.Import(E->getCommon());
5799 Expr *Cond = Importer.Import(E->getCond());
5803 auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5804 Importer.Import(E->getOpaqueValue()));
5808 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5812 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5816 return new (Importer.getToContext()) BinaryConditionalOperator(
5817 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5818 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5819 T, E->getValueKind(), E->getObjectKind());
5822 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
5823 QualType T = Importer.Import(E->getType());
5827 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
5831 Expr *Dim = Importer.Import(E->getDimensionExpression());
5832 if (!Dim && E->getDimensionExpression())
5835 return new (Importer.getToContext()) ArrayTypeTraitExpr(
5836 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5837 E->getValue(), Dim, Importer.Import(E->getLocEnd()), T);
5840 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
5841 QualType T = Importer.Import(E->getType());
5845 Expr *ToQueried = Importer.Import(E->getQueriedExpression());
5849 return new (Importer.getToContext()) ExpressionTraitExpr(
5850 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried,
5851 E->getValue(), Importer.Import(E->getLocEnd()), T);
5854 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
5855 QualType T = Importer.Import(E->getType());
5859 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5860 if (!SourceExpr && E->getSourceExpr())
5863 return new (Importer.getToContext()) OpaqueValueExpr(
5864 Importer.Import(E->getLocation()), T, E->getValueKind(),
5865 E->getObjectKind(), SourceExpr);
5868 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
5869 QualType T = Importer.Import(E->getType());
5873 Expr *ToLHS = Importer.Import(E->getLHS());
5877 Expr *ToRHS = Importer.Import(E->getRHS());
5881 return new (Importer.getToContext()) ArraySubscriptExpr(
5882 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
5883 Importer.Import(E->getRBracketLoc()));
5886 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5887 QualType T = Importer.Import(E->getType());
5891 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5892 if (CompLHSType.isNull())
5895 QualType CompResultType = Importer.Import(E->getComputationResultType());
5896 if (CompResultType.isNull())
5899 Expr *LHS = Importer.Import(E->getLHS());
5903 Expr *RHS = Importer.Import(E->getRHS());
5907 return new (Importer.getToContext())
5908 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
5909 T, E->getValueKind(),
5911 CompLHSType, CompResultType,
5912 Importer.Import(E->getOperatorLoc()),
5913 E->getFPFeatures());
5916 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
5917 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
5918 if (CXXBaseSpecifier *Spec = Importer.Import(*I))
5919 Path.push_back(Spec);
5926 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
5927 QualType T = Importer.Import(E->getType());
5931 Expr *SubExpr = Importer.Import(E->getSubExpr());
5935 CXXCastPath BasePath;
5936 if (ImportCastPath(E, BasePath))
5939 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
5940 SubExpr, &BasePath, E->getValueKind());
5943 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
5944 QualType T = Importer.Import(E->getType());
5948 Expr *SubExpr = Importer.Import(E->getSubExpr());
5952 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
5953 if (!TInfo && E->getTypeInfoAsWritten())
5956 CXXCastPath BasePath;
5957 if (ImportCastPath(E, BasePath))
5960 switch (E->getStmtClass()) {
5961 case Stmt::CStyleCastExprClass: {
5962 auto *CCE = cast<CStyleCastExpr>(E);
5963 return CStyleCastExpr::Create(Importer.getToContext(), T,
5964 E->getValueKind(), E->getCastKind(),
5965 SubExpr, &BasePath, TInfo,
5966 Importer.Import(CCE->getLParenLoc()),
5967 Importer.Import(CCE->getRParenLoc()));
5970 case Stmt::CXXFunctionalCastExprClass: {
5971 auto *FCE = cast<CXXFunctionalCastExpr>(E);
5972 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
5973 E->getValueKind(), TInfo,
5974 E->getCastKind(), SubExpr, &BasePath,
5975 Importer.Import(FCE->getLParenLoc()),
5976 Importer.Import(FCE->getRParenLoc()));
5979 case Stmt::ObjCBridgedCastExprClass: {
5980 auto *OCE = cast<ObjCBridgedCastExpr>(E);
5981 return new (Importer.getToContext()) ObjCBridgedCastExpr(
5982 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
5983 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
5987 break; // just fall through
5990 auto *Named = cast<CXXNamedCastExpr>(E);
5991 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
5992 RParenLoc = Importer.Import(Named->getRParenLoc());
5993 SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
5995 switch (E->getStmtClass()) {
5996 case Stmt::CXXStaticCastExprClass:
5997 return CXXStaticCastExpr::Create(Importer.getToContext(), T,
5998 E->getValueKind(), E->getCastKind(),
5999 SubExpr, &BasePath, TInfo,
6000 ExprLoc, RParenLoc, Brackets);
6002 case Stmt::CXXDynamicCastExprClass:
6003 return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6004 E->getValueKind(), E->getCastKind(),
6005 SubExpr, &BasePath, TInfo,
6006 ExprLoc, RParenLoc, Brackets);
6008 case Stmt::CXXReinterpretCastExprClass:
6009 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6010 E->getValueKind(), E->getCastKind(),
6011 SubExpr, &BasePath, TInfo,
6012 ExprLoc, RParenLoc, Brackets);
6014 case Stmt::CXXConstCastExprClass:
6015 return CXXConstCastExpr::Create(Importer.getToContext(), T,
6016 E->getValueKind(), SubExpr, TInfo, ExprLoc,
6017 RParenLoc, Brackets);
6019 llvm_unreachable("Cast expression of unsupported type!");
6024 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6025 QualType T = Importer.Import(OE->getType());
6029 SmallVector<OffsetOfNode, 4> Nodes;
6030 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6031 const OffsetOfNode &Node = OE->getComponent(I);
6033 switch (Node.getKind()) {
6034 case OffsetOfNode::Array:
6035 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()),
6036 Node.getArrayExprIndex(),
6037 Importer.Import(Node.getLocEnd())));
6040 case OffsetOfNode::Base: {
6041 CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6042 if (!BS && Node.getBase())
6044 Nodes.push_back(OffsetOfNode(BS));
6047 case OffsetOfNode::Field: {
6048 auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
6051 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD,
6052 Importer.Import(Node.getLocEnd())));
6055 case OffsetOfNode::Identifier: {
6056 IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6059 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII,
6060 Importer.Import(Node.getLocEnd())));
6066 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6067 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6068 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6071 Exprs[I] = ToIndexExpr;
6074 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6075 if (!TInfo && OE->getTypeSourceInfo())
6078 return OffsetOfExpr::Create(Importer.getToContext(), T,
6079 Importer.Import(OE->getOperatorLoc()),
6080 TInfo, Nodes, Exprs,
6081 Importer.Import(OE->getRParenLoc()));
6084 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6085 QualType T = Importer.Import(E->getType());
6089 Expr *Operand = Importer.Import(E->getOperand());
6093 CanThrowResult CanThrow;
6094 if (E->isValueDependent())
6095 CanThrow = CT_Dependent;
6097 CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6099 return new (Importer.getToContext()) CXXNoexceptExpr(
6100 T, Operand, CanThrow,
6101 Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd()));
6104 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6105 QualType T = Importer.Import(E->getType());
6109 Expr *SubExpr = Importer.Import(E->getSubExpr());
6110 if (!SubExpr && E->getSubExpr())
6113 return new (Importer.getToContext()) CXXThrowExpr(
6114 SubExpr, T, Importer.Import(E->getThrowLoc()),
6115 E->isThrownVariableInScope());
6118 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
6119 auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
6123 return CXXDefaultArgExpr::Create(
6124 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6127 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6128 QualType T = Importer.Import(E->getType());
6132 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6136 return new (Importer.getToContext()) CXXScalarValueInitExpr(
6137 T, TypeInfo, Importer.Import(E->getRParenLoc()));
6140 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6141 Expr *SubExpr = Importer.Import(E->getSubExpr());
6145 auto *Dtor = cast_or_null<CXXDestructorDecl>(
6146 Importer.Import(const_cast<CXXDestructorDecl *>(
6147 E->getTemporary()->getDestructor())));
6151 ASTContext &ToCtx = Importer.getToContext();
6152 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6153 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6156 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6157 QualType T = Importer.Import(CE->getType());
6161 TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
6165 SmallVector<Expr *, 8> Args(CE->getNumArgs());
6166 if (ImportContainerChecked(CE->arguments(), Args))
6169 auto *Ctor = cast_or_null<CXXConstructorDecl>(
6170 Importer.Import(CE->getConstructor()));
6174 return new (Importer.getToContext()) CXXTemporaryObjectExpr(
6175 Importer.getToContext(), Ctor, T, TInfo, Args,
6176 Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
6177 CE->isListInitialization(), CE->isStdInitListInitialization(),
6178 CE->requiresZeroInitialization());
6182 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6183 QualType T = Importer.Import(E->getType());
6187 Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6191 auto *ExtendedBy = cast_or_null<ValueDecl>(
6192 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6193 if (!ExtendedBy && E->getExtendingDecl())
6196 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
6197 T, TempE, E->isBoundToLvalueReference());
6199 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6200 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6204 Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
6205 QualType T = Importer.Import(E->getType());
6209 Expr *Pattern = Importer.Import(E->getPattern());
6213 return new (Importer.getToContext()) PackExpansionExpr(
6214 T, Pattern, Importer.Import(E->getEllipsisLoc()),
6215 E->getNumExpansions());
6218 Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
6219 auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
6223 Optional<unsigned> Length;
6225 if (!E->isValueDependent())
6226 Length = E->getPackLength();
6228 SmallVector<TemplateArgument, 8> PartialArguments;
6229 if (E->isPartiallySubstituted()) {
6230 if (ImportTemplateArguments(E->getPartialArguments().data(),
6231 E->getPartialArguments().size(),
6236 return SizeOfPackExpr::Create(
6237 Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
6238 Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
6239 Length, PartialArguments);
6242 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6243 QualType T = Importer.Import(CE->getType());
6247 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6248 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6251 auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
6252 Importer.Import(CE->getOperatorNew()));
6253 if (!OperatorNewDecl && CE->getOperatorNew())
6256 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6257 Importer.Import(CE->getOperatorDelete()));
6258 if (!OperatorDeleteDecl && CE->getOperatorDelete())
6261 Expr *ToInit = Importer.Import(CE->getInitializer());
6262 if (!ToInit && CE->getInitializer())
6265 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6269 Expr *ToArrSize = Importer.Import(CE->getArraySize());
6270 if (!ToArrSize && CE->getArraySize())
6273 return new (Importer.getToContext()) CXXNewExpr(
6274 Importer.getToContext(),
6276 OperatorNewDecl, OperatorDeleteDecl,
6277 CE->passAlignment(),
6278 CE->doesUsualArrayDeleteWantSize(),
6280 Importer.Import(CE->getTypeIdParens()),
6281 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6282 Importer.Import(CE->getSourceRange()),
6283 Importer.Import(CE->getDirectInitRange()));
6286 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6287 QualType T = Importer.Import(E->getType());
6291 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
6292 Importer.Import(E->getOperatorDelete()));
6293 if (!OperatorDeleteDecl && E->getOperatorDelete())
6296 Expr *ToArg = Importer.Import(E->getArgument());
6297 if (!ToArg && E->getArgument())
6300 return new (Importer.getToContext()) CXXDeleteExpr(
6301 T, E->isGlobalDelete(),
6303 E->isArrayFormAsWritten(),
6304 E->doesUsualArrayDeleteWantSize(),
6307 Importer.Import(E->getLocStart()));
6310 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6311 QualType T = Importer.Import(E->getType());
6316 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
6320 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
6321 if (ImportContainerChecked(E->arguments(), ToArgs))
6324 return CXXConstructExpr::Create(Importer.getToContext(), T,
6325 Importer.Import(E->getLocation()),
6326 ToCCD, E->isElidable(),
6327 ToArgs, E->hadMultipleCandidates(),
6328 E->isListInitialization(),
6329 E->isStdInitListInitialization(),
6330 E->requiresZeroInitialization(),
6331 E->getConstructionKind(),
6332 Importer.Import(E->getParenOrBraceRange()));
6335 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6336 Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6337 if (!SubExpr && EWC->getSubExpr())
6340 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6341 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6342 if (ExprWithCleanups::CleanupObject Obj =
6343 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6348 return ExprWithCleanups::Create(Importer.getToContext(),
6349 SubExpr, EWC->cleanupsHaveSideEffects(),
6353 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6354 QualType T = Importer.Import(E->getType());
6358 Expr *ToFn = Importer.Import(E->getCallee());
6362 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
6363 if (ImportContainerChecked(E->arguments(), ToArgs))
6366 return new (Importer.getToContext()) CXXMemberCallExpr(
6367 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6368 Importer.Import(E->getRParenLoc()));
6371 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6372 QualType T = Importer.Import(E->getType());
6376 return new (Importer.getToContext())
6377 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6380 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6381 QualType T = Importer.Import(E->getType());
6385 return new (Importer.getToContext())
6386 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6390 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6391 QualType T = Importer.Import(E->getType());
6395 Expr *ToBase = Importer.Import(E->getBase());
6396 if (!ToBase && E->getBase())
6399 auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
6400 if (!ToMember && E->getMemberDecl())
6404 dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl()));
6405 if (!ToDecl && E->getFoundDecl().getDecl())
6408 DeclAccessPair ToFoundDecl =
6409 DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
6411 DeclarationNameInfo ToMemberNameInfo(
6412 Importer.Import(E->getMemberNameInfo().getName()),
6413 Importer.Import(E->getMemberNameInfo().getLoc()));
6415 if (E->hasExplicitTemplateArgs()) {
6416 return nullptr; // FIXME: handle template arguments
6419 return MemberExpr::Create(Importer.getToContext(), ToBase,
6421 Importer.Import(E->getOperatorLoc()),
6422 Importer.Import(E->getQualifierLoc()),
6423 Importer.Import(E->getTemplateKeywordLoc()),
6424 ToMember, ToFoundDecl, ToMemberNameInfo,
6425 nullptr, T, E->getValueKind(),
6426 E->getObjectKind());
6429 Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
6430 CXXPseudoDestructorExpr *E) {
6431 Expr *BaseE = Importer.Import(E->getBase());
6435 TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo());
6436 if (!ScopeInfo && E->getScopeTypeInfo())
6439 PseudoDestructorTypeStorage Storage;
6440 if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
6441 IdentifierInfo *ToII = Importer.Import(FromII);
6444 Storage = PseudoDestructorTypeStorage(
6445 ToII, Importer.Import(E->getDestroyedTypeLoc()));
6447 TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo());
6450 Storage = PseudoDestructorTypeStorage(TI);
6453 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
6454 Importer.getToContext(), BaseE, E->isArrow(),
6455 Importer.Import(E->getOperatorLoc()),
6456 Importer.Import(E->getQualifierLoc()),
6457 ScopeInfo, Importer.Import(E->getColonColonLoc()),
6458 Importer.Import(E->getTildeLoc()), Storage);
6461 Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
6462 CXXDependentScopeMemberExpr *E) {
6463 Expr *Base = nullptr;
6464 if (!E->isImplicitAccess()) {
6465 Base = Importer.Import(E->getBase());
6470 QualType BaseType = Importer.Import(E->getBaseType());
6471 if (BaseType.isNull())
6474 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
6475 if (E->hasExplicitTemplateArgs()) {
6476 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6477 E->template_arguments(), ToTAInfo))
6479 ResInfo = &ToTAInfo;
6482 DeclarationName Name = Importer.Import(E->getMember());
6483 if (!E->getMember().isEmpty() && Name.isEmpty())
6486 DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
6487 // Import additional name location/type info.
6488 ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
6489 auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
6490 if (!ToFQ && E->getFirstQualifierFoundInScope())
6493 return CXXDependentScopeMemberExpr::Create(
6494 Importer.getToContext(), Base, BaseType, E->isArrow(),
6495 Importer.Import(E->getOperatorLoc()),
6496 Importer.Import(E->getQualifierLoc()),
6497 Importer.Import(E->getTemplateKeywordLoc()),
6498 cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
6502 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
6503 DeclarationName Name = Importer.Import(E->getDeclName());
6504 if (!E->getDeclName().isEmpty() && Name.isEmpty())
6507 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getExprLoc()));
6508 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6510 TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
6511 Importer.Import(E->getRAngleLoc()));
6512 TemplateArgumentListInfo *ResInfo = nullptr;
6513 if (E->hasExplicitTemplateArgs()) {
6514 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
6516 ResInfo = &ToTAInfo;
6519 return DependentScopeDeclRefExpr::Create(
6520 Importer.getToContext(), Importer.Import(E->getQualifierLoc()),
6521 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo);
6524 Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
6525 CXXUnresolvedConstructExpr *CE) {
6526 unsigned NumArgs = CE->arg_size();
6528 SmallVector<Expr *, 8> ToArgs(NumArgs);
6529 if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
6532 return CXXUnresolvedConstructExpr::Create(
6533 Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
6534 Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
6535 Importer.Import(CE->getRParenLoc()));
6538 Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
6540 cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
6541 if (E->getNamingClass() && !NamingClass)
6544 DeclarationName Name = Importer.Import(E->getName());
6545 if (E->getName() && !Name)
6548 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6549 // Import additional name location/type info.
6550 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6552 UnresolvedSet<8> ToDecls;
6553 for (auto *D : E->decls()) {
6554 if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
6555 ToDecls.addDecl(To);
6560 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
6561 if (E->hasExplicitTemplateArgs()) {
6562 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6563 E->template_arguments(), ToTAInfo))
6565 ResInfo = &ToTAInfo;
6568 if (ResInfo || E->getTemplateKeywordLoc().isValid())
6569 return UnresolvedLookupExpr::Create(
6570 Importer.getToContext(), NamingClass,
6571 Importer.Import(E->getQualifierLoc()),
6572 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
6573 ResInfo, ToDecls.begin(), ToDecls.end());
6575 return UnresolvedLookupExpr::Create(
6576 Importer.getToContext(), NamingClass,
6577 Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
6578 E->isOverloaded(), ToDecls.begin(), ToDecls.end());
6581 Expr *ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
6582 DeclarationName Name = Importer.Import(E->getName());
6583 if (!E->getName().isEmpty() && Name.isEmpty())
6585 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6586 // Import additional name location/type info.
6587 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6589 QualType BaseType = Importer.Import(E->getType());
6590 if (!E->getType().isNull() && BaseType.isNull())
6593 UnresolvedSet<8> ToDecls;
6594 for (Decl *D : E->decls()) {
6595 if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
6596 ToDecls.addDecl(To);
6601 TemplateArgumentListInfo ToTAInfo;
6602 TemplateArgumentListInfo *ResInfo = nullptr;
6603 if (E->hasExplicitTemplateArgs()) {
6604 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
6606 ResInfo = &ToTAInfo;
6609 Expr *BaseE = E->isImplicitAccess() ? nullptr : Importer.Import(E->getBase());
6610 if (!BaseE && !E->isImplicitAccess() && E->getBase()) {
6614 return UnresolvedMemberExpr::Create(
6615 Importer.getToContext(), E->hasUnresolvedUsing(), BaseE, BaseType,
6616 E->isArrow(), Importer.Import(E->getOperatorLoc()),
6617 Importer.Import(E->getQualifierLoc()),
6618 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo,
6619 ToDecls.begin(), ToDecls.end());
6622 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6623 QualType T = Importer.Import(E->getType());
6627 Expr *ToCallee = Importer.Import(E->getCallee());
6628 if (!ToCallee && E->getCallee())
6631 unsigned NumArgs = E->getNumArgs();
6632 SmallVector<Expr *, 2> ToArgs(NumArgs);
6633 if (ImportContainerChecked(E->arguments(), ToArgs))
6636 auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];
6638 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6639 ToArgs_Copied[ai] = ToArgs[ai];
6641 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
6642 return new (Importer.getToContext()) CXXOperatorCallExpr(
6643 Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T,
6644 OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()),
6645 OCE->getFPFeatures());
6648 return new (Importer.getToContext())
6649 CallExpr(Importer.getToContext(), ToCallee,
6650 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
6651 Importer.Import(E->getRParenLoc()));
6654 Optional<LambdaCapture>
6655 ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) {
6656 VarDecl *Var = nullptr;
6657 if (From.capturesVariable()) {
6658 Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
6663 return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(),
6664 From.getCaptureKind(), Var,
6665 From.isPackExpansion()
6666 ? Importer.Import(From.getEllipsisLoc())
6667 : SourceLocation());
6670 Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) {
6671 CXXRecordDecl *FromClass = LE->getLambdaClass();
6672 auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass));
6676 // NOTE: lambda classes are created with BeingDefined flag set up.
6677 // It means that ImportDefinition doesn't work for them and we should fill it
6679 if (ToClass->isBeingDefined()) {
6680 for (auto FromField : FromClass->fields()) {
6681 auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField));
6687 auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>(
6688 Importer.Import(LE->getCallOperator()));
6692 ToClass->completeDefinition();
6694 unsigned NumCaptures = LE->capture_size();
6695 SmallVector<LambdaCapture, 8> Captures;
6696 Captures.reserve(NumCaptures);
6697 for (const auto &FromCapture : LE->captures()) {
6698 if (auto ToCapture = ImportLambdaCapture(FromCapture))
6699 Captures.push_back(*ToCapture);
6704 SmallVector<Expr *, 8> InitCaptures(NumCaptures);
6705 if (ImportContainerChecked(LE->capture_inits(), InitCaptures))
6708 return LambdaExpr::Create(Importer.getToContext(), ToClass,
6709 Importer.Import(LE->getIntroducerRange()),
6710 LE->getCaptureDefault(),
6711 Importer.Import(LE->getCaptureDefaultLoc()),
6713 LE->hasExplicitParameters(),
6714 LE->hasExplicitResultType(),
6716 Importer.Import(LE->getLocEnd()),
6717 LE->containsUnexpandedParameterPack());
6720 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6721 QualType T = Importer.Import(ILE->getType());
6725 SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
6726 if (ImportContainerChecked(ILE->inits(), Exprs))
6729 ASTContext &ToCtx = Importer.getToContext();
6730 InitListExpr *To = new (ToCtx) InitListExpr(
6731 ToCtx, Importer.Import(ILE->getLBraceLoc()),
6732 Exprs, Importer.Import(ILE->getLBraceLoc()));
6735 if (ILE->hasArrayFiller()) {
6736 Expr *Filler = Importer.Import(ILE->getArrayFiller());
6739 To->setArrayFiller(Filler);
6742 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
6743 auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
6746 To->setInitializedFieldInUnion(ToFD);
6749 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
6750 auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
6753 To->setSyntacticForm(ToSyntForm);
6756 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6757 To->setValueDependent(ILE->isValueDependent());
6758 To->setInstantiationDependent(ILE->isInstantiationDependent());
6763 Expr *ASTNodeImporter::VisitCXXStdInitializerListExpr(
6764 CXXStdInitializerListExpr *E) {
6765 QualType T = Importer.Import(E->getType());
6769 Expr *SE = Importer.Import(E->getSubExpr());
6773 return new (Importer.getToContext()) CXXStdInitializerListExpr(T, SE);
6776 Expr *ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
6777 CXXInheritedCtorInitExpr *E) {
6778 QualType T = Importer.Import(E->getType());
6782 auto *Ctor = cast_or_null<CXXConstructorDecl>(Importer.Import(
6783 E->getConstructor()));
6787 return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
6788 Importer.Import(E->getLocation()), T, Ctor,
6789 E->constructsVBase(), E->inheritedFromVBase());
6792 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6793 QualType ToType = Importer.Import(E->getType());
6794 if (ToType.isNull())
6797 Expr *ToCommon = Importer.Import(E->getCommonExpr());
6798 if (!ToCommon && E->getCommonExpr())
6801 Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6802 if (!ToSubExpr && E->getSubExpr())
6805 return new (Importer.getToContext())
6806 ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6809 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6810 QualType ToType = Importer.Import(E->getType());
6811 if (ToType.isNull())
6813 return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6816 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
6817 auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
6818 if (!ToField && DIE->getField())
6821 return CXXDefaultInitExpr::Create(
6822 Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField);
6825 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6826 QualType ToType = Importer.Import(E->getType());
6827 if (ToType.isNull() && !E->getType().isNull())
6829 ExprValueKind VK = E->getValueKind();
6830 CastKind CK = E->getCastKind();
6831 Expr *ToOp = Importer.Import(E->getSubExpr());
6832 if (!ToOp && E->getSubExpr())
6834 CXXCastPath BasePath;
6835 if (ImportCastPath(E, BasePath))
6837 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6838 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6839 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6840 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
6842 if (isa<CXXStaticCastExpr>(E)) {
6843 return CXXStaticCastExpr::Create(
6844 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6845 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6846 } else if (isa<CXXDynamicCastExpr>(E)) {
6847 return CXXDynamicCastExpr::Create(
6848 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6849 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6850 } else if (isa<CXXReinterpretCastExpr>(E)) {
6851 return CXXReinterpretCastExpr::Create(
6852 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
6853 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6859 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6860 SubstNonTypeTemplateParmExpr *E) {
6861 QualType T = Importer.Import(E->getType());
6865 auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
6866 Importer.Import(E->getParameter()));
6870 Expr *Replacement = Importer.Import(E->getReplacement());
6874 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6875 T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6879 Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
6880 QualType ToType = Importer.Import(E->getType());
6881 if (ToType.isNull())
6884 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
6885 if (ImportContainerChecked(E->getArgs(), ToArgs))
6888 // According to Sema::BuildTypeTrait(), if E is value-dependent,
6889 // Value is always false.
6890 bool ToValue = false;
6891 if (!E->isValueDependent())
6892 ToValue = E->getValue();
6894 return TypeTraitExpr::Create(
6895 Importer.getToContext(), ToType, Importer.Import(E->getLocStart()),
6896 E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue);
6899 Expr *ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
6900 QualType ToType = Importer.Import(E->getType());
6901 if (ToType.isNull())
6904 if (E->isTypeOperand()) {
6905 TypeSourceInfo *TSI = Importer.Import(E->getTypeOperandSourceInfo());
6909 return new (Importer.getToContext())
6910 CXXTypeidExpr(ToType, TSI, Importer.Import(E->getSourceRange()));
6913 Expr *Op = Importer.Import(E->getExprOperand());
6917 return new (Importer.getToContext())
6918 CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange()));
6921 void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
6922 CXXMethodDecl *FromMethod) {
6923 for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
6924 ToMethod->addOverriddenMethod(
6925 cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
6926 FromOverriddenMethod))));
6929 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
6930 ASTContext &FromContext, FileManager &FromFileManager,
6932 : ToContext(ToContext), FromContext(FromContext),
6933 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
6934 Minimal(MinimalImport) {
6935 ImportedDecls[FromContext.getTranslationUnitDecl()]
6936 = ToContext.getTranslationUnitDecl();
6939 ASTImporter::~ASTImporter() = default;
6941 QualType ASTImporter::Import(QualType FromT) {
6945 const Type *fromTy = FromT.getTypePtr();
6947 // Check whether we've already imported this type.
6948 llvm::DenseMap<const Type *, const Type *>::iterator Pos
6949 = ImportedTypes.find(fromTy);
6950 if (Pos != ImportedTypes.end())
6951 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
6954 ASTNodeImporter Importer(*this);
6955 QualType ToT = Importer.Visit(fromTy);
6959 // Record the imported type.
6960 ImportedTypes[fromTy] = ToT.getTypePtr();
6962 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
6965 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
6969 // FIXME: For now we just create a "trivial" type source info based
6970 // on the type and a single location. Implement a real version of this.
6971 QualType T = Import(FromTSI->getType());
6975 return ToContext.getTrivialTypeSourceInfo(T,
6976 Import(FromTSI->getTypeLoc().getLocStart()));
6979 Attr *ASTImporter::Import(const Attr *FromAttr) {
6980 Attr *ToAttr = FromAttr->clone(ToContext);
6981 ToAttr->setRange(Import(FromAttr->getRange()));
6985 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
6986 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
6987 if (Pos != ImportedDecls.end()) {
6988 Decl *ToD = Pos->second;
6989 // FIXME: move this call to ImportDeclParts().
6990 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
6997 Decl *ASTImporter::Import(Decl *FromD) {
7001 ASTNodeImporter Importer(*this);
7003 // Check whether we've already imported this declaration.
7004 Decl *ToD = GetAlreadyImportedOrNull(FromD);
7006 // If FromD has some updated flags after last import, apply it
7007 updateFlags(FromD, ToD);
7012 ToD = Importer.Visit(FromD);
7016 // Notify subclasses.
7017 Imported(FromD, ToD);
7022 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
7026 auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
7030 // When we're using a record/enum/Objective-C class/protocol as a context, we
7031 // need it to have a definition.
7032 if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
7033 auto *FromRecord = cast<RecordDecl>(FromDC);
7034 if (ToRecord->isCompleteDefinition()) {
7036 } else if (FromRecord->isCompleteDefinition()) {
7037 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
7038 ASTNodeImporter::IDK_Basic);
7040 CompleteDecl(ToRecord);
7042 } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
7043 auto *FromEnum = cast<EnumDecl>(FromDC);
7044 if (ToEnum->isCompleteDefinition()) {
7046 } else if (FromEnum->isCompleteDefinition()) {
7047 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7048 ASTNodeImporter::IDK_Basic);
7050 CompleteDecl(ToEnum);
7052 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7053 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
7054 if (ToClass->getDefinition()) {
7056 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7057 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7058 ASTNodeImporter::IDK_Basic);
7060 CompleteDecl(ToClass);
7062 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7063 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
7064 if (ToProto->getDefinition()) {
7066 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7067 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7068 ASTNodeImporter::IDK_Basic);
7070 CompleteDecl(ToProto);
7077 Expr *ASTImporter::Import(Expr *FromE) {
7081 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7084 Stmt *ASTImporter::Import(Stmt *FromS) {
7088 // Check whether we've already imported this declaration.
7089 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7090 if (Pos != ImportedStmts.end())
7094 ASTNodeImporter Importer(*this);
7095 Stmt *ToS = Importer.Visit(FromS);
7099 // Record the imported declaration.
7100 ImportedStmts[FromS] = ToS;
7104 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7108 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7110 switch (FromNNS->getKind()) {
7111 case NestedNameSpecifier::Identifier:
7112 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7113 return NestedNameSpecifier::Create(ToContext, prefix, II);
7117 case NestedNameSpecifier::Namespace:
7119 cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
7120 return NestedNameSpecifier::Create(ToContext, prefix, NS);
7124 case NestedNameSpecifier::NamespaceAlias:
7126 cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
7127 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7131 case NestedNameSpecifier::Global:
7132 return NestedNameSpecifier::GlobalSpecifier(ToContext);
7134 case NestedNameSpecifier::Super:
7136 cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
7137 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7141 case NestedNameSpecifier::TypeSpec:
7142 case NestedNameSpecifier::TypeSpecWithTemplate: {
7143 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7145 bool bTemplate = FromNNS->getKind() ==
7146 NestedNameSpecifier::TypeSpecWithTemplate;
7147 return NestedNameSpecifier::Create(ToContext, prefix,
7148 bTemplate, T.getTypePtr());
7154 llvm_unreachable("Invalid nested name specifier kind");
7157 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
7158 // Copied from NestedNameSpecifier mostly.
7159 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7160 NestedNameSpecifierLoc NNS = FromNNS;
7162 // Push each of the nested-name-specifiers's onto a stack for
7163 // serialization in reverse order.
7165 NestedNames.push_back(NNS);
7166 NNS = NNS.getPrefix();
7169 NestedNameSpecifierLocBuilder Builder;
7171 while (!NestedNames.empty()) {
7172 NNS = NestedNames.pop_back_val();
7173 NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7175 return NestedNameSpecifierLoc();
7177 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7179 case NestedNameSpecifier::Identifier:
7180 Builder.Extend(getToContext(),
7181 Spec->getAsIdentifier(),
7182 Import(NNS.getLocalBeginLoc()),
7183 Import(NNS.getLocalEndLoc()));
7186 case NestedNameSpecifier::Namespace:
7187 Builder.Extend(getToContext(),
7188 Spec->getAsNamespace(),
7189 Import(NNS.getLocalBeginLoc()),
7190 Import(NNS.getLocalEndLoc()));
7193 case NestedNameSpecifier::NamespaceAlias:
7194 Builder.Extend(getToContext(),
7195 Spec->getAsNamespaceAlias(),
7196 Import(NNS.getLocalBeginLoc()),
7197 Import(NNS.getLocalEndLoc()));
7200 case NestedNameSpecifier::TypeSpec:
7201 case NestedNameSpecifier::TypeSpecWithTemplate: {
7202 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7203 QualType(Spec->getAsType(), 0));
7204 Builder.Extend(getToContext(),
7205 Import(NNS.getLocalBeginLoc()),
7207 Import(NNS.getLocalEndLoc()));
7211 case NestedNameSpecifier::Global:
7212 Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7215 case NestedNameSpecifier::Super: {
7216 SourceRange ToRange = Import(NNS.getSourceRange());
7217 Builder.MakeSuper(getToContext(),
7218 Spec->getAsRecordDecl(),
7225 return Builder.getWithLocInContext(getToContext());
7228 TemplateName ASTImporter::Import(TemplateName From) {
7229 switch (From.getKind()) {
7230 case TemplateName::Template:
7231 if (auto *ToTemplate =
7232 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7233 return TemplateName(ToTemplate);
7237 case TemplateName::OverloadedTemplate: {
7238 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7239 UnresolvedSet<2> ToTemplates;
7240 for (auto *I : *FromStorage) {
7241 if (auto *To = cast_or_null<NamedDecl>(Import(I)))
7242 ToTemplates.addDecl(To);
7246 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
7250 case TemplateName::QualifiedTemplate: {
7251 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7252 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7256 if (auto *ToTemplate =
7257 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
7258 return ToContext.getQualifiedTemplateName(Qualifier,
7259 QTN->hasTemplateKeyword(),
7265 case TemplateName::DependentTemplate: {
7266 DependentTemplateName *DTN = From.getAsDependentTemplateName();
7267 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7271 if (DTN->isIdentifier()) {
7272 return ToContext.getDependentTemplateName(Qualifier,
7273 Import(DTN->getIdentifier()));
7276 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7279 case TemplateName::SubstTemplateTemplateParm: {
7280 SubstTemplateTemplateParmStorage *subst
7281 = From.getAsSubstTemplateTemplateParm();
7283 cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
7287 TemplateName replacement = Import(subst->getReplacement());
7288 if (replacement.isNull())
7291 return ToContext.getSubstTemplateTemplateParm(param, replacement);
7294 case TemplateName::SubstTemplateTemplateParmPack: {
7295 SubstTemplateTemplateParmPackStorage *SubstPack
7296 = From.getAsSubstTemplateTemplateParmPack();
7298 cast_or_null<TemplateTemplateParmDecl>(
7299 Import(SubstPack->getParameterPack()));
7303 ASTNodeImporter Importer(*this);
7304 TemplateArgument ArgPack
7305 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7306 if (ArgPack.isNull())
7309 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7313 llvm_unreachable("Invalid template name kind");
7316 SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7317 if (FromLoc.isInvalid())
7320 SourceManager &FromSM = FromContext.getSourceManager();
7322 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
7323 FileID ToFileID = Import(Decomposed.first);
7324 if (ToFileID.isInvalid())
7326 SourceManager &ToSM = ToContext.getSourceManager();
7327 return ToSM.getComposedLoc(ToFileID, Decomposed.second);
7330 SourceRange ASTImporter::Import(SourceRange FromRange) {
7331 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7334 FileID ASTImporter::Import(FileID FromID) {
7335 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
7336 if (Pos != ImportedFileIDs.end())
7339 SourceManager &FromSM = FromContext.getSourceManager();
7340 SourceManager &ToSM = ToContext.getSourceManager();
7341 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
7343 // Map the FromID to the "to" source manager.
7345 if (FromSLoc.isExpansion()) {
7346 const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
7347 SourceLocation ToSpLoc = Import(FromEx.getSpellingLoc());
7348 SourceLocation ToExLocS = Import(FromEx.getExpansionLocStart());
7349 unsigned TokenLen = FromSM.getFileIDSize(FromID);
7350 SourceLocation MLoc;
7351 if (FromEx.isMacroArgExpansion()) {
7352 MLoc = ToSM.createMacroArgExpansionLoc(ToSpLoc, ToExLocS, TokenLen);
7354 SourceLocation ToExLocE = Import(FromEx.getExpansionLocEnd());
7355 MLoc = ToSM.createExpansionLoc(ToSpLoc, ToExLocS, ToExLocE, TokenLen,
7356 FromEx.isExpansionTokenRange());
7358 ToID = ToSM.getFileID(MLoc);
7360 // Include location of this file.
7361 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7363 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7364 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7365 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7367 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7368 // than mmap the files several times.
7369 const FileEntry *Entry =
7370 ToFileManager.getFile(Cache->OrigEntry->getName());
7373 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7374 FromSLoc.getFile().getFileCharacteristic());
7376 // FIXME: We want to re-use the existing MemoryBuffer!
7377 const llvm::MemoryBuffer *FromBuf =
7378 Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7379 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
7380 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7381 FromBuf->getBufferIdentifier());
7382 ToID = ToSM.createFileID(std::move(ToBuf),
7383 FromSLoc.getFile().getFileCharacteristic());
7387 ImportedFileIDs[FromID] = ToID;
7391 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7392 Expr *ToExpr = Import(From->getInit());
7393 if (!ToExpr && From->getInit())
7396 if (From->isBaseInitializer()) {
7397 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7398 if (!ToTInfo && From->getTypeSourceInfo())
7401 return new (ToContext) CXXCtorInitializer(
7402 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7403 ToExpr, Import(From->getRParenLoc()),
7404 From->isPackExpansion() ? Import(From->getEllipsisLoc())
7405 : SourceLocation());
7406 } else if (From->isMemberInitializer()) {
7407 auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
7408 if (!ToField && From->getMember())
7411 return new (ToContext) CXXCtorInitializer(
7412 ToContext, ToField, Import(From->getMemberLocation()),
7413 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7414 } else if (From->isIndirectMemberInitializer()) {
7415 auto *ToIField = cast_or_null<IndirectFieldDecl>(
7416 Import(From->getIndirectMember()));
7417 if (!ToIField && From->getIndirectMember())
7420 return new (ToContext) CXXCtorInitializer(
7421 ToContext, ToIField, Import(From->getMemberLocation()),
7422 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7423 } else if (From->isDelegatingInitializer()) {
7424 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7425 if (!ToTInfo && From->getTypeSourceInfo())
7428 return new (ToContext)
7429 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7430 ToExpr, Import(From->getRParenLoc()));
7436 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7437 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7438 if (Pos != ImportedCXXBaseSpecifiers.end())
7441 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7442 Import(BaseSpec->getSourceRange()),
7443 BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7444 BaseSpec->getAccessSpecifierAsWritten(),
7445 Import(BaseSpec->getTypeSourceInfo()),
7446 Import(BaseSpec->getEllipsisLoc()));
7447 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7451 void ASTImporter::ImportDefinition(Decl *From) {
7452 Decl *To = Import(From);
7456 if (auto *FromDC = cast<DeclContext>(From)) {
7457 ASTNodeImporter Importer(*this);
7459 if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
7460 if (!ToRecord->getDefinition()) {
7461 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
7462 ASTNodeImporter::IDK_Everything);
7467 if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
7468 if (!ToEnum->getDefinition()) {
7469 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
7470 ASTNodeImporter::IDK_Everything);
7475 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
7476 if (!ToIFace->getDefinition()) {
7477 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
7478 ASTNodeImporter::IDK_Everything);
7483 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
7484 if (!ToProto->getDefinition()) {
7485 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
7486 ASTNodeImporter::IDK_Everything);
7491 Importer.ImportDeclContext(FromDC, true);
7495 DeclarationName ASTImporter::Import(DeclarationName FromName) {
7499 switch (FromName.getNameKind()) {
7500 case DeclarationName::Identifier:
7501 return Import(FromName.getAsIdentifierInfo());
7503 case DeclarationName::ObjCZeroArgSelector:
7504 case DeclarationName::ObjCOneArgSelector:
7505 case DeclarationName::ObjCMultiArgSelector:
7506 return Import(FromName.getObjCSelector());
7508 case DeclarationName::CXXConstructorName: {
7509 QualType T = Import(FromName.getCXXNameType());
7513 return ToContext.DeclarationNames.getCXXConstructorName(
7514 ToContext.getCanonicalType(T));
7517 case DeclarationName::CXXDestructorName: {
7518 QualType T = Import(FromName.getCXXNameType());
7522 return ToContext.DeclarationNames.getCXXDestructorName(
7523 ToContext.getCanonicalType(T));
7526 case DeclarationName::CXXDeductionGuideName: {
7527 auto *Template = cast_or_null<TemplateDecl>(
7528 Import(FromName.getCXXDeductionGuideTemplate()));
7531 return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7534 case DeclarationName::CXXConversionFunctionName: {
7535 QualType T = Import(FromName.getCXXNameType());
7539 return ToContext.DeclarationNames.getCXXConversionFunctionName(
7540 ToContext.getCanonicalType(T));
7543 case DeclarationName::CXXOperatorName:
7544 return ToContext.DeclarationNames.getCXXOperatorName(
7545 FromName.getCXXOverloadedOperator());
7547 case DeclarationName::CXXLiteralOperatorName:
7548 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7549 Import(FromName.getCXXLiteralIdentifier()));
7551 case DeclarationName::CXXUsingDirective:
7553 return DeclarationName::getUsingDirectiveName();
7556 llvm_unreachable("Invalid DeclarationName Kind!");
7559 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
7563 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7565 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7566 ToId->setBuiltinID(FromId->getBuiltinID());
7571 Selector ASTImporter::Import(Selector FromSel) {
7572 if (FromSel.isNull())
7575 SmallVector<IdentifierInfo *, 4> Idents;
7576 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7577 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7578 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7579 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7582 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7586 unsigned NumDecls) {
7590 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
7591 if (LastDiagFromFrom)
7592 ToContext.getDiagnostics().notePriorDiagnosticFrom(
7593 FromContext.getDiagnostics());
7594 LastDiagFromFrom = false;
7595 return ToContext.getDiagnostics().Report(Loc, DiagID);
7598 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
7599 if (!LastDiagFromFrom)
7600 FromContext.getDiagnostics().notePriorDiagnosticFrom(
7601 ToContext.getDiagnostics());
7602 LastDiagFromFrom = true;
7603 return FromContext.getDiagnostics().Report(Loc, DiagID);
7606 void ASTImporter::CompleteDecl (Decl *D) {
7607 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
7608 if (!ID->getDefinition())
7609 ID->startDefinition();
7611 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
7612 if (!PD->getDefinition())
7613 PD->startDefinition();
7615 else if (auto *TD = dyn_cast<TagDecl>(D)) {
7616 if (!TD->getDefinition() && !TD->isBeingDefined()) {
7617 TD->startDefinition();
7618 TD->setCompleteDefinition(true);
7622 assert(0 && "CompleteDecl called on a Decl that can't be completed");
7626 Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
7627 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
7628 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
7629 "Try to import an already imported Decl");
7630 if (Pos != ImportedDecls.end())
7632 ImportedDecls[From] = To;
7636 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7638 llvm::DenseMap<const Type *, const Type *>::iterator Pos
7639 = ImportedTypes.find(From.getTypePtr());
7640 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7643 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
7644 getStructuralEquivalenceKind(*this), false,
7646 return Ctx.IsEquivalent(From, To);