blob: c45419140052b5bfa188a225a7d14c527cf1b18f [file] [log] [blame]
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
Douglas Gregor96e578d2010-02-05 17:54:41 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the ASTImporter class which imports AST nodes from one
11// context into another context.
12//
13//===----------------------------------------------------------------------===//
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000014
Douglas Gregor96e578d2010-02-05 17:54:41 +000015#include "clang/AST/ASTImporter.h"
Douglas Gregor96e578d2010-02-05 17:54:41 +000016#include "clang/AST/ASTContext.h"
Douglas Gregor811663e2010-02-10 00:15:17 +000017#include "clang/AST/ASTDiagnostic.h"
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +000018#include "clang/AST/ASTStructuralEquivalence.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000019#include "clang/AST/Attr.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclAccessPair.h"
22#include "clang/AST/DeclBase.h"
Douglas Gregor5c73e912010-02-11 00:48:18 +000023#include "clang/AST/DeclCXX.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000024#include "clang/AST/DeclFriend.h"
25#include "clang/AST/DeclGroup.h"
Douglas Gregor96e578d2010-02-05 17:54:41 +000026#include "clang/AST/DeclObjC.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000027#include "clang/AST/DeclTemplate.h"
Douglas Gregor3aed6cd2010-02-08 21:09:39 +000028#include "clang/AST/DeclVisitor.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000029#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"
Douglas Gregor7eeb5972010-02-11 19:21:55 +000040#include "clang/AST/StmtVisitor.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000041#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
Douglas Gregor96e578d2010-02-05 17:54:41 +000045#include "clang/AST/TypeVisitor.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000046#include "clang/AST/UnresolvedSet.h"
47#include "clang/Basic/ExceptionSpecificationType.h"
Douglas Gregor811663e2010-02-10 00:15:17 +000048#include "clang/Basic/FileManager.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000049#include "clang/Basic/IdentifierTable.h"
50#include "clang/Basic/LLVM.h"
51#include "clang/Basic/LangOptions.h"
52#include "clang/Basic/SourceLocation.h"
Douglas Gregor811663e2010-02-10 00:15:17 +000053#include "clang/Basic/SourceManager.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000054#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"
Douglas Gregor811663e2010-02-10 00:15:17 +000064#include "llvm/Support/MemoryBuffer.h"
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000065#include <algorithm>
66#include <cassert>
67#include <cstddef>
68#include <memory>
69#include <type_traits>
70#include <utility>
Douglas Gregor96e578d2010-02-05 17:54:41 +000071
Douglas Gregor3c2404b2011-11-03 18:07:07 +000072namespace clang {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +000073
Balazs Keri2544b4b2018-08-08 09:40:57 +000074 unsigned ASTImporter::getFieldIndex(Decl *F) {
75 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
76 "Try to get field index for non-field.");
77
78 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
79 if (!Owner)
80 return 0;
81
82 unsigned Index = 1;
83 for (const auto *D : Owner->decls()) {
84 if (D == F)
85 return Index;
86
87 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
88 ++Index;
89 }
90
91 llvm_unreachable("Field was not found in its parent context.");
92
93 return 0;
94 }
95
Gabor Marton5254e642018-06-27 13:32:50 +000096 template <class T>
97 SmallVector<Decl*, 2>
98 getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
99 SmallVector<Decl*, 2> Redecls;
100 for (auto *R : D->getFirstDecl()->redecls()) {
101 if (R != D->getFirstDecl())
102 Redecls.push_back(R);
103 }
104 Redecls.push_back(D->getFirstDecl());
105 std::reverse(Redecls.begin(), Redecls.end());
106 return Redecls;
107 }
108
109 SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
110 // Currently only FunctionDecl is supported
111 auto FD = cast<FunctionDecl>(D);
112 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
113 }
114
Gabor Marton26f72a92018-07-12 09:42:05 +0000115 void updateFlags(const Decl *From, Decl *To) {
116 // Check if some flags or attrs are new in 'From' and copy into 'To'.
117 // FIXME: Other flags or attrs?
118 if (From->isUsed(false) && !To->isUsed(false))
119 To->setIsUsed();
120 }
121
Douglas Gregor3aed6cd2010-02-08 21:09:39 +0000122 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>,
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000123 public DeclVisitor<ASTNodeImporter, Decl *>,
124 public StmtVisitor<ASTNodeImporter, Stmt *> {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000125 ASTImporter &Importer;
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000126
Gabor Marton26f72a92018-07-12 09:42:05 +0000127 // Wrapper for an overload set.
128 template <typename ToDeclT> struct CallOverloadedCreateFun {
129 template <typename... Args>
130 auto operator()(Args &&... args)
131 -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
132 return ToDeclT::Create(std::forward<Args>(args)...);
133 }
134 };
135
136 // Always use these functions to create a Decl during import. There are
137 // certain tasks which must be done after the Decl was created, e.g. we
138 // must immediately register that as an imported Decl. The parameter `ToD`
139 // will be set to the newly created Decl or if had been imported before
140 // then to the already imported Decl. Returns a bool value set to true if
141 // the `FromD` had been imported before.
142 template <typename ToDeclT, typename FromDeclT, typename... Args>
143 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
144 Args &&... args) {
145 // There may be several overloads of ToDeclT::Create. We must make sure
146 // to call the one which would be chosen by the arguments, thus we use a
147 // wrapper for the overload set.
148 CallOverloadedCreateFun<ToDeclT> OC;
149 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
150 std::forward<Args>(args)...);
151 }
152 // Use this overload if a special Type is needed to be created. E.g if we
153 // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
154 // then:
155 // TypedefNameDecl *ToTypedef;
156 // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
157 template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
158 typename... Args>
159 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
160 Args &&... args) {
161 CallOverloadedCreateFun<NewDeclT> OC;
162 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
163 std::forward<Args>(args)...);
164 }
165 // Use this version if a special create function must be
166 // used, e.g. CXXRecordDecl::CreateLambda .
167 template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
168 typename... Args>
169 LLVM_NODISCARD bool
170 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
171 FromDeclT *FromD, Args &&... args) {
172 ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
173 if (ToD)
174 return true; // Already imported.
175 ToD = CreateFun(std::forward<Args>(args)...);
176 InitializeImportedDecl(FromD, ToD);
177 return false; // A new Decl is created.
178 }
179
180 void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
181 Importer.MapImported(FromD, ToD);
182 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
183 if (FromD->hasAttrs())
184 for (const Attr *FromAttr : FromD->getAttrs())
185 ToD->addAttr(Importer.Import(FromAttr));
186 if (FromD->isUsed())
187 ToD->setIsUsed();
188 if (FromD->isImplicit())
189 ToD->setImplicit();
190 }
191
Douglas Gregor96e578d2010-02-05 17:54:41 +0000192 public:
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000193 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
Gabor Marton344b0992018-05-16 11:48:11 +0000194
Douglas Gregor96e578d2010-02-05 17:54:41 +0000195 using TypeVisitor<ASTNodeImporter, QualType>::Visit;
Douglas Gregor62d311f2010-02-09 19:21:46 +0000196 using DeclVisitor<ASTNodeImporter, Decl *>::Visit;
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000197 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit;
Douglas Gregor96e578d2010-02-05 17:54:41 +0000198
199 // Importing types
John McCall424cec92011-01-19 06:33:43 +0000200 QualType VisitType(const Type *T);
Gabor Horvath0866c2f2016-11-23 15:24:23 +0000201 QualType VisitAtomicType(const AtomicType *T);
John McCall424cec92011-01-19 06:33:43 +0000202 QualType VisitBuiltinType(const BuiltinType *T);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000203 QualType VisitDecayedType(const DecayedType *T);
John McCall424cec92011-01-19 06:33:43 +0000204 QualType VisitComplexType(const ComplexType *T);
205 QualType VisitPointerType(const PointerType *T);
206 QualType VisitBlockPointerType(const BlockPointerType *T);
207 QualType VisitLValueReferenceType(const LValueReferenceType *T);
208 QualType VisitRValueReferenceType(const RValueReferenceType *T);
209 QualType VisitMemberPointerType(const MemberPointerType *T);
210 QualType VisitConstantArrayType(const ConstantArrayType *T);
211 QualType VisitIncompleteArrayType(const IncompleteArrayType *T);
212 QualType VisitVariableArrayType(const VariableArrayType *T);
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000213 QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000214 // FIXME: DependentSizedExtVectorType
John McCall424cec92011-01-19 06:33:43 +0000215 QualType VisitVectorType(const VectorType *T);
216 QualType VisitExtVectorType(const ExtVectorType *T);
217 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
218 QualType VisitFunctionProtoType(const FunctionProtoType *T);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000219 QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
Sean Callananda6df8a2011-08-11 16:56:07 +0000220 QualType VisitParenType(const ParenType *T);
John McCall424cec92011-01-19 06:33:43 +0000221 QualType VisitTypedefType(const TypedefType *T);
222 QualType VisitTypeOfExprType(const TypeOfExprType *T);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000223 // FIXME: DependentTypeOfExprType
John McCall424cec92011-01-19 06:33:43 +0000224 QualType VisitTypeOfType(const TypeOfType *T);
225 QualType VisitDecltypeType(const DecltypeType *T);
Alexis Hunte852b102011-05-24 22:41:36 +0000226 QualType VisitUnaryTransformType(const UnaryTransformType *T);
Richard Smith30482bc2011-02-20 03:19:35 +0000227 QualType VisitAutoType(const AutoType *T);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000228 QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000229 // FIXME: DependentDecltypeType
John McCall424cec92011-01-19 06:33:43 +0000230 QualType VisitRecordType(const RecordType *T);
231 QualType VisitEnumType(const EnumType *T);
Sean Callanan72fe0852015-04-02 23:50:08 +0000232 QualType VisitAttributedType(const AttributedType *T);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000233 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
Aleksei Sidorin855086d2017-01-23 09:30:36 +0000234 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
John McCall424cec92011-01-19 06:33:43 +0000235 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T);
236 QualType VisitElaboratedType(const ElaboratedType *T);
Peter Szecsice7f3182018-05-07 12:08:27 +0000237 QualType VisitDependentNameType(const DependentNameType *T);
Gabor Horvath7a91c082017-11-14 11:30:38 +0000238 QualType VisitPackExpansionType(const PackExpansionType *T);
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000239 QualType VisitDependentTemplateSpecializationType(
240 const DependentTemplateSpecializationType *T);
John McCall424cec92011-01-19 06:33:43 +0000241 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T);
242 QualType VisitObjCObjectType(const ObjCObjectType *T);
243 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
Rafael Stahldf556202018-05-29 08:12:15 +0000244
245 // Importing declarations
Fangrui Song6907ce22018-07-30 19:24:48 +0000246 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC,
247 DeclContext *&LexicalDC, DeclarationName &Name,
Sean Callanan59721b32015-04-28 18:41:46 +0000248 NamedDecl *&ToD, SourceLocation &Loc);
Craig Topper36250ad2014-05-12 05:36:57 +0000249 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +0000250 void ImportDeclarationNameLoc(const DeclarationNameInfo &From,
251 DeclarationNameInfo& To);
Douglas Gregor0a791672011-01-18 03:11:38 +0000252 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
Balazs Keri1d20cc22018-07-16 12:16:39 +0000253 void ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000254
Aleksei Sidorina693b372016-09-28 10:16:56 +0000255 bool ImportCastPath(CastExpr *E, CXXCastPath &Path);
256
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000257 using Designator = DesignatedInitExpr::Designator;
258
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000259 Designator ImportDesignator(const Designator &D);
260
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000261 Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From);
Fangrui Song6907ce22018-07-30 19:24:48 +0000262
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000263 /// What we should import from the definition.
Fangrui Song6907ce22018-07-30 19:24:48 +0000264 enum ImportDefinitionKind {
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000265 /// Import the default subset of the definition, which might be
Douglas Gregor95d82832012-01-24 18:36:04 +0000266 /// nothing (if minimal import is set) or might be everything (if minimal
267 /// import is not set).
268 IDK_Default,
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000269
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000270 /// Import everything.
Douglas Gregor95d82832012-01-24 18:36:04 +0000271 IDK_Everything,
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000272
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000273 /// Import only the bare bones needed to establish a valid
Douglas Gregor95d82832012-01-24 18:36:04 +0000274 /// DeclContext.
275 IDK_Basic
276 };
277
Douglas Gregor2e15c842012-02-01 21:00:38 +0000278 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
279 return IDK == IDK_Everything ||
280 (IDK == IDK_Default && !Importer.isMinimalImport());
281 }
282
Fangrui Song6907ce22018-07-30 19:24:48 +0000283 bool ImportDefinition(RecordDecl *From, RecordDecl *To,
Douglas Gregor95d82832012-01-24 18:36:04 +0000284 ImportDefinitionKind Kind = IDK_Default);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000285 bool ImportDefinition(VarDecl *From, VarDecl *To,
286 ImportDefinitionKind Kind = IDK_Default);
Douglas Gregord451ea92011-07-29 23:31:30 +0000287 bool ImportDefinition(EnumDecl *From, EnumDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +0000288 ImportDefinitionKind Kind = IDK_Default);
Douglas Gregor2aa53772012-01-24 17:42:07 +0000289 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +0000290 ImportDefinitionKind Kind = IDK_Default);
Douglas Gregor2aa53772012-01-24 17:42:07 +0000291 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +0000292 ImportDefinitionKind Kind = IDK_Default);
Douglas Gregora082a492010-11-30 19:14:50 +0000293 TemplateParameterList *ImportTemplateParameterList(
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000294 TemplateParameterList *Params);
Douglas Gregore2e50d332010-12-01 01:36:18 +0000295 TemplateArgument ImportTemplateArgument(const TemplateArgument &From);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000296 Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc(
297 const TemplateArgumentLoc &TALoc);
Douglas Gregore2e50d332010-12-01 01:36:18 +0000298 bool ImportTemplateArguments(const TemplateArgument *FromArgs,
299 unsigned NumFromArgs,
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000300 SmallVectorImpl<TemplateArgument> &ToArgs);
301
Aleksei Sidorin7f758b62017-12-27 17:04:42 +0000302 template <typename InContainerTy>
303 bool ImportTemplateArgumentListInfo(const InContainerTy &Container,
304 TemplateArgumentListInfo &ToTAInfo);
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000305
306 template<typename InContainerTy>
307 bool ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,
308 SourceLocation FromRAngleLoc,
309 const InContainerTy &Container,
310 TemplateArgumentListInfo &Result);
311
Gabor Marton5254e642018-06-27 13:32:50 +0000312 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
313 using OptionalTemplateArgsTy = Optional<TemplateArgsTy>;
314 std::tuple<FunctionTemplateDecl *, OptionalTemplateArgsTy>
315 ImportFunctionTemplateWithTemplateArgsFromSpecialization(
316 FunctionDecl *FromFD);
317
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000318 bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
319
Gabor Marton950fb572018-07-17 12:39:27 +0000320 bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
Douglas Gregordd6006f2012-07-17 21:16:27 +0000321 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
322 bool Complain = true);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000323 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
324 bool Complain = true);
Douglas Gregor3996e242010-02-15 22:01:00 +0000325 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
Douglas Gregor91155082012-11-14 22:29:20 +0000326 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +0000327 bool IsStructuralMatch(FunctionTemplateDecl *From,
328 FunctionTemplateDecl *To);
Balazs Keric7797c42018-07-11 09:37:24 +0000329 bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
Douglas Gregora082a492010-11-30 19:14:50 +0000330 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000331 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
Douglas Gregore4c83e42010-02-09 22:48:33 +0000332 Decl *VisitDecl(Decl *D);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000333 Decl *VisitEmptyDecl(EmptyDecl *D);
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +0000334 Decl *VisitAccessSpecDecl(AccessSpecDecl *D);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000335 Decl *VisitStaticAssertDecl(StaticAssertDecl *D);
Sean Callanan65198272011-11-17 23:20:56 +0000336 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D);
Douglas Gregorf18a2c72010-02-21 18:26:36 +0000337 Decl *VisitNamespaceDecl(NamespaceDecl *D);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000338 Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
Richard Smithdda56e42011-04-15 14:24:37 +0000339 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
Douglas Gregor5fa74c32010-02-10 21:10:29 +0000340 Decl *VisitTypedefDecl(TypedefDecl *D);
Richard Smithdda56e42011-04-15 14:24:37 +0000341 Decl *VisitTypeAliasDecl(TypeAliasDecl *D);
Gabor Horvath7a91c082017-11-14 11:30:38 +0000342 Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000343 Decl *VisitLabelDecl(LabelDecl *D);
Douglas Gregor98c10182010-02-12 22:17:39 +0000344 Decl *VisitEnumDecl(EnumDecl *D);
Douglas Gregor5c73e912010-02-11 00:48:18 +0000345 Decl *VisitRecordDecl(RecordDecl *D);
Douglas Gregor98c10182010-02-12 22:17:39 +0000346 Decl *VisitEnumConstantDecl(EnumConstantDecl *D);
Douglas Gregorbb7930c2010-02-10 19:54:31 +0000347 Decl *VisitFunctionDecl(FunctionDecl *D);
Douglas Gregor00eace12010-02-21 18:29:16 +0000348 Decl *VisitCXXMethodDecl(CXXMethodDecl *D);
349 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D);
350 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D);
351 Decl *VisitCXXConversionDecl(CXXConversionDecl *D);
Douglas Gregor5c73e912010-02-11 00:48:18 +0000352 Decl *VisitFieldDecl(FieldDecl *D);
Francois Pichet783dd6e2010-11-21 06:08:52 +0000353 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000354 Decl *VisitFriendDecl(FriendDecl *D);
Douglas Gregor7244b0b2010-02-17 00:34:30 +0000355 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D);
Douglas Gregor3aed6cd2010-02-08 21:09:39 +0000356 Decl *VisitVarDecl(VarDecl *D);
Douglas Gregor8b228d72010-02-17 21:22:52 +0000357 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D);
Douglas Gregorbb7930c2010-02-10 19:54:31 +0000358 Decl *VisitParmVarDecl(ParmVarDecl *D);
Douglas Gregor43f54792010-02-17 02:12:47 +0000359 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D);
Douglas Gregor85f3f952015-07-07 03:57:15 +0000360 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
Douglas Gregor84c51c32010-02-18 01:47:50 +0000361 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D);
Douglas Gregor98d156a2010-02-17 16:12:00 +0000362 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D);
Sean Callanan0aae0412014-12-10 00:00:37 +0000363 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000364 Decl *VisitUsingDecl(UsingDecl *D);
365 Decl *VisitUsingShadowDecl(UsingShadowDecl *D);
366 Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
367 Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
368 Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
369
Douglas Gregor85f3f952015-07-07 03:57:15 +0000370 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list);
Douglas Gregor45635322010-02-16 01:20:57 +0000371 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
Douglas Gregor4da9d682010-12-07 15:32:12 +0000372 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
Douglas Gregorda8025c2010-12-07 01:26:03 +0000373 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D);
Douglas Gregora11c4582010-02-17 18:02:10 +0000374 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D);
Douglas Gregor14a49e22010-12-07 18:32:03 +0000375 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
Douglas Gregora082a492010-11-30 19:14:50 +0000376 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
377 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
378 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
379 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D);
Douglas Gregore2e50d332010-12-01 01:36:18 +0000380 Decl *VisitClassTemplateSpecializationDecl(
381 ClassTemplateSpecializationDecl *D);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000382 Decl *VisitVarTemplateDecl(VarTemplateDecl *D);
383 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +0000384 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
Larisse Voufo39a1e502013-08-06 01:03:05 +0000385
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000386 // Importing statements
Sean Callanan59721b32015-04-28 18:41:46 +0000387 DeclGroupRef ImportDeclGroup(DeclGroupRef DG);
388
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000389 Stmt *VisitStmt(Stmt *S);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000390 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S);
Sean Callanan59721b32015-04-28 18:41:46 +0000391 Stmt *VisitDeclStmt(DeclStmt *S);
392 Stmt *VisitNullStmt(NullStmt *S);
393 Stmt *VisitCompoundStmt(CompoundStmt *S);
394 Stmt *VisitCaseStmt(CaseStmt *S);
395 Stmt *VisitDefaultStmt(DefaultStmt *S);
396 Stmt *VisitLabelStmt(LabelStmt *S);
397 Stmt *VisitAttributedStmt(AttributedStmt *S);
398 Stmt *VisitIfStmt(IfStmt *S);
399 Stmt *VisitSwitchStmt(SwitchStmt *S);
400 Stmt *VisitWhileStmt(WhileStmt *S);
401 Stmt *VisitDoStmt(DoStmt *S);
402 Stmt *VisitForStmt(ForStmt *S);
403 Stmt *VisitGotoStmt(GotoStmt *S);
404 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S);
405 Stmt *VisitContinueStmt(ContinueStmt *S);
406 Stmt *VisitBreakStmt(BreakStmt *S);
407 Stmt *VisitReturnStmt(ReturnStmt *S);
Sean Callanan59721b32015-04-28 18:41:46 +0000408 // FIXME: MSAsmStmt
409 // FIXME: SEHExceptStmt
410 // FIXME: SEHFinallyStmt
411 // FIXME: SEHTryStmt
412 // FIXME: SEHLeaveStmt
413 // FIXME: CapturedStmt
414 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S);
415 Stmt *VisitCXXTryStmt(CXXTryStmt *S);
416 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S);
417 // FIXME: MSDependentExistsStmt
418 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
419 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
420 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
421 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S);
422 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
423 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
424 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000425
426 // Importing expressions
427 Expr *VisitExpr(Expr *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000428 Expr *VisitVAArgExpr(VAArgExpr *E);
429 Expr *VisitGNUNullExpr(GNUNullExpr *E);
430 Expr *VisitPredefinedExpr(PredefinedExpr *E);
Douglas Gregor52f820e2010-02-19 01:17:02 +0000431 Expr *VisitDeclRefExpr(DeclRefExpr *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000432 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE);
433 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E);
434 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
Douglas Gregor7eeb5972010-02-11 19:21:55 +0000435 Expr *VisitIntegerLiteral(IntegerLiteral *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000436 Expr *VisitFloatingLiteral(FloatingLiteral *E);
Gabor Martonbf7f18b2018-08-09 12:18:07 +0000437 Expr *VisitImaginaryLiteral(ImaginaryLiteral *E);
Douglas Gregor623421d2010-02-18 02:21:22 +0000438 Expr *VisitCharacterLiteral(CharacterLiteral *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000439 Expr *VisitStringLiteral(StringLiteral *E);
440 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
441 Expr *VisitAtomicExpr(AtomicExpr *E);
442 Expr *VisitAddrLabelExpr(AddrLabelExpr *E);
Douglas Gregorc74247e2010-02-19 01:07:06 +0000443 Expr *VisitParenExpr(ParenExpr *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000444 Expr *VisitParenListExpr(ParenListExpr *E);
445 Expr *VisitStmtExpr(StmtExpr *E);
Douglas Gregorc74247e2010-02-19 01:07:06 +0000446 Expr *VisitUnaryOperator(UnaryOperator *E);
Peter Collingbournee190dee2011-03-11 19:24:49 +0000447 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
Douglas Gregorc74247e2010-02-19 01:07:06 +0000448 Expr *VisitBinaryOperator(BinaryOperator *E);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000449 Expr *VisitConditionalOperator(ConditionalOperator *E);
450 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
451 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000452 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
453 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E);
454 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
Douglas Gregorc74247e2010-02-19 01:07:06 +0000455 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E);
Douglas Gregor98c10182010-02-12 22:17:39 +0000456 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000457 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E);
458 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE);
459 Expr *VisitCXXThrowExpr(CXXThrowExpr *E);
460 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
461 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
462 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
463 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
464 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE);
465 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
Gabor Horvath7a91c082017-11-14 11:30:38 +0000466 Expr *VisitPackExpansionExpr(PackExpansionExpr *E);
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000467 Expr *VisitSizeOfPackExpr(SizeOfPackExpr *E);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000468 Expr *VisitCXXNewExpr(CXXNewExpr *CE);
469 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E);
Sean Callanan59721b32015-04-28 18:41:46 +0000470 Expr *VisitCXXConstructExpr(CXXConstructExpr *E);
Sean Callanan8bca9962016-03-28 21:43:01 +0000471 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +0000472 Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
Peter Szecsice7f3182018-05-07 12:08:27 +0000473 Expr *VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
Aleksei Sidorine267a0f2018-01-09 16:40:40 +0000474 Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE);
475 Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
Peter Szecsice7f3182018-05-07 12:08:27 +0000476 Expr *VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
Aleksei Sidorina693b372016-09-28 10:16:56 +0000477 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC);
Sean Callanan8bca9962016-03-28 21:43:01 +0000478 Expr *VisitCXXThisExpr(CXXThisExpr *E);
479 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
Aleksei Sidorin60ccb7d2017-11-27 10:30:00 +0000480 Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
Sean Callanan59721b32015-04-28 18:41:46 +0000481 Expr *VisitMemberExpr(MemberExpr *E);
482 Expr *VisitCallExpr(CallExpr *E);
Aleksei Sidorin8fc85102018-01-26 11:36:54 +0000483 Expr *VisitLambdaExpr(LambdaExpr *LE);
Sean Callanan8bca9962016-03-28 21:43:01 +0000484 Expr *VisitInitListExpr(InitListExpr *E);
Gabor Marton07b01ff2018-06-29 12:17:34 +0000485 Expr *VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
Balazs Keri95baa842018-07-25 10:21:06 +0000486 Expr *VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
Richard Smith30e304e2016-12-14 00:03:17 +0000487 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
488 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
Sean Callanandd2c1742016-05-16 20:48:03 +0000489 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
490 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
Aleksei Sidorin855086d2017-01-23 09:30:36 +0000491 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
Aleksei Sidorinb05f37a2017-11-26 17:04:06 +0000492 Expr *VisitTypeTraitExpr(TypeTraitExpr *E);
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000493 Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E);
Aleksei Sidorin855086d2017-01-23 09:30:36 +0000494
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000495 template<typename IIter, typename OIter>
496 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000497 using ItemT = typename std::remove_reference<decltype(*Obegin)>::type;
498
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000499 ASTImporter &ImporterRef = Importer;
500 std::transform(Ibegin, Iend, Obegin,
501 [&ImporterRef](ItemT From) -> ItemT {
502 return ImporterRef.Import(From);
Sean Callanan8bca9962016-03-28 21:43:01 +0000503 });
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000504 }
505
506 template<typename IIter, typename OIter>
507 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000508 using ItemT = typename std::remove_reference<decltype(**Obegin)>::type;
509
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000510 ASTImporter &ImporterRef = Importer;
511 bool Failed = false;
512 std::transform(Ibegin, Iend, Obegin,
513 [&ImporterRef, &Failed](ItemT *From) -> ItemT * {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000514 auto *To = cast_or_null<ItemT>(ImporterRef.Import(From));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000515 if (!To && From)
516 Failed = true;
517 return To;
518 });
519 return Failed;
Sean Callanan8bca9962016-03-28 21:43:01 +0000520 }
Aleksei Sidorina693b372016-09-28 10:16:56 +0000521
522 template<typename InContainerTy, typename OutContainerTy>
523 bool ImportContainerChecked(const InContainerTy &InContainer,
524 OutContainerTy &OutContainer) {
525 return ImportArrayChecked(InContainer.begin(), InContainer.end(),
526 OutContainer.begin());
527 }
528
529 template<typename InContainerTy, typename OIter>
530 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
531 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
532 }
Lang Hames19e07e12017-06-20 21:06:00 +0000533
534 // Importing overrides.
535 void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod);
Gabor Marton5254e642018-06-27 13:32:50 +0000536
537 FunctionDecl *FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000538 };
Aleksei Sidorin782bfcf2018-02-14 11:39:33 +0000539
Aleksei Sidorin782bfcf2018-02-14 11:39:33 +0000540template <typename InContainerTy>
541bool ASTNodeImporter::ImportTemplateArgumentListInfo(
542 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
543 const InContainerTy &Container, TemplateArgumentListInfo &Result) {
544 TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc),
545 Importer.Import(FromRAngleLoc));
546 if (ImportTemplateArgumentListInfo(Container, ToTAInfo))
547 return true;
548 Result = ToTAInfo;
549 return false;
Alexander Kornienkoab9db512015-06-22 23:07:51 +0000550}
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000551
Aleksei Sidorin782bfcf2018-02-14 11:39:33 +0000552template <>
553bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
554 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
555 return ImportTemplateArgumentListInfo(
556 From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
557}
558
559template <>
560bool ASTNodeImporter::ImportTemplateArgumentListInfo<
561 ASTTemplateArgumentListInfo>(const ASTTemplateArgumentListInfo &From,
562 TemplateArgumentListInfo &Result) {
563 return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
564 From.arguments(), Result);
565}
566
Gabor Marton5254e642018-06-27 13:32:50 +0000567std::tuple<FunctionTemplateDecl *, ASTNodeImporter::OptionalTemplateArgsTy>
568ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
569 FunctionDecl *FromFD) {
570 assert(FromFD->getTemplatedKind() ==
571 FunctionDecl::TK_FunctionTemplateSpecialization);
572 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
573 auto *Template = cast_or_null<FunctionTemplateDecl>(
574 Importer.Import(FTSInfo->getTemplate()));
575
576 // Import template arguments.
577 auto TemplArgs = FTSInfo->TemplateArguments->asArray();
578 TemplateArgsTy ToTemplArgs;
579 if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
580 ToTemplArgs)) // Error during import.
581 return std::make_tuple(Template, OptionalTemplateArgsTy());
582
583 return std::make_tuple(Template, ToTemplArgs);
584}
585
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000586} // namespace clang
Aleksei Sidorin782bfcf2018-02-14 11:39:33 +0000587
Douglas Gregor3996e242010-02-15 22:01:00 +0000588//----------------------------------------------------------------------------
Douglas Gregor96e578d2010-02-05 17:54:41 +0000589// Import Types
590//----------------------------------------------------------------------------
591
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +0000592using namespace clang;
593
John McCall424cec92011-01-19 06:33:43 +0000594QualType ASTNodeImporter::VisitType(const Type *T) {
Douglas Gregore4c83e42010-02-09 22:48:33 +0000595 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
596 << T->getTypeClassName();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000597 return {};
Douglas Gregore4c83e42010-02-09 22:48:33 +0000598}
599
Gabor Horvath0866c2f2016-11-23 15:24:23 +0000600QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
601 QualType UnderlyingType = Importer.Import(T->getValueType());
602 if(UnderlyingType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000603 return {};
Gabor Horvath0866c2f2016-11-23 15:24:23 +0000604
605 return Importer.getToContext().getAtomicType(UnderlyingType);
606}
607
John McCall424cec92011-01-19 06:33:43 +0000608QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000609 switch (T->getKind()) {
Alexey Bader954ba212016-04-08 13:40:33 +0000610#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
611 case BuiltinType::Id: \
612 return Importer.getToContext().SingletonId;
Alexey Baderb62f1442016-04-13 08:33:41 +0000613#include "clang/Basic/OpenCLImageTypes.def"
John McCalle314e272011-10-18 21:02:43 +0000614#define SHARED_SINGLETON_TYPE(Expansion)
615#define BUILTIN_TYPE(Id, SingletonId) \
616 case BuiltinType::Id: return Importer.getToContext().SingletonId;
617#include "clang/AST/BuiltinTypes.def"
618
619 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
620 // context supports C++.
621
622 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
623 // context supports ObjC.
624
Douglas Gregor96e578d2010-02-05 17:54:41 +0000625 case BuiltinType::Char_U:
Fangrui Song6907ce22018-07-30 19:24:48 +0000626 // The context we're importing from has an unsigned 'char'. If we're
627 // importing into a context with a signed 'char', translate to
Douglas Gregor96e578d2010-02-05 17:54:41 +0000628 // 'unsigned char' instead.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000629 if (Importer.getToContext().getLangOpts().CharIsSigned)
Douglas Gregor96e578d2010-02-05 17:54:41 +0000630 return Importer.getToContext().UnsignedCharTy;
Fangrui Song6907ce22018-07-30 19:24:48 +0000631
Douglas Gregor96e578d2010-02-05 17:54:41 +0000632 return Importer.getToContext().CharTy;
633
Douglas Gregor96e578d2010-02-05 17:54:41 +0000634 case BuiltinType::Char_S:
Fangrui Song6907ce22018-07-30 19:24:48 +0000635 // The context we're importing from has an unsigned 'char'. If we're
636 // importing into a context with a signed 'char', translate to
Douglas Gregor96e578d2010-02-05 17:54:41 +0000637 // 'unsigned char' instead.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000638 if (!Importer.getToContext().getLangOpts().CharIsSigned)
Douglas Gregor96e578d2010-02-05 17:54:41 +0000639 return Importer.getToContext().SignedCharTy;
Fangrui Song6907ce22018-07-30 19:24:48 +0000640
Douglas Gregor96e578d2010-02-05 17:54:41 +0000641 return Importer.getToContext().CharTy;
642
Chris Lattnerad3467e2010-12-25 23:25:43 +0000643 case BuiltinType::WChar_S:
644 case BuiltinType::WChar_U:
Douglas Gregor96e578d2010-02-05 17:54:41 +0000645 // FIXME: If not in C++, shall we translate to the C equivalent of
646 // wchar_t?
647 return Importer.getToContext().WCharTy;
Douglas Gregor96e578d2010-02-05 17:54:41 +0000648 }
David Blaikiee4d798f2012-01-20 21:50:17 +0000649
650 llvm_unreachable("Invalid BuiltinType Kind!");
Douglas Gregor96e578d2010-02-05 17:54:41 +0000651}
652
Aleksei Sidorina693b372016-09-28 10:16:56 +0000653QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
654 QualType OrigT = Importer.Import(T->getOriginalType());
655 if (OrigT.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000656 return {};
Aleksei Sidorina693b372016-09-28 10:16:56 +0000657
658 return Importer.getToContext().getDecayedType(OrigT);
659}
660
John McCall424cec92011-01-19 06:33:43 +0000661QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000662 QualType ToElementType = Importer.Import(T->getElementType());
663 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000664 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000665
Douglas Gregor96e578d2010-02-05 17:54:41 +0000666 return Importer.getToContext().getComplexType(ToElementType);
667}
668
John McCall424cec92011-01-19 06:33:43 +0000669QualType ASTNodeImporter::VisitPointerType(const PointerType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000670 QualType ToPointeeType = Importer.Import(T->getPointeeType());
671 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000672 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000673
Douglas Gregor96e578d2010-02-05 17:54:41 +0000674 return Importer.getToContext().getPointerType(ToPointeeType);
675}
676
John McCall424cec92011-01-19 06:33:43 +0000677QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000678 // FIXME: Check for blocks support in "to" context.
679 QualType ToPointeeType = Importer.Import(T->getPointeeType());
680 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000681 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000682
Douglas Gregor96e578d2010-02-05 17:54:41 +0000683 return Importer.getToContext().getBlockPointerType(ToPointeeType);
684}
685
John McCall424cec92011-01-19 06:33:43 +0000686QualType
687ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000688 // FIXME: Check for C++ support in "to" context.
689 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
690 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000691 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000692
Douglas Gregor96e578d2010-02-05 17:54:41 +0000693 return Importer.getToContext().getLValueReferenceType(ToPointeeType);
694}
695
John McCall424cec92011-01-19 06:33:43 +0000696QualType
697ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000698 // FIXME: Check for C++0x support in "to" context.
699 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten());
700 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000701 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000702
703 return Importer.getToContext().getRValueReferenceType(ToPointeeType);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000704}
705
John McCall424cec92011-01-19 06:33:43 +0000706QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000707 // FIXME: Check for C++ support in "to" context.
708 QualType ToPointeeType = Importer.Import(T->getPointeeType());
709 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000710 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000711
Douglas Gregor96e578d2010-02-05 17:54:41 +0000712 QualType ClassType = Importer.Import(QualType(T->getClass(), 0));
Fangrui Song6907ce22018-07-30 19:24:48 +0000713 return Importer.getToContext().getMemberPointerType(ToPointeeType,
Douglas Gregor96e578d2010-02-05 17:54:41 +0000714 ClassType.getTypePtr());
715}
716
John McCall424cec92011-01-19 06:33:43 +0000717QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000718 QualType ToElementType = Importer.Import(T->getElementType());
719 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000720 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000721
722 return Importer.getToContext().getConstantArrayType(ToElementType,
Douglas Gregor96e578d2010-02-05 17:54:41 +0000723 T->getSize(),
724 T->getSizeModifier(),
725 T->getIndexTypeCVRQualifiers());
726}
727
John McCall424cec92011-01-19 06:33:43 +0000728QualType
729ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000730 QualType ToElementType = Importer.Import(T->getElementType());
731 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000732 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000733
734 return Importer.getToContext().getIncompleteArrayType(ToElementType,
Douglas Gregor96e578d2010-02-05 17:54:41 +0000735 T->getSizeModifier(),
736 T->getIndexTypeCVRQualifiers());
737}
738
John McCall424cec92011-01-19 06:33:43 +0000739QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000740 QualType ToElementType = Importer.Import(T->getElementType());
741 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000742 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +0000743
744 Expr *Size = Importer.Import(T->getSizeExpr());
745 if (!Size)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000746 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000747
Douglas Gregor96e578d2010-02-05 17:54:41 +0000748 SourceRange Brackets = Importer.Import(T->getBracketsRange());
749 return Importer.getToContext().getVariableArrayType(ToElementType, Size,
750 T->getSizeModifier(),
751 T->getIndexTypeCVRQualifiers(),
752 Brackets);
753}
754
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000755QualType ASTNodeImporter::VisitDependentSizedArrayType(
756 const DependentSizedArrayType *T) {
757 QualType ToElementType = Importer.Import(T->getElementType());
758 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000759 return {};
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000760
761 // SizeExpr may be null if size is not specified directly.
762 // For example, 'int a[]'.
763 Expr *Size = Importer.Import(T->getSizeExpr());
764 if (!Size && T->getSizeExpr())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000765 return {};
Gabor Horvathc78d99a2018-01-27 16:11:45 +0000766
767 SourceRange Brackets = Importer.Import(T->getBracketsRange());
768 return Importer.getToContext().getDependentSizedArrayType(
769 ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(),
770 Brackets);
771}
772
John McCall424cec92011-01-19 06:33:43 +0000773QualType ASTNodeImporter::VisitVectorType(const VectorType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000774 QualType ToElementType = Importer.Import(T->getElementType());
775 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000776 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000777
778 return Importer.getToContext().getVectorType(ToElementType,
Douglas Gregor96e578d2010-02-05 17:54:41 +0000779 T->getNumElements(),
Bob Wilsonaeb56442010-11-10 21:56:12 +0000780 T->getVectorKind());
Douglas Gregor96e578d2010-02-05 17:54:41 +0000781}
782
John McCall424cec92011-01-19 06:33:43 +0000783QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000784 QualType ToElementType = Importer.Import(T->getElementType());
785 if (ToElementType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000786 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000787
788 return Importer.getToContext().getExtVectorType(ToElementType,
Douglas Gregor96e578d2010-02-05 17:54:41 +0000789 T->getNumElements());
790}
791
John McCall424cec92011-01-19 06:33:43 +0000792QualType
793ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
Fangrui Song6907ce22018-07-30 19:24:48 +0000794 // FIXME: What happens if we're importing a function without a prototype
Douglas Gregor96e578d2010-02-05 17:54:41 +0000795 // into C++? Should we make it variadic?
Alp Toker314cc812014-01-25 16:55:45 +0000796 QualType ToResultType = Importer.Import(T->getReturnType());
Douglas Gregor96e578d2010-02-05 17:54:41 +0000797 if (ToResultType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000798 return {};
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000799
Douglas Gregor96e578d2010-02-05 17:54:41 +0000800 return Importer.getToContext().getFunctionNoProtoType(ToResultType,
Rafael Espindolac50c27c2010-03-30 20:24:48 +0000801 T->getExtInfo());
Douglas Gregor96e578d2010-02-05 17:54:41 +0000802}
803
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +0000804QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
Alp Toker314cc812014-01-25 16:55:45 +0000805 QualType ToResultType = Importer.Import(T->getReturnType());
Douglas Gregor96e578d2010-02-05 17:54:41 +0000806 if (ToResultType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000807 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000808
Douglas Gregor96e578d2010-02-05 17:54:41 +0000809 // Import argument types
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000810 SmallVector<QualType, 4> ArgTypes;
Aaron Ballman40bd0aa2014-03-17 15:23:01 +0000811 for (const auto &A : T->param_types()) {
812 QualType ArgType = Importer.Import(A);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000813 if (ArgType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000814 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +0000815 ArgTypes.push_back(ArgType);
816 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000817
Douglas Gregor96e578d2010-02-05 17:54:41 +0000818 // Import exception types
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000819 SmallVector<QualType, 4> ExceptionTypes;
Aaron Ballmanb088fbe2014-03-17 15:38:09 +0000820 for (const auto &E : T->exceptions()) {
821 QualType ExceptionType = Importer.Import(E);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000822 if (ExceptionType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000823 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +0000824 ExceptionTypes.push_back(ExceptionType);
825 }
John McCalldb40c7f2010-12-14 08:05:40 +0000826
Argyrios Kyrtzidisb41791d2012-09-22 01:58:06 +0000827 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
828 FunctionProtoType::ExtProtoInfo ToEPI;
829
830 ToEPI.ExtInfo = FromEPI.ExtInfo;
831 ToEPI.Variadic = FromEPI.Variadic;
832 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
833 ToEPI.TypeQuals = FromEPI.TypeQuals;
834 ToEPI.RefQualifier = FromEPI.RefQualifier;
Richard Smith8acb4282014-07-31 21:57:55 +0000835 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
836 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
837 ToEPI.ExceptionSpec.NoexceptExpr =
838 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr);
839 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>(
840 Importer.Import(FromEPI.ExceptionSpec.SourceDecl));
841 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>(
842 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate));
Argyrios Kyrtzidisb41791d2012-09-22 01:58:06 +0000843
Jordan Rose5c382722013-03-08 21:51:21 +0000844 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI);
Argyrios Kyrtzidisb41791d2012-09-22 01:58:06 +0000845}
846
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000847QualType ASTNodeImporter::VisitUnresolvedUsingType(
848 const UnresolvedUsingType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000849 const auto *ToD =
850 cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl()));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000851 if (!ToD)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000852 return {};
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000853
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000854 auto *ToPrevD =
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000855 cast_or_null<UnresolvedUsingTypenameDecl>(
856 Importer.Import(T->getDecl()->getPreviousDecl()));
857 if (!ToPrevD && T->getDecl()->getPreviousDecl())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000858 return {};
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +0000859
860 return Importer.getToContext().getTypeDeclType(ToD, ToPrevD);
861}
862
Sean Callananda6df8a2011-08-11 16:56:07 +0000863QualType ASTNodeImporter::VisitParenType(const ParenType *T) {
864 QualType ToInnerType = Importer.Import(T->getInnerType());
865 if (ToInnerType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000866 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000867
Sean Callananda6df8a2011-08-11 16:56:07 +0000868 return Importer.getToContext().getParenType(ToInnerType);
869}
870
John McCall424cec92011-01-19 06:33:43 +0000871QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000872 auto *ToDecl =
873 dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl()));
Douglas Gregor96e578d2010-02-05 17:54:41 +0000874 if (!ToDecl)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000875 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000876
Douglas Gregor96e578d2010-02-05 17:54:41 +0000877 return Importer.getToContext().getTypeDeclType(ToDecl);
878}
879
John McCall424cec92011-01-19 06:33:43 +0000880QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000881 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
882 if (!ToExpr)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000883 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000884
Douglas Gregor96e578d2010-02-05 17:54:41 +0000885 return Importer.getToContext().getTypeOfExprType(ToExpr);
886}
887
John McCall424cec92011-01-19 06:33:43 +0000888QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +0000889 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
890 if (ToUnderlyingType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000891 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000892
Douglas Gregor96e578d2010-02-05 17:54:41 +0000893 return Importer.getToContext().getTypeOfType(ToUnderlyingType);
894}
895
John McCall424cec92011-01-19 06:33:43 +0000896QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
Richard Smith30482bc2011-02-20 03:19:35 +0000897 // FIXME: Make sure that the "to" context supports C++0x!
Douglas Gregor96e578d2010-02-05 17:54:41 +0000898 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr());
899 if (!ToExpr)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000900 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000901
Douglas Gregor81495f32012-02-12 18:42:33 +0000902 QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
903 if (UnderlyingType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000904 return {};
Douglas Gregor81495f32012-02-12 18:42:33 +0000905
906 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
Douglas Gregor96e578d2010-02-05 17:54:41 +0000907}
908
Alexis Hunte852b102011-05-24 22:41:36 +0000909QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
910 QualType ToBaseType = Importer.Import(T->getBaseType());
911 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
912 if (ToBaseType.isNull() || ToUnderlyingType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000913 return {};
Alexis Hunte852b102011-05-24 22:41:36 +0000914
915 return Importer.getToContext().getUnaryTransformType(ToBaseType,
916 ToUnderlyingType,
917 T->getUTTKind());
918}
919
Richard Smith30482bc2011-02-20 03:19:35 +0000920QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
Richard Smith74aeef52013-04-26 16:15:35 +0000921 // FIXME: Make sure that the "to" context supports C++11!
Richard Smith30482bc2011-02-20 03:19:35 +0000922 QualType FromDeduced = T->getDeducedType();
923 QualType ToDeduced;
924 if (!FromDeduced.isNull()) {
925 ToDeduced = Importer.Import(FromDeduced);
926 if (ToDeduced.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000927 return {};
Richard Smith30482bc2011-02-20 03:19:35 +0000928 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000929
Richard Smithe301ba22015-11-11 02:02:15 +0000930 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(),
Faisal Vali2b391ab2013-09-26 19:54:12 +0000931 /*IsDependent*/false);
Richard Smith30482bc2011-02-20 03:19:35 +0000932}
933
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000934QualType ASTNodeImporter::VisitInjectedClassNameType(
935 const InjectedClassNameType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000936 auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000937 if (!D)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000938 return {};
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000939
940 QualType InjType = Importer.Import(T->getInjectedSpecializationType());
941 if (InjType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000942 return {};
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000943
944 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
945 // See comments in InjectedClassNameType definition for details
946 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
947 enum {
948 TypeAlignmentInBits = 4,
949 TypeAlignment = 1 << TypeAlignmentInBits
950 };
951
952 return QualType(new (Importer.getToContext(), TypeAlignment)
953 InjectedClassNameType(D, InjType), 0);
954}
955
John McCall424cec92011-01-19 06:33:43 +0000956QualType ASTNodeImporter::VisitRecordType(const RecordType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000957 auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl()));
Douglas Gregor96e578d2010-02-05 17:54:41 +0000958 if (!ToDecl)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000959 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +0000960
961 return Importer.getToContext().getTagDeclType(ToDecl);
962}
963
John McCall424cec92011-01-19 06:33:43 +0000964QualType ASTNodeImporter::VisitEnumType(const EnumType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000965 auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl()));
Douglas Gregor96e578d2010-02-05 17:54:41 +0000966 if (!ToDecl)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000967 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +0000968
969 return Importer.getToContext().getTagDeclType(ToDecl);
970}
971
Sean Callanan72fe0852015-04-02 23:50:08 +0000972QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
973 QualType FromModifiedType = T->getModifiedType();
974 QualType FromEquivalentType = T->getEquivalentType();
975 QualType ToModifiedType;
976 QualType ToEquivalentType;
977
978 if (!FromModifiedType.isNull()) {
979 ToModifiedType = Importer.Import(FromModifiedType);
980 if (ToModifiedType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000981 return {};
Sean Callanan72fe0852015-04-02 23:50:08 +0000982 }
983 if (!FromEquivalentType.isNull()) {
984 ToEquivalentType = Importer.Import(FromEquivalentType);
985 if (ToEquivalentType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000986 return {};
Sean Callanan72fe0852015-04-02 23:50:08 +0000987 }
988
989 return Importer.getToContext().getAttributedType(T->getAttrKind(),
990 ToModifiedType, ToEquivalentType);
991}
992
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000993QualType ASTNodeImporter::VisitTemplateTypeParmType(
994 const TemplateTypeParmType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000995 auto *ParmDecl =
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000996 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl()));
997 if (!ParmDecl && T->getDecl())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +0000998 return {};
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +0000999
1000 return Importer.getToContext().getTemplateTypeParmType(
1001 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl);
1002}
1003
Aleksei Sidorin855086d2017-01-23 09:30:36 +00001004QualType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1005 const SubstTemplateTypeParmType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001006 const auto *Replaced =
Aleksei Sidorin855086d2017-01-23 09:30:36 +00001007 cast_or_null<TemplateTypeParmType>(Importer.Import(
1008 QualType(T->getReplacedParameter(), 0)).getTypePtr());
1009 if (!Replaced)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001010 return {};
Aleksei Sidorin855086d2017-01-23 09:30:36 +00001011
1012 QualType Replacement = Importer.Import(T->getReplacementType());
1013 if (Replacement.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001014 return {};
Aleksei Sidorin855086d2017-01-23 09:30:36 +00001015 Replacement = Replacement.getCanonicalType();
1016
1017 return Importer.getToContext().getSubstTemplateTypeParmType(
1018 Replaced, Replacement);
1019}
1020
Douglas Gregore2e50d332010-12-01 01:36:18 +00001021QualType ASTNodeImporter::VisitTemplateSpecializationType(
John McCall424cec92011-01-19 06:33:43 +00001022 const TemplateSpecializationType *T) {
Douglas Gregore2e50d332010-12-01 01:36:18 +00001023 TemplateName ToTemplate = Importer.Import(T->getTemplateName());
1024 if (ToTemplate.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001025 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00001026
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001027 SmallVector<TemplateArgument, 2> ToTemplateArgs;
Douglas Gregore2e50d332010-12-01 01:36:18 +00001028 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs))
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001029 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00001030
Douglas Gregore2e50d332010-12-01 01:36:18 +00001031 QualType ToCanonType;
1032 if (!QualType(T, 0).isCanonical()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00001033 QualType FromCanonType
Douglas Gregore2e50d332010-12-01 01:36:18 +00001034 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1035 ToCanonType =Importer.Import(FromCanonType);
1036 if (ToCanonType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001037 return {};
Douglas Gregore2e50d332010-12-01 01:36:18 +00001038 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001039 return Importer.getToContext().getTemplateSpecializationType(ToTemplate,
David Majnemer6fbeee32016-07-07 04:43:07 +00001040 ToTemplateArgs,
Douglas Gregore2e50d332010-12-01 01:36:18 +00001041 ToCanonType);
1042}
1043
John McCall424cec92011-01-19 06:33:43 +00001044QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
Craig Topper36250ad2014-05-12 05:36:57 +00001045 NestedNameSpecifier *ToQualifier = nullptr;
Abramo Bagnara6150c882010-05-11 21:36:43 +00001046 // Note: the qualifier in an ElaboratedType is optional.
1047 if (T->getQualifier()) {
1048 ToQualifier = Importer.Import(T->getQualifier());
1049 if (!ToQualifier)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001050 return {};
Abramo Bagnara6150c882010-05-11 21:36:43 +00001051 }
Douglas Gregor96e578d2010-02-05 17:54:41 +00001052
1053 QualType ToNamedType = Importer.Import(T->getNamedType());
1054 if (ToNamedType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001055 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00001056
Joel E. Denny7509a2f2018-05-14 19:36:45 +00001057 TagDecl *OwnedTagDecl =
1058 cast_or_null<TagDecl>(Importer.Import(T->getOwnedTagDecl()));
1059 if (!OwnedTagDecl && T->getOwnedTagDecl())
1060 return {};
1061
Abramo Bagnara6150c882010-05-11 21:36:43 +00001062 return Importer.getToContext().getElaboratedType(T->getKeyword(),
Joel E. Denny7509a2f2018-05-14 19:36:45 +00001063 ToQualifier, ToNamedType,
1064 OwnedTagDecl);
Douglas Gregor96e578d2010-02-05 17:54:41 +00001065}
1066
Gabor Horvath7a91c082017-11-14 11:30:38 +00001067QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1068 QualType Pattern = Importer.Import(T->getPattern());
1069 if (Pattern.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001070 return {};
Gabor Horvath7a91c082017-11-14 11:30:38 +00001071
1072 return Importer.getToContext().getPackExpansionType(Pattern,
1073 T->getNumExpansions());
1074}
1075
Gabor Horvathc78d99a2018-01-27 16:11:45 +00001076QualType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1077 const DependentTemplateSpecializationType *T) {
1078 NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier());
1079 if (!Qualifier && T->getQualifier())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001080 return {};
Gabor Horvathc78d99a2018-01-27 16:11:45 +00001081
1082 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1083 if (!Name && T->getIdentifier())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001084 return {};
Gabor Horvathc78d99a2018-01-27 16:11:45 +00001085
1086 SmallVector<TemplateArgument, 2> ToPack;
1087 ToPack.reserve(T->getNumArgs());
1088 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001089 return {};
Gabor Horvathc78d99a2018-01-27 16:11:45 +00001090
1091 return Importer.getToContext().getDependentTemplateSpecializationType(
1092 T->getKeyword(), Qualifier, Name, ToPack);
1093}
1094
Peter Szecsice7f3182018-05-07 12:08:27 +00001095QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1096 NestedNameSpecifier *NNS = Importer.Import(T->getQualifier());
1097 if (!NNS && T->getQualifier())
1098 return QualType();
1099
1100 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1101 if (!Name && T->getIdentifier())
1102 return QualType();
1103
1104 QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr())
1105 ? QualType()
1106 : Importer.Import(T->getCanonicalTypeInternal());
1107 if (!Canon.isNull())
1108 Canon = Canon.getCanonicalType();
1109
1110 return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS,
1111 Name, Canon);
1112}
1113
John McCall424cec92011-01-19 06:33:43 +00001114QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001115 auto *Class =
1116 dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl()));
Douglas Gregor96e578d2010-02-05 17:54:41 +00001117 if (!Class)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001118 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00001119
John McCall8b07ec22010-05-15 11:32:37 +00001120 return Importer.getToContext().getObjCInterfaceType(Class);
1121}
1122
John McCall424cec92011-01-19 06:33:43 +00001123QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
John McCall8b07ec22010-05-15 11:32:37 +00001124 QualType ToBaseType = Importer.Import(T->getBaseType());
1125 if (ToBaseType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001126 return {};
John McCall8b07ec22010-05-15 11:32:37 +00001127
Douglas Gregore9d95f12015-07-07 03:57:35 +00001128 SmallVector<QualType, 4> TypeArgs;
Douglas Gregore83b9562015-07-07 03:57:53 +00001129 for (auto TypeArg : T->getTypeArgsAsWritten()) {
Douglas Gregore9d95f12015-07-07 03:57:35 +00001130 QualType ImportedTypeArg = Importer.Import(TypeArg);
1131 if (ImportedTypeArg.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001132 return {};
Douglas Gregore9d95f12015-07-07 03:57:35 +00001133
1134 TypeArgs.push_back(ImportedTypeArg);
1135 }
1136
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001137 SmallVector<ObjCProtocolDecl *, 4> Protocols;
Aaron Ballman1683f7b2014-03-17 15:55:30 +00001138 for (auto *P : T->quals()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001139 auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P));
Douglas Gregor96e578d2010-02-05 17:54:41 +00001140 if (!Protocol)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001141 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00001142 Protocols.push_back(Protocol);
1143 }
1144
Douglas Gregore9d95f12015-07-07 03:57:35 +00001145 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs,
Douglas Gregorab209d82015-07-07 03:58:42 +00001146 Protocols,
1147 T->isKindOfTypeAsWritten());
Douglas Gregor96e578d2010-02-05 17:54:41 +00001148}
1149
John McCall424cec92011-01-19 06:33:43 +00001150QualType
1151ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
Douglas Gregor96e578d2010-02-05 17:54:41 +00001152 QualType ToPointeeType = Importer.Import(T->getPointeeType());
1153 if (ToPointeeType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001154 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00001155
John McCall8b07ec22010-05-15 11:32:37 +00001156 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType);
Douglas Gregor96e578d2010-02-05 17:54:41 +00001157}
1158
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00001159//----------------------------------------------------------------------------
1160// Import Declarations
1161//----------------------------------------------------------------------------
Fangrui Song6907ce22018-07-30 19:24:48 +00001162bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
1163 DeclContext *&LexicalDC,
1164 DeclarationName &Name,
Sean Callanan59721b32015-04-28 18:41:46 +00001165 NamedDecl *&ToD,
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001166 SourceLocation &Loc) {
Gabor Marton6e1510c2018-07-12 11:50:21 +00001167 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1168 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1169 DeclContext *OrigDC = D->getDeclContext();
1170 FunctionDecl *FunDecl;
1171 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1172 FunDecl->hasBody()) {
Gabor Martonfe68e292018-08-06 14:38:37 +00001173 auto getLeafPointeeType = [](const Type *T) {
1174 while (T->isPointerType() || T->isArrayType()) {
1175 T = T->getPointeeOrArrayElementType();
1176 }
1177 return T;
1178 };
1179 for (const ParmVarDecl *P : FunDecl->parameters()) {
1180 const Type *LeafT =
1181 getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
1182 auto *RT = dyn_cast<RecordType>(LeafT);
1183 if (RT && RT->getDecl() == D) {
1184 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1185 << D->getDeclKindName();
1186 return true;
1187 }
Gabor Marton6e1510c2018-07-12 11:50:21 +00001188 }
1189 }
1190
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001191 // Import the context of this declaration.
Gabor Marton6e1510c2018-07-12 11:50:21 +00001192 DC = Importer.ImportContext(OrigDC);
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001193 if (!DC)
1194 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +00001195
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001196 LexicalDC = DC;
1197 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1198 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1199 if (!LexicalDC)
1200 return true;
1201 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001202
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001203 // Import the name of this declaration.
1204 Name = Importer.Import(D->getDeclName());
1205 if (D->getDeclName() && !Name)
1206 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +00001207
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001208 // Import the location of this declaration.
1209 Loc = Importer.Import(D->getLocation());
Sean Callanan59721b32015-04-28 18:41:46 +00001210 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
Douglas Gregorbb7930c2010-02-10 19:54:31 +00001211 return false;
1212}
1213
Douglas Gregord451ea92011-07-29 23:31:30 +00001214void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1215 if (!FromD)
1216 return;
Fangrui Song6907ce22018-07-30 19:24:48 +00001217
Douglas Gregord451ea92011-07-29 23:31:30 +00001218 if (!ToD) {
1219 ToD = Importer.Import(FromD);
1220 if (!ToD)
1221 return;
1222 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001223
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001224 if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1225 if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) {
Sean Callanan19dfc932013-01-11 23:17:47 +00001226 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) {
Douglas Gregord451ea92011-07-29 23:31:30 +00001227 ImportDefinition(FromRecord, ToRecord);
1228 }
1229 }
1230 return;
1231 }
1232
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001233 if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1234 if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) {
Douglas Gregord451ea92011-07-29 23:31:30 +00001235 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1236 ImportDefinition(FromEnum, ToEnum);
1237 }
1238 }
1239 return;
1240 }
1241}
1242
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001243void
1244ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From,
1245 DeclarationNameInfo& To) {
1246 // NOTE: To.Name and To.Loc are already imported.
1247 // We only have to import To.LocInfo.
1248 switch (To.getName().getNameKind()) {
1249 case DeclarationName::Identifier:
1250 case DeclarationName::ObjCZeroArgSelector:
1251 case DeclarationName::ObjCOneArgSelector:
1252 case DeclarationName::ObjCMultiArgSelector:
1253 case DeclarationName::CXXUsingDirective:
Richard Smith35845152017-02-07 01:37:30 +00001254 case DeclarationName::CXXDeductionGuideName:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001255 return;
1256
1257 case DeclarationName::CXXOperatorName: {
1258 SourceRange Range = From.getCXXOperatorNameRange();
1259 To.setCXXOperatorNameRange(Importer.Import(Range));
1260 return;
1261 }
1262 case DeclarationName::CXXLiteralOperatorName: {
1263 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc();
1264 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc));
1265 return;
1266 }
1267 case DeclarationName::CXXConstructorName:
1268 case DeclarationName::CXXDestructorName:
1269 case DeclarationName::CXXConversionFunctionName: {
1270 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo();
1271 To.setNamedTypeInfo(Importer.Import(FromTInfo));
1272 return;
1273 }
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001274 }
Douglas Gregor07216d12011-11-02 20:52:01 +00001275 llvm_unreachable("Unknown name kind.");
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001276}
1277
Fangrui Song6907ce22018-07-30 19:24:48 +00001278void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
Douglas Gregor0a791672011-01-18 03:11:38 +00001279 if (Importer.isMinimalImport() && !ForceImport) {
Sean Callanan81d577c2011-07-22 23:46:03 +00001280 Importer.ImportContext(FromDC);
Douglas Gregor0a791672011-01-18 03:11:38 +00001281 return;
1282 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001283
Aaron Ballman629afae2014-03-07 19:56:05 +00001284 for (auto *From : FromDC->decls())
1285 Importer.Import(From);
Douglas Gregor968d6332010-02-21 18:24:45 +00001286}
1287
Balazs Keri1d20cc22018-07-16 12:16:39 +00001288void ASTNodeImporter::ImportImplicitMethods(
1289 const CXXRecordDecl *From, CXXRecordDecl *To) {
1290 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1291 "Import implicit methods to or from non-definition");
Fangrui Song6907ce22018-07-30 19:24:48 +00001292
Balazs Keri1d20cc22018-07-16 12:16:39 +00001293 for (CXXMethodDecl *FromM : From->methods())
1294 if (FromM->isImplicit())
1295 Importer.Import(FromM);
1296}
1297
Aleksei Sidorin04fbffc2018-04-24 10:11:53 +00001298static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1299 ASTImporter &Importer) {
1300 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1301 auto *ToTypedef =
1302 cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef));
1303 assert (ToTypedef && "Failed to import typedef of an anonymous structure");
1304
1305 To->setTypedefNameForAnonDecl(ToTypedef);
1306 }
1307}
1308
Fangrui Song6907ce22018-07-30 19:24:48 +00001309bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
Douglas Gregor95d82832012-01-24 18:36:04 +00001310 ImportDefinitionKind Kind) {
1311 if (To->getDefinition() || To->isBeingDefined()) {
1312 if (Kind == IDK_Everything)
1313 ImportDeclContext(From, /*ForceImport=*/true);
Fangrui Song6907ce22018-07-30 19:24:48 +00001314
Douglas Gregore2e50d332010-12-01 01:36:18 +00001315 return false;
Douglas Gregor95d82832012-01-24 18:36:04 +00001316 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001317
Douglas Gregore2e50d332010-12-01 01:36:18 +00001318 To->startDefinition();
Aleksei Sidorin04fbffc2018-04-24 10:11:53 +00001319
1320 setTypedefNameForAnonDecl(From, To, Importer);
Fangrui Song6907ce22018-07-30 19:24:48 +00001321
Douglas Gregore2e50d332010-12-01 01:36:18 +00001322 // Add base classes.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001323 if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) {
1324 auto *FromCXX = cast<CXXRecordDecl>(From);
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001325
1326 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1327 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1328 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor;
Richard Smith328aae52012-11-30 05:11:39 +00001329 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers;
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001330 ToData.Aggregate = FromData.Aggregate;
1331 ToData.PlainOldData = FromData.PlainOldData;
1332 ToData.Empty = FromData.Empty;
1333 ToData.Polymorphic = FromData.Polymorphic;
1334 ToData.Abstract = FromData.Abstract;
1335 ToData.IsStandardLayout = FromData.IsStandardLayout;
Richard Smithb6070db2018-04-05 18:55:37 +00001336 ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout;
1337 ToData.HasBasesWithFields = FromData.HasBasesWithFields;
1338 ToData.HasBasesWithNonStaticDataMembers =
1339 FromData.HasBasesWithNonStaticDataMembers;
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001340 ToData.HasPrivateFields = FromData.HasPrivateFields;
1341 ToData.HasProtectedFields = FromData.HasProtectedFields;
1342 ToData.HasPublicFields = FromData.HasPublicFields;
1343 ToData.HasMutableFields = FromData.HasMutableFields;
Richard Smithab44d5b2013-12-10 08:25:00 +00001344 ToData.HasVariantMembers = FromData.HasVariantMembers;
Richard Smith561fb152012-02-25 07:33:38 +00001345 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers;
Richard Smithe2648ba2012-05-07 01:07:30 +00001346 ToData.HasInClassInitializer = FromData.HasInClassInitializer;
Richard Smith593f9932012-12-08 02:01:17 +00001347 ToData.HasUninitializedReferenceMember
1348 = FromData.HasUninitializedReferenceMember;
Nico Weber6a6376b2016-02-19 01:52:46 +00001349 ToData.HasUninitializedFields = FromData.HasUninitializedFields;
Richard Smith12e79312016-05-13 06:47:56 +00001350 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor;
1351 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment;
Richard Smith96cd6712017-08-16 01:49:53 +00001352 ToData.NeedOverloadResolutionForCopyConstructor
1353 = FromData.NeedOverloadResolutionForCopyConstructor;
Richard Smith6b02d462012-12-08 08:32:28 +00001354 ToData.NeedOverloadResolutionForMoveConstructor
1355 = FromData.NeedOverloadResolutionForMoveConstructor;
1356 ToData.NeedOverloadResolutionForMoveAssignment
1357 = FromData.NeedOverloadResolutionForMoveAssignment;
1358 ToData.NeedOverloadResolutionForDestructor
1359 = FromData.NeedOverloadResolutionForDestructor;
Richard Smith96cd6712017-08-16 01:49:53 +00001360 ToData.DefaultedCopyConstructorIsDeleted
1361 = FromData.DefaultedCopyConstructorIsDeleted;
Richard Smith6b02d462012-12-08 08:32:28 +00001362 ToData.DefaultedMoveConstructorIsDeleted
1363 = FromData.DefaultedMoveConstructorIsDeleted;
1364 ToData.DefaultedMoveAssignmentIsDeleted
1365 = FromData.DefaultedMoveAssignmentIsDeleted;
1366 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted;
Richard Smith328aae52012-11-30 05:11:39 +00001367 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers;
1368 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor;
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001369 ToData.HasConstexprNonCopyMoveConstructor
1370 = FromData.HasConstexprNonCopyMoveConstructor;
Nico Weber72c57f42016-02-24 20:58:14 +00001371 ToData.HasDefaultedDefaultConstructor
1372 = FromData.HasDefaultedDefaultConstructor;
Richard Smith561fb152012-02-25 07:33:38 +00001373 ToData.DefaultedDefaultConstructorIsConstexpr
1374 = FromData.DefaultedDefaultConstructorIsConstexpr;
Richard Smith561fb152012-02-25 07:33:38 +00001375 ToData.HasConstexprDefaultConstructor
1376 = FromData.HasConstexprDefaultConstructor;
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001377 ToData.HasNonLiteralTypeFieldsOrBases
1378 = FromData.HasNonLiteralTypeFieldsOrBases;
Richard Smith561fb152012-02-25 07:33:38 +00001379 // ComputedVisibleConversions not imported.
Douglas Gregor3c2404b2011-11-03 18:07:07 +00001380 ToData.UserProvidedDefaultConstructor
1381 = FromData.UserProvidedDefaultConstructor;
Richard Smith328aae52012-11-30 05:11:39 +00001382 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers;
Richard Smithdf054d32017-02-25 23:53:05 +00001383 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase
1384 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase;
1385 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase
1386 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase;
Richard Smith1c33fe82012-11-28 06:23:12 +00001387 ToData.ImplicitCopyAssignmentHasConstParam
1388 = FromData.ImplicitCopyAssignmentHasConstParam;
1389 ToData.HasDeclaredCopyConstructorWithConstParam
1390 = FromData.HasDeclaredCopyConstructorWithConstParam;
1391 ToData.HasDeclaredCopyAssignmentWithConstParam
1392 = FromData.HasDeclaredCopyAssignmentWithConstParam;
Richard Smith561fb152012-02-25 07:33:38 +00001393
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001394 SmallVector<CXXBaseSpecifier *, 4> Bases;
Aaron Ballman574705e2014-03-13 15:41:46 +00001395 for (const auto &Base1 : FromCXX->bases()) {
1396 QualType T = Importer.Import(Base1.getType());
Douglas Gregore2e50d332010-12-01 01:36:18 +00001397 if (T.isNull())
Douglas Gregor96303ea2010-12-02 19:33:37 +00001398 return true;
Douglas Gregor752a5952011-01-03 22:36:02 +00001399
1400 SourceLocation EllipsisLoc;
Aaron Ballman574705e2014-03-13 15:41:46 +00001401 if (Base1.isPackExpansion())
1402 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc());
Douglas Gregord451ea92011-07-29 23:31:30 +00001403
1404 // Ensure that we have a definition for the base.
Aaron Ballman574705e2014-03-13 15:41:46 +00001405 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl());
Fangrui Song6907ce22018-07-30 19:24:48 +00001406
Douglas Gregore2e50d332010-12-01 01:36:18 +00001407 Bases.push_back(
Fangrui Song6907ce22018-07-30 19:24:48 +00001408 new (Importer.getToContext())
Aaron Ballman574705e2014-03-13 15:41:46 +00001409 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()),
1410 Base1.isVirtual(),
1411 Base1.isBaseOfClass(),
1412 Base1.getAccessSpecifierAsWritten(),
1413 Importer.Import(Base1.getTypeSourceInfo()),
Douglas Gregor752a5952011-01-03 22:36:02 +00001414 EllipsisLoc));
Douglas Gregore2e50d332010-12-01 01:36:18 +00001415 }
1416 if (!Bases.empty())
Craig Toppere6337e12015-12-25 00:36:02 +00001417 ToCXX->setBases(Bases.data(), Bases.size());
Douglas Gregore2e50d332010-12-01 01:36:18 +00001418 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001419
Douglas Gregor2e15c842012-02-01 21:00:38 +00001420 if (shouldForceImportDeclContext(Kind))
Douglas Gregor95d82832012-01-24 18:36:04 +00001421 ImportDeclContext(From, /*ForceImport=*/true);
Fangrui Song6907ce22018-07-30 19:24:48 +00001422
Douglas Gregore2e50d332010-12-01 01:36:18 +00001423 To->completeDefinition();
Douglas Gregor96303ea2010-12-02 19:33:37 +00001424 return false;
Douglas Gregore2e50d332010-12-01 01:36:18 +00001425}
1426
Larisse Voufo39a1e502013-08-06 01:03:05 +00001427bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To,
1428 ImportDefinitionKind Kind) {
Sean Callanan59721b32015-04-28 18:41:46 +00001429 if (To->getAnyInitializer())
Larisse Voufo39a1e502013-08-06 01:03:05 +00001430 return false;
1431
1432 // FIXME: Can we really import any initializer? Alternatively, we could force
1433 // ourselves to import every declaration of a variable and then only use
1434 // getInit() here.
1435 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer())));
1436
1437 // FIXME: Other bits to merge?
1438
1439 return false;
1440}
1441
Fangrui Song6907ce22018-07-30 19:24:48 +00001442bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +00001443 ImportDefinitionKind Kind) {
1444 if (To->getDefinition() || To->isBeingDefined()) {
1445 if (Kind == IDK_Everything)
1446 ImportDeclContext(From, /*ForceImport=*/true);
Douglas Gregord451ea92011-07-29 23:31:30 +00001447 return false;
Douglas Gregor2e15c842012-02-01 21:00:38 +00001448 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001449
Douglas Gregord451ea92011-07-29 23:31:30 +00001450 To->startDefinition();
1451
Aleksei Sidorin04fbffc2018-04-24 10:11:53 +00001452 setTypedefNameForAnonDecl(From, To, Importer);
1453
Douglas Gregord451ea92011-07-29 23:31:30 +00001454 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From));
1455 if (T.isNull())
1456 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +00001457
Douglas Gregord451ea92011-07-29 23:31:30 +00001458 QualType ToPromotionType = Importer.Import(From->getPromotionType());
1459 if (ToPromotionType.isNull())
1460 return true;
Douglas Gregor2e15c842012-02-01 21:00:38 +00001461
1462 if (shouldForceImportDeclContext(Kind))
1463 ImportDeclContext(From, /*ForceImport=*/true);
Fangrui Song6907ce22018-07-30 19:24:48 +00001464
Douglas Gregord451ea92011-07-29 23:31:30 +00001465 // FIXME: we might need to merge the number of positive or negative bits
1466 // if the enumerator lists don't match.
1467 To->completeDefinition(T, ToPromotionType,
1468 From->getNumPositiveBits(),
1469 From->getNumNegativeBits());
1470 return false;
1471}
1472
Douglas Gregora082a492010-11-30 19:14:50 +00001473TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList(
1474 TemplateParameterList *Params) {
Aleksei Sidorina693b372016-09-28 10:16:56 +00001475 SmallVector<NamedDecl *, 4> ToParams(Params->size());
1476 if (ImportContainerChecked(*Params, ToParams))
1477 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00001478
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00001479 Expr *ToRequiresClause;
1480 if (Expr *const R = Params->getRequiresClause()) {
1481 ToRequiresClause = Importer.Import(R);
1482 if (!ToRequiresClause)
1483 return nullptr;
1484 } else {
1485 ToRequiresClause = nullptr;
1486 }
1487
Douglas Gregora082a492010-11-30 19:14:50 +00001488 return TemplateParameterList::Create(Importer.getToContext(),
1489 Importer.Import(Params->getTemplateLoc()),
1490 Importer.Import(Params->getLAngleLoc()),
David Majnemer902f8c62015-12-27 07:16:27 +00001491 ToParams,
Hubert Tonge4a0c0e2016-07-30 22:33:34 +00001492 Importer.Import(Params->getRAngleLoc()),
1493 ToRequiresClause);
Douglas Gregora082a492010-11-30 19:14:50 +00001494}
1495
Fangrui Song6907ce22018-07-30 19:24:48 +00001496TemplateArgument
Douglas Gregore2e50d332010-12-01 01:36:18 +00001497ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
1498 switch (From.getKind()) {
1499 case TemplateArgument::Null:
1500 return TemplateArgument();
Fangrui Song6907ce22018-07-30 19:24:48 +00001501
Douglas Gregore2e50d332010-12-01 01:36:18 +00001502 case TemplateArgument::Type: {
1503 QualType ToType = Importer.Import(From.getAsType());
1504 if (ToType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001505 return {};
Douglas Gregore2e50d332010-12-01 01:36:18 +00001506 return TemplateArgument(ToType);
1507 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001508
Douglas Gregore2e50d332010-12-01 01:36:18 +00001509 case TemplateArgument::Integral: {
1510 QualType ToType = Importer.Import(From.getIntegralType());
1511 if (ToType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001512 return {};
Benjamin Kramer6003ad52012-06-07 15:09:51 +00001513 return TemplateArgument(From, ToType);
Douglas Gregore2e50d332010-12-01 01:36:18 +00001514 }
1515
Eli Friedmanb826a002012-09-26 02:36:12 +00001516 case TemplateArgument::Declaration: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001517 auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl()));
David Blaikie3c7dd6b2014-10-22 19:54:16 +00001518 QualType ToType = Importer.Import(From.getParamTypeForDecl());
1519 if (!To || ToType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001520 return {};
David Blaikie3c7dd6b2014-10-22 19:54:16 +00001521 return TemplateArgument(To, ToType);
Eli Friedmanb826a002012-09-26 02:36:12 +00001522 }
1523
1524 case TemplateArgument::NullPtr: {
1525 QualType ToType = Importer.Import(From.getNullPtrType());
1526 if (ToType.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001527 return {};
Eli Friedmanb826a002012-09-26 02:36:12 +00001528 return TemplateArgument(ToType, /*isNullPtr*/true);
1529 }
1530
Douglas Gregore2e50d332010-12-01 01:36:18 +00001531 case TemplateArgument::Template: {
1532 TemplateName ToTemplate = Importer.Import(From.getAsTemplate());
1533 if (ToTemplate.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001534 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00001535
Douglas Gregore2e50d332010-12-01 01:36:18 +00001536 return TemplateArgument(ToTemplate);
1537 }
Douglas Gregore4ff4b52011-01-05 18:58:31 +00001538
1539 case TemplateArgument::TemplateExpansion: {
Fangrui Song6907ce22018-07-30 19:24:48 +00001540 TemplateName ToTemplate
Douglas Gregore4ff4b52011-01-05 18:58:31 +00001541 = Importer.Import(From.getAsTemplateOrTemplatePattern());
1542 if (ToTemplate.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001543 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00001544
Douglas Gregore1d60df2011-01-14 23:41:42 +00001545 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions());
Douglas Gregore4ff4b52011-01-05 18:58:31 +00001546 }
1547
Douglas Gregore2e50d332010-12-01 01:36:18 +00001548 case TemplateArgument::Expression:
1549 if (Expr *ToExpr = Importer.Import(From.getAsExpr()))
1550 return TemplateArgument(ToExpr);
1551 return TemplateArgument();
Fangrui Song6907ce22018-07-30 19:24:48 +00001552
Douglas Gregore2e50d332010-12-01 01:36:18 +00001553 case TemplateArgument::Pack: {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001554 SmallVector<TemplateArgument, 2> ToPack;
Douglas Gregore2e50d332010-12-01 01:36:18 +00001555 ToPack.reserve(From.pack_size());
1556 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack))
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001557 return {};
Benjamin Kramercce63472015-08-05 09:40:22 +00001558
1559 return TemplateArgument(
1560 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
Douglas Gregore2e50d332010-12-01 01:36:18 +00001561 }
1562 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001563
Douglas Gregore2e50d332010-12-01 01:36:18 +00001564 llvm_unreachable("Invalid template argument kind");
Douglas Gregore2e50d332010-12-01 01:36:18 +00001565}
1566
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001567Optional<TemplateArgumentLoc>
1568ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) {
Aleksei Sidorina693b372016-09-28 10:16:56 +00001569 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument());
1570 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
1571 TemplateArgumentLocInfo ToInfo;
1572 if (Arg.getKind() == TemplateArgument::Expression) {
1573 Expr *E = Importer.Import(FromInfo.getAsExpr());
1574 ToInfo = TemplateArgumentLocInfo(E);
1575 if (!E)
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001576 return None;
Aleksei Sidorina693b372016-09-28 10:16:56 +00001577 } else if (Arg.getKind() == TemplateArgument::Type) {
1578 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo()))
1579 ToInfo = TemplateArgumentLocInfo(TSI);
1580 else
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001581 return None;
Aleksei Sidorina693b372016-09-28 10:16:56 +00001582 } else {
1583 ToInfo = TemplateArgumentLocInfo(
1584 Importer.Import(FromInfo.getTemplateQualifierLoc()),
1585 Importer.Import(FromInfo.getTemplateNameLoc()),
1586 Importer.Import(FromInfo.getTemplateEllipsisLoc()));
1587 }
1588 return TemplateArgumentLoc(Arg, ToInfo);
1589}
1590
Douglas Gregore2e50d332010-12-01 01:36:18 +00001591bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs,
1592 unsigned NumFromArgs,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001593 SmallVectorImpl<TemplateArgument> &ToArgs) {
Douglas Gregore2e50d332010-12-01 01:36:18 +00001594 for (unsigned I = 0; I != NumFromArgs; ++I) {
1595 TemplateArgument To = ImportTemplateArgument(FromArgs[I]);
1596 if (To.isNull() && !FromArgs[I].isNull())
1597 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +00001598
Douglas Gregore2e50d332010-12-01 01:36:18 +00001599 ToArgs.push_back(To);
1600 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001601
Douglas Gregore2e50d332010-12-01 01:36:18 +00001602 return false;
1603}
1604
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00001605// We cannot use Optional<> pattern here and below because
1606// TemplateArgumentListInfo's operator new is declared as deleted so it cannot
1607// be stored in Optional.
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00001608template <typename InContainerTy>
1609bool ASTNodeImporter::ImportTemplateArgumentListInfo(
1610 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
1611 for (const auto &FromLoc : Container) {
1612 if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc))
1613 ToTAInfo.addArgument(*ToLoc);
1614 else
1615 return true;
1616 }
1617 return false;
1618}
1619
Gabor Marton26f72a92018-07-12 09:42:05 +00001620static StructuralEquivalenceKind
1621getStructuralEquivalenceKind(const ASTImporter &Importer) {
1622 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
1623 : StructuralEquivalenceKind::Default;
1624}
1625
Gabor Marton950fb572018-07-17 12:39:27 +00001626bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
1627 StructuralEquivalenceContext Ctx(
1628 Importer.getFromContext(), Importer.getToContext(),
1629 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1630 false, Complain);
1631 return Ctx.IsEquivalent(From, To);
1632}
1633
1634bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
Douglas Gregordd6006f2012-07-17 21:16:27 +00001635 RecordDecl *ToRecord, bool Complain) {
Sean Callananc665c9e2013-10-09 21:45:11 +00001636 // Eliminate a potential failure point where we attempt to re-import
1637 // something we're trying to import while completing ToRecord.
1638 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
1639 if (ToOrigin) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001640 auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
Sean Callananc665c9e2013-10-09 21:45:11 +00001641 if (ToOriginRecord)
1642 ToRecord = ToOriginRecord;
1643 }
1644
Benjamin Kramer26d19c52010-02-18 13:02:13 +00001645 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
Sean Callananc665c9e2013-10-09 21:45:11 +00001646 ToRecord->getASTContext(),
Douglas Gregordd6006f2012-07-17 21:16:27 +00001647 Importer.getNonEquivalentDecls(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001648 getStructuralEquivalenceKind(Importer),
Douglas Gregordd6006f2012-07-17 21:16:27 +00001649 false, Complain);
Gabor Marton950fb572018-07-17 12:39:27 +00001650 return Ctx.IsEquivalent(FromRecord, ToRecord);
Douglas Gregor5c73e912010-02-11 00:48:18 +00001651}
1652
Larisse Voufo39a1e502013-08-06 01:03:05 +00001653bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
1654 bool Complain) {
1655 StructuralEquivalenceContext Ctx(
1656 Importer.getFromContext(), Importer.getToContext(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001657 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1658 false, Complain);
Gabor Marton950fb572018-07-17 12:39:27 +00001659 return Ctx.IsEquivalent(FromVar, ToVar);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001660}
1661
Douglas Gregor98c10182010-02-12 22:17:39 +00001662bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
Gabor Marton26f72a92018-07-12 09:42:05 +00001663 StructuralEquivalenceContext Ctx(
1664 Importer.getFromContext(), Importer.getToContext(),
1665 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
Gabor Marton950fb572018-07-17 12:39:27 +00001666 return Ctx.IsEquivalent(FromEnum, ToEnum);
Douglas Gregor98c10182010-02-12 22:17:39 +00001667}
1668
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00001669bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
1670 FunctionTemplateDecl *To) {
1671 StructuralEquivalenceContext Ctx(
1672 Importer.getFromContext(), Importer.getToContext(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001673 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1674 false, false);
Gabor Marton950fb572018-07-17 12:39:27 +00001675 return Ctx.IsEquivalent(From, To);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00001676}
1677
Balazs Keric7797c42018-07-11 09:37:24 +00001678bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
1679 StructuralEquivalenceContext Ctx(
1680 Importer.getFromContext(), Importer.getToContext(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001681 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
1682 false, false);
Gabor Marton950fb572018-07-17 12:39:27 +00001683 return Ctx.IsEquivalent(From, To);
Balazs Keric7797c42018-07-11 09:37:24 +00001684}
1685
Douglas Gregor91155082012-11-14 22:29:20 +00001686bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001687 EnumConstantDecl *ToEC) {
Douglas Gregor91155082012-11-14 22:29:20 +00001688 const llvm::APSInt &FromVal = FromEC->getInitVal();
1689 const llvm::APSInt &ToVal = ToEC->getInitVal();
1690
1691 return FromVal.isSigned() == ToVal.isSigned() &&
1692 FromVal.getBitWidth() == ToVal.getBitWidth() &&
1693 FromVal == ToVal;
1694}
1695
1696bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
Douglas Gregora082a492010-11-30 19:14:50 +00001697 ClassTemplateDecl *To) {
1698 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1699 Importer.getToContext(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001700 Importer.getNonEquivalentDecls(),
1701 getStructuralEquivalenceKind(Importer));
Gabor Marton950fb572018-07-17 12:39:27 +00001702 return Ctx.IsEquivalent(From, To);
Douglas Gregora082a492010-11-30 19:14:50 +00001703}
1704
Larisse Voufo39a1e502013-08-06 01:03:05 +00001705bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
1706 VarTemplateDecl *To) {
1707 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
1708 Importer.getToContext(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001709 Importer.getNonEquivalentDecls(),
1710 getStructuralEquivalenceKind(Importer));
Gabor Marton950fb572018-07-17 12:39:27 +00001711 return Ctx.IsEquivalent(From, To);
Larisse Voufo39a1e502013-08-06 01:03:05 +00001712}
1713
Douglas Gregore4c83e42010-02-09 22:48:33 +00001714Decl *ASTNodeImporter::VisitDecl(Decl *D) {
Douglas Gregor811663e2010-02-10 00:15:17 +00001715 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
Douglas Gregore4c83e42010-02-09 22:48:33 +00001716 << D->getDeclKindName();
Craig Topper36250ad2014-05-12 05:36:57 +00001717 return nullptr;
Douglas Gregore4c83e42010-02-09 22:48:33 +00001718}
1719
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001720Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
1721 // Import the context of this declaration.
1722 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1723 if (!DC)
1724 return nullptr;
1725
1726 DeclContext *LexicalDC = DC;
1727 if (D->getDeclContext() != D->getLexicalDeclContext()) {
1728 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
1729 if (!LexicalDC)
1730 return nullptr;
1731 }
1732
1733 // Import the location of this declaration.
1734 SourceLocation Loc = Importer.Import(D->getLocation());
1735
Gabor Marton26f72a92018-07-12 09:42:05 +00001736 EmptyDecl *ToD;
1737 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc))
1738 return ToD;
1739
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001740 ToD->setLexicalDeclContext(LexicalDC);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001741 LexicalDC->addDeclInternal(ToD);
1742 return ToD;
1743}
1744
Sean Callanan65198272011-11-17 23:20:56 +00001745Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
Fangrui Song6907ce22018-07-30 19:24:48 +00001746 TranslationUnitDecl *ToD =
Sean Callanan65198272011-11-17 23:20:56 +00001747 Importer.getToContext().getTranslationUnitDecl();
Fangrui Song6907ce22018-07-30 19:24:48 +00001748
Gabor Marton26f72a92018-07-12 09:42:05 +00001749 Importer.MapImported(D, ToD);
Fangrui Song6907ce22018-07-30 19:24:48 +00001750
Sean Callanan65198272011-11-17 23:20:56 +00001751 return ToD;
1752}
1753
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +00001754Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +00001755 SourceLocation Loc = Importer.Import(D->getLocation());
1756 SourceLocation ColonLoc = Importer.Import(D->getColonLoc());
1757
1758 // Import the context of this declaration.
1759 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1760 if (!DC)
1761 return nullptr;
1762
Gabor Marton26f72a92018-07-12 09:42:05 +00001763 AccessSpecDecl *ToD;
1764 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
1765 DC, Loc, ColonLoc))
1766 return ToD;
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +00001767
1768 // Lexical DeclContext and Semantic DeclContext
1769 // is always the same for the accessSpec.
Gabor Marton26f72a92018-07-12 09:42:05 +00001770 ToD->setLexicalDeclContext(DC);
1771 DC->addDeclInternal(ToD);
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +00001772
Gabor Marton26f72a92018-07-12 09:42:05 +00001773 return ToD;
Argyrios Kyrtzidis544ea712016-02-18 23:08:36 +00001774}
1775
Aleksei Sidorina693b372016-09-28 10:16:56 +00001776Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1777 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
1778 if (!DC)
1779 return nullptr;
1780
1781 DeclContext *LexicalDC = DC;
1782
1783 // Import the location of this declaration.
1784 SourceLocation Loc = Importer.Import(D->getLocation());
1785
1786 Expr *AssertExpr = Importer.Import(D->getAssertExpr());
1787 if (!AssertExpr)
1788 return nullptr;
1789
1790 StringLiteral *FromMsg = D->getMessage();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001791 auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg));
Aleksei Sidorina693b372016-09-28 10:16:56 +00001792 if (!ToMsg && FromMsg)
1793 return nullptr;
1794
Gabor Marton26f72a92018-07-12 09:42:05 +00001795 StaticAssertDecl *ToD;
1796 if (GetImportedOrCreateDecl(
1797 ToD, D, Importer.getToContext(), DC, Loc, AssertExpr, ToMsg,
1798 Importer.Import(D->getRParenLoc()), D->isFailed()))
1799 return ToD;
Aleksei Sidorina693b372016-09-28 10:16:56 +00001800
1801 ToD->setLexicalDeclContext(LexicalDC);
1802 LexicalDC->addDeclInternal(ToD);
Aleksei Sidorina693b372016-09-28 10:16:56 +00001803 return ToD;
1804}
1805
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001806Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
1807 // Import the major distinguishing characteristics of this namespace.
1808 DeclContext *DC, *LexicalDC;
1809 DeclarationName Name;
1810 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00001811 NamedDecl *ToD;
1812 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00001813 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00001814 if (ToD)
1815 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00001816
1817 NamespaceDecl *MergeWithNamespace = nullptr;
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001818 if (!Name) {
1819 // This is an anonymous namespace. Adopt an existing anonymous
1820 // namespace if we can.
1821 // FIXME: Not testable.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001822 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001823 MergeWithNamespace = TU->getAnonymousNamespace();
1824 else
1825 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
1826 } else {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001827 SmallVector<NamedDecl *, 4> ConflictingDecls;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001828 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00001829 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001830 for (auto *FoundDecl : FoundDecls) {
1831 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001832 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00001833
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001834 if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001835 MergeWithNamespace = FoundNS;
1836 ConflictingDecls.clear();
1837 break;
1838 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001839
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001840 ConflictingDecls.push_back(FoundDecl);
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001841 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001842
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001843 if (!ConflictingDecls.empty()) {
John McCalle87beb22010-04-23 18:46:30 +00001844 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace,
Fangrui Song6907ce22018-07-30 19:24:48 +00001845 ConflictingDecls.data(),
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001846 ConflictingDecls.size());
1847 }
1848 }
Fangrui Song6907ce22018-07-30 19:24:48 +00001849
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001850 // Create the "to" namespace, if needed.
1851 NamespaceDecl *ToNamespace = MergeWithNamespace;
1852 if (!ToNamespace) {
Gabor Marton26f72a92018-07-12 09:42:05 +00001853 if (GetImportedOrCreateDecl(
1854 ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001855 Importer.Import(D->getBeginLoc()), Loc, Name.getAsIdentifierInfo(),
Gabor Marton26f72a92018-07-12 09:42:05 +00001856 /*PrevDecl=*/nullptr))
1857 return ToNamespace;
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001858 ToNamespace->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00001859 LexicalDC->addDeclInternal(ToNamespace);
Fangrui Song6907ce22018-07-30 19:24:48 +00001860
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001861 // If this is an anonymous namespace, register it as the anonymous
1862 // namespace within its context.
1863 if (!Name) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001864 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001865 TU->setAnonymousNamespace(ToNamespace);
1866 else
1867 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
1868 }
1869 }
Gabor Marton26f72a92018-07-12 09:42:05 +00001870 Importer.MapImported(D, ToNamespace);
Fangrui Song6907ce22018-07-30 19:24:48 +00001871
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001872 ImportDeclContext(D);
Fangrui Song6907ce22018-07-30 19:24:48 +00001873
Douglas Gregorf18a2c72010-02-21 18:26:36 +00001874 return ToNamespace;
1875}
1876
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001877Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1878 // Import the major distinguishing characteristics of this namespace.
1879 DeclContext *DC, *LexicalDC;
1880 DeclarationName Name;
1881 SourceLocation Loc;
1882 NamedDecl *LookupD;
1883 if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
1884 return nullptr;
1885 if (LookupD)
1886 return LookupD;
1887
1888 // NOTE: No conflict resolution is done for namespace aliases now.
1889
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001890 auto *TargetDecl = cast_or_null<NamespaceDecl>(
1891 Importer.Import(D->getNamespace()));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001892 if (!TargetDecl)
1893 return nullptr;
1894
1895 IdentifierInfo *ToII = Importer.Import(D->getIdentifier());
1896 if (!ToII)
1897 return nullptr;
1898
1899 NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc());
1900 if (D->getQualifierLoc() && !ToQLoc)
1901 return nullptr;
1902
Gabor Marton26f72a92018-07-12 09:42:05 +00001903 NamespaceAliasDecl *ToD;
1904 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
1905 Importer.Import(D->getNamespaceLoc()),
1906 Importer.Import(D->getAliasLoc()), ToII, ToQLoc,
1907 Importer.Import(D->getTargetNameLoc()),
1908 TargetDecl))
1909 return ToD;
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001910
1911 ToD->setLexicalDeclContext(LexicalDC);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00001912 LexicalDC->addDeclInternal(ToD);
1913
1914 return ToD;
1915}
1916
Richard Smithdda56e42011-04-15 14:24:37 +00001917Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001918 // Import the major distinguishing characteristics of this typedef.
1919 DeclContext *DC, *LexicalDC;
1920 DeclarationName Name;
1921 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00001922 NamedDecl *ToD;
1923 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00001924 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00001925 if (ToD)
1926 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00001927
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001928 // If this typedef is not in block scope, determine whether we've
1929 // seen a typedef with the same name (that we can merge with) or any
1930 // other entity by that name (which name lookup could conflict with).
1931 if (!DC->isFunctionOrMethod()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001932 SmallVector<NamedDecl *, 4> ConflictingDecls;
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001933 unsigned IDNS = Decl::IDNS_Ordinary;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001934 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00001935 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001936 for (auto *FoundDecl : FoundDecls) {
1937 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001938 continue;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001939 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
Douglas Gregorb4964f72010-02-15 23:54:17 +00001940 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(),
1941 FoundTypedef->getUnderlyingType()))
Gabor Marton26f72a92018-07-12 09:42:05 +00001942 return Importer.MapImported(D, FoundTypedef);
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001943 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00001944
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00001945 ConflictingDecls.push_back(FoundDecl);
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001946 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00001947
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001948 if (!ConflictingDecls.empty()) {
1949 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00001950 ConflictingDecls.data(),
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001951 ConflictingDecls.size());
1952 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00001953 return nullptr;
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001954 }
1955 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00001956
Douglas Gregorb4964f72010-02-15 23:54:17 +00001957 // Import the underlying type of this typedef;
1958 QualType T = Importer.Import(D->getUnderlyingType());
1959 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00001960 return nullptr;
1961
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001962 // Create the new typedef node.
1963 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Stephen Kellyf2ceec42018-08-09 21:08:08 +00001964 SourceLocation StartL = Importer.Import(D->getBeginLoc());
Gabor Marton26f72a92018-07-12 09:42:05 +00001965
Richard Smithdda56e42011-04-15 14:24:37 +00001966 TypedefNameDecl *ToTypedef;
Gabor Marton26f72a92018-07-12 09:42:05 +00001967 if (IsAlias) {
1968 if (GetImportedOrCreateDecl<TypeAliasDecl>(
1969 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1970 Name.getAsIdentifierInfo(), TInfo))
1971 return ToTypedef;
1972 } else if (GetImportedOrCreateDecl<TypedefDecl>(
1973 ToTypedef, D, Importer.getToContext(), DC, StartL, Loc,
1974 Name.getAsIdentifierInfo(), TInfo))
1975 return ToTypedef;
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00001976
Douglas Gregordd483172010-02-22 17:42:47 +00001977 ToTypedef->setAccess(D->getAccess());
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001978 ToTypedef->setLexicalDeclContext(LexicalDC);
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00001979
1980 // Templated declarations should not appear in DeclContext.
1981 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
1982 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
1983 LexicalDC->addDeclInternal(ToTypedef);
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00001984
Douglas Gregor5fa74c32010-02-10 21:10:29 +00001985 return ToTypedef;
1986}
1987
Richard Smithdda56e42011-04-15 14:24:37 +00001988Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
1989 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
1990}
1991
1992Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
1993 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
1994}
1995
Gabor Horvath7a91c082017-11-14 11:30:38 +00001996Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
1997 // Import the major distinguishing characteristics of this typedef.
1998 DeclContext *DC, *LexicalDC;
1999 DeclarationName Name;
2000 SourceLocation Loc;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002001 NamedDecl *FoundD;
2002 if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
Gabor Horvath7a91c082017-11-14 11:30:38 +00002003 return nullptr;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002004 if (FoundD)
2005 return FoundD;
Gabor Horvath7a91c082017-11-14 11:30:38 +00002006
2007 // If this typedef is not in block scope, determine whether we've
2008 // seen a typedef with the same name (that we can merge with) or any
2009 // other entity by that name (which name lookup could conflict with).
2010 if (!DC->isFunctionOrMethod()) {
2011 SmallVector<NamedDecl *, 4> ConflictingDecls;
2012 unsigned IDNS = Decl::IDNS_Ordinary;
2013 SmallVector<NamedDecl *, 2> FoundDecls;
2014 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002015 for (auto *FoundDecl : FoundDecls) {
2016 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Gabor Horvath7a91c082017-11-14 11:30:38 +00002017 continue;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002018 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
Gabor Marton26f72a92018-07-12 09:42:05 +00002019 return Importer.MapImported(D, FoundAlias);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002020 ConflictingDecls.push_back(FoundDecl);
Gabor Horvath7a91c082017-11-14 11:30:38 +00002021 }
2022
2023 if (!ConflictingDecls.empty()) {
2024 Name = Importer.HandleNameConflict(Name, DC, IDNS,
2025 ConflictingDecls.data(),
2026 ConflictingDecls.size());
2027 if (!Name)
2028 return nullptr;
2029 }
2030 }
2031
2032 TemplateParameterList *Params = ImportTemplateParameterList(
2033 D->getTemplateParameters());
2034 if (!Params)
2035 return nullptr;
2036
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002037 auto *TemplDecl = cast_or_null<TypeAliasDecl>(
Gabor Horvath7a91c082017-11-14 11:30:38 +00002038 Importer.Import(D->getTemplatedDecl()));
2039 if (!TemplDecl)
2040 return nullptr;
2041
Gabor Marton26f72a92018-07-12 09:42:05 +00002042 TypeAliasTemplateDecl *ToAlias;
2043 if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2044 Name, Params, TemplDecl))
2045 return ToAlias;
Gabor Horvath7a91c082017-11-14 11:30:38 +00002046
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002047 TemplDecl->setDescribedAliasTemplate(ToAlias);
2048
Gabor Horvath7a91c082017-11-14 11:30:38 +00002049 ToAlias->setAccess(D->getAccess());
2050 ToAlias->setLexicalDeclContext(LexicalDC);
Gabor Horvath7a91c082017-11-14 11:30:38 +00002051 LexicalDC->addDeclInternal(ToAlias);
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002052 return ToAlias;
Gabor Horvath7a91c082017-11-14 11:30:38 +00002053}
2054
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00002055Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2056 // Import the major distinguishing characteristics of this label.
2057 DeclContext *DC, *LexicalDC;
2058 DeclarationName Name;
2059 SourceLocation Loc;
2060 NamedDecl *ToD;
2061 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2062 return nullptr;
2063 if (ToD)
2064 return ToD;
2065
2066 assert(LexicalDC->isFunctionOrMethod());
2067
Gabor Marton26f72a92018-07-12 09:42:05 +00002068 LabelDecl *ToLabel;
2069 if (D->isGnuLocal()
2070 ? GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2071 Importer.Import(D->getLocation()),
2072 Name.getAsIdentifierInfo(),
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002073 Importer.Import(D->getBeginLoc()))
Gabor Marton26f72a92018-07-12 09:42:05 +00002074 : GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC,
2075 Importer.Import(D->getLocation()),
2076 Name.getAsIdentifierInfo()))
2077 return ToLabel;
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00002078
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002079 auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00002080 if (!Label)
2081 return nullptr;
2082
2083 ToLabel->setStmt(Label);
2084 ToLabel->setLexicalDeclContext(LexicalDC);
2085 LexicalDC->addDeclInternal(ToLabel);
2086 return ToLabel;
2087}
2088
Douglas Gregor98c10182010-02-12 22:17:39 +00002089Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2090 // Import the major distinguishing characteristics of this enum.
2091 DeclContext *DC, *LexicalDC;
2092 DeclarationName Name;
2093 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002094 NamedDecl *ToD;
2095 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002096 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002097 if (ToD)
2098 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00002099
Douglas Gregor98c10182010-02-12 22:17:39 +00002100 // Figure out what enum name we're looking for.
2101 unsigned IDNS = Decl::IDNS_Tag;
2102 DeclarationName SearchName = Name;
Richard Smithdda56e42011-04-15 14:24:37 +00002103 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2104 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
Douglas Gregor98c10182010-02-12 22:17:39 +00002105 IDNS = Decl::IDNS_Ordinary;
David Blaikiebbafb8a2012-03-11 07:00:24 +00002106 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
Douglas Gregor98c10182010-02-12 22:17:39 +00002107 IDNS |= Decl::IDNS_Ordinary;
Fangrui Song6907ce22018-07-30 19:24:48 +00002108
Douglas Gregor98c10182010-02-12 22:17:39 +00002109 // We may already have an enum of the same name; try to find and match it.
2110 if (!DC->isFunctionOrMethod() && SearchName) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002111 SmallVector<NamedDecl *, 4> ConflictingDecls;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002112 SmallVector<NamedDecl *, 2> FoundDecls;
Gabor Horvath5558ba22017-04-03 09:30:20 +00002113 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002114 for (auto *FoundDecl : FoundDecls) {
2115 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregor98c10182010-02-12 22:17:39 +00002116 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00002117
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002118 Decl *Found = FoundDecl;
2119 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2120 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
Douglas Gregor98c10182010-02-12 22:17:39 +00002121 Found = Tag->getDecl();
2122 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002123
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002124 if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) {
Douglas Gregor8cdbe642010-02-12 23:44:20 +00002125 if (IsStructuralMatch(D, FoundEnum))
Gabor Marton26f72a92018-07-12 09:42:05 +00002126 return Importer.MapImported(D, FoundEnum);
Douglas Gregor98c10182010-02-12 22:17:39 +00002127 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002128
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002129 ConflictingDecls.push_back(FoundDecl);
Douglas Gregor98c10182010-02-12 22:17:39 +00002130 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002131
Douglas Gregor98c10182010-02-12 22:17:39 +00002132 if (!ConflictingDecls.empty()) {
2133 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00002134 ConflictingDecls.data(),
Douglas Gregor98c10182010-02-12 22:17:39 +00002135 ConflictingDecls.size());
2136 }
2137 }
Gabor Marton26f72a92018-07-12 09:42:05 +00002138
Douglas Gregor98c10182010-02-12 22:17:39 +00002139 // Create the enum declaration.
Gabor Marton26f72a92018-07-12 09:42:05 +00002140 EnumDecl *D2;
2141 if (GetImportedOrCreateDecl(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002142 D2, D, Importer.getToContext(), DC, Importer.Import(D->getBeginLoc()),
Gabor Marton26f72a92018-07-12 09:42:05 +00002143 Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(),
2144 D->isScopedUsingClassTag(), D->isFixed()))
2145 return D2;
2146
John McCall3e11ebe2010-03-15 10:12:16 +00002147 // Import the qualifier, if any.
Douglas Gregor14454802011-02-25 02:25:35 +00002148 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Douglas Gregordd483172010-02-22 17:42:47 +00002149 D2->setAccess(D->getAccess());
Douglas Gregor3996e242010-02-15 22:01:00 +00002150 D2->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00002151 LexicalDC->addDeclInternal(D2);
Douglas Gregor98c10182010-02-12 22:17:39 +00002152
2153 // Import the integer type.
2154 QualType ToIntegerType = Importer.Import(D->getIntegerType());
2155 if (ToIntegerType.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002156 return nullptr;
Douglas Gregor3996e242010-02-15 22:01:00 +00002157 D2->setIntegerType(ToIntegerType);
Fangrui Song6907ce22018-07-30 19:24:48 +00002158
Douglas Gregor98c10182010-02-12 22:17:39 +00002159 // Import the definition
John McCallf937c022011-10-07 06:10:15 +00002160 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
Craig Topper36250ad2014-05-12 05:36:57 +00002161 return nullptr;
Douglas Gregor98c10182010-02-12 22:17:39 +00002162
Douglas Gregor3996e242010-02-15 22:01:00 +00002163 return D2;
Douglas Gregor98c10182010-02-12 22:17:39 +00002164}
2165
Douglas Gregor5c73e912010-02-11 00:48:18 +00002166Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
Balazs Keri0c23dc52018-08-13 13:08:37 +00002167 bool IsFriendTemplate = false;
2168 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2169 IsFriendTemplate =
2170 DCXX->getDescribedClassTemplate() &&
2171 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2172 Decl::FOK_None;
2173 }
2174
Douglas Gregor5c73e912010-02-11 00:48:18 +00002175 // If this record has a definition in the translation unit we're coming from,
2176 // but this particular declaration is not that definition, import the
2177 // definition and map to that.
Douglas Gregor0a5a2212010-02-11 01:04:33 +00002178 TagDecl *Definition = D->getDefinition();
Gabor Martona3af5672018-05-23 14:24:02 +00002179 if (Definition && Definition != D &&
Balazs Keri0c23dc52018-08-13 13:08:37 +00002180 // Friend template declaration must be imported on its own.
2181 !IsFriendTemplate &&
Gabor Martona3af5672018-05-23 14:24:02 +00002182 // In contrast to a normal CXXRecordDecl, the implicit
2183 // CXXRecordDecl of ClassTemplateSpecializationDecl is its redeclaration.
2184 // The definition of the implicit CXXRecordDecl in this case is the
2185 // ClassTemplateSpecializationDecl itself. Thus, we start with an extra
2186 // condition in order to be able to import the implict Decl.
2187 !D->isImplicit()) {
Douglas Gregor5c73e912010-02-11 00:48:18 +00002188 Decl *ImportedDef = Importer.Import(Definition);
Douglas Gregor8cdbe642010-02-12 23:44:20 +00002189 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00002190 return nullptr;
2191
Gabor Marton26f72a92018-07-12 09:42:05 +00002192 return Importer.MapImported(D, ImportedDef);
Douglas Gregor5c73e912010-02-11 00:48:18 +00002193 }
Gabor Martona3af5672018-05-23 14:24:02 +00002194
Douglas Gregor5c73e912010-02-11 00:48:18 +00002195 // Import the major distinguishing characteristics of this record.
2196 DeclContext *DC, *LexicalDC;
2197 DeclarationName Name;
2198 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002199 NamedDecl *ToD;
2200 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002201 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002202 if (ToD)
2203 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00002204
Douglas Gregor5c73e912010-02-11 00:48:18 +00002205 // Figure out what structure name we're looking for.
2206 unsigned IDNS = Decl::IDNS_Tag;
2207 DeclarationName SearchName = Name;
Richard Smithdda56e42011-04-15 14:24:37 +00002208 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2209 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName());
Douglas Gregor5c73e912010-02-11 00:48:18 +00002210 IDNS = Decl::IDNS_Ordinary;
David Blaikiebbafb8a2012-03-11 07:00:24 +00002211 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
Douglas Gregor5c73e912010-02-11 00:48:18 +00002212 IDNS |= Decl::IDNS_Ordinary;
2213
2214 // We may already have a record of the same name; try to find and match it.
Craig Topper36250ad2014-05-12 05:36:57 +00002215 RecordDecl *AdoptDecl = nullptr;
Sean Callanan9092d472017-05-13 00:46:33 +00002216 RecordDecl *PrevDecl = nullptr;
Douglas Gregordd6006f2012-07-17 21:16:27 +00002217 if (!DC->isFunctionOrMethod()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002218 SmallVector<NamedDecl *, 4> ConflictingDecls;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002219 SmallVector<NamedDecl *, 2> FoundDecls;
Gabor Horvath5558ba22017-04-03 09:30:20 +00002220 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls);
Sean Callanan9092d472017-05-13 00:46:33 +00002221
2222 if (!FoundDecls.empty()) {
2223 // We're going to have to compare D against potentially conflicting Decls, so complete it.
2224 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2225 D->getASTContext().getExternalSource()->CompleteType(D);
2226 }
2227
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002228 for (auto *FoundDecl : FoundDecls) {
2229 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregor5c73e912010-02-11 00:48:18 +00002230 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00002231
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002232 Decl *Found = FoundDecl;
2233 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2234 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
Douglas Gregor5c73e912010-02-11 00:48:18 +00002235 Found = Tag->getDecl();
2236 }
Gabor Martona0df7a92018-05-30 09:19:26 +00002237
2238 if (D->getDescribedTemplate()) {
2239 if (auto *Template = dyn_cast<ClassTemplateDecl>(Found))
2240 Found = Template->getTemplatedDecl();
2241 else
2242 continue;
2243 }
2244
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002245 if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
Aleksei Sidorin499de6c2018-04-05 15:31:49 +00002246 if (!SearchName) {
Gabor Marton0bebf952018-07-05 09:51:13 +00002247 if (!IsStructuralMatch(D, FoundRecord, false))
2248 continue;
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002249 }
2250
Sean Callanan9092d472017-05-13 00:46:33 +00002251 PrevDecl = FoundRecord;
2252
Douglas Gregor25791052010-02-12 00:09:27 +00002253 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) {
Balazs Keri0c23dc52018-08-13 13:08:37 +00002254 if ((SearchName && !D->isCompleteDefinition() && !IsFriendTemplate)
Douglas Gregordd6006f2012-07-17 21:16:27 +00002255 || (D->isCompleteDefinition() &&
2256 D->isAnonymousStructOrUnion()
2257 == FoundDef->isAnonymousStructOrUnion() &&
2258 IsStructuralMatch(D, FoundDef))) {
Douglas Gregor25791052010-02-12 00:09:27 +00002259 // The record types structurally match, or the "from" translation
2260 // unit only had a forward declaration anyway; call it the same
2261 // function.
Balazs Keri1d20cc22018-07-16 12:16:39 +00002262 // FIXME: Structural equivalence check should check for same
2263 // user-defined methods.
2264 Importer.MapImported(D, FoundDef);
2265 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2266 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2267 assert(FoundCXX && "Record type mismatch");
2268
2269 if (D->isCompleteDefinition() && !Importer.isMinimalImport())
2270 // FoundDef may not have every implicit method that D has
2271 // because implicit methods are created only if they are used.
2272 ImportImplicitMethods(DCXX, FoundCXX);
2273 }
2274 return FoundDef;
Douglas Gregor25791052010-02-12 00:09:27 +00002275 }
Douglas Gregordd6006f2012-07-17 21:16:27 +00002276 } else if (!D->isCompleteDefinition()) {
Douglas Gregor25791052010-02-12 00:09:27 +00002277 // We have a forward declaration of this type, so adopt that forward
2278 // declaration rather than building a new one.
Fangrui Song6907ce22018-07-30 19:24:48 +00002279
Sean Callananc94711c2014-03-04 18:11:50 +00002280 // If one or both can be completed from external storage then try one
2281 // last time to complete and compare them before doing this.
Fangrui Song6907ce22018-07-30 19:24:48 +00002282
Sean Callananc94711c2014-03-04 18:11:50 +00002283 if (FoundRecord->hasExternalLexicalStorage() &&
2284 !FoundRecord->isCompleteDefinition())
2285 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord);
2286 if (D->hasExternalLexicalStorage())
2287 D->getASTContext().getExternalSource()->CompleteType(D);
Fangrui Song6907ce22018-07-30 19:24:48 +00002288
Sean Callananc94711c2014-03-04 18:11:50 +00002289 if (FoundRecord->isCompleteDefinition() &&
2290 D->isCompleteDefinition() &&
2291 !IsStructuralMatch(D, FoundRecord))
2292 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00002293
Balazs Keri0c23dc52018-08-13 13:08:37 +00002294 if (IsFriendTemplate)
2295 continue;
2296
Douglas Gregor25791052010-02-12 00:09:27 +00002297 AdoptDecl = FoundRecord;
2298 continue;
Douglas Gregordd6006f2012-07-17 21:16:27 +00002299 } else if (!SearchName) {
2300 continue;
2301 }
Douglas Gregor5c73e912010-02-11 00:48:18 +00002302 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002303
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002304 ConflictingDecls.push_back(FoundDecl);
Douglas Gregor5c73e912010-02-11 00:48:18 +00002305 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002306
Douglas Gregordd6006f2012-07-17 21:16:27 +00002307 if (!ConflictingDecls.empty() && SearchName) {
Douglas Gregor5c73e912010-02-11 00:48:18 +00002308 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00002309 ConflictingDecls.data(),
Douglas Gregor5c73e912010-02-11 00:48:18 +00002310 ConflictingDecls.size());
2311 }
2312 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002313
Douglas Gregor5c73e912010-02-11 00:48:18 +00002314 // Create the record declaration.
Douglas Gregor3996e242010-02-15 22:01:00 +00002315 RecordDecl *D2 = AdoptDecl;
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002316 SourceLocation StartLoc = Importer.Import(D->getBeginLoc());
Douglas Gregor3996e242010-02-15 22:01:00 +00002317 if (!D2) {
Sean Callanan8bca9962016-03-28 21:43:01 +00002318 CXXRecordDecl *D2CXX = nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002319 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
Sean Callanan8bca9962016-03-28 21:43:01 +00002320 if (DCXX->isLambda()) {
2321 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo());
Gabor Marton26f72a92018-07-12 09:42:05 +00002322 if (GetImportedOrCreateSpecialDecl(
2323 D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2324 DC, TInfo, Loc, DCXX->isDependentLambda(),
2325 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2326 return D2CXX;
Sean Callanan8bca9962016-03-28 21:43:01 +00002327 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl());
2328 if (DCXX->getLambdaContextDecl() && !CDecl)
2329 return nullptr;
Sean Callanan041cceb2016-05-14 05:43:57 +00002330 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl);
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002331 } else if (DCXX->isInjectedClassName()) {
2332 // We have to be careful to do a similar dance to the one in
2333 // Sema::ActOnStartCXXMemberDeclarations
2334 CXXRecordDecl *const PrevDecl = nullptr;
2335 const bool DelayTypeCreation = true;
Gabor Marton26f72a92018-07-12 09:42:05 +00002336 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2337 D->getTagKind(), DC, StartLoc, Loc,
2338 Name.getAsIdentifierInfo(), PrevDecl,
2339 DelayTypeCreation))
2340 return D2CXX;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002341 Importer.getToContext().getTypeDeclType(
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002342 D2CXX, dyn_cast<CXXRecordDecl>(DC));
Sean Callanan8bca9962016-03-28 21:43:01 +00002343 } else {
Gabor Marton26f72a92018-07-12 09:42:05 +00002344 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2345 D->getTagKind(), DC, StartLoc, Loc,
2346 Name.getAsIdentifierInfo(),
2347 cast_or_null<CXXRecordDecl>(PrevDecl)))
2348 return D2CXX;
Sean Callanan8bca9962016-03-28 21:43:01 +00002349 }
Gabor Marton26f72a92018-07-12 09:42:05 +00002350
Douglas Gregor3996e242010-02-15 22:01:00 +00002351 D2 = D2CXX;
Douglas Gregordd483172010-02-22 17:42:47 +00002352 D2->setAccess(D->getAccess());
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002353 D2->setLexicalDeclContext(LexicalDC);
Gabor Martonde8bf262018-05-17 09:46:07 +00002354 if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit())
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002355 LexicalDC->addDeclInternal(D2);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00002356
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00002357 if (ClassTemplateDecl *FromDescribed =
2358 DCXX->getDescribedClassTemplate()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002359 auto *ToDescribed = cast_or_null<ClassTemplateDecl>(
2360 Importer.Import(FromDescribed));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00002361 if (!ToDescribed)
2362 return nullptr;
2363 D2CXX->setDescribedClassTemplate(ToDescribed);
Balazs Keri0c23dc52018-08-13 13:08:37 +00002364 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
Gabor Marton5915777e2018-06-26 13:44:24 +00002365 // In a record describing a template the type should be an
2366 // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2367 // previously set type to the correct value here (ToDescribed is not
2368 // available at record create).
2369 // FIXME: The previous type is cleared but not removed from
2370 // ASTContext's internal storage.
2371 CXXRecordDecl *Injected = nullptr;
2372 for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2373 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2374 if (Record && Record->isInjectedClassName()) {
2375 Injected = Record;
2376 break;
2377 }
2378 }
2379 D2CXX->setTypeForDecl(nullptr);
2380 Importer.getToContext().getInjectedClassNameType(D2CXX,
2381 ToDescribed->getInjectedClassNameSpecialization());
2382 if (Injected) {
2383 Injected->setTypeForDecl(nullptr);
2384 Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2385 }
2386 }
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00002387 } else if (MemberSpecializationInfo *MemberInfo =
2388 DCXX->getMemberSpecializationInfo()) {
2389 TemplateSpecializationKind SK =
2390 MemberInfo->getTemplateSpecializationKind();
2391 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002392 auto *ToInst =
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00002393 cast_or_null<CXXRecordDecl>(Importer.Import(FromInst));
2394 if (FromInst && !ToInst)
2395 return nullptr;
2396 D2CXX->setInstantiationOfMemberClass(ToInst, SK);
2397 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
2398 Importer.Import(MemberInfo->getPointOfInstantiation()));
2399 }
Douglas Gregor25791052010-02-12 00:09:27 +00002400 } else {
Gabor Marton26f72a92018-07-12 09:42:05 +00002401 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2402 D->getTagKind(), DC, StartLoc, Loc,
2403 Name.getAsIdentifierInfo(), PrevDecl))
2404 return D2;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002405 D2->setLexicalDeclContext(LexicalDC);
2406 LexicalDC->addDeclInternal(D2);
Douglas Gregor5c73e912010-02-11 00:48:18 +00002407 }
Gabor Marton26f72a92018-07-12 09:42:05 +00002408
Douglas Gregor14454802011-02-25 02:25:35 +00002409 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Douglas Gregordd6006f2012-07-17 21:16:27 +00002410 if (D->isAnonymousStructOrUnion())
2411 D2->setAnonymousStructOrUnion(true);
Douglas Gregor5c73e912010-02-11 00:48:18 +00002412 }
Gabor Marton26f72a92018-07-12 09:42:05 +00002413
2414 Importer.MapImported(D, D2);
Douglas Gregor25791052010-02-12 00:09:27 +00002415
Douglas Gregor95d82832012-01-24 18:36:04 +00002416 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default))
Craig Topper36250ad2014-05-12 05:36:57 +00002417 return nullptr;
2418
Douglas Gregor3996e242010-02-15 22:01:00 +00002419 return D2;
Douglas Gregor5c73e912010-02-11 00:48:18 +00002420}
2421
Douglas Gregor98c10182010-02-12 22:17:39 +00002422Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2423 // Import the major distinguishing characteristics of this enumerator.
2424 DeclContext *DC, *LexicalDC;
2425 DeclarationName Name;
2426 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002427 NamedDecl *ToD;
2428 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002429 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002430 if (ToD)
2431 return ToD;
Douglas Gregorb4964f72010-02-15 23:54:17 +00002432
2433 QualType T = Importer.Import(D->getType());
2434 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002435 return nullptr;
Douglas Gregorb4964f72010-02-15 23:54:17 +00002436
Fangrui Song6907ce22018-07-30 19:24:48 +00002437 // Determine whether there are any other declarations with the same name and
Douglas Gregor98c10182010-02-12 22:17:39 +00002438 // in the same context.
2439 if (!LexicalDC->isFunctionOrMethod()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002440 SmallVector<NamedDecl *, 4> ConflictingDecls;
Douglas Gregor98c10182010-02-12 22:17:39 +00002441 unsigned IDNS = Decl::IDNS_Ordinary;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002442 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00002443 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002444 for (auto *FoundDecl : FoundDecls) {
2445 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregor98c10182010-02-12 22:17:39 +00002446 continue;
Douglas Gregor91155082012-11-14 22:29:20 +00002447
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002448 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
Douglas Gregor91155082012-11-14 22:29:20 +00002449 if (IsStructuralMatch(D, FoundEnumConstant))
Gabor Marton26f72a92018-07-12 09:42:05 +00002450 return Importer.MapImported(D, FoundEnumConstant);
Douglas Gregor91155082012-11-14 22:29:20 +00002451 }
2452
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002453 ConflictingDecls.push_back(FoundDecl);
Douglas Gregor98c10182010-02-12 22:17:39 +00002454 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002455
Douglas Gregor98c10182010-02-12 22:17:39 +00002456 if (!ConflictingDecls.empty()) {
2457 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00002458 ConflictingDecls.data(),
Douglas Gregor98c10182010-02-12 22:17:39 +00002459 ConflictingDecls.size());
2460 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00002461 return nullptr;
Douglas Gregor98c10182010-02-12 22:17:39 +00002462 }
2463 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002464
Douglas Gregor98c10182010-02-12 22:17:39 +00002465 Expr *Init = Importer.Import(D->getInitExpr());
2466 if (D->getInitExpr() && !Init)
Craig Topper36250ad2014-05-12 05:36:57 +00002467 return nullptr;
2468
Gabor Marton26f72a92018-07-12 09:42:05 +00002469 EnumConstantDecl *ToEnumerator;
2470 if (GetImportedOrCreateDecl(
2471 ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
2472 Name.getAsIdentifierInfo(), T, Init, D->getInitVal()))
2473 return ToEnumerator;
2474
Douglas Gregordd483172010-02-22 17:42:47 +00002475 ToEnumerator->setAccess(D->getAccess());
Douglas Gregor98c10182010-02-12 22:17:39 +00002476 ToEnumerator->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00002477 LexicalDC->addDeclInternal(ToEnumerator);
Douglas Gregor98c10182010-02-12 22:17:39 +00002478 return ToEnumerator;
2479}
Douglas Gregor5c73e912010-02-11 00:48:18 +00002480
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002481bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
2482 FunctionDecl *ToFD) {
2483 switch (FromFD->getTemplatedKind()) {
2484 case FunctionDecl::TK_NonTemplate:
2485 case FunctionDecl::TK_FunctionTemplate:
Sam McCallfdc32072018-01-26 12:06:44 +00002486 return false;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002487
2488 case FunctionDecl::TK_MemberSpecialization: {
2489 auto *InstFD = cast_or_null<FunctionDecl>(
2490 Importer.Import(FromFD->getInstantiatedFromMemberFunction()));
2491 if (!InstFD)
2492 return true;
2493
2494 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
2495 SourceLocation POI = Importer.Import(
2496 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation());
2497 ToFD->setInstantiationOfMemberFunction(InstFD, TSK);
2498 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
Sam McCallfdc32072018-01-26 12:06:44 +00002499 return false;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002500 }
2501
2502 case FunctionDecl::TK_FunctionTemplateSpecialization: {
Gabor Marton5254e642018-06-27 13:32:50 +00002503 FunctionTemplateDecl* Template;
2504 OptionalTemplateArgsTy ToTemplArgs;
2505 std::tie(Template, ToTemplArgs) =
2506 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2507 if (!Template || !ToTemplArgs)
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002508 return true;
2509
2510 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
Gabor Marton5254e642018-06-27 13:32:50 +00002511 Importer.getToContext(), *ToTemplArgs);
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002512
Gabor Marton5254e642018-06-27 13:32:50 +00002513 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002514 TemplateArgumentListInfo ToTAInfo;
2515 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00002516 if (FromTAArgsAsWritten)
2517 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002518 return true;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002519
2520 SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation());
2521
Gabor Marton5254e642018-06-27 13:32:50 +00002522 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002523 ToFD->setFunctionTemplateSpecialization(
2524 Template, ToTAList, /* InsertPos= */ nullptr,
2525 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI);
Sam McCallfdc32072018-01-26 12:06:44 +00002526 return false;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002527 }
2528
2529 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
2530 auto *FromInfo = FromFD->getDependentSpecializationInfo();
2531 UnresolvedSet<8> TemplDecls;
2532 unsigned NumTemplates = FromInfo->getNumTemplates();
2533 for (unsigned I = 0; I < NumTemplates; I++) {
2534 if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>(
2535 Importer.Import(FromInfo->getTemplate(I))))
2536 TemplDecls.addDecl(ToFTD);
2537 else
2538 return true;
2539 }
2540
2541 // Import TemplateArgumentListInfo.
2542 TemplateArgumentListInfo ToTAInfo;
2543 if (ImportTemplateArgumentListInfo(
2544 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
2545 llvm::makeArrayRef(FromInfo->getTemplateArgs(),
2546 FromInfo->getNumTemplateArgs()),
2547 ToTAInfo))
2548 return true;
2549
2550 ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
2551 TemplDecls, ToTAInfo);
Sam McCallfdc32072018-01-26 12:06:44 +00002552 return false;
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002553 }
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002554 }
Sam McCallfdc32072018-01-26 12:06:44 +00002555 llvm_unreachable("All cases should be covered!");
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002556}
2557
Gabor Marton5254e642018-06-27 13:32:50 +00002558FunctionDecl *
2559ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
2560 FunctionTemplateDecl* Template;
2561 OptionalTemplateArgsTy ToTemplArgs;
2562 std::tie(Template, ToTemplArgs) =
2563 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
2564 if (!Template || !ToTemplArgs)
2565 return nullptr;
2566
2567 void *InsertPos = nullptr;
2568 auto *FoundSpec = Template->findSpecialization(*ToTemplArgs, InsertPos);
2569 return FoundSpec;
2570}
2571
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002572Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
Gabor Marton5254e642018-06-27 13:32:50 +00002573
2574 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
2575 auto RedeclIt = Redecls.begin();
2576 // Import the first part of the decl chain. I.e. import all previous
2577 // declarations starting from the canonical decl.
2578 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt)
2579 if (!Importer.Import(*RedeclIt))
2580 return nullptr;
2581 assert(*RedeclIt == D);
2582
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002583 // Import the major distinguishing characteristics of this function.
2584 DeclContext *DC, *LexicalDC;
2585 DeclarationName Name;
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002586 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002587 NamedDecl *ToD;
2588 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002589 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002590 if (ToD)
2591 return ToD;
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002592
Gabor Marton5254e642018-06-27 13:32:50 +00002593 const FunctionDecl *FoundByLookup = nullptr;
Balazs Keria35798d2018-07-17 09:52:41 +00002594 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
Gabor Horvathe350b0a2017-09-22 11:11:01 +00002595
Gabor Marton5254e642018-06-27 13:32:50 +00002596 // If this is a function template specialization, then try to find the same
2597 // existing specialization in the "to" context. The localUncachedLookup
2598 // below will not find any specialization, but would find the primary
2599 // template; thus, we have to skip normal lookup in case of specializations.
2600 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
2601 if (D->getTemplatedKind() ==
2602 FunctionDecl::TK_FunctionTemplateSpecialization) {
2603 if (FunctionDecl *FoundFunction = FindFunctionTemplateSpecialization(D)) {
2604 if (D->doesThisDeclarationHaveABody() &&
2605 FoundFunction->hasBody())
2606 return Importer.Imported(D, FoundFunction);
2607 FoundByLookup = FoundFunction;
2608 }
2609 }
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002610 // Try to find a function in our own ("to") context with the same name, same
2611 // type, and in the same context as the function we're importing.
Gabor Marton5254e642018-06-27 13:32:50 +00002612 else if (!LexicalDC->isFunctionOrMethod()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002613 SmallVector<NamedDecl *, 4> ConflictingDecls;
Gabor Marton5254e642018-06-27 13:32:50 +00002614 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002615 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00002616 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002617 for (auto *FoundDecl : FoundDecls) {
2618 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002619 continue;
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002620
Balazs Keria35798d2018-07-17 09:52:41 +00002621 // If template was found, look at the templated function.
2622 if (FromFT) {
2623 if (auto *Template = dyn_cast<FunctionTemplateDecl>(FoundDecl))
2624 FoundDecl = Template->getTemplatedDecl();
2625 else
2626 continue;
2627 }
2628
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002629 if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
Rafael Espindola3ae00052013-05-13 00:12:11 +00002630 if (FoundFunction->hasExternalFormalLinkage() &&
2631 D->hasExternalFormalLinkage()) {
Balazs Keric7797c42018-07-11 09:37:24 +00002632 if (IsStructuralMatch(D, FoundFunction)) {
2633 const FunctionDecl *Definition = nullptr;
2634 if (D->doesThisDeclarationHaveABody() &&
2635 FoundFunction->hasBody(Definition)) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002636 return Importer.MapImported(
Balazs Keric7797c42018-07-11 09:37:24 +00002637 D, const_cast<FunctionDecl *>(Definition));
2638 }
2639 FoundByLookup = FoundFunction;
2640 break;
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002641 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002642
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002643 // FIXME: Check for overloading more carefully, e.g., by boosting
2644 // Sema::IsOverload out to the AST library.
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002645
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002646 // Function overloading is okay in C++.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002647 if (Importer.getToContext().getLangOpts().CPlusPlus)
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002648 continue;
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002649
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002650 // Complain about inconsistent function types.
2651 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent)
Douglas Gregorb4964f72010-02-15 23:54:17 +00002652 << Name << D->getType() << FoundFunction->getType();
Fangrui Song6907ce22018-07-30 19:24:48 +00002653 Importer.ToDiag(FoundFunction->getLocation(),
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002654 diag::note_odr_value_here)
2655 << FoundFunction->getType();
2656 }
2657 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002658
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002659 ConflictingDecls.push_back(FoundDecl);
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002660 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002661
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002662 if (!ConflictingDecls.empty()) {
2663 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00002664 ConflictingDecls.data(),
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002665 ConflictingDecls.size());
2666 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00002667 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00002668 }
Douglas Gregor62d311f2010-02-09 19:21:46 +00002669 }
Douglas Gregorb4964f72010-02-15 23:54:17 +00002670
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002671 DeclarationNameInfo NameInfo(Name, Loc);
2672 // Import additional name location/type info.
2673 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
2674
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002675 QualType FromTy = D->getType();
2676 bool usedDifferentExceptionSpec = false;
2677
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002678 if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) {
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002679 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
2680 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
2681 // FunctionDecl that we are importing the FunctionProtoType for.
2682 // To avoid an infinite recursion when importing, create the FunctionDecl
2683 // with a simplified function type and update it afterwards.
Richard Smith8acb4282014-07-31 21:57:55 +00002684 if (FromEPI.ExceptionSpec.SourceDecl ||
2685 FromEPI.ExceptionSpec.SourceTemplate ||
2686 FromEPI.ExceptionSpec.NoexceptExpr) {
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002687 FunctionProtoType::ExtProtoInfo DefaultEPI;
2688 FromTy = Importer.getFromContext().getFunctionType(
Alp Toker314cc812014-01-25 16:55:45 +00002689 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI);
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002690 usedDifferentExceptionSpec = true;
2691 }
2692 }
2693
Douglas Gregorb4964f72010-02-15 23:54:17 +00002694 // Import the type.
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002695 QualType T = Importer.Import(FromTy);
Douglas Gregorb4964f72010-02-15 23:54:17 +00002696 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002697 return nullptr;
2698
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002699 // Import the function parameters.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002700 SmallVector<ParmVarDecl *, 8> Parameters;
David Majnemer59f77922016-06-24 04:05:48 +00002701 for (auto P : D->parameters()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002702 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P));
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002703 if (!ToP)
Craig Topper36250ad2014-05-12 05:36:57 +00002704 return nullptr;
2705
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002706 Parameters.push_back(ToP);
2707 }
Fangrui Song6907ce22018-07-30 19:24:48 +00002708
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002709 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002710 if (D->getTypeSourceInfo() && !TInfo)
2711 return nullptr;
2712
2713 // Create the imported function.
Craig Topper36250ad2014-05-12 05:36:57 +00002714 FunctionDecl *ToFunction = nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002715 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart());
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002716 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002717 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
2718 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2719 InnerLocStart, NameInfo, T, TInfo, FromConstructor->isExplicit(),
2720 D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
2721 return ToFunction;
Sean Callanandd2c1742016-05-16 20:48:03 +00002722 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
2723 SmallVector<CXXCtorInitializer *, 4> CtorInitializers;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002724 for (auto *I : FromConstructor->inits()) {
2725 auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I));
Sean Callanandd2c1742016-05-16 20:48:03 +00002726 if (!ToI && I)
2727 return nullptr;
2728 CtorInitializers.push_back(ToI);
2729 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002730 auto **Memory =
Sean Callanandd2c1742016-05-16 20:48:03 +00002731 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
2732 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002733 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
Sean Callanandd2c1742016-05-16 20:48:03 +00002734 ToCtor->setCtorInitializers(Memory);
2735 ToCtor->setNumCtorInitializers(NumInitializers);
2736 }
Douglas Gregor00eace12010-02-21 18:29:16 +00002737 } else if (isa<CXXDestructorDecl>(D)) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002738 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
2739 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2740 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2741 D->isImplicit()))
2742 return ToFunction;
2743 } else if (CXXConversionDecl *FromConversion =
2744 dyn_cast<CXXConversionDecl>(D)) {
2745 if (GetImportedOrCreateDecl<CXXConversionDecl>(
2746 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2747 InnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
2748 FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
2749 return ToFunction;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002750 } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002751 if (GetImportedOrCreateDecl<CXXMethodDecl>(
2752 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
2753 InnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
2754 Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
2755 return ToFunction;
Douglas Gregor00eace12010-02-21 18:29:16 +00002756 } else {
Gabor Marton26f72a92018-07-12 09:42:05 +00002757 if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
2758 InnerLocStart, NameInfo, T, TInfo,
2759 D->getStorageClass(), D->isInlineSpecified(),
2760 D->hasWrittenPrototype(), D->isConstexpr()))
2761 return ToFunction;
Douglas Gregor00eace12010-02-21 18:29:16 +00002762 }
John McCall3e11ebe2010-03-15 10:12:16 +00002763
2764 // Import the qualifier, if any.
Douglas Gregor14454802011-02-25 02:25:35 +00002765 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Douglas Gregordd483172010-02-22 17:42:47 +00002766 ToFunction->setAccess(D->getAccess());
Douglas Gregor43f54792010-02-17 02:12:47 +00002767 ToFunction->setLexicalDeclContext(LexicalDC);
John McCall08432c82011-01-27 02:37:01 +00002768 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
2769 ToFunction->setTrivial(D->isTrivial());
2770 ToFunction->setPure(D->isPure());
Stephen Kelly1c301dc2018-08-09 21:09:38 +00002771 ToFunction->setRangeEnd(Importer.Import(D->getEndLoc()));
Douglas Gregor62d311f2010-02-09 19:21:46 +00002772
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002773 // Set the parameters.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002774 for (auto *Param : Parameters) {
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002775 Param->setOwningFunction(ToFunction);
2776 ToFunction->addDeclInternal(Param);
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002777 }
David Blaikie9c70e042011-09-21 18:16:56 +00002778 ToFunction->setParams(Parameters);
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002779
Gabor Marton5254e642018-06-27 13:32:50 +00002780 if (FoundByLookup) {
Gabor Horvathe350b0a2017-09-22 11:11:01 +00002781 auto *Recent = const_cast<FunctionDecl *>(
Gabor Marton5254e642018-06-27 13:32:50 +00002782 FoundByLookup->getMostRecentDecl());
Gabor Horvathe350b0a2017-09-22 11:11:01 +00002783 ToFunction->setPreviousDecl(Recent);
2784 }
2785
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002786 // We need to complete creation of FunctionProtoTypeLoc manually with setting
2787 // params it refers to.
2788 if (TInfo) {
2789 if (auto ProtoLoc =
2790 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
2791 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
2792 ProtoLoc.setParam(I, Parameters[I]);
2793 }
2794 }
2795
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002796 if (usedDifferentExceptionSpec) {
2797 // Update FunctionProtoType::ExtProtoInfo.
2798 QualType T = Importer.Import(D->getType());
2799 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002800 return nullptr;
Argyrios Kyrtzidis2f458532012-09-25 19:26:39 +00002801 ToFunction->setType(T);
Argyrios Kyrtzidisb41791d2012-09-22 01:58:06 +00002802 }
2803
Balazs Keria35798d2018-07-17 09:52:41 +00002804 // Import the describing template function, if any.
2805 if (FromFT)
2806 if (!Importer.Import(FromFT))
2807 return nullptr;
2808
Gabor Marton5254e642018-06-27 13:32:50 +00002809 if (D->doesThisDeclarationHaveABody()) {
2810 if (Stmt *FromBody = D->getBody()) {
2811 if (Stmt *ToBody = Importer.Import(FromBody)) {
2812 ToFunction->setBody(ToBody);
2813 }
Sean Callanan59721b32015-04-28 18:41:46 +00002814 }
2815 }
2816
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002817 // FIXME: Other bits to merge?
Douglas Gregor0eaa2bf2010-10-01 23:55:07 +00002818
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002819 // If it is a template, import all related things.
2820 if (ImportTemplateInformation(D, ToFunction))
2821 return nullptr;
2822
Gabor Marton5254e642018-06-27 13:32:50 +00002823 bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend);
2824
2825 // TODO Can we generalize this approach to other AST nodes as well?
2826 if (D->getDeclContext()->containsDeclAndLoad(D))
2827 DC->addDeclInternal(ToFunction);
2828 if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D))
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00002829 LexicalDC->addDeclInternal(ToFunction);
Douglas Gregor0eaa2bf2010-10-01 23:55:07 +00002830
Gabor Marton5254e642018-06-27 13:32:50 +00002831 // Friend declaration's lexical context is the befriending class, but the
2832 // semantic context is the enclosing scope of the befriending class.
2833 // We want the friend functions to be found in the semantic context by lookup.
2834 // FIXME should we handle this generically in VisitFriendDecl?
2835 // In Other cases when LexicalDC != DC we don't want it to be added,
2836 // e.g out-of-class definitions like void B::f() {} .
2837 if (LexicalDC != DC && IsFriend) {
2838 DC->makeDeclVisibleInContext(ToFunction);
2839 }
2840
2841 // Import the rest of the chain. I.e. import all subsequent declarations.
2842 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt)
2843 if (!Importer.Import(*RedeclIt))
2844 return nullptr;
2845
Lang Hames19e07e12017-06-20 21:06:00 +00002846 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
2847 ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod);
2848
Douglas Gregor43f54792010-02-17 02:12:47 +00002849 return ToFunction;
Douglas Gregorbb7930c2010-02-10 19:54:31 +00002850}
2851
Douglas Gregor00eace12010-02-21 18:29:16 +00002852Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
2853 return VisitFunctionDecl(D);
2854}
2855
2856Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
2857 return VisitCXXMethodDecl(D);
2858}
2859
2860Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
2861 return VisitCXXMethodDecl(D);
2862}
2863
2864Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
2865 return VisitCXXMethodDecl(D);
2866}
2867
Douglas Gregor5c73e912010-02-11 00:48:18 +00002868Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
2869 // Import the major distinguishing characteristics of a variable.
2870 DeclContext *DC, *LexicalDC;
2871 DeclarationName Name;
Douglas Gregor5c73e912010-02-11 00:48:18 +00002872 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002873 NamedDecl *ToD;
2874 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002875 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002876 if (ToD)
2877 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00002878
Fangrui Song6907ce22018-07-30 19:24:48 +00002879 // Determine whether we've already imported this field.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002880 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00002881 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002882 for (auto *FoundDecl : FoundDecls) {
2883 if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002884 // For anonymous fields, match up by index.
Balazs Keri2544b4b2018-08-08 09:40:57 +00002885 if (!Name &&
2886 ASTImporter::getFieldIndex(D) !=
2887 ASTImporter::getFieldIndex(FoundField))
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002888 continue;
2889
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002890 if (Importer.IsStructurallyEquivalent(D->getType(),
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002891 FoundField->getType())) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002892 Importer.MapImported(D, FoundField);
Gabor Marton42e15de2018-08-22 11:52:14 +00002893 // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
2894 // initializer of a FieldDecl might not had been instantiated in the
2895 // "To" context. However, the "From" context might instantiated that,
2896 // thus we have to merge that.
2897 if (Expr *FromInitializer = D->getInClassInitializer()) {
2898 // We don't have yet the initializer set.
2899 if (FoundField->hasInClassInitializer() &&
2900 !FoundField->getInClassInitializer()) {
2901 Expr *ToInitializer = Importer.Import(FromInitializer);
2902 if (!ToInitializer)
2903 // We can't return a nullptr here,
2904 // since we already mapped D as imported.
2905 return FoundField;
2906 FoundField->setInClassInitializer(ToInitializer);
2907 }
2908 }
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002909 return FoundField;
2910 }
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002911
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002912 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2913 << Name << D->getType() << FoundField->getType();
2914 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2915 << FoundField->getType();
Craig Topper36250ad2014-05-12 05:36:57 +00002916 return nullptr;
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002917 }
2918 }
2919
Douglas Gregorb4964f72010-02-15 23:54:17 +00002920 // Import the type.
2921 QualType T = Importer.Import(D->getType());
2922 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002923 return nullptr;
2924
Douglas Gregor5c73e912010-02-11 00:48:18 +00002925 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
2926 Expr *BitWidth = Importer.Import(D->getBitWidth());
2927 if (!BitWidth && D->getBitWidth())
Craig Topper36250ad2014-05-12 05:36:57 +00002928 return nullptr;
2929
Gabor Marton26f72a92018-07-12 09:42:05 +00002930 FieldDecl *ToField;
2931 if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
2932 Importer.Import(D->getInnerLocStart()), Loc,
2933 Name.getAsIdentifierInfo(), T, TInfo, BitWidth,
2934 D->isMutable(), D->getInClassInitStyle()))
2935 return ToField;
2936
Douglas Gregordd483172010-02-22 17:42:47 +00002937 ToField->setAccess(D->getAccess());
Douglas Gregor5c73e912010-02-11 00:48:18 +00002938 ToField->setLexicalDeclContext(LexicalDC);
Sean Callanan3a83ea72016-03-03 02:22:05 +00002939 if (Expr *FromInitializer = D->getInClassInitializer()) {
Sean Callananbb33f582016-03-03 01:21:28 +00002940 Expr *ToInitializer = Importer.Import(FromInitializer);
2941 if (ToInitializer)
2942 ToField->setInClassInitializer(ToInitializer);
2943 else
2944 return nullptr;
2945 }
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002946 ToField->setImplicit(D->isImplicit());
Sean Callanan95e74be2011-10-21 02:57:43 +00002947 LexicalDC->addDeclInternal(ToField);
Douglas Gregor5c73e912010-02-11 00:48:18 +00002948 return ToField;
2949}
2950
Francois Pichet783dd6e2010-11-21 06:08:52 +00002951Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
2952 // Import the major distinguishing characteristics of a variable.
2953 DeclContext *DC, *LexicalDC;
2954 DeclarationName Name;
2955 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00002956 NamedDecl *ToD;
2957 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00002958 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00002959 if (ToD)
2960 return ToD;
Francois Pichet783dd6e2010-11-21 06:08:52 +00002961
Fangrui Song6907ce22018-07-30 19:24:48 +00002962 // Determine whether we've already imported this field.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002963 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00002964 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Douglas Gregor9e0a5b32011-10-15 00:10:27 +00002965 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002966 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002967 // For anonymous indirect fields, match up by index.
Balazs Keri2544b4b2018-08-08 09:40:57 +00002968 if (!Name &&
2969 ASTImporter::getFieldIndex(D) !=
2970 ASTImporter::getFieldIndex(FoundField))
Douglas Gregorceb32bf2012-10-26 16:45:11 +00002971 continue;
2972
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00002973 if (Importer.IsStructurallyEquivalent(D->getType(),
Douglas Gregordd6006f2012-07-17 21:16:27 +00002974 FoundField->getType(),
David Blaikie7d170102013-05-15 07:37:26 +00002975 !Name.isEmpty())) {
Gabor Marton26f72a92018-07-12 09:42:05 +00002976 Importer.MapImported(D, FoundField);
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002977 return FoundField;
2978 }
Douglas Gregordd6006f2012-07-17 21:16:27 +00002979
2980 // If there are more anonymous fields to check, continue.
2981 if (!Name && I < N-1)
2982 continue;
2983
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002984 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent)
2985 << Name << D->getType() << FoundField->getType();
2986 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
2987 << FoundField->getType();
Craig Topper36250ad2014-05-12 05:36:57 +00002988 return nullptr;
Douglas Gregor03d1ed32011-10-14 21:54:42 +00002989 }
2990 }
2991
Francois Pichet783dd6e2010-11-21 06:08:52 +00002992 // Import the type.
2993 QualType T = Importer.Import(D->getType());
2994 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00002995 return nullptr;
Francois Pichet783dd6e2010-11-21 06:08:52 +00002996
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00002997 auto **NamedChain =
2998 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
Francois Pichet783dd6e2010-11-21 06:08:52 +00002999
3000 unsigned i = 0;
Aaron Ballman29c94602014-03-07 18:36:15 +00003001 for (auto *PI : D->chain()) {
Aaron Ballman13916082014-03-07 18:11:58 +00003002 Decl *D = Importer.Import(PI);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003003 if (!D)
Craig Topper36250ad2014-05-12 05:36:57 +00003004 return nullptr;
Francois Pichet783dd6e2010-11-21 06:08:52 +00003005 NamedChain[i++] = cast<NamedDecl>(D);
3006 }
3007
Gabor Marton26f72a92018-07-12 09:42:05 +00003008 llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
3009 IndirectFieldDecl *ToIndirectField;
3010 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
3011 Loc, Name.getAsIdentifierInfo(), T, CH))
3012 // FIXME here we leak `NamedChain` which is allocated before
3013 return ToIndirectField;
Aaron Ballman260995b2014-10-15 16:58:18 +00003014
Aleksei Sidorin8f266db2018-05-08 12:45:21 +00003015 for (const auto *A : D->attrs())
3016 ToIndirectField->addAttr(Importer.Import(A));
Aaron Ballman260995b2014-10-15 16:58:18 +00003017
Francois Pichet783dd6e2010-11-21 06:08:52 +00003018 ToIndirectField->setAccess(D->getAccess());
3019 ToIndirectField->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00003020 LexicalDC->addDeclInternal(ToIndirectField);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003021 return ToIndirectField;
3022}
3023
Aleksei Sidorina693b372016-09-28 10:16:56 +00003024Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3025 // Import the major distinguishing characteristics of a declaration.
3026 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3027 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext()
3028 ? DC : Importer.ImportContext(D->getLexicalDeclContext());
3029 if (!DC || !LexicalDC)
3030 return nullptr;
3031
3032 // Determine whether we've already imported this decl.
3033 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup.
3034 auto *RD = cast<CXXRecordDecl>(DC);
3035 FriendDecl *ImportedFriend = RD->getFirstFriend();
Aleksei Sidorina693b372016-09-28 10:16:56 +00003036
3037 while (ImportedFriend) {
3038 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
Gabor Marton950fb572018-07-17 12:39:27 +00003039 if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
3040 /*Complain=*/false))
Gabor Marton26f72a92018-07-12 09:42:05 +00003041 return Importer.MapImported(D, ImportedFriend);
Aleksei Sidorina693b372016-09-28 10:16:56 +00003042
3043 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3044 if (Importer.IsStructurallyEquivalent(
3045 D->getFriendType()->getType(),
3046 ImportedFriend->getFriendType()->getType(), true))
Gabor Marton26f72a92018-07-12 09:42:05 +00003047 return Importer.MapImported(D, ImportedFriend);
Aleksei Sidorina693b372016-09-28 10:16:56 +00003048 }
3049 ImportedFriend = ImportedFriend->getNextFriend();
3050 }
3051
3052 // Not found. Create it.
3053 FriendDecl::FriendUnion ToFU;
Peter Szecsib180eeb2018-04-25 17:28:03 +00003054 if (NamedDecl *FriendD = D->getFriendDecl()) {
3055 auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD));
3056 if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None &&
3057 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3058 ToFriendD->setObjectOfFriendDecl(false);
3059
3060 ToFU = ToFriendD;
3061 } else // The friend is a type, not a decl.
Aleksei Sidorina693b372016-09-28 10:16:56 +00003062 ToFU = Importer.Import(D->getFriendType());
3063 if (!ToFU)
3064 return nullptr;
3065
3066 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003067 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
Aleksei Sidorina693b372016-09-28 10:16:56 +00003068 for (unsigned I = 0; I < D->NumTPLists; I++) {
3069 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]);
3070 if (!List)
3071 return nullptr;
3072 ToTPLists[I] = List;
3073 }
3074
Gabor Marton26f72a92018-07-12 09:42:05 +00003075 FriendDecl *FrD;
3076 if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3077 Importer.Import(D->getLocation()), ToFU,
3078 Importer.Import(D->getFriendLoc()), ToTPLists))
3079 return FrD;
Aleksei Sidorina693b372016-09-28 10:16:56 +00003080
3081 FrD->setAccess(D->getAccess());
3082 FrD->setLexicalDeclContext(LexicalDC);
3083 LexicalDC->addDeclInternal(FrD);
3084 return FrD;
3085}
3086
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003087Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3088 // Import the major distinguishing characteristics of an ivar.
3089 DeclContext *DC, *LexicalDC;
3090 DeclarationName Name;
3091 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00003092 NamedDecl *ToD;
3093 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00003094 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003095 if (ToD)
3096 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00003097
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003098 // Determine whether we've already imported this ivar
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003099 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00003100 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003101 for (auto *FoundDecl : FoundDecls) {
3102 if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003103 if (Importer.IsStructurallyEquivalent(D->getType(),
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003104 FoundIvar->getType())) {
Gabor Marton26f72a92018-07-12 09:42:05 +00003105 Importer.MapImported(D, FoundIvar);
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003106 return FoundIvar;
3107 }
3108
3109 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent)
3110 << Name << D->getType() << FoundIvar->getType();
3111 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3112 << FoundIvar->getType();
Craig Topper36250ad2014-05-12 05:36:57 +00003113 return nullptr;
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003114 }
3115 }
3116
3117 // Import the type.
3118 QualType T = Importer.Import(D->getType());
3119 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003120 return nullptr;
3121
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003122 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
3123 Expr *BitWidth = Importer.Import(D->getBitWidth());
3124 if (!BitWidth && D->getBitWidth())
Craig Topper36250ad2014-05-12 05:36:57 +00003125 return nullptr;
3126
Gabor Marton26f72a92018-07-12 09:42:05 +00003127 ObjCIvarDecl *ToIvar;
3128 if (GetImportedOrCreateDecl(
3129 ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3130 Importer.Import(D->getInnerLocStart()), Loc,
3131 Name.getAsIdentifierInfo(), T, TInfo, D->getAccessControl(), BitWidth,
3132 D->getSynthesize()))
3133 return ToIvar;
3134
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003135 ToIvar->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00003136 LexicalDC->addDeclInternal(ToIvar);
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003137 return ToIvar;
Douglas Gregor7244b0b2010-02-17 00:34:30 +00003138}
3139
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003140Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3141 // Import the major distinguishing characteristics of a variable.
3142 DeclContext *DC, *LexicalDC;
3143 DeclarationName Name;
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003144 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00003145 NamedDecl *ToD;
3146 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00003147 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003148 if (ToD)
3149 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00003150
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003151 // Try to find a variable in our own ("to") context with the same name and
3152 // in the same context as the variable we're importing.
Douglas Gregor62d311f2010-02-09 19:21:46 +00003153 if (D->isFileVarDecl()) {
Craig Topper36250ad2014-05-12 05:36:57 +00003154 VarDecl *MergeWithVar = nullptr;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003155 SmallVector<NamedDecl *, 4> ConflictingDecls;
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003156 unsigned IDNS = Decl::IDNS_Ordinary;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003157 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00003158 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003159 for (auto *FoundDecl : FoundDecls) {
3160 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003161 continue;
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003162
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003163 if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003164 // We have found a variable that we may need to merge with. Check it.
Rafael Espindola3ae00052013-05-13 00:12:11 +00003165 if (FoundVar->hasExternalFormalLinkage() &&
3166 D->hasExternalFormalLinkage()) {
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003167 if (Importer.IsStructurallyEquivalent(D->getType(),
Douglas Gregorb4964f72010-02-15 23:54:17 +00003168 FoundVar->getType())) {
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003169 MergeWithVar = FoundVar;
3170 break;
3171 }
3172
Douglas Gregor56521c52010-02-12 17:23:39 +00003173 const ArrayType *FoundArray
3174 = Importer.getToContext().getAsArrayType(FoundVar->getType());
3175 const ArrayType *TArray
Douglas Gregorb4964f72010-02-15 23:54:17 +00003176 = Importer.getToContext().getAsArrayType(D->getType());
Douglas Gregor56521c52010-02-12 17:23:39 +00003177 if (FoundArray && TArray) {
3178 if (isa<IncompleteArrayType>(FoundArray) &&
3179 isa<ConstantArrayType>(TArray)) {
Douglas Gregorb4964f72010-02-15 23:54:17 +00003180 // Import the type.
3181 QualType T = Importer.Import(D->getType());
3182 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003183 return nullptr;
3184
Douglas Gregor56521c52010-02-12 17:23:39 +00003185 FoundVar->setType(T);
3186 MergeWithVar = FoundVar;
3187 break;
3188 } else if (isa<IncompleteArrayType>(TArray) &&
3189 isa<ConstantArrayType>(FoundArray)) {
3190 MergeWithVar = FoundVar;
3191 break;
Douglas Gregor2fbe5582010-02-10 17:16:49 +00003192 }
3193 }
3194
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003195 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent)
Douglas Gregorb4964f72010-02-15 23:54:17 +00003196 << Name << D->getType() << FoundVar->getType();
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003197 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3198 << FoundVar->getType();
3199 }
3200 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003201
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003202 ConflictingDecls.push_back(FoundDecl);
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003203 }
3204
3205 if (MergeWithVar) {
Gabor Marton26f72a92018-07-12 09:42:05 +00003206 // An equivalent variable with external linkage has been found. Link
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003207 // the two declarations, then merge them.
Gabor Marton26f72a92018-07-12 09:42:05 +00003208 Importer.MapImported(D, MergeWithVar);
3209 updateFlags(D, MergeWithVar);
3210
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003211 if (VarDecl *DDef = D->getDefinition()) {
3212 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00003213 Importer.ToDiag(ExistingDef->getLocation(),
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003214 diag::err_odr_variable_multiple_def)
3215 << Name;
3216 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here);
3217 } else {
3218 Expr *Init = Importer.Import(DDef->getInit());
Douglas Gregord5058122010-02-11 01:19:42 +00003219 MergeWithVar->setInit(Init);
Richard Smithd0b4dd62011-12-19 06:19:21 +00003220 if (DDef->isInitKnownICE()) {
3221 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt();
3222 Eval->CheckedICE = true;
3223 Eval->IsICE = DDef->isInitICE();
3224 }
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003225 }
3226 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003227
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003228 return MergeWithVar;
3229 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003230
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003231 if (!ConflictingDecls.empty()) {
3232 Name = Importer.HandleNameConflict(Name, DC, IDNS,
Fangrui Song6907ce22018-07-30 19:24:48 +00003233 ConflictingDecls.data(),
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003234 ConflictingDecls.size());
3235 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00003236 return nullptr;
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003237 }
3238 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003239
Douglas Gregorb4964f72010-02-15 23:54:17 +00003240 // Import the type.
3241 QualType T = Importer.Import(D->getType());
3242 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003243 return nullptr;
3244
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003245 // Create the imported variable.
Douglas Gregorfa7a0e52010-02-10 17:47:19 +00003246 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Gabor Marton26f72a92018-07-12 09:42:05 +00003247 VarDecl *ToVar;
3248 if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
3249 Importer.Import(D->getInnerLocStart()), Loc,
3250 Name.getAsIdentifierInfo(), T, TInfo,
3251 D->getStorageClass()))
3252 return ToVar;
3253
Douglas Gregor14454802011-02-25 02:25:35 +00003254 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Douglas Gregordd483172010-02-22 17:42:47 +00003255 ToVar->setAccess(D->getAccess());
Douglas Gregor62d311f2010-02-09 19:21:46 +00003256 ToVar->setLexicalDeclContext(LexicalDC);
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00003257
3258 // Templated declarations should never appear in the enclosing DeclContext.
3259 if (!D->getDescribedVarTemplate())
3260 LexicalDC->addDeclInternal(ToVar);
Douglas Gregor62d311f2010-02-09 19:21:46 +00003261
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003262 // Merge the initializer.
Larisse Voufo39a1e502013-08-06 01:03:05 +00003263 if (ImportDefinition(D, ToVar))
Craig Topper36250ad2014-05-12 05:36:57 +00003264 return nullptr;
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003265
Aleksei Sidorin855086d2017-01-23 09:30:36 +00003266 if (D->isConstexpr())
3267 ToVar->setConstexpr(true);
3268
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00003269 return ToVar;
3270}
3271
Douglas Gregor8b228d72010-02-17 21:22:52 +00003272Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
3273 // Parameters are created in the translation unit's context, then moved
3274 // into the function declaration's context afterward.
3275 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
Fangrui Song6907ce22018-07-30 19:24:48 +00003276
Douglas Gregor8b228d72010-02-17 21:22:52 +00003277 // Import the name of this declaration.
3278 DeclarationName Name = Importer.Import(D->getDeclName());
3279 if (D->getDeclName() && !Name)
Craig Topper36250ad2014-05-12 05:36:57 +00003280 return nullptr;
3281
Douglas Gregor8b228d72010-02-17 21:22:52 +00003282 // Import the location of this declaration.
3283 SourceLocation Loc = Importer.Import(D->getLocation());
Fangrui Song6907ce22018-07-30 19:24:48 +00003284
Douglas Gregor8b228d72010-02-17 21:22:52 +00003285 // Import the parameter's type.
3286 QualType T = Importer.Import(D->getType());
3287 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003288 return nullptr;
3289
Douglas Gregor8b228d72010-02-17 21:22:52 +00003290 // Create the imported parameter.
Gabor Marton26f72a92018-07-12 09:42:05 +00003291 ImplicitParamDecl *ToParm = nullptr;
3292 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, Loc,
3293 Name.getAsIdentifierInfo(), T,
3294 D->getParameterKind()))
3295 return ToParm;
3296 return ToParm;
Douglas Gregor8b228d72010-02-17 21:22:52 +00003297}
3298
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003299Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
3300 // Parameters are created in the translation unit's context, then moved
3301 // into the function declaration's context afterward.
3302 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
Fangrui Song6907ce22018-07-30 19:24:48 +00003303
Douglas Gregorfa7a0e52010-02-10 17:47:19 +00003304 // Import the name of this declaration.
3305 DeclarationName Name = Importer.Import(D->getDeclName());
3306 if (D->getDeclName() && !Name)
Craig Topper36250ad2014-05-12 05:36:57 +00003307 return nullptr;
3308
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003309 // Import the location of this declaration.
3310 SourceLocation Loc = Importer.Import(D->getLocation());
Fangrui Song6907ce22018-07-30 19:24:48 +00003311
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003312 // Import the parameter's type.
3313 QualType T = Importer.Import(D->getType());
3314 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003315 return nullptr;
3316
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003317 // Create the imported parameter.
3318 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
Gabor Marton26f72a92018-07-12 09:42:05 +00003319 ParmVarDecl *ToParm;
3320 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
3321 Importer.Import(D->getInnerLocStart()), Loc,
3322 Name.getAsIdentifierInfo(), T, TInfo,
3323 D->getStorageClass(),
3324 /*DefaultArg*/ nullptr))
3325 return ToParm;
Aleksei Sidorin55a63502017-02-20 11:57:12 +00003326
3327 // Set the default argument.
John McCallf3cd6652010-03-12 18:31:32 +00003328 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
Aleksei Sidorin55a63502017-02-20 11:57:12 +00003329 ToParm->setKNRPromoted(D->isKNRPromoted());
3330
3331 Expr *ToDefArg = nullptr;
3332 Expr *FromDefArg = nullptr;
3333 if (D->hasUninstantiatedDefaultArg()) {
3334 FromDefArg = D->getUninstantiatedDefaultArg();
3335 ToDefArg = Importer.Import(FromDefArg);
3336 ToParm->setUninstantiatedDefaultArg(ToDefArg);
3337 } else if (D->hasUnparsedDefaultArg()) {
3338 ToParm->setUnparsedDefaultArg();
3339 } else if (D->hasDefaultArg()) {
3340 FromDefArg = D->getDefaultArg();
3341 ToDefArg = Importer.Import(FromDefArg);
3342 ToParm->setDefaultArg(ToDefArg);
3343 }
3344 if (FromDefArg && !ToDefArg)
3345 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003346
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00003347 if (D->isObjCMethodParameter()) {
3348 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
3349 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
3350 } else {
3351 ToParm->setScopeInfo(D->getFunctionScopeDepth(),
3352 D->getFunctionScopeIndex());
3353 }
3354
Gabor Marton26f72a92018-07-12 09:42:05 +00003355 return ToParm;
Douglas Gregorbb7930c2010-02-10 19:54:31 +00003356}
3357
Douglas Gregor43f54792010-02-17 02:12:47 +00003358Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
3359 // Import the major distinguishing characteristics of a method.
3360 DeclContext *DC, *LexicalDC;
3361 DeclarationName Name;
3362 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00003363 NamedDecl *ToD;
3364 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00003365 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003366 if (ToD)
3367 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00003368
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003369 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00003370 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003371 for (auto *FoundDecl : FoundDecls) {
3372 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
Douglas Gregor43f54792010-02-17 02:12:47 +00003373 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
3374 continue;
3375
3376 // Check return types.
Alp Toker314cc812014-01-25 16:55:45 +00003377 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
3378 FoundMethod->getReturnType())) {
Douglas Gregor43f54792010-02-17 02:12:47 +00003379 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent)
Alp Toker314cc812014-01-25 16:55:45 +00003380 << D->isInstanceMethod() << Name << D->getReturnType()
3381 << FoundMethod->getReturnType();
Fangrui Song6907ce22018-07-30 19:24:48 +00003382 Importer.ToDiag(FoundMethod->getLocation(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003383 diag::note_odr_objc_method_here)
3384 << D->isInstanceMethod() << Name;
Craig Topper36250ad2014-05-12 05:36:57 +00003385 return nullptr;
Douglas Gregor43f54792010-02-17 02:12:47 +00003386 }
3387
3388 // Check the number of parameters.
3389 if (D->param_size() != FoundMethod->param_size()) {
3390 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent)
3391 << D->isInstanceMethod() << Name
3392 << D->param_size() << FoundMethod->param_size();
Fangrui Song6907ce22018-07-30 19:24:48 +00003393 Importer.ToDiag(FoundMethod->getLocation(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003394 diag::note_odr_objc_method_here)
3395 << D->isInstanceMethod() << Name;
Craig Topper36250ad2014-05-12 05:36:57 +00003396 return nullptr;
Douglas Gregor43f54792010-02-17 02:12:47 +00003397 }
3398
3399 // Check parameter types.
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003400 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003401 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
3402 P != PEnd; ++P, ++FoundP) {
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003403 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003404 (*FoundP)->getType())) {
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00003405 Importer.FromDiag((*P)->getLocation(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003406 diag::err_odr_objc_method_param_type_inconsistent)
3407 << D->isInstanceMethod() << Name
3408 << (*P)->getType() << (*FoundP)->getType();
3409 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
3410 << (*FoundP)->getType();
Craig Topper36250ad2014-05-12 05:36:57 +00003411 return nullptr;
Douglas Gregor43f54792010-02-17 02:12:47 +00003412 }
3413 }
3414
3415 // Check variadic/non-variadic.
3416 // Check the number of parameters.
3417 if (D->isVariadic() != FoundMethod->isVariadic()) {
3418 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent)
3419 << D->isInstanceMethod() << Name;
Fangrui Song6907ce22018-07-30 19:24:48 +00003420 Importer.ToDiag(FoundMethod->getLocation(),
Douglas Gregor43f54792010-02-17 02:12:47 +00003421 diag::note_odr_objc_method_here)
3422 << D->isInstanceMethod() << Name;
Craig Topper36250ad2014-05-12 05:36:57 +00003423 return nullptr;
Douglas Gregor43f54792010-02-17 02:12:47 +00003424 }
3425
3426 // FIXME: Any other bits we need to merge?
Gabor Marton26f72a92018-07-12 09:42:05 +00003427 return Importer.MapImported(D, FoundMethod);
Douglas Gregor43f54792010-02-17 02:12:47 +00003428 }
3429 }
3430
3431 // Import the result type.
Alp Toker314cc812014-01-25 16:55:45 +00003432 QualType ResultTy = Importer.Import(D->getReturnType());
Douglas Gregor43f54792010-02-17 02:12:47 +00003433 if (ResultTy.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00003434 return nullptr;
Douglas Gregor43f54792010-02-17 02:12:47 +00003435
Alp Toker314cc812014-01-25 16:55:45 +00003436 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo());
Douglas Gregor12852d92010-03-08 14:59:44 +00003437
Gabor Marton26f72a92018-07-12 09:42:05 +00003438 ObjCMethodDecl *ToMethod;
3439 if (GetImportedOrCreateDecl(
3440 ToMethod, D, Importer.getToContext(), Loc,
Stephen Kelly1c301dc2018-08-09 21:09:38 +00003441 Importer.Import(D->getEndLoc()), Name.getObjCSelector(), ResultTy,
Gabor Marton26f72a92018-07-12 09:42:05 +00003442 ReturnTInfo, DC, D->isInstanceMethod(), D->isVariadic(),
3443 D->isPropertyAccessor(), D->isImplicit(), D->isDefined(),
3444 D->getImplementationControl(), D->hasRelatedResultType()))
3445 return ToMethod;
Douglas Gregor43f54792010-02-17 02:12:47 +00003446
3447 // FIXME: When we decide to merge method definitions, we'll need to
3448 // deal with implicit parameters.
3449
3450 // Import the parameters
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003451 SmallVector<ParmVarDecl *, 5> ToParams;
David Majnemer59f77922016-06-24 04:05:48 +00003452 for (auto *FromP : D->parameters()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003453 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP));
Douglas Gregor43f54792010-02-17 02:12:47 +00003454 if (!ToP)
Craig Topper36250ad2014-05-12 05:36:57 +00003455 return nullptr;
3456
Douglas Gregor43f54792010-02-17 02:12:47 +00003457 ToParams.push_back(ToP);
3458 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003459
Douglas Gregor43f54792010-02-17 02:12:47 +00003460 // Set the parameters.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003461 for (auto *ToParam : ToParams) {
3462 ToParam->setOwningFunction(ToMethod);
3463 ToMethod->addDeclInternal(ToParam);
Douglas Gregor43f54792010-02-17 02:12:47 +00003464 }
Aleksei Sidorin47dbaf62018-01-09 14:25:05 +00003465
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00003466 SmallVector<SourceLocation, 12> SelLocs;
3467 D->getSelectorLocs(SelLocs);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003468 for (auto &Loc : SelLocs)
Aleksei Sidorin47dbaf62018-01-09 14:25:05 +00003469 Loc = Importer.Import(Loc);
3470
3471 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs);
Douglas Gregor43f54792010-02-17 02:12:47 +00003472
3473 ToMethod->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00003474 LexicalDC->addDeclInternal(ToMethod);
Douglas Gregor43f54792010-02-17 02:12:47 +00003475 return ToMethod;
3476}
3477
Douglas Gregor85f3f952015-07-07 03:57:15 +00003478Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
3479 // Import the major distinguishing characteristics of a category.
3480 DeclContext *DC, *LexicalDC;
3481 DeclarationName Name;
3482 SourceLocation Loc;
3483 NamedDecl *ToD;
3484 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3485 return nullptr;
3486 if (ToD)
3487 return ToD;
3488
3489 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo());
3490 if (!BoundInfo)
3491 return nullptr;
3492
Gabor Marton26f72a92018-07-12 09:42:05 +00003493 ObjCTypeParamDecl *Result;
3494 if (GetImportedOrCreateDecl(
3495 Result, D, Importer.getToContext(), DC, D->getVariance(),
3496 Importer.Import(D->getVarianceLoc()), D->getIndex(),
3497 Importer.Import(D->getLocation()), Name.getAsIdentifierInfo(),
3498 Importer.Import(D->getColonLoc()), BoundInfo))
3499 return Result;
3500
Douglas Gregor85f3f952015-07-07 03:57:15 +00003501 Result->setLexicalDeclContext(LexicalDC);
3502 return Result;
3503}
3504
Douglas Gregor84c51c32010-02-18 01:47:50 +00003505Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
3506 // Import the major distinguishing characteristics of a category.
3507 DeclContext *DC, *LexicalDC;
3508 DeclarationName Name;
3509 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00003510 NamedDecl *ToD;
3511 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00003512 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003513 if (ToD)
3514 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00003515
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003516 auto *ToInterface =
3517 cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface()));
Douglas Gregor84c51c32010-02-18 01:47:50 +00003518 if (!ToInterface)
Craig Topper36250ad2014-05-12 05:36:57 +00003519 return nullptr;
3520
Douglas Gregor84c51c32010-02-18 01:47:50 +00003521 // Determine if we've already encountered this category.
3522 ObjCCategoryDecl *MergeWithCategory
3523 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
3524 ObjCCategoryDecl *ToCategory = MergeWithCategory;
3525 if (!ToCategory) {
Gabor Marton26f72a92018-07-12 09:42:05 +00003526
3527 if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
3528 Importer.Import(D->getAtStartLoc()), Loc,
3529 Importer.Import(D->getCategoryNameLoc()),
3530 Name.getAsIdentifierInfo(), ToInterface,
3531 /*TypeParamList=*/nullptr,
3532 Importer.Import(D->getIvarLBraceLoc()),
3533 Importer.Import(D->getIvarRBraceLoc())))
3534 return ToCategory;
3535
Douglas Gregor84c51c32010-02-18 01:47:50 +00003536 ToCategory->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00003537 LexicalDC->addDeclInternal(ToCategory);
Douglas Gregorab7f0b32015-07-07 06:20:12 +00003538 // Import the type parameter list after calling Imported, to avoid
3539 // loops when bringing in their DeclContext.
3540 ToCategory->setTypeParamList(ImportObjCTypeParamList(
3541 D->getTypeParamList()));
Fangrui Song6907ce22018-07-30 19:24:48 +00003542
Douglas Gregor84c51c32010-02-18 01:47:50 +00003543 // Import protocols
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003544 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3545 SmallVector<SourceLocation, 4> ProtocolLocs;
Douglas Gregor84c51c32010-02-18 01:47:50 +00003546 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
3547 = D->protocol_loc_begin();
3548 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
3549 FromProtoEnd = D->protocol_end();
3550 FromProto != FromProtoEnd;
3551 ++FromProto, ++FromProtoLoc) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003552 auto *ToProto =
3553 cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
Douglas Gregor84c51c32010-02-18 01:47:50 +00003554 if (!ToProto)
Craig Topper36250ad2014-05-12 05:36:57 +00003555 return nullptr;
Douglas Gregor84c51c32010-02-18 01:47:50 +00003556 Protocols.push_back(ToProto);
3557 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3558 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003559
Douglas Gregor84c51c32010-02-18 01:47:50 +00003560 // FIXME: If we're merging, make sure that the protocol list is the same.
3561 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
3562 ProtocolLocs.data(), Importer.getToContext());
Douglas Gregor84c51c32010-02-18 01:47:50 +00003563 } else {
Gabor Marton26f72a92018-07-12 09:42:05 +00003564 Importer.MapImported(D, ToCategory);
Douglas Gregor84c51c32010-02-18 01:47:50 +00003565 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003566
Douglas Gregor84c51c32010-02-18 01:47:50 +00003567 // Import all of the members of this category.
Douglas Gregor968d6332010-02-21 18:24:45 +00003568 ImportDeclContext(D);
Fangrui Song6907ce22018-07-30 19:24:48 +00003569
Douglas Gregor84c51c32010-02-18 01:47:50 +00003570 // If we have an implementation, import it as well.
3571 if (D->getImplementation()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003572 auto *Impl =
3573 cast_or_null<ObjCCategoryImplDecl>(
Douglas Gregor35fd7bc2010-12-08 16:41:55 +00003574 Importer.Import(D->getImplementation()));
Douglas Gregor84c51c32010-02-18 01:47:50 +00003575 if (!Impl)
Craig Topper36250ad2014-05-12 05:36:57 +00003576 return nullptr;
3577
Douglas Gregor84c51c32010-02-18 01:47:50 +00003578 ToCategory->setImplementation(Impl);
3579 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003580
Douglas Gregor84c51c32010-02-18 01:47:50 +00003581 return ToCategory;
3582}
3583
Fangrui Song6907ce22018-07-30 19:24:48 +00003584bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
Douglas Gregor2aa53772012-01-24 17:42:07 +00003585 ObjCProtocolDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +00003586 ImportDefinitionKind Kind) {
Douglas Gregor2aa53772012-01-24 17:42:07 +00003587 if (To->getDefinition()) {
Douglas Gregor2e15c842012-02-01 21:00:38 +00003588 if (shouldForceImportDeclContext(Kind))
3589 ImportDeclContext(From);
Douglas Gregor2aa53772012-01-24 17:42:07 +00003590 return false;
3591 }
3592
3593 // Start the protocol definition
3594 To->startDefinition();
Fangrui Song6907ce22018-07-30 19:24:48 +00003595
Douglas Gregor2aa53772012-01-24 17:42:07 +00003596 // Import protocols
3597 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3598 SmallVector<SourceLocation, 4> ProtocolLocs;
Fangrui Song6907ce22018-07-30 19:24:48 +00003599 ObjCProtocolDecl::protocol_loc_iterator
Douglas Gregor2aa53772012-01-24 17:42:07 +00003600 FromProtoLoc = From->protocol_loc_begin();
3601 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
3602 FromProtoEnd = From->protocol_end();
3603 FromProto != FromProtoEnd;
3604 ++FromProto, ++FromProtoLoc) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003605 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
Douglas Gregor2aa53772012-01-24 17:42:07 +00003606 if (!ToProto)
3607 return true;
3608 Protocols.push_back(ToProto);
3609 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3610 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003611
Douglas Gregor2aa53772012-01-24 17:42:07 +00003612 // FIXME: If we're merging, make sure that the protocol list is the same.
3613 To->setProtocolList(Protocols.data(), Protocols.size(),
3614 ProtocolLocs.data(), Importer.getToContext());
3615
Douglas Gregor2e15c842012-02-01 21:00:38 +00003616 if (shouldForceImportDeclContext(Kind)) {
3617 // Import all of the members of this protocol.
3618 ImportDeclContext(From, /*ForceImport=*/true);
3619 }
Douglas Gregor2aa53772012-01-24 17:42:07 +00003620 return false;
3621}
3622
Douglas Gregor98d156a2010-02-17 16:12:00 +00003623Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
Fangrui Song6907ce22018-07-30 19:24:48 +00003624 // If this protocol has a definition in the translation unit we're coming
Douglas Gregor2aa53772012-01-24 17:42:07 +00003625 // from, but this particular declaration is not that definition, import the
3626 // definition and map to that.
3627 ObjCProtocolDecl *Definition = D->getDefinition();
3628 if (Definition && Definition != D) {
3629 Decl *ImportedDef = Importer.Import(Definition);
3630 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00003631 return nullptr;
3632
Gabor Marton26f72a92018-07-12 09:42:05 +00003633 return Importer.MapImported(D, ImportedDef);
Douglas Gregor2aa53772012-01-24 17:42:07 +00003634 }
3635
Douglas Gregor84c51c32010-02-18 01:47:50 +00003636 // Import the major distinguishing characteristics of a protocol.
Douglas Gregor98d156a2010-02-17 16:12:00 +00003637 DeclContext *DC, *LexicalDC;
3638 DeclarationName Name;
3639 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00003640 NamedDecl *ToD;
3641 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00003642 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00003643 if (ToD)
3644 return ToD;
Douglas Gregor98d156a2010-02-17 16:12:00 +00003645
Craig Topper36250ad2014-05-12 05:36:57 +00003646 ObjCProtocolDecl *MergeWithProtocol = nullptr;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003647 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00003648 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003649 for (auto *FoundDecl : FoundDecls) {
3650 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
Douglas Gregor98d156a2010-02-17 16:12:00 +00003651 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00003652
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003653 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
Douglas Gregor98d156a2010-02-17 16:12:00 +00003654 break;
3655 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003656
Douglas Gregor98d156a2010-02-17 16:12:00 +00003657 ObjCProtocolDecl *ToProto = MergeWithProtocol;
Douglas Gregor2aa53772012-01-24 17:42:07 +00003658 if (!ToProto) {
Gabor Marton26f72a92018-07-12 09:42:05 +00003659 if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
3660 Name.getAsIdentifierInfo(), Loc,
3661 Importer.Import(D->getAtStartLoc()),
3662 /*PrevDecl=*/nullptr))
3663 return ToProto;
Douglas Gregor2aa53772012-01-24 17:42:07 +00003664 ToProto->setLexicalDeclContext(LexicalDC);
3665 LexicalDC->addDeclInternal(ToProto);
Douglas Gregor98d156a2010-02-17 16:12:00 +00003666 }
Gabor Marton26f72a92018-07-12 09:42:05 +00003667
3668 Importer.MapImported(D, ToProto);
Douglas Gregor98d156a2010-02-17 16:12:00 +00003669
Douglas Gregor2aa53772012-01-24 17:42:07 +00003670 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto))
Craig Topper36250ad2014-05-12 05:36:57 +00003671 return nullptr;
3672
Douglas Gregor98d156a2010-02-17 16:12:00 +00003673 return ToProto;
3674}
3675
Sean Callanan0aae0412014-12-10 00:00:37 +00003676Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
3677 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
3678 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
3679
3680 SourceLocation ExternLoc = Importer.Import(D->getExternLoc());
3681 SourceLocation LangLoc = Importer.Import(D->getLocation());
3682
3683 bool HasBraces = D->hasBraces();
Gabor Marton26f72a92018-07-12 09:42:05 +00003684
3685 LinkageSpecDecl *ToLinkageSpec;
3686 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
3687 ExternLoc, LangLoc, D->getLanguage(), HasBraces))
3688 return ToLinkageSpec;
Sean Callanan0aae0412014-12-10 00:00:37 +00003689
3690 if (HasBraces) {
3691 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc());
3692 ToLinkageSpec->setRBraceLoc(RBraceLoc);
3693 }
3694
3695 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
3696 LexicalDC->addDeclInternal(ToLinkageSpec);
3697
Sean Callanan0aae0412014-12-10 00:00:37 +00003698 return ToLinkageSpec;
3699}
3700
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003701Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
3702 DeclContext *DC, *LexicalDC;
3703 DeclarationName Name;
3704 SourceLocation Loc;
3705 NamedDecl *ToD = nullptr;
3706 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3707 return nullptr;
3708 if (ToD)
3709 return ToD;
3710
3711 DeclarationNameInfo NameInfo(Name,
3712 Importer.Import(D->getNameInfo().getLoc()));
3713 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3714
Gabor Marton26f72a92018-07-12 09:42:05 +00003715 UsingDecl *ToUsing;
3716 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3717 Importer.Import(D->getUsingLoc()),
3718 Importer.Import(D->getQualifierLoc()), NameInfo,
3719 D->hasTypename()))
3720 return ToUsing;
3721
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003722 ToUsing->setLexicalDeclContext(LexicalDC);
3723 LexicalDC->addDeclInternal(ToUsing);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003724
3725 if (NamedDecl *FromPattern =
3726 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003727 if (auto *ToPattern =
3728 dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern)))
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003729 Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern);
3730 else
3731 return nullptr;
3732 }
3733
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003734 for (auto *FromShadow : D->shadows()) {
3735 if (auto *ToShadow =
3736 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow)))
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003737 ToUsing->addShadowDecl(ToShadow);
3738 else
3739 // FIXME: We return a nullptr here but the definition is already created
3740 // and available with lookups. How to fix this?..
3741 return nullptr;
3742 }
3743 return ToUsing;
3744}
3745
3746Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
3747 DeclContext *DC, *LexicalDC;
3748 DeclarationName Name;
3749 SourceLocation Loc;
3750 NamedDecl *ToD = nullptr;
3751 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3752 return nullptr;
3753 if (ToD)
3754 return ToD;
3755
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003756 auto *ToUsing = dyn_cast_or_null<UsingDecl>(
3757 Importer.Import(D->getUsingDecl()));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003758 if (!ToUsing)
3759 return nullptr;
3760
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003761 auto *ToTarget = dyn_cast_or_null<NamedDecl>(
3762 Importer.Import(D->getTargetDecl()));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003763 if (!ToTarget)
3764 return nullptr;
3765
Gabor Marton26f72a92018-07-12 09:42:05 +00003766 UsingShadowDecl *ToShadow;
3767 if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
3768 ToUsing, ToTarget))
3769 return ToShadow;
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003770
3771 ToShadow->setLexicalDeclContext(LexicalDC);
3772 ToShadow->setAccess(D->getAccess());
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003773
3774 if (UsingShadowDecl *FromPattern =
3775 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003776 if (auto *ToPattern =
3777 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern)))
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003778 Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow,
3779 ToPattern);
3780 else
3781 // FIXME: We return a nullptr here but the definition is already created
3782 // and available with lookups. How to fix this?..
3783 return nullptr;
3784 }
3785
3786 LexicalDC->addDeclInternal(ToShadow);
3787
3788 return ToShadow;
3789}
3790
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003791Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
3792 DeclContext *DC, *LexicalDC;
3793 DeclarationName Name;
3794 SourceLocation Loc;
3795 NamedDecl *ToD = nullptr;
3796 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3797 return nullptr;
3798 if (ToD)
3799 return ToD;
3800
3801 DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor());
3802 if (!ToComAncestor)
3803 return nullptr;
3804
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003805 auto *ToNominated = cast_or_null<NamespaceDecl>(
3806 Importer.Import(D->getNominatedNamespace()));
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003807 if (!ToNominated)
3808 return nullptr;
3809
Gabor Marton26f72a92018-07-12 09:42:05 +00003810 UsingDirectiveDecl *ToUsingDir;
3811 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
3812 Importer.Import(D->getUsingLoc()),
3813 Importer.Import(D->getNamespaceKeyLocation()),
3814 Importer.Import(D->getQualifierLoc()),
3815 Importer.Import(D->getIdentLocation()),
3816 ToNominated, ToComAncestor))
3817 return ToUsingDir;
3818
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003819 ToUsingDir->setLexicalDeclContext(LexicalDC);
3820 LexicalDC->addDeclInternal(ToUsingDir);
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003821
3822 return ToUsingDir;
3823}
3824
3825Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl(
3826 UnresolvedUsingValueDecl *D) {
3827 DeclContext *DC, *LexicalDC;
3828 DeclarationName Name;
3829 SourceLocation Loc;
3830 NamedDecl *ToD = nullptr;
3831 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3832 return nullptr;
3833 if (ToD)
3834 return ToD;
3835
3836 DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc()));
3837 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo);
3838
Gabor Marton26f72a92018-07-12 09:42:05 +00003839 UnresolvedUsingValueDecl *ToUsingValue;
3840 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
3841 Importer.Import(D->getUsingLoc()),
3842 Importer.Import(D->getQualifierLoc()), NameInfo,
3843 Importer.Import(D->getEllipsisLoc())))
3844 return ToUsingValue;
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003845
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003846 ToUsingValue->setAccess(D->getAccess());
3847 ToUsingValue->setLexicalDeclContext(LexicalDC);
3848 LexicalDC->addDeclInternal(ToUsingValue);
3849
3850 return ToUsingValue;
3851}
3852
3853Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
3854 UnresolvedUsingTypenameDecl *D) {
3855 DeclContext *DC, *LexicalDC;
3856 DeclarationName Name;
3857 SourceLocation Loc;
3858 NamedDecl *ToD = nullptr;
3859 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3860 return nullptr;
3861 if (ToD)
3862 return ToD;
3863
Gabor Marton26f72a92018-07-12 09:42:05 +00003864 UnresolvedUsingTypenameDecl *ToUsing;
3865 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
3866 Importer.Import(D->getUsingLoc()),
3867 Importer.Import(D->getTypenameLoc()),
3868 Importer.Import(D->getQualifierLoc()), Loc, Name,
3869 Importer.Import(D->getEllipsisLoc())))
3870 return ToUsing;
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003871
Aleksei Sidorin2697f8e2017-11-21 16:08:41 +00003872 ToUsing->setAccess(D->getAccess());
3873 ToUsing->setLexicalDeclContext(LexicalDC);
3874 LexicalDC->addDeclInternal(ToUsing);
3875
3876 return ToUsing;
3877}
3878
Fangrui Song6907ce22018-07-30 19:24:48 +00003879bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
Douglas Gregor2aa53772012-01-24 17:42:07 +00003880 ObjCInterfaceDecl *To,
Douglas Gregor2e15c842012-02-01 21:00:38 +00003881 ImportDefinitionKind Kind) {
Douglas Gregor2aa53772012-01-24 17:42:07 +00003882 if (To->getDefinition()) {
3883 // Check consistency of superclass.
3884 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
3885 if (FromSuper) {
3886 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper));
3887 if (!FromSuper)
3888 return true;
3889 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003890
3891 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
Douglas Gregor2aa53772012-01-24 17:42:07 +00003892 if ((bool)FromSuper != (bool)ToSuper ||
3893 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
Fangrui Song6907ce22018-07-30 19:24:48 +00003894 Importer.ToDiag(To->getLocation(),
Douglas Gregor2aa53772012-01-24 17:42:07 +00003895 diag::err_odr_objc_superclass_inconsistent)
3896 << To->getDeclName();
3897 if (ToSuper)
3898 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
3899 << To->getSuperClass()->getDeclName();
3900 else
Fangrui Song6907ce22018-07-30 19:24:48 +00003901 Importer.ToDiag(To->getLocation(),
Douglas Gregor2aa53772012-01-24 17:42:07 +00003902 diag::note_odr_objc_missing_superclass);
3903 if (From->getSuperClass())
Fangrui Song6907ce22018-07-30 19:24:48 +00003904 Importer.FromDiag(From->getSuperClassLoc(),
Douglas Gregor2aa53772012-01-24 17:42:07 +00003905 diag::note_odr_objc_superclass)
3906 << From->getSuperClass()->getDeclName();
3907 else
Fangrui Song6907ce22018-07-30 19:24:48 +00003908 Importer.FromDiag(From->getLocation(),
3909 diag::note_odr_objc_missing_superclass);
Douglas Gregor2aa53772012-01-24 17:42:07 +00003910 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003911
Douglas Gregor2e15c842012-02-01 21:00:38 +00003912 if (shouldForceImportDeclContext(Kind))
3913 ImportDeclContext(From);
Douglas Gregor2aa53772012-01-24 17:42:07 +00003914 return false;
3915 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003916
Douglas Gregor2aa53772012-01-24 17:42:07 +00003917 // Start the definition.
3918 To->startDefinition();
Fangrui Song6907ce22018-07-30 19:24:48 +00003919
Douglas Gregor2aa53772012-01-24 17:42:07 +00003920 // If this class has a superclass, import it.
3921 if (From->getSuperClass()) {
Douglas Gregore9d95f12015-07-07 03:57:35 +00003922 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo());
3923 if (!SuperTInfo)
Douglas Gregor2aa53772012-01-24 17:42:07 +00003924 return true;
Douglas Gregore9d95f12015-07-07 03:57:35 +00003925
3926 To->setSuperClass(SuperTInfo);
Douglas Gregor2aa53772012-01-24 17:42:07 +00003927 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003928
Douglas Gregor2aa53772012-01-24 17:42:07 +00003929 // Import protocols
3930 SmallVector<ObjCProtocolDecl *, 4> Protocols;
3931 SmallVector<SourceLocation, 4> ProtocolLocs;
Fangrui Song6907ce22018-07-30 19:24:48 +00003932 ObjCInterfaceDecl::protocol_loc_iterator
Douglas Gregor2aa53772012-01-24 17:42:07 +00003933 FromProtoLoc = From->protocol_loc_begin();
Fangrui Song6907ce22018-07-30 19:24:48 +00003934
Douglas Gregor2aa53772012-01-24 17:42:07 +00003935 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
3936 FromProtoEnd = From->protocol_end();
3937 FromProto != FromProtoEnd;
3938 ++FromProto, ++FromProtoLoc) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003939 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto));
Douglas Gregor2aa53772012-01-24 17:42:07 +00003940 if (!ToProto)
3941 return true;
3942 Protocols.push_back(ToProto);
3943 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc));
3944 }
Fangrui Song6907ce22018-07-30 19:24:48 +00003945
Douglas Gregor2aa53772012-01-24 17:42:07 +00003946 // FIXME: If we're merging, make sure that the protocol list is the same.
3947 To->setProtocolList(Protocols.data(), Protocols.size(),
3948 ProtocolLocs.data(), Importer.getToContext());
Fangrui Song6907ce22018-07-30 19:24:48 +00003949
Douglas Gregor2aa53772012-01-24 17:42:07 +00003950 // Import categories. When the categories themselves are imported, they'll
3951 // hook themselves into this interface.
Aaron Ballman15063e12014-03-13 21:35:02 +00003952 for (auto *Cat : From->known_categories())
3953 Importer.Import(Cat);
Fangrui Song6907ce22018-07-30 19:24:48 +00003954
Douglas Gregor2aa53772012-01-24 17:42:07 +00003955 // If we have an @implementation, import it as well.
3956 if (From->getImplementation()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003957 auto *Impl = cast_or_null<ObjCImplementationDecl>(
3958 Importer.Import(From->getImplementation()));
Douglas Gregor2aa53772012-01-24 17:42:07 +00003959 if (!Impl)
3960 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +00003961
Douglas Gregor2aa53772012-01-24 17:42:07 +00003962 To->setImplementation(Impl);
3963 }
3964
Douglas Gregor2e15c842012-02-01 21:00:38 +00003965 if (shouldForceImportDeclContext(Kind)) {
3966 // Import all of the members of this class.
3967 ImportDeclContext(From, /*ForceImport=*/true);
3968 }
Douglas Gregor2aa53772012-01-24 17:42:07 +00003969 return false;
3970}
3971
Douglas Gregor85f3f952015-07-07 03:57:15 +00003972ObjCTypeParamList *
3973ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
3974 if (!list)
3975 return nullptr;
3976
3977 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
3978 for (auto fromTypeParam : *list) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00003979 auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>(
3980 Importer.Import(fromTypeParam));
Douglas Gregor85f3f952015-07-07 03:57:15 +00003981 if (!toTypeParam)
3982 return nullptr;
3983
3984 toTypeParams.push_back(toTypeParam);
3985 }
3986
3987 return ObjCTypeParamList::create(Importer.getToContext(),
3988 Importer.Import(list->getLAngleLoc()),
3989 toTypeParams,
3990 Importer.Import(list->getRAngleLoc()));
3991}
3992
Douglas Gregor45635322010-02-16 01:20:57 +00003993Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
Douglas Gregor2aa53772012-01-24 17:42:07 +00003994 // If this class has a definition in the translation unit we're coming from,
3995 // but this particular declaration is not that definition, import the
3996 // definition and map to that.
3997 ObjCInterfaceDecl *Definition = D->getDefinition();
3998 if (Definition && Definition != D) {
3999 Decl *ImportedDef = Importer.Import(Definition);
4000 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00004001 return nullptr;
4002
Gabor Marton26f72a92018-07-12 09:42:05 +00004003 return Importer.MapImported(D, ImportedDef);
Douglas Gregor2aa53772012-01-24 17:42:07 +00004004 }
4005
Douglas Gregor45635322010-02-16 01:20:57 +00004006 // Import the major distinguishing characteristics of an @interface.
4007 DeclContext *DC, *LexicalDC;
4008 DeclarationName Name;
4009 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00004010 NamedDecl *ToD;
4011 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00004012 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00004013 if (ToD)
4014 return ToD;
Douglas Gregor45635322010-02-16 01:20:57 +00004015
Douglas Gregor2aa53772012-01-24 17:42:07 +00004016 // Look for an existing interface with the same name.
Craig Topper36250ad2014-05-12 05:36:57 +00004017 ObjCInterfaceDecl *MergeWithIface = nullptr;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004018 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00004019 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004020 for (auto *FoundDecl : FoundDecls) {
4021 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
Douglas Gregor45635322010-02-16 01:20:57 +00004022 continue;
Fangrui Song6907ce22018-07-30 19:24:48 +00004023
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004024 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
Douglas Gregor45635322010-02-16 01:20:57 +00004025 break;
4026 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004027
Douglas Gregor2aa53772012-01-24 17:42:07 +00004028 // Create an interface declaration, if one does not already exist.
Douglas Gregor45635322010-02-16 01:20:57 +00004029 ObjCInterfaceDecl *ToIface = MergeWithIface;
Douglas Gregor2aa53772012-01-24 17:42:07 +00004030 if (!ToIface) {
Gabor Marton26f72a92018-07-12 09:42:05 +00004031 if (GetImportedOrCreateDecl(
4032 ToIface, D, Importer.getToContext(), DC,
4033 Importer.Import(D->getAtStartLoc()), Name.getAsIdentifierInfo(),
4034 /*TypeParamList=*/nullptr,
4035 /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
4036 return ToIface;
Douglas Gregor2aa53772012-01-24 17:42:07 +00004037 ToIface->setLexicalDeclContext(LexicalDC);
4038 LexicalDC->addDeclInternal(ToIface);
Douglas Gregor45635322010-02-16 01:20:57 +00004039 }
Gabor Marton26f72a92018-07-12 09:42:05 +00004040 Importer.MapImported(D, ToIface);
Douglas Gregorab7f0b32015-07-07 06:20:12 +00004041 // Import the type parameter list after calling Imported, to avoid
4042 // loops when bringing in their DeclContext.
4043 ToIface->setTypeParamList(ImportObjCTypeParamList(
4044 D->getTypeParamListAsWritten()));
Fangrui Song6907ce22018-07-30 19:24:48 +00004045
Douglas Gregor2aa53772012-01-24 17:42:07 +00004046 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface))
Craig Topper36250ad2014-05-12 05:36:57 +00004047 return nullptr;
4048
Douglas Gregor98d156a2010-02-17 16:12:00 +00004049 return ToIface;
Douglas Gregor45635322010-02-16 01:20:57 +00004050}
4051
Douglas Gregor4da9d682010-12-07 15:32:12 +00004052Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004053 auto *Category = cast_or_null<ObjCCategoryDecl>(
4054 Importer.Import(D->getCategoryDecl()));
Douglas Gregor4da9d682010-12-07 15:32:12 +00004055 if (!Category)
Craig Topper36250ad2014-05-12 05:36:57 +00004056 return nullptr;
4057
Douglas Gregor4da9d682010-12-07 15:32:12 +00004058 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4059 if (!ToImpl) {
4060 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4061 if (!DC)
Craig Topper36250ad2014-05-12 05:36:57 +00004062 return nullptr;
4063
Argyrios Kyrtzidis4996f5f2011-12-09 00:31:40 +00004064 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc());
Gabor Marton26f72a92018-07-12 09:42:05 +00004065 if (GetImportedOrCreateDecl(
4066 ToImpl, D, Importer.getToContext(), DC,
4067 Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4068 Importer.Import(D->getLocation()),
4069 Importer.Import(D->getAtStartLoc()), CategoryNameLoc))
4070 return ToImpl;
4071
Douglas Gregor4da9d682010-12-07 15:32:12 +00004072 DeclContext *LexicalDC = DC;
4073 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4074 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4075 if (!LexicalDC)
Craig Topper36250ad2014-05-12 05:36:57 +00004076 return nullptr;
4077
Douglas Gregor4da9d682010-12-07 15:32:12 +00004078 ToImpl->setLexicalDeclContext(LexicalDC);
4079 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004080
Sean Callanan95e74be2011-10-21 02:57:43 +00004081 LexicalDC->addDeclInternal(ToImpl);
Douglas Gregor4da9d682010-12-07 15:32:12 +00004082 Category->setImplementation(ToImpl);
4083 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004084
Gabor Marton26f72a92018-07-12 09:42:05 +00004085 Importer.MapImported(D, ToImpl);
Douglas Gregor35fd7bc2010-12-08 16:41:55 +00004086 ImportDeclContext(D);
Douglas Gregor4da9d682010-12-07 15:32:12 +00004087 return ToImpl;
4088}
4089
Douglas Gregorda8025c2010-12-07 01:26:03 +00004090Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4091 // Find the corresponding interface.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004092 auto *Iface = cast_or_null<ObjCInterfaceDecl>(
4093 Importer.Import(D->getClassInterface()));
Douglas Gregorda8025c2010-12-07 01:26:03 +00004094 if (!Iface)
Craig Topper36250ad2014-05-12 05:36:57 +00004095 return nullptr;
Douglas Gregorda8025c2010-12-07 01:26:03 +00004096
4097 // Import the superclass, if any.
Craig Topper36250ad2014-05-12 05:36:57 +00004098 ObjCInterfaceDecl *Super = nullptr;
Douglas Gregorda8025c2010-12-07 01:26:03 +00004099 if (D->getSuperClass()) {
4100 Super = cast_or_null<ObjCInterfaceDecl>(
4101 Importer.Import(D->getSuperClass()));
4102 if (!Super)
Craig Topper36250ad2014-05-12 05:36:57 +00004103 return nullptr;
Douglas Gregorda8025c2010-12-07 01:26:03 +00004104 }
4105
4106 ObjCImplementationDecl *Impl = Iface->getImplementation();
4107 if (!Impl) {
4108 // We haven't imported an implementation yet. Create a new @implementation
4109 // now.
Gabor Marton26f72a92018-07-12 09:42:05 +00004110 if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
4111 Importer.ImportContext(D->getDeclContext()),
4112 Iface, Super, Importer.Import(D->getLocation()),
4113 Importer.Import(D->getAtStartLoc()),
4114 Importer.Import(D->getSuperClassLoc()),
4115 Importer.Import(D->getIvarLBraceLoc()),
4116 Importer.Import(D->getIvarRBraceLoc())))
4117 return Impl;
4118
Douglas Gregorda8025c2010-12-07 01:26:03 +00004119 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4120 DeclContext *LexicalDC
4121 = Importer.ImportContext(D->getLexicalDeclContext());
4122 if (!LexicalDC)
Craig Topper36250ad2014-05-12 05:36:57 +00004123 return nullptr;
Douglas Gregorda8025c2010-12-07 01:26:03 +00004124 Impl->setLexicalDeclContext(LexicalDC);
4125 }
Gabor Marton26f72a92018-07-12 09:42:05 +00004126
Douglas Gregorda8025c2010-12-07 01:26:03 +00004127 // Associate the implementation with the class it implements.
4128 Iface->setImplementation(Impl);
Gabor Marton26f72a92018-07-12 09:42:05 +00004129 Importer.MapImported(D, Iface->getImplementation());
Douglas Gregorda8025c2010-12-07 01:26:03 +00004130 } else {
Gabor Marton26f72a92018-07-12 09:42:05 +00004131 Importer.MapImported(D, Iface->getImplementation());
Douglas Gregorda8025c2010-12-07 01:26:03 +00004132
4133 // Verify that the existing @implementation has the same superclass.
4134 if ((Super && !Impl->getSuperClass()) ||
4135 (!Super && Impl->getSuperClass()) ||
Craig Topperdcfc60f2014-05-07 06:57:44 +00004136 (Super && Impl->getSuperClass() &&
4137 !declaresSameEntity(Super->getCanonicalDecl(),
4138 Impl->getSuperClass()))) {
4139 Importer.ToDiag(Impl->getLocation(),
4140 diag::err_odr_objc_superclass_inconsistent)
4141 << Iface->getDeclName();
4142 // FIXME: It would be nice to have the location of the superclass
4143 // below.
4144 if (Impl->getSuperClass())
4145 Importer.ToDiag(Impl->getLocation(),
4146 diag::note_odr_objc_superclass)
4147 << Impl->getSuperClass()->getDeclName();
4148 else
4149 Importer.ToDiag(Impl->getLocation(),
4150 diag::note_odr_objc_missing_superclass);
4151 if (D->getSuperClass())
4152 Importer.FromDiag(D->getLocation(),
Douglas Gregorda8025c2010-12-07 01:26:03 +00004153 diag::note_odr_objc_superclass)
Craig Topperdcfc60f2014-05-07 06:57:44 +00004154 << D->getSuperClass()->getDeclName();
4155 else
4156 Importer.FromDiag(D->getLocation(),
Douglas Gregorda8025c2010-12-07 01:26:03 +00004157 diag::note_odr_objc_missing_superclass);
Craig Topper36250ad2014-05-12 05:36:57 +00004158 return nullptr;
Douglas Gregorda8025c2010-12-07 01:26:03 +00004159 }
4160 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004161
Douglas Gregorda8025c2010-12-07 01:26:03 +00004162 // Import all of the members of this @implementation.
4163 ImportDeclContext(D);
4164
4165 return Impl;
4166}
4167
Douglas Gregora11c4582010-02-17 18:02:10 +00004168Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
4169 // Import the major distinguishing characteristics of an @property.
4170 DeclContext *DC, *LexicalDC;
4171 DeclarationName Name;
4172 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00004173 NamedDecl *ToD;
4174 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00004175 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00004176 if (ToD)
4177 return ToD;
Douglas Gregora11c4582010-02-17 18:02:10 +00004178
4179 // Check whether we have already imported this property.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004180 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00004181 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004182 for (auto *FoundDecl : FoundDecls) {
4183 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
Douglas Gregora11c4582010-02-17 18:02:10 +00004184 // Check property types.
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00004185 if (!Importer.IsStructurallyEquivalent(D->getType(),
Douglas Gregora11c4582010-02-17 18:02:10 +00004186 FoundProp->getType())) {
4187 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent)
4188 << Name << D->getType() << FoundProp->getType();
4189 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
4190 << FoundProp->getType();
Craig Topper36250ad2014-05-12 05:36:57 +00004191 return nullptr;
Douglas Gregora11c4582010-02-17 18:02:10 +00004192 }
4193
4194 // FIXME: Check property attributes, getters, setters, etc.?
4195
4196 // Consider these properties to be equivalent.
Gabor Marton26f72a92018-07-12 09:42:05 +00004197 Importer.MapImported(D, FoundProp);
Douglas Gregora11c4582010-02-17 18:02:10 +00004198 return FoundProp;
4199 }
4200 }
4201
4202 // Import the type.
Douglas Gregor813a0662015-06-19 18:14:38 +00004203 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo());
4204 if (!TSI)
Craig Topper36250ad2014-05-12 05:36:57 +00004205 return nullptr;
Douglas Gregora11c4582010-02-17 18:02:10 +00004206
4207 // Create the new property.
Gabor Marton26f72a92018-07-12 09:42:05 +00004208 ObjCPropertyDecl *ToProperty;
4209 if (GetImportedOrCreateDecl(
4210 ToProperty, D, Importer.getToContext(), DC, Loc,
4211 Name.getAsIdentifierInfo(), Importer.Import(D->getAtLoc()),
4212 Importer.Import(D->getLParenLoc()), Importer.Import(D->getType()),
4213 TSI, D->getPropertyImplementation()))
4214 return ToProperty;
4215
Douglas Gregora11c4582010-02-17 18:02:10 +00004216 ToProperty->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00004217 LexicalDC->addDeclInternal(ToProperty);
Douglas Gregora11c4582010-02-17 18:02:10 +00004218
4219 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
Fariborz Jahanian3bf0ded2010-06-22 23:20:40 +00004220 ToProperty->setPropertyAttributesAsWritten(
4221 D->getPropertyAttributesAsWritten());
Argyrios Kyrtzidis194b28e2017-03-16 18:25:40 +00004222 ToProperty->setGetterName(Importer.Import(D->getGetterName()),
4223 Importer.Import(D->getGetterNameLoc()));
4224 ToProperty->setSetterName(Importer.Import(D->getSetterName()),
4225 Importer.Import(D->getSetterNameLoc()));
Douglas Gregora11c4582010-02-17 18:02:10 +00004226 ToProperty->setGetterMethodDecl(
4227 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl())));
4228 ToProperty->setSetterMethodDecl(
4229 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl())));
4230 ToProperty->setPropertyIvarDecl(
4231 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl())));
4232 return ToProperty;
4233}
4234
Douglas Gregor14a49e22010-12-07 18:32:03 +00004235Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004236 auto *Property = cast_or_null<ObjCPropertyDecl>(
4237 Importer.Import(D->getPropertyDecl()));
Douglas Gregor14a49e22010-12-07 18:32:03 +00004238 if (!Property)
Craig Topper36250ad2014-05-12 05:36:57 +00004239 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004240
4241 DeclContext *DC = Importer.ImportContext(D->getDeclContext());
4242 if (!DC)
Craig Topper36250ad2014-05-12 05:36:57 +00004243 return nullptr;
4244
Douglas Gregor14a49e22010-12-07 18:32:03 +00004245 // Import the lexical declaration context.
4246 DeclContext *LexicalDC = DC;
4247 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4248 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4249 if (!LexicalDC)
Craig Topper36250ad2014-05-12 05:36:57 +00004250 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004251 }
4252
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004253 auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC);
Douglas Gregor14a49e22010-12-07 18:32:03 +00004254 if (!InImpl)
Craig Topper36250ad2014-05-12 05:36:57 +00004255 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004256
4257 // Import the ivar (for an @synthesize).
Craig Topper36250ad2014-05-12 05:36:57 +00004258 ObjCIvarDecl *Ivar = nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004259 if (D->getPropertyIvarDecl()) {
4260 Ivar = cast_or_null<ObjCIvarDecl>(
4261 Importer.Import(D->getPropertyIvarDecl()));
4262 if (!Ivar)
Craig Topper36250ad2014-05-12 05:36:57 +00004263 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004264 }
4265
4266 ObjCPropertyImplDecl *ToImpl
Manman Ren5b786402016-01-28 18:49:28 +00004267 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
4268 Property->getQueryKind());
Gabor Marton26f72a92018-07-12 09:42:05 +00004269 if (!ToImpl) {
4270 if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
Stephen Kellyf2ceec42018-08-09 21:08:08 +00004271 Importer.Import(D->getBeginLoc()),
Gabor Marton26f72a92018-07-12 09:42:05 +00004272 Importer.Import(D->getLocation()), Property,
4273 D->getPropertyImplementation(), Ivar,
4274 Importer.Import(D->getPropertyIvarDeclLoc())))
4275 return ToImpl;
4276
Douglas Gregor14a49e22010-12-07 18:32:03 +00004277 ToImpl->setLexicalDeclContext(LexicalDC);
Sean Callanan95e74be2011-10-21 02:57:43 +00004278 LexicalDC->addDeclInternal(ToImpl);
Douglas Gregor14a49e22010-12-07 18:32:03 +00004279 } else {
4280 // Check that we have the same kind of property implementation (@synthesize
4281 // vs. @dynamic).
4282 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00004283 Importer.ToDiag(ToImpl->getLocation(),
Douglas Gregor14a49e22010-12-07 18:32:03 +00004284 diag::err_odr_objc_property_impl_kind_inconsistent)
Fangrui Song6907ce22018-07-30 19:24:48 +00004285 << Property->getDeclName()
4286 << (ToImpl->getPropertyImplementation()
Douglas Gregor14a49e22010-12-07 18:32:03 +00004287 == ObjCPropertyImplDecl::Dynamic);
4288 Importer.FromDiag(D->getLocation(),
4289 diag::note_odr_objc_property_impl_kind)
4290 << D->getPropertyDecl()->getDeclName()
4291 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
Craig Topper36250ad2014-05-12 05:36:57 +00004292 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004293 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004294
4295 // For @synthesize, check that we have the same
Douglas Gregor14a49e22010-12-07 18:32:03 +00004296 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
4297 Ivar != ToImpl->getPropertyIvarDecl()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00004298 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
Douglas Gregor14a49e22010-12-07 18:32:03 +00004299 diag::err_odr_objc_synthesize_ivar_inconsistent)
4300 << Property->getDeclName()
4301 << ToImpl->getPropertyIvarDecl()->getDeclName()
4302 << Ivar->getDeclName();
Fangrui Song6907ce22018-07-30 19:24:48 +00004303 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
Douglas Gregor14a49e22010-12-07 18:32:03 +00004304 diag::note_odr_objc_synthesize_ivar_here)
4305 << D->getPropertyIvarDecl()->getDeclName();
Craig Topper36250ad2014-05-12 05:36:57 +00004306 return nullptr;
Douglas Gregor14a49e22010-12-07 18:32:03 +00004307 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004308
Douglas Gregor14a49e22010-12-07 18:32:03 +00004309 // Merge the existing implementation with the new implementation.
Gabor Marton26f72a92018-07-12 09:42:05 +00004310 Importer.MapImported(D, ToImpl);
Douglas Gregor14a49e22010-12-07 18:32:03 +00004311 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004312
Douglas Gregor14a49e22010-12-07 18:32:03 +00004313 return ToImpl;
4314}
4315
Douglas Gregora082a492010-11-30 19:14:50 +00004316Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
4317 // For template arguments, we adopt the translation unit as our declaration
4318 // context. This context will be fixed when the actual template declaration
4319 // is created.
Fangrui Song6907ce22018-07-30 19:24:48 +00004320
Douglas Gregora082a492010-11-30 19:14:50 +00004321 // FIXME: Import default argument.
Gabor Marton26f72a92018-07-12 09:42:05 +00004322 TemplateTypeParmDecl *ToD = nullptr;
4323 (void)GetImportedOrCreateDecl(
4324 ToD, D, Importer.getToContext(),
4325 Importer.getToContext().getTranslationUnitDecl(),
Stephen Kellyf2ceec42018-08-09 21:08:08 +00004326 Importer.Import(D->getBeginLoc()), Importer.Import(D->getLocation()),
Gabor Marton26f72a92018-07-12 09:42:05 +00004327 D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
4328 D->wasDeclaredWithTypename(), D->isParameterPack());
4329 return ToD;
Douglas Gregora082a492010-11-30 19:14:50 +00004330}
4331
4332Decl *
4333ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
4334 // Import the name of this declaration.
4335 DeclarationName Name = Importer.Import(D->getDeclName());
4336 if (D->getDeclName() && !Name)
Craig Topper36250ad2014-05-12 05:36:57 +00004337 return nullptr;
4338
Douglas Gregora082a492010-11-30 19:14:50 +00004339 // Import the location of this declaration.
4340 SourceLocation Loc = Importer.Import(D->getLocation());
4341
4342 // Import the type of this declaration.
4343 QualType T = Importer.Import(D->getType());
4344 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00004345 return nullptr;
4346
Douglas Gregora082a492010-11-30 19:14:50 +00004347 // Import type-source information.
4348 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4349 if (D->getTypeSourceInfo() && !TInfo)
Craig Topper36250ad2014-05-12 05:36:57 +00004350 return nullptr;
4351
Douglas Gregora082a492010-11-30 19:14:50 +00004352 // FIXME: Import default argument.
Gabor Marton26f72a92018-07-12 09:42:05 +00004353
4354 NonTypeTemplateParmDecl *ToD = nullptr;
4355 (void)GetImportedOrCreateDecl(
4356 ToD, D, Importer.getToContext(),
4357 Importer.getToContext().getTranslationUnitDecl(),
4358 Importer.Import(D->getInnerLocStart()), Loc, D->getDepth(),
4359 D->getPosition(), Name.getAsIdentifierInfo(), T, D->isParameterPack(),
4360 TInfo);
4361 return ToD;
Douglas Gregora082a492010-11-30 19:14:50 +00004362}
4363
4364Decl *
4365ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
4366 // Import the name of this declaration.
4367 DeclarationName Name = Importer.Import(D->getDeclName());
4368 if (D->getDeclName() && !Name)
Craig Topper36250ad2014-05-12 05:36:57 +00004369 return nullptr;
4370
Douglas Gregora082a492010-11-30 19:14:50 +00004371 // Import the location of this declaration.
4372 SourceLocation Loc = Importer.Import(D->getLocation());
Gabor Marton26f72a92018-07-12 09:42:05 +00004373
Douglas Gregora082a492010-11-30 19:14:50 +00004374 // Import template parameters.
4375 TemplateParameterList *TemplateParams
4376 = ImportTemplateParameterList(D->getTemplateParameters());
4377 if (!TemplateParams)
Craig Topper36250ad2014-05-12 05:36:57 +00004378 return nullptr;
4379
Douglas Gregora082a492010-11-30 19:14:50 +00004380 // FIXME: Import default argument.
Gabor Marton26f72a92018-07-12 09:42:05 +00004381
4382 TemplateTemplateParmDecl *ToD = nullptr;
4383 (void)GetImportedOrCreateDecl(
4384 ToD, D, Importer.getToContext(),
4385 Importer.getToContext().getTranslationUnitDecl(), Loc, D->getDepth(),
4386 D->getPosition(), D->isParameterPack(), Name.getAsIdentifierInfo(),
4387 TemplateParams);
4388 return ToD;
Douglas Gregora082a492010-11-30 19:14:50 +00004389}
4390
Gabor Marton9581c332018-05-23 13:53:36 +00004391// Returns the definition for a (forward) declaration of a ClassTemplateDecl, if
4392// it has any definition in the redecl chain.
4393static ClassTemplateDecl *getDefinition(ClassTemplateDecl *D) {
4394 CXXRecordDecl *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
4395 if (!ToTemplatedDef)
4396 return nullptr;
4397 ClassTemplateDecl *TemplateWithDef =
4398 ToTemplatedDef->getDescribedClassTemplate();
4399 return TemplateWithDef;
4400}
4401
Douglas Gregora082a492010-11-30 19:14:50 +00004402Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
Balazs Keri0c23dc52018-08-13 13:08:37 +00004403 bool IsFriend = D->getFriendObjectKind() != Decl::FOK_None;
4404
Douglas Gregora082a492010-11-30 19:14:50 +00004405 // If this record has a definition in the translation unit we're coming from,
4406 // but this particular declaration is not that definition, import the
4407 // definition and map to that.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004408 auto *Definition =
4409 cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition());
Balazs Keri0c23dc52018-08-13 13:08:37 +00004410 if (Definition && Definition != D->getTemplatedDecl() && !IsFriend) {
Douglas Gregora082a492010-11-30 19:14:50 +00004411 Decl *ImportedDef
4412 = Importer.Import(Definition->getDescribedClassTemplate());
4413 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00004414 return nullptr;
4415
Gabor Marton26f72a92018-07-12 09:42:05 +00004416 return Importer.MapImported(D, ImportedDef);
Douglas Gregora082a492010-11-30 19:14:50 +00004417 }
Gabor Marton9581c332018-05-23 13:53:36 +00004418
Douglas Gregora082a492010-11-30 19:14:50 +00004419 // Import the major distinguishing characteristics of this class template.
4420 DeclContext *DC, *LexicalDC;
4421 DeclarationName Name;
4422 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00004423 NamedDecl *ToD;
4424 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00004425 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00004426 if (ToD)
4427 return ToD;
Craig Topper36250ad2014-05-12 05:36:57 +00004428
Douglas Gregora082a492010-11-30 19:14:50 +00004429 // We may already have a template of the same name; try to find and match it.
4430 if (!DC->isFunctionOrMethod()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004431 SmallVector<NamedDecl *, 4> ConflictingDecls;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00004432 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00004433 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004434 for (auto *FoundDecl : FoundDecls) {
4435 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
Douglas Gregora082a492010-11-30 19:14:50 +00004436 continue;
Gabor Marton9581c332018-05-23 13:53:36 +00004437
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004438 Decl *Found = FoundDecl;
4439 if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) {
Gabor Marton9581c332018-05-23 13:53:36 +00004440
4441 // The class to be imported is a definition.
4442 if (D->isThisDeclarationADefinition()) {
4443 // Lookup will find the fwd decl only if that is more recent than the
4444 // definition. So, try to get the definition if that is available in
4445 // the redecl chain.
4446 ClassTemplateDecl *TemplateWithDef = getDefinition(FoundTemplate);
Balazs Keri0c23dc52018-08-13 13:08:37 +00004447 if (TemplateWithDef)
4448 FoundTemplate = TemplateWithDef;
4449 else
Gabor Marton9581c332018-05-23 13:53:36 +00004450 continue;
Gabor Marton9581c332018-05-23 13:53:36 +00004451 }
4452
Douglas Gregora082a492010-11-30 19:14:50 +00004453 if (IsStructuralMatch(D, FoundTemplate)) {
Balazs Keri0c23dc52018-08-13 13:08:37 +00004454 if (!IsFriend) {
4455 Importer.MapImported(D->getTemplatedDecl(),
4456 FoundTemplate->getTemplatedDecl());
4457 return Importer.MapImported(D, FoundTemplate);
4458 }
Aleksei Sidorin761c2242018-05-15 11:09:07 +00004459
Balazs Keri0c23dc52018-08-13 13:08:37 +00004460 continue;
Gabor Marton9581c332018-05-23 13:53:36 +00004461 }
Douglas Gregora082a492010-11-30 19:14:50 +00004462 }
Gabor Marton9581c332018-05-23 13:53:36 +00004463
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004464 ConflictingDecls.push_back(FoundDecl);
Douglas Gregora082a492010-11-30 19:14:50 +00004465 }
Gabor Marton9581c332018-05-23 13:53:36 +00004466
Douglas Gregora082a492010-11-30 19:14:50 +00004467 if (!ConflictingDecls.empty()) {
4468 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
Gabor Marton9581c332018-05-23 13:53:36 +00004469 ConflictingDecls.data(),
Douglas Gregora082a492010-11-30 19:14:50 +00004470 ConflictingDecls.size());
4471 }
Gabor Marton9581c332018-05-23 13:53:36 +00004472
Douglas Gregora082a492010-11-30 19:14:50 +00004473 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00004474 return nullptr;
Douglas Gregora082a492010-11-30 19:14:50 +00004475 }
4476
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004477 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
4478
Douglas Gregora082a492010-11-30 19:14:50 +00004479 // Create the declaration that is being templated.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004480 auto *ToTemplated = cast_or_null<CXXRecordDecl>(
4481 Importer.Import(FromTemplated));
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004482 if (!ToTemplated)
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00004483 return nullptr;
4484
Douglas Gregora082a492010-11-30 19:14:50 +00004485 // Create the class template declaration itself.
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004486 TemplateParameterList *TemplateParams =
4487 ImportTemplateParameterList(D->getTemplateParameters());
Douglas Gregora082a492010-11-30 19:14:50 +00004488 if (!TemplateParams)
Craig Topper36250ad2014-05-12 05:36:57 +00004489 return nullptr;
4490
Gabor Marton26f72a92018-07-12 09:42:05 +00004491 ClassTemplateDecl *D2;
4492 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
4493 TemplateParams, ToTemplated))
4494 return D2;
4495
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004496 ToTemplated->setDescribedClassTemplate(D2);
Fangrui Song6907ce22018-07-30 19:24:48 +00004497
Balazs Keri0c23dc52018-08-13 13:08:37 +00004498 if (ToTemplated->getPreviousDecl()) {
4499 assert(
4500 ToTemplated->getPreviousDecl()->getDescribedClassTemplate() &&
4501 "Missing described template");
4502 D2->setPreviousDecl(
4503 ToTemplated->getPreviousDecl()->getDescribedClassTemplate());
4504 }
Douglas Gregora082a492010-11-30 19:14:50 +00004505 D2->setAccess(D->getAccess());
4506 D2->setLexicalDeclContext(LexicalDC);
Balazs Keri0c23dc52018-08-13 13:08:37 +00004507 if (!IsFriend)
4508 LexicalDC->addDeclInternal(D2);
Fangrui Song6907ce22018-07-30 19:24:48 +00004509
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004510 if (FromTemplated->isCompleteDefinition() &&
4511 !ToTemplated->isCompleteDefinition()) {
Douglas Gregora082a492010-11-30 19:14:50 +00004512 // FIXME: Import definition!
4513 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004514
Douglas Gregora082a492010-11-30 19:14:50 +00004515 return D2;
4516}
4517
Douglas Gregore2e50d332010-12-01 01:36:18 +00004518Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl(
4519 ClassTemplateSpecializationDecl *D) {
4520 // If this record has a definition in the translation unit we're coming from,
4521 // but this particular declaration is not that definition, import the
4522 // definition and map to that.
4523 TagDecl *Definition = D->getDefinition();
4524 if (Definition && Definition != D) {
4525 Decl *ImportedDef = Importer.Import(Definition);
4526 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00004527 return nullptr;
4528
Gabor Marton26f72a92018-07-12 09:42:05 +00004529 return Importer.MapImported(D, ImportedDef);
Douglas Gregore2e50d332010-12-01 01:36:18 +00004530 }
4531
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004532 auto *ClassTemplate =
4533 cast_or_null<ClassTemplateDecl>(Importer.Import(
Douglas Gregore2e50d332010-12-01 01:36:18 +00004534 D->getSpecializedTemplate()));
4535 if (!ClassTemplate)
Craig Topper36250ad2014-05-12 05:36:57 +00004536 return nullptr;
4537
Douglas Gregore2e50d332010-12-01 01:36:18 +00004538 // Import the context of this declaration.
4539 DeclContext *DC = ClassTemplate->getDeclContext();
4540 if (!DC)
Craig Topper36250ad2014-05-12 05:36:57 +00004541 return nullptr;
4542
Douglas Gregore2e50d332010-12-01 01:36:18 +00004543 DeclContext *LexicalDC = DC;
4544 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4545 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4546 if (!LexicalDC)
Craig Topper36250ad2014-05-12 05:36:57 +00004547 return nullptr;
Douglas Gregore2e50d332010-12-01 01:36:18 +00004548 }
Fangrui Song6907ce22018-07-30 19:24:48 +00004549
Douglas Gregore2e50d332010-12-01 01:36:18 +00004550 // Import the location of this declaration.
Stephen Kellyf2ceec42018-08-09 21:08:08 +00004551 SourceLocation StartLoc = Importer.Import(D->getBeginLoc());
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004552 SourceLocation IdLoc = Importer.Import(D->getLocation());
Douglas Gregore2e50d332010-12-01 01:36:18 +00004553
4554 // Import template arguments.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004555 SmallVector<TemplateArgument, 2> TemplateArgs;
Fangrui Song6907ce22018-07-30 19:24:48 +00004556 if (ImportTemplateArguments(D->getTemplateArgs().data(),
Douglas Gregore2e50d332010-12-01 01:36:18 +00004557 D->getTemplateArgs().size(),
4558 TemplateArgs))
Craig Topper36250ad2014-05-12 05:36:57 +00004559 return nullptr;
4560
Douglas Gregore2e50d332010-12-01 01:36:18 +00004561 // Try to find an existing specialization with these template arguments.
Craig Topper36250ad2014-05-12 05:36:57 +00004562 void *InsertPos = nullptr;
Gabor Marton42e15de2018-08-22 11:52:14 +00004563 ClassTemplateSpecializationDecl *D2 = nullptr;
4564 ClassTemplatePartialSpecializationDecl *PartialSpec =
4565 dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
4566 if (PartialSpec)
4567 D2 = ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos);
4568 else
4569 D2 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
4570 ClassTemplateSpecializationDecl * const PrevDecl = D2;
4571 RecordDecl *FoundDef = D2 ? D2->getDefinition() : nullptr;
4572 if (FoundDef) {
4573 if (!D->isCompleteDefinition()) {
4574 // The "From" translation unit only had a forward declaration; call it
4575 // the same declaration.
4576 // TODO Handle the redecl chain properly!
4577 return Importer.MapImported(D, FoundDef);
Douglas Gregore2e50d332010-12-01 01:36:18 +00004578 }
Gabor Marton42e15de2018-08-22 11:52:14 +00004579
4580 if (IsStructuralMatch(D, FoundDef)) {
4581
4582 Importer.MapImported(D, FoundDef);
4583
4584 // Import those those default field initializers which have been
4585 // instantiated in the "From" context, but not in the "To" context.
4586 for (auto *FromField : D->fields())
4587 Importer.Import(FromField);
4588
4589 // Import those methods which have been instantiated in the
4590 // "From" context, but not in the "To" context.
4591 for (CXXMethodDecl *FromM : D->methods())
4592 Importer.Import(FromM);
4593
4594 // TODO Import instantiated default arguments.
4595 // TODO Import instantiated exception specifications.
4596 //
4597 // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint what
4598 // else could be fused during an AST merge.
4599
4600 return FoundDef;
4601 }
4602 } else { // We either couldn't find any previous specialization in the "To"
4603 // context, or we found one but without definition. Let's create a
4604 // new specialization and register that at the class template.
4605 if (PartialSpec) {
4606 // Import TemplateArgumentListInfo.
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004607 TemplateArgumentListInfo ToTAInfo;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004608 const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
4609 if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00004610 return nullptr;
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004611
4612 QualType CanonInjType = Importer.Import(
4613 PartialSpec->getInjectedSpecializationType());
4614 if (CanonInjType.isNull())
4615 return nullptr;
4616 CanonInjType = CanonInjType.getCanonicalType();
4617
4618 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4619 PartialSpec->getTemplateParameters());
4620 if (!ToTPList && PartialSpec->getTemplateParameters())
4621 return nullptr;
4622
Gabor Marton26f72a92018-07-12 09:42:05 +00004623 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
4624 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
4625 IdLoc, ToTPList, ClassTemplate,
4626 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
Gabor Marton42e15de2018-08-22 11:52:14 +00004627 ToTAInfo, CanonInjType,
4628 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
Gabor Marton26f72a92018-07-12 09:42:05 +00004629 return D2;
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004630
Gabor Marton42e15de2018-08-22 11:52:14 +00004631 // Update InsertPos, because preceding import calls may have invalidated
4632 // it by adding new specializations.
4633 if (!ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos))
4634 // Add this partial specialization to the class template.
4635 ClassTemplate->AddPartialSpecialization(
4636 cast<ClassTemplatePartialSpecializationDecl>(D2), InsertPos);
4637
4638 } else { // Not a partial specialization.
Gabor Marton26f72a92018-07-12 09:42:05 +00004639 if (GetImportedOrCreateDecl(
4640 D2, D, Importer.getToContext(), D->getTagKind(), DC, StartLoc,
Gabor Marton42e15de2018-08-22 11:52:14 +00004641 IdLoc, ClassTemplate, TemplateArgs, PrevDecl))
Gabor Marton26f72a92018-07-12 09:42:05 +00004642 return D2;
Gabor Marton42e15de2018-08-22 11:52:14 +00004643
4644 // Update InsertPos, because preceding import calls may have invalidated
4645 // it by adding new specializations.
4646 if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
4647 // Add this specialization to the class template.
4648 ClassTemplate->AddSpecialization(D2, InsertPos);
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004649 }
4650
Douglas Gregore2e50d332010-12-01 01:36:18 +00004651 D2->setSpecializationKind(D->getSpecializationKind());
4652
Douglas Gregore2e50d332010-12-01 01:36:18 +00004653 // Import the qualifier, if any.
Douglas Gregor14454802011-02-25 02:25:35 +00004654 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004655
Aleksei Sidorin855086d2017-01-23 09:30:36 +00004656 if (auto *TSI = D->getTypeAsWritten()) {
4657 TypeSourceInfo *TInfo = Importer.Import(TSI);
4658 if (!TInfo)
4659 return nullptr;
4660 D2->setTypeAsWritten(TInfo);
4661 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc()));
4662 D2->setExternLoc(Importer.Import(D->getExternLoc()));
4663 }
4664
4665 SourceLocation POI = Importer.Import(D->getPointOfInstantiation());
4666 if (POI.isValid())
4667 D2->setPointOfInstantiation(POI);
4668 else if (D->getPointOfInstantiation().isValid())
4669 return nullptr;
4670
4671 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
4672
Gabor Martonb14056b2018-05-25 11:21:24 +00004673 // Set the context of this specialization/instantiation.
Douglas Gregore2e50d332010-12-01 01:36:18 +00004674 D2->setLexicalDeclContext(LexicalDC);
Gabor Martonb14056b2018-05-25 11:21:24 +00004675
4676 // Add to the DC only if it was an explicit specialization/instantiation.
4677 if (D2->isExplicitInstantiationOrSpecialization()) {
4678 LexicalDC->addDeclInternal(D2);
4679 }
Douglas Gregore2e50d332010-12-01 01:36:18 +00004680 }
John McCallf937c022011-10-07 06:10:15 +00004681 if (D->isCompleteDefinition() && ImportDefinition(D, D2))
Craig Topper36250ad2014-05-12 05:36:57 +00004682 return nullptr;
4683
Douglas Gregore2e50d332010-12-01 01:36:18 +00004684 return D2;
4685}
4686
Larisse Voufo39a1e502013-08-06 01:03:05 +00004687Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
4688 // If this variable has a definition in the translation unit we're coming
4689 // from,
4690 // but this particular declaration is not that definition, import the
4691 // definition and map to that.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004692 auto *Definition =
Larisse Voufo39a1e502013-08-06 01:03:05 +00004693 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition());
4694 if (Definition && Definition != D->getTemplatedDecl()) {
4695 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate());
4696 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00004697 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004698
Gabor Marton26f72a92018-07-12 09:42:05 +00004699 return Importer.MapImported(D, ImportedDef);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004700 }
4701
4702 // Import the major distinguishing characteristics of this variable template.
4703 DeclContext *DC, *LexicalDC;
4704 DeclarationName Name;
4705 SourceLocation Loc;
Sean Callanan59721b32015-04-28 18:41:46 +00004706 NamedDecl *ToD;
4707 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
Craig Topper36250ad2014-05-12 05:36:57 +00004708 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00004709 if (ToD)
4710 return ToD;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004711
4712 // We may already have a template of the same name; try to find and match it.
4713 assert(!DC->isFunctionOrMethod() &&
4714 "Variable templates cannot be declared at function scope");
4715 SmallVector<NamedDecl *, 4> ConflictingDecls;
4716 SmallVector<NamedDecl *, 2> FoundDecls;
Sean Callanan49475322014-12-10 03:09:41 +00004717 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004718 for (auto *FoundDecl : FoundDecls) {
4719 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
Larisse Voufo39a1e502013-08-06 01:03:05 +00004720 continue;
4721
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004722 Decl *Found = FoundDecl;
4723 if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004724 if (IsStructuralMatch(D, FoundTemplate)) {
4725 // The variable templates structurally match; call it the same template.
Gabor Marton26f72a92018-07-12 09:42:05 +00004726 Importer.MapImported(D->getTemplatedDecl(),
4727 FoundTemplate->getTemplatedDecl());
4728 return Importer.MapImported(D, FoundTemplate);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004729 }
4730 }
4731
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004732 ConflictingDecls.push_back(FoundDecl);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004733 }
4734
4735 if (!ConflictingDecls.empty()) {
4736 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary,
4737 ConflictingDecls.data(),
4738 ConflictingDecls.size());
4739 }
4740
4741 if (!Name)
Craig Topper36250ad2014-05-12 05:36:57 +00004742 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004743
4744 VarDecl *DTemplated = D->getTemplatedDecl();
4745
4746 // Import the type.
4747 QualType T = Importer.Import(DTemplated->getType());
4748 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00004749 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004750
4751 // Create the declaration that is being templated.
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004752 auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated));
4753 if (!ToTemplated)
Craig Topper36250ad2014-05-12 05:36:57 +00004754 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004755
4756 // Create the variable template declaration itself.
4757 TemplateParameterList *TemplateParams =
4758 ImportTemplateParameterList(D->getTemplateParameters());
4759 if (!TemplateParams)
Craig Topper36250ad2014-05-12 05:36:57 +00004760 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004761
Gabor Marton26f72a92018-07-12 09:42:05 +00004762 VarTemplateDecl *ToVarTD;
4763 if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
4764 Name, TemplateParams, ToTemplated))
4765 return ToVarTD;
4766
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004767 ToTemplated->setDescribedVarTemplate(ToVarTD);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004768
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004769 ToVarTD->setAccess(D->getAccess());
4770 ToVarTD->setLexicalDeclContext(LexicalDC);
4771 LexicalDC->addDeclInternal(ToVarTD);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004772
Larisse Voufo39a1e502013-08-06 01:03:05 +00004773 if (DTemplated->isThisDeclarationADefinition() &&
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004774 !ToTemplated->isThisDeclarationADefinition()) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004775 // FIXME: Import definition!
4776 }
4777
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004778 return ToVarTD;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004779}
4780
4781Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl(
4782 VarTemplateSpecializationDecl *D) {
4783 // If this record has a definition in the translation unit we're coming from,
4784 // but this particular declaration is not that definition, import the
4785 // definition and map to that.
4786 VarDecl *Definition = D->getDefinition();
4787 if (Definition && Definition != D) {
4788 Decl *ImportedDef = Importer.Import(Definition);
4789 if (!ImportedDef)
Craig Topper36250ad2014-05-12 05:36:57 +00004790 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004791
Gabor Marton26f72a92018-07-12 09:42:05 +00004792 return Importer.MapImported(D, ImportedDef);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004793 }
4794
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004795 auto *VarTemplate = cast_or_null<VarTemplateDecl>(
Larisse Voufo39a1e502013-08-06 01:03:05 +00004796 Importer.Import(D->getSpecializedTemplate()));
4797 if (!VarTemplate)
Craig Topper36250ad2014-05-12 05:36:57 +00004798 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004799
4800 // Import the context of this declaration.
4801 DeclContext *DC = VarTemplate->getDeclContext();
4802 if (!DC)
Craig Topper36250ad2014-05-12 05:36:57 +00004803 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004804
4805 DeclContext *LexicalDC = DC;
4806 if (D->getDeclContext() != D->getLexicalDeclContext()) {
4807 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext());
4808 if (!LexicalDC)
Craig Topper36250ad2014-05-12 05:36:57 +00004809 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004810 }
4811
4812 // Import the location of this declaration.
Stephen Kellyf2ceec42018-08-09 21:08:08 +00004813 SourceLocation StartLoc = Importer.Import(D->getBeginLoc());
Larisse Voufo39a1e502013-08-06 01:03:05 +00004814 SourceLocation IdLoc = Importer.Import(D->getLocation());
4815
4816 // Import template arguments.
4817 SmallVector<TemplateArgument, 2> TemplateArgs;
4818 if (ImportTemplateArguments(D->getTemplateArgs().data(),
4819 D->getTemplateArgs().size(), TemplateArgs))
Craig Topper36250ad2014-05-12 05:36:57 +00004820 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004821
4822 // Try to find an existing specialization with these template arguments.
Craig Topper36250ad2014-05-12 05:36:57 +00004823 void *InsertPos = nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004824 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
Craig Topper7e0daca2014-06-26 04:58:53 +00004825 TemplateArgs, InsertPos);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004826 if (D2) {
4827 // We already have a variable template specialization with these template
4828 // arguments.
4829
4830 // FIXME: Check for specialization vs. instantiation errors.
4831
4832 if (VarDecl *FoundDef = D2->getDefinition()) {
4833 if (!D->isThisDeclarationADefinition() ||
4834 IsStructuralMatch(D, FoundDef)) {
4835 // The record types structurally match, or the "from" translation
4836 // unit only had a forward declaration anyway; call it the same
4837 // variable.
Gabor Marton26f72a92018-07-12 09:42:05 +00004838 return Importer.MapImported(D, FoundDef);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004839 }
4840 }
4841 } else {
Larisse Voufo39a1e502013-08-06 01:03:05 +00004842 // Import the type.
4843 QualType T = Importer.Import(D->getType());
4844 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00004845 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004846
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004847 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo());
4848 if (D->getTypeSourceInfo() && !TInfo)
4849 return nullptr;
4850
4851 TemplateArgumentListInfo ToTAInfo;
4852 if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
4853 return nullptr;
4854
4855 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004856 // Create a new specialization.
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004857 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
4858 // Import TemplateArgumentListInfo
4859 TemplateArgumentListInfo ArgInfos;
4860 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
4861 // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
4862 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
4863 return nullptr;
4864
4865 TemplateParameterList *ToTPList = ImportTemplateParameterList(
4866 FromPartial->getTemplateParameters());
4867 if (!ToTPList)
4868 return nullptr;
4869
Gabor Marton26f72a92018-07-12 09:42:05 +00004870 PartVarSpecDecl *ToPartial;
4871 if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
4872 StartLoc, IdLoc, ToTPList, VarTemplate, T,
4873 TInfo, D->getStorageClass(), TemplateArgs,
4874 ArgInfos))
4875 return ToPartial;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004876
4877 auto *FromInst = FromPartial->getInstantiatedFromMember();
4878 auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst));
4879 if (FromInst && !ToInst)
4880 return nullptr;
4881
4882 ToPartial->setInstantiatedFromMember(ToInst);
4883 if (FromPartial->isMemberSpecialization())
4884 ToPartial->setMemberSpecialization();
4885
4886 D2 = ToPartial;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004887 } else { // Full specialization
Gabor Marton26f72a92018-07-12 09:42:05 +00004888 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, StartLoc,
4889 IdLoc, VarTemplate, T, TInfo,
4890 D->getStorageClass(), TemplateArgs))
4891 return D2;
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004892 }
4893
4894 SourceLocation POI = D->getPointOfInstantiation();
4895 if (POI.isValid())
4896 D2->setPointOfInstantiation(Importer.Import(POI));
4897
Larisse Voufo39a1e502013-08-06 01:03:05 +00004898 D2->setSpecializationKind(D->getSpecializationKind());
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004899 D2->setTemplateArgsInfo(ToTAInfo);
Larisse Voufo39a1e502013-08-06 01:03:05 +00004900
4901 // Add this specialization to the class template.
4902 VarTemplate->AddSpecialization(D2, InsertPos);
4903
4904 // Import the qualifier, if any.
4905 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
4906
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004907 if (D->isConstexpr())
4908 D2->setConstexpr(true);
4909
Larisse Voufo39a1e502013-08-06 01:03:05 +00004910 // Add the specialization to this context.
4911 D2->setLexicalDeclContext(LexicalDC);
4912 LexicalDC->addDeclInternal(D2);
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004913
4914 D2->setAccess(D->getAccess());
Larisse Voufo39a1e502013-08-06 01:03:05 +00004915 }
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004916
Aleksei Sidorin4c05f142018-02-14 11:18:00 +00004917 // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if
4918 // declaration has initializer. Should this be fixed in the AST?.. Anyway,
4919 // we have to check the declaration for initializer - otherwise, it won't be
4920 // imported.
4921 if ((D->isThisDeclarationADefinition() || D->hasInit()) &&
4922 ImportDefinition(D, D2))
Craig Topper36250ad2014-05-12 05:36:57 +00004923 return nullptr;
Larisse Voufo39a1e502013-08-06 01:03:05 +00004924
4925 return D2;
4926}
4927
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004928Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
4929 DeclContext *DC, *LexicalDC;
4930 DeclarationName Name;
4931 SourceLocation Loc;
4932 NamedDecl *ToD;
4933
4934 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4935 return nullptr;
4936
4937 if (ToD)
4938 return ToD;
4939
4940 // Try to find a function in our own ("to") context with the same name, same
4941 // type, and in the same context as the function we're importing.
4942 if (!LexicalDC->isFunctionOrMethod()) {
4943 unsigned IDNS = Decl::IDNS_Ordinary;
4944 SmallVector<NamedDecl *, 2> FoundDecls;
4945 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004946 for (auto *FoundDecl : FoundDecls) {
4947 if (!FoundDecl->isInIdentifierNamespace(IDNS))
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004948 continue;
4949
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004950 if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004951 if (FoundFunction->hasExternalFormalLinkage() &&
4952 D->hasExternalFormalLinkage()) {
4953 if (IsStructuralMatch(D, FoundFunction)) {
Gabor Marton26f72a92018-07-12 09:42:05 +00004954 Importer.MapImported(D, FoundFunction);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004955 // FIXME: Actually try to merge the body and other attributes.
4956 return FoundFunction;
4957 }
4958 }
4959 }
4960 }
4961 }
4962
4963 TemplateParameterList *Params =
4964 ImportTemplateParameterList(D->getTemplateParameters());
4965 if (!Params)
4966 return nullptr;
4967
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00004968 auto *TemplatedFD =
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004969 cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl()));
4970 if (!TemplatedFD)
4971 return nullptr;
4972
Gabor Marton26f72a92018-07-12 09:42:05 +00004973 FunctionTemplateDecl *ToFunc;
4974 if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
4975 Params, TemplatedFD))
4976 return ToFunc;
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004977
4978 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
4979 ToFunc->setAccess(D->getAccess());
4980 ToFunc->setLexicalDeclContext(LexicalDC);
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00004981
4982 LexicalDC->addDeclInternal(ToFunc);
4983 return ToFunc;
4984}
4985
Douglas Gregor7eeb5972010-02-11 19:21:55 +00004986//----------------------------------------------------------------------------
4987// Import Statements
4988//----------------------------------------------------------------------------
4989
Sean Callanan59721b32015-04-28 18:41:46 +00004990DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) {
4991 if (DG.isNull())
4992 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
4993 size_t NumDecls = DG.end() - DG.begin();
4994 SmallVector<Decl *, 1> ToDecls(NumDecls);
4995 auto &_Importer = this->Importer;
4996 std::transform(DG.begin(), DG.end(), ToDecls.begin(),
4997 [&_Importer](Decl *D) -> Decl * {
4998 return _Importer.Import(D);
4999 });
5000 return DeclGroupRef::Create(Importer.getToContext(),
5001 ToDecls.begin(),
5002 NumDecls);
5003}
5004
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005005Stmt *ASTNodeImporter::VisitStmt(Stmt *S) {
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005006 Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
5007 << S->getStmtClassName();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005008 return nullptr;
5009}
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005010
5011Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5012 SmallVector<IdentifierInfo *, 4> Names;
5013 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5014 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
Gabor Horvath27f5ff62017-03-13 15:32:24 +00005015 // ToII is nullptr when no symbolic name is given for output operand
5016 // see ParseStmtAsm::ParseAsmOperandsOpt
5017 if (!ToII && S->getOutputIdentifier(I))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005018 return nullptr;
5019 Names.push_back(ToII);
5020 }
5021 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5022 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
Gabor Horvath27f5ff62017-03-13 15:32:24 +00005023 // ToII is nullptr when no symbolic name is given for input operand
5024 // see ParseStmtAsm::ParseAsmOperandsOpt
5025 if (!ToII && S->getInputIdentifier(I))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005026 return nullptr;
5027 Names.push_back(ToII);
5028 }
5029
5030 SmallVector<StringLiteral *, 4> Clobbers;
5031 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005032 auto *Clobber = cast_or_null<StringLiteral>(
5033 Importer.Import(S->getClobberStringLiteral(I)));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005034 if (!Clobber)
5035 return nullptr;
5036 Clobbers.push_back(Clobber);
5037 }
5038
5039 SmallVector<StringLiteral *, 4> Constraints;
5040 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005041 auto *Output = cast_or_null<StringLiteral>(
5042 Importer.Import(S->getOutputConstraintLiteral(I)));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005043 if (!Output)
5044 return nullptr;
5045 Constraints.push_back(Output);
5046 }
5047
5048 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005049 auto *Input = cast_or_null<StringLiteral>(
5050 Importer.Import(S->getInputConstraintLiteral(I)));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005051 if (!Input)
5052 return nullptr;
5053 Constraints.push_back(Input);
5054 }
5055
5056 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs());
Aleksei Sidorina693b372016-09-28 10:16:56 +00005057 if (ImportContainerChecked(S->outputs(), Exprs))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005058 return nullptr;
5059
Aleksei Sidorina693b372016-09-28 10:16:56 +00005060 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005061 return nullptr;
5062
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005063 auto *AsmStr = cast_or_null<StringLiteral>(
5064 Importer.Import(S->getAsmString()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005065 if (!AsmStr)
5066 return nullptr;
5067
5068 return new (Importer.getToContext()) GCCAsmStmt(
5069 Importer.getToContext(),
5070 Importer.Import(S->getAsmLoc()),
5071 S->isSimple(),
5072 S->isVolatile(),
5073 S->getNumOutputs(),
5074 S->getNumInputs(),
5075 Names.data(),
5076 Constraints.data(),
5077 Exprs.data(),
5078 AsmStr,
5079 S->getNumClobbers(),
5080 Clobbers.data(),
5081 Importer.Import(S->getRParenLoc()));
5082}
5083
Sean Callanan59721b32015-04-28 18:41:46 +00005084Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
5085 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup());
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005086 for (auto *ToD : ToDG) {
Sean Callanan59721b32015-04-28 18:41:46 +00005087 if (!ToD)
5088 return nullptr;
5089 }
Stephen Kellya6e43582018-08-09 21:05:56 +00005090 SourceLocation ToStartLoc = Importer.Import(S->getBeginLoc());
Sean Callanan59721b32015-04-28 18:41:46 +00005091 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc());
5092 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc);
5093}
5094
5095Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) {
5096 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc());
5097 return new (Importer.getToContext()) NullStmt(ToSemiLoc,
5098 S->hasLeadingEmptyMacro());
5099}
5100
5101Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005102 SmallVector<Stmt *, 8> ToStmts(S->size());
Aleksei Sidorina693b372016-09-28 10:16:56 +00005103
5104 if (ImportContainerChecked(S->body(), ToStmts))
Sean Callanan8bca9962016-03-28 21:43:01 +00005105 return nullptr;
5106
Sean Callanan59721b32015-04-28 18:41:46 +00005107 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc());
5108 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc());
Benjamin Kramer07420902017-12-24 16:24:20 +00005109 return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc,
5110 ToRBraceLoc);
Sean Callanan59721b32015-04-28 18:41:46 +00005111}
5112
5113Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
5114 Expr *ToLHS = Importer.Import(S->getLHS());
5115 if (!ToLHS)
5116 return nullptr;
5117 Expr *ToRHS = Importer.Import(S->getRHS());
5118 if (!ToRHS && S->getRHS())
5119 return nullptr;
Gabor Horvath480892b2017-10-18 09:25:18 +00005120 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5121 if (!ToSubStmt && S->getSubStmt())
5122 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00005123 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc());
5124 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc());
5125 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005126 auto *ToStmt = new (Importer.getToContext())
Gabor Horvath480892b2017-10-18 09:25:18 +00005127 CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc);
5128 ToStmt->setSubStmt(ToSubStmt);
5129 return ToStmt;
Sean Callanan59721b32015-04-28 18:41:46 +00005130}
5131
5132Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
5133 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc());
5134 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5135 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5136 if (!ToSubStmt && S->getSubStmt())
5137 return nullptr;
5138 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc,
5139 ToSubStmt);
5140}
5141
5142Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
5143 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc());
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005144 auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl()));
Sean Callanan59721b32015-04-28 18:41:46 +00005145 if (!ToLabelDecl && S->getDecl())
5146 return nullptr;
5147 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5148 if (!ToSubStmt && S->getSubStmt())
5149 return nullptr;
5150 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl,
5151 ToSubStmt);
5152}
5153
5154Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
5155 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc());
5156 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
5157 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
Aleksei Sidorin8f266db2018-05-08 12:45:21 +00005158 if (ImportContainerChecked(FromAttrs, ToAttrs))
5159 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00005160 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5161 if (!ToSubStmt && S->getSubStmt())
5162 return nullptr;
5163 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc,
5164 ToAttrs, ToSubStmt);
5165}
5166
5167Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) {
5168 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc());
Richard Smitha547eb22016-07-14 00:11:03 +00005169 Stmt *ToInit = Importer.Import(S->getInit());
5170 if (!ToInit && S->getInit())
5171 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00005172 VarDecl *ToConditionVariable = nullptr;
5173 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5174 ToConditionVariable =
5175 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5176 if (!ToConditionVariable)
5177 return nullptr;
5178 }
5179 Expr *ToCondition = Importer.Import(S->getCond());
5180 if (!ToCondition && S->getCond())
5181 return nullptr;
5182 Stmt *ToThenStmt = Importer.Import(S->getThen());
5183 if (!ToThenStmt && S->getThen())
5184 return nullptr;
5185 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc());
5186 Stmt *ToElseStmt = Importer.Import(S->getElse());
5187 if (!ToElseStmt && S->getElse())
5188 return nullptr;
5189 return new (Importer.getToContext()) IfStmt(Importer.getToContext(),
Richard Smithb130fe72016-06-23 19:16:49 +00005190 ToIfLoc, S->isConstexpr(),
Richard Smitha547eb22016-07-14 00:11:03 +00005191 ToInit,
Richard Smithb130fe72016-06-23 19:16:49 +00005192 ToConditionVariable,
Sean Callanan59721b32015-04-28 18:41:46 +00005193 ToCondition, ToThenStmt,
5194 ToElseLoc, ToElseStmt);
5195}
5196
5197Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
Richard Smitha547eb22016-07-14 00:11:03 +00005198 Stmt *ToInit = Importer.Import(S->getInit());
5199 if (!ToInit && S->getInit())
5200 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00005201 VarDecl *ToConditionVariable = nullptr;
5202 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5203 ToConditionVariable =
5204 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5205 if (!ToConditionVariable)
5206 return nullptr;
5207 }
5208 Expr *ToCondition = Importer.Import(S->getCond());
5209 if (!ToCondition && S->getCond())
5210 return nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005211 auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
Richard Smitha547eb22016-07-14 00:11:03 +00005212 Importer.getToContext(), ToInit,
5213 ToConditionVariable, ToCondition);
Sean Callanan59721b32015-04-28 18:41:46 +00005214 Stmt *ToBody = Importer.Import(S->getBody());
5215 if (!ToBody && S->getBody())
5216 return nullptr;
5217 ToStmt->setBody(ToBody);
5218 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc()));
5219 // Now we have to re-chain the cases.
5220 SwitchCase *LastChainedSwitchCase = nullptr;
5221 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
5222 SC = SC->getNextSwitchCase()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005223 auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC));
Sean Callanan59721b32015-04-28 18:41:46 +00005224 if (!ToSC)
5225 return nullptr;
5226 if (LastChainedSwitchCase)
5227 LastChainedSwitchCase->setNextSwitchCase(ToSC);
5228 else
5229 ToStmt->setSwitchCaseList(ToSC);
5230 LastChainedSwitchCase = ToSC;
5231 }
5232 return ToStmt;
5233}
5234
5235Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
5236 VarDecl *ToConditionVariable = nullptr;
5237 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5238 ToConditionVariable =
5239 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5240 if (!ToConditionVariable)
5241 return nullptr;
5242 }
5243 Expr *ToCondition = Importer.Import(S->getCond());
5244 if (!ToCondition && S->getCond())
5245 return nullptr;
5246 Stmt *ToBody = Importer.Import(S->getBody());
5247 if (!ToBody && S->getBody())
5248 return nullptr;
5249 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5250 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(),
5251 ToConditionVariable,
5252 ToCondition, ToBody,
5253 ToWhileLoc);
5254}
5255
5256Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) {
5257 Stmt *ToBody = Importer.Import(S->getBody());
5258 if (!ToBody && S->getBody())
5259 return nullptr;
5260 Expr *ToCondition = Importer.Import(S->getCond());
5261 if (!ToCondition && S->getCond())
5262 return nullptr;
5263 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc());
5264 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc());
5265 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5266 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition,
5267 ToDoLoc, ToWhileLoc,
5268 ToRParenLoc);
5269}
5270
5271Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) {
5272 Stmt *ToInit = Importer.Import(S->getInit());
5273 if (!ToInit && S->getInit())
5274 return nullptr;
5275 Expr *ToCondition = Importer.Import(S->getCond());
5276 if (!ToCondition && S->getCond())
5277 return nullptr;
5278 VarDecl *ToConditionVariable = nullptr;
5279 if (VarDecl *FromConditionVariable = S->getConditionVariable()) {
5280 ToConditionVariable =
5281 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable));
5282 if (!ToConditionVariable)
5283 return nullptr;
5284 }
5285 Expr *ToInc = Importer.Import(S->getInc());
5286 if (!ToInc && S->getInc())
5287 return nullptr;
5288 Stmt *ToBody = Importer.Import(S->getBody());
5289 if (!ToBody && S->getBody())
5290 return nullptr;
5291 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5292 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc());
5293 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5294 return new (Importer.getToContext()) ForStmt(Importer.getToContext(),
5295 ToInit, ToCondition,
5296 ToConditionVariable,
5297 ToInc, ToBody,
5298 ToForLoc, ToLParenLoc,
5299 ToRParenLoc);
5300}
5301
5302Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
5303 LabelDecl *ToLabel = nullptr;
5304 if (LabelDecl *FromLabel = S->getLabel()) {
5305 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel));
5306 if (!ToLabel)
5307 return nullptr;
5308 }
5309 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5310 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc());
5311 return new (Importer.getToContext()) GotoStmt(ToLabel,
5312 ToGotoLoc, ToLabelLoc);
5313}
5314
5315Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
5316 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc());
5317 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc());
5318 Expr *ToTarget = Importer.Import(S->getTarget());
5319 if (!ToTarget && S->getTarget())
5320 return nullptr;
5321 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc,
5322 ToTarget);
5323}
5324
5325Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
5326 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc());
5327 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc);
5328}
5329
5330Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
5331 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc());
5332 return new (Importer.getToContext()) BreakStmt(ToBreakLoc);
5333}
5334
5335Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
5336 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc());
5337 Expr *ToRetExpr = Importer.Import(S->getRetValue());
5338 if (!ToRetExpr && S->getRetValue())
5339 return nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005340 auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate());
5341 auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate));
Sean Callanan59721b32015-04-28 18:41:46 +00005342 if (!ToNRVOCandidate && NRVOCandidate)
5343 return nullptr;
5344 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr,
5345 ToNRVOCandidate);
5346}
5347
5348Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
5349 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc());
5350 VarDecl *ToExceptionDecl = nullptr;
5351 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) {
5352 ToExceptionDecl =
5353 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5354 if (!ToExceptionDecl)
5355 return nullptr;
5356 }
5357 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock());
5358 if (!ToHandlerBlock && S->getHandlerBlock())
5359 return nullptr;
5360 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc,
5361 ToExceptionDecl,
5362 ToHandlerBlock);
5363}
5364
5365Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
5366 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc());
5367 Stmt *ToTryBlock = Importer.Import(S->getTryBlock());
5368 if (!ToTryBlock && S->getTryBlock())
5369 return nullptr;
5370 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
5371 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
5372 CXXCatchStmt *FromHandler = S->getHandler(HI);
5373 if (Stmt *ToHandler = Importer.Import(FromHandler))
5374 ToHandlers[HI] = ToHandler;
5375 else
5376 return nullptr;
5377 }
5378 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock,
5379 ToHandlers);
5380}
5381
5382Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005383 auto *ToRange =
Sean Callanan59721b32015-04-28 18:41:46 +00005384 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt()));
5385 if (!ToRange && S->getRangeStmt())
5386 return nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005387 auto *ToBegin =
Richard Smith01694c32016-03-20 10:33:40 +00005388 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt()));
5389 if (!ToBegin && S->getBeginStmt())
5390 return nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005391 auto *ToEnd =
Richard Smith01694c32016-03-20 10:33:40 +00005392 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt()));
5393 if (!ToEnd && S->getEndStmt())
Sean Callanan59721b32015-04-28 18:41:46 +00005394 return nullptr;
5395 Expr *ToCond = Importer.Import(S->getCond());
5396 if (!ToCond && S->getCond())
5397 return nullptr;
5398 Expr *ToInc = Importer.Import(S->getInc());
5399 if (!ToInc && S->getInc())
5400 return nullptr;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005401 auto *ToLoopVar =
Sean Callanan59721b32015-04-28 18:41:46 +00005402 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt()));
5403 if (!ToLoopVar && S->getLoopVarStmt())
5404 return nullptr;
5405 Stmt *ToBody = Importer.Import(S->getBody());
5406 if (!ToBody && S->getBody())
5407 return nullptr;
5408 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
Richard Smith9f690bd2015-10-27 06:02:45 +00005409 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc());
Sean Callanan59721b32015-04-28 18:41:46 +00005410 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc());
5411 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
Richard Smith01694c32016-03-20 10:33:40 +00005412 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd,
Sean Callanan59721b32015-04-28 18:41:46 +00005413 ToCond, ToInc,
5414 ToLoopVar, ToBody,
Richard Smith9f690bd2015-10-27 06:02:45 +00005415 ToForLoc, ToCoawaitLoc,
5416 ToColonLoc, ToRParenLoc);
Sean Callanan59721b32015-04-28 18:41:46 +00005417}
5418
5419Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
5420 Stmt *ToElem = Importer.Import(S->getElement());
5421 if (!ToElem && S->getElement())
5422 return nullptr;
5423 Expr *ToCollect = Importer.Import(S->getCollection());
5424 if (!ToCollect && S->getCollection())
5425 return nullptr;
5426 Stmt *ToBody = Importer.Import(S->getBody());
5427 if (!ToBody && S->getBody())
5428 return nullptr;
5429 SourceLocation ToForLoc = Importer.Import(S->getForLoc());
5430 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5431 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem,
5432 ToCollect,
5433 ToBody, ToForLoc,
5434 ToRParenLoc);
5435}
5436
5437Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
5438 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc());
5439 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc());
5440 VarDecl *ToExceptionDecl = nullptr;
5441 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) {
5442 ToExceptionDecl =
5443 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl));
5444 if (!ToExceptionDecl)
5445 return nullptr;
5446 }
5447 Stmt *ToBody = Importer.Import(S->getCatchBody());
5448 if (!ToBody && S->getCatchBody())
5449 return nullptr;
5450 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc,
5451 ToRParenLoc,
5452 ToExceptionDecl,
5453 ToBody);
5454}
5455
5456Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
5457 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc());
5458 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody());
5459 if (!ToAtFinallyStmt && S->getFinallyBody())
5460 return nullptr;
5461 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc,
5462 ToAtFinallyStmt);
5463}
5464
5465Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
5466 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc());
5467 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody());
5468 if (!ToAtTryStmt && S->getTryBody())
5469 return nullptr;
5470 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
5471 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
5472 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
5473 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt))
5474 ToCatchStmts[CI] = ToCatchStmt;
5475 else
5476 return nullptr;
5477 }
5478 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt());
5479 if (!ToAtFinallyStmt && S->getFinallyStmt())
5480 return nullptr;
5481 return ObjCAtTryStmt::Create(Importer.getToContext(),
5482 ToAtTryLoc, ToAtTryStmt,
5483 ToCatchStmts.begin(), ToCatchStmts.size(),
5484 ToAtFinallyStmt);
5485}
5486
5487Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt
5488 (ObjCAtSynchronizedStmt *S) {
5489 SourceLocation ToAtSynchronizedLoc =
5490 Importer.Import(S->getAtSynchronizedLoc());
5491 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr());
5492 if (!ToSynchExpr && S->getSynchExpr())
5493 return nullptr;
5494 Stmt *ToSynchBody = Importer.Import(S->getSynchBody());
5495 if (!ToSynchBody && S->getSynchBody())
5496 return nullptr;
5497 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
5498 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
5499}
5500
5501Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
5502 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc());
5503 Expr *ToThrow = Importer.Import(S->getThrowExpr());
5504 if (!ToThrow && S->getThrowExpr())
5505 return nullptr;
5506 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow);
5507}
5508
5509Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt
5510 (ObjCAutoreleasePoolStmt *S) {
5511 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc());
5512 Stmt *ToSubStmt = Importer.Import(S->getSubStmt());
5513 if (!ToSubStmt && S->getSubStmt())
5514 return nullptr;
5515 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc,
5516 ToSubStmt);
Douglas Gregor7eeb5972010-02-11 19:21:55 +00005517}
5518
5519//----------------------------------------------------------------------------
5520// Import Expressions
5521//----------------------------------------------------------------------------
5522Expr *ASTNodeImporter::VisitExpr(Expr *E) {
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005523 Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
5524 << E->getStmtClassName();
Craig Topper36250ad2014-05-12 05:36:57 +00005525 return nullptr;
Douglas Gregor7eeb5972010-02-11 19:21:55 +00005526}
5527
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005528Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
5529 QualType T = Importer.Import(E->getType());
5530 if (T.isNull())
5531 return nullptr;
5532
5533 Expr *SubExpr = Importer.Import(E->getSubExpr());
5534 if (!SubExpr && E->getSubExpr())
5535 return nullptr;
5536
5537 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo());
5538 if (!TInfo)
5539 return nullptr;
5540
5541 return new (Importer.getToContext()) VAArgExpr(
5542 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo,
5543 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI());
5544}
5545
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005546Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
5547 QualType T = Importer.Import(E->getType());
5548 if (T.isNull())
5549 return nullptr;
5550
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005551 return new (Importer.getToContext())
5552 GNUNullExpr(T, Importer.Import(E->getBeginLoc()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005553}
5554
5555Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
5556 QualType T = Importer.Import(E->getType());
5557 if (T.isNull())
5558 return nullptr;
5559
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005560 auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005561 if (!SL && E->getFunctionName())
5562 return nullptr;
5563
5564 return new (Importer.getToContext()) PredefinedExpr(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005565 Importer.Import(E->getBeginLoc()), T, E->getIdentType(), SL);
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005566}
5567
Douglas Gregor52f820e2010-02-19 01:17:02 +00005568Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005569 auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl()));
Douglas Gregor52f820e2010-02-19 01:17:02 +00005570 if (!ToD)
Craig Topper36250ad2014-05-12 05:36:57 +00005571 return nullptr;
Chandler Carruth8d26bb02011-05-01 23:48:14 +00005572
Craig Topper36250ad2014-05-12 05:36:57 +00005573 NamedDecl *FoundD = nullptr;
Chandler Carruth8d26bb02011-05-01 23:48:14 +00005574 if (E->getDecl() != E->getFoundDecl()) {
5575 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl()));
5576 if (!FoundD)
Craig Topper36250ad2014-05-12 05:36:57 +00005577 return nullptr;
Chandler Carruth8d26bb02011-05-01 23:48:14 +00005578 }
Fangrui Song6907ce22018-07-30 19:24:48 +00005579
Douglas Gregor52f820e2010-02-19 01:17:02 +00005580 QualType T = Importer.Import(E->getType());
5581 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005582 return nullptr;
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00005583
Aleksei Sidorina693b372016-09-28 10:16:56 +00005584 TemplateArgumentListInfo ToTAInfo;
5585 TemplateArgumentListInfo *ResInfo = nullptr;
5586 if (E->hasExplicitTemplateArgs()) {
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00005587 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
5588 return nullptr;
Aleksei Sidorina693b372016-09-28 10:16:56 +00005589 ResInfo = &ToTAInfo;
5590 }
5591
Fangrui Song6907ce22018-07-30 19:24:48 +00005592 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(),
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00005593 Importer.Import(E->getQualifierLoc()),
Abramo Bagnara7945c982012-01-27 09:46:47 +00005594 Importer.Import(E->getTemplateKeywordLoc()),
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00005595 ToD,
Alexey Bataev19acc3d2015-01-12 10:17:46 +00005596 E->refersToEnclosingVariableOrCapture(),
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00005597 Importer.Import(E->getLocation()),
5598 T, E->getValueKind(),
Aleksei Sidorina693b372016-09-28 10:16:56 +00005599 FoundD, ResInfo);
Abramo Bagnara635ed24e2011-10-05 07:56:41 +00005600 if (E->hadMultipleCandidates())
5601 DRE->setHadMultipleCandidates(true);
5602 return DRE;
Douglas Gregor52f820e2010-02-19 01:17:02 +00005603}
5604
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005605Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
5606 QualType T = Importer.Import(E->getType());
5607 if (T.isNull())
Aleksei Sidorina693b372016-09-28 10:16:56 +00005608 return nullptr;
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005609
5610 return new (Importer.getToContext()) ImplicitValueInitExpr(T);
5611}
5612
5613ASTNodeImporter::Designator
5614ASTNodeImporter::ImportDesignator(const Designator &D) {
5615 if (D.isFieldDesignator()) {
5616 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
5617 // Caller checks for import error
5618 return Designator(ToFieldName, Importer.Import(D.getDotLoc()),
5619 Importer.Import(D.getFieldLoc()));
5620 }
5621 if (D.isArrayDesignator())
5622 return Designator(D.getFirstExprIndex(),
5623 Importer.Import(D.getLBracketLoc()),
5624 Importer.Import(D.getRBracketLoc()));
5625
5626 assert(D.isArrayRangeDesignator());
5627 return Designator(D.getFirstExprIndex(),
5628 Importer.Import(D.getLBracketLoc()),
5629 Importer.Import(D.getEllipsisLoc()),
5630 Importer.Import(D.getRBracketLoc()));
5631}
5632
5633
5634Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005635 auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005636 if (!Init)
5637 return nullptr;
5638
5639 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1);
5640 // List elements from the second, the first is Init itself
5641 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005642 if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I))))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005643 IndexExprs[I - 1] = Arg;
5644 else
5645 return nullptr;
5646 }
5647
5648 SmallVector<Designator, 4> Designators(DIE->size());
David Majnemerf7e36092016-06-23 00:15:04 +00005649 llvm::transform(DIE->designators(), Designators.begin(),
5650 [this](const Designator &D) -> Designator {
5651 return ImportDesignator(D);
5652 });
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005653
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005654 for (const auto &D : DIE->designators())
David Majnemerf7e36092016-06-23 00:15:04 +00005655 if (D.isFieldDesignator() && !D.getFieldName())
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005656 return nullptr;
5657
5658 return DesignatedInitExpr::Create(
David Majnemerf7e36092016-06-23 00:15:04 +00005659 Importer.getToContext(), Designators,
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005660 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()),
5661 DIE->usesGNUSyntax(), Init);
5662}
5663
5664Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
5665 QualType T = Importer.Import(E->getType());
5666 if (T.isNull())
5667 return nullptr;
5668
5669 return new (Importer.getToContext())
5670 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation()));
5671}
5672
Douglas Gregor7eeb5972010-02-11 19:21:55 +00005673Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
5674 QualType T = Importer.Import(E->getType());
5675 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005676 return nullptr;
Douglas Gregor7eeb5972010-02-11 19:21:55 +00005677
Fangrui Song6907ce22018-07-30 19:24:48 +00005678 return IntegerLiteral::Create(Importer.getToContext(),
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00005679 E->getValue(), T,
5680 Importer.Import(E->getLocation()));
Douglas Gregor7eeb5972010-02-11 19:21:55 +00005681}
5682
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005683Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
5684 QualType T = Importer.Import(E->getType());
5685 if (T.isNull())
5686 return nullptr;
5687
5688 return FloatingLiteral::Create(Importer.getToContext(),
5689 E->getValue(), E->isExact(), T,
5690 Importer.Import(E->getLocation()));
5691}
5692
Gabor Martonbf7f18b2018-08-09 12:18:07 +00005693Expr *ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
5694 QualType T = Importer.Import(E->getType());
5695 if (T.isNull())
5696 return nullptr;
5697
5698 Expr *SubE = Importer.Import(E->getSubExpr());
5699 if (!SubE)
5700 return nullptr;
5701
5702 return new (Importer.getToContext()) ImaginaryLiteral(SubE, T);
5703}
5704
Douglas Gregor623421d2010-02-18 02:21:22 +00005705Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
5706 QualType T = Importer.Import(E->getType());
5707 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005708 return nullptr;
5709
Douglas Gregorfb65e592011-07-27 05:40:30 +00005710 return new (Importer.getToContext()) CharacterLiteral(E->getValue(),
5711 E->getKind(), T,
Douglas Gregor623421d2010-02-18 02:21:22 +00005712 Importer.Import(E->getLocation()));
5713}
5714
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005715Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
5716 QualType T = Importer.Import(E->getType());
5717 if (T.isNull())
5718 return nullptr;
5719
5720 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated());
5721 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin());
5722
5723 return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
5724 E->getKind(), E->isPascal(), T,
5725 Locations.data(), Locations.size());
5726}
5727
5728Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
5729 QualType T = Importer.Import(E->getType());
5730 if (T.isNull())
5731 return nullptr;
5732
5733 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo());
5734 if (!TInfo)
5735 return nullptr;
5736
5737 Expr *Init = Importer.Import(E->getInitializer());
5738 if (!Init)
5739 return nullptr;
5740
5741 return new (Importer.getToContext()) CompoundLiteralExpr(
5742 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(),
5743 Init, E->isFileScope());
5744}
5745
5746Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
5747 QualType T = Importer.Import(E->getType());
5748 if (T.isNull())
5749 return nullptr;
5750
5751 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs());
5752 if (ImportArrayChecked(
5753 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
5754 Exprs.begin()))
5755 return nullptr;
5756
5757 return new (Importer.getToContext()) AtomicExpr(
5758 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(),
5759 Importer.Import(E->getRParenLoc()));
5760}
5761
5762Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
5763 QualType T = Importer.Import(E->getType());
5764 if (T.isNull())
5765 return nullptr;
5766
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005767 auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005768 if (!ToLabel)
5769 return nullptr;
5770
5771 return new (Importer.getToContext()) AddrLabelExpr(
5772 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()),
5773 ToLabel, T);
5774}
5775
Douglas Gregorc74247e2010-02-19 01:07:06 +00005776Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
5777 Expr *SubExpr = Importer.Import(E->getSubExpr());
5778 if (!SubExpr)
Craig Topper36250ad2014-05-12 05:36:57 +00005779 return nullptr;
5780
Fangrui Song6907ce22018-07-30 19:24:48 +00005781 return new (Importer.getToContext())
Douglas Gregorc74247e2010-02-19 01:07:06 +00005782 ParenExpr(Importer.Import(E->getLParen()),
5783 Importer.Import(E->getRParen()),
5784 SubExpr);
5785}
5786
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005787Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
5788 SmallVector<Expr *, 4> Exprs(E->getNumExprs());
Aleksei Sidorina693b372016-09-28 10:16:56 +00005789 if (ImportContainerChecked(E->exprs(), Exprs))
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005790 return nullptr;
5791
5792 return new (Importer.getToContext()) ParenListExpr(
5793 Importer.getToContext(), Importer.Import(E->getLParenLoc()),
5794 Exprs, Importer.Import(E->getLParenLoc()));
5795}
5796
5797Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
5798 QualType T = Importer.Import(E->getType());
5799 if (T.isNull())
5800 return nullptr;
5801
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005802 auto *ToSubStmt = cast_or_null<CompoundStmt>(
5803 Importer.Import(E->getSubStmt()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005804 if (!ToSubStmt && E->getSubStmt())
5805 return nullptr;
5806
5807 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T,
5808 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc()));
5809}
5810
Douglas Gregorc74247e2010-02-19 01:07:06 +00005811Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
5812 QualType T = Importer.Import(E->getType());
5813 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005814 return nullptr;
Douglas Gregorc74247e2010-02-19 01:07:06 +00005815
5816 Expr *SubExpr = Importer.Import(E->getSubExpr());
5817 if (!SubExpr)
Craig Topper36250ad2014-05-12 05:36:57 +00005818 return nullptr;
5819
Aaron Ballmana5038552018-01-09 13:07:03 +00005820 return new (Importer.getToContext()) UnaryOperator(
5821 SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(),
5822 Importer.Import(E->getOperatorLoc()), E->canOverflow());
Douglas Gregorc74247e2010-02-19 01:07:06 +00005823}
5824
Aaron Ballmana5038552018-01-09 13:07:03 +00005825Expr *
5826ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
Douglas Gregord8552cd2010-02-19 01:24:23 +00005827 QualType ResultType = Importer.Import(E->getType());
Fangrui Song6907ce22018-07-30 19:24:48 +00005828
Douglas Gregord8552cd2010-02-19 01:24:23 +00005829 if (E->isArgumentType()) {
5830 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo());
5831 if (!TInfo)
Craig Topper36250ad2014-05-12 05:36:57 +00005832 return nullptr;
5833
Peter Collingbournee190dee2011-03-11 19:24:49 +00005834 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5835 TInfo, ResultType,
Douglas Gregord8552cd2010-02-19 01:24:23 +00005836 Importer.Import(E->getOperatorLoc()),
5837 Importer.Import(E->getRParenLoc()));
5838 }
Fangrui Song6907ce22018-07-30 19:24:48 +00005839
Douglas Gregord8552cd2010-02-19 01:24:23 +00005840 Expr *SubExpr = Importer.Import(E->getArgumentExpr());
5841 if (!SubExpr)
Craig Topper36250ad2014-05-12 05:36:57 +00005842 return nullptr;
5843
Peter Collingbournee190dee2011-03-11 19:24:49 +00005844 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(),
5845 SubExpr, ResultType,
Douglas Gregord8552cd2010-02-19 01:24:23 +00005846 Importer.Import(E->getOperatorLoc()),
5847 Importer.Import(E->getRParenLoc()));
5848}
5849
Douglas Gregorc74247e2010-02-19 01:07:06 +00005850Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
5851 QualType T = Importer.Import(E->getType());
5852 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005853 return nullptr;
Douglas Gregorc74247e2010-02-19 01:07:06 +00005854
5855 Expr *LHS = Importer.Import(E->getLHS());
5856 if (!LHS)
Craig Topper36250ad2014-05-12 05:36:57 +00005857 return nullptr;
5858
Douglas Gregorc74247e2010-02-19 01:07:06 +00005859 Expr *RHS = Importer.Import(E->getRHS());
5860 if (!RHS)
Craig Topper36250ad2014-05-12 05:36:57 +00005861 return nullptr;
5862
Douglas Gregorc74247e2010-02-19 01:07:06 +00005863 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(),
John McCall7decc9e2010-11-18 06:31:45 +00005864 T, E->getValueKind(),
5865 E->getObjectKind(),
Lang Hames5de91cc2012-10-02 04:45:10 +00005866 Importer.Import(E->getOperatorLoc()),
Adam Nemet484aa452017-03-27 19:17:25 +00005867 E->getFPFeatures());
Douglas Gregorc74247e2010-02-19 01:07:06 +00005868}
5869
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005870Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
5871 QualType T = Importer.Import(E->getType());
5872 if (T.isNull())
5873 return nullptr;
5874
5875 Expr *ToLHS = Importer.Import(E->getLHS());
5876 if (!ToLHS)
5877 return nullptr;
5878
5879 Expr *ToRHS = Importer.Import(E->getRHS());
5880 if (!ToRHS)
5881 return nullptr;
5882
5883 Expr *ToCond = Importer.Import(E->getCond());
5884 if (!ToCond)
5885 return nullptr;
5886
5887 return new (Importer.getToContext()) ConditionalOperator(
5888 ToCond, Importer.Import(E->getQuestionLoc()),
5889 ToLHS, Importer.Import(E->getColonLoc()),
5890 ToRHS, T, E->getValueKind(), E->getObjectKind());
5891}
5892
5893Expr *ASTNodeImporter::VisitBinaryConditionalOperator(
5894 BinaryConditionalOperator *E) {
5895 QualType T = Importer.Import(E->getType());
5896 if (T.isNull())
5897 return nullptr;
5898
5899 Expr *Common = Importer.Import(E->getCommon());
5900 if (!Common)
5901 return nullptr;
5902
5903 Expr *Cond = Importer.Import(E->getCond());
5904 if (!Cond)
5905 return nullptr;
5906
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00005907 auto *OpaqueValue = cast_or_null<OpaqueValueExpr>(
5908 Importer.Import(E->getOpaqueValue()));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005909 if (!OpaqueValue)
5910 return nullptr;
5911
5912 Expr *TrueExpr = Importer.Import(E->getTrueExpr());
5913 if (!TrueExpr)
5914 return nullptr;
5915
5916 Expr *FalseExpr = Importer.Import(E->getFalseExpr());
5917 if (!FalseExpr)
5918 return nullptr;
5919
5920 return new (Importer.getToContext()) BinaryConditionalOperator(
5921 Common, OpaqueValue, Cond, TrueExpr, FalseExpr,
5922 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()),
5923 T, E->getValueKind(), E->getObjectKind());
5924}
5925
Aleksei Sidorina693b372016-09-28 10:16:56 +00005926Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
5927 QualType T = Importer.Import(E->getType());
5928 if (T.isNull())
5929 return nullptr;
5930
5931 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo());
5932 if (!ToQueried)
5933 return nullptr;
5934
5935 Expr *Dim = Importer.Import(E->getDimensionExpression());
5936 if (!Dim && E->getDimensionExpression())
5937 return nullptr;
5938
5939 return new (Importer.getToContext()) ArrayTypeTraitExpr(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005940 Importer.Import(E->getBeginLoc()), E->getTrait(), ToQueried,
Stephen Kelly1c301dc2018-08-09 21:09:38 +00005941 E->getValue(), Dim, Importer.Import(E->getEndLoc()), T);
Aleksei Sidorina693b372016-09-28 10:16:56 +00005942}
5943
5944Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
5945 QualType T = Importer.Import(E->getType());
5946 if (T.isNull())
5947 return nullptr;
5948
5949 Expr *ToQueried = Importer.Import(E->getQueriedExpression());
5950 if (!ToQueried)
5951 return nullptr;
5952
5953 return new (Importer.getToContext()) ExpressionTraitExpr(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00005954 Importer.Import(E->getBeginLoc()), E->getTrait(), ToQueried,
Stephen Kelly1c301dc2018-08-09 21:09:38 +00005955 E->getValue(), Importer.Import(E->getEndLoc()), T);
Aleksei Sidorina693b372016-09-28 10:16:56 +00005956}
5957
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005958Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
5959 QualType T = Importer.Import(E->getType());
5960 if (T.isNull())
5961 return nullptr;
5962
5963 Expr *SourceExpr = Importer.Import(E->getSourceExpr());
5964 if (!SourceExpr && E->getSourceExpr())
5965 return nullptr;
5966
5967 return new (Importer.getToContext()) OpaqueValueExpr(
Aleksei Sidorina693b372016-09-28 10:16:56 +00005968 Importer.Import(E->getLocation()), T, E->getValueKind(),
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00005969 E->getObjectKind(), SourceExpr);
5970}
5971
Aleksei Sidorina693b372016-09-28 10:16:56 +00005972Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
5973 QualType T = Importer.Import(E->getType());
5974 if (T.isNull())
5975 return nullptr;
5976
5977 Expr *ToLHS = Importer.Import(E->getLHS());
5978 if (!ToLHS)
5979 return nullptr;
5980
5981 Expr *ToRHS = Importer.Import(E->getRHS());
5982 if (!ToRHS)
5983 return nullptr;
5984
5985 return new (Importer.getToContext()) ArraySubscriptExpr(
5986 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(),
5987 Importer.Import(E->getRBracketLoc()));
5988}
5989
Douglas Gregorc74247e2010-02-19 01:07:06 +00005990Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
5991 QualType T = Importer.Import(E->getType());
5992 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005993 return nullptr;
5994
Douglas Gregorc74247e2010-02-19 01:07:06 +00005995 QualType CompLHSType = Importer.Import(E->getComputationLHSType());
5996 if (CompLHSType.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00005997 return nullptr;
5998
Douglas Gregorc74247e2010-02-19 01:07:06 +00005999 QualType CompResultType = Importer.Import(E->getComputationResultType());
6000 if (CompResultType.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00006001 return nullptr;
6002
Douglas Gregorc74247e2010-02-19 01:07:06 +00006003 Expr *LHS = Importer.Import(E->getLHS());
6004 if (!LHS)
Craig Topper36250ad2014-05-12 05:36:57 +00006005 return nullptr;
6006
Douglas Gregorc74247e2010-02-19 01:07:06 +00006007 Expr *RHS = Importer.Import(E->getRHS());
6008 if (!RHS)
Craig Topper36250ad2014-05-12 05:36:57 +00006009 return nullptr;
6010
Fangrui Song6907ce22018-07-30 19:24:48 +00006011 return new (Importer.getToContext())
Douglas Gregorc74247e2010-02-19 01:07:06 +00006012 CompoundAssignOperator(LHS, RHS, E->getOpcode(),
John McCall7decc9e2010-11-18 06:31:45 +00006013 T, E->getValueKind(),
6014 E->getObjectKind(),
6015 CompLHSType, CompResultType,
Lang Hames5de91cc2012-10-02 04:45:10 +00006016 Importer.Import(E->getOperatorLoc()),
Adam Nemet484aa452017-03-27 19:17:25 +00006017 E->getFPFeatures());
Douglas Gregorc74247e2010-02-19 01:07:06 +00006018}
6019
Aleksei Sidorina693b372016-09-28 10:16:56 +00006020bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) {
6021 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
6022 if (CXXBaseSpecifier *Spec = Importer.Import(*I))
6023 Path.push_back(Spec);
6024 else
6025 return true;
6026 }
6027 return false;
John McCallcf142162010-08-07 06:22:56 +00006028}
6029
Douglas Gregor98c10182010-02-12 22:17:39 +00006030Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
6031 QualType T = Importer.Import(E->getType());
6032 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00006033 return nullptr;
Douglas Gregor98c10182010-02-12 22:17:39 +00006034
6035 Expr *SubExpr = Importer.Import(E->getSubExpr());
6036 if (!SubExpr)
Craig Topper36250ad2014-05-12 05:36:57 +00006037 return nullptr;
John McCallcf142162010-08-07 06:22:56 +00006038
6039 CXXCastPath BasePath;
6040 if (ImportCastPath(E, BasePath))
Craig Topper36250ad2014-05-12 05:36:57 +00006041 return nullptr;
John McCallcf142162010-08-07 06:22:56 +00006042
6043 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(),
John McCall2536c6d2010-08-25 10:28:54 +00006044 SubExpr, &BasePath, E->getValueKind());
Douglas Gregor98c10182010-02-12 22:17:39 +00006045}
6046
Aleksei Sidorina693b372016-09-28 10:16:56 +00006047Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
Douglas Gregor5481d322010-02-19 01:32:14 +00006048 QualType T = Importer.Import(E->getType());
6049 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00006050 return nullptr;
6051
Douglas Gregor5481d322010-02-19 01:32:14 +00006052 Expr *SubExpr = Importer.Import(E->getSubExpr());
6053 if (!SubExpr)
Craig Topper36250ad2014-05-12 05:36:57 +00006054 return nullptr;
Douglas Gregor5481d322010-02-19 01:32:14 +00006055
6056 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten());
6057 if (!TInfo && E->getTypeInfoAsWritten())
Craig Topper36250ad2014-05-12 05:36:57 +00006058 return nullptr;
6059
John McCallcf142162010-08-07 06:22:56 +00006060 CXXCastPath BasePath;
6061 if (ImportCastPath(E, BasePath))
Craig Topper36250ad2014-05-12 05:36:57 +00006062 return nullptr;
John McCallcf142162010-08-07 06:22:56 +00006063
Aleksei Sidorina693b372016-09-28 10:16:56 +00006064 switch (E->getStmtClass()) {
6065 case Stmt::CStyleCastExprClass: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006066 auto *CCE = cast<CStyleCastExpr>(E);
Aleksei Sidorina693b372016-09-28 10:16:56 +00006067 return CStyleCastExpr::Create(Importer.getToContext(), T,
6068 E->getValueKind(), E->getCastKind(),
6069 SubExpr, &BasePath, TInfo,
6070 Importer.Import(CCE->getLParenLoc()),
6071 Importer.Import(CCE->getRParenLoc()));
6072 }
6073
6074 case Stmt::CXXFunctionalCastExprClass: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006075 auto *FCE = cast<CXXFunctionalCastExpr>(E);
Aleksei Sidorina693b372016-09-28 10:16:56 +00006076 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T,
6077 E->getValueKind(), TInfo,
6078 E->getCastKind(), SubExpr, &BasePath,
6079 Importer.Import(FCE->getLParenLoc()),
6080 Importer.Import(FCE->getRParenLoc()));
6081 }
6082
6083 case Stmt::ObjCBridgedCastExprClass: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006084 auto *OCE = cast<ObjCBridgedCastExpr>(E);
Aleksei Sidorina693b372016-09-28 10:16:56 +00006085 return new (Importer.getToContext()) ObjCBridgedCastExpr(
6086 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(),
6087 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()),
6088 TInfo, SubExpr);
6089 }
6090 default:
6091 break; // just fall through
6092 }
6093
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006094 auto *Named = cast<CXXNamedCastExpr>(E);
Aleksei Sidorina693b372016-09-28 10:16:56 +00006095 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()),
6096 RParenLoc = Importer.Import(Named->getRParenLoc());
6097 SourceRange Brackets = Importer.Import(Named->getAngleBrackets());
6098
6099 switch (E->getStmtClass()) {
6100 case Stmt::CXXStaticCastExprClass:
6101 return CXXStaticCastExpr::Create(Importer.getToContext(), T,
6102 E->getValueKind(), E->getCastKind(),
6103 SubExpr, &BasePath, TInfo,
6104 ExprLoc, RParenLoc, Brackets);
6105
6106 case Stmt::CXXDynamicCastExprClass:
6107 return CXXDynamicCastExpr::Create(Importer.getToContext(), T,
6108 E->getValueKind(), E->getCastKind(),
6109 SubExpr, &BasePath, TInfo,
6110 ExprLoc, RParenLoc, Brackets);
6111
6112 case Stmt::CXXReinterpretCastExprClass:
6113 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T,
6114 E->getValueKind(), E->getCastKind(),
6115 SubExpr, &BasePath, TInfo,
6116 ExprLoc, RParenLoc, Brackets);
6117
6118 case Stmt::CXXConstCastExprClass:
6119 return CXXConstCastExpr::Create(Importer.getToContext(), T,
6120 E->getValueKind(), SubExpr, TInfo, ExprLoc,
6121 RParenLoc, Brackets);
6122 default:
6123 llvm_unreachable("Cast expression of unsupported type!");
6124 return nullptr;
6125 }
6126}
6127
6128Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) {
6129 QualType T = Importer.Import(OE->getType());
6130 if (T.isNull())
6131 return nullptr;
6132
6133 SmallVector<OffsetOfNode, 4> Nodes;
6134 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) {
6135 const OffsetOfNode &Node = OE->getComponent(I);
6136
6137 switch (Node.getKind()) {
6138 case OffsetOfNode::Array:
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006139 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getBeginLoc()),
Aleksei Sidorina693b372016-09-28 10:16:56 +00006140 Node.getArrayExprIndex(),
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006141 Importer.Import(Node.getEndLoc())));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006142 break;
6143
6144 case OffsetOfNode::Base: {
6145 CXXBaseSpecifier *BS = Importer.Import(Node.getBase());
6146 if (!BS && Node.getBase())
6147 return nullptr;
6148 Nodes.push_back(OffsetOfNode(BS));
6149 break;
6150 }
6151 case OffsetOfNode::Field: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006152 auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField()));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006153 if (!FD)
6154 return nullptr;
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006155 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getBeginLoc()), FD,
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006156 Importer.Import(Node.getEndLoc())));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006157 break;
6158 }
6159 case OffsetOfNode::Identifier: {
6160 IdentifierInfo *ToII = Importer.Import(Node.getFieldName());
6161 if (!ToII)
6162 return nullptr;
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006163 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getBeginLoc()), ToII,
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006164 Importer.Import(Node.getEndLoc())));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006165 break;
6166 }
6167 }
6168 }
6169
6170 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions());
6171 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) {
6172 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I));
6173 if (!ToIndexExpr)
6174 return nullptr;
6175 Exprs[I] = ToIndexExpr;
6176 }
6177
6178 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo());
6179 if (!TInfo && OE->getTypeSourceInfo())
6180 return nullptr;
6181
6182 return OffsetOfExpr::Create(Importer.getToContext(), T,
6183 Importer.Import(OE->getOperatorLoc()),
6184 TInfo, Nodes, Exprs,
6185 Importer.Import(OE->getRParenLoc()));
6186}
6187
6188Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
6189 QualType T = Importer.Import(E->getType());
6190 if (T.isNull())
6191 return nullptr;
6192
6193 Expr *Operand = Importer.Import(E->getOperand());
6194 if (!Operand)
6195 return nullptr;
6196
6197 CanThrowResult CanThrow;
6198 if (E->isValueDependent())
6199 CanThrow = CT_Dependent;
6200 else
6201 CanThrow = E->getValue() ? CT_Can : CT_Cannot;
6202
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006203 return new (Importer.getToContext())
6204 CXXNoexceptExpr(T, Operand, CanThrow, Importer.Import(E->getBeginLoc()),
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006205 Importer.Import(E->getEndLoc()));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006206}
6207
6208Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
6209 QualType T = Importer.Import(E->getType());
6210 if (T.isNull())
6211 return nullptr;
6212
6213 Expr *SubExpr = Importer.Import(E->getSubExpr());
6214 if (!SubExpr && E->getSubExpr())
6215 return nullptr;
6216
6217 return new (Importer.getToContext()) CXXThrowExpr(
6218 SubExpr, T, Importer.Import(E->getThrowLoc()),
6219 E->isThrownVariableInScope());
6220}
6221
6222Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006223 auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam()));
Aleksei Sidorina693b372016-09-28 10:16:56 +00006224 if (!Param)
6225 return nullptr;
6226
6227 return CXXDefaultArgExpr::Create(
6228 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param);
6229}
6230
6231Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
6232 QualType T = Importer.Import(E->getType());
6233 if (T.isNull())
6234 return nullptr;
6235
6236 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo());
6237 if (!TypeInfo)
6238 return nullptr;
6239
6240 return new (Importer.getToContext()) CXXScalarValueInitExpr(
6241 T, TypeInfo, Importer.Import(E->getRParenLoc()));
6242}
6243
6244Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
6245 Expr *SubExpr = Importer.Import(E->getSubExpr());
6246 if (!SubExpr)
6247 return nullptr;
6248
6249 auto *Dtor = cast_or_null<CXXDestructorDecl>(
6250 Importer.Import(const_cast<CXXDestructorDecl *>(
6251 E->getTemporary()->getDestructor())));
6252 if (!Dtor)
6253 return nullptr;
6254
6255 ASTContext &ToCtx = Importer.getToContext();
6256 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor);
6257 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr);
6258}
6259
6260Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) {
6261 QualType T = Importer.Import(CE->getType());
6262 if (T.isNull())
6263 return nullptr;
6264
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006265 TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo());
6266 if (!TInfo)
6267 return nullptr;
6268
Aleksei Sidorina693b372016-09-28 10:16:56 +00006269 SmallVector<Expr *, 8> Args(CE->getNumArgs());
6270 if (ImportContainerChecked(CE->arguments(), Args))
6271 return nullptr;
6272
6273 auto *Ctor = cast_or_null<CXXConstructorDecl>(
6274 Importer.Import(CE->getConstructor()));
6275 if (!Ctor)
6276 return nullptr;
6277
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006278 return new (Importer.getToContext()) CXXTemporaryObjectExpr(
6279 Importer.getToContext(), Ctor, T, TInfo, Args,
6280 Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(),
6281 CE->isListInitialization(), CE->isStdInitListInitialization(),
6282 CE->requiresZeroInitialization());
Aleksei Sidorina693b372016-09-28 10:16:56 +00006283}
6284
6285Expr *
6286ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
6287 QualType T = Importer.Import(E->getType());
6288 if (T.isNull())
6289 return nullptr;
6290
6291 Expr *TempE = Importer.Import(E->GetTemporaryExpr());
6292 if (!TempE)
6293 return nullptr;
6294
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006295 auto *ExtendedBy = cast_or_null<ValueDecl>(
Aleksei Sidorina693b372016-09-28 10:16:56 +00006296 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl())));
6297 if (!ExtendedBy && E->getExtendingDecl())
6298 return nullptr;
6299
6300 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
6301 T, TempE, E->isBoundToLvalueReference());
6302
6303 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
6304 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber());
6305 return ToMTE;
6306}
6307
Gabor Horvath7a91c082017-11-14 11:30:38 +00006308Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
6309 QualType T = Importer.Import(E->getType());
6310 if (T.isNull())
6311 return nullptr;
6312
6313 Expr *Pattern = Importer.Import(E->getPattern());
6314 if (!Pattern)
6315 return nullptr;
6316
6317 return new (Importer.getToContext()) PackExpansionExpr(
6318 T, Pattern, Importer.Import(E->getEllipsisLoc()),
6319 E->getNumExpansions());
6320}
6321
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006322Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
6323 auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack()));
6324 if (!Pack)
6325 return nullptr;
6326
6327 Optional<unsigned> Length;
6328
6329 if (!E->isValueDependent())
6330 Length = E->getPackLength();
6331
6332 SmallVector<TemplateArgument, 8> PartialArguments;
6333 if (E->isPartiallySubstituted()) {
6334 if (ImportTemplateArguments(E->getPartialArguments().data(),
6335 E->getPartialArguments().size(),
6336 PartialArguments))
6337 return nullptr;
6338 }
6339
6340 return SizeOfPackExpr::Create(
6341 Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack,
6342 Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()),
6343 Length, PartialArguments);
6344}
6345
Aleksei Sidorina693b372016-09-28 10:16:56 +00006346Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) {
6347 QualType T = Importer.Import(CE->getType());
6348 if (T.isNull())
6349 return nullptr;
6350
6351 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs());
6352 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs))
6353 return nullptr;
6354
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006355 auto *OperatorNewDecl = cast_or_null<FunctionDecl>(
Aleksei Sidorina693b372016-09-28 10:16:56 +00006356 Importer.Import(CE->getOperatorNew()));
6357 if (!OperatorNewDecl && CE->getOperatorNew())
6358 return nullptr;
6359
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006360 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
Aleksei Sidorina693b372016-09-28 10:16:56 +00006361 Importer.Import(CE->getOperatorDelete()));
6362 if (!OperatorDeleteDecl && CE->getOperatorDelete())
6363 return nullptr;
6364
6365 Expr *ToInit = Importer.Import(CE->getInitializer());
6366 if (!ToInit && CE->getInitializer())
6367 return nullptr;
6368
6369 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo());
6370 if (!TInfo)
6371 return nullptr;
6372
6373 Expr *ToArrSize = Importer.Import(CE->getArraySize());
6374 if (!ToArrSize && CE->getArraySize())
6375 return nullptr;
6376
6377 return new (Importer.getToContext()) CXXNewExpr(
6378 Importer.getToContext(),
6379 CE->isGlobalNew(),
6380 OperatorNewDecl, OperatorDeleteDecl,
Richard Smithb2f0f052016-10-10 18:54:32 +00006381 CE->passAlignment(),
Aleksei Sidorina693b372016-09-28 10:16:56 +00006382 CE->doesUsualArrayDeleteWantSize(),
6383 PlacementArgs,
6384 Importer.Import(CE->getTypeIdParens()),
6385 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo,
6386 Importer.Import(CE->getSourceRange()),
6387 Importer.Import(CE->getDirectInitRange()));
6388}
6389
6390Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
6391 QualType T = Importer.Import(E->getType());
6392 if (T.isNull())
6393 return nullptr;
6394
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006395 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>(
Aleksei Sidorina693b372016-09-28 10:16:56 +00006396 Importer.Import(E->getOperatorDelete()));
6397 if (!OperatorDeleteDecl && E->getOperatorDelete())
6398 return nullptr;
6399
6400 Expr *ToArg = Importer.Import(E->getArgument());
6401 if (!ToArg && E->getArgument())
6402 return nullptr;
6403
6404 return new (Importer.getToContext()) CXXDeleteExpr(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006405 T, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
6406 E->doesUsualArrayDeleteWantSize(), OperatorDeleteDecl, ToArg,
6407 Importer.Import(E->getBeginLoc()));
Douglas Gregor5481d322010-02-19 01:32:14 +00006408}
6409
Sean Callanan59721b32015-04-28 18:41:46 +00006410Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
6411 QualType T = Importer.Import(E->getType());
6412 if (T.isNull())
6413 return nullptr;
6414
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006415 auto *ToCCD =
Sean Callanandd2c1742016-05-16 20:48:03 +00006416 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor()));
Richard Smithc2bebe92016-05-11 20:37:46 +00006417 if (!ToCCD)
Sean Callanan59721b32015-04-28 18:41:46 +00006418 return nullptr;
6419
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006420 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
Aleksei Sidorina693b372016-09-28 10:16:56 +00006421 if (ImportContainerChecked(E->arguments(), ToArgs))
Sean Callanan8bca9962016-03-28 21:43:01 +00006422 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00006423
6424 return CXXConstructExpr::Create(Importer.getToContext(), T,
6425 Importer.Import(E->getLocation()),
Richard Smithc83bf822016-06-10 00:58:19 +00006426 ToCCD, E->isElidable(),
Sean Callanan59721b32015-04-28 18:41:46 +00006427 ToArgs, E->hadMultipleCandidates(),
6428 E->isListInitialization(),
6429 E->isStdInitListInitialization(),
6430 E->requiresZeroInitialization(),
6431 E->getConstructionKind(),
6432 Importer.Import(E->getParenOrBraceRange()));
6433}
6434
Aleksei Sidorina693b372016-09-28 10:16:56 +00006435Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) {
6436 Expr *SubExpr = Importer.Import(EWC->getSubExpr());
6437 if (!SubExpr && EWC->getSubExpr())
6438 return nullptr;
6439
6440 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects());
6441 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++)
6442 if (ExprWithCleanups::CleanupObject Obj =
6443 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I))))
6444 Objs[I] = Obj;
6445 else
6446 return nullptr;
6447
6448 return ExprWithCleanups::Create(Importer.getToContext(),
6449 SubExpr, EWC->cleanupsHaveSideEffects(),
6450 Objs);
6451}
6452
Sean Callanan8bca9962016-03-28 21:43:01 +00006453Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
6454 QualType T = Importer.Import(E->getType());
6455 if (T.isNull())
6456 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00006457
Sean Callanan8bca9962016-03-28 21:43:01 +00006458 Expr *ToFn = Importer.Import(E->getCallee());
6459 if (!ToFn)
6460 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00006461
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006462 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
Aleksei Sidorina693b372016-09-28 10:16:56 +00006463 if (ImportContainerChecked(E->arguments(), ToArgs))
Sean Callanan8bca9962016-03-28 21:43:01 +00006464 return nullptr;
6465
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006466 return new (Importer.getToContext()) CXXMemberCallExpr(
6467 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(),
6468 Importer.Import(E->getRParenLoc()));
Sean Callanan8bca9962016-03-28 21:43:01 +00006469}
6470
6471Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
6472 QualType T = Importer.Import(E->getType());
6473 if (T.isNull())
6474 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00006475
Sean Callanan8bca9962016-03-28 21:43:01 +00006476 return new (Importer.getToContext())
6477 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit());
6478}
6479
6480Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
6481 QualType T = Importer.Import(E->getType());
6482 if (T.isNull())
6483 return nullptr;
Fangrui Song6907ce22018-07-30 19:24:48 +00006484
Sean Callanan8bca9962016-03-28 21:43:01 +00006485 return new (Importer.getToContext())
6486 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation()));
6487}
6488
6489
Sean Callanan59721b32015-04-28 18:41:46 +00006490Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
6491 QualType T = Importer.Import(E->getType());
6492 if (T.isNull())
6493 return nullptr;
6494
6495 Expr *ToBase = Importer.Import(E->getBase());
6496 if (!ToBase && E->getBase())
6497 return nullptr;
6498
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006499 auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl()));
Sean Callanan59721b32015-04-28 18:41:46 +00006500 if (!ToMember && E->getMemberDecl())
6501 return nullptr;
6502
Peter Szecsief972522018-05-02 11:52:54 +00006503 auto *ToDecl =
6504 dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl()));
6505 if (!ToDecl && E->getFoundDecl().getDecl())
6506 return nullptr;
6507
6508 DeclAccessPair ToFoundDecl =
6509 DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
Sean Callanan59721b32015-04-28 18:41:46 +00006510
6511 DeclarationNameInfo ToMemberNameInfo(
6512 Importer.Import(E->getMemberNameInfo().getName()),
6513 Importer.Import(E->getMemberNameInfo().getLoc()));
6514
6515 if (E->hasExplicitTemplateArgs()) {
6516 return nullptr; // FIXME: handle template arguments
6517 }
6518
6519 return MemberExpr::Create(Importer.getToContext(), ToBase,
6520 E->isArrow(),
6521 Importer.Import(E->getOperatorLoc()),
6522 Importer.Import(E->getQualifierLoc()),
6523 Importer.Import(E->getTemplateKeywordLoc()),
6524 ToMember, ToFoundDecl, ToMemberNameInfo,
6525 nullptr, T, E->getValueKind(),
6526 E->getObjectKind());
6527}
6528
Aleksei Sidorin60ccb7d2017-11-27 10:30:00 +00006529Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr(
6530 CXXPseudoDestructorExpr *E) {
Aleksei Sidorin60ccb7d2017-11-27 10:30:00 +00006531 Expr *BaseE = Importer.Import(E->getBase());
6532 if (!BaseE)
6533 return nullptr;
6534
6535 TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo());
6536 if (!ScopeInfo && E->getScopeTypeInfo())
6537 return nullptr;
6538
6539 PseudoDestructorTypeStorage Storage;
6540 if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
6541 IdentifierInfo *ToII = Importer.Import(FromII);
6542 if (!ToII)
6543 return nullptr;
6544 Storage = PseudoDestructorTypeStorage(
6545 ToII, Importer.Import(E->getDestroyedTypeLoc()));
6546 } else {
6547 TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo());
6548 if (!TI)
6549 return nullptr;
6550 Storage = PseudoDestructorTypeStorage(TI);
6551 }
6552
6553 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
6554 Importer.getToContext(), BaseE, E->isArrow(),
6555 Importer.Import(E->getOperatorLoc()),
6556 Importer.Import(E->getQualifierLoc()),
6557 ScopeInfo, Importer.Import(E->getColonColonLoc()),
6558 Importer.Import(E->getTildeLoc()), Storage);
6559}
6560
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00006561Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
6562 CXXDependentScopeMemberExpr *E) {
6563 Expr *Base = nullptr;
6564 if (!E->isImplicitAccess()) {
6565 Base = Importer.Import(E->getBase());
6566 if (!Base)
6567 return nullptr;
6568 }
6569
6570 QualType BaseType = Importer.Import(E->getBaseType());
6571 if (BaseType.isNull())
6572 return nullptr;
6573
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006574 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00006575 if (E->hasExplicitTemplateArgs()) {
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006576 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6577 E->template_arguments(), ToTAInfo))
Aleksei Sidorin7f758b62017-12-27 17:04:42 +00006578 return nullptr;
6579 ResInfo = &ToTAInfo;
6580 }
6581
6582 DeclarationName Name = Importer.Import(E->getMember());
6583 if (!E->getMember().isEmpty() && Name.isEmpty())
6584 return nullptr;
6585
6586 DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc()));
6587 // Import additional name location/type info.
6588 ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo);
6589 auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope());
6590 if (!ToFQ && E->getFirstQualifierFoundInScope())
6591 return nullptr;
6592
6593 return CXXDependentScopeMemberExpr::Create(
6594 Importer.getToContext(), Base, BaseType, E->isArrow(),
6595 Importer.Import(E->getOperatorLoc()),
6596 Importer.Import(E->getQualifierLoc()),
6597 Importer.Import(E->getTemplateKeywordLoc()),
6598 cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo);
6599}
6600
Peter Szecsice7f3182018-05-07 12:08:27 +00006601Expr *
6602ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
6603 DeclarationName Name = Importer.Import(E->getDeclName());
6604 if (!E->getDeclName().isEmpty() && Name.isEmpty())
6605 return nullptr;
6606
6607 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getExprLoc()));
6608 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6609
6610 TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()),
6611 Importer.Import(E->getRAngleLoc()));
6612 TemplateArgumentListInfo *ResInfo = nullptr;
6613 if (E->hasExplicitTemplateArgs()) {
6614 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
6615 return nullptr;
6616 ResInfo = &ToTAInfo;
6617 }
6618
6619 return DependentScopeDeclRefExpr::Create(
6620 Importer.getToContext(), Importer.Import(E->getQualifierLoc()),
6621 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo);
6622}
6623
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006624Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
6625 CXXUnresolvedConstructExpr *CE) {
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006626 unsigned NumArgs = CE->arg_size();
6627
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006628 SmallVector<Expr *, 8> ToArgs(NumArgs);
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006629 if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin()))
6630 return nullptr;
6631
6632 return CXXUnresolvedConstructExpr::Create(
6633 Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()),
6634 Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs),
6635 Importer.Import(CE->getRParenLoc()));
6636}
6637
6638Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006639 auto *NamingClass =
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006640 cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass()));
6641 if (E->getNamingClass() && !NamingClass)
6642 return nullptr;
6643
6644 DeclarationName Name = Importer.Import(E->getName());
6645 if (E->getName() && !Name)
6646 return nullptr;
6647
6648 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6649 // Import additional name location/type info.
6650 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6651
6652 UnresolvedSet<8> ToDecls;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006653 for (auto *D : E->decls()) {
6654 if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D)))
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006655 ToDecls.addDecl(To);
6656 else
6657 return nullptr;
6658 }
6659
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006660 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006661 if (E->hasExplicitTemplateArgs()) {
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006662 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6663 E->template_arguments(), ToTAInfo))
Aleksei Sidorine267a0f2018-01-09 16:40:40 +00006664 return nullptr;
6665 ResInfo = &ToTAInfo;
6666 }
6667
6668 if (ResInfo || E->getTemplateKeywordLoc().isValid())
6669 return UnresolvedLookupExpr::Create(
6670 Importer.getToContext(), NamingClass,
6671 Importer.Import(E->getQualifierLoc()),
6672 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(),
6673 ResInfo, ToDecls.begin(), ToDecls.end());
6674
6675 return UnresolvedLookupExpr::Create(
6676 Importer.getToContext(), NamingClass,
6677 Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(),
6678 E->isOverloaded(), ToDecls.begin(), ToDecls.end());
6679}
6680
Peter Szecsice7f3182018-05-07 12:08:27 +00006681Expr *ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
6682 DeclarationName Name = Importer.Import(E->getName());
6683 if (!E->getName().isEmpty() && Name.isEmpty())
6684 return nullptr;
6685 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc()));
6686 // Import additional name location/type info.
6687 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo);
6688
6689 QualType BaseType = Importer.Import(E->getType());
6690 if (!E->getType().isNull() && BaseType.isNull())
6691 return nullptr;
6692
6693 UnresolvedSet<8> ToDecls;
6694 for (Decl *D : E->decls()) {
6695 if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D)))
6696 ToDecls.addDecl(To);
6697 else
6698 return nullptr;
6699 }
6700
6701 TemplateArgumentListInfo ToTAInfo;
6702 TemplateArgumentListInfo *ResInfo = nullptr;
6703 if (E->hasExplicitTemplateArgs()) {
6704 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
6705 return nullptr;
6706 ResInfo = &ToTAInfo;
6707 }
6708
6709 Expr *BaseE = E->isImplicitAccess() ? nullptr : Importer.Import(E->getBase());
6710 if (!BaseE && !E->isImplicitAccess() && E->getBase()) {
6711 return nullptr;
6712 }
6713
6714 return UnresolvedMemberExpr::Create(
6715 Importer.getToContext(), E->hasUnresolvedUsing(), BaseE, BaseType,
6716 E->isArrow(), Importer.Import(E->getOperatorLoc()),
6717 Importer.Import(E->getQualifierLoc()),
6718 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo,
6719 ToDecls.begin(), ToDecls.end());
6720}
6721
Sean Callanan59721b32015-04-28 18:41:46 +00006722Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) {
6723 QualType T = Importer.Import(E->getType());
6724 if (T.isNull())
6725 return nullptr;
6726
6727 Expr *ToCallee = Importer.Import(E->getCallee());
6728 if (!ToCallee && E->getCallee())
6729 return nullptr;
6730
6731 unsigned NumArgs = E->getNumArgs();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006732 SmallVector<Expr *, 2> ToArgs(NumArgs);
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006733 if (ImportContainerChecked(E->arguments(), ToArgs))
6734 return nullptr;
Sean Callanan59721b32015-04-28 18:41:46 +00006735
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006736 auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];
Sean Callanan59721b32015-04-28 18:41:46 +00006737
6738 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
6739 ToArgs_Copied[ai] = ToArgs[ai];
6740
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006741 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
6742 return new (Importer.getToContext()) CXXOperatorCallExpr(
6743 Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T,
6744 OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()),
6745 OCE->getFPFeatures());
6746 }
6747
Sean Callanan59721b32015-04-28 18:41:46 +00006748 return new (Importer.getToContext())
Fangrui Song6907ce22018-07-30 19:24:48 +00006749 CallExpr(Importer.getToContext(), ToCallee,
Craig Topperc005cc02015-09-27 03:44:08 +00006750 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(),
Sean Callanan59721b32015-04-28 18:41:46 +00006751 Importer.Import(E->getRParenLoc()));
6752}
6753
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006754Optional<LambdaCapture>
6755ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) {
6756 VarDecl *Var = nullptr;
6757 if (From.capturesVariable()) {
6758 Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar()));
6759 if (!Var)
6760 return None;
6761 }
6762
6763 return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(),
6764 From.getCaptureKind(), Var,
6765 From.isPackExpansion()
6766 ? Importer.Import(From.getEllipsisLoc())
6767 : SourceLocation());
6768}
6769
6770Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) {
6771 CXXRecordDecl *FromClass = LE->getLambdaClass();
6772 auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass));
6773 if (!ToClass)
6774 return nullptr;
6775
6776 // NOTE: lambda classes are created with BeingDefined flag set up.
6777 // It means that ImportDefinition doesn't work for them and we should fill it
6778 // manually.
6779 if (ToClass->isBeingDefined()) {
6780 for (auto FromField : FromClass->fields()) {
6781 auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField));
6782 if (!ToField)
6783 return nullptr;
6784 }
6785 }
6786
6787 auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>(
6788 Importer.Import(LE->getCallOperator()));
6789 if (!ToCallOp)
6790 return nullptr;
6791
6792 ToClass->completeDefinition();
6793
6794 unsigned NumCaptures = LE->capture_size();
6795 SmallVector<LambdaCapture, 8> Captures;
6796 Captures.reserve(NumCaptures);
6797 for (const auto &FromCapture : LE->captures()) {
6798 if (auto ToCapture = ImportLambdaCapture(FromCapture))
6799 Captures.push_back(*ToCapture);
6800 else
6801 return nullptr;
6802 }
6803
6804 SmallVector<Expr *, 8> InitCaptures(NumCaptures);
6805 if (ImportContainerChecked(LE->capture_inits(), InitCaptures))
6806 return nullptr;
6807
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006808 return LambdaExpr::Create(
6809 Importer.getToContext(), ToClass,
6810 Importer.Import(LE->getIntroducerRange()), LE->getCaptureDefault(),
6811 Importer.Import(LE->getCaptureDefaultLoc()), Captures,
6812 LE->hasExplicitParameters(), LE->hasExplicitResultType(), InitCaptures,
6813 Importer.Import(LE->getEndLoc()), LE->containsUnexpandedParameterPack());
Aleksei Sidorin8fc85102018-01-26 11:36:54 +00006814}
6815
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006816Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) {
6817 QualType T = Importer.Import(ILE->getType());
Sean Callanan8bca9962016-03-28 21:43:01 +00006818 if (T.isNull())
6819 return nullptr;
Sean Callanan8bca9962016-03-28 21:43:01 +00006820
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006821 SmallVector<Expr *, 4> Exprs(ILE->getNumInits());
Aleksei Sidorina693b372016-09-28 10:16:56 +00006822 if (ImportContainerChecked(ILE->inits(), Exprs))
Sean Callanan8bca9962016-03-28 21:43:01 +00006823 return nullptr;
Sean Callanan8bca9962016-03-28 21:43:01 +00006824
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006825 ASTContext &ToCtx = Importer.getToContext();
6826 InitListExpr *To = new (ToCtx) InitListExpr(
6827 ToCtx, Importer.Import(ILE->getLBraceLoc()),
6828 Exprs, Importer.Import(ILE->getLBraceLoc()));
6829 To->setType(T);
6830
6831 if (ILE->hasArrayFiller()) {
6832 Expr *Filler = Importer.Import(ILE->getArrayFiller());
6833 if (!Filler)
6834 return nullptr;
6835 To->setArrayFiller(Filler);
6836 }
6837
6838 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006839 auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006840 if (!ToFD)
6841 return nullptr;
6842 To->setInitializedFieldInUnion(ToFD);
6843 }
6844
6845 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006846 auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm));
Artem Dergachev4e7c6fd2016-04-14 11:51:27 +00006847 if (!ToSyntForm)
6848 return nullptr;
6849 To->setSyntacticForm(ToSyntForm);
6850 }
6851
6852 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator());
6853 To->setValueDependent(ILE->isValueDependent());
6854 To->setInstantiationDependent(ILE->isInstantiationDependent());
6855
6856 return To;
Sean Callanan8bca9962016-03-28 21:43:01 +00006857}
6858
Gabor Marton07b01ff2018-06-29 12:17:34 +00006859Expr *ASTNodeImporter::VisitCXXStdInitializerListExpr(
6860 CXXStdInitializerListExpr *E) {
6861 QualType T = Importer.Import(E->getType());
6862 if (T.isNull())
6863 return nullptr;
6864
6865 Expr *SE = Importer.Import(E->getSubExpr());
6866 if (!SE)
6867 return nullptr;
6868
6869 return new (Importer.getToContext()) CXXStdInitializerListExpr(T, SE);
6870}
6871
Balazs Keri95baa842018-07-25 10:21:06 +00006872Expr *ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
6873 CXXInheritedCtorInitExpr *E) {
6874 QualType T = Importer.Import(E->getType());
6875 if (T.isNull())
6876 return nullptr;
6877
6878 auto *Ctor = cast_or_null<CXXConstructorDecl>(Importer.Import(
6879 E->getConstructor()));
6880 if (!Ctor)
6881 return nullptr;
6882
6883 return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
6884 Importer.Import(E->getLocation()), T, Ctor,
6885 E->constructsVBase(), E->inheritedFromVBase());
6886}
6887
Richard Smith30e304e2016-12-14 00:03:17 +00006888Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
6889 QualType ToType = Importer.Import(E->getType());
6890 if (ToType.isNull())
6891 return nullptr;
6892
6893 Expr *ToCommon = Importer.Import(E->getCommonExpr());
6894 if (!ToCommon && E->getCommonExpr())
6895 return nullptr;
6896
6897 Expr *ToSubExpr = Importer.Import(E->getSubExpr());
6898 if (!ToSubExpr && E->getSubExpr())
6899 return nullptr;
6900
6901 return new (Importer.getToContext())
6902 ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr);
6903}
6904
6905Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
6906 QualType ToType = Importer.Import(E->getType());
6907 if (ToType.isNull())
6908 return nullptr;
6909 return new (Importer.getToContext()) ArrayInitIndexExpr(ToType);
6910}
6911
Sean Callanandd2c1742016-05-16 20:48:03 +00006912Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006913 auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField()));
Sean Callanandd2c1742016-05-16 20:48:03 +00006914 if (!ToField && DIE->getField())
6915 return nullptr;
6916
6917 return CXXDefaultInitExpr::Create(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006918 Importer.getToContext(), Importer.Import(DIE->getBeginLoc()), ToField);
Sean Callanandd2c1742016-05-16 20:48:03 +00006919}
6920
6921Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
6922 QualType ToType = Importer.Import(E->getType());
6923 if (ToType.isNull() && !E->getType().isNull())
6924 return nullptr;
6925 ExprValueKind VK = E->getValueKind();
6926 CastKind CK = E->getCastKind();
6927 Expr *ToOp = Importer.Import(E->getSubExpr());
6928 if (!ToOp && E->getSubExpr())
6929 return nullptr;
6930 CXXCastPath BasePath;
6931 if (ImportCastPath(E, BasePath))
6932 return nullptr;
6933 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten());
6934 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc());
6935 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc());
6936 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets());
Fangrui Song6907ce22018-07-30 19:24:48 +00006937
Sean Callanandd2c1742016-05-16 20:48:03 +00006938 if (isa<CXXStaticCastExpr>(E)) {
6939 return CXXStaticCastExpr::Create(
Fangrui Song6907ce22018-07-30 19:24:48 +00006940 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
Sean Callanandd2c1742016-05-16 20:48:03 +00006941 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6942 } else if (isa<CXXDynamicCastExpr>(E)) {
6943 return CXXDynamicCastExpr::Create(
Fangrui Song6907ce22018-07-30 19:24:48 +00006944 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
Sean Callanandd2c1742016-05-16 20:48:03 +00006945 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
6946 } else if (isa<CXXReinterpretCastExpr>(E)) {
6947 return CXXReinterpretCastExpr::Create(
Fangrui Song6907ce22018-07-30 19:24:48 +00006948 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath,
Sean Callanandd2c1742016-05-16 20:48:03 +00006949 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
Raphael Isemannc705bb82018-08-20 16:20:01 +00006950 } else if (isa<CXXConstCastExpr>(E)) {
6951 return CXXConstCastExpr::Create(Importer.getToContext(), ToType, VK, ToOp,
6952 ToWritten, ToOperatorLoc, ToRParenLoc,
6953 ToAngleBrackets);
Sean Callanandd2c1742016-05-16 20:48:03 +00006954 } else {
6955 return nullptr;
6956 }
6957}
6958
Aleksei Sidorin855086d2017-01-23 09:30:36 +00006959Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
6960 SubstNonTypeTemplateParmExpr *E) {
6961 QualType T = Importer.Import(E->getType());
6962 if (T.isNull())
6963 return nullptr;
6964
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00006965 auto *Param = cast_or_null<NonTypeTemplateParmDecl>(
Aleksei Sidorin855086d2017-01-23 09:30:36 +00006966 Importer.Import(E->getParameter()));
6967 if (!Param)
6968 return nullptr;
6969
6970 Expr *Replacement = Importer.Import(E->getReplacement());
6971 if (!Replacement)
6972 return nullptr;
6973
6974 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
6975 T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param,
6976 Replacement);
6977}
6978
Aleksei Sidorinb05f37a2017-11-26 17:04:06 +00006979Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
6980 QualType ToType = Importer.Import(E->getType());
6981 if (ToType.isNull())
6982 return nullptr;
6983
6984 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
6985 if (ImportContainerChecked(E->getArgs(), ToArgs))
6986 return nullptr;
6987
6988 // According to Sema::BuildTypeTrait(), if E is value-dependent,
6989 // Value is always false.
6990 bool ToValue = false;
6991 if (!E->isValueDependent())
6992 ToValue = E->getValue();
6993
6994 return TypeTraitExpr::Create(
Stephen Kellyf2ceec42018-08-09 21:08:08 +00006995 Importer.getToContext(), ToType, Importer.Import(E->getBeginLoc()),
Stephen Kelly1c301dc2018-08-09 21:09:38 +00006996 E->getTrait(), ToArgs, Importer.Import(E->getEndLoc()), ToValue);
Aleksei Sidorinb05f37a2017-11-26 17:04:06 +00006997}
6998
Gabor Horvathc78d99a2018-01-27 16:11:45 +00006999Expr *ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
7000 QualType ToType = Importer.Import(E->getType());
7001 if (ToType.isNull())
7002 return nullptr;
7003
7004 if (E->isTypeOperand()) {
7005 TypeSourceInfo *TSI = Importer.Import(E->getTypeOperandSourceInfo());
7006 if (!TSI)
7007 return nullptr;
7008
7009 return new (Importer.getToContext())
7010 CXXTypeidExpr(ToType, TSI, Importer.Import(E->getSourceRange()));
7011 }
7012
7013 Expr *Op = Importer.Import(E->getExprOperand());
7014 if (!Op)
7015 return nullptr;
7016
7017 return new (Importer.getToContext())
7018 CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange()));
7019}
7020
Lang Hames19e07e12017-06-20 21:06:00 +00007021void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod,
7022 CXXMethodDecl *FromMethod) {
7023 for (auto *FromOverriddenMethod : FromMethod->overridden_methods())
7024 ToMethod->addOverriddenMethod(
7025 cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>(
7026 FromOverriddenMethod))));
7027}
7028
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00007029ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
Douglas Gregor0a791672011-01-18 03:11:38 +00007030 ASTContext &FromContext, FileManager &FromFileManager,
7031 bool MinimalImport)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007032 : ToContext(ToContext), FromContext(FromContext),
7033 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
7034 Minimal(MinimalImport) {
Douglas Gregor62d311f2010-02-09 19:21:46 +00007035 ImportedDecls[FromContext.getTranslationUnitDecl()]
7036 = ToContext.getTranslationUnitDecl();
7037}
7038
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007039ASTImporter::~ASTImporter() = default;
Douglas Gregor96e578d2010-02-05 17:54:41 +00007040
7041QualType ASTImporter::Import(QualType FromT) {
7042 if (FromT.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007043 return {};
John McCall424cec92011-01-19 06:33:43 +00007044
7045 const Type *fromTy = FromT.getTypePtr();
Fangrui Song6907ce22018-07-30 19:24:48 +00007046
7047 // Check whether we've already imported this type.
John McCall424cec92011-01-19 06:33:43 +00007048 llvm::DenseMap<const Type *, const Type *>::iterator Pos
7049 = ImportedTypes.find(fromTy);
Douglas Gregorf65bbb32010-02-08 15:18:58 +00007050 if (Pos != ImportedTypes.end())
John McCall424cec92011-01-19 06:33:43 +00007051 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
Fangrui Song6907ce22018-07-30 19:24:48 +00007052
Douglas Gregorf65bbb32010-02-08 15:18:58 +00007053 // Import the type
Douglas Gregor96e578d2010-02-05 17:54:41 +00007054 ASTNodeImporter Importer(*this);
John McCall424cec92011-01-19 06:33:43 +00007055 QualType ToT = Importer.Visit(fromTy);
Douglas Gregor96e578d2010-02-05 17:54:41 +00007056 if (ToT.isNull())
7057 return ToT;
Fangrui Song6907ce22018-07-30 19:24:48 +00007058
Douglas Gregorf65bbb32010-02-08 15:18:58 +00007059 // Record the imported type.
John McCall424cec92011-01-19 06:33:43 +00007060 ImportedTypes[fromTy] = ToT.getTypePtr();
Fangrui Song6907ce22018-07-30 19:24:48 +00007061
John McCall424cec92011-01-19 06:33:43 +00007062 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers());
Douglas Gregor96e578d2010-02-05 17:54:41 +00007063}
7064
Douglas Gregor62d311f2010-02-09 19:21:46 +00007065TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) {
Douglas Gregorfa7a0e52010-02-10 17:47:19 +00007066 if (!FromTSI)
7067 return FromTSI;
7068
7069 // FIXME: For now we just create a "trivial" type source info based
Nick Lewycky19b9f952010-07-26 16:56:01 +00007070 // on the type and a single location. Implement a real version of this.
Douglas Gregorfa7a0e52010-02-10 17:47:19 +00007071 QualType T = Import(FromTSI->getType());
7072 if (T.isNull())
Craig Topper36250ad2014-05-12 05:36:57 +00007073 return nullptr;
Douglas Gregorfa7a0e52010-02-10 17:47:19 +00007074
Stephen Kellyf2ceec42018-08-09 21:08:08 +00007075 return ToContext.getTrivialTypeSourceInfo(
7076 T, Import(FromTSI->getTypeLoc().getBeginLoc()));
Douglas Gregor62d311f2010-02-09 19:21:46 +00007077}
7078
Aleksei Sidorin8f266db2018-05-08 12:45:21 +00007079Attr *ASTImporter::Import(const Attr *FromAttr) {
7080 Attr *ToAttr = FromAttr->clone(ToContext);
7081 ToAttr->setRange(Import(FromAttr->getRange()));
7082 return ToAttr;
7083}
7084
Sean Callanan59721b32015-04-28 18:41:46 +00007085Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) {
7086 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD);
7087 if (Pos != ImportedDecls.end()) {
7088 Decl *ToD = Pos->second;
Gabor Marton26f72a92018-07-12 09:42:05 +00007089 // FIXME: move this call to ImportDeclParts().
Sean Callanan59721b32015-04-28 18:41:46 +00007090 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD);
7091 return ToD;
7092 } else {
7093 return nullptr;
7094 }
7095}
7096
Douglas Gregor62d311f2010-02-09 19:21:46 +00007097Decl *ASTImporter::Import(Decl *FromD) {
7098 if (!FromD)
Craig Topper36250ad2014-05-12 05:36:57 +00007099 return nullptr;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007100
Douglas Gregord451ea92011-07-29 23:31:30 +00007101 ASTNodeImporter Importer(*this);
7102
Gabor Marton26f72a92018-07-12 09:42:05 +00007103 // Check whether we've already imported this declaration.
7104 Decl *ToD = GetAlreadyImportedOrNull(FromD);
7105 if (ToD) {
7106 // If FromD has some updated flags after last import, apply it
7107 updateFlags(FromD, ToD);
Douglas Gregord451ea92011-07-29 23:31:30 +00007108 return ToD;
7109 }
Gabor Marton26f72a92018-07-12 09:42:05 +00007110
7111 // Import the type.
7112 ToD = Importer.Visit(FromD);
Douglas Gregor62d311f2010-02-09 19:21:46 +00007113 if (!ToD)
Craig Topper36250ad2014-05-12 05:36:57 +00007114 return nullptr;
7115
Gabor Marton26f72a92018-07-12 09:42:05 +00007116 // Notify subclasses.
7117 Imported(FromD, ToD);
7118
Douglas Gregor62d311f2010-02-09 19:21:46 +00007119 return ToD;
7120}
7121
7122DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) {
7123 if (!FromDC)
7124 return FromDC;
7125
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007126 auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC)));
Douglas Gregor2e15c842012-02-01 21:00:38 +00007127 if (!ToDC)
Craig Topper36250ad2014-05-12 05:36:57 +00007128 return nullptr;
7129
Fangrui Song6907ce22018-07-30 19:24:48 +00007130 // When we're using a record/enum/Objective-C class/protocol as a context, we
Douglas Gregor2e15c842012-02-01 21:00:38 +00007131 // need it to have a definition.
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007132 if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
7133 auto *FromRecord = cast<RecordDecl>(FromDC);
Douglas Gregor2e15c842012-02-01 21:00:38 +00007134 if (ToRecord->isCompleteDefinition()) {
7135 // Do nothing.
7136 } else if (FromRecord->isCompleteDefinition()) {
7137 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord,
7138 ASTNodeImporter::IDK_Basic);
7139 } else {
7140 CompleteDecl(ToRecord);
7141 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007142 } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
7143 auto *FromEnum = cast<EnumDecl>(FromDC);
Douglas Gregor2e15c842012-02-01 21:00:38 +00007144 if (ToEnum->isCompleteDefinition()) {
7145 // Do nothing.
7146 } else if (FromEnum->isCompleteDefinition()) {
7147 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum,
7148 ASTNodeImporter::IDK_Basic);
7149 } else {
7150 CompleteDecl(ToEnum);
Fangrui Song6907ce22018-07-30 19:24:48 +00007151 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007152 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
7153 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
Douglas Gregor2e15c842012-02-01 21:00:38 +00007154 if (ToClass->getDefinition()) {
7155 // Do nothing.
7156 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
7157 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass,
7158 ASTNodeImporter::IDK_Basic);
7159 } else {
7160 CompleteDecl(ToClass);
7161 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007162 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
7163 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
Douglas Gregor2e15c842012-02-01 21:00:38 +00007164 if (ToProto->getDefinition()) {
7165 // Do nothing.
7166 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
7167 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto,
7168 ASTNodeImporter::IDK_Basic);
7169 } else {
7170 CompleteDecl(ToProto);
Fangrui Song6907ce22018-07-30 19:24:48 +00007171 }
Douglas Gregor95d82832012-01-24 18:36:04 +00007172 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007173
Douglas Gregor95d82832012-01-24 18:36:04 +00007174 return ToDC;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007175}
7176
7177Expr *ASTImporter::Import(Expr *FromE) {
7178 if (!FromE)
Craig Topper36250ad2014-05-12 05:36:57 +00007179 return nullptr;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007180
7181 return cast_or_null<Expr>(Import(cast<Stmt>(FromE)));
7182}
7183
7184Stmt *ASTImporter::Import(Stmt *FromS) {
7185 if (!FromS)
Craig Topper36250ad2014-05-12 05:36:57 +00007186 return nullptr;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007187
Fangrui Song6907ce22018-07-30 19:24:48 +00007188 // Check whether we've already imported this declaration.
Douglas Gregor7eeb5972010-02-11 19:21:55 +00007189 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
7190 if (Pos != ImportedStmts.end())
7191 return Pos->second;
Fangrui Song6907ce22018-07-30 19:24:48 +00007192
Douglas Gregor7eeb5972010-02-11 19:21:55 +00007193 // Import the type
7194 ASTNodeImporter Importer(*this);
7195 Stmt *ToS = Importer.Visit(FromS);
7196 if (!ToS)
Craig Topper36250ad2014-05-12 05:36:57 +00007197 return nullptr;
7198
Douglas Gregor7eeb5972010-02-11 19:21:55 +00007199 // Record the imported declaration.
7200 ImportedStmts[FromS] = ToS;
7201 return ToS;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007202}
7203
7204NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) {
7205 if (!FromNNS)
Craig Topper36250ad2014-05-12 05:36:57 +00007206 return nullptr;
Douglas Gregor62d311f2010-02-09 19:21:46 +00007207
Douglas Gregor90ebf252011-04-27 16:48:40 +00007208 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix());
7209
7210 switch (FromNNS->getKind()) {
7211 case NestedNameSpecifier::Identifier:
7212 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) {
7213 return NestedNameSpecifier::Create(ToContext, prefix, II);
7214 }
Craig Topper36250ad2014-05-12 05:36:57 +00007215 return nullptr;
Douglas Gregor90ebf252011-04-27 16:48:40 +00007216
7217 case NestedNameSpecifier::Namespace:
Fangrui Song6907ce22018-07-30 19:24:48 +00007218 if (auto *NS =
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007219 cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) {
Douglas Gregor90ebf252011-04-27 16:48:40 +00007220 return NestedNameSpecifier::Create(ToContext, prefix, NS);
7221 }
Craig Topper36250ad2014-05-12 05:36:57 +00007222 return nullptr;
Douglas Gregor90ebf252011-04-27 16:48:40 +00007223
7224 case NestedNameSpecifier::NamespaceAlias:
Fangrui Song6907ce22018-07-30 19:24:48 +00007225 if (auto *NSAD =
Aleksei Sidorin855086d2017-01-23 09:30:36 +00007226 cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) {
Douglas Gregor90ebf252011-04-27 16:48:40 +00007227 return NestedNameSpecifier::Create(ToContext, prefix, NSAD);
7228 }
Craig Topper36250ad2014-05-12 05:36:57 +00007229 return nullptr;
Douglas Gregor90ebf252011-04-27 16:48:40 +00007230
7231 case NestedNameSpecifier::Global:
7232 return NestedNameSpecifier::GlobalSpecifier(ToContext);
7233
Nikola Smiljanic67860242014-09-26 00:28:20 +00007234 case NestedNameSpecifier::Super:
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007235 if (auto *RD =
Aleksei Sidorin855086d2017-01-23 09:30:36 +00007236 cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) {
Nikola Smiljanic67860242014-09-26 00:28:20 +00007237 return NestedNameSpecifier::SuperSpecifier(ToContext, RD);
7238 }
7239 return nullptr;
7240
Douglas Gregor90ebf252011-04-27 16:48:40 +00007241 case NestedNameSpecifier::TypeSpec:
7242 case NestedNameSpecifier::TypeSpecWithTemplate: {
7243 QualType T = Import(QualType(FromNNS->getAsType(), 0u));
7244 if (!T.isNull()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00007245 bool bTemplate = FromNNS->getKind() ==
Douglas Gregor90ebf252011-04-27 16:48:40 +00007246 NestedNameSpecifier::TypeSpecWithTemplate;
Fangrui Song6907ce22018-07-30 19:24:48 +00007247 return NestedNameSpecifier::Create(ToContext, prefix,
Douglas Gregor90ebf252011-04-27 16:48:40 +00007248 bTemplate, T.getTypePtr());
7249 }
7250 }
Craig Topper36250ad2014-05-12 05:36:57 +00007251 return nullptr;
Douglas Gregor90ebf252011-04-27 16:48:40 +00007252 }
7253
7254 llvm_unreachable("Invalid nested name specifier kind");
Douglas Gregor62d311f2010-02-09 19:21:46 +00007255}
7256
Douglas Gregor14454802011-02-25 02:25:35 +00007257NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
Aleksei Sidorin855086d2017-01-23 09:30:36 +00007258 // Copied from NestedNameSpecifier mostly.
7259 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
7260 NestedNameSpecifierLoc NNS = FromNNS;
7261
7262 // Push each of the nested-name-specifiers's onto a stack for
7263 // serialization in reverse order.
7264 while (NNS) {
7265 NestedNames.push_back(NNS);
7266 NNS = NNS.getPrefix();
7267 }
7268
7269 NestedNameSpecifierLocBuilder Builder;
7270
7271 while (!NestedNames.empty()) {
7272 NNS = NestedNames.pop_back_val();
7273 NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier());
7274 if (!Spec)
7275 return NestedNameSpecifierLoc();
7276
7277 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
7278 switch (Kind) {
7279 case NestedNameSpecifier::Identifier:
7280 Builder.Extend(getToContext(),
7281 Spec->getAsIdentifier(),
7282 Import(NNS.getLocalBeginLoc()),
7283 Import(NNS.getLocalEndLoc()));
7284 break;
7285
7286 case NestedNameSpecifier::Namespace:
7287 Builder.Extend(getToContext(),
7288 Spec->getAsNamespace(),
7289 Import(NNS.getLocalBeginLoc()),
7290 Import(NNS.getLocalEndLoc()));
7291 break;
7292
7293 case NestedNameSpecifier::NamespaceAlias:
7294 Builder.Extend(getToContext(),
7295 Spec->getAsNamespaceAlias(),
7296 Import(NNS.getLocalBeginLoc()),
7297 Import(NNS.getLocalEndLoc()));
7298 break;
7299
7300 case NestedNameSpecifier::TypeSpec:
7301 case NestedNameSpecifier::TypeSpecWithTemplate: {
7302 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
7303 QualType(Spec->getAsType(), 0));
7304 Builder.Extend(getToContext(),
7305 Import(NNS.getLocalBeginLoc()),
7306 TSI->getTypeLoc(),
7307 Import(NNS.getLocalEndLoc()));
7308 break;
7309 }
7310
7311 case NestedNameSpecifier::Global:
7312 Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc()));
7313 break;
7314
7315 case NestedNameSpecifier::Super: {
7316 SourceRange ToRange = Import(NNS.getSourceRange());
7317 Builder.MakeSuper(getToContext(),
7318 Spec->getAsRecordDecl(),
7319 ToRange.getBegin(),
7320 ToRange.getEnd());
7321 }
7322 }
7323 }
7324
7325 return Builder.getWithLocInContext(getToContext());
Douglas Gregor14454802011-02-25 02:25:35 +00007326}
7327
Douglas Gregore2e50d332010-12-01 01:36:18 +00007328TemplateName ASTImporter::Import(TemplateName From) {
7329 switch (From.getKind()) {
7330 case TemplateName::Template:
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007331 if (auto *ToTemplate =
7332 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
Douglas Gregore2e50d332010-12-01 01:36:18 +00007333 return TemplateName(ToTemplate);
Fangrui Song6907ce22018-07-30 19:24:48 +00007334
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007335 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007336
Douglas Gregore2e50d332010-12-01 01:36:18 +00007337 case TemplateName::OverloadedTemplate: {
7338 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
7339 UnresolvedSet<2> ToTemplates;
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007340 for (auto *I : *FromStorage) {
Fangrui Song6907ce22018-07-30 19:24:48 +00007341 if (auto *To = cast_or_null<NamedDecl>(Import(I)))
Douglas Gregore2e50d332010-12-01 01:36:18 +00007342 ToTemplates.addDecl(To);
7343 else
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007344 return {};
Douglas Gregore2e50d332010-12-01 01:36:18 +00007345 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007346 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
Douglas Gregore2e50d332010-12-01 01:36:18 +00007347 ToTemplates.end());
7348 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007349
Douglas Gregore2e50d332010-12-01 01:36:18 +00007350 case TemplateName::QualifiedTemplate: {
7351 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
7352 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier());
7353 if (!Qualifier)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007354 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007355
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007356 if (auto *ToTemplate =
7357 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl())))
Fangrui Song6907ce22018-07-30 19:24:48 +00007358 return ToContext.getQualifiedTemplateName(Qualifier,
7359 QTN->hasTemplateKeyword(),
Douglas Gregore2e50d332010-12-01 01:36:18 +00007360 ToTemplate);
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007361
7362 return {};
Douglas Gregore2e50d332010-12-01 01:36:18 +00007363 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007364
Douglas Gregore2e50d332010-12-01 01:36:18 +00007365 case TemplateName::DependentTemplate: {
7366 DependentTemplateName *DTN = From.getAsDependentTemplateName();
7367 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier());
7368 if (!Qualifier)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007369 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007370
Douglas Gregore2e50d332010-12-01 01:36:18 +00007371 if (DTN->isIdentifier()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00007372 return ToContext.getDependentTemplateName(Qualifier,
Douglas Gregore2e50d332010-12-01 01:36:18 +00007373 Import(DTN->getIdentifier()));
7374 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007375
Douglas Gregore2e50d332010-12-01 01:36:18 +00007376 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator());
7377 }
John McCalld9dfe3a2011-06-30 08:33:18 +00007378
7379 case TemplateName::SubstTemplateTemplateParm: {
7380 SubstTemplateTemplateParmStorage *subst
7381 = From.getAsSubstTemplateTemplateParm();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007382 auto *param =
7383 cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter()));
John McCalld9dfe3a2011-06-30 08:33:18 +00007384 if (!param)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007385 return {};
John McCalld9dfe3a2011-06-30 08:33:18 +00007386
7387 TemplateName replacement = Import(subst->getReplacement());
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007388 if (replacement.isNull())
7389 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007390
John McCalld9dfe3a2011-06-30 08:33:18 +00007391 return ToContext.getSubstTemplateTemplateParm(param, replacement);
7392 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007393
Douglas Gregor5590be02011-01-15 06:45:20 +00007394 case TemplateName::SubstTemplateTemplateParmPack: {
7395 SubstTemplateTemplateParmPackStorage *SubstPack
7396 = From.getAsSubstTemplateTemplateParmPack();
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007397 auto *Param =
7398 cast_or_null<TemplateTemplateParmDecl>(
7399 Import(SubstPack->getParameterPack()));
Douglas Gregor5590be02011-01-15 06:45:20 +00007400 if (!Param)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007401 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007402
Douglas Gregor5590be02011-01-15 06:45:20 +00007403 ASTNodeImporter Importer(*this);
Fangrui Song6907ce22018-07-30 19:24:48 +00007404 TemplateArgument ArgPack
Douglas Gregor5590be02011-01-15 06:45:20 +00007405 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
7406 if (ArgPack.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007407 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +00007408
Douglas Gregor5590be02011-01-15 06:45:20 +00007409 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack);
7410 }
Douglas Gregore2e50d332010-12-01 01:36:18 +00007411 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007412
Douglas Gregore2e50d332010-12-01 01:36:18 +00007413 llvm_unreachable("Invalid template name kind");
Douglas Gregore2e50d332010-12-01 01:36:18 +00007414}
7415
Douglas Gregor62d311f2010-02-09 19:21:46 +00007416SourceLocation ASTImporter::Import(SourceLocation FromLoc) {
7417 if (FromLoc.isInvalid())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007418 return {};
Douglas Gregor62d311f2010-02-09 19:21:46 +00007419
Douglas Gregor811663e2010-02-10 00:15:17 +00007420 SourceManager &FromSM = FromContext.getSourceManager();
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007421
Douglas Gregor811663e2010-02-10 00:15:17 +00007422 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
Sean Callanan238d8972014-12-10 01:26:39 +00007423 FileID ToFileID = Import(Decomposed.first);
7424 if (ToFileID.isInvalid())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007425 return {};
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007426 SourceManager &ToSM = ToContext.getSourceManager();
7427 return ToSM.getComposedLoc(ToFileID, Decomposed.second);
Douglas Gregor62d311f2010-02-09 19:21:46 +00007428}
7429
7430SourceRange ASTImporter::Import(SourceRange FromRange) {
7431 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd()));
7432}
7433
Douglas Gregor811663e2010-02-10 00:15:17 +00007434FileID ASTImporter::Import(FileID FromID) {
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007435 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
Douglas Gregor811663e2010-02-10 00:15:17 +00007436 if (Pos != ImportedFileIDs.end())
7437 return Pos->second;
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007438
Douglas Gregor811663e2010-02-10 00:15:17 +00007439 SourceManager &FromSM = FromContext.getSourceManager();
7440 SourceManager &ToSM = ToContext.getSourceManager();
7441 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007442
7443 // Map the FromID to the "to" source manager.
Douglas Gregor811663e2010-02-10 00:15:17 +00007444 FileID ToID;
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007445 if (FromSLoc.isExpansion()) {
7446 const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
7447 SourceLocation ToSpLoc = Import(FromEx.getSpellingLoc());
7448 SourceLocation ToExLocS = Import(FromEx.getExpansionLocStart());
7449 unsigned TokenLen = FromSM.getFileIDSize(FromID);
7450 SourceLocation MLoc;
7451 if (FromEx.isMacroArgExpansion()) {
7452 MLoc = ToSM.createMacroArgExpansionLoc(ToSpLoc, ToExLocS, TokenLen);
7453 } else {
7454 SourceLocation ToExLocE = Import(FromEx.getExpansionLocEnd());
7455 MLoc = ToSM.createExpansionLoc(ToSpLoc, ToExLocS, ToExLocE, TokenLen,
7456 FromEx.isExpansionTokenRange());
7457 }
7458 ToID = ToSM.getFileID(MLoc);
Douglas Gregor811663e2010-02-10 00:15:17 +00007459 } else {
Rafael Stahl29f37fb2018-07-04 13:34:05 +00007460 // Include location of this file.
7461 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
7462
7463 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache();
7464 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
7465 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
7466 // disk again
7467 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
7468 // than mmap the files several times.
7469 const FileEntry *Entry =
7470 ToFileManager.getFile(Cache->OrigEntry->getName());
7471 if (!Entry)
7472 return {};
7473 ToID = ToSM.createFileID(Entry, ToIncludeLoc,
7474 FromSLoc.getFile().getFileCharacteristic());
7475 } else {
7476 // FIXME: We want to re-use the existing MemoryBuffer!
7477 const llvm::MemoryBuffer *FromBuf =
7478 Cache->getBuffer(FromContext.getDiagnostics(), FromSM);
7479 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
7480 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
7481 FromBuf->getBufferIdentifier());
7482 ToID = ToSM.createFileID(std::move(ToBuf),
7483 FromSLoc.getFile().getFileCharacteristic());
7484 }
Douglas Gregor811663e2010-02-10 00:15:17 +00007485 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007486
Sebastian Redl99219f12010-09-30 01:03:06 +00007487 ImportedFileIDs[FromID] = ToID;
Douglas Gregor811663e2010-02-10 00:15:17 +00007488 return ToID;
7489}
7490
Sean Callanandd2c1742016-05-16 20:48:03 +00007491CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) {
7492 Expr *ToExpr = Import(From->getInit());
7493 if (!ToExpr && From->getInit())
7494 return nullptr;
7495
7496 if (From->isBaseInitializer()) {
7497 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7498 if (!ToTInfo && From->getTypeSourceInfo())
7499 return nullptr;
7500
7501 return new (ToContext) CXXCtorInitializer(
7502 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()),
7503 ToExpr, Import(From->getRParenLoc()),
7504 From->isPackExpansion() ? Import(From->getEllipsisLoc())
7505 : SourceLocation());
7506 } else if (From->isMemberInitializer()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007507 auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember()));
Sean Callanandd2c1742016-05-16 20:48:03 +00007508 if (!ToField && From->getMember())
7509 return nullptr;
7510
7511 return new (ToContext) CXXCtorInitializer(
7512 ToContext, ToField, Import(From->getMemberLocation()),
7513 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7514 } else if (From->isIndirectMemberInitializer()) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007515 auto *ToIField = cast_or_null<IndirectFieldDecl>(
Sean Callanandd2c1742016-05-16 20:48:03 +00007516 Import(From->getIndirectMember()));
7517 if (!ToIField && From->getIndirectMember())
7518 return nullptr;
7519
7520 return new (ToContext) CXXCtorInitializer(
7521 ToContext, ToIField, Import(From->getMemberLocation()),
7522 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc()));
7523 } else if (From->isDelegatingInitializer()) {
7524 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo());
7525 if (!ToTInfo && From->getTypeSourceInfo())
7526 return nullptr;
7527
7528 return new (ToContext)
7529 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()),
7530 ToExpr, Import(From->getRParenLoc()));
Sean Callanandd2c1742016-05-16 20:48:03 +00007531 } else {
7532 return nullptr;
7533 }
7534}
7535
Aleksei Sidorina693b372016-09-28 10:16:56 +00007536CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
7537 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
7538 if (Pos != ImportedCXXBaseSpecifiers.end())
7539 return Pos->second;
7540
7541 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
7542 Import(BaseSpec->getSourceRange()),
7543 BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
7544 BaseSpec->getAccessSpecifierAsWritten(),
7545 Import(BaseSpec->getTypeSourceInfo()),
7546 Import(BaseSpec->getEllipsisLoc()));
7547 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
7548 return Imported;
7549}
7550
Douglas Gregor0a791672011-01-18 03:11:38 +00007551void ASTImporter::ImportDefinition(Decl *From) {
7552 Decl *To = Import(From);
7553 if (!To)
7554 return;
Fangrui Song6907ce22018-07-30 19:24:48 +00007555
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007556 if (auto *FromDC = cast<DeclContext>(From)) {
Douglas Gregor0a791672011-01-18 03:11:38 +00007557 ASTNodeImporter Importer(*this);
Fangrui Song6907ce22018-07-30 19:24:48 +00007558
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007559 if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
Sean Callanan53a6bff2011-07-19 22:38:25 +00007560 if (!ToRecord->getDefinition()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00007561 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
Douglas Gregor95d82832012-01-24 18:36:04 +00007562 ASTNodeImporter::IDK_Everything);
Sean Callanan53a6bff2011-07-19 22:38:25 +00007563 return;
Fangrui Song6907ce22018-07-30 19:24:48 +00007564 }
Sean Callanan53a6bff2011-07-19 22:38:25 +00007565 }
Douglas Gregord451ea92011-07-29 23:31:30 +00007566
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007567 if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
Douglas Gregord451ea92011-07-29 23:31:30 +00007568 if (!ToEnum->getDefinition()) {
Fangrui Song6907ce22018-07-30 19:24:48 +00007569 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
Douglas Gregor2e15c842012-02-01 21:00:38 +00007570 ASTNodeImporter::IDK_Everything);
Douglas Gregord451ea92011-07-29 23:31:30 +00007571 return;
Fangrui Song6907ce22018-07-30 19:24:48 +00007572 }
Douglas Gregord451ea92011-07-29 23:31:30 +00007573 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007574
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007575 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
Douglas Gregor2aa53772012-01-24 17:42:07 +00007576 if (!ToIFace->getDefinition()) {
7577 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
Douglas Gregor2e15c842012-02-01 21:00:38 +00007578 ASTNodeImporter::IDK_Everything);
Douglas Gregor2aa53772012-01-24 17:42:07 +00007579 return;
7580 }
7581 }
Douglas Gregord451ea92011-07-29 23:31:30 +00007582
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007583 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
Douglas Gregor2aa53772012-01-24 17:42:07 +00007584 if (!ToProto->getDefinition()) {
7585 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
Douglas Gregor2e15c842012-02-01 21:00:38 +00007586 ASTNodeImporter::IDK_Everything);
Douglas Gregor2aa53772012-01-24 17:42:07 +00007587 return;
7588 }
7589 }
Fangrui Song6907ce22018-07-30 19:24:48 +00007590
Douglas Gregor0a791672011-01-18 03:11:38 +00007591 Importer.ImportDeclContext(FromDC, true);
7592 }
7593}
7594
Douglas Gregor96e578d2010-02-05 17:54:41 +00007595DeclarationName ASTImporter::Import(DeclarationName FromName) {
7596 if (!FromName)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007597 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00007598
7599 switch (FromName.getNameKind()) {
7600 case DeclarationName::Identifier:
7601 return Import(FromName.getAsIdentifierInfo());
7602
7603 case DeclarationName::ObjCZeroArgSelector:
7604 case DeclarationName::ObjCOneArgSelector:
7605 case DeclarationName::ObjCMultiArgSelector:
7606 return Import(FromName.getObjCSelector());
7607
7608 case DeclarationName::CXXConstructorName: {
7609 QualType T = Import(FromName.getCXXNameType());
7610 if (T.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007611 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00007612
7613 return ToContext.DeclarationNames.getCXXConstructorName(
7614 ToContext.getCanonicalType(T));
7615 }
7616
7617 case DeclarationName::CXXDestructorName: {
7618 QualType T = Import(FromName.getCXXNameType());
7619 if (T.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007620 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00007621
7622 return ToContext.DeclarationNames.getCXXDestructorName(
7623 ToContext.getCanonicalType(T));
7624 }
7625
Richard Smith35845152017-02-07 01:37:30 +00007626 case DeclarationName::CXXDeductionGuideName: {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007627 auto *Template = cast_or_null<TemplateDecl>(
Richard Smith35845152017-02-07 01:37:30 +00007628 Import(FromName.getCXXDeductionGuideTemplate()));
7629 if (!Template)
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007630 return {};
Richard Smith35845152017-02-07 01:37:30 +00007631 return ToContext.DeclarationNames.getCXXDeductionGuideName(Template);
7632 }
7633
Douglas Gregor96e578d2010-02-05 17:54:41 +00007634 case DeclarationName::CXXConversionFunctionName: {
7635 QualType T = Import(FromName.getCXXNameType());
7636 if (T.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007637 return {};
Douglas Gregor96e578d2010-02-05 17:54:41 +00007638
7639 return ToContext.DeclarationNames.getCXXConversionFunctionName(
7640 ToContext.getCanonicalType(T));
7641 }
7642
7643 case DeclarationName::CXXOperatorName:
7644 return ToContext.DeclarationNames.getCXXOperatorName(
7645 FromName.getCXXOverloadedOperator());
7646
7647 case DeclarationName::CXXLiteralOperatorName:
7648 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
7649 Import(FromName.getCXXLiteralIdentifier()));
7650
7651 case DeclarationName::CXXUsingDirective:
7652 // FIXME: STATICS!
7653 return DeclarationName::getUsingDirectiveName();
7654 }
7655
David Blaikiee4d798f2012-01-20 21:50:17 +00007656 llvm_unreachable("Invalid DeclarationName Kind!");
Douglas Gregor96e578d2010-02-05 17:54:41 +00007657}
7658
Douglas Gregore2e50d332010-12-01 01:36:18 +00007659IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
Douglas Gregor96e578d2010-02-05 17:54:41 +00007660 if (!FromId)
Craig Topper36250ad2014-05-12 05:36:57 +00007661 return nullptr;
Douglas Gregor96e578d2010-02-05 17:54:41 +00007662
Sean Callananf94ef1d2016-05-14 06:11:19 +00007663 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
7664
7665 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
7666 ToId->setBuiltinID(FromId->getBuiltinID());
7667
7668 return ToId;
Douglas Gregor96e578d2010-02-05 17:54:41 +00007669}
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00007670
Douglas Gregor43f54792010-02-17 02:12:47 +00007671Selector ASTImporter::Import(Selector FromSel) {
7672 if (FromSel.isNull())
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007673 return {};
Douglas Gregor43f54792010-02-17 02:12:47 +00007674
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007675 SmallVector<IdentifierInfo *, 4> Idents;
Douglas Gregor43f54792010-02-17 02:12:47 +00007676 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
7677 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
7678 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
7679 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
7680}
7681
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00007682DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name,
7683 DeclContext *DC,
7684 unsigned IDNS,
7685 NamedDecl **Decls,
7686 unsigned NumDecls) {
7687 return Name;
7688}
7689
7690DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
Richard Smith5bb4cdf2012-12-20 02:22:15 +00007691 if (LastDiagFromFrom)
7692 ToContext.getDiagnostics().notePriorDiagnosticFrom(
7693 FromContext.getDiagnostics());
7694 LastDiagFromFrom = false;
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00007695 return ToContext.getDiagnostics().Report(Loc, DiagID);
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00007696}
7697
7698DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
Richard Smith5bb4cdf2012-12-20 02:22:15 +00007699 if (!LastDiagFromFrom)
7700 FromContext.getDiagnostics().notePriorDiagnosticFrom(
7701 ToContext.getDiagnostics());
7702 LastDiagFromFrom = true;
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00007703 return FromContext.getDiagnostics().Report(Loc, DiagID);
Douglas Gregor3aed6cd2010-02-08 21:09:39 +00007704}
Douglas Gregor8cdbe642010-02-12 23:44:20 +00007705
Douglas Gregor2e15c842012-02-01 21:00:38 +00007706void ASTImporter::CompleteDecl (Decl *D) {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007707 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
Douglas Gregor2e15c842012-02-01 21:00:38 +00007708 if (!ID->getDefinition())
7709 ID->startDefinition();
7710 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007711 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
Douglas Gregor2e15c842012-02-01 21:00:38 +00007712 if (!PD->getDefinition())
7713 PD->startDefinition();
7714 }
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007715 else if (auto *TD = dyn_cast<TagDecl>(D)) {
Douglas Gregor2e15c842012-02-01 21:00:38 +00007716 if (!TD->getDefinition() && !TD->isBeingDefined()) {
7717 TD->startDefinition();
7718 TD->setCompleteDefinition(true);
7719 }
7720 }
7721 else {
Eugene Zelenko9a9c8232018-04-09 21:54:38 +00007722 assert(0 && "CompleteDecl called on a Decl that can't be completed");
Douglas Gregor2e15c842012-02-01 21:00:38 +00007723 }
7724}
7725
Gabor Marton26f72a92018-07-12 09:42:05 +00007726Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
7727 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
7728 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
7729 "Try to import an already imported Decl");
7730 if (Pos != ImportedDecls.end())
7731 return Pos->second;
Douglas Gregor8cdbe642010-02-12 23:44:20 +00007732 ImportedDecls[From] = To;
7733 return To;
Daniel Dunbar9ced5422010-02-13 20:24:39 +00007734}
Douglas Gregorb4964f72010-02-15 23:54:17 +00007735
Douglas Gregordd6006f2012-07-17 21:16:27 +00007736bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
7737 bool Complain) {
John McCall424cec92011-01-19 06:33:43 +00007738 llvm::DenseMap<const Type *, const Type *>::iterator Pos
Douglas Gregorb4964f72010-02-15 23:54:17 +00007739 = ImportedTypes.find(From.getTypePtr());
7740 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To))
7741 return true;
Bruno Cardoso Lopes95ff11b2017-04-28 00:31:30 +00007742
Douglas Gregordd6006f2012-07-17 21:16:27 +00007743 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
Gabor Marton26f72a92018-07-12 09:42:05 +00007744 getStructuralEquivalenceKind(*this), false,
7745 Complain);
Gabor Marton950fb572018-07-17 12:39:27 +00007746 return Ctx.IsEquivalent(From, To);
Douglas Gregorb4964f72010-02-15 23:54:17 +00007747}