1 //===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the ASTImporter class which imports AST nodes from one
10 // context into another context.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/ASTImporter.h"
15 #include "clang/AST/ASTImporterSharedState.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTDiagnostic.h"
18 #include "clang/AST/ASTStructuralEquivalence.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclAccessPair.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclVisitor.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExprObjC.h"
33 #include "clang/AST/ExternalASTSource.h"
34 #include "clang/AST/LambdaCapture.h"
35 #include "clang/AST/NestedNameSpecifier.h"
36 #include "clang/AST/OperationKinds.h"
37 #include "clang/AST/Stmt.h"
38 #include "clang/AST/StmtCXX.h"
39 #include "clang/AST/StmtObjC.h"
40 #include "clang/AST/StmtVisitor.h"
41 #include "clang/AST/TemplateBase.h"
42 #include "clang/AST/TemplateName.h"
43 #include "clang/AST/Type.h"
44 #include "clang/AST/TypeLoc.h"
45 #include "clang/AST/TypeVisitor.h"
46 #include "clang/AST/UnresolvedSet.h"
47 #include "clang/Basic/Builtins.h"
48 #include "clang/Basic/ExceptionSpecificationType.h"
49 #include "clang/Basic/FileManager.h"
50 #include "clang/Basic/IdentifierTable.h"
51 #include "clang/Basic/LLVM.h"
52 #include "clang/Basic/LangOptions.h"
53 #include "clang/Basic/SourceLocation.h"
54 #include "clang/Basic/SourceManager.h"
55 #include "clang/Basic/Specifiers.h"
56 #include "llvm/ADT/APSInt.h"
57 #include "llvm/ADT/ArrayRef.h"
58 #include "llvm/ADT/DenseMap.h"
59 #include "llvm/ADT/None.h"
60 #include "llvm/ADT/Optional.h"
61 #include "llvm/ADT/ScopeExit.h"
62 #include "llvm/ADT/STLExtras.h"
63 #include "llvm/ADT/SmallVector.h"
64 #include "llvm/Support/Casting.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/MemoryBuffer.h"
67 #include <algorithm>
68 #include <cassert>
69 #include <cstddef>
70 #include <memory>
71 #include <type_traits>
72 #include <utility>
73
74 namespace clang {
75
76 using llvm::make_error;
77 using llvm::Error;
78 using llvm::Expected;
79 using ExpectedTypePtr = llvm::Expected<const Type *>;
80 using ExpectedType = llvm::Expected<QualType>;
81 using ExpectedStmt = llvm::Expected<Stmt *>;
82 using ExpectedExpr = llvm::Expected<Expr *>;
83 using ExpectedDecl = llvm::Expected<Decl *>;
84 using ExpectedSLoc = llvm::Expected<SourceLocation>;
85 using ExpectedName = llvm::Expected<DeclarationName>;
86
toString() const87 std::string ImportError::toString() const {
88 // FIXME: Improve error texts.
89 switch (Error) {
90 case NameConflict:
91 return "NameConflict";
92 case UnsupportedConstruct:
93 return "UnsupportedConstruct";
94 case Unknown:
95 return "Unknown error";
96 }
97 llvm_unreachable("Invalid error code.");
98 return "Invalid error code.";
99 }
100
log(raw_ostream & OS) const101 void ImportError::log(raw_ostream &OS) const {
102 OS << toString();
103 }
104
convertToErrorCode() const105 std::error_code ImportError::convertToErrorCode() const {
106 llvm_unreachable("Function not implemented.");
107 }
108
109 char ImportError::ID;
110
111 template <class T>
112 SmallVector<Decl *, 2>
getCanonicalForwardRedeclChain(Redeclarable<T> * D)113 getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
114 SmallVector<Decl *, 2> Redecls;
115 for (auto *R : D->getFirstDecl()->redecls()) {
116 if (R != D->getFirstDecl())
117 Redecls.push_back(R);
118 }
119 Redecls.push_back(D->getFirstDecl());
120 std::reverse(Redecls.begin(), Redecls.end());
121 return Redecls;
122 }
123
getCanonicalForwardRedeclChain(Decl * D)124 SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
125 if (auto *FD = dyn_cast<FunctionDecl>(D))
126 return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
127 if (auto *VD = dyn_cast<VarDecl>(D))
128 return getCanonicalForwardRedeclChain<VarDecl>(VD);
129 if (auto *TD = dyn_cast<TagDecl>(D))
130 return getCanonicalForwardRedeclChain<TagDecl>(TD);
131 llvm_unreachable("Bad declaration kind");
132 }
133
updateFlags(const Decl * From,Decl * To)134 void updateFlags(const Decl *From, Decl *To) {
135 // Check if some flags or attrs are new in 'From' and copy into 'To'.
136 // FIXME: Other flags or attrs?
137 if (From->isUsed(false) && !To->isUsed(false))
138 To->setIsUsed();
139 }
140
141 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
142 public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
143 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
144 ASTImporter &Importer;
145
146 // Use this instead of Importer.importInto .
147 template <typename ImportT>
importInto(ImportT & To,const ImportT & From)148 LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
149 return Importer.importInto(To, From);
150 }
151
152 // Use this to import pointers of specific type.
153 template <typename ImportT>
importInto(ImportT * & To,ImportT * From)154 LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
155 auto ToOrErr = Importer.Import(From);
156 if (ToOrErr)
157 To = cast_or_null<ImportT>(*ToOrErr);
158 return ToOrErr.takeError();
159 }
160
161 // Call the import function of ASTImporter for a baseclass of type `T` and
162 // cast the return value to `T`.
163 template <typename T>
import(T * From)164 auto import(T *From)
165 -> std::conditional_t<std::is_base_of<Type, T>::value,
166 Expected<const T *>, Expected<T *>> {
167 auto ToOrErr = Importer.Import(From);
168 if (!ToOrErr)
169 return ToOrErr.takeError();
170 return cast_or_null<T>(*ToOrErr);
171 }
172
173 template <typename T>
import(const T * From)174 auto import(const T *From) {
175 return import(const_cast<T *>(From));
176 }
177
178 // Call the import function of ASTImporter for type `T`.
179 template <typename T>
import(const T & From)180 Expected<T> import(const T &From) {
181 return Importer.Import(From);
182 }
183
184 // Import an Optional<T> by importing the contained T, if any.
185 template<typename T>
import(Optional<T> From)186 Expected<Optional<T>> import(Optional<T> From) {
187 if (!From)
188 return Optional<T>();
189 return import(*From);
190 }
191
192 ExplicitSpecifier importExplicitSpecifier(Error &Err,
193 ExplicitSpecifier ESpec);
194
195 // Wrapper for an overload set.
196 template <typename ToDeclT> struct CallOverloadedCreateFun {
operator ()clang::ASTNodeImporter::CallOverloadedCreateFun197 template <typename... Args> decltype(auto) operator()(Args &&... args) {
198 return ToDeclT::Create(std::forward<Args>(args)...);
199 }
200 };
201
202 // Always use these functions to create a Decl during import. There are
203 // certain tasks which must be done after the Decl was created, e.g. we
204 // must immediately register that as an imported Decl. The parameter `ToD`
205 // will be set to the newly created Decl or if had been imported before
206 // then to the already imported Decl. Returns a bool value set to true if
207 // the `FromD` had been imported before.
208 template <typename ToDeclT, typename FromDeclT, typename... Args>
GetImportedOrCreateDecl(ToDeclT * & ToD,FromDeclT * FromD,Args &&...args)209 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
210 Args &&... args) {
211 // There may be several overloads of ToDeclT::Create. We must make sure
212 // to call the one which would be chosen by the arguments, thus we use a
213 // wrapper for the overload set.
214 CallOverloadedCreateFun<ToDeclT> OC;
215 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
216 std::forward<Args>(args)...);
217 }
218 // Use this overload if a special Type is needed to be created. E.g if we
219 // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
220 // then:
221 // TypedefNameDecl *ToTypedef;
222 // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
223 template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
224 typename... Args>
GetImportedOrCreateDecl(ToDeclT * & ToD,FromDeclT * FromD,Args &&...args)225 LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
226 Args &&... args) {
227 CallOverloadedCreateFun<NewDeclT> OC;
228 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
229 std::forward<Args>(args)...);
230 }
231 // Use this version if a special create function must be
232 // used, e.g. CXXRecordDecl::CreateLambda .
233 template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
234 typename... Args>
235 LLVM_NODISCARD bool
GetImportedOrCreateSpecialDecl(ToDeclT * & ToD,CreateFunT CreateFun,FromDeclT * FromD,Args &&...args)236 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
237 FromDeclT *FromD, Args &&... args) {
238 if (Importer.getImportDeclErrorIfAny(FromD)) {
239 ToD = nullptr;
240 return true; // Already imported but with error.
241 }
242 ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
243 if (ToD)
244 return true; // Already imported.
245 ToD = CreateFun(std::forward<Args>(args)...);
246 // Keep track of imported Decls.
247 Importer.RegisterImportedDecl(FromD, ToD);
248 InitializeImportedDecl(FromD, ToD);
249 return false; // A new Decl is created.
250 }
251
InitializeImportedDecl(Decl * FromD,Decl * ToD)252 void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
253 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
254 if (FromD->isUsed())
255 ToD->setIsUsed();
256 if (FromD->isImplicit())
257 ToD->setImplicit();
258 }
259
260 // Check if we have found an existing definition. Returns with that
261 // definition if yes, otherwise returns null.
FindAndMapDefinition(FunctionDecl * D,FunctionDecl * FoundFunction)262 Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
263 const FunctionDecl *Definition = nullptr;
264 if (D->doesThisDeclarationHaveABody() &&
265 FoundFunction->hasBody(Definition))
266 return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
267 return nullptr;
268 }
269
addDeclToContexts(Decl * FromD,Decl * ToD)270 void addDeclToContexts(Decl *FromD, Decl *ToD) {
271 if (Importer.isMinimalImport()) {
272 // In minimal import case the decl must be added even if it is not
273 // contained in original context, for LLDB compatibility.
274 // FIXME: Check if a better solution is possible.
275 if (!FromD->getDescribedTemplate() &&
276 FromD->getFriendObjectKind() == Decl::FOK_None)
277 ToD->getLexicalDeclContext()->addDeclInternal(ToD);
278 return;
279 }
280
281 DeclContext *FromDC = FromD->getDeclContext();
282 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
283 DeclContext *ToDC = ToD->getDeclContext();
284 DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
285
286 bool Visible = false;
287 if (FromDC->containsDeclAndLoad(FromD)) {
288 ToDC->addDeclInternal(ToD);
289 Visible = true;
290 }
291 if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
292 ToLexicalDC->addDeclInternal(ToD);
293 Visible = true;
294 }
295
296 // If the Decl was added to any context, it was made already visible.
297 // Otherwise it is still possible that it should be visible.
298 if (!Visible) {
299 if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
300 auto *ToNamed = cast<NamedDecl>(ToD);
301 DeclContextLookupResult FromLookup =
302 FromDC->lookup(FromNamed->getDeclName());
303 for (NamedDecl *ND : FromLookup)
304 if (ND == FromNamed) {
305 ToDC->makeDeclVisibleInContext(ToNamed);
306 break;
307 }
308 }
309 }
310 }
311
updateLookupTableForTemplateParameters(TemplateParameterList & Params,DeclContext * OldDC)312 void updateLookupTableForTemplateParameters(TemplateParameterList &Params,
313 DeclContext *OldDC) {
314 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
315 if (!LT)
316 return;
317
318 for (NamedDecl *TP : Params)
319 LT->update(TP, OldDC);
320 }
321
updateLookupTableForTemplateParameters(TemplateParameterList & Params)322 void updateLookupTableForTemplateParameters(TemplateParameterList &Params) {
323 updateLookupTableForTemplateParameters(
324 Params, Importer.getToContext().getTranslationUnitDecl());
325 }
326
327 public:
ASTNodeImporter(ASTImporter & Importer)328 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
329
330 using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
331 using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
332 using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
333
334 // Importing types
335 ExpectedType VisitType(const Type *T);
336 ExpectedType VisitAtomicType(const AtomicType *T);
337 ExpectedType VisitBuiltinType(const BuiltinType *T);
338 ExpectedType VisitDecayedType(const DecayedType *T);
339 ExpectedType VisitComplexType(const ComplexType *T);
340 ExpectedType VisitPointerType(const PointerType *T);
341 ExpectedType VisitBlockPointerType(const BlockPointerType *T);
342 ExpectedType VisitLValueReferenceType(const LValueReferenceType *T);
343 ExpectedType VisitRValueReferenceType(const RValueReferenceType *T);
344 ExpectedType VisitMemberPointerType(const MemberPointerType *T);
345 ExpectedType VisitConstantArrayType(const ConstantArrayType *T);
346 ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T);
347 ExpectedType VisitVariableArrayType(const VariableArrayType *T);
348 ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
349 // FIXME: DependentSizedExtVectorType
350 ExpectedType VisitVectorType(const VectorType *T);
351 ExpectedType VisitExtVectorType(const ExtVectorType *T);
352 ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
353 ExpectedType VisitFunctionProtoType(const FunctionProtoType *T);
354 ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
355 ExpectedType VisitParenType(const ParenType *T);
356 ExpectedType VisitTypedefType(const TypedefType *T);
357 ExpectedType VisitTypeOfExprType(const TypeOfExprType *T);
358 // FIXME: DependentTypeOfExprType
359 ExpectedType VisitTypeOfType(const TypeOfType *T);
360 ExpectedType VisitDecltypeType(const DecltypeType *T);
361 ExpectedType VisitUnaryTransformType(const UnaryTransformType *T);
362 ExpectedType VisitAutoType(const AutoType *T);
363 ExpectedType VisitDeducedTemplateSpecializationType(
364 const DeducedTemplateSpecializationType *T);
365 ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T);
366 // FIXME: DependentDecltypeType
367 ExpectedType VisitRecordType(const RecordType *T);
368 ExpectedType VisitEnumType(const EnumType *T);
369 ExpectedType VisitAttributedType(const AttributedType *T);
370 ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
371 ExpectedType VisitSubstTemplateTypeParmType(
372 const SubstTemplateTypeParmType *T);
373 ExpectedType
374 VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T);
375 ExpectedType VisitTemplateSpecializationType(
376 const TemplateSpecializationType *T);
377 ExpectedType VisitElaboratedType(const ElaboratedType *T);
378 ExpectedType VisitDependentNameType(const DependentNameType *T);
379 ExpectedType VisitPackExpansionType(const PackExpansionType *T);
380 ExpectedType VisitDependentTemplateSpecializationType(
381 const DependentTemplateSpecializationType *T);
382 ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T);
383 ExpectedType VisitObjCObjectType(const ObjCObjectType *T);
384 ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
385
386 // Importing declarations
387 Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
388 SourceLocation &Loc);
389 Error ImportDeclParts(
390 NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
391 DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc);
392 Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
393 Error ImportDeclarationNameLoc(
394 const DeclarationNameInfo &From, DeclarationNameInfo &To);
395 Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
396 Error ImportDeclContext(
397 Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
398 Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
399
400 Expected<CXXCastPath> ImportCastPath(CastExpr *E);
401 Expected<APValue> ImportAPValue(const APValue &FromValue);
402
403 using Designator = DesignatedInitExpr::Designator;
404
405 /// What we should import from the definition.
406 enum ImportDefinitionKind {
407 /// Import the default subset of the definition, which might be
408 /// nothing (if minimal import is set) or might be everything (if minimal
409 /// import is not set).
410 IDK_Default,
411 /// Import everything.
412 IDK_Everything,
413 /// Import only the bare bones needed to establish a valid
414 /// DeclContext.
415 IDK_Basic
416 };
417
shouldForceImportDeclContext(ImportDefinitionKind IDK)418 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
419 return IDK == IDK_Everything ||
420 (IDK == IDK_Default && !Importer.isMinimalImport());
421 }
422
423 Error ImportInitializer(VarDecl *From, VarDecl *To);
424 Error ImportDefinition(
425 RecordDecl *From, RecordDecl *To,
426 ImportDefinitionKind Kind = IDK_Default);
427 Error ImportDefinition(
428 EnumDecl *From, EnumDecl *To,
429 ImportDefinitionKind Kind = IDK_Default);
430 Error ImportDefinition(
431 ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
432 ImportDefinitionKind Kind = IDK_Default);
433 Error ImportDefinition(
434 ObjCProtocolDecl *From, ObjCProtocolDecl *To,
435 ImportDefinitionKind Kind = IDK_Default);
436 Error ImportTemplateArguments(
437 const TemplateArgument *FromArgs, unsigned NumFromArgs,
438 SmallVectorImpl<TemplateArgument> &ToArgs);
439 Expected<TemplateArgument>
440 ImportTemplateArgument(const TemplateArgument &From);
441
442 template <typename InContainerTy>
443 Error ImportTemplateArgumentListInfo(
444 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
445
446 template<typename InContainerTy>
447 Error ImportTemplateArgumentListInfo(
448 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
449 const InContainerTy &Container, TemplateArgumentListInfo &Result);
450
451 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
452 using FunctionTemplateAndArgsTy =
453 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
454 Expected<FunctionTemplateAndArgsTy>
455 ImportFunctionTemplateWithTemplateArgsFromSpecialization(
456 FunctionDecl *FromFD);
457 Error ImportTemplateParameterLists(const DeclaratorDecl *FromD,
458 DeclaratorDecl *ToD);
459
460 Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
461
462 Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
463
464 Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
465 ParmVarDecl *ToParam);
466
467 Expected<InheritedConstructor>
468 ImportInheritedConstructor(const InheritedConstructor &From);
469
470 template <typename T>
471 bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
472
473 bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
474 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
475 bool Complain = true);
476 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
477 bool Complain = true);
478 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
479 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
480 bool IsStructuralMatch(FunctionTemplateDecl *From,
481 FunctionTemplateDecl *To);
482 bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
483 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
484 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
485 ExpectedDecl VisitDecl(Decl *D);
486 ExpectedDecl VisitImportDecl(ImportDecl *D);
487 ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
488 ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
489 ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
490 ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
491 ExpectedDecl VisitBindingDecl(BindingDecl *D);
492 ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
493 ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
494 ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
495 ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
496 ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
497 ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
498 ExpectedDecl VisitLabelDecl(LabelDecl *D);
499 ExpectedDecl VisitEnumDecl(EnumDecl *D);
500 ExpectedDecl VisitRecordDecl(RecordDecl *D);
501 ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
502 ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
503 ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
504 ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
505 ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
506 ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
507 ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
508 ExpectedDecl VisitFieldDecl(FieldDecl *D);
509 ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
510 ExpectedDecl VisitFriendDecl(FriendDecl *D);
511 ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
512 ExpectedDecl VisitVarDecl(VarDecl *D);
513 ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
514 ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
515 ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
516 ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
517 ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
518 ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
519 ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
520 ExpectedDecl VisitUsingDecl(UsingDecl *D);
521 ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
522 ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
523 ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI);
524 ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D);
525 ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
526 ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
527 ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
528 ExpectedDecl
529 VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
530
531 Expected<ObjCTypeParamList *>
532 ImportObjCTypeParamList(ObjCTypeParamList *list);
533
534 ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
535 ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
536 ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
537 ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
538 ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
539 ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
540 ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
541 ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
542 ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
543 ExpectedDecl VisitClassTemplateSpecializationDecl(
544 ClassTemplateSpecializationDecl *D);
545 ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
546 ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
547 ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
548
549 // Importing statements
550 ExpectedStmt VisitStmt(Stmt *S);
551 ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
552 ExpectedStmt VisitDeclStmt(DeclStmt *S);
553 ExpectedStmt VisitNullStmt(NullStmt *S);
554 ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
555 ExpectedStmt VisitCaseStmt(CaseStmt *S);
556 ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
557 ExpectedStmt VisitLabelStmt(LabelStmt *S);
558 ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
559 ExpectedStmt VisitIfStmt(IfStmt *S);
560 ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
561 ExpectedStmt VisitWhileStmt(WhileStmt *S);
562 ExpectedStmt VisitDoStmt(DoStmt *S);
563 ExpectedStmt VisitForStmt(ForStmt *S);
564 ExpectedStmt VisitGotoStmt(GotoStmt *S);
565 ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
566 ExpectedStmt VisitContinueStmt(ContinueStmt *S);
567 ExpectedStmt VisitBreakStmt(BreakStmt *S);
568 ExpectedStmt VisitReturnStmt(ReturnStmt *S);
569 // FIXME: MSAsmStmt
570 // FIXME: SEHExceptStmt
571 // FIXME: SEHFinallyStmt
572 // FIXME: SEHTryStmt
573 // FIXME: SEHLeaveStmt
574 // FIXME: CapturedStmt
575 ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
576 ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
577 ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
578 // FIXME: MSDependentExistsStmt
579 ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
580 ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
581 ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
582 ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
583 ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
584 ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
585 ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
586
587 // Importing expressions
588 ExpectedStmt VisitExpr(Expr *E);
589 ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
590 ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
591 ExpectedStmt VisitChooseExpr(ChooseExpr *E);
592 ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E);
593 ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
594 ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
595 ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
596 ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
597 ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
598 ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
599 ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
600 ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
601 ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
602 ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
603 ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
604 ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
605 ExpectedStmt VisitStringLiteral(StringLiteral *E);
606 ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
607 ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
608 ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
609 ExpectedStmt VisitConstantExpr(ConstantExpr *E);
610 ExpectedStmt VisitParenExpr(ParenExpr *E);
611 ExpectedStmt VisitParenListExpr(ParenListExpr *E);
612 ExpectedStmt VisitStmtExpr(StmtExpr *E);
613 ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
614 ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
615 ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
616 ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
617 ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
618 ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
619 ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
620 ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
621 ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
622 ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
623 ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
624 ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
625 ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
626 ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
627 ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
628 ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
629 ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
630 ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
631 ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
632 ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
633 ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
634 ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
635 ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
636 ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
637 ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
638 ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
639 ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
640 ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
641 ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
642 ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
643 ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
644 ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
645 ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
646 ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
647 ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
648 ExpectedStmt VisitMemberExpr(MemberExpr *E);
649 ExpectedStmt VisitCallExpr(CallExpr *E);
650 ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
651 ExpectedStmt VisitInitListExpr(InitListExpr *E);
652 ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
653 ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
654 ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
655 ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
656 ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
657 ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
658 ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
659 ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
660 ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
661 ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
662
663 // Helper for chaining together multiple imports. If an error is detected,
664 // subsequent imports will return default constructed nodes, so that failure
665 // can be detected with a single conditional branch after a sequence of
666 // imports.
importChecked(Error & Err,const T & From)667 template <typename T> T importChecked(Error &Err, const T &From) {
668 // Don't attempt to import nodes if we hit an error earlier.
669 if (Err)
670 return T{};
671 Expected<T> MaybeVal = import(From);
672 if (!MaybeVal) {
673 Err = MaybeVal.takeError();
674 return T{};
675 }
676 return *MaybeVal;
677 }
678
679 template<typename IIter, typename OIter>
ImportArrayChecked(IIter Ibegin,IIter Iend,OIter Obegin)680 Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
681 using ItemT = std::remove_reference_t<decltype(*Obegin)>;
682 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
683 Expected<ItemT> ToOrErr = import(*Ibegin);
684 if (!ToOrErr)
685 return ToOrErr.takeError();
686 *Obegin = *ToOrErr;
687 }
688 return Error::success();
689 }
690
691 // Import every item from a container structure into an output container.
692 // If error occurs, stops at first error and returns the error.
693 // The output container should have space for all needed elements (it is not
694 // expanded, new items are put into from the beginning).
695 template<typename InContainerTy, typename OutContainerTy>
ImportContainerChecked(const InContainerTy & InContainer,OutContainerTy & OutContainer)696 Error ImportContainerChecked(
697 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
698 return ImportArrayChecked(
699 InContainer.begin(), InContainer.end(), OutContainer.begin());
700 }
701
702 template<typename InContainerTy, typename OIter>
ImportArrayChecked(const InContainerTy & InContainer,OIter Obegin)703 Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
704 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
705 }
706
707 Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
708 CXXMethodDecl *FromMethod);
709
710 Expected<FunctionDecl *> FindFunctionTemplateSpecialization(
711 FunctionDecl *FromFD);
712
713 // Returns true if the given function has a placeholder return type and
714 // that type is declared inside the body of the function.
715 // E.g. auto f() { struct X{}; return X(); }
716 bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
717 };
718
719 template <typename InContainerTy>
ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,SourceLocation FromRAngleLoc,const InContainerTy & Container,TemplateArgumentListInfo & Result)720 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
721 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
722 const InContainerTy &Container, TemplateArgumentListInfo &Result) {
723 auto ToLAngleLocOrErr = import(FromLAngleLoc);
724 if (!ToLAngleLocOrErr)
725 return ToLAngleLocOrErr.takeError();
726 auto ToRAngleLocOrErr = import(FromRAngleLoc);
727 if (!ToRAngleLocOrErr)
728 return ToRAngleLocOrErr.takeError();
729
730 TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
731 if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo))
732 return Err;
733 Result = ToTAInfo;
734 return Error::success();
735 }
736
737 template <>
ImportTemplateArgumentListInfo(const TemplateArgumentListInfo & From,TemplateArgumentListInfo & Result)738 Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
739 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
740 return ImportTemplateArgumentListInfo(
741 From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
742 }
743
744 template <>
ImportTemplateArgumentListInfo(const ASTTemplateArgumentListInfo & From,TemplateArgumentListInfo & Result)745 Error ASTNodeImporter::ImportTemplateArgumentListInfo<
746 ASTTemplateArgumentListInfo>(
747 const ASTTemplateArgumentListInfo &From,
748 TemplateArgumentListInfo &Result) {
749 return ImportTemplateArgumentListInfo(
750 From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
751 }
752
753 Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
ImportFunctionTemplateWithTemplateArgsFromSpecialization(FunctionDecl * FromFD)754 ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
755 FunctionDecl *FromFD) {
756 assert(FromFD->getTemplatedKind() ==
757 FunctionDecl::TK_FunctionTemplateSpecialization);
758
759 FunctionTemplateAndArgsTy Result;
760
761 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
762 if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
763 return std::move(Err);
764
765 // Import template arguments.
766 auto TemplArgs = FTSInfo->TemplateArguments->asArray();
767 if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
768 std::get<1>(Result)))
769 return std::move(Err);
770
771 return Result;
772 }
773
774 template <>
775 Expected<TemplateParameterList *>
import(TemplateParameterList * From)776 ASTNodeImporter::import(TemplateParameterList *From) {
777 SmallVector<NamedDecl *, 4> To(From->size());
778 if (Error Err = ImportContainerChecked(*From, To))
779 return std::move(Err);
780
781 ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
782 if (!ToRequiresClause)
783 return ToRequiresClause.takeError();
784
785 auto ToTemplateLocOrErr = import(From->getTemplateLoc());
786 if (!ToTemplateLocOrErr)
787 return ToTemplateLocOrErr.takeError();
788 auto ToLAngleLocOrErr = import(From->getLAngleLoc());
789 if (!ToLAngleLocOrErr)
790 return ToLAngleLocOrErr.takeError();
791 auto ToRAngleLocOrErr = import(From->getRAngleLoc());
792 if (!ToRAngleLocOrErr)
793 return ToRAngleLocOrErr.takeError();
794
795 return TemplateParameterList::Create(
796 Importer.getToContext(),
797 *ToTemplateLocOrErr,
798 *ToLAngleLocOrErr,
799 To,
800 *ToRAngleLocOrErr,
801 *ToRequiresClause);
802 }
803
804 template <>
805 Expected<TemplateArgument>
import(const TemplateArgument & From)806 ASTNodeImporter::import(const TemplateArgument &From) {
807 switch (From.getKind()) {
808 case TemplateArgument::Null:
809 return TemplateArgument();
810
811 case TemplateArgument::Type: {
812 ExpectedType ToTypeOrErr = import(From.getAsType());
813 if (!ToTypeOrErr)
814 return ToTypeOrErr.takeError();
815 return TemplateArgument(*ToTypeOrErr);
816 }
817
818 case TemplateArgument::Integral: {
819 ExpectedType ToTypeOrErr = import(From.getIntegralType());
820 if (!ToTypeOrErr)
821 return ToTypeOrErr.takeError();
822 return TemplateArgument(From, *ToTypeOrErr);
823 }
824
825 case TemplateArgument::Declaration: {
826 Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
827 if (!ToOrErr)
828 return ToOrErr.takeError();
829 ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
830 if (!ToTypeOrErr)
831 return ToTypeOrErr.takeError();
832 return TemplateArgument(*ToOrErr, *ToTypeOrErr);
833 }
834
835 case TemplateArgument::NullPtr: {
836 ExpectedType ToTypeOrErr = import(From.getNullPtrType());
837 if (!ToTypeOrErr)
838 return ToTypeOrErr.takeError();
839 return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true);
840 }
841
842 case TemplateArgument::Template: {
843 Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
844 if (!ToTemplateOrErr)
845 return ToTemplateOrErr.takeError();
846
847 return TemplateArgument(*ToTemplateOrErr);
848 }
849
850 case TemplateArgument::TemplateExpansion: {
851 Expected<TemplateName> ToTemplateOrErr =
852 import(From.getAsTemplateOrTemplatePattern());
853 if (!ToTemplateOrErr)
854 return ToTemplateOrErr.takeError();
855
856 return TemplateArgument(
857 *ToTemplateOrErr, From.getNumTemplateExpansions());
858 }
859
860 case TemplateArgument::Expression:
861 if (ExpectedExpr ToExpr = import(From.getAsExpr()))
862 return TemplateArgument(*ToExpr);
863 else
864 return ToExpr.takeError();
865
866 case TemplateArgument::Pack: {
867 SmallVector<TemplateArgument, 2> ToPack;
868 ToPack.reserve(From.pack_size());
869 if (Error Err = ImportTemplateArguments(
870 From.pack_begin(), From.pack_size(), ToPack))
871 return std::move(Err);
872
873 return TemplateArgument(
874 llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
875 }
876 }
877
878 llvm_unreachable("Invalid template argument kind");
879 }
880
881 template <>
882 Expected<TemplateArgumentLoc>
import(const TemplateArgumentLoc & TALoc)883 ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
884 Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
885 if (!ArgOrErr)
886 return ArgOrErr.takeError();
887 TemplateArgument Arg = *ArgOrErr;
888
889 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
890
891 TemplateArgumentLocInfo ToInfo;
892 if (Arg.getKind() == TemplateArgument::Expression) {
893 ExpectedExpr E = import(FromInfo.getAsExpr());
894 if (!E)
895 return E.takeError();
896 ToInfo = TemplateArgumentLocInfo(*E);
897 } else if (Arg.getKind() == TemplateArgument::Type) {
898 if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
899 ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
900 else
901 return TSIOrErr.takeError();
902 } else {
903 auto ToTemplateQualifierLocOrErr =
904 import(FromInfo.getTemplateQualifierLoc());
905 if (!ToTemplateQualifierLocOrErr)
906 return ToTemplateQualifierLocOrErr.takeError();
907 auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
908 if (!ToTemplateNameLocOrErr)
909 return ToTemplateNameLocOrErr.takeError();
910 auto ToTemplateEllipsisLocOrErr =
911 import(FromInfo.getTemplateEllipsisLoc());
912 if (!ToTemplateEllipsisLocOrErr)
913 return ToTemplateEllipsisLocOrErr.takeError();
914 ToInfo = TemplateArgumentLocInfo(
915 Importer.getToContext(), *ToTemplateQualifierLocOrErr,
916 *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
917 }
918
919 return TemplateArgumentLoc(Arg, ToInfo);
920 }
921
922 template <>
import(const DeclGroupRef & DG)923 Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
924 if (DG.isNull())
925 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
926 size_t NumDecls = DG.end() - DG.begin();
927 SmallVector<Decl *, 1> ToDecls;
928 ToDecls.reserve(NumDecls);
929 for (Decl *FromD : DG) {
930 if (auto ToDOrErr = import(FromD))
931 ToDecls.push_back(*ToDOrErr);
932 else
933 return ToDOrErr.takeError();
934 }
935 return DeclGroupRef::Create(Importer.getToContext(),
936 ToDecls.begin(),
937 NumDecls);
938 }
939
940 template <>
941 Expected<ASTNodeImporter::Designator>
import(const Designator & D)942 ASTNodeImporter::import(const Designator &D) {
943 if (D.isFieldDesignator()) {
944 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
945
946 ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
947 if (!ToDotLocOrErr)
948 return ToDotLocOrErr.takeError();
949
950 ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
951 if (!ToFieldLocOrErr)
952 return ToFieldLocOrErr.takeError();
953
954 return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
955 }
956
957 ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
958 if (!ToLBracketLocOrErr)
959 return ToLBracketLocOrErr.takeError();
960
961 ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
962 if (!ToRBracketLocOrErr)
963 return ToRBracketLocOrErr.takeError();
964
965 if (D.isArrayDesignator())
966 return Designator(D.getFirstExprIndex(),
967 *ToLBracketLocOrErr, *ToRBracketLocOrErr);
968
969 ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
970 if (!ToEllipsisLocOrErr)
971 return ToEllipsisLocOrErr.takeError();
972
973 assert(D.isArrayRangeDesignator());
974 return Designator(
975 D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
976 *ToRBracketLocOrErr);
977 }
978
979 template <>
import(const LambdaCapture & From)980 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
981 VarDecl *Var = nullptr;
982 if (From.capturesVariable()) {
983 if (auto VarOrErr = import(From.getCapturedVar()))
984 Var = *VarOrErr;
985 else
986 return VarOrErr.takeError();
987 }
988
989 auto LocationOrErr = import(From.getLocation());
990 if (!LocationOrErr)
991 return LocationOrErr.takeError();
992
993 SourceLocation EllipsisLoc;
994 if (From.isPackExpansion())
995 if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
996 return std::move(Err);
997
998 return LambdaCapture(
999 *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
1000 EllipsisLoc);
1001 }
1002
1003 template <typename T>
hasSameVisibilityContextAndLinkage(T * Found,T * From)1004 bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
1005 if (Found->getLinkageInternal() != From->getLinkageInternal())
1006 return false;
1007
1008 if (From->hasExternalFormalLinkage())
1009 return Found->hasExternalFormalLinkage();
1010 if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl())
1011 return false;
1012 if (From->isInAnonymousNamespace())
1013 return Found->isInAnonymousNamespace();
1014 else
1015 return !Found->isInAnonymousNamespace() &&
1016 !Found->hasExternalFormalLinkage();
1017 }
1018
1019 template <>
hasSameVisibilityContextAndLinkage(TypedefNameDecl * Found,TypedefNameDecl * From)1020 bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
1021 TypedefNameDecl *From) {
1022 if (Found->getLinkageInternal() != From->getLinkageInternal())
1023 return false;
1024
1025 if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
1026 return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
1027 return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
1028 }
1029
1030 } // namespace clang
1031
1032 //----------------------------------------------------------------------------
1033 // Import Types
1034 //----------------------------------------------------------------------------
1035
1036 using namespace clang;
1037
VisitType(const Type * T)1038 ExpectedType ASTNodeImporter::VisitType(const Type *T) {
1039 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1040 << T->getTypeClassName();
1041 return make_error<ImportError>(ImportError::UnsupportedConstruct);
1042 }
1043
VisitAtomicType(const AtomicType * T)1044 ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1045 ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
1046 if (!UnderlyingTypeOrErr)
1047 return UnderlyingTypeOrErr.takeError();
1048
1049 return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
1050 }
1051
VisitBuiltinType(const BuiltinType * T)1052 ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1053 switch (T->getKind()) {
1054 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1055 case BuiltinType::Id: \
1056 return Importer.getToContext().SingletonId;
1057 #include "clang/Basic/OpenCLImageTypes.def"
1058 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1059 case BuiltinType::Id: \
1060 return Importer.getToContext().Id##Ty;
1061 #include "clang/Basic/OpenCLExtensionTypes.def"
1062 #define SVE_TYPE(Name, Id, SingletonId) \
1063 case BuiltinType::Id: \
1064 return Importer.getToContext().SingletonId;
1065 #include "clang/Basic/AArch64SVEACLETypes.def"
1066 #define PPC_VECTOR_TYPE(Name, Id, Size) \
1067 case BuiltinType::Id: \
1068 return Importer.getToContext().Id##Ty;
1069 #include "clang/Basic/PPCTypes.def"
1070 #define RVV_TYPE(Name, Id, SingletonId) \
1071 case BuiltinType::Id: \
1072 return Importer.getToContext().SingletonId;
1073 #include "clang/Basic/RISCVVTypes.def"
1074 #define SHARED_SINGLETON_TYPE(Expansion)
1075 #define BUILTIN_TYPE(Id, SingletonId) \
1076 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1077 #include "clang/AST/BuiltinTypes.def"
1078
1079 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1080 // context supports C++.
1081
1082 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1083 // context supports ObjC.
1084
1085 case BuiltinType::Char_U:
1086 // The context we're importing from has an unsigned 'char'. If we're
1087 // importing into a context with a signed 'char', translate to
1088 // 'unsigned char' instead.
1089 if (Importer.getToContext().getLangOpts().CharIsSigned)
1090 return Importer.getToContext().UnsignedCharTy;
1091
1092 return Importer.getToContext().CharTy;
1093
1094 case BuiltinType::Char_S:
1095 // The context we're importing from has an unsigned 'char'. If we're
1096 // importing into a context with a signed 'char', translate to
1097 // 'unsigned char' instead.
1098 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1099 return Importer.getToContext().SignedCharTy;
1100
1101 return Importer.getToContext().CharTy;
1102
1103 case BuiltinType::WChar_S:
1104 case BuiltinType::WChar_U:
1105 // FIXME: If not in C++, shall we translate to the C equivalent of
1106 // wchar_t?
1107 return Importer.getToContext().WCharTy;
1108 }
1109
1110 llvm_unreachable("Invalid BuiltinType Kind!");
1111 }
1112
VisitDecayedType(const DecayedType * T)1113 ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1114 ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
1115 if (!ToOriginalTypeOrErr)
1116 return ToOriginalTypeOrErr.takeError();
1117
1118 return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
1119 }
1120
VisitComplexType(const ComplexType * T)1121 ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1122 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1123 if (!ToElementTypeOrErr)
1124 return ToElementTypeOrErr.takeError();
1125
1126 return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
1127 }
1128
VisitPointerType(const PointerType * T)1129 ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1130 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1131 if (!ToPointeeTypeOrErr)
1132 return ToPointeeTypeOrErr.takeError();
1133
1134 return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
1135 }
1136
VisitBlockPointerType(const BlockPointerType * T)1137 ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1138 // FIXME: Check for blocks support in "to" context.
1139 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1140 if (!ToPointeeTypeOrErr)
1141 return ToPointeeTypeOrErr.takeError();
1142
1143 return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr);
1144 }
1145
1146 ExpectedType
VisitLValueReferenceType(const LValueReferenceType * T)1147 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1148 // FIXME: Check for C++ support in "to" context.
1149 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1150 if (!ToPointeeTypeOrErr)
1151 return ToPointeeTypeOrErr.takeError();
1152
1153 return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr);
1154 }
1155
1156 ExpectedType
VisitRValueReferenceType(const RValueReferenceType * T)1157 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1158 // FIXME: Check for C++0x support in "to" context.
1159 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1160 if (!ToPointeeTypeOrErr)
1161 return ToPointeeTypeOrErr.takeError();
1162
1163 return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr);
1164 }
1165
1166 ExpectedType
VisitMemberPointerType(const MemberPointerType * T)1167 ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1168 // FIXME: Check for C++ support in "to" context.
1169 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1170 if (!ToPointeeTypeOrErr)
1171 return ToPointeeTypeOrErr.takeError();
1172
1173 ExpectedTypePtr ClassTypeOrErr = import(T->getClass());
1174 if (!ClassTypeOrErr)
1175 return ClassTypeOrErr.takeError();
1176
1177 return Importer.getToContext().getMemberPointerType(*ToPointeeTypeOrErr,
1178 *ClassTypeOrErr);
1179 }
1180
1181 ExpectedType
VisitConstantArrayType(const ConstantArrayType * T)1182 ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1183 Error Err = Error::success();
1184 auto ToElementType = importChecked(Err, T->getElementType());
1185 auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
1186 if (Err)
1187 return std::move(Err);
1188
1189 return Importer.getToContext().getConstantArrayType(
1190 ToElementType, T->getSize(), ToSizeExpr, T->getSizeModifier(),
1191 T->getIndexTypeCVRQualifiers());
1192 }
1193
1194 ExpectedType
VisitIncompleteArrayType(const IncompleteArrayType * T)1195 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1196 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1197 if (!ToElementTypeOrErr)
1198 return ToElementTypeOrErr.takeError();
1199
1200 return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
1201 T->getSizeModifier(),
1202 T->getIndexTypeCVRQualifiers());
1203 }
1204
1205 ExpectedType
VisitVariableArrayType(const VariableArrayType * T)1206 ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1207 Error Err = Error::success();
1208 QualType ToElementType = importChecked(Err, T->getElementType());
1209 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1210 SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1211 if (Err)
1212 return std::move(Err);
1213 return Importer.getToContext().getVariableArrayType(
1214 ToElementType, ToSizeExpr, T->getSizeModifier(),
1215 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1216 }
1217
VisitDependentSizedArrayType(const DependentSizedArrayType * T)1218 ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1219 const DependentSizedArrayType *T) {
1220 Error Err = Error::success();
1221 QualType ToElementType = importChecked(Err, T->getElementType());
1222 Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1223 SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1224 if (Err)
1225 return std::move(Err);
1226 // SizeExpr may be null if size is not specified directly.
1227 // For example, 'int a[]'.
1228
1229 return Importer.getToContext().getDependentSizedArrayType(
1230 ToElementType, ToSizeExpr, T->getSizeModifier(),
1231 T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1232 }
1233
VisitVectorType(const VectorType * T)1234 ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1235 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1236 if (!ToElementTypeOrErr)
1237 return ToElementTypeOrErr.takeError();
1238
1239 return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
1240 T->getNumElements(),
1241 T->getVectorKind());
1242 }
1243
VisitExtVectorType(const ExtVectorType * T)1244 ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1245 ExpectedType ToElementTypeOrErr = import(T->getElementType());
1246 if (!ToElementTypeOrErr)
1247 return ToElementTypeOrErr.takeError();
1248
1249 return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr,
1250 T->getNumElements());
1251 }
1252
1253 ExpectedType
VisitFunctionNoProtoType(const FunctionNoProtoType * T)1254 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1255 // FIXME: What happens if we're importing a function without a prototype
1256 // into C++? Should we make it variadic?
1257 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1258 if (!ToReturnTypeOrErr)
1259 return ToReturnTypeOrErr.takeError();
1260
1261 return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr,
1262 T->getExtInfo());
1263 }
1264
1265 ExpectedType
VisitFunctionProtoType(const FunctionProtoType * T)1266 ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1267 ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1268 if (!ToReturnTypeOrErr)
1269 return ToReturnTypeOrErr.takeError();
1270
1271 // Import argument types
1272 SmallVector<QualType, 4> ArgTypes;
1273 for (const auto &A : T->param_types()) {
1274 ExpectedType TyOrErr = import(A);
1275 if (!TyOrErr)
1276 return TyOrErr.takeError();
1277 ArgTypes.push_back(*TyOrErr);
1278 }
1279
1280 // Import exception types
1281 SmallVector<QualType, 4> ExceptionTypes;
1282 for (const auto &E : T->exceptions()) {
1283 ExpectedType TyOrErr = import(E);
1284 if (!TyOrErr)
1285 return TyOrErr.takeError();
1286 ExceptionTypes.push_back(*TyOrErr);
1287 }
1288
1289 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1290 Error Err = Error::success();
1291 FunctionProtoType::ExtProtoInfo ToEPI;
1292 ToEPI.ExtInfo = FromEPI.ExtInfo;
1293 ToEPI.Variadic = FromEPI.Variadic;
1294 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1295 ToEPI.TypeQuals = FromEPI.TypeQuals;
1296 ToEPI.RefQualifier = FromEPI.RefQualifier;
1297 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1298 ToEPI.ExceptionSpec.NoexceptExpr =
1299 importChecked(Err, FromEPI.ExceptionSpec.NoexceptExpr);
1300 ToEPI.ExceptionSpec.SourceDecl =
1301 importChecked(Err, FromEPI.ExceptionSpec.SourceDecl);
1302 ToEPI.ExceptionSpec.SourceTemplate =
1303 importChecked(Err, FromEPI.ExceptionSpec.SourceTemplate);
1304 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1305
1306 if (Err)
1307 return std::move(Err);
1308
1309 return Importer.getToContext().getFunctionType(
1310 *ToReturnTypeOrErr, ArgTypes, ToEPI);
1311 }
1312
VisitUnresolvedUsingType(const UnresolvedUsingType * T)1313 ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
1314 const UnresolvedUsingType *T) {
1315 Error Err = Error::success();
1316 auto ToD = importChecked(Err, T->getDecl());
1317 auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
1318 if (Err)
1319 return std::move(Err);
1320
1321 return Importer.getToContext().getTypeDeclType(
1322 ToD, cast_or_null<TypeDecl>(ToPrevD));
1323 }
1324
VisitParenType(const ParenType * T)1325 ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
1326 ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
1327 if (!ToInnerTypeOrErr)
1328 return ToInnerTypeOrErr.takeError();
1329
1330 return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
1331 }
1332
VisitTypedefType(const TypedefType * T)1333 ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1334 Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
1335 if (!ToDeclOrErr)
1336 return ToDeclOrErr.takeError();
1337
1338 return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
1339 }
1340
VisitTypeOfExprType(const TypeOfExprType * T)1341 ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1342 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1343 if (!ToExprOrErr)
1344 return ToExprOrErr.takeError();
1345
1346 return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
1347 }
1348
VisitTypeOfType(const TypeOfType * T)1349 ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1350 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1351 if (!ToUnderlyingTypeOrErr)
1352 return ToUnderlyingTypeOrErr.takeError();
1353
1354 return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
1355 }
1356
VisitDecltypeType(const DecltypeType * T)1357 ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1358 // FIXME: Make sure that the "to" context supports C++0x!
1359 ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1360 if (!ToExprOrErr)
1361 return ToExprOrErr.takeError();
1362
1363 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1364 if (!ToUnderlyingTypeOrErr)
1365 return ToUnderlyingTypeOrErr.takeError();
1366
1367 return Importer.getToContext().getDecltypeType(
1368 *ToExprOrErr, *ToUnderlyingTypeOrErr);
1369 }
1370
1371 ExpectedType
VisitUnaryTransformType(const UnaryTransformType * T)1372 ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1373 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1374 if (!ToBaseTypeOrErr)
1375 return ToBaseTypeOrErr.takeError();
1376
1377 ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1378 if (!ToUnderlyingTypeOrErr)
1379 return ToUnderlyingTypeOrErr.takeError();
1380
1381 return Importer.getToContext().getUnaryTransformType(
1382 *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1383 }
1384
VisitAutoType(const AutoType * T)1385 ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1386 // FIXME: Make sure that the "to" context supports C++11!
1387 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1388 if (!ToDeducedTypeOrErr)
1389 return ToDeducedTypeOrErr.takeError();
1390
1391 ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1392 if (!ToTypeConstraintConcept)
1393 return ToTypeConstraintConcept.takeError();
1394
1395 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1396 ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
1397 if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
1398 FromTemplateArgs.size(),
1399 ToTemplateArgs))
1400 return std::move(Err);
1401
1402 return Importer.getToContext().getAutoType(
1403 *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
1404 /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1405 ToTemplateArgs);
1406 }
1407
VisitDeducedTemplateSpecializationType(const DeducedTemplateSpecializationType * T)1408 ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1409 const DeducedTemplateSpecializationType *T) {
1410 // FIXME: Make sure that the "to" context supports C++17!
1411 Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
1412 if (!ToTemplateNameOrErr)
1413 return ToTemplateNameOrErr.takeError();
1414 ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1415 if (!ToDeducedTypeOrErr)
1416 return ToDeducedTypeOrErr.takeError();
1417
1418 return Importer.getToContext().getDeducedTemplateSpecializationType(
1419 *ToTemplateNameOrErr, *ToDeducedTypeOrErr, T->isDependentType());
1420 }
1421
VisitInjectedClassNameType(const InjectedClassNameType * T)1422 ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1423 const InjectedClassNameType *T) {
1424 Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
1425 if (!ToDeclOrErr)
1426 return ToDeclOrErr.takeError();
1427
1428 ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType());
1429 if (!ToInjTypeOrErr)
1430 return ToInjTypeOrErr.takeError();
1431
1432 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
1433 // See comments in InjectedClassNameType definition for details
1434 // return Importer.getToContext().getInjectedClassNameType(D, InjType);
1435 enum {
1436 TypeAlignmentInBits = 4,
1437 TypeAlignment = 1 << TypeAlignmentInBits
1438 };
1439
1440 return QualType(new (Importer.getToContext(), TypeAlignment)
1441 InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1442 }
1443
VisitRecordType(const RecordType * T)1444 ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1445 Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
1446 if (!ToDeclOrErr)
1447 return ToDeclOrErr.takeError();
1448
1449 return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1450 }
1451
VisitEnumType(const EnumType * T)1452 ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1453 Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
1454 if (!ToDeclOrErr)
1455 return ToDeclOrErr.takeError();
1456
1457 return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1458 }
1459
VisitAttributedType(const AttributedType * T)1460 ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1461 ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
1462 if (!ToModifiedTypeOrErr)
1463 return ToModifiedTypeOrErr.takeError();
1464 ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
1465 if (!ToEquivalentTypeOrErr)
1466 return ToEquivalentTypeOrErr.takeError();
1467
1468 return Importer.getToContext().getAttributedType(T->getAttrKind(),
1469 *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1470 }
1471
VisitTemplateTypeParmType(const TemplateTypeParmType * T)1472 ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1473 const TemplateTypeParmType *T) {
1474 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1475 if (!ToDeclOrErr)
1476 return ToDeclOrErr.takeError();
1477
1478 return Importer.getToContext().getTemplateTypeParmType(
1479 T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1480 }
1481
VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType * T)1482 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1483 const SubstTemplateTypeParmType *T) {
1484 Expected<const TemplateTypeParmType *> ReplacedOrErr =
1485 import(T->getReplacedParameter());
1486 if (!ReplacedOrErr)
1487 return ReplacedOrErr.takeError();
1488
1489 ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1490 if (!ToReplacementTypeOrErr)
1491 return ToReplacementTypeOrErr.takeError();
1492
1493 return Importer.getToContext().getSubstTemplateTypeParmType(
1494 *ReplacedOrErr, ToReplacementTypeOrErr->getCanonicalType());
1495 }
1496
VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType * T)1497 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1498 const SubstTemplateTypeParmPackType *T) {
1499 Expected<const TemplateTypeParmType *> ReplacedOrErr =
1500 import(T->getReplacedParameter());
1501 if (!ReplacedOrErr)
1502 return ReplacedOrErr.takeError();
1503
1504 Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
1505 if (!ToArgumentPack)
1506 return ToArgumentPack.takeError();
1507
1508 return Importer.getToContext().getSubstTemplateTypeParmPackType(
1509 *ReplacedOrErr, *ToArgumentPack);
1510 }
1511
VisitTemplateSpecializationType(const TemplateSpecializationType * T)1512 ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1513 const TemplateSpecializationType *T) {
1514 auto ToTemplateOrErr = import(T->getTemplateName());
1515 if (!ToTemplateOrErr)
1516 return ToTemplateOrErr.takeError();
1517
1518 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1519 if (Error Err = ImportTemplateArguments(
1520 T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1521 return std::move(Err);
1522
1523 QualType ToCanonType;
1524 if (!T->isCanonicalUnqualified()) {
1525 QualType FromCanonType
1526 = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1527 if (ExpectedType TyOrErr = import(FromCanonType))
1528 ToCanonType = *TyOrErr;
1529 else
1530 return TyOrErr.takeError();
1531 }
1532 return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
1533 ToTemplateArgs,
1534 ToCanonType);
1535 }
1536
VisitElaboratedType(const ElaboratedType * T)1537 ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1538 // Note: the qualifier in an ElaboratedType is optional.
1539 auto ToQualifierOrErr = import(T->getQualifier());
1540 if (!ToQualifierOrErr)
1541 return ToQualifierOrErr.takeError();
1542
1543 ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1544 if (!ToNamedTypeOrErr)
1545 return ToNamedTypeOrErr.takeError();
1546
1547 Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1548 if (!ToOwnedTagDeclOrErr)
1549 return ToOwnedTagDeclOrErr.takeError();
1550
1551 return Importer.getToContext().getElaboratedType(T->getKeyword(),
1552 *ToQualifierOrErr,
1553 *ToNamedTypeOrErr,
1554 *ToOwnedTagDeclOrErr);
1555 }
1556
1557 ExpectedType
VisitPackExpansionType(const PackExpansionType * T)1558 ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1559 ExpectedType ToPatternOrErr = import(T->getPattern());
1560 if (!ToPatternOrErr)
1561 return ToPatternOrErr.takeError();
1562
1563 return Importer.getToContext().getPackExpansionType(*ToPatternOrErr,
1564 T->getNumExpansions(),
1565 /*ExpactPack=*/false);
1566 }
1567
VisitDependentTemplateSpecializationType(const DependentTemplateSpecializationType * T)1568 ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1569 const DependentTemplateSpecializationType *T) {
1570 auto ToQualifierOrErr = import(T->getQualifier());
1571 if (!ToQualifierOrErr)
1572 return ToQualifierOrErr.takeError();
1573
1574 IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
1575
1576 SmallVector<TemplateArgument, 2> ToPack;
1577 ToPack.reserve(T->getNumArgs());
1578 if (Error Err = ImportTemplateArguments(
1579 T->getArgs(), T->getNumArgs(), ToPack))
1580 return std::move(Err);
1581
1582 return Importer.getToContext().getDependentTemplateSpecializationType(
1583 T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1584 }
1585
1586 ExpectedType
VisitDependentNameType(const DependentNameType * T)1587 ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1588 auto ToQualifierOrErr = import(T->getQualifier());
1589 if (!ToQualifierOrErr)
1590 return ToQualifierOrErr.takeError();
1591
1592 IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1593
1594 QualType Canon;
1595 if (T != T->getCanonicalTypeInternal().getTypePtr()) {
1596 if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1597 Canon = (*TyOrErr).getCanonicalType();
1598 else
1599 return TyOrErr.takeError();
1600 }
1601
1602 return Importer.getToContext().getDependentNameType(T->getKeyword(),
1603 *ToQualifierOrErr,
1604 Name, Canon);
1605 }
1606
1607 ExpectedType
VisitObjCInterfaceType(const ObjCInterfaceType * T)1608 ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1609 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1610 if (!ToDeclOrErr)
1611 return ToDeclOrErr.takeError();
1612
1613 return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
1614 }
1615
VisitObjCObjectType(const ObjCObjectType * T)1616 ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1617 ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1618 if (!ToBaseTypeOrErr)
1619 return ToBaseTypeOrErr.takeError();
1620
1621 SmallVector<QualType, 4> TypeArgs;
1622 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1623 if (ExpectedType TyOrErr = import(TypeArg))
1624 TypeArgs.push_back(*TyOrErr);
1625 else
1626 return TyOrErr.takeError();
1627 }
1628
1629 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1630 for (auto *P : T->quals()) {
1631 if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
1632 Protocols.push_back(*ProtocolOrErr);
1633 else
1634 return ProtocolOrErr.takeError();
1635
1636 }
1637
1638 return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
1639 Protocols,
1640 T->isKindOfTypeAsWritten());
1641 }
1642
1643 ExpectedType
VisitObjCObjectPointerType(const ObjCObjectPointerType * T)1644 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1645 ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1646 if (!ToPointeeTypeOrErr)
1647 return ToPointeeTypeOrErr.takeError();
1648
1649 return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr);
1650 }
1651
1652 //----------------------------------------------------------------------------
1653 // Import Declarations
1654 //----------------------------------------------------------------------------
ImportDeclParts(NamedDecl * D,DeclContext * & DC,DeclContext * & LexicalDC,DeclarationName & Name,NamedDecl * & ToD,SourceLocation & Loc)1655 Error ASTNodeImporter::ImportDeclParts(
1656 NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
1657 DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
1658 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1659 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1660 // FIXME: We could support these constructs by importing a different type of
1661 // this parameter and by importing the original type of the parameter only
1662 // after the FunctionDecl is created. See
1663 // VisitFunctionDecl::UsedDifferentProtoType.
1664 DeclContext *OrigDC = D->getDeclContext();
1665 FunctionDecl *FunDecl;
1666 if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1667 FunDecl->hasBody()) {
1668 auto getLeafPointeeType = [](const Type *T) {
1669 while (T->isPointerType() || T->isArrayType()) {
1670 T = T->getPointeeOrArrayElementType();
1671 }
1672 return T;
1673 };
1674 for (const ParmVarDecl *P : FunDecl->parameters()) {
1675 const Type *LeafT =
1676 getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
1677 auto *RT = dyn_cast<RecordType>(LeafT);
1678 if (RT && RT->getDecl() == D) {
1679 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1680 << D->getDeclKindName();
1681 return make_error<ImportError>(ImportError::UnsupportedConstruct);
1682 }
1683 }
1684 }
1685
1686 // Import the context of this declaration.
1687 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
1688 return Err;
1689
1690 // Import the name of this declaration.
1691 if (Error Err = importInto(Name, D->getDeclName()))
1692 return Err;
1693
1694 // Import the location of this declaration.
1695 if (Error Err = importInto(Loc, D->getLocation()))
1696 return Err;
1697
1698 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1699 if (ToD)
1700 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1701 return Err;
1702
1703 return Error::success();
1704 }
1705
ImportDeclParts(NamedDecl * D,DeclarationName & Name,NamedDecl * & ToD,SourceLocation & Loc)1706 Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
1707 NamedDecl *&ToD, SourceLocation &Loc) {
1708
1709 // Import the name of this declaration.
1710 if (Error Err = importInto(Name, D->getDeclName()))
1711 return Err;
1712
1713 // Import the location of this declaration.
1714 if (Error Err = importInto(Loc, D->getLocation()))
1715 return Err;
1716
1717 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1718 if (ToD)
1719 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1720 return Err;
1721
1722 return Error::success();
1723 }
1724
ImportDefinitionIfNeeded(Decl * FromD,Decl * ToD)1725 Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1726 if (!FromD)
1727 return Error::success();
1728
1729 if (!ToD)
1730 if (Error Err = importInto(ToD, FromD))
1731 return Err;
1732
1733 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1734 if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1735 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1736 !ToRecord->getDefinition()) {
1737 if (Error Err = ImportDefinition(FromRecord, ToRecord))
1738 return Err;
1739 }
1740 }
1741 return Error::success();
1742 }
1743
1744 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1745 if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1746 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1747 if (Error Err = ImportDefinition(FromEnum, ToEnum))
1748 return Err;
1749 }
1750 }
1751 return Error::success();
1752 }
1753
1754 return Error::success();
1755 }
1756
1757 Error
ImportDeclarationNameLoc(const DeclarationNameInfo & From,DeclarationNameInfo & To)1758 ASTNodeImporter::ImportDeclarationNameLoc(
1759 const DeclarationNameInfo &From, DeclarationNameInfo& To) {
1760 // NOTE: To.Name and To.Loc are already imported.
1761 // We only have to import To.LocInfo.
1762 switch (To.getName().getNameKind()) {
1763 case DeclarationName::Identifier:
1764 case DeclarationName::ObjCZeroArgSelector:
1765 case DeclarationName::ObjCOneArgSelector:
1766 case DeclarationName::ObjCMultiArgSelector:
1767 case DeclarationName::CXXUsingDirective:
1768 case DeclarationName::CXXDeductionGuideName:
1769 return Error::success();
1770
1771 case DeclarationName::CXXOperatorName: {
1772 if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
1773 To.setCXXOperatorNameRange(*ToRangeOrErr);
1774 else
1775 return ToRangeOrErr.takeError();
1776 return Error::success();
1777 }
1778 case DeclarationName::CXXLiteralOperatorName: {
1779 if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
1780 To.setCXXLiteralOperatorNameLoc(*LocOrErr);
1781 else
1782 return LocOrErr.takeError();
1783 return Error::success();
1784 }
1785 case DeclarationName::CXXConstructorName:
1786 case DeclarationName::CXXDestructorName:
1787 case DeclarationName::CXXConversionFunctionName: {
1788 if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
1789 To.setNamedTypeInfo(*ToTInfoOrErr);
1790 else
1791 return ToTInfoOrErr.takeError();
1792 return Error::success();
1793 }
1794 }
1795 llvm_unreachable("Unknown name kind.");
1796 }
1797
1798 Error
ImportDeclContext(DeclContext * FromDC,bool ForceImport)1799 ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1800 if (Importer.isMinimalImport() && !ForceImport) {
1801 auto ToDCOrErr = Importer.ImportContext(FromDC);
1802 return ToDCOrErr.takeError();
1803 }
1804
1805 // We use strict error handling in case of records and enums, but not
1806 // with e.g. namespaces.
1807 //
1808 // FIXME Clients of the ASTImporter should be able to choose an
1809 // appropriate error handling strategy for their needs. For instance,
1810 // they may not want to mark an entire namespace as erroneous merely
1811 // because there is an ODR error with two typedefs. As another example,
1812 // the client may allow EnumConstantDecls with same names but with
1813 // different values in two distinct translation units.
1814 bool AccumulateChildErrors = isa<TagDecl>(FromDC);
1815
1816 Error ChildErrors = Error::success();
1817 for (auto *From : FromDC->decls()) {
1818 ExpectedDecl ImportedOrErr = import(From);
1819
1820 // If we are in the process of ImportDefinition(...) for a RecordDecl we
1821 // want to make sure that we are also completing each FieldDecl. There
1822 // are currently cases where this does not happen and this is correctness
1823 // fix since operations such as code generation will expect this to be so.
1824 if (ImportedOrErr) {
1825 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1826 Decl *ImportedDecl = *ImportedOrErr;
1827 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1828 if (FieldFrom && FieldTo) {
1829 RecordDecl *FromRecordDecl = nullptr;
1830 RecordDecl *ToRecordDecl = nullptr;
1831 // If we have a field that is an ArrayType we need to check if the array
1832 // element is a RecordDecl and if so we need to import the definition.
1833 if (FieldFrom->getType()->isArrayType()) {
1834 // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
1835 FromRecordDecl = FieldFrom->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1836 ToRecordDecl = FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1837 }
1838
1839 if (!FromRecordDecl || !ToRecordDecl) {
1840 const RecordType *RecordFrom =
1841 FieldFrom->getType()->getAs<RecordType>();
1842 const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>();
1843
1844 if (RecordFrom && RecordTo) {
1845 FromRecordDecl = RecordFrom->getDecl();
1846 ToRecordDecl = RecordTo->getDecl();
1847 }
1848 }
1849
1850 if (FromRecordDecl && ToRecordDecl) {
1851 if (FromRecordDecl->isCompleteDefinition() &&
1852 !ToRecordDecl->isCompleteDefinition()) {
1853 Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl);
1854
1855 if (Err && AccumulateChildErrors)
1856 ChildErrors = joinErrors(std::move(ChildErrors), std::move(Err));
1857 else
1858 consumeError(std::move(Err));
1859 }
1860 }
1861 }
1862 } else {
1863 if (AccumulateChildErrors)
1864 ChildErrors =
1865 joinErrors(std::move(ChildErrors), ImportedOrErr.takeError());
1866 else
1867 consumeError(ImportedOrErr.takeError());
1868 }
1869 }
1870
1871 // We reorder declarations in RecordDecls because they may have another order
1872 // in the "to" context than they have in the "from" context. This may happen
1873 // e.g when we import a class like this:
1874 // struct declToImport {
1875 // int a = c + b;
1876 // int b = 1;
1877 // int c = 2;
1878 // };
1879 // During the import of `a` we import first the dependencies in sequence,
1880 // thus the order would be `c`, `b`, `a`. We will get the normal order by
1881 // first removing the already imported members and then adding them in the
1882 // order as they apper in the "from" context.
1883 //
1884 // Keeping field order is vital because it determines structure layout.
1885 //
1886 // Here and below, we cannot call field_begin() method and its callers on
1887 // ToDC if it has an external storage. Calling field_begin() will
1888 // automatically load all the fields by calling
1889 // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
1890 // call ASTImporter::Import(). This is because the ExternalASTSource
1891 // interface in LLDB is implemented by the means of the ASTImporter. However,
1892 // calling an import at this point would result in an uncontrolled import, we
1893 // must avoid that.
1894 const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1895 if (!FromRD)
1896 return ChildErrors;
1897
1898 auto ToDCOrErr = Importer.ImportContext(FromDC);
1899 if (!ToDCOrErr) {
1900 consumeError(std::move(ChildErrors));
1901 return ToDCOrErr.takeError();
1902 }
1903
1904 DeclContext *ToDC = *ToDCOrErr;
1905 // Remove all declarations, which may be in wrong order in the
1906 // lexical DeclContext and then add them in the proper order.
1907 for (auto *D : FromRD->decls()) {
1908 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1909 assert(D && "DC contains a null decl");
1910 Decl *ToD = Importer.GetAlreadyImportedOrNull(D);
1911 // Remove only the decls which we successfully imported.
1912 if (ToD) {
1913 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
1914 // Remove the decl from its wrong place in the linked list.
1915 ToDC->removeDecl(ToD);
1916 // Add the decl to the end of the linked list.
1917 // This time it will be at the proper place because the enclosing for
1918 // loop iterates in the original (good) order of the decls.
1919 ToDC->addDeclInternal(ToD);
1920 }
1921 }
1922 }
1923
1924 return ChildErrors;
1925 }
1926
ImportDeclContext(Decl * FromD,DeclContext * & ToDC,DeclContext * & ToLexicalDC)1927 Error ASTNodeImporter::ImportDeclContext(
1928 Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
1929 auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
1930 if (!ToDCOrErr)
1931 return ToDCOrErr.takeError();
1932 ToDC = *ToDCOrErr;
1933
1934 if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
1935 auto ToLexicalDCOrErr = Importer.ImportContext(
1936 FromD->getLexicalDeclContext());
1937 if (!ToLexicalDCOrErr)
1938 return ToLexicalDCOrErr.takeError();
1939 ToLexicalDC = *ToLexicalDCOrErr;
1940 } else
1941 ToLexicalDC = ToDC;
1942
1943 return Error::success();
1944 }
1945
ImportImplicitMethods(const CXXRecordDecl * From,CXXRecordDecl * To)1946 Error ASTNodeImporter::ImportImplicitMethods(
1947 const CXXRecordDecl *From, CXXRecordDecl *To) {
1948 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1949 "Import implicit methods to or from non-definition");
1950
1951 for (CXXMethodDecl *FromM : From->methods())
1952 if (FromM->isImplicit()) {
1953 Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
1954 if (!ToMOrErr)
1955 return ToMOrErr.takeError();
1956 }
1957
1958 return Error::success();
1959 }
1960
setTypedefNameForAnonDecl(TagDecl * From,TagDecl * To,ASTImporter & Importer)1961 static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1962 ASTImporter &Importer) {
1963 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1964 if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef))
1965 To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
1966 else
1967 return ToTypedefOrErr.takeError();
1968 }
1969 return Error::success();
1970 }
1971
ImportDefinition(RecordDecl * From,RecordDecl * To,ImportDefinitionKind Kind)1972 Error ASTNodeImporter::ImportDefinition(
1973 RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
1974 auto DefinitionCompleter = [To]() {
1975 // There are cases in LLDB when we first import a class without its
1976 // members. The class will have DefinitionData, but no members. Then,
1977 // importDefinition is called from LLDB, which tries to get the members, so
1978 // when we get here, the class already has the DefinitionData set, so we
1979 // must unset the CompleteDefinition here to be able to complete again the
1980 // definition.
1981 To->setCompleteDefinition(false);
1982 To->completeDefinition();
1983 };
1984
1985 if (To->getDefinition() || To->isBeingDefined()) {
1986 if (Kind == IDK_Everything ||
1987 // In case of lambdas, the class already has a definition ptr set, but
1988 // the contained decls are not imported yet. Also, isBeingDefined was
1989 // set in CXXRecordDecl::CreateLambda. We must import the contained
1990 // decls here and finish the definition.
1991 (To->isLambda() && shouldForceImportDeclContext(Kind))) {
1992 if (To->isLambda()) {
1993 auto *FromCXXRD = cast<CXXRecordDecl>(From);
1994 SmallVector<LambdaCapture, 8> ToCaptures;
1995 ToCaptures.reserve(FromCXXRD->capture_size());
1996 for (const auto &FromCapture : FromCXXRD->captures()) {
1997 if (auto ToCaptureOrErr = import(FromCapture))
1998 ToCaptures.push_back(*ToCaptureOrErr);
1999 else
2000 return ToCaptureOrErr.takeError();
2001 }
2002 cast<CXXRecordDecl>(To)->setCaptures(Importer.getToContext(),
2003 ToCaptures);
2004 }
2005
2006 Error Result = ImportDeclContext(From, /*ForceImport=*/true);
2007 // Finish the definition of the lambda, set isBeingDefined to false.
2008 if (To->isLambda())
2009 DefinitionCompleter();
2010 return Result;
2011 }
2012
2013 return Error::success();
2014 }
2015
2016 To->startDefinition();
2017 // Complete the definition even if error is returned.
2018 // The RecordDecl may be already part of the AST so it is better to
2019 // have it in complete state even if something is wrong with it.
2020 auto DefinitionCompleterScopeExit =
2021 llvm::make_scope_exit(DefinitionCompleter);
2022
2023 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2024 return Err;
2025
2026 // Add base classes.
2027 auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
2028 auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
2029 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2030
2031 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2032 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2033
2034 #define FIELD(Name, Width, Merge) \
2035 ToData.Name = FromData.Name;
2036 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2037
2038 // Copy over the data stored in RecordDeclBits
2039 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2040
2041 SmallVector<CXXBaseSpecifier *, 4> Bases;
2042 for (const auto &Base1 : FromCXX->bases()) {
2043 ExpectedType TyOrErr = import(Base1.getType());
2044 if (!TyOrErr)
2045 return TyOrErr.takeError();
2046
2047 SourceLocation EllipsisLoc;
2048 if (Base1.isPackExpansion()) {
2049 if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
2050 EllipsisLoc = *LocOrErr;
2051 else
2052 return LocOrErr.takeError();
2053 }
2054
2055 // Ensure that we have a definition for the base.
2056 if (Error Err =
2057 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
2058 return Err;
2059
2060 auto RangeOrErr = import(Base1.getSourceRange());
2061 if (!RangeOrErr)
2062 return RangeOrErr.takeError();
2063
2064 auto TSIOrErr = import(Base1.getTypeSourceInfo());
2065 if (!TSIOrErr)
2066 return TSIOrErr.takeError();
2067
2068 Bases.push_back(
2069 new (Importer.getToContext()) CXXBaseSpecifier(
2070 *RangeOrErr,
2071 Base1.isVirtual(),
2072 Base1.isBaseOfClass(),
2073 Base1.getAccessSpecifierAsWritten(),
2074 *TSIOrErr,
2075 EllipsisLoc));
2076 }
2077 if (!Bases.empty())
2078 ToCXX->setBases(Bases.data(), Bases.size());
2079 }
2080
2081 if (shouldForceImportDeclContext(Kind))
2082 if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2083 return Err;
2084
2085 return Error::success();
2086 }
2087
ImportInitializer(VarDecl * From,VarDecl * To)2088 Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
2089 if (To->getAnyInitializer())
2090 return Error::success();
2091
2092 Expr *FromInit = From->getInit();
2093 if (!FromInit)
2094 return Error::success();
2095
2096 ExpectedExpr ToInitOrErr = import(FromInit);
2097 if (!ToInitOrErr)
2098 return ToInitOrErr.takeError();
2099
2100 To->setInit(*ToInitOrErr);
2101 if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2102 EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2103 ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2104 ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2105 // FIXME: Also import the initializer value.
2106 }
2107
2108 // FIXME: Other bits to merge?
2109 return Error::success();
2110 }
2111
ImportDefinition(EnumDecl * From,EnumDecl * To,ImportDefinitionKind Kind)2112 Error ASTNodeImporter::ImportDefinition(
2113 EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
2114 if (To->getDefinition() || To->isBeingDefined()) {
2115 if (Kind == IDK_Everything)
2116 return ImportDeclContext(From, /*ForceImport=*/true);
2117 return Error::success();
2118 }
2119
2120 To->startDefinition();
2121
2122 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2123 return Err;
2124
2125 ExpectedType ToTypeOrErr =
2126 import(Importer.getFromContext().getTypeDeclType(From));
2127 if (!ToTypeOrErr)
2128 return ToTypeOrErr.takeError();
2129
2130 ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2131 if (!ToPromotionTypeOrErr)
2132 return ToPromotionTypeOrErr.takeError();
2133
2134 if (shouldForceImportDeclContext(Kind))
2135 if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2136 return Err;
2137
2138 // FIXME: we might need to merge the number of positive or negative bits
2139 // if the enumerator lists don't match.
2140 To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
2141 From->getNumPositiveBits(),
2142 From->getNumNegativeBits());
2143 return Error::success();
2144 }
2145
ImportTemplateArguments(const TemplateArgument * FromArgs,unsigned NumFromArgs,SmallVectorImpl<TemplateArgument> & ToArgs)2146 Error ASTNodeImporter::ImportTemplateArguments(
2147 const TemplateArgument *FromArgs, unsigned NumFromArgs,
2148 SmallVectorImpl<TemplateArgument> &ToArgs) {
2149 for (unsigned I = 0; I != NumFromArgs; ++I) {
2150 if (auto ToOrErr = import(FromArgs[I]))
2151 ToArgs.push_back(*ToOrErr);
2152 else
2153 return ToOrErr.takeError();
2154 }
2155
2156 return Error::success();
2157 }
2158
2159 // FIXME: Do not forget to remove this and use only 'import'.
2160 Expected<TemplateArgument>
ImportTemplateArgument(const TemplateArgument & From)2161 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2162 return import(From);
2163 }
2164
2165 template <typename InContainerTy>
ImportTemplateArgumentListInfo(const InContainerTy & Container,TemplateArgumentListInfo & ToTAInfo)2166 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
2167 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
2168 for (const auto &FromLoc : Container) {
2169 if (auto ToLocOrErr = import(FromLoc))
2170 ToTAInfo.addArgument(*ToLocOrErr);
2171 else
2172 return ToLocOrErr.takeError();
2173 }
2174 return Error::success();
2175 }
2176
2177 static StructuralEquivalenceKind
getStructuralEquivalenceKind(const ASTImporter & Importer)2178 getStructuralEquivalenceKind(const ASTImporter &Importer) {
2179 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
2180 : StructuralEquivalenceKind::Default;
2181 }
2182
IsStructuralMatch(Decl * From,Decl * To,bool Complain)2183 bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
2184 StructuralEquivalenceContext Ctx(
2185 Importer.getFromContext(), Importer.getToContext(),
2186 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2187 false, Complain);
2188 return Ctx.IsEquivalent(From, To);
2189 }
2190
IsStructuralMatch(RecordDecl * FromRecord,RecordDecl * ToRecord,bool Complain)2191 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2192 RecordDecl *ToRecord, bool Complain) {
2193 // Eliminate a potential failure point where we attempt to re-import
2194 // something we're trying to import while completing ToRecord.
2195 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2196 if (ToOrigin) {
2197 auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2198 if (ToOriginRecord)
2199 ToRecord = ToOriginRecord;
2200 }
2201
2202 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2203 ToRecord->getASTContext(),
2204 Importer.getNonEquivalentDecls(),
2205 getStructuralEquivalenceKind(Importer),
2206 false, Complain);
2207 return Ctx.IsEquivalent(FromRecord, ToRecord);
2208 }
2209
IsStructuralMatch(VarDecl * FromVar,VarDecl * ToVar,bool Complain)2210 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2211 bool Complain) {
2212 StructuralEquivalenceContext Ctx(
2213 Importer.getFromContext(), Importer.getToContext(),
2214 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2215 false, Complain);
2216 return Ctx.IsEquivalent(FromVar, ToVar);
2217 }
2218
IsStructuralMatch(EnumDecl * FromEnum,EnumDecl * ToEnum)2219 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2220 // Eliminate a potential failure point where we attempt to re-import
2221 // something we're trying to import while completing ToEnum.
2222 if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum))
2223 if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin))
2224 ToEnum = ToOriginEnum;
2225
2226 StructuralEquivalenceContext Ctx(
2227 Importer.getFromContext(), Importer.getToContext(),
2228 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
2229 return Ctx.IsEquivalent(FromEnum, ToEnum);
2230 }
2231
IsStructuralMatch(FunctionTemplateDecl * From,FunctionTemplateDecl * To)2232 bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
2233 FunctionTemplateDecl *To) {
2234 StructuralEquivalenceContext Ctx(
2235 Importer.getFromContext(), Importer.getToContext(),
2236 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2237 false, false);
2238 return Ctx.IsEquivalent(From, To);
2239 }
2240
IsStructuralMatch(FunctionDecl * From,FunctionDecl * To)2241 bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
2242 StructuralEquivalenceContext Ctx(
2243 Importer.getFromContext(), Importer.getToContext(),
2244 Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2245 false, false);
2246 return Ctx.IsEquivalent(From, To);
2247 }
2248
IsStructuralMatch(EnumConstantDecl * FromEC,EnumConstantDecl * ToEC)2249 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2250 EnumConstantDecl *ToEC) {
2251 const llvm::APSInt &FromVal = FromEC->getInitVal();
2252 const llvm::APSInt &ToVal = ToEC->getInitVal();
2253
2254 return FromVal.isSigned() == ToVal.isSigned() &&
2255 FromVal.getBitWidth() == ToVal.getBitWidth() &&
2256 FromVal == ToVal;
2257 }
2258
IsStructuralMatch(ClassTemplateDecl * From,ClassTemplateDecl * To)2259 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2260 ClassTemplateDecl *To) {
2261 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2262 Importer.getToContext(),
2263 Importer.getNonEquivalentDecls(),
2264 getStructuralEquivalenceKind(Importer));
2265 return Ctx.IsEquivalent(From, To);
2266 }
2267
IsStructuralMatch(VarTemplateDecl * From,VarTemplateDecl * To)2268 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2269 VarTemplateDecl *To) {
2270 StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2271 Importer.getToContext(),
2272 Importer.getNonEquivalentDecls(),
2273 getStructuralEquivalenceKind(Importer));
2274 return Ctx.IsEquivalent(From, To);
2275 }
2276
VisitDecl(Decl * D)2277 ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
2278 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2279 << D->getDeclKindName();
2280 return make_error<ImportError>(ImportError::UnsupportedConstruct);
2281 }
2282
VisitImportDecl(ImportDecl * D)2283 ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
2284 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2285 << D->getDeclKindName();
2286 return make_error<ImportError>(ImportError::UnsupportedConstruct);
2287 }
2288
VisitEmptyDecl(EmptyDecl * D)2289 ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
2290 // Import the context of this declaration.
2291 DeclContext *DC, *LexicalDC;
2292 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
2293 return std::move(Err);
2294
2295 // Import the location of this declaration.
2296 ExpectedSLoc LocOrErr = import(D->getLocation());
2297 if (!LocOrErr)
2298 return LocOrErr.takeError();
2299
2300 EmptyDecl *ToD;
2301 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr))
2302 return ToD;
2303
2304 ToD->setLexicalDeclContext(LexicalDC);
2305 LexicalDC->addDeclInternal(ToD);
2306 return ToD;
2307 }
2308
VisitTranslationUnitDecl(TranslationUnitDecl * D)2309 ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2310 TranslationUnitDecl *ToD =
2311 Importer.getToContext().getTranslationUnitDecl();
2312
2313 Importer.MapImported(D, ToD);
2314
2315 return ToD;
2316 }
2317
VisitBindingDecl(BindingDecl * D)2318 ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
2319 DeclContext *DC, *LexicalDC;
2320 DeclarationName Name;
2321 SourceLocation Loc;
2322 NamedDecl *ToND;
2323 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToND, Loc))
2324 return std::move(Err);
2325 if (ToND)
2326 return ToND;
2327
2328 BindingDecl *ToD;
2329 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc,
2330 Name.getAsIdentifierInfo()))
2331 return ToD;
2332
2333 Error Err = Error::success();
2334 QualType ToType = importChecked(Err, D->getType());
2335 Expr *ToBinding = importChecked(Err, D->getBinding());
2336 ValueDecl *ToDecomposedDecl = importChecked(Err, D->getDecomposedDecl());
2337 if (Err)
2338 return std::move(Err);
2339
2340 ToD->setBinding(ToType, ToBinding);
2341 ToD->setDecomposedDecl(ToDecomposedDecl);
2342 addDeclToContexts(D, ToD);
2343
2344 return ToD;
2345 }
2346
VisitAccessSpecDecl(AccessSpecDecl * D)2347 ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2348 ExpectedSLoc LocOrErr = import(D->getLocation());
2349 if (!LocOrErr)
2350 return LocOrErr.takeError();
2351 auto ColonLocOrErr = import(D->getColonLoc());
2352 if (!ColonLocOrErr)
2353 return ColonLocOrErr.takeError();
2354
2355 // Import the context of this declaration.
2356 auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2357 if (!DCOrErr)
2358 return DCOrErr.takeError();
2359 DeclContext *DC = *DCOrErr;
2360
2361 AccessSpecDecl *ToD;
2362 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
2363 DC, *LocOrErr, *ColonLocOrErr))
2364 return ToD;
2365
2366 // Lexical DeclContext and Semantic DeclContext
2367 // is always the same for the accessSpec.
2368 ToD->setLexicalDeclContext(DC);
2369 DC->addDeclInternal(ToD);
2370
2371 return ToD;
2372 }
2373
VisitStaticAssertDecl(StaticAssertDecl * D)2374 ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2375 auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2376 if (!DCOrErr)
2377 return DCOrErr.takeError();
2378 DeclContext *DC = *DCOrErr;
2379 DeclContext *LexicalDC = DC;
2380
2381 Error Err = Error::success();
2382 auto ToLocation = importChecked(Err, D->getLocation());
2383 auto ToRParenLoc = importChecked(Err, D->getRParenLoc());
2384 auto ToAssertExpr = importChecked(Err, D->getAssertExpr());
2385 auto ToMessage = importChecked(Err, D->getMessage());
2386 if (Err)
2387 return std::move(Err);
2388
2389 StaticAssertDecl *ToD;
2390 if (GetImportedOrCreateDecl(
2391 ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2392 ToRParenLoc, D->isFailed()))
2393 return ToD;
2394
2395 ToD->setLexicalDeclContext(LexicalDC);
2396 LexicalDC->addDeclInternal(ToD);
2397 return ToD;
2398 }
2399
VisitNamespaceDecl(NamespaceDecl * D)2400 ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2401 // Import the major distinguishing characteristics of this namespace.
2402 DeclContext *DC, *LexicalDC;
2403 DeclarationName Name;
2404 SourceLocation Loc;
2405 NamedDecl *ToD;
2406 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2407 return std::move(Err);
2408 if (ToD)
2409 return ToD;
2410
2411 NamespaceDecl *MergeWithNamespace = nullptr;
2412 if (!Name) {
2413 // This is an anonymous namespace. Adopt an existing anonymous
2414 // namespace if we can.
2415 // FIXME: Not testable.
2416 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2417 MergeWithNamespace = TU->getAnonymousNamespace();
2418 else
2419 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2420 } else {
2421 SmallVector<NamedDecl *, 4> ConflictingDecls;
2422 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2423 for (auto *FoundDecl : FoundDecls) {
2424 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
2425 continue;
2426
2427 if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2428 MergeWithNamespace = FoundNS;
2429 ConflictingDecls.clear();
2430 break;
2431 }
2432
2433 ConflictingDecls.push_back(FoundDecl);
2434 }
2435
2436 if (!ConflictingDecls.empty()) {
2437 ExpectedName NameOrErr = Importer.HandleNameConflict(
2438 Name, DC, Decl::IDNS_Namespace, ConflictingDecls.data(),
2439 ConflictingDecls.size());
2440 if (NameOrErr)
2441 Name = NameOrErr.get();
2442 else
2443 return NameOrErr.takeError();
2444 }
2445 }
2446
2447 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2448 if (!BeginLocOrErr)
2449 return BeginLocOrErr.takeError();
2450 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2451 if (!RBraceLocOrErr)
2452 return RBraceLocOrErr.takeError();
2453
2454 // Create the "to" namespace, if needed.
2455 NamespaceDecl *ToNamespace = MergeWithNamespace;
2456 if (!ToNamespace) {
2457 if (GetImportedOrCreateDecl(
2458 ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
2459 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2460 /*PrevDecl=*/nullptr))
2461 return ToNamespace;
2462 ToNamespace->setRBraceLoc(*RBraceLocOrErr);
2463 ToNamespace->setLexicalDeclContext(LexicalDC);
2464 LexicalDC->addDeclInternal(ToNamespace);
2465
2466 // If this is an anonymous namespace, register it as the anonymous
2467 // namespace within its context.
2468 if (!Name) {
2469 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2470 TU->setAnonymousNamespace(ToNamespace);
2471 else
2472 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2473 }
2474 }
2475 Importer.MapImported(D, ToNamespace);
2476
2477 if (Error Err = ImportDeclContext(D))
2478 return std::move(Err);
2479
2480 return ToNamespace;
2481 }
2482
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)2483 ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
2484 // Import the major distinguishing characteristics of this namespace.
2485 DeclContext *DC, *LexicalDC;
2486 DeclarationName Name;
2487 SourceLocation Loc;
2488 NamedDecl *LookupD;
2489 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
2490 return std::move(Err);
2491 if (LookupD)
2492 return LookupD;
2493
2494 // NOTE: No conflict resolution is done for namespace aliases now.
2495
2496 Error Err = Error::success();
2497 auto ToNamespaceLoc = importChecked(Err, D->getNamespaceLoc());
2498 auto ToAliasLoc = importChecked(Err, D->getAliasLoc());
2499 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2500 auto ToTargetNameLoc = importChecked(Err, D->getTargetNameLoc());
2501 auto ToNamespace = importChecked(Err, D->getNamespace());
2502 if (Err)
2503 return std::move(Err);
2504
2505 IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());
2506
2507 NamespaceAliasDecl *ToD;
2508 if (GetImportedOrCreateDecl(
2509 ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2510 ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2511 return ToD;
2512
2513 ToD->setLexicalDeclContext(LexicalDC);
2514 LexicalDC->addDeclInternal(ToD);
2515
2516 return ToD;
2517 }
2518
2519 ExpectedDecl
VisitTypedefNameDecl(TypedefNameDecl * D,bool IsAlias)2520 ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2521 // Import the major distinguishing characteristics of this typedef.
2522 DeclarationName Name;
2523 SourceLocation Loc;
2524 NamedDecl *ToD;
2525 // Do not import the DeclContext, we will import it once the TypedefNameDecl
2526 // is created.
2527 if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
2528 return std::move(Err);
2529 if (ToD)
2530 return ToD;
2531
2532 DeclContext *DC = cast_or_null<DeclContext>(
2533 Importer.GetAlreadyImportedOrNull(cast<Decl>(D->getDeclContext())));
2534 DeclContext *LexicalDC =
2535 cast_or_null<DeclContext>(Importer.GetAlreadyImportedOrNull(
2536 cast<Decl>(D->getLexicalDeclContext())));
2537
2538 // If this typedef is not in block scope, determine whether we've
2539 // seen a typedef with the same name (that we can merge with) or any
2540 // other entity by that name (which name lookup could conflict with).
2541 // Note: Repeated typedefs are not valid in C99:
2542 // 'typedef int T; typedef int T;' is invalid
2543 // We do not care about this now.
2544 if (DC && !DC->isFunctionOrMethod()) {
2545 SmallVector<NamedDecl *, 4> ConflictingDecls;
2546 unsigned IDNS = Decl::IDNS_Ordinary;
2547 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2548 for (auto *FoundDecl : FoundDecls) {
2549 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2550 continue;
2551 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2552 if (!hasSameVisibilityContextAndLinkage(FoundTypedef, D))
2553 continue;
2554
2555 QualType FromUT = D->getUnderlyingType();
2556 QualType FoundUT = FoundTypedef->getUnderlyingType();
2557 if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) {
2558 // If the "From" context has a complete underlying type but we
2559 // already have a complete underlying type then return with that.
2560 if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
2561 return Importer.MapImported(D, FoundTypedef);
2562 // FIXME Handle redecl chain. When you do that make consistent changes
2563 // in ASTImporterLookupTable too.
2564 } else {
2565 ConflictingDecls.push_back(FoundDecl);
2566 }
2567 }
2568 }
2569
2570 if (!ConflictingDecls.empty()) {
2571 ExpectedName NameOrErr = Importer.HandleNameConflict(
2572 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2573 if (NameOrErr)
2574 Name = NameOrErr.get();
2575 else
2576 return NameOrErr.takeError();
2577 }
2578 }
2579
2580 Error Err = Error::success();
2581 auto ToUnderlyingType = importChecked(Err, D->getUnderlyingType());
2582 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
2583 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2584 if (Err)
2585 return std::move(Err);
2586
2587 // Create the new typedef node.
2588 // FIXME: ToUnderlyingType is not used.
2589 (void)ToUnderlyingType;
2590 TypedefNameDecl *ToTypedef;
2591 if (IsAlias) {
2592 if (GetImportedOrCreateDecl<TypeAliasDecl>(
2593 ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2594 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2595 return ToTypedef;
2596 } else if (GetImportedOrCreateDecl<TypedefDecl>(
2597 ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2598 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2599 return ToTypedef;
2600
2601 // Import the DeclContext and set it to the Typedef.
2602 if ((Err = ImportDeclContext(D, DC, LexicalDC)))
2603 return std::move(Err);
2604 ToTypedef->setDeclContext(DC);
2605 ToTypedef->setLexicalDeclContext(LexicalDC);
2606 // Add to the lookupTable because we could not do that in MapImported.
2607 Importer.AddToLookupTable(ToTypedef);
2608
2609 ToTypedef->setAccess(D->getAccess());
2610
2611 // Templated declarations should not appear in DeclContext.
2612 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
2613 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
2614 LexicalDC->addDeclInternal(ToTypedef);
2615
2616 return ToTypedef;
2617 }
2618
VisitTypedefDecl(TypedefDecl * D)2619 ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2620 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2621 }
2622
VisitTypeAliasDecl(TypeAliasDecl * D)2623 ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2624 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2625 }
2626
2627 ExpectedDecl
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)2628 ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2629 // Import the major distinguishing characteristics of this typedef.
2630 DeclContext *DC, *LexicalDC;
2631 DeclarationName Name;
2632 SourceLocation Loc;
2633 NamedDecl *FoundD;
2634 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
2635 return std::move(Err);
2636 if (FoundD)
2637 return FoundD;
2638
2639 // If this typedef is not in block scope, determine whether we've
2640 // seen a typedef with the same name (that we can merge with) or any
2641 // other entity by that name (which name lookup could conflict with).
2642 if (!DC->isFunctionOrMethod()) {
2643 SmallVector<NamedDecl *, 4> ConflictingDecls;
2644 unsigned IDNS = Decl::IDNS_Ordinary;
2645 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2646 for (auto *FoundDecl : FoundDecls) {
2647 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2648 continue;
2649 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2650 return Importer.MapImported(D, FoundAlias);
2651 ConflictingDecls.push_back(FoundDecl);
2652 }
2653
2654 if (!ConflictingDecls.empty()) {
2655 ExpectedName NameOrErr = Importer.HandleNameConflict(
2656 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2657 if (NameOrErr)
2658 Name = NameOrErr.get();
2659 else
2660 return NameOrErr.takeError();
2661 }
2662 }
2663
2664 Error Err = Error::success();
2665 auto ToTemplateParameters = importChecked(Err, D->getTemplateParameters());
2666 auto ToTemplatedDecl = importChecked(Err, D->getTemplatedDecl());
2667 if (Err)
2668 return std::move(Err);
2669
2670 TypeAliasTemplateDecl *ToAlias;
2671 if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2672 Name, ToTemplateParameters, ToTemplatedDecl))
2673 return ToAlias;
2674
2675 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2676
2677 ToAlias->setAccess(D->getAccess());
2678 ToAlias->setLexicalDeclContext(LexicalDC);
2679 LexicalDC->addDeclInternal(ToAlias);
2680 if (DC != Importer.getToContext().getTranslationUnitDecl())
2681 updateLookupTableForTemplateParameters(*ToTemplateParameters);
2682 return ToAlias;
2683 }
2684
VisitLabelDecl(LabelDecl * D)2685 ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2686 // Import the major distinguishing characteristics of this label.
2687 DeclContext *DC, *LexicalDC;
2688 DeclarationName Name;
2689 SourceLocation Loc;
2690 NamedDecl *ToD;
2691 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2692 return std::move(Err);
2693 if (ToD)
2694 return ToD;
2695
2696 assert(LexicalDC->isFunctionOrMethod());
2697
2698 LabelDecl *ToLabel;
2699 if (D->isGnuLocal()) {
2700 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2701 if (!BeginLocOrErr)
2702 return BeginLocOrErr.takeError();
2703 if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2704 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2705 return ToLabel;
2706
2707 } else {
2708 if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2709 Name.getAsIdentifierInfo()))
2710 return ToLabel;
2711
2712 }
2713
2714 Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
2715 if (!ToStmtOrErr)
2716 return ToStmtOrErr.takeError();
2717
2718 ToLabel->setStmt(*ToStmtOrErr);
2719 ToLabel->setLexicalDeclContext(LexicalDC);
2720 LexicalDC->addDeclInternal(ToLabel);
2721 return ToLabel;
2722 }
2723
VisitEnumDecl(EnumDecl * D)2724 ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2725 // Import the major distinguishing characteristics of this enum.
2726 DeclContext *DC, *LexicalDC;
2727 DeclarationName Name;
2728 SourceLocation Loc;
2729 NamedDecl *ToD;
2730 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2731 return std::move(Err);
2732 if (ToD)
2733 return ToD;
2734
2735 // Figure out what enum name we're looking for.
2736 unsigned IDNS = Decl::IDNS_Tag;
2737 DeclarationName SearchName = Name;
2738 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2739 if (Error Err = importInto(
2740 SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2741 return std::move(Err);
2742 IDNS = Decl::IDNS_Ordinary;
2743 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2744 IDNS |= Decl::IDNS_Ordinary;
2745
2746 // We may already have an enum of the same name; try to find and match it.
2747 EnumDecl *PrevDecl = nullptr;
2748 if (!DC->isFunctionOrMethod() && SearchName) {
2749 SmallVector<NamedDecl *, 4> ConflictingDecls;
2750 auto FoundDecls =
2751 Importer.findDeclsInToCtx(DC, SearchName);
2752 for (auto *FoundDecl : FoundDecls) {
2753 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2754 continue;
2755
2756 if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2757 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2758 FoundDecl = Tag->getDecl();
2759 }
2760
2761 if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2762 if (!hasSameVisibilityContextAndLinkage(FoundEnum, D))
2763 continue;
2764 if (IsStructuralMatch(D, FoundEnum)) {
2765 EnumDecl *FoundDef = FoundEnum->getDefinition();
2766 if (D->isThisDeclarationADefinition() && FoundDef)
2767 return Importer.MapImported(D, FoundDef);
2768 PrevDecl = FoundEnum->getMostRecentDecl();
2769 break;
2770 }
2771 ConflictingDecls.push_back(FoundDecl);
2772 }
2773 }
2774
2775 if (!ConflictingDecls.empty()) {
2776 ExpectedName NameOrErr = Importer.HandleNameConflict(
2777 SearchName, DC, IDNS, ConflictingDecls.data(),
2778 ConflictingDecls.size());
2779 if (NameOrErr)
2780 Name = NameOrErr.get();
2781 else
2782 return NameOrErr.takeError();
2783 }
2784 }
2785
2786 Error Err = Error::success();
2787 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2788 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2789 auto ToIntegerType = importChecked(Err, D->getIntegerType());
2790 auto ToBraceRange = importChecked(Err, D->getBraceRange());
2791 if (Err)
2792 return std::move(Err);
2793
2794 // Create the enum declaration.
2795 EnumDecl *D2;
2796 if (GetImportedOrCreateDecl(
2797 D2, D, Importer.getToContext(), DC, ToBeginLoc,
2798 Loc, Name.getAsIdentifierInfo(), PrevDecl, D->isScoped(),
2799 D->isScopedUsingClassTag(), D->isFixed()))
2800 return D2;
2801
2802 D2->setQualifierInfo(ToQualifierLoc);
2803 D2->setIntegerType(ToIntegerType);
2804 D2->setBraceRange(ToBraceRange);
2805 D2->setAccess(D->getAccess());
2806 D2->setLexicalDeclContext(LexicalDC);
2807 addDeclToContexts(D, D2);
2808
2809 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
2810 TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
2811 EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
2812 if (Expected<EnumDecl *> ToInstOrErr = import(FromInst))
2813 D2->setInstantiationOfMemberEnum(*ToInstOrErr, SK);
2814 else
2815 return ToInstOrErr.takeError();
2816 if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
2817 D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
2818 else
2819 return POIOrErr.takeError();
2820 }
2821
2822 // Import the definition
2823 if (D->isCompleteDefinition())
2824 if (Error Err = ImportDefinition(D, D2))
2825 return std::move(Err);
2826
2827 return D2;
2828 }
2829
VisitRecordDecl(RecordDecl * D)2830 ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2831 bool IsFriendTemplate = false;
2832 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2833 IsFriendTemplate =
2834 DCXX->getDescribedClassTemplate() &&
2835 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2836 Decl::FOK_None;
2837 }
2838
2839 // Import the major distinguishing characteristics of this record.
2840 DeclContext *DC = nullptr, *LexicalDC = nullptr;
2841 DeclarationName Name;
2842 SourceLocation Loc;
2843 NamedDecl *ToD = nullptr;
2844 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2845 return std::move(Err);
2846 if (ToD)
2847 return ToD;
2848
2849 // Figure out what structure name we're looking for.
2850 unsigned IDNS = Decl::IDNS_Tag;
2851 DeclarationName SearchName = Name;
2852 if (!SearchName && D->getTypedefNameForAnonDecl()) {
2853 if (Error Err = importInto(
2854 SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2855 return std::move(Err);
2856 IDNS = Decl::IDNS_Ordinary;
2857 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2858 IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
2859
2860 // We may already have a record of the same name; try to find and match it.
2861 RecordDecl *PrevDecl = nullptr;
2862 if (!DC->isFunctionOrMethod() && !D->isLambda()) {
2863 SmallVector<NamedDecl *, 4> ConflictingDecls;
2864 auto FoundDecls =
2865 Importer.findDeclsInToCtx(DC, SearchName);
2866 if (!FoundDecls.empty()) {
2867 // We're going to have to compare D against potentially conflicting Decls,
2868 // so complete it.
2869 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2870 D->getASTContext().getExternalSource()->CompleteType(D);
2871 }
2872
2873 for (auto *FoundDecl : FoundDecls) {
2874 if (!FoundDecl->isInIdentifierNamespace(IDNS))
2875 continue;
2876
2877 Decl *Found = FoundDecl;
2878 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2879 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2880 Found = Tag->getDecl();
2881 }
2882
2883 if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2884 // Do not emit false positive diagnostic in case of unnamed
2885 // struct/union and in case of anonymous structs. Would be false
2886 // because there may be several anonymous/unnamed structs in a class.
2887 // E.g. these are both valid:
2888 // struct A { // unnamed structs
2889 // struct { struct A *next; } entry0;
2890 // struct { struct A *next; } entry1;
2891 // };
2892 // struct X { struct { int a; }; struct { int b; }; }; // anon structs
2893 if (!SearchName)
2894 if (!IsStructuralMatch(D, FoundRecord, false))
2895 continue;
2896
2897 if (!hasSameVisibilityContextAndLinkage(FoundRecord, D))
2898 continue;
2899
2900 if (IsStructuralMatch(D, FoundRecord)) {
2901 RecordDecl *FoundDef = FoundRecord->getDefinition();
2902 if (D->isThisDeclarationADefinition() && FoundDef) {
2903 // FIXME: Structural equivalence check should check for same
2904 // user-defined methods.
2905 Importer.MapImported(D, FoundDef);
2906 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2907 auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2908 assert(FoundCXX && "Record type mismatch");
2909
2910 if (!Importer.isMinimalImport())
2911 // FoundDef may not have every implicit method that D has
2912 // because implicit methods are created only if they are used.
2913 if (Error Err = ImportImplicitMethods(DCXX, FoundCXX))
2914 return std::move(Err);
2915 }
2916 }
2917 PrevDecl = FoundRecord->getMostRecentDecl();
2918 break;
2919 }
2920 ConflictingDecls.push_back(FoundDecl);
2921 } // kind is RecordDecl
2922 } // for
2923
2924 if (!ConflictingDecls.empty() && SearchName) {
2925 ExpectedName NameOrErr = Importer.HandleNameConflict(
2926 SearchName, DC, IDNS, ConflictingDecls.data(),
2927 ConflictingDecls.size());
2928 if (NameOrErr)
2929 Name = NameOrErr.get();
2930 else
2931 return NameOrErr.takeError();
2932 }
2933 }
2934
2935 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2936 if (!BeginLocOrErr)
2937 return BeginLocOrErr.takeError();
2938
2939 // Create the record declaration.
2940 RecordDecl *D2 = nullptr;
2941 CXXRecordDecl *D2CXX = nullptr;
2942 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2943 if (DCXX->isLambda()) {
2944 auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
2945 if (!TInfoOrErr)
2946 return TInfoOrErr.takeError();
2947 if (GetImportedOrCreateSpecialDecl(
2948 D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2949 DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(),
2950 DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2951 return D2CXX;
2952 ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl());
2953 if (!CDeclOrErr)
2954 return CDeclOrErr.takeError();
2955 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
2956 DCXX->hasKnownLambdaInternalLinkage());
2957 D2CXX->setDeviceLambdaManglingNumber(
2958 DCXX->getDeviceLambdaManglingNumber());
2959 } else if (DCXX->isInjectedClassName()) {
2960 // We have to be careful to do a similar dance to the one in
2961 // Sema::ActOnStartCXXMemberDeclarations
2962 const bool DelayTypeCreation = true;
2963 if (GetImportedOrCreateDecl(
2964 D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
2965 *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2966 cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2967 return D2CXX;
2968 Importer.getToContext().getTypeDeclType(
2969 D2CXX, dyn_cast<CXXRecordDecl>(DC));
2970 } else {
2971 if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2972 D->getTagKind(), DC, *BeginLocOrErr, Loc,
2973 Name.getAsIdentifierInfo(),
2974 cast_or_null<CXXRecordDecl>(PrevDecl)))
2975 return D2CXX;
2976 }
2977
2978 D2 = D2CXX;
2979 D2->setAccess(D->getAccess());
2980 D2->setLexicalDeclContext(LexicalDC);
2981 addDeclToContexts(D, D2);
2982
2983 if (ClassTemplateDecl *FromDescribed =
2984 DCXX->getDescribedClassTemplate()) {
2985 ClassTemplateDecl *ToDescribed;
2986 if (Error Err = importInto(ToDescribed, FromDescribed))
2987 return std::move(Err);
2988 D2CXX->setDescribedClassTemplate(ToDescribed);
2989 if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2990 // In a record describing a template the type should be an
2991 // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2992 // previously set type to the correct value here (ToDescribed is not
2993 // available at record create).
2994 // FIXME: The previous type is cleared but not removed from
2995 // ASTContext's internal storage.
2996 CXXRecordDecl *Injected = nullptr;
2997 for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2998 auto *Record = dyn_cast<CXXRecordDecl>(Found);
2999 if (Record && Record->isInjectedClassName()) {
3000 Injected = Record;
3001 break;
3002 }
3003 }
3004 // Create an injected type for the whole redecl chain.
3005 SmallVector<Decl *, 2> Redecls =
3006 getCanonicalForwardRedeclChain(D2CXX);
3007 for (auto *R : Redecls) {
3008 auto *RI = cast<CXXRecordDecl>(R);
3009 RI->setTypeForDecl(nullptr);
3010 // Below we create a new injected type and assign that to the
3011 // canonical decl, subsequent declarations in the chain will reuse
3012 // that type.
3013 Importer.getToContext().getInjectedClassNameType(
3014 RI, ToDescribed->getInjectedClassNameSpecialization());
3015 }
3016 // Set the new type for the previous injected decl too.
3017 if (Injected) {
3018 Injected->setTypeForDecl(nullptr);
3019 Importer.getToContext().getTypeDeclType(Injected, D2CXX);
3020 }
3021 }
3022 } else if (MemberSpecializationInfo *MemberInfo =
3023 DCXX->getMemberSpecializationInfo()) {
3024 TemplateSpecializationKind SK =
3025 MemberInfo->getTemplateSpecializationKind();
3026 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
3027
3028 if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
3029 D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
3030 else
3031 return ToInstOrErr.takeError();
3032
3033 if (ExpectedSLoc POIOrErr =
3034 import(MemberInfo->getPointOfInstantiation()))
3035 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
3036 *POIOrErr);
3037 else
3038 return POIOrErr.takeError();
3039 }
3040
3041 } else {
3042 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
3043 D->getTagKind(), DC, *BeginLocOrErr, Loc,
3044 Name.getAsIdentifierInfo(), PrevDecl))
3045 return D2;
3046 D2->setLexicalDeclContext(LexicalDC);
3047 addDeclToContexts(D, D2);
3048 }
3049
3050 if (auto BraceRangeOrErr = import(D->getBraceRange()))
3051 D2->setBraceRange(*BraceRangeOrErr);
3052 else
3053 return BraceRangeOrErr.takeError();
3054 if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
3055 D2->setQualifierInfo(*QualifierLocOrErr);
3056 else
3057 return QualifierLocOrErr.takeError();
3058
3059 if (D->isAnonymousStructOrUnion())
3060 D2->setAnonymousStructOrUnion(true);
3061
3062 if (D->isCompleteDefinition())
3063 if (Error Err = ImportDefinition(D, D2, IDK_Default))
3064 return std::move(Err);
3065
3066 return D2;
3067 }
3068
VisitEnumConstantDecl(EnumConstantDecl * D)3069 ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3070 // Import the major distinguishing characteristics of this enumerator.
3071 DeclContext *DC, *LexicalDC;
3072 DeclarationName Name;
3073 SourceLocation Loc;
3074 NamedDecl *ToD;
3075 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3076 return std::move(Err);
3077 if (ToD)
3078 return ToD;
3079
3080 // Determine whether there are any other declarations with the same name and
3081 // in the same context.
3082 if (!LexicalDC->isFunctionOrMethod()) {
3083 SmallVector<NamedDecl *, 4> ConflictingDecls;
3084 unsigned IDNS = Decl::IDNS_Ordinary;
3085 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3086 for (auto *FoundDecl : FoundDecls) {
3087 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3088 continue;
3089
3090 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
3091 if (IsStructuralMatch(D, FoundEnumConstant))
3092 return Importer.MapImported(D, FoundEnumConstant);
3093 ConflictingDecls.push_back(FoundDecl);
3094 }
3095 }
3096
3097 if (!ConflictingDecls.empty()) {
3098 ExpectedName NameOrErr = Importer.HandleNameConflict(
3099 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3100 if (NameOrErr)
3101 Name = NameOrErr.get();
3102 else
3103 return NameOrErr.takeError();
3104 }
3105 }
3106
3107 ExpectedType TypeOrErr = import(D->getType());
3108 if (!TypeOrErr)
3109 return TypeOrErr.takeError();
3110
3111 ExpectedExpr InitOrErr = import(D->getInitExpr());
3112 if (!InitOrErr)
3113 return InitOrErr.takeError();
3114
3115 EnumConstantDecl *ToEnumerator;
3116 if (GetImportedOrCreateDecl(
3117 ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3118 Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
3119 return ToEnumerator;
3120
3121 ToEnumerator->setAccess(D->getAccess());
3122 ToEnumerator->setLexicalDeclContext(LexicalDC);
3123 LexicalDC->addDeclInternal(ToEnumerator);
3124 return ToEnumerator;
3125 }
3126
ImportTemplateParameterLists(const DeclaratorDecl * FromD,DeclaratorDecl * ToD)3127 Error ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD,
3128 DeclaratorDecl *ToD) {
3129 unsigned int Num = FromD->getNumTemplateParameterLists();
3130 if (Num == 0)
3131 return Error::success();
3132 SmallVector<TemplateParameterList *, 2> ToTPLists(Num);
3133 for (unsigned int I = 0; I < Num; ++I)
3134 if (Expected<TemplateParameterList *> ToTPListOrErr =
3135 import(FromD->getTemplateParameterList(I)))
3136 ToTPLists[I] = *ToTPListOrErr;
3137 else
3138 return ToTPListOrErr.takeError();
3139 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3140 return Error::success();
3141 }
3142
ImportTemplateInformation(FunctionDecl * FromFD,FunctionDecl * ToFD)3143 Error ASTNodeImporter::ImportTemplateInformation(
3144 FunctionDecl *FromFD, FunctionDecl *ToFD) {
3145 switch (FromFD->getTemplatedKind()) {
3146 case FunctionDecl::TK_NonTemplate:
3147 case FunctionDecl::TK_FunctionTemplate:
3148 return Error::success();
3149
3150 case FunctionDecl::TK_MemberSpecialization: {
3151 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3152
3153 if (Expected<FunctionDecl *> InstFDOrErr =
3154 import(FromFD->getInstantiatedFromMemberFunction()))
3155 ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3156 else
3157 return InstFDOrErr.takeError();
3158
3159 if (ExpectedSLoc POIOrErr = import(
3160 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3161 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3162 else
3163 return POIOrErr.takeError();
3164
3165 return Error::success();
3166 }
3167
3168 case FunctionDecl::TK_FunctionTemplateSpecialization: {
3169 auto FunctionAndArgsOrErr =
3170 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3171 if (!FunctionAndArgsOrErr)
3172 return FunctionAndArgsOrErr.takeError();
3173
3174 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
3175 Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3176
3177 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3178 TemplateArgumentListInfo ToTAInfo;
3179 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3180 if (FromTAArgsAsWritten)
3181 if (Error Err = ImportTemplateArgumentListInfo(
3182 *FromTAArgsAsWritten, ToTAInfo))
3183 return Err;
3184
3185 ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3186 if (!POIOrErr)
3187 return POIOrErr.takeError();
3188
3189 if (Error Err = ImportTemplateParameterLists(FromFD, ToFD))
3190 return Err;
3191
3192 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3193 ToFD->setFunctionTemplateSpecialization(
3194 std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr,
3195 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr);
3196 return Error::success();
3197 }
3198
3199 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
3200 auto *FromInfo = FromFD->getDependentSpecializationInfo();
3201 UnresolvedSet<8> TemplDecls;
3202 unsigned NumTemplates = FromInfo->getNumTemplates();
3203 for (unsigned I = 0; I < NumTemplates; I++) {
3204 if (Expected<FunctionTemplateDecl *> ToFTDOrErr =
3205 import(FromInfo->getTemplate(I)))
3206 TemplDecls.addDecl(*ToFTDOrErr);
3207 else
3208 return ToFTDOrErr.takeError();
3209 }
3210
3211 // Import TemplateArgumentListInfo.
3212 TemplateArgumentListInfo ToTAInfo;
3213 if (Error Err = ImportTemplateArgumentListInfo(
3214 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3215 llvm::makeArrayRef(
3216 FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()),
3217 ToTAInfo))
3218 return Err;
3219
3220 ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
3221 TemplDecls, ToTAInfo);
3222 return Error::success();
3223 }
3224 }
3225 llvm_unreachable("All cases should be covered!");
3226 }
3227
3228 Expected<FunctionDecl *>
FindFunctionTemplateSpecialization(FunctionDecl * FromFD)3229 ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
3230 auto FunctionAndArgsOrErr =
3231 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3232 if (!FunctionAndArgsOrErr)
3233 return FunctionAndArgsOrErr.takeError();
3234
3235 FunctionTemplateDecl *Template;
3236 TemplateArgsTy ToTemplArgs;
3237 std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3238 void *InsertPos = nullptr;
3239 auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos);
3240 return FoundSpec;
3241 }
3242
ImportFunctionDeclBody(FunctionDecl * FromFD,FunctionDecl * ToFD)3243 Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
3244 FunctionDecl *ToFD) {
3245 if (Stmt *FromBody = FromFD->getBody()) {
3246 if (ExpectedStmt ToBodyOrErr = import(FromBody))
3247 ToFD->setBody(*ToBodyOrErr);
3248 else
3249 return ToBodyOrErr.takeError();
3250 }
3251 return Error::success();
3252 }
3253
3254 // Returns true if the given D has a DeclContext up to the TranslationUnitDecl
3255 // which is equal to the given DC.
isAncestorDeclContextOf(const DeclContext * DC,const Decl * D)3256 static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
3257 const DeclContext *DCi = D->getDeclContext();
3258 while (DCi != D->getTranslationUnitDecl()) {
3259 if (DCi == DC)
3260 return true;
3261 DCi = DCi->getParent();
3262 }
3263 return false;
3264 }
3265
hasAutoReturnTypeDeclaredInside(FunctionDecl * D)3266 bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
3267 QualType FromTy = D->getType();
3268 const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>();
3269 assert(FromFPT && "Must be called on FunctionProtoType");
3270 if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
3271 QualType DeducedT = AutoT->getDeducedType();
3272 if (const RecordType *RecordT =
3273 DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
3274 RecordDecl *RD = RecordT->getDecl();
3275 assert(RD);
3276 if (isAncestorDeclContextOf(D, RD)) {
3277 assert(RD->getLexicalDeclContext() == RD->getDeclContext());
3278 return true;
3279 }
3280 }
3281 }
3282 if (const TypedefType *TypedefT =
3283 dyn_cast<TypedefType>(FromFPT->getReturnType())) {
3284 TypedefNameDecl *TD = TypedefT->getDecl();
3285 assert(TD);
3286 if (isAncestorDeclContextOf(D, TD)) {
3287 assert(TD->getLexicalDeclContext() == TD->getDeclContext());
3288 return true;
3289 }
3290 }
3291 return false;
3292 }
3293
3294 ExplicitSpecifier
importExplicitSpecifier(Error & Err,ExplicitSpecifier ESpec)3295 ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
3296 Expr *ExplicitExpr = ESpec.getExpr();
3297 if (ExplicitExpr)
3298 ExplicitExpr = importChecked(Err, ESpec.getExpr());
3299 return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3300 }
3301
VisitFunctionDecl(FunctionDecl * D)3302 ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3303
3304 SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
3305 auto RedeclIt = Redecls.begin();
3306 // Import the first part of the decl chain. I.e. import all previous
3307 // declarations starting from the canonical decl.
3308 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3309 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3310 if (!ToRedeclOrErr)
3311 return ToRedeclOrErr.takeError();
3312 }
3313 assert(*RedeclIt == D);
3314
3315 // Import the major distinguishing characteristics of this function.
3316 DeclContext *DC, *LexicalDC;
3317 DeclarationName Name;
3318 SourceLocation Loc;
3319 NamedDecl *ToD;
3320 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3321 return std::move(Err);
3322 if (ToD)
3323 return ToD;
3324
3325 FunctionDecl *FoundByLookup = nullptr;
3326 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3327
3328 // If this is a function template specialization, then try to find the same
3329 // existing specialization in the "to" context. The lookup below will not
3330 // find any specialization, but would find the primary template; thus, we
3331 // have to skip normal lookup in case of specializations.
3332 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
3333 if (D->getTemplatedKind() ==
3334 FunctionDecl::TK_FunctionTemplateSpecialization) {
3335 auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D);
3336 if (!FoundFunctionOrErr)
3337 return FoundFunctionOrErr.takeError();
3338 if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3339 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3340 return Def;
3341 FoundByLookup = FoundFunction;
3342 }
3343 }
3344 // Try to find a function in our own ("to") context with the same name, same
3345 // type, and in the same context as the function we're importing.
3346 else if (!LexicalDC->isFunctionOrMethod()) {
3347 SmallVector<NamedDecl *, 4> ConflictingDecls;
3348 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
3349 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3350 for (auto *FoundDecl : FoundDecls) {
3351 if (!FoundDecl->isInIdentifierNamespace(IDNS))
3352 continue;
3353
3354 if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3355 if (!hasSameVisibilityContextAndLinkage(FoundFunction, D))
3356 continue;
3357
3358 if (IsStructuralMatch(D, FoundFunction)) {
3359 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3360 return Def;
3361 FoundByLookup = FoundFunction;
3362 break;
3363 }
3364 // FIXME: Check for overloading more carefully, e.g., by boosting
3365 // Sema::IsOverload out to the AST library.
3366
3367 // Function overloading is okay in C++.
3368 if (Importer.getToContext().getLangOpts().CPlusPlus)
3369 continue;
3370
3371 // Complain about inconsistent function types.
3372 Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3373 << Name << D->getType() << FoundFunction->getType();
3374 Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3375 << FoundFunction->getType();
3376 ConflictingDecls.push_back(FoundDecl);
3377 }
3378 }
3379
3380 if (!ConflictingDecls.empty()) {
3381 ExpectedName NameOrErr = Importer.HandleNameConflict(
3382 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3383 if (NameOrErr)
3384 Name = NameOrErr.get();
3385 else
3386 return NameOrErr.takeError();
3387 }
3388 }
3389
3390 // We do not allow more than one in-class declaration of a function. This is
3391 // because AST clients like VTableBuilder asserts on this. VTableBuilder
3392 // assumes there is only one in-class declaration. Building a redecl
3393 // chain would result in more than one in-class declaration for
3394 // overrides (even if they are part of the same redecl chain inside the
3395 // derived class.)
3396 if (FoundByLookup) {
3397 if (isa<CXXMethodDecl>(FoundByLookup)) {
3398 if (D->getLexicalDeclContext() == D->getDeclContext()) {
3399 if (!D->doesThisDeclarationHaveABody()) {
3400 if (FunctionTemplateDecl *DescribedD =
3401 D->getDescribedFunctionTemplate()) {
3402 // Handle a "templated" function together with its described
3403 // template. This avoids need for a similar check at import of the
3404 // described template.
3405 assert(FoundByLookup->getDescribedFunctionTemplate() &&
3406 "Templated function mapped to non-templated?");
3407 Importer.MapImported(DescribedD,
3408 FoundByLookup->getDescribedFunctionTemplate());
3409 }
3410 return Importer.MapImported(D, FoundByLookup);
3411 } else {
3412 // Let's continue and build up the redecl chain in this case.
3413 // FIXME Merge the functions into one decl.
3414 }
3415 }
3416 }
3417 }
3418
3419 DeclarationNameInfo NameInfo(Name, Loc);
3420 // Import additional name location/type info.
3421 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
3422 return std::move(Err);
3423
3424 QualType FromTy = D->getType();
3425 // Set to true if we do not import the type of the function as is. There are
3426 // cases when the original type would result in an infinite recursion during
3427 // the import. To avoid an infinite recursion when importing, we create the
3428 // FunctionDecl with a simplified function type and update it only after the
3429 // relevant AST nodes are already imported.
3430 bool UsedDifferentProtoType = false;
3431 if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3432 QualType FromReturnTy = FromFPT->getReturnType();
3433 // Functions with auto return type may define a struct inside their body
3434 // and the return type could refer to that struct.
3435 // E.g.: auto foo() { struct X{}; return X(); }
3436 // To avoid an infinite recursion when importing, create the FunctionDecl
3437 // with a simplified return type.
3438 if (hasAutoReturnTypeDeclaredInside(D)) {
3439 FromReturnTy = Importer.getFromContext().VoidTy;
3440 UsedDifferentProtoType = true;
3441 }
3442 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3443 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3444 // FunctionDecl that we are importing the FunctionProtoType for.
3445 // To avoid an infinite recursion when importing, create the FunctionDecl
3446 // with a simplified function type.
3447 if (FromEPI.ExceptionSpec.SourceDecl ||
3448 FromEPI.ExceptionSpec.SourceTemplate ||
3449 FromEPI.ExceptionSpec.NoexceptExpr) {
3450 FunctionProtoType::ExtProtoInfo DefaultEPI;
3451 FromEPI = DefaultEPI;
3452 UsedDifferentProtoType = true;
3453 }
3454 FromTy = Importer.getFromContext().getFunctionType(
3455 FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3456 }
3457
3458 Error Err = Error::success();
3459 auto T = importChecked(Err, FromTy);
3460 auto TInfo = importChecked(Err, D->getTypeSourceInfo());
3461 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3462 auto ToEndLoc = importChecked(Err, D->getEndLoc());
3463 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
3464 auto TrailingRequiresClause =
3465 importChecked(Err, D->getTrailingRequiresClause());
3466 if (Err)
3467 return std::move(Err);
3468
3469 // Import the function parameters.
3470 SmallVector<ParmVarDecl *, 8> Parameters;
3471 for (auto P : D->parameters()) {
3472 if (Expected<ParmVarDecl *> ToPOrErr = import(P))
3473 Parameters.push_back(*ToPOrErr);
3474 else
3475 return ToPOrErr.takeError();
3476 }
3477
3478 // Create the imported function.
3479 FunctionDecl *ToFunction = nullptr;
3480 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3481 ExplicitSpecifier ESpec =
3482 importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3483 if (Err)
3484 return std::move(Err);
3485 auto ToInheritedConstructor = InheritedConstructor();
3486 if (FromConstructor->isInheritingConstructor()) {
3487 Expected<InheritedConstructor> ImportedInheritedCtor =
3488 import(FromConstructor->getInheritedConstructor());
3489 if (!ImportedInheritedCtor)
3490 return ImportedInheritedCtor.takeError();
3491 ToInheritedConstructor = *ImportedInheritedCtor;
3492 }
3493 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3494 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3495 ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->UsesFPIntrin(),
3496 D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
3497 ToInheritedConstructor, TrailingRequiresClause))
3498 return ToFunction;
3499 } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {
3500
3501 Error Err = Error::success();
3502 auto ToOperatorDelete = importChecked(
3503 Err, const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
3504 auto ToThisArg = importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3505 if (Err)
3506 return std::move(Err);
3507
3508 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3509 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3510 ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
3511 D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(),
3512 TrailingRequiresClause))
3513 return ToFunction;
3514
3515 CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction);
3516
3517 ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
3518 } else if (CXXConversionDecl *FromConversion =
3519 dyn_cast<CXXConversionDecl>(D)) {
3520 ExplicitSpecifier ESpec =
3521 importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3522 if (Err)
3523 return std::move(Err);
3524 if (GetImportedOrCreateDecl<CXXConversionDecl>(
3525 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3526 ToInnerLocStart, NameInfo, T, TInfo, D->UsesFPIntrin(),
3527 D->isInlineSpecified(), ESpec, D->getConstexprKind(),
3528 SourceLocation(), TrailingRequiresClause))
3529 return ToFunction;
3530 } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3531 if (GetImportedOrCreateDecl<CXXMethodDecl>(
3532 ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3533 ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3534 Method->UsesFPIntrin(), Method->isInlineSpecified(),
3535 D->getConstexprKind(), SourceLocation(), TrailingRequiresClause))
3536 return ToFunction;
3537 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3538 ExplicitSpecifier ESpec =
3539 importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3540 CXXConstructorDecl *Ctor =
3541 importChecked(Err, Guide->getCorrespondingConstructor());
3542 if (Err)
3543 return std::move(Err);
3544 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3545 ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, ESpec,
3546 NameInfo, T, TInfo, ToEndLoc, Ctor))
3547 return ToFunction;
3548 cast<CXXDeductionGuideDecl>(ToFunction)
3549 ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3550 } else {
3551 if (GetImportedOrCreateDecl(
3552 ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart,
3553 NameInfo, T, TInfo, D->getStorageClass(), D->UsesFPIntrin(),
3554 D->isInlineSpecified(), D->hasWrittenPrototype(),
3555 D->getConstexprKind(), TrailingRequiresClause))
3556 return ToFunction;
3557 }
3558
3559 // Connect the redecl chain.
3560 if (FoundByLookup) {
3561 auto *Recent = const_cast<FunctionDecl *>(
3562 FoundByLookup->getMostRecentDecl());
3563 ToFunction->setPreviousDecl(Recent);
3564 // FIXME Probably we should merge exception specifications. E.g. In the
3565 // "To" context the existing function may have exception specification with
3566 // noexcept-unevaluated, while the newly imported function may have an
3567 // evaluated noexcept. A call to adjustExceptionSpec() on the imported
3568 // decl and its redeclarations may be required.
3569 }
3570
3571 ToFunction->setQualifierInfo(ToQualifierLoc);
3572 ToFunction->setAccess(D->getAccess());
3573 ToFunction->setLexicalDeclContext(LexicalDC);
3574 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3575 ToFunction->setTrivial(D->isTrivial());
3576 ToFunction->setPure(D->isPure());
3577 ToFunction->setDefaulted(D->isDefaulted());
3578 ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
3579 ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
3580 ToFunction->setRangeEnd(ToEndLoc);
3581
3582 // Set the parameters.
3583 for (auto *Param : Parameters) {
3584 Param->setOwningFunction(ToFunction);
3585 ToFunction->addDeclInternal(Param);
3586 if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
3587 LT->update(Param, Importer.getToContext().getTranslationUnitDecl());
3588 }
3589 ToFunction->setParams(Parameters);
3590
3591 // We need to complete creation of FunctionProtoTypeLoc manually with setting
3592 // params it refers to.
3593 if (TInfo) {
3594 if (auto ProtoLoc =
3595 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
3596 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
3597 ProtoLoc.setParam(I, Parameters[I]);
3598 }
3599 }
3600
3601 // Import the describing template function, if any.
3602 if (FromFT) {
3603 auto ToFTOrErr = import(FromFT);
3604 if (!ToFTOrErr)
3605 return ToFTOrErr.takeError();
3606 }
3607
3608 // Import Ctor initializers.
3609 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3610 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3611 SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
3612 // Import first, then allocate memory and copy if there was no error.
3613 if (Error Err = ImportContainerChecked(
3614 FromConstructor->inits(), CtorInitializers))
3615 return std::move(Err);
3616 auto **Memory =
3617 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3618 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3619 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3620 ToCtor->setCtorInitializers(Memory);
3621 ToCtor->setNumCtorInitializers(NumInitializers);
3622 }
3623 }
3624
3625 if (D->doesThisDeclarationHaveABody()) {
3626 Error Err = ImportFunctionDeclBody(D, ToFunction);
3627
3628 if (Err)
3629 return std::move(Err);
3630 }
3631
3632 // Import and set the original type in case we used another type.
3633 if (UsedDifferentProtoType) {
3634 if (ExpectedType TyOrErr = import(D->getType()))
3635 ToFunction->setType(*TyOrErr);
3636 else
3637 return TyOrErr.takeError();
3638 }
3639
3640 // FIXME: Other bits to merge?
3641
3642 // If it is a template, import all related things.
3643 if (Error Err = ImportTemplateInformation(D, ToFunction))
3644 return std::move(Err);
3645
3646 addDeclToContexts(D, ToFunction);
3647
3648 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3649 if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
3650 FromCXXMethod))
3651 return std::move(Err);
3652
3653 // Import the rest of the chain. I.e. import all subsequent declarations.
3654 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3655 ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3656 if (!ToRedeclOrErr)
3657 return ToRedeclOrErr.takeError();
3658 }
3659
3660 return ToFunction;
3661 }
3662
VisitCXXMethodDecl(CXXMethodDecl * D)3663 ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3664 return VisitFunctionDecl(D);
3665 }
3666
VisitCXXConstructorDecl(CXXConstructorDecl * D)3667 ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3668 return VisitCXXMethodDecl(D);
3669 }
3670
VisitCXXDestructorDecl(CXXDestructorDecl * D)3671 ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3672 return VisitCXXMethodDecl(D);
3673 }
3674
VisitCXXConversionDecl(CXXConversionDecl * D)3675 ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3676 return VisitCXXMethodDecl(D);
3677 }
3678
3679 ExpectedDecl
VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl * D)3680 ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
3681 return VisitFunctionDecl(D);
3682 }
3683
VisitFieldDecl(FieldDecl * D)3684 ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3685 // Import the major distinguishing characteristics of a variable.
3686 DeclContext *DC, *LexicalDC;
3687 DeclarationName Name;
3688 SourceLocation Loc;
3689 NamedDecl *ToD;
3690 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3691 return std::move(Err);
3692 if (ToD)
3693 return ToD;
3694
3695 // Determine whether we've already imported this field.
3696 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3697 for (auto *FoundDecl : FoundDecls) {
3698 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3699 // For anonymous fields, match up by index.
3700 if (!Name &&
3701 ASTImporter::getFieldIndex(D) !=
3702 ASTImporter::getFieldIndex(FoundField))
3703 continue;
3704
3705 if (Importer.IsStructurallyEquivalent(D->getType(),
3706 FoundField->getType())) {
3707 Importer.MapImported(D, FoundField);
3708 // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
3709 // initializer of a FieldDecl might not had been instantiated in the
3710 // "To" context. However, the "From" context might instantiated that,
3711 // thus we have to merge that.
3712 if (Expr *FromInitializer = D->getInClassInitializer()) {
3713 // We don't have yet the initializer set.
3714 if (FoundField->hasInClassInitializer() &&
3715 !FoundField->getInClassInitializer()) {
3716 if (ExpectedExpr ToInitializerOrErr = import(FromInitializer))
3717 FoundField->setInClassInitializer(*ToInitializerOrErr);
3718 else {
3719 // We can't return error here,
3720 // since we already mapped D as imported.
3721 // FIXME: warning message?
3722 consumeError(ToInitializerOrErr.takeError());
3723 return FoundField;
3724 }
3725 }
3726 }
3727 return FoundField;
3728 }
3729
3730 // FIXME: Why is this case not handled with calling HandleNameConflict?
3731 Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3732 << Name << D->getType() << FoundField->getType();
3733 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3734 << FoundField->getType();
3735
3736 return make_error<ImportError>(ImportError::NameConflict);
3737 }
3738 }
3739
3740 Error Err = Error::success();
3741 auto ToType = importChecked(Err, D->getType());
3742 auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
3743 auto ToBitWidth = importChecked(Err, D->getBitWidth());
3744 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3745 auto ToInitializer = importChecked(Err, D->getInClassInitializer());
3746 if (Err)
3747 return std::move(Err);
3748 const Type *ToCapturedVLAType = nullptr;
3749 if (Error Err = Importer.importInto(
3750 ToCapturedVLAType, cast_or_null<Type>(D->getCapturedVLAType())))
3751 return std::move(Err);
3752
3753 FieldDecl *ToField;
3754 if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
3755 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3756 ToType, ToTInfo, ToBitWidth, D->isMutable(),
3757 D->getInClassInitStyle()))
3758 return ToField;
3759
3760 ToField->setAccess(D->getAccess());
3761 ToField->setLexicalDeclContext(LexicalDC);
3762 if (ToInitializer)
3763 ToField->setInClassInitializer(ToInitializer);
3764 ToField->setImplicit(D->isImplicit());
3765 if (ToCapturedVLAType)
3766 ToField->setCapturedVLAType(cast<VariableArrayType>(ToCapturedVLAType));
3767 LexicalDC->addDeclInternal(ToField);
3768 return ToField;
3769 }
3770
VisitIndirectFieldDecl(IndirectFieldDecl * D)3771 ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3772 // Import the major distinguishing characteristics of a variable.
3773 DeclContext *DC, *LexicalDC;
3774 DeclarationName Name;
3775 SourceLocation Loc;
3776 NamedDecl *ToD;
3777 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3778 return std::move(Err);
3779 if (ToD)
3780 return ToD;
3781
3782 // Determine whether we've already imported this field.
3783 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3784 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3785 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3786 // For anonymous indirect fields, match up by index.
3787 if (!Name &&
3788 ASTImporter::getFieldIndex(D) !=
3789 ASTImporter::getFieldIndex(FoundField))
3790 continue;
3791
3792 if (Importer.IsStructurallyEquivalent(D->getType(),
3793 FoundField->getType(),
3794 !Name.isEmpty())) {
3795 Importer.MapImported(D, FoundField);
3796 return FoundField;
3797 }
3798
3799 // If there are more anonymous fields to check, continue.
3800 if (!Name && I < N-1)
3801 continue;
3802
3803 // FIXME: Why is this case not handled with calling HandleNameConflict?
3804 Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3805 << Name << D->getType() << FoundField->getType();
3806 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3807 << FoundField->getType();
3808
3809 return make_error<ImportError>(ImportError::NameConflict);
3810 }
3811 }
3812
3813 // Import the type.
3814 auto TypeOrErr = import(D->getType());
3815 if (!TypeOrErr)
3816 return TypeOrErr.takeError();
3817
3818 auto **NamedChain =
3819 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
3820
3821 unsigned i = 0;
3822 for (auto *PI : D->chain())
3823 if (Expected<NamedDecl *> ToD = import(PI))
3824 NamedChain[i++] = *ToD;
3825 else
3826 return ToD.takeError();
3827
3828 llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
3829 IndirectFieldDecl *ToIndirectField;
3830 if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
3831 Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3832 // FIXME here we leak `NamedChain` which is allocated before
3833 return ToIndirectField;
3834
3835 ToIndirectField->setAccess(D->getAccess());
3836 ToIndirectField->setLexicalDeclContext(LexicalDC);
3837 LexicalDC->addDeclInternal(ToIndirectField);
3838 return ToIndirectField;
3839 }
3840
3841 /// Used as return type of getFriendCountAndPosition.
3842 struct FriendCountAndPosition {
3843 /// Number of similar looking friends.
3844 unsigned int TotalCount;
3845 /// Index of the specific FriendDecl.
3846 unsigned int IndexOfDecl;
3847 };
3848
3849 template <class T>
getFriendCountAndPosition(const FriendDecl * FD,llvm::function_ref<T (const FriendDecl *)> GetCanTypeOrDecl)3850 static FriendCountAndPosition getFriendCountAndPosition(
3851 const FriendDecl *FD,
3852 llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
3853 unsigned int FriendCount = 0;
3854 llvm::Optional<unsigned int> FriendPosition;
3855 const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
3856
3857 T TypeOrDecl = GetCanTypeOrDecl(FD);
3858
3859 for (const FriendDecl *FoundFriend : RD->friends()) {
3860 if (FoundFriend == FD) {
3861 FriendPosition = FriendCount;
3862 ++FriendCount;
3863 } else if (!FoundFriend->getFriendDecl() == !FD->getFriendDecl() &&
3864 GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
3865 ++FriendCount;
3866 }
3867 }
3868
3869 assert(FriendPosition && "Friend decl not found in own parent.");
3870
3871 return {FriendCount, *FriendPosition};
3872 }
3873
getFriendCountAndPosition(const FriendDecl * FD)3874 static FriendCountAndPosition getFriendCountAndPosition(const FriendDecl *FD) {
3875 if (FD->getFriendType())
3876 return getFriendCountAndPosition<QualType>(FD, [](const FriendDecl *F) {
3877 if (TypeSourceInfo *TSI = F->getFriendType())
3878 return TSI->getType().getCanonicalType();
3879 llvm_unreachable("Wrong friend object type.");
3880 });
3881 else
3882 return getFriendCountAndPosition<Decl *>(FD, [](const FriendDecl *F) {
3883 if (Decl *D = F->getFriendDecl())
3884 return D->getCanonicalDecl();
3885 llvm_unreachable("Wrong friend object type.");
3886 });
3887 }
3888
VisitFriendDecl(FriendDecl * D)3889 ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3890 // Import the major distinguishing characteristics of a declaration.
3891 DeclContext *DC, *LexicalDC;
3892 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
3893 return std::move(Err);
3894
3895 // Determine whether we've already imported this decl.
3896 // FriendDecl is not a NamedDecl so we cannot use lookup.
3897 // We try to maintain order and count of redundant friend declarations.
3898 const auto *RD = cast<CXXRecordDecl>(DC);
3899 FriendDecl *ImportedFriend = RD->getFirstFriend();
3900 SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
3901
3902 while (ImportedFriend) {
3903 bool Match = false;
3904 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3905 Match =
3906 IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
3907 /*Complain=*/false);
3908 } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3909 Match = Importer.IsStructurallyEquivalent(
3910 D->getFriendType()->getType(),
3911 ImportedFriend->getFriendType()->getType(), /*Complain=*/false);
3912 }
3913 if (Match)
3914 ImportedEquivalentFriends.push_back(ImportedFriend);
3915
3916 ImportedFriend = ImportedFriend->getNextFriend();
3917 }
3918 FriendCountAndPosition CountAndPosition = getFriendCountAndPosition(D);
3919
3920 assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
3921 "Class with non-matching friends is imported, ODR check wrong?");
3922 if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
3923 return Importer.MapImported(
3924 D, ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
3925
3926 // Not found. Create it.
3927 // The declarations will be put into order later by ImportDeclContext.
3928 FriendDecl::FriendUnion ToFU;
3929 if (NamedDecl *FriendD = D->getFriendDecl()) {
3930 NamedDecl *ToFriendD;
3931 if (Error Err = importInto(ToFriendD, FriendD))
3932 return std::move(Err);
3933
3934 if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
3935 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3936 ToFriendD->setObjectOfFriendDecl(false);
3937
3938 ToFU = ToFriendD;
3939 } else { // The friend is a type, not a decl.
3940 if (auto TSIOrErr = import(D->getFriendType()))
3941 ToFU = *TSIOrErr;
3942 else
3943 return TSIOrErr.takeError();
3944 }
3945
3946 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3947 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3948 for (unsigned I = 0; I < D->NumTPLists; I++) {
3949 if (auto ListOrErr = import(FromTPLists[I]))
3950 ToTPLists[I] = *ListOrErr;
3951 else
3952 return ListOrErr.takeError();
3953 }
3954
3955 auto LocationOrErr = import(D->getLocation());
3956 if (!LocationOrErr)
3957 return LocationOrErr.takeError();
3958 auto FriendLocOrErr = import(D->getFriendLoc());
3959 if (!FriendLocOrErr)
3960 return FriendLocOrErr.takeError();
3961
3962 FriendDecl *FrD;
3963 if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3964 *LocationOrErr, ToFU,
3965 *FriendLocOrErr, ToTPLists))
3966 return FrD;
3967
3968 FrD->setAccess(D->getAccess());
3969 FrD->setLexicalDeclContext(LexicalDC);
3970 LexicalDC->addDeclInternal(FrD);
3971 return FrD;
3972 }
3973
VisitObjCIvarDecl(ObjCIvarDecl * D)3974 ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3975 // Import the major distinguishing characteristics of an ivar.
3976 DeclContext *DC, *LexicalDC;
3977 DeclarationName Name;
3978 SourceLocation Loc;
3979 NamedDecl *ToD;
3980 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3981 return std::move(Err);
3982 if (ToD)
3983 return ToD;
3984
3985 // Determine whether we've already imported this ivar
3986 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3987 for (auto *FoundDecl : FoundDecls) {
3988 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3989 if (Importer.IsStructurallyEquivalent(D->getType(),
3990 FoundIvar->getType())) {
3991 Importer.MapImported(D, FoundIvar);
3992 return FoundIvar;
3993 }
3994
3995 Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
3996 << Name << D->getType() << FoundIvar->getType();
3997 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3998 << FoundIvar->getType();
3999
4000 return make_error<ImportError>(ImportError::NameConflict);
4001 }
4002 }
4003
4004 Error Err = Error::success();
4005 auto ToType = importChecked(Err, D->getType());
4006 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4007 auto ToBitWidth = importChecked(Err, D->getBitWidth());
4008 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4009 if (Err)
4010 return std::move(Err);
4011
4012 ObjCIvarDecl *ToIvar;
4013 if (GetImportedOrCreateDecl(
4014 ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
4015 ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
4016 ToType, ToTypeSourceInfo,
4017 D->getAccessControl(),ToBitWidth, D->getSynthesize()))
4018 return ToIvar;
4019
4020 ToIvar->setLexicalDeclContext(LexicalDC);
4021 LexicalDC->addDeclInternal(ToIvar);
4022 return ToIvar;
4023 }
4024
VisitVarDecl(VarDecl * D)4025 ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
4026
4027 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
4028 auto RedeclIt = Redecls.begin();
4029 // Import the first part of the decl chain. I.e. import all previous
4030 // declarations starting from the canonical decl.
4031 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4032 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4033 if (!RedeclOrErr)
4034 return RedeclOrErr.takeError();
4035 }
4036 assert(*RedeclIt == D);
4037
4038 // Import the major distinguishing characteristics of a variable.
4039 DeclContext *DC, *LexicalDC;
4040 DeclarationName Name;
4041 SourceLocation Loc;
4042 NamedDecl *ToD;
4043 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4044 return std::move(Err);
4045 if (ToD)
4046 return ToD;
4047
4048 // Try to find a variable in our own ("to") context with the same name and
4049 // in the same context as the variable we're importing.
4050 VarDecl *FoundByLookup = nullptr;
4051 if (D->isFileVarDecl()) {
4052 SmallVector<NamedDecl *, 4> ConflictingDecls;
4053 unsigned IDNS = Decl::IDNS_Ordinary;
4054 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4055 for (auto *FoundDecl : FoundDecls) {
4056 if (!FoundDecl->isInIdentifierNamespace(IDNS))
4057 continue;
4058
4059 if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
4060 if (!hasSameVisibilityContextAndLinkage(FoundVar, D))
4061 continue;
4062 if (Importer.IsStructurallyEquivalent(D->getType(),
4063 FoundVar->getType())) {
4064
4065 // The VarDecl in the "From" context has a definition, but in the
4066 // "To" context we already have a definition.
4067 VarDecl *FoundDef = FoundVar->getDefinition();
4068 if (D->isThisDeclarationADefinition() && FoundDef)
4069 // FIXME Check for ODR error if the two definitions have
4070 // different initializers?
4071 return Importer.MapImported(D, FoundDef);
4072
4073 // The VarDecl in the "From" context has an initializer, but in the
4074 // "To" context we already have an initializer.
4075 const VarDecl *FoundDInit = nullptr;
4076 if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
4077 // FIXME Diagnose ODR error if the two initializers are different?
4078 return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit));
4079
4080 FoundByLookup = FoundVar;
4081 break;
4082 }
4083
4084 const ArrayType *FoundArray
4085 = Importer.getToContext().getAsArrayType(FoundVar->getType());
4086 const ArrayType *TArray
4087 = Importer.getToContext().getAsArrayType(D->getType());
4088 if (FoundArray && TArray) {
4089 if (isa<IncompleteArrayType>(FoundArray) &&
4090 isa<ConstantArrayType>(TArray)) {
4091 // Import the type.
4092 if (auto TyOrErr = import(D->getType()))
4093 FoundVar->setType(*TyOrErr);
4094 else
4095 return TyOrErr.takeError();
4096
4097 FoundByLookup = FoundVar;
4098 break;
4099 } else if (isa<IncompleteArrayType>(TArray) &&
4100 isa<ConstantArrayType>(FoundArray)) {
4101 FoundByLookup = FoundVar;
4102 break;
4103 }
4104 }
4105
4106 Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
4107 << Name << D->getType() << FoundVar->getType();
4108 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
4109 << FoundVar->getType();
4110 ConflictingDecls.push_back(FoundDecl);
4111 }
4112 }
4113
4114 if (!ConflictingDecls.empty()) {
4115 ExpectedName NameOrErr = Importer.HandleNameConflict(
4116 Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
4117 if (NameOrErr)
4118 Name = NameOrErr.get();
4119 else
4120 return NameOrErr.takeError();
4121 }
4122 }
4123
4124 Error Err = Error::success();
4125 auto ToType = importChecked(Err, D->getType());
4126 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4127 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4128 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4129 if (Err)
4130 return std::move(Err);
4131
4132 VarDecl *ToVar;
4133 if (auto *FromDecomp = dyn_cast<DecompositionDecl>(D)) {
4134 SmallVector<BindingDecl *> Bindings(FromDecomp->bindings().size());
4135 if (Error Err =
4136 ImportArrayChecked(FromDecomp->bindings(), Bindings.begin()))
4137 return std::move(Err);
4138 DecompositionDecl *ToDecomp;
4139 if (GetImportedOrCreateDecl(
4140 ToDecomp, FromDecomp, Importer.getToContext(), DC, ToInnerLocStart,
4141 Loc, ToType, ToTypeSourceInfo, D->getStorageClass(), Bindings))
4142 return ToDecomp;
4143 ToVar = ToDecomp;
4144 } else {
4145 // Create the imported variable.
4146 if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
4147 ToInnerLocStart, Loc,
4148 Name.getAsIdentifierInfo(), ToType,
4149 ToTypeSourceInfo, D->getStorageClass()))
4150 return ToVar;
4151 }
4152
4153 ToVar->setTSCSpec(D->getTSCSpec());
4154 ToVar->setQualifierInfo(ToQualifierLoc);
4155 ToVar->setAccess(D->getAccess());
4156 ToVar->setLexicalDeclContext(LexicalDC);
4157
4158 if (FoundByLookup) {
4159 auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4160 ToVar->setPreviousDecl(Recent);
4161 }
4162
4163 // Import the described template, if any.
4164 if (D->getDescribedVarTemplate()) {
4165 auto ToVTOrErr = import(D->getDescribedVarTemplate());
4166 if (!ToVTOrErr)
4167 return ToVTOrErr.takeError();
4168 }
4169
4170 if (Error Err = ImportInitializer(D, ToVar))
4171 return std::move(Err);
4172
4173 if (D->isConstexpr())
4174 ToVar->setConstexpr(true);
4175
4176 addDeclToContexts(D, ToVar);
4177
4178 // Import the rest of the chain. I.e. import all subsequent declarations.
4179 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4180 ExpectedDecl RedeclOrErr = import(*RedeclIt);
4181 if (!RedeclOrErr)
4182 return RedeclOrErr.takeError();
4183 }
4184
4185 return ToVar;
4186 }
4187
VisitImplicitParamDecl(ImplicitParamDecl * D)4188 ExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
4189 // Parameters are created in the translation unit's context, then moved
4190 // into the function declaration's context afterward.
4191 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4192
4193 Error Err = Error::success();
4194 auto ToDeclName = importChecked(Err, D->getDeclName());
4195 auto ToLocation = importChecked(Err, D->getLocation());
4196 auto ToType = importChecked(Err, D->getType());
4197 if (Err)
4198 return std::move(Err);
4199
4200 // Create the imported parameter.
4201 ImplicitParamDecl *ToParm = nullptr;
4202 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4203 ToLocation, ToDeclName.getAsIdentifierInfo(),
4204 ToType, D->getParameterKind()))
4205 return ToParm;
4206 return ToParm;
4207 }
4208
ImportDefaultArgOfParmVarDecl(const ParmVarDecl * FromParam,ParmVarDecl * ToParam)4209 Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
4210 const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
4211 ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4212 ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4213
4214 if (FromParam->hasUninstantiatedDefaultArg()) {
4215 if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4216 ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4217 else
4218 return ToDefArgOrErr.takeError();
4219 } else if (FromParam->hasUnparsedDefaultArg()) {
4220 ToParam->setUnparsedDefaultArg();
4221 } else if (FromParam->hasDefaultArg()) {
4222 if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4223 ToParam->setDefaultArg(*ToDefArgOrErr);
4224 else
4225 return ToDefArgOrErr.takeError();
4226 }
4227
4228 return Error::success();
4229 }
4230
4231 Expected<InheritedConstructor>
ImportInheritedConstructor(const InheritedConstructor & From)4232 ASTNodeImporter::ImportInheritedConstructor(const InheritedConstructor &From) {
4233 Error Err = Error::success();
4234 CXXConstructorDecl *ToBaseCtor = importChecked(Err, From.getConstructor());
4235 ConstructorUsingShadowDecl *ToShadow =
4236 importChecked(Err, From.getShadowDecl());
4237 if (Err)
4238 return std::move(Err);
4239 return InheritedConstructor(ToShadow, ToBaseCtor);
4240 }
4241
VisitParmVarDecl(ParmVarDecl * D)4242 ExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
4243 // Parameters are created in the translation unit's context, then moved
4244 // into the function declaration's context afterward.
4245 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4246
4247 Error Err = Error::success();
4248 auto ToDeclName = importChecked(Err, D->getDeclName());
4249 auto ToLocation = importChecked(Err, D->getLocation());
4250 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4251 auto ToType = importChecked(Err, D->getType());
4252 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4253 if (Err)
4254 return std::move(Err);
4255
4256 ParmVarDecl *ToParm;
4257 if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4258 ToInnerLocStart, ToLocation,
4259 ToDeclName.getAsIdentifierInfo(), ToType,
4260 ToTypeSourceInfo, D->getStorageClass(),
4261 /*DefaultArg*/ nullptr))
4262 return ToParm;
4263
4264 // Set the default argument. It should be no problem if it was already done.
4265 // Do not import the default expression before GetImportedOrCreateDecl call
4266 // to avoid possible infinite import loop because circular dependency.
4267 if (Error Err = ImportDefaultArgOfParmVarDecl(D, ToParm))
4268 return std::move(Err);
4269
4270 if (D->isObjCMethodParameter()) {
4271 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4272 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4273 } else {
4274 ToParm->setScopeInfo(D->getFunctionScopeDepth(),
4275 D->getFunctionScopeIndex());
4276 }
4277
4278 return ToParm;
4279 }
4280
VisitObjCMethodDecl(ObjCMethodDecl * D)4281 ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
4282 // Import the major distinguishing characteristics of a method.
4283 DeclContext *DC, *LexicalDC;
4284 DeclarationName Name;
4285 SourceLocation Loc;
4286 NamedDecl *ToD;
4287 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4288 return std::move(Err);
4289 if (ToD)
4290 return ToD;
4291
4292 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4293 for (auto *FoundDecl : FoundDecls) {
4294 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4295 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4296 continue;
4297
4298 // Check return types.
4299 if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
4300 FoundMethod->getReturnType())) {
4301 Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4302 << D->isInstanceMethod() << Name << D->getReturnType()
4303 << FoundMethod->getReturnType();
4304 Importer.ToDiag(FoundMethod->getLocation(),
4305 diag::note_odr_objc_method_here)
4306 << D->isInstanceMethod() << Name;
4307
4308 return make_error<ImportError>(ImportError::NameConflict);
4309 }
4310
4311 // Check the number of parameters.
4312 if (D->param_size() != FoundMethod->param_size()) {
4313 Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4314 << D->isInstanceMethod() << Name
4315 << D->param_size() << FoundMethod->param_size();
4316 Importer.ToDiag(FoundMethod->getLocation(),
4317 diag::note_odr_objc_method_here)
4318 << D->isInstanceMethod() << Name;
4319
4320 return make_error<ImportError>(ImportError::NameConflict);
4321 }
4322
4323 // Check parameter types.
4324 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4325 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4326 P != PEnd; ++P, ++FoundP) {
4327 if (!Importer.IsStructurallyEquivalent((*P)->getType(),
4328 (*FoundP)->getType())) {
4329 Importer.FromDiag((*P)->getLocation(),
4330 diag::warn_odr_objc_method_param_type_inconsistent)
4331 << D->isInstanceMethod() << Name
4332 << (*P)->getType() << (*FoundP)->getType();
4333 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4334 << (*FoundP)->getType();
4335
4336 return make_error<ImportError>(ImportError::NameConflict);
4337 }
4338 }
4339
4340 // Check variadic/non-variadic.
4341 // Check the number of parameters.
4342 if (D->isVariadic() != FoundMethod->isVariadic()) {
4343 Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4344 << D->isInstanceMethod() << Name;
4345 Importer.ToDiag(FoundMethod->getLocation(),
4346 diag::note_odr_objc_method_here)
4347 << D->isInstanceMethod() << Name;
4348
4349 return make_error<ImportError>(ImportError::NameConflict);
4350 }
4351
4352 // FIXME: Any other bits we need to merge?
4353 return Importer.MapImported(D, FoundMethod);
4354 }
4355 }
4356
4357 Error Err = Error::success();
4358 auto ToEndLoc = importChecked(Err, D->getEndLoc());
4359 auto ToReturnType = importChecked(Err, D->getReturnType());
4360 auto ToReturnTypeSourceInfo =
4361 importChecked(Err, D->getReturnTypeSourceInfo());
4362 if (Err)
4363 return std::move(Err);
4364
4365 ObjCMethodDecl *ToMethod;
4366 if (GetImportedOrCreateDecl(
4367 ToMethod, D, Importer.getToContext(), Loc, ToEndLoc,
4368 Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4369 D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(),
4370 D->isSynthesizedAccessorStub(), D->isImplicit(), D->isDefined(),
4371 D->getImplementationControl(), D->hasRelatedResultType()))
4372 return ToMethod;
4373
4374 // FIXME: When we decide to merge method definitions, we'll need to
4375 // deal with implicit parameters.
4376
4377 // Import the parameters
4378 SmallVector<ParmVarDecl *, 5> ToParams;
4379 for (auto *FromP : D->parameters()) {
4380 if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
4381 ToParams.push_back(*ToPOrErr);
4382 else
4383 return ToPOrErr.takeError();
4384 }
4385
4386 // Set the parameters.
4387 for (auto *ToParam : ToParams) {
4388 ToParam->setOwningFunction(ToMethod);
4389 ToMethod->addDeclInternal(ToParam);
4390 }
4391
4392 SmallVector<SourceLocation, 12> FromSelLocs;
4393 D->getSelectorLocs(FromSelLocs);
4394 SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
4395 if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs))
4396 return std::move(Err);
4397
4398 ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs);
4399
4400 ToMethod->setLexicalDeclContext(LexicalDC);
4401 LexicalDC->addDeclInternal(ToMethod);
4402
4403 // Implicit params are declared when Sema encounters the definition but this
4404 // never happens when the method is imported. Manually declare the implicit
4405 // params now that the MethodDecl knows its class interface.
4406 if (D->getSelfDecl())
4407 ToMethod->createImplicitParams(Importer.getToContext(),
4408 ToMethod->getClassInterface());
4409
4410 return ToMethod;
4411 }
4412
VisitObjCTypeParamDecl(ObjCTypeParamDecl * D)4413 ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4414 // Import the major distinguishing characteristics of a category.
4415 DeclContext *DC, *LexicalDC;
4416 DeclarationName Name;
4417 SourceLocation Loc;
4418 NamedDecl *ToD;
4419 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4420 return std::move(Err);
4421 if (ToD)
4422 return ToD;
4423
4424 Error Err = Error::success();
4425 auto ToVarianceLoc = importChecked(Err, D->getVarianceLoc());
4426 auto ToLocation = importChecked(Err, D->getLocation());
4427 auto ToColonLoc = importChecked(Err, D->getColonLoc());
4428 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4429 if (Err)
4430 return std::move(Err);
4431
4432 ObjCTypeParamDecl *Result;
4433 if (GetImportedOrCreateDecl(
4434 Result, D, Importer.getToContext(), DC, D->getVariance(),
4435 ToVarianceLoc, D->getIndex(),
4436 ToLocation, Name.getAsIdentifierInfo(),
4437 ToColonLoc, ToTypeSourceInfo))
4438 return Result;
4439
4440 Result->setLexicalDeclContext(LexicalDC);
4441 return Result;
4442 }
4443
VisitObjCCategoryDecl(ObjCCategoryDecl * D)4444 ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4445 // Import the major distinguishing characteristics of a category.
4446 DeclContext *DC, *LexicalDC;
4447 DeclarationName Name;
4448 SourceLocation Loc;
4449 NamedDecl *ToD;
4450 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4451 return std::move(Err);
4452 if (ToD)
4453 return ToD;
4454
4455 ObjCInterfaceDecl *ToInterface;
4456 if (Error Err = importInto(ToInterface, D->getClassInterface()))
4457 return std::move(Err);
4458
4459 // Determine if we've already encountered this category.
4460 ObjCCategoryDecl *MergeWithCategory
4461 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4462 ObjCCategoryDecl *ToCategory = MergeWithCategory;
4463 if (!ToCategory) {
4464
4465 Error Err = Error::success();
4466 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4467 auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4468 auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
4469 auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
4470 if (Err)
4471 return std::move(Err);
4472
4473 if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
4474 ToAtStartLoc, Loc,
4475 ToCategoryNameLoc,
4476 Name.getAsIdentifierInfo(), ToInterface,
4477 /*TypeParamList=*/nullptr,
4478 ToIvarLBraceLoc,
4479 ToIvarRBraceLoc))
4480 return ToCategory;
4481
4482 ToCategory->setLexicalDeclContext(LexicalDC);
4483 LexicalDC->addDeclInternal(ToCategory);
4484 // Import the type parameter list after MapImported, to avoid
4485 // loops when bringing in their DeclContext.
4486 if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList()))
4487 ToCategory->setTypeParamList(*PListOrErr);
4488 else
4489 return PListOrErr.takeError();
4490
4491 // Import protocols
4492 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4493 SmallVector<SourceLocation, 4> ProtocolLocs;
4494 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4495 = D->protocol_loc_begin();
4496 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4497 FromProtoEnd = D->protocol_end();
4498 FromProto != FromProtoEnd;
4499 ++FromProto, ++FromProtoLoc) {
4500 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4501 Protocols.push_back(*ToProtoOrErr);
4502 else
4503 return ToProtoOrErr.takeError();
4504
4505 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4506 ProtocolLocs.push_back(*ToProtoLocOrErr);
4507 else
4508 return ToProtoLocOrErr.takeError();
4509 }
4510
4511 // FIXME: If we're merging, make sure that the protocol list is the same.
4512 ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4513 ProtocolLocs.data(), Importer.getToContext());
4514
4515 } else {
4516 Importer.MapImported(D, ToCategory);
4517 }
4518
4519 // Import all of the members of this category.
4520 if (Error Err = ImportDeclContext(D))
4521 return std::move(Err);
4522
4523 // If we have an implementation, import it as well.
4524 if (D->getImplementation()) {
4525 if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
4526 import(D->getImplementation()))
4527 ToCategory->setImplementation(*ToImplOrErr);
4528 else
4529 return ToImplOrErr.takeError();
4530 }
4531
4532 return ToCategory;
4533 }
4534
ImportDefinition(ObjCProtocolDecl * From,ObjCProtocolDecl * To,ImportDefinitionKind Kind)4535 Error ASTNodeImporter::ImportDefinition(
4536 ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
4537 if (To->getDefinition()) {
4538 if (shouldForceImportDeclContext(Kind))
4539 if (Error Err = ImportDeclContext(From))
4540 return Err;
4541 return Error::success();
4542 }
4543
4544 // Start the protocol definition
4545 To->startDefinition();
4546
4547 // Import protocols
4548 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4549 SmallVector<SourceLocation, 4> ProtocolLocs;
4550 ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
4551 From->protocol_loc_begin();
4552 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4553 FromProtoEnd = From->protocol_end();
4554 FromProto != FromProtoEnd;
4555 ++FromProto, ++FromProtoLoc) {
4556 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4557 Protocols.push_back(*ToProtoOrErr);
4558 else
4559 return ToProtoOrErr.takeError();
4560
4561 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4562 ProtocolLocs.push_back(*ToProtoLocOrErr);
4563 else
4564 return ToProtoLocOrErr.takeError();
4565
4566 }
4567
4568 // FIXME: If we're merging, make sure that the protocol list is the same.
4569 To->setProtocolList(Protocols.data(), Protocols.size(),
4570 ProtocolLocs.data(), Importer.getToContext());
4571
4572 if (shouldForceImportDeclContext(Kind)) {
4573 // Import all of the members of this protocol.
4574 if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
4575 return Err;
4576 }
4577 return Error::success();
4578 }
4579
VisitObjCProtocolDecl(ObjCProtocolDecl * D)4580 ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4581 // If this protocol has a definition in the translation unit we're coming
4582 // from, but this particular declaration is not that definition, import the
4583 // definition and map to that.
4584 ObjCProtocolDecl *Definition = D->getDefinition();
4585 if (Definition && Definition != D) {
4586 if (ExpectedDecl ImportedDefOrErr = import(Definition))
4587 return Importer.MapImported(D, *ImportedDefOrErr);
4588 else
4589 return ImportedDefOrErr.takeError();
4590 }
4591
4592 // Import the major distinguishing characteristics of a protocol.
4593 DeclContext *DC, *LexicalDC;
4594 DeclarationName Name;
4595 SourceLocation Loc;
4596 NamedDecl *ToD;
4597 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4598 return std::move(Err);
4599 if (ToD)
4600 return ToD;
4601
4602 ObjCProtocolDecl *MergeWithProtocol = nullptr;
4603 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4604 for (auto *FoundDecl : FoundDecls) {
4605 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4606 continue;
4607
4608 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4609 break;
4610 }
4611
4612 ObjCProtocolDecl *ToProto = MergeWithProtocol;
4613 if (!ToProto) {
4614 auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
4615 if (!ToAtBeginLocOrErr)
4616 return ToAtBeginLocOrErr.takeError();
4617
4618 if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
4619 Name.getAsIdentifierInfo(), Loc,
4620 *ToAtBeginLocOrErr,
4621 /*PrevDecl=*/nullptr))
4622 return ToProto;
4623 ToProto->setLexicalDeclContext(LexicalDC);
4624 LexicalDC->addDeclInternal(ToProto);
4625 }
4626
4627 Importer.MapImported(D, ToProto);
4628
4629 if (D->isThisDeclarationADefinition())
4630 if (Error Err = ImportDefinition(D, ToProto))
4631 return std::move(Err);
4632
4633 return ToProto;
4634 }
4635
VisitLinkageSpecDecl(LinkageSpecDecl * D)4636 ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4637 DeclContext *DC, *LexicalDC;
4638 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4639 return std::move(Err);
4640
4641 ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
4642 if (!ExternLocOrErr)
4643 return ExternLocOrErr.takeError();
4644
4645 ExpectedSLoc LangLocOrErr = import(D->getLocation());
4646 if (!LangLocOrErr)
4647 return LangLocOrErr.takeError();
4648
4649 bool HasBraces = D->hasBraces();
4650
4651 LinkageSpecDecl *ToLinkageSpec;
4652 if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
4653 *ExternLocOrErr, *LangLocOrErr,
4654 D->getLanguage(), HasBraces))
4655 return ToLinkageSpec;
4656
4657 if (HasBraces) {
4658 ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
4659 if (!RBraceLocOrErr)
4660 return RBraceLocOrErr.takeError();
4661 ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
4662 }
4663
4664 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4665 LexicalDC->addDeclInternal(ToLinkageSpec);
4666
4667 return ToLinkageSpec;
4668 }
4669
ImportUsingShadowDecls(BaseUsingDecl * D,BaseUsingDecl * ToSI)4670 ExpectedDecl ASTNodeImporter::ImportUsingShadowDecls(BaseUsingDecl *D,
4671 BaseUsingDecl *ToSI) {
4672 for (UsingShadowDecl *FromShadow : D->shadows()) {
4673 if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
4674 ToSI->addShadowDecl(*ToShadowOrErr);
4675 else
4676 // FIXME: We return error here but the definition is already created
4677 // and available with lookups. How to fix this?..
4678 return ToShadowOrErr.takeError();
4679 }
4680 return ToSI;
4681 }
4682
VisitUsingDecl(UsingDecl * D)4683 ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
4684 DeclContext *DC, *LexicalDC;
4685 DeclarationName Name;
4686 SourceLocation Loc;
4687 NamedDecl *ToD = nullptr;
4688 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4689 return std::move(Err);
4690 if (ToD)
4691 return ToD;
4692
4693 Error Err = Error::success();
4694 auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4695 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4696 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4697 if (Err)
4698 return std::move(Err);
4699
4700 DeclarationNameInfo NameInfo(Name, ToLoc);
4701 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4702 return std::move(Err);
4703
4704 UsingDecl *ToUsing;
4705 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4706 ToUsingLoc, ToQualifierLoc, NameInfo,
4707 D->hasTypename()))
4708 return ToUsing;
4709
4710 ToUsing->setLexicalDeclContext(LexicalDC);
4711 LexicalDC->addDeclInternal(ToUsing);
4712
4713 if (NamedDecl *FromPattern =
4714 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
4715 if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
4716 Importer.getToContext().setInstantiatedFromUsingDecl(
4717 ToUsing, *ToPatternOrErr);
4718 else
4719 return ToPatternOrErr.takeError();
4720 }
4721
4722 return ImportUsingShadowDecls(D, ToUsing);
4723 }
4724
VisitUsingEnumDecl(UsingEnumDecl * D)4725 ExpectedDecl ASTNodeImporter::VisitUsingEnumDecl(UsingEnumDecl *D) {
4726 DeclContext *DC, *LexicalDC;
4727 DeclarationName Name;
4728 SourceLocation Loc;
4729 NamedDecl *ToD = nullptr;
4730 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4731 return std::move(Err);
4732 if (ToD)
4733 return ToD;
4734
4735 Error Err = Error::success();
4736 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4737 auto ToEnumLoc = importChecked(Err, D->getEnumLoc());
4738 auto ToEnumDecl = importChecked(Err, D->getEnumDecl());
4739 if (Err)
4740 return std::move(Err);
4741
4742 UsingEnumDecl *ToUsingEnum;
4743 if (GetImportedOrCreateDecl(ToUsingEnum, D, Importer.getToContext(), DC,
4744 ToUsingLoc, ToEnumLoc, Loc, ToEnumDecl))
4745 return ToUsingEnum;
4746
4747 ToUsingEnum->setLexicalDeclContext(LexicalDC);
4748 LexicalDC->addDeclInternal(ToUsingEnum);
4749
4750 if (UsingEnumDecl *FromPattern =
4751 Importer.getFromContext().getInstantiatedFromUsingEnumDecl(D)) {
4752 if (Expected<UsingEnumDecl *> ToPatternOrErr = import(FromPattern))
4753 Importer.getToContext().setInstantiatedFromUsingEnumDecl(ToUsingEnum,
4754 *ToPatternOrErr);
4755 else
4756 return ToPatternOrErr.takeError();
4757 }
4758
4759 return ImportUsingShadowDecls(D, ToUsingEnum);
4760 }
4761
VisitUsingShadowDecl(UsingShadowDecl * D)4762 ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
4763 DeclContext *DC, *LexicalDC;
4764 DeclarationName Name;
4765 SourceLocation Loc;
4766 NamedDecl *ToD = nullptr;
4767 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4768 return std::move(Err);
4769 if (ToD)
4770 return ToD;
4771
4772 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(D->getIntroducer());
4773 if (!ToIntroducerOrErr)
4774 return ToIntroducerOrErr.takeError();
4775
4776 Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
4777 if (!ToTargetOrErr)
4778 return ToTargetOrErr.takeError();
4779
4780 UsingShadowDecl *ToShadow;
4781 if (auto *FromConstructorUsingShadow =
4782 dyn_cast<ConstructorUsingShadowDecl>(D)) {
4783 Error Err = Error::success();
4784 ConstructorUsingShadowDecl *Nominated = importChecked(
4785 Err, FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
4786 if (Err)
4787 return std::move(Err);
4788 // The 'Target' parameter of ConstructorUsingShadowDecl constructor
4789 // is really the "NominatedBaseClassShadowDecl" value if it exists
4790 // (see code of ConstructorUsingShadowDecl::ConstructorUsingShadowDecl).
4791 // We should pass the NominatedBaseClassShadowDecl to it (if non-null) to
4792 // get the correct values.
4793 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
4794 ToShadow, D, Importer.getToContext(), DC, Loc,
4795 cast<UsingDecl>(*ToIntroducerOrErr),
4796 Nominated ? Nominated : *ToTargetOrErr,
4797 FromConstructorUsingShadow->constructsVirtualBase()))
4798 return ToShadow;
4799 } else {
4800 if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
4801 Name, *ToIntroducerOrErr, *ToTargetOrErr))
4802 return ToShadow;
4803 }
4804
4805 ToShadow->setLexicalDeclContext(LexicalDC);
4806 ToShadow->setAccess(D->getAccess());
4807
4808 if (UsingShadowDecl *FromPattern =
4809 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
4810 if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
4811 Importer.getToContext().setInstantiatedFromUsingShadowDecl(
4812 ToShadow, *ToPatternOrErr);
4813 else
4814 // FIXME: We return error here but the definition is already created
4815 // and available with lookups. How to fix this?..
4816 return ToPatternOrErr.takeError();
4817 }
4818
4819 LexicalDC->addDeclInternal(ToShadow);
4820
4821 return ToShadow;
4822 }
4823
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)4824 ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
4825 DeclContext *DC, *LexicalDC;
4826 DeclarationName Name;
4827 SourceLocation Loc;
4828 NamedDecl *ToD = nullptr;
4829 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4830 return std::move(Err);
4831 if (ToD)
4832 return ToD;
4833
4834 auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
4835 if (!ToComAncestorOrErr)
4836 return ToComAncestorOrErr.takeError();
4837
4838 Error Err = Error::success();
4839 auto ToNominatedNamespace = importChecked(Err, D->getNominatedNamespace());
4840 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4841 auto ToNamespaceKeyLocation =
4842 importChecked(Err, D->getNamespaceKeyLocation());
4843 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4844 auto ToIdentLocation = importChecked(Err, D->getIdentLocation());
4845 if (Err)
4846 return std::move(Err);
4847
4848 UsingDirectiveDecl *ToUsingDir;
4849 if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
4850 ToUsingLoc,
4851 ToNamespaceKeyLocation,
4852 ToQualifierLoc,
4853 ToIdentLocation,
4854 ToNominatedNamespace, *ToComAncestorOrErr))
4855 return ToUsingDir;
4856
4857 ToUsingDir->setLexicalDeclContext(LexicalDC);
4858 LexicalDC->addDeclInternal(ToUsingDir);
4859
4860 return ToUsingDir;
4861 }
4862
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)4863 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
4864 UnresolvedUsingValueDecl *D) {
4865 DeclContext *DC, *LexicalDC;
4866 DeclarationName Name;
4867 SourceLocation Loc;
4868 NamedDecl *ToD = nullptr;
4869 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4870 return std::move(Err);
4871 if (ToD)
4872 return ToD;
4873
4874 Error Err = Error::success();
4875 auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4876 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4877 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4878 auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4879 if (Err)
4880 return std::move(Err);
4881
4882 DeclarationNameInfo NameInfo(Name, ToLoc);
4883 if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4884 return std::move(Err);
4885
4886 UnresolvedUsingValueDecl *ToUsingValue;
4887 if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
4888 ToUsingLoc, ToQualifierLoc, NameInfo,
4889 ToEllipsisLoc))
4890 return ToUsingValue;
4891
4892 ToUsingValue->setAccess(D->getAccess());
4893 ToUsingValue->setLexicalDeclContext(LexicalDC);
4894 LexicalDC->addDeclInternal(ToUsingValue);
4895
4896 return ToUsingValue;
4897 }
4898
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)4899 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
4900 UnresolvedUsingTypenameDecl *D) {
4901 DeclContext *DC, *LexicalDC;
4902 DeclarationName Name;
4903 SourceLocation Loc;
4904 NamedDecl *ToD = nullptr;
4905 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4906 return std::move(Err);
4907 if (ToD)
4908 return ToD;
4909
4910 Error Err = Error::success();
4911 auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4912 auto ToTypenameLoc = importChecked(Err, D->getTypenameLoc());
4913 auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4914 auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4915 if (Err)
4916 return std::move(Err);
4917
4918 UnresolvedUsingTypenameDecl *ToUsing;
4919 if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4920 ToUsingLoc, ToTypenameLoc,
4921 ToQualifierLoc, Loc, Name, ToEllipsisLoc))
4922 return ToUsing;
4923
4924 ToUsing->setAccess(D->getAccess());
4925 ToUsing->setLexicalDeclContext(LexicalDC);
4926 LexicalDC->addDeclInternal(ToUsing);
4927
4928 return ToUsing;
4929 }
4930
VisitBuiltinTemplateDecl(BuiltinTemplateDecl * D)4931 ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
4932 Decl* ToD = nullptr;
4933 switch (D->getBuiltinTemplateKind()) {
4934 case BuiltinTemplateKind::BTK__make_integer_seq:
4935 ToD = Importer.getToContext().getMakeIntegerSeqDecl();
4936 break;
4937 case BuiltinTemplateKind::BTK__type_pack_element:
4938 ToD = Importer.getToContext().getTypePackElementDecl();
4939 break;
4940 }
4941 assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
4942 Importer.MapImported(D, ToD);
4943 return ToD;
4944 }
4945
ImportDefinition(ObjCInterfaceDecl * From,ObjCInterfaceDecl * To,ImportDefinitionKind Kind)4946 Error ASTNodeImporter::ImportDefinition(
4947 ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
4948 if (To->getDefinition()) {
4949 // Check consistency of superclass.
4950 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4951 if (FromSuper) {
4952 if (auto FromSuperOrErr = import(FromSuper))
4953 FromSuper = *FromSuperOrErr;
4954 else
4955 return FromSuperOrErr.takeError();
4956 }
4957
4958 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4959 if ((bool)FromSuper != (bool)ToSuper ||
4960 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4961 Importer.ToDiag(To->getLocation(),
4962 diag::warn_odr_objc_superclass_inconsistent)
4963 << To->getDeclName();
4964 if (ToSuper)
4965 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4966 << To->getSuperClass()->getDeclName();
4967 else
4968 Importer.ToDiag(To->getLocation(),
4969 diag::note_odr_objc_missing_superclass);
4970 if (From->getSuperClass())
4971 Importer.FromDiag(From->getSuperClassLoc(),
4972 diag::note_odr_objc_superclass)
4973 << From->getSuperClass()->getDeclName();
4974 else
4975 Importer.FromDiag(From->getLocation(),
4976 diag::note_odr_objc_missing_superclass);
4977 }
4978
4979 if (shouldForceImportDeclContext(Kind))
4980 if (Error Err = ImportDeclContext(From))
4981 return Err;
4982 return Error::success();
4983 }
4984
4985 // Start the definition.
4986 To->startDefinition();
4987
4988 // If this class has a superclass, import it.
4989 if (From->getSuperClass()) {
4990 if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
4991 To->setSuperClass(*SuperTInfoOrErr);
4992 else
4993 return SuperTInfoOrErr.takeError();
4994 }
4995
4996 // Import protocols
4997 SmallVector<ObjCProtocolDecl *, 4> Protocols;
4998 SmallVector<SourceLocation, 4> ProtocolLocs;
4999 ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc =
5000 From->protocol_loc_begin();
5001
5002 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
5003 FromProtoEnd = From->protocol_end();
5004 FromProto != FromProtoEnd;
5005 ++FromProto, ++FromProtoLoc) {
5006 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
5007 Protocols.push_back(*ToProtoOrErr);
5008 else
5009 return ToProtoOrErr.takeError();
5010
5011 if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
5012 ProtocolLocs.push_back(*ToProtoLocOrErr);
5013 else
5014 return ToProtoLocOrErr.takeError();
5015
5016 }
5017
5018 // FIXME: If we're merging, make sure that the protocol list is the same.
5019 To->setProtocolList(Protocols.data(), Protocols.size(),
5020 ProtocolLocs.data(), Importer.getToContext());
5021
5022 // Import categories. When the categories themselves are imported, they'll
5023 // hook themselves into this interface.
5024 for (auto *Cat : From->known_categories()) {
5025 auto ToCatOrErr = import(Cat);
5026 if (!ToCatOrErr)
5027 return ToCatOrErr.takeError();
5028 }
5029
5030 // If we have an @implementation, import it as well.
5031 if (From->getImplementation()) {
5032 if (Expected<ObjCImplementationDecl *> ToImplOrErr =
5033 import(From->getImplementation()))
5034 To->setImplementation(*ToImplOrErr);
5035 else
5036 return ToImplOrErr.takeError();
5037 }
5038
5039 // Import all of the members of this class.
5040 if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
5041 return Err;
5042
5043 return Error::success();
5044 }
5045
5046 Expected<ObjCTypeParamList *>
ImportObjCTypeParamList(ObjCTypeParamList * list)5047 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
5048 if (!list)
5049 return nullptr;
5050
5051 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
5052 for (auto *fromTypeParam : *list) {
5053 if (auto toTypeParamOrErr = import(fromTypeParam))
5054 toTypeParams.push_back(*toTypeParamOrErr);
5055 else
5056 return toTypeParamOrErr.takeError();
5057 }
5058
5059 auto LAngleLocOrErr = import(list->getLAngleLoc());
5060 if (!LAngleLocOrErr)
5061 return LAngleLocOrErr.takeError();
5062
5063 auto RAngleLocOrErr = import(list->getRAngleLoc());
5064 if (!RAngleLocOrErr)
5065 return RAngleLocOrErr.takeError();
5066
5067 return ObjCTypeParamList::create(Importer.getToContext(),
5068 *LAngleLocOrErr,
5069 toTypeParams,
5070 *RAngleLocOrErr);
5071 }
5072
VisitObjCInterfaceDecl(ObjCInterfaceDecl * D)5073 ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
5074 // If this class has a definition in the translation unit we're coming from,
5075 // but this particular declaration is not that definition, import the
5076 // definition and map to that.
5077 ObjCInterfaceDecl *Definition = D->getDefinition();
5078 if (Definition && Definition != D) {
5079 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5080 return Importer.MapImported(D, *ImportedDefOrErr);
5081 else
5082 return ImportedDefOrErr.takeError();
5083 }
5084
5085 // Import the major distinguishing characteristics of an @interface.
5086 DeclContext *DC, *LexicalDC;
5087 DeclarationName Name;
5088 SourceLocation Loc;
5089 NamedDecl *ToD;
5090 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5091 return std::move(Err);
5092 if (ToD)
5093 return ToD;
5094
5095 // Look for an existing interface with the same name.
5096 ObjCInterfaceDecl *MergeWithIface = nullptr;
5097 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5098 for (auto *FoundDecl : FoundDecls) {
5099 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5100 continue;
5101
5102 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
5103 break;
5104 }
5105
5106 // Create an interface declaration, if one does not already exist.
5107 ObjCInterfaceDecl *ToIface = MergeWithIface;
5108 if (!ToIface) {
5109 ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
5110 if (!AtBeginLocOrErr)
5111 return AtBeginLocOrErr.takeError();
5112
5113 if (GetImportedOrCreateDecl(
5114 ToIface, D, Importer.getToContext(), DC,
5115 *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
5116 /*TypeParamList=*/nullptr,
5117 /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
5118 return ToIface;
5119 ToIface->setLexicalDeclContext(LexicalDC);
5120 LexicalDC->addDeclInternal(ToIface);
5121 }
5122 Importer.MapImported(D, ToIface);
5123 // Import the type parameter list after MapImported, to avoid
5124 // loops when bringing in their DeclContext.
5125 if (auto ToPListOrErr =
5126 ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
5127 ToIface->setTypeParamList(*ToPListOrErr);
5128 else
5129 return ToPListOrErr.takeError();
5130
5131 if (D->isThisDeclarationADefinition())
5132 if (Error Err = ImportDefinition(D, ToIface))
5133 return std::move(Err);
5134
5135 return ToIface;
5136 }
5137
5138 ExpectedDecl
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)5139 ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
5140 ObjCCategoryDecl *Category;
5141 if (Error Err = importInto(Category, D->getCategoryDecl()))
5142 return std::move(Err);
5143
5144 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
5145 if (!ToImpl) {
5146 DeclContext *DC, *LexicalDC;
5147 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5148 return std::move(Err);
5149
5150 Error Err = Error::success();
5151 auto ToLocation = importChecked(Err, D->getLocation());
5152 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
5153 auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
5154 if (Err)
5155 return std::move(Err);
5156
5157 if (GetImportedOrCreateDecl(
5158 ToImpl, D, Importer.getToContext(), DC,
5159 Importer.Import(D->getIdentifier()), Category->getClassInterface(),
5160 ToLocation, ToAtStartLoc, ToCategoryNameLoc))
5161 return ToImpl;
5162
5163 ToImpl->setLexicalDeclContext(LexicalDC);
5164 LexicalDC->addDeclInternal(ToImpl);
5165 Category->setImplementation(ToImpl);
5166 }
5167
5168 Importer.MapImported(D, ToImpl);
5169 if (Error Err = ImportDeclContext(D))
5170 return std::move(Err);
5171
5172 return ToImpl;
5173 }
5174
5175 ExpectedDecl
VisitObjCImplementationDecl(ObjCImplementationDecl * D)5176 ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
5177 // Find the corresponding interface.
5178 ObjCInterfaceDecl *Iface;
5179 if (Error Err = importInto(Iface, D->getClassInterface()))
5180 return std::move(Err);
5181
5182 // Import the superclass, if any.
5183 ObjCInterfaceDecl *Super;
5184 if (Error Err = importInto(Super, D->getSuperClass()))
5185 return std::move(Err);
5186
5187 ObjCImplementationDecl *Impl = Iface->getImplementation();
5188 if (!Impl) {
5189 // We haven't imported an implementation yet. Create a new @implementation
5190 // now.
5191 DeclContext *DC, *LexicalDC;
5192 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5193 return std::move(Err);
5194
5195 Error Err = Error::success();
5196 auto ToLocation = importChecked(Err, D->getLocation());
5197 auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
5198 auto ToSuperClassLoc = importChecked(Err, D->getSuperClassLoc());
5199 auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
5200 auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
5201 if (Err)
5202 return std::move(Err);
5203
5204 if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
5205 DC, Iface, Super,
5206 ToLocation,
5207 ToAtStartLoc,
5208 ToSuperClassLoc,
5209 ToIvarLBraceLoc,
5210 ToIvarRBraceLoc))
5211 return Impl;
5212
5213 Impl->setLexicalDeclContext(LexicalDC);
5214
5215 // Associate the implementation with the class it implements.
5216 Iface->setImplementation(Impl);
5217 Importer.MapImported(D, Iface->getImplementation());
5218 } else {
5219 Importer.MapImported(D, Iface->getImplementation());
5220
5221 // Verify that the existing @implementation has the same superclass.
5222 if ((Super && !Impl->getSuperClass()) ||
5223 (!Super && Impl->getSuperClass()) ||
5224 (Super && Impl->getSuperClass() &&
5225 !declaresSameEntity(Super->getCanonicalDecl(),
5226 Impl->getSuperClass()))) {
5227 Importer.ToDiag(Impl->getLocation(),
5228 diag::warn_odr_objc_superclass_inconsistent)
5229 << Iface->getDeclName();
5230 // FIXME: It would be nice to have the location of the superclass
5231 // below.
5232 if (Impl->getSuperClass())
5233 Importer.ToDiag(Impl->getLocation(),
5234 diag::note_odr_objc_superclass)
5235 << Impl->getSuperClass()->getDeclName();
5236 else
5237 Importer.ToDiag(Impl->getLocation(),
5238 diag::note_odr_objc_missing_superclass);
5239 if (D->getSuperClass())
5240 Importer.FromDiag(D->getLocation(),
5241 diag::note_odr_objc_superclass)
5242 << D->getSuperClass()->getDeclName();
5243 else
5244 Importer.FromDiag(D->getLocation(),
5245 diag::note_odr_objc_missing_superclass);
5246
5247 return make_error<ImportError>(ImportError::NameConflict);
5248 }
5249 }
5250
5251 // Import all of the members of this @implementation.
5252 if (Error Err = ImportDeclContext(D))
5253 return std::move(Err);
5254
5255 return Impl;
5256 }
5257
VisitObjCPropertyDecl(ObjCPropertyDecl * D)5258 ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
5259 // Import the major distinguishing characteristics of an @property.
5260 DeclContext *DC, *LexicalDC;
5261 DeclarationName Name;
5262 SourceLocation Loc;
5263 NamedDecl *ToD;
5264 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5265 return std::move(Err);
5266 if (ToD)
5267 return ToD;
5268
5269 // Check whether we have already imported this property.
5270 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5271 for (auto *FoundDecl : FoundDecls) {
5272 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5273 // Instance and class properties can share the same name but are different
5274 // declarations.
5275 if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
5276 continue;
5277
5278 // Check property types.
5279 if (!Importer.IsStructurallyEquivalent(D->getType(),
5280 FoundProp->getType())) {
5281 Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
5282 << Name << D->getType() << FoundProp->getType();
5283 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5284 << FoundProp->getType();
5285
5286 return make_error<ImportError>(ImportError::NameConflict);
5287 }
5288
5289 // FIXME: Check property attributes, getters, setters, etc.?
5290
5291 // Consider these properties to be equivalent.
5292 Importer.MapImported(D, FoundProp);
5293 return FoundProp;
5294 }
5295 }
5296
5297 Error Err = Error::success();
5298 auto ToType = importChecked(Err, D->getType());
5299 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5300 auto ToAtLoc = importChecked(Err, D->getAtLoc());
5301 auto ToLParenLoc = importChecked(Err, D->getLParenLoc());
5302 if (Err)
5303 return std::move(Err);
5304
5305 // Create the new property.
5306 ObjCPropertyDecl *ToProperty;
5307 if (GetImportedOrCreateDecl(
5308 ToProperty, D, Importer.getToContext(), DC, Loc,
5309 Name.getAsIdentifierInfo(), ToAtLoc,
5310 ToLParenLoc, ToType,
5311 ToTypeSourceInfo, D->getPropertyImplementation()))
5312 return ToProperty;
5313
5314 auto ToGetterName = importChecked(Err, D->getGetterName());
5315 auto ToSetterName = importChecked(Err, D->getSetterName());
5316 auto ToGetterNameLoc = importChecked(Err, D->getGetterNameLoc());
5317 auto ToSetterNameLoc = importChecked(Err, D->getSetterNameLoc());
5318 auto ToGetterMethodDecl = importChecked(Err, D->getGetterMethodDecl());
5319 auto ToSetterMethodDecl = importChecked(Err, D->getSetterMethodDecl());
5320 auto ToPropertyIvarDecl = importChecked(Err, D->getPropertyIvarDecl());
5321 if (Err)
5322 return std::move(Err);
5323
5324 ToProperty->setLexicalDeclContext(LexicalDC);
5325 LexicalDC->addDeclInternal(ToProperty);
5326
5327 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5328 ToProperty->setPropertyAttributesAsWritten(
5329 D->getPropertyAttributesAsWritten());
5330 ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
5331 ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
5332 ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5333 ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5334 ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
5335 return ToProperty;
5336 }
5337
5338 ExpectedDecl
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)5339 ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
5340 ObjCPropertyDecl *Property;
5341 if (Error Err = importInto(Property, D->getPropertyDecl()))
5342 return std::move(Err);
5343
5344 DeclContext *DC, *LexicalDC;
5345 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5346 return std::move(Err);
5347
5348 auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5349
5350 // Import the ivar (for an @synthesize).
5351 ObjCIvarDecl *Ivar = nullptr;
5352 if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
5353 return std::move(Err);
5354
5355 ObjCPropertyImplDecl *ToImpl
5356 = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
5357 Property->getQueryKind());
5358 if (!ToImpl) {
5359
5360 Error Err = Error::success();
5361 auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
5362 auto ToLocation = importChecked(Err, D->getLocation());
5363 auto ToPropertyIvarDeclLoc =
5364 importChecked(Err, D->getPropertyIvarDeclLoc());
5365 if (Err)
5366 return std::move(Err);
5367
5368 if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
5369 ToBeginLoc,
5370 ToLocation, Property,
5371 D->getPropertyImplementation(), Ivar,
5372 ToPropertyIvarDeclLoc))
5373 return ToImpl;
5374
5375 ToImpl->setLexicalDeclContext(LexicalDC);
5376 LexicalDC->addDeclInternal(ToImpl);
5377 } else {
5378 // Check that we have the same kind of property implementation (@synthesize
5379 // vs. @dynamic).
5380 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
5381 Importer.ToDiag(ToImpl->getLocation(),
5382 diag::warn_odr_objc_property_impl_kind_inconsistent)
5383 << Property->getDeclName()
5384 << (ToImpl->getPropertyImplementation()
5385 == ObjCPropertyImplDecl::Dynamic);
5386 Importer.FromDiag(D->getLocation(),
5387 diag::note_odr_objc_property_impl_kind)
5388 << D->getPropertyDecl()->getDeclName()
5389 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
5390
5391 return make_error<ImportError>(ImportError::NameConflict);
5392 }
5393
5394 // For @synthesize, check that we have the same
5395 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
5396 Ivar != ToImpl->getPropertyIvarDecl()) {
5397 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
5398 diag::warn_odr_objc_synthesize_ivar_inconsistent)
5399 << Property->getDeclName()
5400 << ToImpl->getPropertyIvarDecl()->getDeclName()
5401 << Ivar->getDeclName();
5402 Importer.FromDiag(D->getPropertyIvarDeclLoc(),
5403 diag::note_odr_objc_synthesize_ivar_here)
5404 << D->getPropertyIvarDecl()->getDeclName();
5405
5406 return make_error<ImportError>(ImportError::NameConflict);
5407 }
5408
5409 // Merge the existing implementation with the new implementation.
5410 Importer.MapImported(D, ToImpl);
5411 }
5412
5413 return ToImpl;
5414 }
5415
5416 ExpectedDecl
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)5417 ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
5418 // For template arguments, we adopt the translation unit as our declaration
5419 // context. This context will be fixed when the actual template declaration
5420 // is created.
5421
5422 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5423 if (!BeginLocOrErr)
5424 return BeginLocOrErr.takeError();
5425
5426 ExpectedSLoc LocationOrErr = import(D->getLocation());
5427 if (!LocationOrErr)
5428 return LocationOrErr.takeError();
5429
5430 TemplateTypeParmDecl *ToD = nullptr;
5431 if (GetImportedOrCreateDecl(
5432 ToD, D, Importer.getToContext(),
5433 Importer.getToContext().getTranslationUnitDecl(),
5434 *BeginLocOrErr, *LocationOrErr,
5435 D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
5436 D->wasDeclaredWithTypename(), D->isParameterPack(),
5437 D->hasTypeConstraint()))
5438 return ToD;
5439
5440 // Import the type-constraint
5441 if (const TypeConstraint *TC = D->getTypeConstraint()) {
5442
5443 Error Err = Error::success();
5444 auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
5445 auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
5446 auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
5447 auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
5448 auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
5449 auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5450 if (Err)
5451 return std::move(Err);
5452
5453 TemplateArgumentListInfo ToTAInfo;
5454 const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
5455 if (ASTTemplateArgs)
5456 if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
5457 ToTAInfo))
5458 return std::move(Err);
5459
5460 ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
5461 ToFoundDecl, ToNamedConcept,
5462 ASTTemplateArgs ?
5463 ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
5464 ToTAInfo) : nullptr,
5465 ToIDC);
5466 }
5467
5468 if (D->hasDefaultArgument()) {
5469 Expected<TypeSourceInfo *> ToDefaultArgOrErr =
5470 import(D->getDefaultArgumentInfo());
5471 if (!ToDefaultArgOrErr)
5472 return ToDefaultArgOrErr.takeError();
5473 ToD->setDefaultArgument(*ToDefaultArgOrErr);
5474 }
5475
5476 return ToD;
5477 }
5478
5479 ExpectedDecl
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)5480 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
5481
5482 Error Err = Error::success();
5483 auto ToDeclName = importChecked(Err, D->getDeclName());
5484 auto ToLocation = importChecked(Err, D->getLocation());
5485 auto ToType = importChecked(Err, D->getType());
5486 auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5487 auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
5488 if (Err)
5489 return std::move(Err);
5490
5491 NonTypeTemplateParmDecl *ToD = nullptr;
5492 if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(),
5493 Importer.getToContext().getTranslationUnitDecl(),
5494 ToInnerLocStart, ToLocation, D->getDepth(),
5495 D->getPosition(),
5496 ToDeclName.getAsIdentifierInfo(), ToType,
5497 D->isParameterPack(), ToTypeSourceInfo))
5498 return ToD;
5499
5500 if (D->hasDefaultArgument()) {
5501 ExpectedExpr ToDefaultArgOrErr = import(D->getDefaultArgument());
5502 if (!ToDefaultArgOrErr)
5503 return ToDefaultArgOrErr.takeError();
5504 ToD->setDefaultArgument(*ToDefaultArgOrErr);
5505 }
5506
5507 return ToD;
5508 }
5509
5510 ExpectedDecl
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)5511 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
5512 // Import the name of this declaration.
5513 auto NameOrErr = import(D->getDeclName());
5514 if (!NameOrErr)
5515 return NameOrErr.takeError();
5516
5517 // Import the location of this declaration.
5518 ExpectedSLoc LocationOrErr = import(D->getLocation());
5519 if (!LocationOrErr)
5520 return LocationOrErr.takeError();
5521
5522 // Import template parameters.
5523 auto TemplateParamsOrErr = import(D->getTemplateParameters());
5524 if (!TemplateParamsOrErr)
5525 return TemplateParamsOrErr.takeError();
5526
5527 TemplateTemplateParmDecl *ToD = nullptr;
5528 if (GetImportedOrCreateDecl(
5529 ToD, D, Importer.getToContext(),
5530 Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
5531 D->getDepth(), D->getPosition(), D->isParameterPack(),
5532 (*NameOrErr).getAsIdentifierInfo(), *TemplateParamsOrErr))
5533 return ToD;
5534
5535 if (D->hasDefaultArgument()) {
5536 Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
5537 import(D->getDefaultArgument());
5538 if (!ToDefaultArgOrErr)
5539 return ToDefaultArgOrErr.takeError();
5540 ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
5541 }
5542
5543 return ToD;
5544 }
5545
5546 // Returns the definition for a (forward) declaration of a TemplateDecl, if
5547 // it has any definition in the redecl chain.
getTemplateDefinition(T * D)5548 template <typename T> static auto getTemplateDefinition(T *D) -> T * {
5549 assert(D->getTemplatedDecl() && "Should be called on templates only");
5550 auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
5551 if (!ToTemplatedDef)
5552 return nullptr;
5553 auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
5554 return cast_or_null<T>(TemplateWithDef);
5555 }
5556
VisitClassTemplateDecl(ClassTemplateDecl * D)5557 ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
5558
5559 // Import the major distinguishing characteristics of this class template.
5560 DeclContext *DC, *LexicalDC;
5561 DeclarationName Name;
5562 SourceLocation Loc;
5563 NamedDecl *ToD;
5564 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5565 return std::move(Err);
5566 if (ToD)
5567 return ToD;
5568
5569 ClassTemplateDecl *FoundByLookup = nullptr;
5570
5571 // We may already have a template of the same name; try to find and match it.
5572 if (!DC->isFunctionOrMethod()) {
5573 SmallVector<NamedDecl *, 4> ConflictingDecls;
5574 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5575 for (auto *FoundDecl : FoundDecls) {
5576 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary |
5577 Decl::IDNS_TagFriend))
5578 continue;
5579
5580 Decl *Found = FoundDecl;
5581 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
5582 if (FoundTemplate) {
5583 if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
5584 continue;
5585
5586 if (IsStructuralMatch(D, FoundTemplate)) {
5587 ClassTemplateDecl *TemplateWithDef =
5588 getTemplateDefinition(FoundTemplate);
5589 if (D->isThisDeclarationADefinition() && TemplateWithDef)
5590 return Importer.MapImported(D, TemplateWithDef);
5591 if (!FoundByLookup)
5592 FoundByLookup = FoundTemplate;
5593 // Search in all matches because there may be multiple decl chains,
5594 // see ASTTests test ImportExistingFriendClassTemplateDef.
5595 continue;
5596 }
5597 ConflictingDecls.push_back(FoundDecl);
5598 }
5599 }
5600
5601 if (!ConflictingDecls.empty()) {
5602 ExpectedName NameOrErr = Importer.HandleNameConflict(
5603 Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5604 ConflictingDecls.size());
5605 if (NameOrErr)
5606 Name = NameOrErr.get();
5607 else
5608 return NameOrErr.takeError();
5609 }
5610 }
5611
5612 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
5613
5614 auto TemplateParamsOrErr = import(D->getTemplateParameters());
5615 if (!TemplateParamsOrErr)
5616 return TemplateParamsOrErr.takeError();
5617
5618 // Create the declaration that is being templated.
5619 CXXRecordDecl *ToTemplated;
5620 if (Error Err = importInto(ToTemplated, FromTemplated))
5621 return std::move(Err);
5622
5623 // Create the class template declaration itself.
5624 ClassTemplateDecl *D2;
5625 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
5626 *TemplateParamsOrErr, ToTemplated))
5627 return D2;
5628
5629 ToTemplated->setDescribedClassTemplate(D2);
5630
5631 D2->setAccess(D->getAccess());
5632 D2->setLexicalDeclContext(LexicalDC);
5633
5634 addDeclToContexts(D, D2);
5635 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
5636
5637 if (FoundByLookup) {
5638 auto *Recent =
5639 const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5640
5641 // It is possible that during the import of the class template definition
5642 // we start the import of a fwd friend decl of the very same class template
5643 // and we add the fwd friend decl to the lookup table. But the ToTemplated
5644 // had been created earlier and by that time the lookup could not find
5645 // anything existing, so it has no previous decl. Later, (still during the
5646 // import of the fwd friend decl) we start to import the definition again
5647 // and this time the lookup finds the previous fwd friend class template.
5648 // In this case we must set up the previous decl for the templated decl.
5649 if (!ToTemplated->getPreviousDecl()) {
5650 assert(FoundByLookup->getTemplatedDecl() &&
5651 "Found decl must have its templated decl set");
5652 CXXRecordDecl *PrevTemplated =
5653 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5654 if (ToTemplated != PrevTemplated)
5655 ToTemplated->setPreviousDecl(PrevTemplated);
5656 }
5657
5658 D2->setPreviousDecl(Recent);
5659 }
5660
5661 if (FromTemplated->isCompleteDefinition() &&
5662 !ToTemplated->isCompleteDefinition()) {
5663 // FIXME: Import definition!
5664 }
5665
5666 return D2;
5667 }
5668
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)5669 ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
5670 ClassTemplateSpecializationDecl *D) {
5671 ClassTemplateDecl *ClassTemplate;
5672 if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
5673 return std::move(Err);
5674
5675 // Import the context of this declaration.
5676 DeclContext *DC, *LexicalDC;
5677 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5678 return std::move(Err);
5679
5680 // Import template arguments.
5681 SmallVector<TemplateArgument, 2> TemplateArgs;
5682 if (Error Err = ImportTemplateArguments(
5683 D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5684 return std::move(Err);
5685 // Try to find an existing specialization with these template arguments and
5686 // template parameter list.
5687 void *InsertPos = nullptr;
5688 ClassTemplateSpecializationDecl *PrevDecl = nullptr;
5689 ClassTemplatePartialSpecializationDecl *PartialSpec =
5690 dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
5691
5692 // Import template parameters.
5693 TemplateParameterList *ToTPList = nullptr;
5694
5695 if (PartialSpec) {
5696 auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
5697 if (!ToTPListOrErr)
5698 return ToTPListOrErr.takeError();
5699 ToTPList = *ToTPListOrErr;
5700 PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
5701 *ToTPListOrErr,
5702 InsertPos);
5703 } else
5704 PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
5705
5706 if (PrevDecl) {
5707 if (IsStructuralMatch(D, PrevDecl)) {
5708 CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
5709 if (D->isThisDeclarationADefinition() && PrevDefinition) {
5710 Importer.MapImported(D, PrevDefinition);
5711 // Import those default field initializers which have been
5712 // instantiated in the "From" context, but not in the "To" context.
5713 for (auto *FromField : D->fields()) {
5714 auto ToOrErr = import(FromField);
5715 if (!ToOrErr)
5716 return ToOrErr.takeError();
5717 }
5718
5719 // Import those methods which have been instantiated in the
5720 // "From" context, but not in the "To" context.
5721 for (CXXMethodDecl *FromM : D->methods()) {
5722 auto ToOrErr = import(FromM);
5723 if (!ToOrErr)
5724 return ToOrErr.takeError();
5725 }
5726
5727 // TODO Import instantiated default arguments.
5728 // TODO Import instantiated exception specifications.
5729 //
5730 // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
5731 // what else could be fused during an AST merge.
5732 return PrevDefinition;
5733 }
5734 } else { // ODR violation.
5735 // FIXME HandleNameConflict
5736 return make_error<ImportError>(ImportError::NameConflict);
5737 }
5738 }
5739
5740 // Import the location of this declaration.
5741 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5742 if (!BeginLocOrErr)
5743 return BeginLocOrErr.takeError();
5744 ExpectedSLoc IdLocOrErr = import(D->getLocation());
5745 if (!IdLocOrErr)
5746 return IdLocOrErr.takeError();
5747
5748 // Create the specialization.
5749 ClassTemplateSpecializationDecl *D2 = nullptr;
5750 if (PartialSpec) {
5751 // Import TemplateArgumentListInfo.
5752 TemplateArgumentListInfo ToTAInfo;
5753 const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
5754 if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
5755 return std::move(Err);
5756
5757 QualType CanonInjType;
5758 if (Error Err = importInto(
5759 CanonInjType, PartialSpec->getInjectedSpecializationType()))
5760 return std::move(Err);
5761 CanonInjType = CanonInjType.getCanonicalType();
5762
5763 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
5764 D2, D, Importer.getToContext(), D->getTagKind(), DC,
5765 *BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate,
5766 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
5767 ToTAInfo, CanonInjType,
5768 cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
5769 return D2;
5770
5771 // Update InsertPos, because preceding import calls may have invalidated
5772 // it by adding new specializations.
5773 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
5774 if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList,
5775 InsertPos))
5776 // Add this partial specialization to the class template.
5777 ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos);
5778
5779 updateLookupTableForTemplateParameters(*ToTPList);
5780 } else { // Not a partial specialization.
5781 if (GetImportedOrCreateDecl(
5782 D2, D, Importer.getToContext(), D->getTagKind(), DC,
5783 *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
5784 PrevDecl))
5785 return D2;
5786
5787 // Update InsertPos, because preceding import calls may have invalidated
5788 // it by adding new specializations.
5789 if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
5790 // Add this specialization to the class template.
5791 ClassTemplate->AddSpecialization(D2, InsertPos);
5792 }
5793
5794 D2->setSpecializationKind(D->getSpecializationKind());
5795
5796 // Set the context of this specialization/instantiation.
5797 D2->setLexicalDeclContext(LexicalDC);
5798
5799 // Add to the DC only if it was an explicit specialization/instantiation.
5800 if (D2->isExplicitInstantiationOrSpecialization()) {
5801 LexicalDC->addDeclInternal(D2);
5802 }
5803
5804 if (auto BraceRangeOrErr = import(D->getBraceRange()))
5805 D2->setBraceRange(*BraceRangeOrErr);
5806 else
5807 return BraceRangeOrErr.takeError();
5808
5809 // Import the qualifier, if any.
5810 if (auto LocOrErr = import(D->getQualifierLoc()))
5811 D2->setQualifierInfo(*LocOrErr);
5812 else
5813 return LocOrErr.takeError();
5814
5815 if (auto *TSI = D->getTypeAsWritten()) {
5816 if (auto TInfoOrErr = import(TSI))
5817 D2->setTypeAsWritten(*TInfoOrErr);
5818 else
5819 return TInfoOrErr.takeError();
5820
5821 if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
5822 D2->setTemplateKeywordLoc(*LocOrErr);
5823 else
5824 return LocOrErr.takeError();
5825
5826 if (auto LocOrErr = import(D->getExternLoc()))
5827 D2->setExternLoc(*LocOrErr);
5828 else
5829 return LocOrErr.takeError();
5830 }
5831
5832 if (D->getPointOfInstantiation().isValid()) {
5833 if (auto POIOrErr = import(D->getPointOfInstantiation()))
5834 D2->setPointOfInstantiation(*POIOrErr);
5835 else
5836 return POIOrErr.takeError();
5837 }
5838
5839 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
5840
5841 if (D->isCompleteDefinition())
5842 if (Error Err = ImportDefinition(D, D2))
5843 return std::move(Err);
5844
5845 return D2;
5846 }
5847
VisitVarTemplateDecl(VarTemplateDecl * D)5848 ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
5849 // Import the major distinguishing characteristics of this variable template.
5850 DeclContext *DC, *LexicalDC;
5851 DeclarationName Name;
5852 SourceLocation Loc;
5853 NamedDecl *ToD;
5854 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5855 return std::move(Err);
5856 if (ToD)
5857 return ToD;
5858
5859 // We may already have a template of the same name; try to find and match it.
5860 assert(!DC->isFunctionOrMethod() &&
5861 "Variable templates cannot be declared at function scope");
5862
5863 SmallVector<NamedDecl *, 4> ConflictingDecls;
5864 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5865 VarTemplateDecl *FoundByLookup = nullptr;
5866 for (auto *FoundDecl : FoundDecls) {
5867 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5868 continue;
5869
5870 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
5871 // Use the templated decl, some linkage flags are set only there.
5872 if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
5873 D->getTemplatedDecl()))
5874 continue;
5875 if (IsStructuralMatch(D, FoundTemplate)) {
5876 // The Decl in the "From" context has a definition, but in the
5877 // "To" context we already have a definition.
5878 VarTemplateDecl *FoundDef = getTemplateDefinition(FoundTemplate);
5879 if (D->isThisDeclarationADefinition() && FoundDef)
5880 // FIXME Check for ODR error if the two definitions have
5881 // different initializers?
5882 return Importer.MapImported(D, FoundDef);
5883
5884 FoundByLookup = FoundTemplate;
5885 break;
5886 }
5887 ConflictingDecls.push_back(FoundDecl);
5888 }
5889 }
5890
5891 if (!ConflictingDecls.empty()) {
5892 ExpectedName NameOrErr = Importer.HandleNameConflict(
5893 Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5894 ConflictingDecls.size());
5895 if (NameOrErr)
5896 Name = NameOrErr.get();
5897 else
5898 return NameOrErr.takeError();
5899 }
5900
5901 VarDecl *DTemplated = D->getTemplatedDecl();
5902
5903 // Import the type.
5904 // FIXME: Value not used?
5905 ExpectedType TypeOrErr = import(DTemplated->getType());
5906 if (!TypeOrErr)
5907 return TypeOrErr.takeError();
5908
5909 // Create the declaration that is being templated.
5910 VarDecl *ToTemplated;
5911 if (Error Err = importInto(ToTemplated, DTemplated))
5912 return std::move(Err);
5913
5914 // Create the variable template declaration itself.
5915 auto TemplateParamsOrErr = import(D->getTemplateParameters());
5916 if (!TemplateParamsOrErr)
5917 return TemplateParamsOrErr.takeError();
5918
5919 VarTemplateDecl *ToVarTD;
5920 if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
5921 Name, *TemplateParamsOrErr, ToTemplated))
5922 return ToVarTD;
5923
5924 ToTemplated->setDescribedVarTemplate(ToVarTD);
5925
5926 ToVarTD->setAccess(D->getAccess());
5927 ToVarTD->setLexicalDeclContext(LexicalDC);
5928 LexicalDC->addDeclInternal(ToVarTD);
5929 if (DC != Importer.getToContext().getTranslationUnitDecl())
5930 updateLookupTableForTemplateParameters(**TemplateParamsOrErr);
5931
5932 if (FoundByLookup) {
5933 auto *Recent =
5934 const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5935 if (!ToTemplated->getPreviousDecl()) {
5936 auto *PrevTemplated =
5937 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5938 if (ToTemplated != PrevTemplated)
5939 ToTemplated->setPreviousDecl(PrevTemplated);
5940 }
5941 ToVarTD->setPreviousDecl(Recent);
5942 }
5943
5944 if (DTemplated->isThisDeclarationADefinition() &&
5945 !ToTemplated->isThisDeclarationADefinition()) {
5946 // FIXME: Import definition!
5947 }
5948
5949 return ToVarTD;
5950 }
5951
VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl * D)5952 ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5953 VarTemplateSpecializationDecl *D) {
5954 // If this record has a definition in the translation unit we're coming from,
5955 // but this particular declaration is not that definition, import the
5956 // definition and map to that.
5957 VarDecl *Definition = D->getDefinition();
5958 if (Definition && Definition != D) {
5959 if (ExpectedDecl ImportedDefOrErr = import(Definition))
5960 return Importer.MapImported(D, *ImportedDefOrErr);
5961 else
5962 return ImportedDefOrErr.takeError();
5963 }
5964
5965 VarTemplateDecl *VarTemplate = nullptr;
5966 if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
5967 return std::move(Err);
5968
5969 // Import the context of this declaration.
5970 DeclContext *DC, *LexicalDC;
5971 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5972 return std::move(Err);
5973
5974 // Import the location of this declaration.
5975 ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5976 if (!BeginLocOrErr)
5977 return BeginLocOrErr.takeError();
5978
5979 auto IdLocOrErr = import(D->getLocation());
5980 if (!IdLocOrErr)
5981 return IdLocOrErr.takeError();
5982
5983 // Import template arguments.
5984 SmallVector<TemplateArgument, 2> TemplateArgs;
5985 if (Error Err = ImportTemplateArguments(
5986 D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5987 return std::move(Err);
5988
5989 // Try to find an existing specialization with these template arguments.
5990 void *InsertPos = nullptr;
5991 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5992 TemplateArgs, InsertPos);
5993 if (D2) {
5994 // We already have a variable template specialization with these template
5995 // arguments.
5996
5997 // FIXME: Check for specialization vs. instantiation errors.
5998
5999 if (VarDecl *FoundDef = D2->getDefinition()) {
6000 if (!D->isThisDeclarationADefinition() ||
6001 IsStructuralMatch(D, FoundDef)) {
6002 // The record types structurally match, or the "from" translation
6003 // unit only had a forward declaration anyway; call it the same
6004 // variable.
6005 return Importer.MapImported(D, FoundDef);
6006 }
6007 }
6008 } else {
6009 // Import the type.
6010 QualType T;
6011 if (Error Err = importInto(T, D->getType()))
6012 return std::move(Err);
6013
6014 auto TInfoOrErr = import(D->getTypeSourceInfo());
6015 if (!TInfoOrErr)
6016 return TInfoOrErr.takeError();
6017
6018 TemplateArgumentListInfo ToTAInfo;
6019 if (Error Err = ImportTemplateArgumentListInfo(
6020 D->getTemplateArgsInfo(), ToTAInfo))
6021 return std::move(Err);
6022
6023 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
6024 // Create a new specialization.
6025 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
6026 // Import TemplateArgumentListInfo
6027 TemplateArgumentListInfo ArgInfos;
6028 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
6029 // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
6030 if (Error Err = ImportTemplateArgumentListInfo(
6031 *FromTAArgsAsWritten, ArgInfos))
6032 return std::move(Err);
6033
6034 auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
6035 if (!ToTPListOrErr)
6036 return ToTPListOrErr.takeError();
6037
6038 PartVarSpecDecl *ToPartial;
6039 if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
6040 *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
6041 VarTemplate, T, *TInfoOrErr,
6042 D->getStorageClass(), TemplateArgs, ArgInfos))
6043 return ToPartial;
6044
6045 if (Expected<PartVarSpecDecl *> ToInstOrErr = import(
6046 FromPartial->getInstantiatedFromMember()))
6047 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
6048 else
6049 return ToInstOrErr.takeError();
6050
6051 if (FromPartial->isMemberSpecialization())
6052 ToPartial->setMemberSpecialization();
6053
6054 D2 = ToPartial;
6055
6056 // FIXME: Use this update if VarTemplatePartialSpecializationDecl is fixed
6057 // to adopt template parameters.
6058 // updateLookupTableForTemplateParameters(**ToTPListOrErr);
6059 } else { // Full specialization
6060 if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC,
6061 *BeginLocOrErr, *IdLocOrErr, VarTemplate,
6062 T, *TInfoOrErr,
6063 D->getStorageClass(), TemplateArgs))
6064 return D2;
6065 }
6066
6067 if (D->getPointOfInstantiation().isValid()) {
6068 if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
6069 D2->setPointOfInstantiation(*POIOrErr);
6070 else
6071 return POIOrErr.takeError();
6072 }
6073
6074 D2->setSpecializationKind(D->getSpecializationKind());
6075 D2->setTemplateArgsInfo(ToTAInfo);
6076
6077 // Add this specialization to the class template.
6078 VarTemplate->AddSpecialization(D2, InsertPos);
6079
6080 // Import the qualifier, if any.
6081 if (auto LocOrErr = import(D->getQualifierLoc()))
6082 D2->setQualifierInfo(*LocOrErr);
6083 else
6084 return LocOrErr.takeError();
6085
6086 if (D->isConstexpr())
6087 D2->setConstexpr(true);
6088
6089 // Add the specialization to this context.
6090 D2->setLexicalDeclContext(LexicalDC);
6091 LexicalDC->addDeclInternal(D2);
6092
6093 D2->setAccess(D->getAccess());
6094 }
6095
6096 if (Error Err = ImportInitializer(D, D2))
6097 return std::move(Err);
6098
6099 return D2;
6100 }
6101
6102 ExpectedDecl
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)6103 ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
6104 DeclContext *DC, *LexicalDC;
6105 DeclarationName Name;
6106 SourceLocation Loc;
6107 NamedDecl *ToD;
6108
6109 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6110 return std::move(Err);
6111
6112 if (ToD)
6113 return ToD;
6114
6115 const FunctionTemplateDecl *FoundByLookup = nullptr;
6116
6117 // Try to find a function in our own ("to") context with the same name, same
6118 // type, and in the same context as the function we're importing.
6119 // FIXME Split this into a separate function.
6120 if (!LexicalDC->isFunctionOrMethod()) {
6121 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
6122 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6123 for (auto *FoundDecl : FoundDecls) {
6124 if (!FoundDecl->isInIdentifierNamespace(IDNS))
6125 continue;
6126
6127 if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
6128 if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
6129 continue;
6130 if (IsStructuralMatch(D, FoundTemplate)) {
6131 FunctionTemplateDecl *TemplateWithDef =
6132 getTemplateDefinition(FoundTemplate);
6133 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6134 return Importer.MapImported(D, TemplateWithDef);
6135
6136 FoundByLookup = FoundTemplate;
6137 break;
6138 // TODO: handle conflicting names
6139 }
6140 }
6141 }
6142 }
6143
6144 auto ParamsOrErr = import(D->getTemplateParameters());
6145 if (!ParamsOrErr)
6146 return ParamsOrErr.takeError();
6147 TemplateParameterList *Params = *ParamsOrErr;
6148
6149 FunctionDecl *TemplatedFD;
6150 if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
6151 return std::move(Err);
6152
6153 // Template parameters of the ClassTemplateDecl and FunctionTemplateDecl are
6154 // shared, if the FunctionTemplateDecl is a deduction guide for the class.
6155 // At import the ClassTemplateDecl object is always created first (FIXME: is
6156 // this really true?) because the dependency, then the FunctionTemplateDecl.
6157 // The DeclContext of the template parameters is changed when the
6158 // FunctionTemplateDecl is created, but was set already when the class
6159 // template was created. So here it is not the TU (default value) any more.
6160 // FIXME: The DeclContext of the parameters is now set finally to the
6161 // CXXDeductionGuideDecl object that was imported later. This may not be the
6162 // same that is in the original AST, specially if there are multiple deduction
6163 // guides.
6164 DeclContext *OldParamDC = nullptr;
6165 if (Params->size() > 0)
6166 OldParamDC = Params->getParam(0)->getDeclContext();
6167
6168 FunctionTemplateDecl *ToFunc;
6169 if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
6170 Params, TemplatedFD))
6171 return ToFunc;
6172
6173 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
6174
6175 ToFunc->setAccess(D->getAccess());
6176 ToFunc->setLexicalDeclContext(LexicalDC);
6177 LexicalDC->addDeclInternal(ToFunc);
6178 updateLookupTableForTemplateParameters(*Params, OldParamDC);
6179
6180 if (FoundByLookup) {
6181 auto *Recent =
6182 const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6183 if (!TemplatedFD->getPreviousDecl()) {
6184 assert(FoundByLookup->getTemplatedDecl() &&
6185 "Found decl must have its templated decl set");
6186 auto *PrevTemplated =
6187 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6188 if (TemplatedFD != PrevTemplated)
6189 TemplatedFD->setPreviousDecl(PrevTemplated);
6190 }
6191 ToFunc->setPreviousDecl(Recent);
6192 }
6193
6194 return ToFunc;
6195 }
6196
6197 //----------------------------------------------------------------------------
6198 // Import Statements
6199 //----------------------------------------------------------------------------
6200
VisitStmt(Stmt * S)6201 ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
6202 Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
6203 << S->getStmtClassName();
6204 return make_error<ImportError>(ImportError::UnsupportedConstruct);
6205 }
6206
6207
VisitGCCAsmStmt(GCCAsmStmt * S)6208 ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
6209 if (Importer.returnWithErrorInTest())
6210 return make_error<ImportError>(ImportError::UnsupportedConstruct);
6211 SmallVector<IdentifierInfo *, 4> Names;
6212 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6213 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
6214 // ToII is nullptr when no symbolic name is given for output operand
6215 // see ParseStmtAsm::ParseAsmOperandsOpt
6216 Names.push_back(ToII);
6217 }
6218
6219 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6220 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
6221 // ToII is nullptr when no symbolic name is given for input operand
6222 // see ParseStmtAsm::ParseAsmOperandsOpt
6223 Names.push_back(ToII);
6224 }
6225
6226 SmallVector<StringLiteral *, 4> Clobbers;
6227 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
6228 if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
6229 Clobbers.push_back(*ClobberOrErr);
6230 else
6231 return ClobberOrErr.takeError();
6232
6233 }
6234
6235 SmallVector<StringLiteral *, 4> Constraints;
6236 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
6237 if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
6238 Constraints.push_back(*OutputOrErr);
6239 else
6240 return OutputOrErr.takeError();
6241 }
6242
6243 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6244 if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6245 Constraints.push_back(*InputOrErr);
6246 else
6247 return InputOrErr.takeError();
6248 }
6249
6250 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
6251 S->getNumLabels());
6252 if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
6253 return std::move(Err);
6254
6255 if (Error Err =
6256 ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
6257 return std::move(Err);
6258
6259 if (Error Err = ImportArrayChecked(
6260 S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6261 return std::move(Err);
6262
6263 ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6264 if (!AsmLocOrErr)
6265 return AsmLocOrErr.takeError();
6266 auto AsmStrOrErr = import(S->getAsmString());
6267 if (!AsmStrOrErr)
6268 return AsmStrOrErr.takeError();
6269 ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6270 if (!RParenLocOrErr)
6271 return RParenLocOrErr.takeError();
6272
6273 return new (Importer.getToContext()) GCCAsmStmt(
6274 Importer.getToContext(),
6275 *AsmLocOrErr,
6276 S->isSimple(),
6277 S->isVolatile(),
6278 S->getNumOutputs(),
6279 S->getNumInputs(),
6280 Names.data(),
6281 Constraints.data(),
6282 Exprs.data(),
6283 *AsmStrOrErr,
6284 S->getNumClobbers(),
6285 Clobbers.data(),
6286 S->getNumLabels(),
6287 *RParenLocOrErr);
6288 }
6289
VisitDeclStmt(DeclStmt * S)6290 ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
6291
6292 Error Err = Error::success();
6293 auto ToDG = importChecked(Err, S->getDeclGroup());
6294 auto ToBeginLoc = importChecked(Err, S->getBeginLoc());
6295 auto ToEndLoc = importChecked(Err, S->getEndLoc());
6296 if (Err)
6297 return std::move(Err);
6298 return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
6299 }
6300
VisitNullStmt(NullStmt * S)6301 ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
6302 ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6303 if (!ToSemiLocOrErr)
6304 return ToSemiLocOrErr.takeError();
6305 return new (Importer.getToContext()) NullStmt(
6306 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6307 }
6308
VisitCompoundStmt(CompoundStmt * S)6309 ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
6310 SmallVector<Stmt *, 8> ToStmts(S->size());
6311
6312 if (Error Err = ImportContainerChecked(S->body(), ToStmts))
6313 return std::move(Err);
6314
6315 ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6316 if (!ToLBracLocOrErr)
6317 return ToLBracLocOrErr.takeError();
6318
6319 ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6320 if (!ToRBracLocOrErr)
6321 return ToRBracLocOrErr.takeError();
6322
6323 return CompoundStmt::Create(
6324 Importer.getToContext(), ToStmts,
6325 *ToLBracLocOrErr, *ToRBracLocOrErr);
6326 }
6327
VisitCaseStmt(CaseStmt * S)6328 ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
6329
6330 Error Err = Error::success();
6331 auto ToLHS = importChecked(Err, S->getLHS());
6332 auto ToRHS = importChecked(Err, S->getRHS());
6333 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6334 auto ToCaseLoc = importChecked(Err, S->getCaseLoc());
6335 auto ToEllipsisLoc = importChecked(Err, S->getEllipsisLoc());
6336 auto ToColonLoc = importChecked(Err, S->getColonLoc());
6337 if (Err)
6338 return std::move(Err);
6339
6340 auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS,
6341 ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6342 ToStmt->setSubStmt(ToSubStmt);
6343
6344 return ToStmt;
6345 }
6346
VisitDefaultStmt(DefaultStmt * S)6347 ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
6348
6349 Error Err = Error::success();
6350 auto ToDefaultLoc = importChecked(Err, S->getDefaultLoc());
6351 auto ToColonLoc = importChecked(Err, S->getColonLoc());
6352 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6353 if (Err)
6354 return std::move(Err);
6355
6356 return new (Importer.getToContext()) DefaultStmt(
6357 ToDefaultLoc, ToColonLoc, ToSubStmt);
6358 }
6359
VisitLabelStmt(LabelStmt * S)6360 ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
6361
6362 Error Err = Error::success();
6363 auto ToIdentLoc = importChecked(Err, S->getIdentLoc());
6364 auto ToLabelDecl = importChecked(Err, S->getDecl());
6365 auto ToSubStmt = importChecked(Err, S->getSubStmt());
6366 if (Err)
6367 return std::move(Err);
6368
6369 return new (Importer.getToContext()) LabelStmt(
6370 ToIdentLoc, ToLabelDecl, ToSubStmt);
6371 }
6372
VisitAttributedStmt(AttributedStmt * S)6373 ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
6374 ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6375 if (!ToAttrLocOrErr)
6376 return ToAttrLocOrErr.takeError();
6377 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
6378 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
6379 if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
6380 return std::move(Err);
6381 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6382 if (!ToSubStmtOrErr)
6383 return ToSubStmtOrErr.takeError();
6384
6385 return AttributedStmt::Create(
6386 Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6387 }
6388
VisitIfStmt(IfStmt * S)6389 ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
6390
6391 Error Err = Error::success();
6392 auto ToIfLoc = importChecked(Err, S->getIfLoc());
6393 auto ToInit = importChecked(Err, S->getInit());
6394 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6395 auto ToCond = importChecked(Err, S->getCond());
6396 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6397 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6398 auto ToThen = importChecked(Err, S->getThen());
6399 auto ToElseLoc = importChecked(Err, S->getElseLoc());
6400 auto ToElse = importChecked(Err, S->getElse());
6401 if (Err)
6402 return std::move(Err);
6403
6404 return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->getStatementKind(),
6405 ToInit, ToConditionVariable, ToCond, ToLParenLoc,
6406 ToRParenLoc, ToThen, ToElseLoc, ToElse);
6407 }
6408
VisitSwitchStmt(SwitchStmt * S)6409 ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
6410
6411 Error Err = Error::success();
6412 auto ToInit = importChecked(Err, S->getInit());
6413 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6414 auto ToCond = importChecked(Err, S->getCond());
6415 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6416 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6417 auto ToBody = importChecked(Err, S->getBody());
6418 auto ToSwitchLoc = importChecked(Err, S->getSwitchLoc());
6419 if (Err)
6420 return std::move(Err);
6421
6422 auto *ToStmt =
6423 SwitchStmt::Create(Importer.getToContext(), ToInit, ToConditionVariable,
6424 ToCond, ToLParenLoc, ToRParenLoc);
6425 ToStmt->setBody(ToBody);
6426 ToStmt->setSwitchLoc(ToSwitchLoc);
6427
6428 // Now we have to re-chain the cases.
6429 SwitchCase *LastChainedSwitchCase = nullptr;
6430 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
6431 SC = SC->getNextSwitchCase()) {
6432 Expected<SwitchCase *> ToSCOrErr = import(SC);
6433 if (!ToSCOrErr)
6434 return ToSCOrErr.takeError();
6435 if (LastChainedSwitchCase)
6436 LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
6437 else
6438 ToStmt->setSwitchCaseList(*ToSCOrErr);
6439 LastChainedSwitchCase = *ToSCOrErr;
6440 }
6441
6442 return ToStmt;
6443 }
6444
VisitWhileStmt(WhileStmt * S)6445 ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
6446
6447 Error Err = Error::success();
6448 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6449 auto ToCond = importChecked(Err, S->getCond());
6450 auto ToBody = importChecked(Err, S->getBody());
6451 auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6452 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6453 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6454 if (Err)
6455 return std::move(Err);
6456
6457 return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond,
6458 ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6459 }
6460
VisitDoStmt(DoStmt * S)6461 ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
6462
6463 Error Err = Error::success();
6464 auto ToBody = importChecked(Err, S->getBody());
6465 auto ToCond = importChecked(Err, S->getCond());
6466 auto ToDoLoc = importChecked(Err, S->getDoLoc());
6467 auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6468 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6469 if (Err)
6470 return std::move(Err);
6471
6472 return new (Importer.getToContext()) DoStmt(
6473 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
6474 }
6475
VisitForStmt(ForStmt * S)6476 ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
6477
6478 Error Err = Error::success();
6479 auto ToInit = importChecked(Err, S->getInit());
6480 auto ToCond = importChecked(Err, S->getCond());
6481 auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6482 auto ToInc = importChecked(Err, S->getInc());
6483 auto ToBody = importChecked(Err, S->getBody());
6484 auto ToForLoc = importChecked(Err, S->getForLoc());
6485 auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6486 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6487 if (Err)
6488 return std::move(Err);
6489
6490 return new (Importer.getToContext()) ForStmt(
6491 Importer.getToContext(),
6492 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
6493 ToRParenLoc);
6494 }
6495
VisitGotoStmt(GotoStmt * S)6496 ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
6497
6498 Error Err = Error::success();
6499 auto ToLabel = importChecked(Err, S->getLabel());
6500 auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6501 auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
6502 if (Err)
6503 return std::move(Err);
6504
6505 return new (Importer.getToContext()) GotoStmt(
6506 ToLabel, ToGotoLoc, ToLabelLoc);
6507 }
6508
VisitIndirectGotoStmt(IndirectGotoStmt * S)6509 ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
6510
6511 Error Err = Error::success();
6512 auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6513 auto ToStarLoc = importChecked(Err, S->getStarLoc());
6514 auto ToTarget = importChecked(Err, S->getTarget());
6515 if (Err)
6516 return std::move(Err);
6517
6518 return new (Importer.getToContext()) IndirectGotoStmt(
6519 ToGotoLoc, ToStarLoc, ToTarget);
6520 }
6521
VisitContinueStmt(ContinueStmt * S)6522 ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
6523 ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
6524 if (!ToContinueLocOrErr)
6525 return ToContinueLocOrErr.takeError();
6526 return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
6527 }
6528
VisitBreakStmt(BreakStmt * S)6529 ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
6530 auto ToBreakLocOrErr = import(S->getBreakLoc());
6531 if (!ToBreakLocOrErr)
6532 return ToBreakLocOrErr.takeError();
6533 return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
6534 }
6535
VisitReturnStmt(ReturnStmt * S)6536 ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
6537
6538 Error Err = Error::success();
6539 auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
6540 auto ToRetValue = importChecked(Err, S->getRetValue());
6541 auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
6542 if (Err)
6543 return std::move(Err);
6544
6545 return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue,
6546 ToNRVOCandidate);
6547 }
6548
VisitCXXCatchStmt(CXXCatchStmt * S)6549 ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
6550
6551 Error Err = Error::success();
6552 auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
6553 auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
6554 auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());
6555 if (Err)
6556 return std::move(Err);
6557
6558 return new (Importer.getToContext()) CXXCatchStmt (
6559 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
6560 }
6561
VisitCXXTryStmt(CXXTryStmt * S)6562 ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
6563 ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
6564 if (!ToTryLocOrErr)
6565 return ToTryLocOrErr.takeError();
6566
6567 ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
6568 if (!ToTryBlockOrErr)
6569 return ToTryBlockOrErr.takeError();
6570
6571 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
6572 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
6573 CXXCatchStmt *FromHandler = S->getHandler(HI);
6574 if (auto ToHandlerOrErr = import(FromHandler))
6575 ToHandlers[HI] = *ToHandlerOrErr;
6576 else
6577 return ToHandlerOrErr.takeError();
6578 }
6579
6580 return CXXTryStmt::Create(
6581 Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6582 }
6583
VisitCXXForRangeStmt(CXXForRangeStmt * S)6584 ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
6585
6586 Error Err = Error::success();
6587 auto ToInit = importChecked(Err, S->getInit());
6588 auto ToRangeStmt = importChecked(Err, S->getRangeStmt());
6589 auto ToBeginStmt = importChecked(Err, S->getBeginStmt());
6590 auto ToEndStmt = importChecked(Err, S->getEndStmt());
6591 auto ToCond = importChecked(Err, S->getCond());
6592 auto ToInc = importChecked(Err, S->getInc());
6593 auto ToLoopVarStmt = importChecked(Err, S->getLoopVarStmt());
6594 auto ToBody = importChecked(Err, S->getBody());
6595 auto ToForLoc = importChecked(Err, S->getForLoc());
6596 auto ToCoawaitLoc = importChecked(Err, S->getCoawaitLoc());
6597 auto ToColonLoc = importChecked(Err, S->getColonLoc());
6598 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6599 if (Err)
6600 return std::move(Err);
6601
6602 return new (Importer.getToContext()) CXXForRangeStmt(
6603 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
6604 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
6605 }
6606
6607 ExpectedStmt
VisitObjCForCollectionStmt(ObjCForCollectionStmt * S)6608 ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
6609 Error Err = Error::success();
6610 auto ToElement = importChecked(Err, S->getElement());
6611 auto ToCollection = importChecked(Err, S->getCollection());
6612 auto ToBody = importChecked(Err, S->getBody());
6613 auto ToForLoc = importChecked(Err, S->getForLoc());
6614 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6615 if (Err)
6616 return std::move(Err);
6617
6618 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
6619 ToCollection,
6620 ToBody,
6621 ToForLoc,
6622 ToRParenLoc);
6623 }
6624
VisitObjCAtCatchStmt(ObjCAtCatchStmt * S)6625 ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6626
6627 Error Err = Error::success();
6628 auto ToAtCatchLoc = importChecked(Err, S->getAtCatchLoc());
6629 auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6630 auto ToCatchParamDecl = importChecked(Err, S->getCatchParamDecl());
6631 auto ToCatchBody = importChecked(Err, S->getCatchBody());
6632 if (Err)
6633 return std::move(Err);
6634
6635 return new (Importer.getToContext()) ObjCAtCatchStmt (
6636 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
6637 }
6638
VisitObjCAtFinallyStmt(ObjCAtFinallyStmt * S)6639 ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6640 ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
6641 if (!ToAtFinallyLocOrErr)
6642 return ToAtFinallyLocOrErr.takeError();
6643 ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
6644 if (!ToAtFinallyStmtOrErr)
6645 return ToAtFinallyStmtOrErr.takeError();
6646 return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
6647 *ToAtFinallyStmtOrErr);
6648 }
6649
VisitObjCAtTryStmt(ObjCAtTryStmt * S)6650 ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
6651
6652 Error Err = Error::success();
6653 auto ToAtTryLoc = importChecked(Err, S->getAtTryLoc());
6654 auto ToTryBody = importChecked(Err, S->getTryBody());
6655 auto ToFinallyStmt = importChecked(Err, S->getFinallyStmt());
6656 if (Err)
6657 return std::move(Err);
6658
6659 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
6660 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
6661 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
6662 if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
6663 ToCatchStmts[CI] = *ToCatchStmtOrErr;
6664 else
6665 return ToCatchStmtOrErr.takeError();
6666 }
6667
6668 return ObjCAtTryStmt::Create(Importer.getToContext(),
6669 ToAtTryLoc, ToTryBody,
6670 ToCatchStmts.begin(), ToCatchStmts.size(),
6671 ToFinallyStmt);
6672 }
6673
6674 ExpectedStmt
VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt * S)6675 ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
6676
6677 Error Err = Error::success();
6678 auto ToAtSynchronizedLoc = importChecked(Err, S->getAtSynchronizedLoc());
6679 auto ToSynchExpr = importChecked(Err, S->getSynchExpr());
6680 auto ToSynchBody = importChecked(Err, S->getSynchBody());
6681 if (Err)
6682 return std::move(Err);
6683
6684 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
6685 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
6686 }
6687
VisitObjCAtThrowStmt(ObjCAtThrowStmt * S)6688 ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6689 ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
6690 if (!ToThrowLocOrErr)
6691 return ToThrowLocOrErr.takeError();
6692 ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
6693 if (!ToThrowExprOrErr)
6694 return ToThrowExprOrErr.takeError();
6695 return new (Importer.getToContext()) ObjCAtThrowStmt(
6696 *ToThrowLocOrErr, *ToThrowExprOrErr);
6697 }
6698
VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt * S)6699 ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
6700 ObjCAutoreleasePoolStmt *S) {
6701 ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
6702 if (!ToAtLocOrErr)
6703 return ToAtLocOrErr.takeError();
6704 ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6705 if (!ToSubStmtOrErr)
6706 return ToSubStmtOrErr.takeError();
6707 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
6708 *ToSubStmtOrErr);
6709 }
6710
6711 //----------------------------------------------------------------------------
6712 // Import Expressions
6713 //----------------------------------------------------------------------------
VisitExpr(Expr * E)6714 ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
6715 Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
6716 << E->getStmtClassName();
6717 return make_error<ImportError>(ImportError::UnsupportedConstruct);
6718 }
6719
VisitSourceLocExpr(SourceLocExpr * E)6720 ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
6721 Error Err = Error::success();
6722 auto BLoc = importChecked(Err, E->getBeginLoc());
6723 auto RParenLoc = importChecked(Err, E->getEndLoc());
6724 if (Err)
6725 return std::move(Err);
6726 auto ParentContextOrErr = Importer.ImportContext(E->getParentContext());
6727 if (!ParentContextOrErr)
6728 return ParentContextOrErr.takeError();
6729
6730 return new (Importer.getToContext())
6731 SourceLocExpr(Importer.getToContext(), E->getIdentKind(), BLoc, RParenLoc,
6732 *ParentContextOrErr);
6733 }
6734
VisitVAArgExpr(VAArgExpr * E)6735 ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
6736
6737 Error Err = Error::success();
6738 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6739 auto ToSubExpr = importChecked(Err, E->getSubExpr());
6740 auto ToWrittenTypeInfo = importChecked(Err, E->getWrittenTypeInfo());
6741 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6742 auto ToType = importChecked(Err, E->getType());
6743 if (Err)
6744 return std::move(Err);
6745
6746 return new (Importer.getToContext()) VAArgExpr(
6747 ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
6748 E->isMicrosoftABI());
6749 }
6750
VisitChooseExpr(ChooseExpr * E)6751 ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
6752
6753 Error Err = Error::success();
6754 auto ToCond = importChecked(Err, E->getCond());
6755 auto ToLHS = importChecked(Err, E->getLHS());
6756 auto ToRHS = importChecked(Err, E->getRHS());
6757 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6758 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6759 auto ToType = importChecked(Err, E->getType());
6760 if (Err)
6761 return std::move(Err);
6762
6763 ExprValueKind VK = E->getValueKind();
6764 ExprObjectKind OK = E->getObjectKind();
6765
6766 // The value of CondIsTrue only matters if the value is not
6767 // condition-dependent.
6768 bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
6769
6770 return new (Importer.getToContext())
6771 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
6772 ToRParenLoc, CondIsTrue);
6773 }
6774
VisitShuffleVectorExpr(ShuffleVectorExpr * E)6775 ExpectedStmt ASTNodeImporter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
6776 Error Err = Error::success();
6777 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6778 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6779 auto ToType = importChecked(Err, E->getType());
6780 const unsigned NumSubExprs = E->getNumSubExprs();
6781
6782 llvm::SmallVector<Expr *, 8> ToSubExprs;
6783 llvm::ArrayRef<Expr *> FromSubExprs(E->getSubExprs(), NumSubExprs);
6784 ToSubExprs.resize(NumSubExprs);
6785
6786 if ((Err = ImportContainerChecked(FromSubExprs, ToSubExprs)))
6787 return std::move(Err);
6788
6789 return new (Importer.getToContext()) ShuffleVectorExpr(
6790 Importer.getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
6791 }
6792
VisitGNUNullExpr(GNUNullExpr * E)6793 ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
6794 ExpectedType TypeOrErr = import(E->getType());
6795 if (!TypeOrErr)
6796 return TypeOrErr.takeError();
6797
6798 ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
6799 if (!BeginLocOrErr)
6800 return BeginLocOrErr.takeError();
6801
6802 return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6803 }
6804
6805 ExpectedStmt
VisitGenericSelectionExpr(GenericSelectionExpr * E)6806 ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
6807 Error Err = Error::success();
6808 auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
6809 auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
6810 auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
6811 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6812 if (Err)
6813 return std::move(Err);
6814
6815 ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
6816 SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
6817 if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
6818 return std::move(Err);
6819
6820 ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
6821 SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
6822 if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
6823 return std::move(Err);
6824
6825 const ASTContext &ToCtx = Importer.getToContext();
6826 if (E->isResultDependent()) {
6827 return GenericSelectionExpr::Create(
6828 ToCtx, ToGenericLoc, ToControllingExpr,
6829 llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs),
6830 ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack());
6831 }
6832
6833 return GenericSelectionExpr::Create(
6834 ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes),
6835 llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
6836 E->containsUnexpandedParameterPack(), E->getResultIndex());
6837 }
6838
VisitPredefinedExpr(PredefinedExpr * E)6839 ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
6840
6841 Error Err = Error::success();
6842 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6843 auto ToType = importChecked(Err, E->getType());
6844 auto ToFunctionName = importChecked(Err, E->getFunctionName());
6845 if (Err)
6846 return std::move(Err);
6847
6848 return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType,
6849 E->getIdentKind(), ToFunctionName);
6850 }
6851
VisitDeclRefExpr(DeclRefExpr * E)6852 ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
6853
6854 Error Err = Error::success();
6855 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
6856 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
6857 auto ToDecl = importChecked(Err, E->getDecl());
6858 auto ToLocation = importChecked(Err, E->getLocation());
6859 auto ToType = importChecked(Err, E->getType());
6860 if (Err)
6861 return std::move(Err);
6862
6863 NamedDecl *ToFoundD = nullptr;
6864 if (E->getDecl() != E->getFoundDecl()) {
6865 auto FoundDOrErr = import(E->getFoundDecl());
6866 if (!FoundDOrErr)
6867 return FoundDOrErr.takeError();
6868 ToFoundD = *FoundDOrErr;
6869 }
6870
6871 TemplateArgumentListInfo ToTAInfo;
6872 TemplateArgumentListInfo *ToResInfo = nullptr;
6873 if (E->hasExplicitTemplateArgs()) {
6874 if (Error Err =
6875 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6876 E->template_arguments(), ToTAInfo))
6877 return std::move(Err);
6878 ToResInfo = &ToTAInfo;
6879 }
6880
6881 auto *ToE = DeclRefExpr::Create(
6882 Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
6883 E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
6884 E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
6885 if (E->hadMultipleCandidates())
6886 ToE->setHadMultipleCandidates(true);
6887 return ToE;
6888 }
6889
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)6890 ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
6891 ExpectedType TypeOrErr = import(E->getType());
6892 if (!TypeOrErr)
6893 return TypeOrErr.takeError();
6894
6895 return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
6896 }
6897
VisitDesignatedInitExpr(DesignatedInitExpr * E)6898 ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
6899 ExpectedExpr ToInitOrErr = import(E->getInit());
6900 if (!ToInitOrErr)
6901 return ToInitOrErr.takeError();
6902
6903 ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
6904 if (!ToEqualOrColonLocOrErr)
6905 return ToEqualOrColonLocOrErr.takeError();
6906
6907 SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
6908 // List elements from the second, the first is Init itself
6909 for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
6910 if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
6911 ToIndexExprs[I - 1] = *ToArgOrErr;
6912 else
6913 return ToArgOrErr.takeError();
6914 }
6915
6916 SmallVector<Designator, 4> ToDesignators(E->size());
6917 if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
6918 return std::move(Err);
6919
6920 return DesignatedInitExpr::Create(
6921 Importer.getToContext(), ToDesignators,
6922 ToIndexExprs, *ToEqualOrColonLocOrErr,
6923 E->usesGNUSyntax(), *ToInitOrErr);
6924 }
6925
6926 ExpectedStmt
VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr * E)6927 ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
6928 ExpectedType ToTypeOrErr = import(E->getType());
6929 if (!ToTypeOrErr)
6930 return ToTypeOrErr.takeError();
6931
6932 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6933 if (!ToLocationOrErr)
6934 return ToLocationOrErr.takeError();
6935
6936 return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
6937 *ToTypeOrErr, *ToLocationOrErr);
6938 }
6939
VisitIntegerLiteral(IntegerLiteral * E)6940 ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
6941 ExpectedType ToTypeOrErr = import(E->getType());
6942 if (!ToTypeOrErr)
6943 return ToTypeOrErr.takeError();
6944
6945 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6946 if (!ToLocationOrErr)
6947 return ToLocationOrErr.takeError();
6948
6949 return IntegerLiteral::Create(
6950 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6951 }
6952
6953
VisitFloatingLiteral(FloatingLiteral * E)6954 ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
6955 ExpectedType ToTypeOrErr = import(E->getType());
6956 if (!ToTypeOrErr)
6957 return ToTypeOrErr.takeError();
6958
6959 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6960 if (!ToLocationOrErr)
6961 return ToLocationOrErr.takeError();
6962
6963 return FloatingLiteral::Create(
6964 Importer.getToContext(), E->getValue(), E->isExact(),
6965 *ToTypeOrErr, *ToLocationOrErr);
6966 }
6967
VisitImaginaryLiteral(ImaginaryLiteral * E)6968 ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
6969 auto ToTypeOrErr = import(E->getType());
6970 if (!ToTypeOrErr)
6971 return ToTypeOrErr.takeError();
6972
6973 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
6974 if (!ToSubExprOrErr)
6975 return ToSubExprOrErr.takeError();
6976
6977 return new (Importer.getToContext()) ImaginaryLiteral(
6978 *ToSubExprOrErr, *ToTypeOrErr);
6979 }
6980
VisitFixedPointLiteral(FixedPointLiteral * E)6981 ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
6982 auto ToTypeOrErr = import(E->getType());
6983 if (!ToTypeOrErr)
6984 return ToTypeOrErr.takeError();
6985
6986 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6987 if (!ToLocationOrErr)
6988 return ToLocationOrErr.takeError();
6989
6990 return new (Importer.getToContext()) FixedPointLiteral(
6991 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
6992 Importer.getToContext().getFixedPointScale(*ToTypeOrErr));
6993 }
6994
VisitCharacterLiteral(CharacterLiteral * E)6995 ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
6996 ExpectedType ToTypeOrErr = import(E->getType());
6997 if (!ToTypeOrErr)
6998 return ToTypeOrErr.takeError();
6999
7000 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7001 if (!ToLocationOrErr)
7002 return ToLocationOrErr.takeError();
7003
7004 return new (Importer.getToContext()) CharacterLiteral(
7005 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7006 }
7007
VisitStringLiteral(StringLiteral * E)7008 ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
7009 ExpectedType ToTypeOrErr = import(E->getType());
7010 if (!ToTypeOrErr)
7011 return ToTypeOrErr.takeError();
7012
7013 SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
7014 if (Error Err = ImportArrayChecked(
7015 E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
7016 return std::move(Err);
7017
7018 return StringLiteral::Create(
7019 Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
7020 *ToTypeOrErr, ToLocations.data(), ToLocations.size());
7021 }
7022
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)7023 ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
7024
7025 Error Err = Error::success();
7026 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7027 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7028 auto ToType = importChecked(Err, E->getType());
7029 auto ToInitializer = importChecked(Err, E->getInitializer());
7030 if (Err)
7031 return std::move(Err);
7032
7033 return new (Importer.getToContext()) CompoundLiteralExpr(
7034 ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
7035 ToInitializer, E->isFileScope());
7036 }
7037
VisitAtomicExpr(AtomicExpr * E)7038 ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
7039
7040 Error Err = Error::success();
7041 auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
7042 auto ToType = importChecked(Err, E->getType());
7043 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7044 if (Err)
7045 return std::move(Err);
7046
7047 SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
7048 if (Error Err = ImportArrayChecked(
7049 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
7050 ToExprs.begin()))
7051 return std::move(Err);
7052
7053 return new (Importer.getToContext()) AtomicExpr(
7054
7055 ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
7056 }
7057
VisitAddrLabelExpr(AddrLabelExpr * E)7058 ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
7059 Error Err = Error::success();
7060 auto ToAmpAmpLoc = importChecked(Err, E->getAmpAmpLoc());
7061 auto ToLabelLoc = importChecked(Err, E->getLabelLoc());
7062 auto ToLabel = importChecked(Err, E->getLabel());
7063 auto ToType = importChecked(Err, E->getType());
7064 if (Err)
7065 return std::move(Err);
7066
7067 return new (Importer.getToContext()) AddrLabelExpr(
7068 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7069 }
VisitConstantExpr(ConstantExpr * E)7070 ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
7071 Error Err = Error::success();
7072 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7073 auto ToResult = importChecked(Err, E->getAPValueResult());
7074 if (Err)
7075 return std::move(Err);
7076
7077 return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, ToResult);
7078 }
VisitParenExpr(ParenExpr * E)7079 ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
7080 Error Err = Error::success();
7081 auto ToLParen = importChecked(Err, E->getLParen());
7082 auto ToRParen = importChecked(Err, E->getRParen());
7083 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7084 if (Err)
7085 return std::move(Err);
7086
7087 return new (Importer.getToContext())
7088 ParenExpr(ToLParen, ToRParen, ToSubExpr);
7089 }
7090
VisitParenListExpr(ParenListExpr * E)7091 ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
7092 SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
7093 if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
7094 return std::move(Err);
7095
7096 ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
7097 if (!ToLParenLocOrErr)
7098 return ToLParenLocOrErr.takeError();
7099
7100 ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
7101 if (!ToRParenLocOrErr)
7102 return ToRParenLocOrErr.takeError();
7103
7104 return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr,
7105 ToExprs, *ToRParenLocOrErr);
7106 }
7107
VisitStmtExpr(StmtExpr * E)7108 ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
7109 Error Err = Error::success();
7110 auto ToSubStmt = importChecked(Err, E->getSubStmt());
7111 auto ToType = importChecked(Err, E->getType());
7112 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7113 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7114 if (Err)
7115 return std::move(Err);
7116
7117 return new (Importer.getToContext())
7118 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
7119 E->getTemplateDepth());
7120 }
7121
VisitUnaryOperator(UnaryOperator * E)7122 ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
7123 Error Err = Error::success();
7124 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7125 auto ToType = importChecked(Err, E->getType());
7126 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7127 if (Err)
7128 return std::move(Err);
7129
7130 return UnaryOperator::Create(
7131 Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
7132 E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
7133 E->getFPOptionsOverride());
7134 }
7135
7136 ExpectedStmt
7137
VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)7138 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
7139 Error Err = Error::success();
7140 auto ToType = importChecked(Err, E->getType());
7141 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7142 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7143 if (Err)
7144 return std::move(Err);
7145
7146 if (E->isArgumentType()) {
7147 Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
7148 import(E->getArgumentTypeInfo());
7149 if (!ToArgumentTypeInfoOrErr)
7150 return ToArgumentTypeInfoOrErr.takeError();
7151
7152 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
7153 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
7154 ToRParenLoc);
7155 }
7156
7157 ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
7158 if (!ToArgumentExprOrErr)
7159 return ToArgumentExprOrErr.takeError();
7160
7161 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
7162 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
7163 }
7164
VisitBinaryOperator(BinaryOperator * E)7165 ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
7166 Error Err = Error::success();
7167 auto ToLHS = importChecked(Err, E->getLHS());
7168 auto ToRHS = importChecked(Err, E->getRHS());
7169 auto ToType = importChecked(Err, E->getType());
7170 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7171 if (Err)
7172 return std::move(Err);
7173
7174 return BinaryOperator::Create(
7175 Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7176 E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7177 E->getFPFeatures(Importer.getFromContext().getLangOpts()));
7178 }
7179
VisitConditionalOperator(ConditionalOperator * E)7180 ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
7181 Error Err = Error::success();
7182 auto ToCond = importChecked(Err, E->getCond());
7183 auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
7184 auto ToLHS = importChecked(Err, E->getLHS());
7185 auto ToColonLoc = importChecked(Err, E->getColonLoc());
7186 auto ToRHS = importChecked(Err, E->getRHS());
7187 auto ToType = importChecked(Err, E->getType());
7188 if (Err)
7189 return std::move(Err);
7190
7191 return new (Importer.getToContext()) ConditionalOperator(
7192 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
7193 E->getValueKind(), E->getObjectKind());
7194 }
7195
7196 ExpectedStmt
VisitBinaryConditionalOperator(BinaryConditionalOperator * E)7197 ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
7198 Error Err = Error::success();
7199 auto ToCommon = importChecked(Err, E->getCommon());
7200 auto ToOpaqueValue = importChecked(Err, E->getOpaqueValue());
7201 auto ToCond = importChecked(Err, E->getCond());
7202 auto ToTrueExpr = importChecked(Err, E->getTrueExpr());
7203 auto ToFalseExpr = importChecked(Err, E->getFalseExpr());
7204 auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
7205 auto ToColonLoc = importChecked(Err, E->getColonLoc());
7206 auto ToType = importChecked(Err, E->getType());
7207 if (Err)
7208 return std::move(Err);
7209
7210 return new (Importer.getToContext()) BinaryConditionalOperator(
7211 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
7212 ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
7213 E->getObjectKind());
7214 }
7215
VisitArrayTypeTraitExpr(ArrayTypeTraitExpr * E)7216 ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
7217 Error Err = Error::success();
7218 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7219 auto ToQueriedTypeSourceInfo =
7220 importChecked(Err, E->getQueriedTypeSourceInfo());
7221 auto ToDimensionExpression = importChecked(Err, E->getDimensionExpression());
7222 auto ToEndLoc = importChecked(Err, E->getEndLoc());
7223 auto ToType = importChecked(Err, E->getType());
7224 if (Err)
7225 return std::move(Err);
7226
7227 return new (Importer.getToContext()) ArrayTypeTraitExpr(
7228 ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
7229 ToDimensionExpression, ToEndLoc, ToType);
7230 }
7231
VisitExpressionTraitExpr(ExpressionTraitExpr * E)7232 ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
7233 Error Err = Error::success();
7234 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7235 auto ToQueriedExpression = importChecked(Err, E->getQueriedExpression());
7236 auto ToEndLoc = importChecked(Err, E->getEndLoc());
7237 auto ToType = importChecked(Err, E->getType());
7238 if (Err)
7239 return std::move(Err);
7240
7241 return new (Importer.getToContext()) ExpressionTraitExpr(
7242 ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
7243 ToEndLoc, ToType);
7244 }
7245
VisitOpaqueValueExpr(OpaqueValueExpr * E)7246 ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
7247 Error Err = Error::success();
7248 auto ToLocation = importChecked(Err, E->getLocation());
7249 auto ToType = importChecked(Err, E->getType());
7250 auto ToSourceExpr = importChecked(Err, E->getSourceExpr());
7251 if (Err)
7252 return std::move(Err);
7253
7254 return new (Importer.getToContext()) OpaqueValueExpr(
7255 ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
7256 }
7257
VisitArraySubscriptExpr(ArraySubscriptExpr * E)7258 ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
7259 Error Err = Error::success();
7260 auto ToLHS = importChecked(Err, E->getLHS());
7261 auto ToRHS = importChecked(Err, E->getRHS());
7262 auto ToType = importChecked(Err, E->getType());
7263 auto ToRBracketLoc = importChecked(Err, E->getRBracketLoc());
7264 if (Err)
7265 return std::move(Err);
7266
7267 return new (Importer.getToContext()) ArraySubscriptExpr(
7268 ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
7269 ToRBracketLoc);
7270 }
7271
7272 ExpectedStmt
VisitCompoundAssignOperator(CompoundAssignOperator * E)7273 ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
7274 Error Err = Error::success();
7275 auto ToLHS = importChecked(Err, E->getLHS());
7276 auto ToRHS = importChecked(Err, E->getRHS());
7277 auto ToType = importChecked(Err, E->getType());
7278 auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
7279 auto ToComputationResultType =
7280 importChecked(Err, E->getComputationResultType());
7281 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7282 if (Err)
7283 return std::move(Err);
7284
7285 return CompoundAssignOperator::Create(
7286 Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7287 E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7288 E->getFPFeatures(Importer.getFromContext().getLangOpts()),
7289 ToComputationLHSType, ToComputationResultType);
7290 }
7291
7292 Expected<CXXCastPath>
ImportCastPath(CastExpr * CE)7293 ASTNodeImporter::ImportCastPath(CastExpr *CE) {
7294 CXXCastPath Path;
7295 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
7296 if (auto SpecOrErr = import(*I))
7297 Path.push_back(*SpecOrErr);
7298 else
7299 return SpecOrErr.takeError();
7300 }
7301 return Path;
7302 }
7303
VisitImplicitCastExpr(ImplicitCastExpr * E)7304 ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
7305 ExpectedType ToTypeOrErr = import(E->getType());
7306 if (!ToTypeOrErr)
7307 return ToTypeOrErr.takeError();
7308
7309 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7310 if (!ToSubExprOrErr)
7311 return ToSubExprOrErr.takeError();
7312
7313 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7314 if (!ToBasePathOrErr)
7315 return ToBasePathOrErr.takeError();
7316
7317 return ImplicitCastExpr::Create(
7318 Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
7319 &(*ToBasePathOrErr), E->getValueKind(), E->getFPFeatures());
7320 }
7321
VisitExplicitCastExpr(ExplicitCastExpr * E)7322 ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
7323 Error Err = Error::success();
7324 auto ToType = importChecked(Err, E->getType());
7325 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7326 auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7327 if (Err)
7328 return std::move(Err);
7329
7330 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7331 if (!ToBasePathOrErr)
7332 return ToBasePathOrErr.takeError();
7333 CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
7334
7335 switch (E->getStmtClass()) {
7336 case Stmt::CStyleCastExprClass: {
7337 auto *CCE = cast<CStyleCastExpr>(E);
7338 ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7339 if (!ToLParenLocOrErr)
7340 return ToLParenLocOrErr.takeError();
7341 ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
7342 if (!ToRParenLocOrErr)
7343 return ToRParenLocOrErr.takeError();
7344 return CStyleCastExpr::Create(
7345 Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(),
7346 ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7347 *ToLParenLocOrErr, *ToRParenLocOrErr);
7348 }
7349
7350 case Stmt::CXXFunctionalCastExprClass: {
7351 auto *FCE = cast<CXXFunctionalCastExpr>(E);
7352 ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
7353 if (!ToLParenLocOrErr)
7354 return ToLParenLocOrErr.takeError();
7355 ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
7356 if (!ToRParenLocOrErr)
7357 return ToRParenLocOrErr.takeError();
7358 return CXXFunctionalCastExpr::Create(
7359 Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten,
7360 E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7361 *ToLParenLocOrErr, *ToRParenLocOrErr);
7362 }
7363
7364 case Stmt::ObjCBridgedCastExprClass: {
7365 auto *OCE = cast<ObjCBridgedCastExpr>(E);
7366 ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
7367 if (!ToLParenLocOrErr)
7368 return ToLParenLocOrErr.takeError();
7369 ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
7370 if (!ToBridgeKeywordLocOrErr)
7371 return ToBridgeKeywordLocOrErr.takeError();
7372 return new (Importer.getToContext()) ObjCBridgedCastExpr(
7373 *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
7374 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
7375 }
7376 default:
7377 llvm_unreachable("Cast expression of unsupported type!");
7378 return make_error<ImportError>(ImportError::UnsupportedConstruct);
7379 }
7380 }
7381
VisitOffsetOfExpr(OffsetOfExpr * E)7382 ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
7383 SmallVector<OffsetOfNode, 4> ToNodes;
7384 for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
7385 const OffsetOfNode &FromNode = E->getComponent(I);
7386
7387 SourceLocation ToBeginLoc, ToEndLoc;
7388
7389 if (FromNode.getKind() != OffsetOfNode::Base) {
7390 Error Err = Error::success();
7391 ToBeginLoc = importChecked(Err, FromNode.getBeginLoc());
7392 ToEndLoc = importChecked(Err, FromNode.getEndLoc());
7393 if (Err)
7394 return std::move(Err);
7395 }
7396
7397 switch (FromNode.getKind()) {
7398 case OffsetOfNode::Array:
7399 ToNodes.push_back(
7400 OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
7401 break;
7402 case OffsetOfNode::Base: {
7403 auto ToBSOrErr = import(FromNode.getBase());
7404 if (!ToBSOrErr)
7405 return ToBSOrErr.takeError();
7406 ToNodes.push_back(OffsetOfNode(*ToBSOrErr));
7407 break;
7408 }
7409 case OffsetOfNode::Field: {
7410 auto ToFieldOrErr = import(FromNode.getField());
7411 if (!ToFieldOrErr)
7412 return ToFieldOrErr.takeError();
7413 ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
7414 break;
7415 }
7416 case OffsetOfNode::Identifier: {
7417 IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName());
7418 ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
7419 break;
7420 }
7421 }
7422 }
7423
7424 SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
7425 for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
7426 ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
7427 if (!ToIndexExprOrErr)
7428 return ToIndexExprOrErr.takeError();
7429 ToExprs[I] = *ToIndexExprOrErr;
7430 }
7431
7432 Error Err = Error::success();
7433 auto ToType = importChecked(Err, E->getType());
7434 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7435 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7436 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7437 if (Err)
7438 return std::move(Err);
7439
7440 return OffsetOfExpr::Create(
7441 Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
7442 ToExprs, ToRParenLoc);
7443 }
7444
VisitCXXNoexceptExpr(CXXNoexceptExpr * E)7445 ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
7446 Error Err = Error::success();
7447 auto ToType = importChecked(Err, E->getType());
7448 auto ToOperand = importChecked(Err, E->getOperand());
7449 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7450 auto ToEndLoc = importChecked(Err, E->getEndLoc());
7451 if (Err)
7452 return std::move(Err);
7453
7454 CanThrowResult ToCanThrow;
7455 if (E->isValueDependent())
7456 ToCanThrow = CT_Dependent;
7457 else
7458 ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
7459
7460 return new (Importer.getToContext()) CXXNoexceptExpr(
7461 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
7462 }
7463
VisitCXXThrowExpr(CXXThrowExpr * E)7464 ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
7465 Error Err = Error::success();
7466 auto ToSubExpr = importChecked(Err, E->getSubExpr());
7467 auto ToType = importChecked(Err, E->getType());
7468 auto ToThrowLoc = importChecked(Err, E->getThrowLoc());
7469 if (Err)
7470 return std::move(Err);
7471
7472 return new (Importer.getToContext()) CXXThrowExpr(
7473 ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
7474 }
7475
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * E)7476 ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
7477 ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
7478 if (!ToUsedLocOrErr)
7479 return ToUsedLocOrErr.takeError();
7480
7481 auto ToParamOrErr = import(E->getParam());
7482 if (!ToParamOrErr)
7483 return ToParamOrErr.takeError();
7484
7485 auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
7486 if (!UsedContextOrErr)
7487 return UsedContextOrErr.takeError();
7488
7489 // Import the default arg if it was not imported yet.
7490 // This is needed because it can happen that during the import of the
7491 // default expression (from VisitParmVarDecl) the same ParmVarDecl is
7492 // encountered here. The default argument for a ParmVarDecl is set in the
7493 // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
7494 // see VisitParmVarDecl).
7495 ParmVarDecl *ToParam = *ToParamOrErr;
7496 if (!ToParam->getDefaultArg()) {
7497 Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
7498 assert(FromParam && "ParmVarDecl was not imported?");
7499
7500 if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
7501 return std::move(Err);
7502 }
7503
7504 return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
7505 *ToParamOrErr, *UsedContextOrErr);
7506 }
7507
7508 ExpectedStmt
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)7509 ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
7510 Error Err = Error::success();
7511 auto ToType = importChecked(Err, E->getType());
7512 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7513 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7514 if (Err)
7515 return std::move(Err);
7516
7517 return new (Importer.getToContext()) CXXScalarValueInitExpr(
7518 ToType, ToTypeSourceInfo, ToRParenLoc);
7519 }
7520
7521 ExpectedStmt
VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr * E)7522 ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
7523 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7524 if (!ToSubExprOrErr)
7525 return ToSubExprOrErr.takeError();
7526
7527 auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
7528 if (!ToDtorOrErr)
7529 return ToDtorOrErr.takeError();
7530
7531 ASTContext &ToCtx = Importer.getToContext();
7532 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr);
7533 return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr);
7534 }
7535
7536 ExpectedStmt
7537
VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr * E)7538 ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
7539 Error Err = Error::success();
7540 auto ToConstructor = importChecked(Err, E->getConstructor());
7541 auto ToType = importChecked(Err, E->getType());
7542 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7543 auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7544 if (Err)
7545 return std::move(Err);
7546
7547 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7548 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7549 return std::move(Err);
7550
7551 return CXXTemporaryObjectExpr::Create(
7552 Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
7553 ToParenOrBraceRange, E->hadMultipleCandidates(),
7554 E->isListInitialization(), E->isStdInitListInitialization(),
7555 E->requiresZeroInitialization());
7556 }
7557
VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl * D)7558 ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
7559 LifetimeExtendedTemporaryDecl *D) {
7560 DeclContext *DC, *LexicalDC;
7561 if (Error Err = ImportDeclContext(D, DC, LexicalDC))
7562 return std::move(Err);
7563
7564 Error Err = Error::success();
7565 auto Temporary = importChecked(Err, D->getTemporaryExpr());
7566 auto ExtendingDecl = importChecked(Err, D->getExtendingDecl());
7567 if (Err)
7568 return std::move(Err);
7569 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
7570
7571 LifetimeExtendedTemporaryDecl *To;
7572 if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl,
7573 D->getManglingNumber()))
7574 return To;
7575
7576 To->setLexicalDeclContext(LexicalDC);
7577 LexicalDC->addDeclInternal(To);
7578 return To;
7579 }
7580
7581 ExpectedStmt
VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr * E)7582 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
7583 Error Err = Error::success();
7584 auto ToType = importChecked(Err, E->getType());
7585 Expr *ToTemporaryExpr = importChecked(
7586 Err, E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
7587 auto ToMaterializedDecl =
7588 importChecked(Err, E->getLifetimeExtendedTemporaryDecl());
7589 if (Err)
7590 return std::move(Err);
7591
7592 if (!ToTemporaryExpr)
7593 ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
7594
7595 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
7596 ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
7597 ToMaterializedDecl);
7598
7599 return ToMTE;
7600 }
7601
VisitPackExpansionExpr(PackExpansionExpr * E)7602 ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
7603 Error Err = Error::success();
7604 auto ToType = importChecked(Err, E->getType());
7605 auto ToPattern = importChecked(Err, E->getPattern());
7606 auto ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
7607 if (Err)
7608 return std::move(Err);
7609
7610 return new (Importer.getToContext()) PackExpansionExpr(
7611 ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions());
7612 }
7613
VisitSizeOfPackExpr(SizeOfPackExpr * E)7614 ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
7615 Error Err = Error::success();
7616 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7617 auto ToPack = importChecked(Err, E->getPack());
7618 auto ToPackLoc = importChecked(Err, E->getPackLoc());
7619 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7620 if (Err)
7621 return std::move(Err);
7622
7623 Optional<unsigned> Length;
7624 if (!E->isValueDependent())
7625 Length = E->getPackLength();
7626
7627 SmallVector<TemplateArgument, 8> ToPartialArguments;
7628 if (E->isPartiallySubstituted()) {
7629 if (Error Err = ImportTemplateArguments(
7630 E->getPartialArguments().data(),
7631 E->getPartialArguments().size(),
7632 ToPartialArguments))
7633 return std::move(Err);
7634 }
7635
7636 return SizeOfPackExpr::Create(
7637 Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
7638 Length, ToPartialArguments);
7639 }
7640
7641
VisitCXXNewExpr(CXXNewExpr * E)7642 ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
7643 Error Err = Error::success();
7644 auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
7645 auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7646 auto ToTypeIdParens = importChecked(Err, E->getTypeIdParens());
7647 auto ToArraySize = importChecked(Err, E->getArraySize());
7648 auto ToInitializer = importChecked(Err, E->getInitializer());
7649 auto ToType = importChecked(Err, E->getType());
7650 auto ToAllocatedTypeSourceInfo =
7651 importChecked(Err, E->getAllocatedTypeSourceInfo());
7652 auto ToSourceRange = importChecked(Err, E->getSourceRange());
7653 auto ToDirectInitRange = importChecked(Err, E->getDirectInitRange());
7654 if (Err)
7655 return std::move(Err);
7656
7657 SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
7658 if (Error Err =
7659 ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
7660 return std::move(Err);
7661
7662 return CXXNewExpr::Create(
7663 Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
7664 ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
7665 ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
7666 ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
7667 ToDirectInitRange);
7668 }
7669
VisitCXXDeleteExpr(CXXDeleteExpr * E)7670 ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
7671 Error Err = Error::success();
7672 auto ToType = importChecked(Err, E->getType());
7673 auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7674 auto ToArgument = importChecked(Err, E->getArgument());
7675 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7676 if (Err)
7677 return std::move(Err);
7678
7679 return new (Importer.getToContext()) CXXDeleteExpr(
7680 ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
7681 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
7682 ToBeginLoc);
7683 }
7684
VisitCXXConstructExpr(CXXConstructExpr * E)7685 ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
7686 Error Err = Error::success();
7687 auto ToType = importChecked(Err, E->getType());
7688 auto ToLocation = importChecked(Err, E->getLocation());
7689 auto ToConstructor = importChecked(Err, E->getConstructor());
7690 auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7691 if (Err)
7692 return std::move(Err);
7693
7694 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
7695 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7696 return std::move(Err);
7697
7698 return CXXConstructExpr::Create(
7699 Importer.getToContext(), ToType, ToLocation, ToConstructor,
7700 E->isElidable(), ToArgs, E->hadMultipleCandidates(),
7701 E->isListInitialization(), E->isStdInitListInitialization(),
7702 E->requiresZeroInitialization(), E->getConstructionKind(),
7703 ToParenOrBraceRange);
7704 }
7705
VisitExprWithCleanups(ExprWithCleanups * E)7706 ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
7707 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7708 if (!ToSubExprOrErr)
7709 return ToSubExprOrErr.takeError();
7710
7711 SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
7712 if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
7713 return std::move(Err);
7714
7715 return ExprWithCleanups::Create(
7716 Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
7717 ToObjects);
7718 }
7719
VisitCXXMemberCallExpr(CXXMemberCallExpr * E)7720 ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
7721 Error Err = Error::success();
7722 auto ToCallee = importChecked(Err, E->getCallee());
7723 auto ToType = importChecked(Err, E->getType());
7724 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7725 if (Err)
7726 return std::move(Err);
7727
7728 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
7729 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7730 return std::move(Err);
7731
7732 return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs,
7733 ToType, E->getValueKind(), ToRParenLoc,
7734 E->getFPFeatures());
7735 }
7736
VisitCXXThisExpr(CXXThisExpr * E)7737 ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
7738 ExpectedType ToTypeOrErr = import(E->getType());
7739 if (!ToTypeOrErr)
7740 return ToTypeOrErr.takeError();
7741
7742 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7743 if (!ToLocationOrErr)
7744 return ToLocationOrErr.takeError();
7745
7746 return new (Importer.getToContext()) CXXThisExpr(
7747 *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7748 }
7749
VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr * E)7750 ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
7751 ExpectedType ToTypeOrErr = import(E->getType());
7752 if (!ToTypeOrErr)
7753 return ToTypeOrErr.takeError();
7754
7755 ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7756 if (!ToLocationOrErr)
7757 return ToLocationOrErr.takeError();
7758
7759 return new (Importer.getToContext()) CXXBoolLiteralExpr(
7760 E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7761 }
7762
VisitMemberExpr(MemberExpr * E)7763 ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
7764 Error Err = Error::success();
7765 auto ToBase = importChecked(Err, E->getBase());
7766 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7767 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7768 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7769 auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
7770 auto ToType = importChecked(Err, E->getType());
7771 auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
7772 auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
7773 auto ToLoc = importChecked(Err, E->getMemberNameInfo().getLoc());
7774 if (Err)
7775 return std::move(Err);
7776
7777 DeclAccessPair ToFoundDecl =
7778 DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
7779
7780 DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
7781
7782 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7783 if (E->hasExplicitTemplateArgs()) {
7784 if (Error Err =
7785 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7786 E->template_arguments(), ToTAInfo))
7787 return std::move(Err);
7788 ResInfo = &ToTAInfo;
7789 }
7790
7791 return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
7792 ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
7793 ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
7794 ResInfo, ToType, E->getValueKind(),
7795 E->getObjectKind(), E->isNonOdrUse());
7796 }
7797
7798 ExpectedStmt
VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr * E)7799 ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
7800 Error Err = Error::success();
7801 auto ToBase = importChecked(Err, E->getBase());
7802 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7803 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7804 auto ToScopeTypeInfo = importChecked(Err, E->getScopeTypeInfo());
7805 auto ToColonColonLoc = importChecked(Err, E->getColonColonLoc());
7806 auto ToTildeLoc = importChecked(Err, E->getTildeLoc());
7807 if (Err)
7808 return std::move(Err);
7809
7810 PseudoDestructorTypeStorage Storage;
7811 if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
7812 IdentifierInfo *ToII = Importer.Import(FromII);
7813 ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
7814 if (!ToDestroyedTypeLocOrErr)
7815 return ToDestroyedTypeLocOrErr.takeError();
7816 Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
7817 } else {
7818 if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
7819 Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
7820 else
7821 return ToTIOrErr.takeError();
7822 }
7823
7824 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
7825 Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
7826 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
7827 }
7828
VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr * E)7829 ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
7830 CXXDependentScopeMemberExpr *E) {
7831 Error Err = Error::success();
7832 auto ToType = importChecked(Err, E->getType());
7833 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7834 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7835 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7836 auto ToFirstQualifierFoundInScope =
7837 importChecked(Err, E->getFirstQualifierFoundInScope());
7838 if (Err)
7839 return std::move(Err);
7840
7841 Expr *ToBase = nullptr;
7842 if (!E->isImplicitAccess()) {
7843 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
7844 ToBase = *ToBaseOrErr;
7845 else
7846 return ToBaseOrErr.takeError();
7847 }
7848
7849 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7850
7851 if (E->hasExplicitTemplateArgs()) {
7852 if (Error Err =
7853 ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7854 E->template_arguments(), ToTAInfo))
7855 return std::move(Err);
7856 ResInfo = &ToTAInfo;
7857 }
7858 auto ToMember = importChecked(Err, E->getMember());
7859 auto ToMemberLoc = importChecked(Err, E->getMemberLoc());
7860 if (Err)
7861 return std::move(Err);
7862 DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);
7863
7864 // Import additional name location/type info.
7865 if (Error Err =
7866 ImportDeclarationNameLoc(E->getMemberNameInfo(), ToMemberNameInfo))
7867 return std::move(Err);
7868
7869 return CXXDependentScopeMemberExpr::Create(
7870 Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
7871 ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
7872 ToMemberNameInfo, ResInfo);
7873 }
7874
7875 ExpectedStmt
VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr * E)7876 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
7877 Error Err = Error::success();
7878 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7879 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7880 auto ToDeclName = importChecked(Err, E->getDeclName());
7881 auto ToNameLoc = importChecked(Err, E->getNameInfo().getLoc());
7882 auto ToLAngleLoc = importChecked(Err, E->getLAngleLoc());
7883 auto ToRAngleLoc = importChecked(Err, E->getRAngleLoc());
7884 if (Err)
7885 return std::move(Err);
7886
7887 DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
7888 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7889 return std::move(Err);
7890
7891 TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
7892 TemplateArgumentListInfo *ResInfo = nullptr;
7893 if (E->hasExplicitTemplateArgs()) {
7894 if (Error Err =
7895 ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
7896 return std::move(Err);
7897 ResInfo = &ToTAInfo;
7898 }
7899
7900 return DependentScopeDeclRefExpr::Create(
7901 Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
7902 ToNameInfo, ResInfo);
7903 }
7904
VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr * E)7905 ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
7906 CXXUnresolvedConstructExpr *E) {
7907 Error Err = Error::success();
7908 auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7909 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7910 auto ToType = importChecked(Err, E->getType());
7911 auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7912 if (Err)
7913 return std::move(Err);
7914
7915 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7916 if (Error Err =
7917 ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
7918 return std::move(Err);
7919
7920 return CXXUnresolvedConstructExpr::Create(
7921 Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
7922 llvm::makeArrayRef(ToArgs), ToRParenLoc);
7923 }
7924
7925 ExpectedStmt
VisitUnresolvedLookupExpr(UnresolvedLookupExpr * E)7926 ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
7927 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
7928 if (!ToNamingClassOrErr)
7929 return ToNamingClassOrErr.takeError();
7930
7931 auto ToQualifierLocOrErr = import(E->getQualifierLoc());
7932 if (!ToQualifierLocOrErr)
7933 return ToQualifierLocOrErr.takeError();
7934
7935 Error Err = Error::success();
7936 auto ToName = importChecked(Err, E->getName());
7937 auto ToNameLoc = importChecked(Err, E->getNameLoc());
7938 if (Err)
7939 return std::move(Err);
7940 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7941
7942 // Import additional name location/type info.
7943 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7944 return std::move(Err);
7945
7946 UnresolvedSet<8> ToDecls;
7947 for (auto *D : E->decls())
7948 if (auto ToDOrErr = import(D))
7949 ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7950 else
7951 return ToDOrErr.takeError();
7952
7953 if (E->hasExplicitTemplateArgs()) {
7954 TemplateArgumentListInfo ToTAInfo;
7955 if (Error Err = ImportTemplateArgumentListInfo(
7956 E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
7957 ToTAInfo))
7958 return std::move(Err);
7959
7960 ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
7961 if (!ToTemplateKeywordLocOrErr)
7962 return ToTemplateKeywordLocOrErr.takeError();
7963
7964 return UnresolvedLookupExpr::Create(
7965 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7966 *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
7967 ToDecls.begin(), ToDecls.end());
7968 }
7969
7970 return UnresolvedLookupExpr::Create(
7971 Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7972 ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(),
7973 ToDecls.end());
7974 }
7975
7976 ExpectedStmt
VisitUnresolvedMemberExpr(UnresolvedMemberExpr * E)7977 ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
7978 Error Err = Error::success();
7979 auto ToType = importChecked(Err, E->getType());
7980 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7981 auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7982 auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7983 auto ToName = importChecked(Err, E->getName());
7984 auto ToNameLoc = importChecked(Err, E->getNameLoc());
7985 if (Err)
7986 return std::move(Err);
7987
7988 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7989 // Import additional name location/type info.
7990 if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7991 return std::move(Err);
7992
7993 UnresolvedSet<8> ToDecls;
7994 for (Decl *D : E->decls())
7995 if (auto ToDOrErr = import(D))
7996 ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7997 else
7998 return ToDOrErr.takeError();
7999
8000 TemplateArgumentListInfo ToTAInfo;
8001 TemplateArgumentListInfo *ResInfo = nullptr;
8002 if (E->hasExplicitTemplateArgs()) {
8003 TemplateArgumentListInfo FromTAInfo;
8004 E->copyTemplateArgumentsInto(FromTAInfo);
8005 if (Error Err = ImportTemplateArgumentListInfo(FromTAInfo, ToTAInfo))
8006 return std::move(Err);
8007 ResInfo = &ToTAInfo;
8008 }
8009
8010 Expr *ToBase = nullptr;
8011 if (!E->isImplicitAccess()) {
8012 if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
8013 ToBase = *ToBaseOrErr;
8014 else
8015 return ToBaseOrErr.takeError();
8016 }
8017
8018 return UnresolvedMemberExpr::Create(
8019 Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType,
8020 E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
8021 ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end());
8022 }
8023
VisitCallExpr(CallExpr * E)8024 ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
8025 Error Err = Error::success();
8026 auto ToCallee = importChecked(Err, E->getCallee());
8027 auto ToType = importChecked(Err, E->getType());
8028 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8029 if (Err)
8030 return std::move(Err);
8031
8032 unsigned NumArgs = E->getNumArgs();
8033 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
8034 if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
8035 return std::move(Err);
8036
8037 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
8038 return CXXOperatorCallExpr::Create(
8039 Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
8040 OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
8041 OCE->getADLCallKind());
8042 }
8043
8044 return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
8045 E->getValueKind(), ToRParenLoc, E->getFPFeatures(),
8046 /*MinNumArgs=*/0, E->getADLCallKind());
8047 }
8048
VisitLambdaExpr(LambdaExpr * E)8049 ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
8050 CXXRecordDecl *FromClass = E->getLambdaClass();
8051 auto ToClassOrErr = import(FromClass);
8052 if (!ToClassOrErr)
8053 return ToClassOrErr.takeError();
8054 CXXRecordDecl *ToClass = *ToClassOrErr;
8055
8056 auto ToCallOpOrErr = import(E->getCallOperator());
8057 if (!ToCallOpOrErr)
8058 return ToCallOpOrErr.takeError();
8059
8060 SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
8061 if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
8062 return std::move(Err);
8063
8064 Error Err = Error::success();
8065 auto ToIntroducerRange = importChecked(Err, E->getIntroducerRange());
8066 auto ToCaptureDefaultLoc = importChecked(Err, E->getCaptureDefaultLoc());
8067 auto ToEndLoc = importChecked(Err, E->getEndLoc());
8068 if (Err)
8069 return std::move(Err);
8070
8071 return LambdaExpr::Create(Importer.getToContext(), ToClass, ToIntroducerRange,
8072 E->getCaptureDefault(), ToCaptureDefaultLoc,
8073 E->hasExplicitParameters(),
8074 E->hasExplicitResultType(), ToCaptureInits,
8075 ToEndLoc, E->containsUnexpandedParameterPack());
8076 }
8077
8078
VisitInitListExpr(InitListExpr * E)8079 ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
8080 Error Err = Error::success();
8081 auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
8082 auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
8083 auto ToType = importChecked(Err, E->getType());
8084 if (Err)
8085 return std::move(Err);
8086
8087 SmallVector<Expr *, 4> ToExprs(E->getNumInits());
8088 if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
8089 return std::move(Err);
8090
8091 ASTContext &ToCtx = Importer.getToContext();
8092 InitListExpr *To = new (ToCtx) InitListExpr(
8093 ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
8094 To->setType(ToType);
8095
8096 if (E->hasArrayFiller()) {
8097 if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
8098 To->setArrayFiller(*ToFillerOrErr);
8099 else
8100 return ToFillerOrErr.takeError();
8101 }
8102
8103 if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
8104 if (auto ToFDOrErr = import(FromFD))
8105 To->setInitializedFieldInUnion(*ToFDOrErr);
8106 else
8107 return ToFDOrErr.takeError();
8108 }
8109
8110 if (InitListExpr *SyntForm = E->getSyntacticForm()) {
8111 if (auto ToSyntFormOrErr = import(SyntForm))
8112 To->setSyntacticForm(*ToSyntFormOrErr);
8113 else
8114 return ToSyntFormOrErr.takeError();
8115 }
8116
8117 // Copy InitListExprBitfields, which are not handled in the ctor of
8118 // InitListExpr.
8119 To->sawArrayRangeDesignator(E->hadArrayRangeDesignator());
8120
8121 return To;
8122 }
8123
VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr * E)8124 ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
8125 CXXStdInitializerListExpr *E) {
8126 ExpectedType ToTypeOrErr = import(E->getType());
8127 if (!ToTypeOrErr)
8128 return ToTypeOrErr.takeError();
8129
8130 ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
8131 if (!ToSubExprOrErr)
8132 return ToSubExprOrErr.takeError();
8133
8134 return new (Importer.getToContext()) CXXStdInitializerListExpr(
8135 *ToTypeOrErr, *ToSubExprOrErr);
8136 }
8137
VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr * E)8138 ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
8139 CXXInheritedCtorInitExpr *E) {
8140 Error Err = Error::success();
8141 auto ToLocation = importChecked(Err, E->getLocation());
8142 auto ToType = importChecked(Err, E->getType());
8143 auto ToConstructor = importChecked(Err, E->getConstructor());
8144 if (Err)
8145 return std::move(Err);
8146
8147 return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
8148 ToLocation, ToType, ToConstructor, E->constructsVBase(),
8149 E->inheritedFromVBase());
8150 }
8151
VisitArrayInitLoopExpr(ArrayInitLoopExpr * E)8152 ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
8153 Error Err = Error::success();
8154 auto ToType = importChecked(Err, E->getType());
8155 auto ToCommonExpr = importChecked(Err, E->getCommonExpr());
8156 auto ToSubExpr = importChecked(Err, E->getSubExpr());
8157 if (Err)
8158 return std::move(Err);
8159
8160 return new (Importer.getToContext()) ArrayInitLoopExpr(
8161 ToType, ToCommonExpr, ToSubExpr);
8162 }
8163
VisitArrayInitIndexExpr(ArrayInitIndexExpr * E)8164 ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
8165 ExpectedType ToTypeOrErr = import(E->getType());
8166 if (!ToTypeOrErr)
8167 return ToTypeOrErr.takeError();
8168 return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
8169 }
8170
VisitCXXDefaultInitExpr(CXXDefaultInitExpr * E)8171 ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
8172 ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
8173 if (!ToBeginLocOrErr)
8174 return ToBeginLocOrErr.takeError();
8175
8176 auto ToFieldOrErr = import(E->getField());
8177 if (!ToFieldOrErr)
8178 return ToFieldOrErr.takeError();
8179
8180 auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
8181 if (!UsedContextOrErr)
8182 return UsedContextOrErr.takeError();
8183
8184 return CXXDefaultInitExpr::Create(
8185 Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
8186 }
8187
VisitCXXNamedCastExpr(CXXNamedCastExpr * E)8188 ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
8189 Error Err = Error::success();
8190 auto ToType = importChecked(Err, E->getType());
8191 auto ToSubExpr = importChecked(Err, E->getSubExpr());
8192 auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
8193 auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
8194 auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
8195 auto ToAngleBrackets = importChecked(Err, E->getAngleBrackets());
8196 if (Err)
8197 return std::move(Err);
8198
8199 ExprValueKind VK = E->getValueKind();
8200 CastKind CK = E->getCastKind();
8201 auto ToBasePathOrErr = ImportCastPath(E);
8202 if (!ToBasePathOrErr)
8203 return ToBasePathOrErr.takeError();
8204
8205 if (auto CCE = dyn_cast<CXXStaticCastExpr>(E)) {
8206 return CXXStaticCastExpr::Create(
8207 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8208 ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
8209 ToAngleBrackets);
8210 } else if (isa<CXXDynamicCastExpr>(E)) {
8211 return CXXDynamicCastExpr::Create(
8212 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8213 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8214 } else if (isa<CXXReinterpretCastExpr>(E)) {
8215 return CXXReinterpretCastExpr::Create(
8216 Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
8217 ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8218 } else if (isa<CXXConstCastExpr>(E)) {
8219 return CXXConstCastExpr::Create(
8220 Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
8221 ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
8222 } else {
8223 llvm_unreachable("Unknown cast type");
8224 return make_error<ImportError>();
8225 }
8226 }
8227
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * E)8228 ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
8229 SubstNonTypeTemplateParmExpr *E) {
8230 Error Err = Error::success();
8231 auto ToType = importChecked(Err, E->getType());
8232 auto ToExprLoc = importChecked(Err, E->getExprLoc());
8233 auto ToParameter = importChecked(Err, E->getParameter());
8234 auto ToReplacement = importChecked(Err, E->getReplacement());
8235 if (Err)
8236 return std::move(Err);
8237
8238 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
8239 ToType, E->getValueKind(), ToExprLoc, ToParameter,
8240 E->isReferenceParameter(), ToReplacement);
8241 }
8242
VisitTypeTraitExpr(TypeTraitExpr * E)8243 ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
8244 Error Err = Error::success();
8245 auto ToType = importChecked(Err, E->getType());
8246 auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
8247 auto ToEndLoc = importChecked(Err, E->getEndLoc());
8248 if (Err)
8249 return std::move(Err);
8250
8251 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
8252 if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
8253 return std::move(Err);
8254
8255 // According to Sema::BuildTypeTrait(), if E is value-dependent,
8256 // Value is always false.
8257 bool ToValue = (E->isValueDependent() ? false : E->getValue());
8258
8259 return TypeTraitExpr::Create(
8260 Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
8261 ToEndLoc, ToValue);
8262 }
8263
VisitCXXTypeidExpr(CXXTypeidExpr * E)8264 ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
8265 ExpectedType ToTypeOrErr = import(E->getType());
8266 if (!ToTypeOrErr)
8267 return ToTypeOrErr.takeError();
8268
8269 auto ToSourceRangeOrErr = import(E->getSourceRange());
8270 if (!ToSourceRangeOrErr)
8271 return ToSourceRangeOrErr.takeError();
8272
8273 if (E->isTypeOperand()) {
8274 if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8275 return new (Importer.getToContext()) CXXTypeidExpr(
8276 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8277 else
8278 return ToTSIOrErr.takeError();
8279 }
8280
8281 ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
8282 if (!ToExprOperandOrErr)
8283 return ToExprOperandOrErr.takeError();
8284
8285 return new (Importer.getToContext()) CXXTypeidExpr(
8286 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8287 }
8288
VisitCXXFoldExpr(CXXFoldExpr * E)8289 ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
8290 Error Err = Error::success();
8291
8292 QualType ToType = importChecked(Err, E->getType());
8293 UnresolvedLookupExpr *ToCallee = importChecked(Err, E->getCallee());
8294 SourceLocation ToLParenLoc = importChecked(Err, E->getLParenLoc());
8295 Expr *ToLHS = importChecked(Err, E->getLHS());
8296 SourceLocation ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
8297 Expr *ToRHS = importChecked(Err, E->getRHS());
8298 SourceLocation ToRParenLoc = importChecked(Err, E->getRParenLoc());
8299
8300 if (Err)
8301 return std::move(Err);
8302
8303 return new (Importer.getToContext())
8304 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
8305 ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
8306 }
8307
ImportOverriddenMethods(CXXMethodDecl * ToMethod,CXXMethodDecl * FromMethod)8308 Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
8309 CXXMethodDecl *FromMethod) {
8310 Error ImportErrors = Error::success();
8311 for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
8312 if (auto ImportedOrErr = import(FromOverriddenMethod))
8313 ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
8314 (*ImportedOrErr)->getCanonicalDecl()));
8315 else
8316 ImportErrors =
8317 joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8318 }
8319 return ImportErrors;
8320 }
8321
ASTImporter(ASTContext & ToContext,FileManager & ToFileManager,ASTContext & FromContext,FileManager & FromFileManager,bool MinimalImport,std::shared_ptr<ASTImporterSharedState> SharedState)8322 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
8323 ASTContext &FromContext, FileManager &FromFileManager,
8324 bool MinimalImport,
8325 std::shared_ptr<ASTImporterSharedState> SharedState)
8326 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
8327 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
8328 Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {
8329
8330 // Create a default state without the lookup table: LLDB case.
8331 if (!SharedState) {
8332 this->SharedState = std::make_shared<ASTImporterSharedState>();
8333 }
8334
8335 ImportedDecls[FromContext.getTranslationUnitDecl()] =
8336 ToContext.getTranslationUnitDecl();
8337 }
8338
8339 ASTImporter::~ASTImporter() = default;
8340
getFieldIndex(Decl * F)8341 Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
8342 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
8343 "Try to get field index for non-field.");
8344
8345 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
8346 if (!Owner)
8347 return None;
8348
8349 unsigned Index = 0;
8350 for (const auto *D : Owner->decls()) {
8351 if (D == F)
8352 return Index;
8353
8354 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
8355 ++Index;
8356 }
8357
8358 llvm_unreachable("Field was not found in its parent context.");
8359
8360 return None;
8361 }
8362
8363 ASTImporter::FoundDeclsTy
findDeclsInToCtx(DeclContext * DC,DeclarationName Name)8364 ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
8365 // We search in the redecl context because of transparent contexts.
8366 // E.g. a simple C language enum is a transparent context:
8367 // enum E { A, B };
8368 // Now if we had a global variable in the TU
8369 // int A;
8370 // then the enum constant 'A' and the variable 'A' violates ODR.
8371 // We can diagnose this only if we search in the redecl context.
8372 DeclContext *ReDC = DC->getRedeclContext();
8373 if (SharedState->getLookupTable()) {
8374 ASTImporterLookupTable::LookupResult LookupResult =
8375 SharedState->getLookupTable()->lookup(ReDC, Name);
8376 return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
8377 } else {
8378 DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
8379 FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
8380 // We must search by the slow case of localUncachedLookup because that is
8381 // working even if there is no LookupPtr for the DC. We could use
8382 // DC::buildLookup() to create the LookupPtr, but that would load external
8383 // decls again, we must avoid that case.
8384 // Also, even if we had the LookupPtr, we must find Decls which are not
8385 // in the LookupPtr, so we need the slow case.
8386 // These cases are handled in ASTImporterLookupTable, but we cannot use
8387 // that with LLDB since that traverses through the AST which initiates the
8388 // load of external decls again via DC::decls(). And again, we must avoid
8389 // loading external decls during the import.
8390 if (Result.empty())
8391 ReDC->localUncachedLookup(Name, Result);
8392 return Result;
8393 }
8394 }
8395
AddToLookupTable(Decl * ToD)8396 void ASTImporter::AddToLookupTable(Decl *ToD) {
8397 SharedState->addDeclToLookup(ToD);
8398 }
8399
ImportImpl(Decl * FromD)8400 Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
8401 // Import the decl using ASTNodeImporter.
8402 ASTNodeImporter Importer(*this);
8403 return Importer.Visit(FromD);
8404 }
8405
RegisterImportedDecl(Decl * FromD,Decl * ToD)8406 void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
8407 MapImported(FromD, ToD);
8408 }
8409
8410 llvm::Expected<ExprWithCleanups::CleanupObject>
Import(ExprWithCleanups::CleanupObject From)8411 ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
8412 if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
8413 if (Expected<Expr *> R = Import(CLE))
8414 return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
8415 }
8416
8417 // FIXME: Handle BlockDecl when we implement importing BlockExpr in
8418 // ASTNodeImporter.
8419 return make_error<ImportError>(ImportError::UnsupportedConstruct);
8420 }
8421
Import(const Type * FromT)8422 ExpectedTypePtr ASTImporter::Import(const Type *FromT) {
8423 if (!FromT)
8424 return FromT;
8425
8426 // Check whether we've already imported this type.
8427 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
8428 ImportedTypes.find(FromT);
8429 if (Pos != ImportedTypes.end())
8430 return Pos->second;
8431
8432 // Import the type.
8433 ASTNodeImporter Importer(*this);
8434 ExpectedType ToTOrErr = Importer.Visit(FromT);
8435 if (!ToTOrErr)
8436 return ToTOrErr.takeError();
8437
8438 // Record the imported type.
8439 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
8440
8441 return ToTOrErr->getTypePtr();
8442 }
8443
Import(QualType FromT)8444 Expected<QualType> ASTImporter::Import(QualType FromT) {
8445 if (FromT.isNull())
8446 return QualType{};
8447
8448 ExpectedTypePtr ToTyOrErr = Import(FromT.getTypePtr());
8449 if (!ToTyOrErr)
8450 return ToTyOrErr.takeError();
8451
8452 return ToContext.getQualifiedType(*ToTyOrErr, FromT.getLocalQualifiers());
8453 }
8454
Import(TypeSourceInfo * FromTSI)8455 Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
8456 if (!FromTSI)
8457 return FromTSI;
8458
8459 // FIXME: For now we just create a "trivial" type source info based
8460 // on the type and a single location. Implement a real version of this.
8461 ExpectedType TOrErr = Import(FromTSI->getType());
8462 if (!TOrErr)
8463 return TOrErr.takeError();
8464 ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc());
8465 if (!BeginLocOrErr)
8466 return BeginLocOrErr.takeError();
8467
8468 return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
8469 }
8470
8471 // To use this object, it should be created before the new attribute is created,
8472 // and destructed after it is created. The construction already performs the
8473 // import of the data.
8474 template <typename T> struct AttrArgImporter {
8475 AttrArgImporter<T>(const AttrArgImporter<T> &) = delete;
8476 AttrArgImporter<T>(AttrArgImporter<T> &&) = default;
8477 AttrArgImporter<T> &operator=(const AttrArgImporter<T> &) = delete;
8478 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) = default;
8479
AttrArgImporterAttrArgImporter8480 AttrArgImporter(ASTNodeImporter &I, Error &Err, const T &From)
8481 : To(I.importChecked(Err, From)) {}
8482
valueAttrArgImporter8483 const T &value() { return To; }
8484
8485 private:
8486 T To;
8487 };
8488
8489 // To use this object, it should be created before the new attribute is created,
8490 // and destructed after it is created. The construction already performs the
8491 // import of the data. The array data is accessible in a pointer form, this form
8492 // is used by the attribute classes. This object should be created once for the
8493 // array data to be imported (the array size is not imported, just copied).
8494 template <typename T> struct AttrArgArrayImporter {
8495 AttrArgArrayImporter<T>(const AttrArgArrayImporter<T> &) = delete;
8496 AttrArgArrayImporter<T>(AttrArgArrayImporter<T> &&) = default;
8497 AttrArgArrayImporter<T> &operator=(const AttrArgArrayImporter<T> &) = delete;
8498 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) = default;
8499
AttrArgArrayImporterAttrArgArrayImporter8500 AttrArgArrayImporter(ASTNodeImporter &I, Error &Err,
8501 const llvm::iterator_range<T *> &From,
8502 unsigned ArraySize) {
8503 if (Err)
8504 return;
8505 To.reserve(ArraySize);
8506 Err = I.ImportContainerChecked(From, To);
8507 }
8508
valueAttrArgArrayImporter8509 T *value() { return To.data(); }
8510
8511 private:
8512 llvm::SmallVector<T, 2> To;
8513 };
8514
8515 class AttrImporter {
8516 Error Err{Error::success()};
8517 Attr *ToAttr = nullptr;
8518 ASTImporter &Importer;
8519 ASTNodeImporter NImporter;
8520
8521 public:
AttrImporter(ASTImporter & I)8522 AttrImporter(ASTImporter &I) : Importer(I), NImporter(I) {}
8523
8524 // Create an "importer" for an attribute parameter.
8525 // Result of the 'value()' of that object is to be passed to the function
8526 // 'importAttr', in the order that is expected by the attribute class.
importArg(const T & From)8527 template <class T> AttrArgImporter<T> importArg(const T &From) {
8528 return AttrArgImporter<T>(NImporter, Err, From);
8529 }
8530
8531 // Create an "importer" for an attribute parameter that has array type.
8532 // Result of the 'value()' of that object is to be passed to the function
8533 // 'importAttr', then the size of the array as next argument.
8534 template <typename T>
importArrayArg(const llvm::iterator_range<T * > & From,unsigned ArraySize)8535 AttrArgArrayImporter<T> importArrayArg(const llvm::iterator_range<T *> &From,
8536 unsigned ArraySize) {
8537 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
8538 }
8539
8540 // Create an attribute object with the specified arguments.
8541 // The 'FromAttr' is the original (not imported) attribute, the 'ImportedArg'
8542 // should be values that are passed to the 'Create' function of the attribute.
8543 // (The 'Create' with 'ASTContext' first and 'AttributeCommonInfo' last is
8544 // used here.) As much data is copied or imported from the old attribute
8545 // as possible. The passed arguments should be already imported.
8546 // If an import error happens, the internal error is set to it, and any
8547 // further import attempt is ignored.
8548 template <typename T, typename... Arg>
importAttr(const T * FromAttr,Arg &&...ImportedArg)8549 void importAttr(const T *FromAttr, Arg &&...ImportedArg) {
8550 static_assert(std::is_base_of<Attr, T>::value,
8551 "T should be subclass of Attr.");
8552 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
8553
8554 const IdentifierInfo *ToAttrName = Importer.Import(FromAttr->getAttrName());
8555 const IdentifierInfo *ToScopeName =
8556 Importer.Import(FromAttr->getScopeName());
8557 SourceRange ToAttrRange =
8558 NImporter.importChecked(Err, FromAttr->getRange());
8559 SourceLocation ToScopeLoc =
8560 NImporter.importChecked(Err, FromAttr->getScopeLoc());
8561
8562 if (Err)
8563 return;
8564
8565 AttributeCommonInfo ToI(ToAttrName, ToScopeName, ToAttrRange, ToScopeLoc,
8566 FromAttr->getParsedKind(), FromAttr->getSyntax(),
8567 FromAttr->getAttributeSpellingListIndex());
8568 // The "SemanticSpelling" is not needed to be passed to the constructor.
8569 // That value is recalculated from the SpellingListIndex if needed.
8570 ToAttr = T::Create(Importer.getToContext(),
8571 std::forward<Arg>(ImportedArg)..., ToI);
8572
8573 ToAttr->setImplicit(FromAttr->isImplicit());
8574 ToAttr->setPackExpansion(FromAttr->isPackExpansion());
8575 if (auto *ToInheritableAttr = dyn_cast<InheritableAttr>(ToAttr))
8576 ToInheritableAttr->setInherited(FromAttr->isInherited());
8577 }
8578
8579 // Create a clone of the 'FromAttr' and import its source range only.
8580 // This causes objects with invalid references to be created if the 'FromAttr'
8581 // contains other data that should be imported.
cloneAttr(const Attr * FromAttr)8582 void cloneAttr(const Attr *FromAttr) {
8583 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
8584
8585 SourceRange ToRange = NImporter.importChecked(Err, FromAttr->getRange());
8586 if (Err)
8587 return;
8588
8589 ToAttr = FromAttr->clone(Importer.getToContext());
8590 ToAttr->setRange(ToRange);
8591 }
8592
8593 // Get the result of the previous import attempt (can be used only once).
getResult()8594 llvm::Expected<Attr *> getResult() && {
8595 if (Err)
8596 return std::move(Err);
8597 assert(ToAttr && "Attribute should be created.");
8598 return ToAttr;
8599 }
8600 };
8601
Import(const Attr * FromAttr)8602 Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
8603 AttrImporter AI(*this);
8604
8605 // FIXME: Is there some kind of AttrVisitor to use here?
8606 switch (FromAttr->getKind()) {
8607 case attr::Aligned: {
8608 auto *From = cast<AlignedAttr>(FromAttr);
8609 if (From->isAlignmentExpr())
8610 AI.importAttr(From, true, AI.importArg(From->getAlignmentExpr()).value());
8611 else
8612 AI.importAttr(From, false,
8613 AI.importArg(From->getAlignmentType()).value());
8614 break;
8615 }
8616
8617 case attr::Format: {
8618 const auto *From = cast<FormatAttr>(FromAttr);
8619 AI.importAttr(From, Import(From->getType()), From->getFormatIdx(),
8620 From->getFirstArg());
8621 break;
8622 }
8623
8624 case attr::AssertCapability: {
8625 const auto *From = cast<AssertCapabilityAttr>(FromAttr);
8626 AI.importAttr(From,
8627 AI.importArrayArg(From->args(), From->args_size()).value(),
8628 From->args_size());
8629 break;
8630 }
8631 case attr::AcquireCapability: {
8632 const auto *From = cast<AcquireCapabilityAttr>(FromAttr);
8633 AI.importAttr(From,
8634 AI.importArrayArg(From->args(), From->args_size()).value(),
8635 From->args_size());
8636 break;
8637 }
8638 case attr::TryAcquireCapability: {
8639 const auto *From = cast<TryAcquireCapabilityAttr>(FromAttr);
8640 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
8641 AI.importArrayArg(From->args(), From->args_size()).value(),
8642 From->args_size());
8643 break;
8644 }
8645 case attr::ReleaseCapability: {
8646 const auto *From = cast<ReleaseCapabilityAttr>(FromAttr);
8647 AI.importAttr(From,
8648 AI.importArrayArg(From->args(), From->args_size()).value(),
8649 From->args_size());
8650 break;
8651 }
8652 case attr::RequiresCapability: {
8653 const auto *From = cast<RequiresCapabilityAttr>(FromAttr);
8654 AI.importAttr(From,
8655 AI.importArrayArg(From->args(), From->args_size()).value(),
8656 From->args_size());
8657 break;
8658 }
8659 case attr::GuardedBy: {
8660 const auto *From = cast<GuardedByAttr>(FromAttr);
8661 AI.importAttr(From, AI.importArg(From->getArg()).value());
8662 break;
8663 }
8664 case attr::PtGuardedBy: {
8665 const auto *From = cast<PtGuardedByAttr>(FromAttr);
8666 AI.importAttr(From, AI.importArg(From->getArg()).value());
8667 break;
8668 }
8669 case attr::AcquiredAfter: {
8670 const auto *From = cast<AcquiredAfterAttr>(FromAttr);
8671 AI.importAttr(From,
8672 AI.importArrayArg(From->args(), From->args_size()).value(),
8673 From->args_size());
8674 break;
8675 }
8676 case attr::AcquiredBefore: {
8677 const auto *From = cast<AcquiredBeforeAttr>(FromAttr);
8678 AI.importAttr(From,
8679 AI.importArrayArg(From->args(), From->args_size()).value(),
8680 From->args_size());
8681 break;
8682 }
8683 case attr::AssertExclusiveLock: {
8684 const auto *From = cast<AssertExclusiveLockAttr>(FromAttr);
8685 AI.importAttr(From,
8686 AI.importArrayArg(From->args(), From->args_size()).value(),
8687 From->args_size());
8688 break;
8689 }
8690 case attr::AssertSharedLock: {
8691 const auto *From = cast<AssertSharedLockAttr>(FromAttr);
8692 AI.importAttr(From,
8693 AI.importArrayArg(From->args(), From->args_size()).value(),
8694 From->args_size());
8695 break;
8696 }
8697 case attr::ExclusiveTrylockFunction: {
8698 const auto *From = cast<ExclusiveTrylockFunctionAttr>(FromAttr);
8699 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
8700 AI.importArrayArg(From->args(), From->args_size()).value(),
8701 From->args_size());
8702 break;
8703 }
8704 case attr::SharedTrylockFunction: {
8705 const auto *From = cast<SharedTrylockFunctionAttr>(FromAttr);
8706 AI.importAttr(From, AI.importArg(From->getSuccessValue()).value(),
8707 AI.importArrayArg(From->args(), From->args_size()).value(),
8708 From->args_size());
8709 break;
8710 }
8711 case attr::LockReturned: {
8712 const auto *From = cast<LockReturnedAttr>(FromAttr);
8713 AI.importAttr(From, AI.importArg(From->getArg()).value());
8714 break;
8715 }
8716 case attr::LocksExcluded: {
8717 const auto *From = cast<LocksExcludedAttr>(FromAttr);
8718 AI.importAttr(From,
8719 AI.importArrayArg(From->args(), From->args_size()).value(),
8720 From->args_size());
8721 break;
8722 }
8723
8724 default: {
8725 // The default branch works for attributes that have no arguments to import.
8726 // FIXME: Handle every attribute type that has arguments of type to import
8727 // (most often Expr* or Decl* or type) in the switch above.
8728 AI.cloneAttr(FromAttr);
8729 break;
8730 }
8731 }
8732
8733 return std::move(AI).getResult();
8734 }
8735
GetAlreadyImportedOrNull(const Decl * FromD) const8736 Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
8737 auto Pos = ImportedDecls.find(FromD);
8738 if (Pos != ImportedDecls.end())
8739 return Pos->second;
8740 else
8741 return nullptr;
8742 }
8743
GetFromTU(Decl * ToD)8744 TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
8745 auto FromDPos = ImportedFromDecls.find(ToD);
8746 if (FromDPos == ImportedFromDecls.end())
8747 return nullptr;
8748 return FromDPos->second->getTranslationUnitDecl();
8749 }
8750
Import(Decl * FromD)8751 Expected<Decl *> ASTImporter::Import(Decl *FromD) {
8752 if (!FromD)
8753 return nullptr;
8754
8755 // Push FromD to the stack, and remove that when we return.
8756 ImportPath.push(FromD);
8757 auto ImportPathBuilder =
8758 llvm::make_scope_exit([this]() { ImportPath.pop(); });
8759
8760 // Check whether there was a previous failed import.
8761 // If yes return the existing error.
8762 if (auto Error = getImportDeclErrorIfAny(FromD))
8763 return make_error<ImportError>(*Error);
8764
8765 // Check whether we've already imported this declaration.
8766 Decl *ToD = GetAlreadyImportedOrNull(FromD);
8767 if (ToD) {
8768 // Already imported (possibly from another TU) and with an error.
8769 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8770 setImportDeclError(FromD, *Error);
8771 return make_error<ImportError>(*Error);
8772 }
8773
8774 // If FromD has some updated flags after last import, apply it.
8775 updateFlags(FromD, ToD);
8776 // If we encounter a cycle during an import then we save the relevant part
8777 // of the import path associated to the Decl.
8778 if (ImportPath.hasCycleAtBack())
8779 SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
8780 return ToD;
8781 }
8782
8783 // Import the declaration.
8784 ExpectedDecl ToDOrErr = ImportImpl(FromD);
8785 if (!ToDOrErr) {
8786 // Failed to import.
8787
8788 auto Pos = ImportedDecls.find(FromD);
8789 if (Pos != ImportedDecls.end()) {
8790 // Import failed after the object was created.
8791 // Remove all references to it.
8792 auto *ToD = Pos->second;
8793 ImportedDecls.erase(Pos);
8794
8795 // ImportedDecls and ImportedFromDecls are not symmetric. It may happen
8796 // (e.g. with namespaces) that several decls from the 'from' context are
8797 // mapped to the same decl in the 'to' context. If we removed entries
8798 // from the LookupTable here then we may end up removing them multiple
8799 // times.
8800
8801 // The Lookuptable contains decls only which are in the 'to' context.
8802 // Remove from the Lookuptable only if it is *imported* into the 'to'
8803 // context (and do not remove it if it was added during the initial
8804 // traverse of the 'to' context).
8805 auto PosF = ImportedFromDecls.find(ToD);
8806 if (PosF != ImportedFromDecls.end()) {
8807 // In the case of TypedefNameDecl we create the Decl first and only
8808 // then we import and set its DeclContext. So, the DC might not be set
8809 // when we reach here.
8810 if (ToD->getDeclContext())
8811 SharedState->removeDeclFromLookup(ToD);
8812 ImportedFromDecls.erase(PosF);
8813 }
8814
8815 // FIXME: AST may contain remaining references to the failed object.
8816 // However, the ImportDeclErrors in the shared state contains all the
8817 // failed objects together with their error.
8818 }
8819
8820 // Error encountered for the first time.
8821 // After takeError the error is not usable any more in ToDOrErr.
8822 // Get a copy of the error object (any more simple solution for this?).
8823 ImportError ErrOut;
8824 handleAllErrors(ToDOrErr.takeError(),
8825 [&ErrOut](const ImportError &E) { ErrOut = E; });
8826 setImportDeclError(FromD, ErrOut);
8827 // Set the error for the mapped to Decl, which is in the "to" context.
8828 if (Pos != ImportedDecls.end())
8829 SharedState->setImportDeclError(Pos->second, ErrOut);
8830
8831 // Set the error for all nodes which have been created before we
8832 // recognized the error.
8833 for (const auto &Path : SavedImportPaths[FromD])
8834 for (Decl *FromDi : Path) {
8835 setImportDeclError(FromDi, ErrOut);
8836 //FIXME Should we remove these Decls from ImportedDecls?
8837 // Set the error for the mapped to Decl, which is in the "to" context.
8838 auto Ii = ImportedDecls.find(FromDi);
8839 if (Ii != ImportedDecls.end())
8840 SharedState->setImportDeclError(Ii->second, ErrOut);
8841 // FIXME Should we remove these Decls from the LookupTable,
8842 // and from ImportedFromDecls?
8843 }
8844 SavedImportPaths.erase(FromD);
8845
8846 // Do not return ToDOrErr, error was taken out of it.
8847 return make_error<ImportError>(ErrOut);
8848 }
8849
8850 ToD = *ToDOrErr;
8851
8852 // FIXME: Handle the "already imported with error" case. We can get here
8853 // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
8854 // previously failed create was requested).
8855 // Later GetImportedOrCreateDecl can be updated to return the error.
8856 if (!ToD) {
8857 auto Err = getImportDeclErrorIfAny(FromD);
8858 assert(Err);
8859 return make_error<ImportError>(*Err);
8860 }
8861
8862 // We could import from the current TU without error. But previously we
8863 // already had imported a Decl as `ToD` from another TU (with another
8864 // ASTImporter object) and with an error.
8865 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8866 setImportDeclError(FromD, *Error);
8867 return make_error<ImportError>(*Error);
8868 }
8869
8870 // Make sure that ImportImpl registered the imported decl.
8871 assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
8872
8873 if (FromD->hasAttrs())
8874 for (const Attr *FromAttr : FromD->getAttrs()) {
8875 auto ToAttrOrErr = Import(FromAttr);
8876 if (ToAttrOrErr)
8877 ToD->addAttr(*ToAttrOrErr);
8878 else
8879 return ToAttrOrErr.takeError();
8880 }
8881
8882 // Notify subclasses.
8883 Imported(FromD, ToD);
8884
8885 updateFlags(FromD, ToD);
8886 SavedImportPaths.erase(FromD);
8887 return ToDOrErr;
8888 }
8889
8890 llvm::Expected<InheritedConstructor>
Import(const InheritedConstructor & From)8891 ASTImporter::Import(const InheritedConstructor &From) {
8892 return ASTNodeImporter(*this).ImportInheritedConstructor(From);
8893 }
8894
ImportContext(DeclContext * FromDC)8895 Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
8896 if (!FromDC)
8897 return FromDC;
8898
8899 ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC));
8900 if (!ToDCOrErr)
8901 return ToDCOrErr.takeError();
8902 auto *ToDC = cast<DeclContext>(*ToDCOrErr);
8903
8904 // When we're using a record/enum/Objective-C class/protocol as a context, we
8905 // need it to have a definition.
8906 if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
8907 auto *FromRecord = cast<RecordDecl>(FromDC);
8908 if (ToRecord->isCompleteDefinition())
8909 return ToDC;
8910
8911 // If FromRecord is not defined we need to force it to be.
8912 // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
8913 // it will start the definition but we never finish it.
8914 // If there are base classes they won't be imported and we will
8915 // be missing anything that we inherit from those bases.
8916 if (FromRecord->getASTContext().getExternalSource() &&
8917 !FromRecord->isCompleteDefinition())
8918 FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
8919
8920 if (FromRecord->isCompleteDefinition())
8921 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8922 FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
8923 return std::move(Err);
8924 } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
8925 auto *FromEnum = cast<EnumDecl>(FromDC);
8926 if (ToEnum->isCompleteDefinition()) {
8927 // Do nothing.
8928 } else if (FromEnum->isCompleteDefinition()) {
8929 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8930 FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
8931 return std::move(Err);
8932 } else {
8933 CompleteDecl(ToEnum);
8934 }
8935 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
8936 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
8937 if (ToClass->getDefinition()) {
8938 // Do nothing.
8939 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
8940 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8941 FromDef, ToClass, ASTNodeImporter::IDK_Basic))
8942 return std::move(Err);
8943 } else {
8944 CompleteDecl(ToClass);
8945 }
8946 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
8947 auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
8948 if (ToProto->getDefinition()) {
8949 // Do nothing.
8950 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
8951 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8952 FromDef, ToProto, ASTNodeImporter::IDK_Basic))
8953 return std::move(Err);
8954 } else {
8955 CompleteDecl(ToProto);
8956 }
8957 }
8958
8959 return ToDC;
8960 }
8961
Import(Expr * FromE)8962 Expected<Expr *> ASTImporter::Import(Expr *FromE) {
8963 if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE)))
8964 return cast_or_null<Expr>(*ToSOrErr);
8965 else
8966 return ToSOrErr.takeError();
8967 }
8968
Import(Stmt * FromS)8969 Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
8970 if (!FromS)
8971 return nullptr;
8972
8973 // Check whether we've already imported this statement.
8974 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
8975 if (Pos != ImportedStmts.end())
8976 return Pos->second;
8977
8978 // Import the statement.
8979 ASTNodeImporter Importer(*this);
8980 ExpectedStmt ToSOrErr = Importer.Visit(FromS);
8981 if (!ToSOrErr)
8982 return ToSOrErr;
8983
8984 if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8985 auto *FromE = cast<Expr>(FromS);
8986 // Copy ExprBitfields, which may not be handled in Expr subclasses
8987 // constructors.
8988 ToE->setValueKind(FromE->getValueKind());
8989 ToE->setObjectKind(FromE->getObjectKind());
8990 ToE->setDependence(FromE->getDependence());
8991 }
8992
8993 // Record the imported statement object.
8994 ImportedStmts[FromS] = *ToSOrErr;
8995 return ToSOrErr;
8996 }
8997
8998 Expected<NestedNameSpecifier *>
Import(NestedNameSpecifier * FromNNS)8999 ASTImporter::Import(NestedNameSpecifier *FromNNS) {
9000 if (!FromNNS)
9001 return nullptr;
9002
9003 NestedNameSpecifier *Prefix = nullptr;
9004 if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
9005 return std::move(Err);
9006
9007 switch (FromNNS->getKind()) {
9008 case NestedNameSpecifier::Identifier:
9009 assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.");
9010 return NestedNameSpecifier::Create(ToContext, Prefix,
9011 Import(FromNNS->getAsIdentifier()));
9012
9013 case NestedNameSpecifier::Namespace:
9014 if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) {
9015 return NestedNameSpecifier::Create(ToContext, Prefix,
9016 cast<NamespaceDecl>(*NSOrErr));
9017 } else
9018 return NSOrErr.takeError();
9019
9020 case NestedNameSpecifier::NamespaceAlias:
9021 if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias()))
9022 return NestedNameSpecifier::Create(ToContext, Prefix,
9023 cast<NamespaceAliasDecl>(*NSADOrErr));
9024 else
9025 return NSADOrErr.takeError();
9026
9027 case NestedNameSpecifier::Global:
9028 return NestedNameSpecifier::GlobalSpecifier(ToContext);
9029
9030 case NestedNameSpecifier::Super:
9031 if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl()))
9032 return NestedNameSpecifier::SuperSpecifier(ToContext,
9033 cast<CXXRecordDecl>(*RDOrErr));
9034 else
9035 return RDOrErr.takeError();
9036
9037 case NestedNameSpecifier::TypeSpec:
9038 case NestedNameSpecifier::TypeSpecWithTemplate:
9039 if (ExpectedTypePtr TyOrErr = Import(FromNNS->getAsType())) {
9040 bool TSTemplate =
9041 FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
9042 return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate,
9043 *TyOrErr);
9044 } else {
9045 return TyOrErr.takeError();
9046 }
9047 }
9048
9049 llvm_unreachable("Invalid nested name specifier kind");
9050 }
9051
9052 Expected<NestedNameSpecifierLoc>
Import(NestedNameSpecifierLoc FromNNS)9053 ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
9054 // Copied from NestedNameSpecifier mostly.
9055 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
9056 NestedNameSpecifierLoc NNS = FromNNS;
9057
9058 // Push each of the nested-name-specifiers's onto a stack for
9059 // serialization in reverse order.
9060 while (NNS) {
9061 NestedNames.push_back(NNS);
9062 NNS = NNS.getPrefix();
9063 }
9064
9065 NestedNameSpecifierLocBuilder Builder;
9066
9067 while (!NestedNames.empty()) {
9068 NNS = NestedNames.pop_back_val();
9069 NestedNameSpecifier *Spec = nullptr;
9070 if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier()))
9071 return std::move(Err);
9072
9073 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
9074
9075 SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
9076 if (Kind != NestedNameSpecifier::Super) {
9077 if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc()))
9078 return std::move(Err);
9079
9080 if (Kind != NestedNameSpecifier::Global)
9081 if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc()))
9082 return std::move(Err);
9083 }
9084
9085 switch (Kind) {
9086 case NestedNameSpecifier::Identifier:
9087 Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
9088 ToLocalEndLoc);
9089 break;
9090
9091 case NestedNameSpecifier::Namespace:
9092 Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
9093 ToLocalEndLoc);
9094 break;
9095
9096 case NestedNameSpecifier::NamespaceAlias:
9097 Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
9098 ToLocalBeginLoc, ToLocalEndLoc);
9099 break;
9100
9101 case NestedNameSpecifier::TypeSpec:
9102 case NestedNameSpecifier::TypeSpecWithTemplate: {
9103 SourceLocation ToTLoc;
9104 if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
9105 return std::move(Err);
9106 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
9107 QualType(Spec->getAsType(), 0), ToTLoc);
9108 if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
9109 // ToLocalBeginLoc is here the location of the 'template' keyword.
9110 Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
9111 ToLocalEndLoc);
9112 else
9113 // No location for 'template' keyword here.
9114 Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
9115 ToLocalEndLoc);
9116 break;
9117 }
9118
9119 case NestedNameSpecifier::Global:
9120 Builder.MakeGlobal(getToContext(), ToLocalBeginLoc);
9121 break;
9122
9123 case NestedNameSpecifier::Super: {
9124 auto ToSourceRangeOrErr = Import(NNS.getSourceRange());
9125 if (!ToSourceRangeOrErr)
9126 return ToSourceRangeOrErr.takeError();
9127
9128 Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(),
9129 ToSourceRangeOrErr->getBegin(),
9130 ToSourceRangeOrErr->getEnd());
9131 }
9132 }
9133 }
9134
9135 return Builder.getWithLocInContext(getToContext());
9136 }
9137
Import(TemplateName From)9138 Expected<TemplateName> ASTImporter::Import(TemplateName From) {
9139 switch (From.getKind()) {
9140 case TemplateName::Template:
9141 if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
9142 return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr));
9143 else
9144 return ToTemplateOrErr.takeError();
9145
9146 case TemplateName::OverloadedTemplate: {
9147 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
9148 UnresolvedSet<2> ToTemplates;
9149 for (auto *I : *FromStorage) {
9150 if (auto ToOrErr = Import(I))
9151 ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr));
9152 else
9153 return ToOrErr.takeError();
9154 }
9155 return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
9156 ToTemplates.end());
9157 }
9158
9159 case TemplateName::AssumedTemplate: {
9160 AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
9161 auto DeclNameOrErr = Import(FromStorage->getDeclName());
9162 if (!DeclNameOrErr)
9163 return DeclNameOrErr.takeError();
9164 return ToContext.getAssumedTemplateName(*DeclNameOrErr);
9165 }
9166
9167 case TemplateName::QualifiedTemplate: {
9168 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
9169 auto QualifierOrErr = Import(QTN->getQualifier());
9170 if (!QualifierOrErr)
9171 return QualifierOrErr.takeError();
9172
9173 if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
9174 return ToContext.getQualifiedTemplateName(
9175 *QualifierOrErr, QTN->hasTemplateKeyword(),
9176 cast<TemplateDecl>(*ToTemplateOrErr));
9177 else
9178 return ToTemplateOrErr.takeError();
9179 }
9180
9181 case TemplateName::DependentTemplate: {
9182 DependentTemplateName *DTN = From.getAsDependentTemplateName();
9183 auto QualifierOrErr = Import(DTN->getQualifier());
9184 if (!QualifierOrErr)
9185 return QualifierOrErr.takeError();
9186
9187 if (DTN->isIdentifier()) {
9188 return ToContext.getDependentTemplateName(*QualifierOrErr,
9189 Import(DTN->getIdentifier()));
9190 }
9191
9192 return ToContext.getDependentTemplateName(*QualifierOrErr,
9193 DTN->getOperator());
9194 }
9195
9196 case TemplateName::SubstTemplateTemplateParm: {
9197 SubstTemplateTemplateParmStorage *Subst =
9198 From.getAsSubstTemplateTemplateParm();
9199 ExpectedDecl ParamOrErr = Import(Subst->getParameter());
9200 if (!ParamOrErr)
9201 return ParamOrErr.takeError();
9202
9203 auto ReplacementOrErr = Import(Subst->getReplacement());
9204 if (!ReplacementOrErr)
9205 return ReplacementOrErr.takeError();
9206
9207 return ToContext.getSubstTemplateTemplateParm(
9208 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
9209 }
9210
9211 case TemplateName::SubstTemplateTemplateParmPack: {
9212 SubstTemplateTemplateParmPackStorage *SubstPack
9213 = From.getAsSubstTemplateTemplateParmPack();
9214 ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack());
9215 if (!ParamOrErr)
9216 return ParamOrErr.takeError();
9217
9218 ASTNodeImporter Importer(*this);
9219 auto ArgPackOrErr =
9220 Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
9221 if (!ArgPackOrErr)
9222 return ArgPackOrErr.takeError();
9223
9224 return ToContext.getSubstTemplateTemplateParmPack(
9225 cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
9226 }
9227 }
9228
9229 llvm_unreachable("Invalid template name kind");
9230 }
9231
Import(SourceLocation FromLoc)9232 Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
9233 if (FromLoc.isInvalid())
9234 return SourceLocation{};
9235
9236 SourceManager &FromSM = FromContext.getSourceManager();
9237 bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc);
9238
9239 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
9240 Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
9241 if (!ToFileIDOrErr)
9242 return ToFileIDOrErr.takeError();
9243 SourceManager &ToSM = ToContext.getSourceManager();
9244 return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
9245 }
9246
Import(SourceRange FromRange)9247 Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
9248 SourceLocation ToBegin, ToEnd;
9249 if (Error Err = importInto(ToBegin, FromRange.getBegin()))
9250 return std::move(Err);
9251 if (Error Err = importInto(ToEnd, FromRange.getEnd()))
9252 return std::move(Err);
9253
9254 return SourceRange(ToBegin, ToEnd);
9255 }
9256
Import(FileID FromID,bool IsBuiltin)9257 Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
9258 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
9259 if (Pos != ImportedFileIDs.end())
9260 return Pos->second;
9261
9262 SourceManager &FromSM = FromContext.getSourceManager();
9263 SourceManager &ToSM = ToContext.getSourceManager();
9264 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
9265
9266 // Map the FromID to the "to" source manager.
9267 FileID ToID;
9268 if (FromSLoc.isExpansion()) {
9269 const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
9270 ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc());
9271 if (!ToSpLoc)
9272 return ToSpLoc.takeError();
9273 ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart());
9274 if (!ToExLocS)
9275 return ToExLocS.takeError();
9276 unsigned TokenLen = FromSM.getFileIDSize(FromID);
9277 SourceLocation MLoc;
9278 if (FromEx.isMacroArgExpansion()) {
9279 MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
9280 } else {
9281 if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd()))
9282 MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
9283 FromEx.isExpansionTokenRange());
9284 else
9285 return ToExLocE.takeError();
9286 }
9287 ToID = ToSM.getFileID(MLoc);
9288 } else {
9289 const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
9290
9291 if (!IsBuiltin && !Cache->BufferOverridden) {
9292 // Include location of this file.
9293 ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
9294 if (!ToIncludeLoc)
9295 return ToIncludeLoc.takeError();
9296
9297 // Every FileID that is not the main FileID needs to have a valid include
9298 // location so that the include chain points to the main FileID. When
9299 // importing the main FileID (which has no include location), we need to
9300 // create a fake include location in the main file to keep this property
9301 // intact.
9302 SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
9303 if (FromID == FromSM.getMainFileID())
9304 ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(ToSM.getMainFileID());
9305
9306 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
9307 // FIXME: We probably want to use getVirtualFile(), so we don't hit the
9308 // disk again
9309 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
9310 // than mmap the files several times.
9311 auto Entry =
9312 ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
9313 // FIXME: The filename may be a virtual name that does probably not
9314 // point to a valid file and we get no Entry here. In this case try with
9315 // the memory buffer below.
9316 if (Entry)
9317 ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
9318 FromSLoc.getFile().getFileCharacteristic());
9319 }
9320 }
9321
9322 if (ToID.isInvalid() || IsBuiltin) {
9323 // FIXME: We want to re-use the existing MemoryBuffer!
9324 llvm::Optional<llvm::MemoryBufferRef> FromBuf =
9325 Cache->getBufferOrNone(FromContext.getDiagnostics(),
9326 FromSM.getFileManager(), SourceLocation{});
9327 if (!FromBuf)
9328 return llvm::make_error<ImportError>(ImportError::Unknown);
9329
9330 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
9331 llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
9332 FromBuf->getBufferIdentifier());
9333 ToID = ToSM.createFileID(std::move(ToBuf),
9334 FromSLoc.getFile().getFileCharacteristic());
9335 }
9336 }
9337
9338 assert(ToID.isValid() && "Unexpected invalid fileID was created.");
9339
9340 ImportedFileIDs[FromID] = ToID;
9341 return ToID;
9342 }
9343
Import(CXXCtorInitializer * From)9344 Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
9345 ExpectedExpr ToExprOrErr = Import(From->getInit());
9346 if (!ToExprOrErr)
9347 return ToExprOrErr.takeError();
9348
9349 auto LParenLocOrErr = Import(From->getLParenLoc());
9350 if (!LParenLocOrErr)
9351 return LParenLocOrErr.takeError();
9352
9353 auto RParenLocOrErr = Import(From->getRParenLoc());
9354 if (!RParenLocOrErr)
9355 return RParenLocOrErr.takeError();
9356
9357 if (From->isBaseInitializer()) {
9358 auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
9359 if (!ToTInfoOrErr)
9360 return ToTInfoOrErr.takeError();
9361
9362 SourceLocation EllipsisLoc;
9363 if (From->isPackExpansion())
9364 if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc()))
9365 return std::move(Err);
9366
9367 return new (ToContext) CXXCtorInitializer(
9368 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
9369 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
9370 } else if (From->isMemberInitializer()) {
9371 ExpectedDecl ToFieldOrErr = Import(From->getMember());
9372 if (!ToFieldOrErr)
9373 return ToFieldOrErr.takeError();
9374
9375 auto MemberLocOrErr = Import(From->getMemberLocation());
9376 if (!MemberLocOrErr)
9377 return MemberLocOrErr.takeError();
9378
9379 return new (ToContext) CXXCtorInitializer(
9380 ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
9381 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
9382 } else if (From->isIndirectMemberInitializer()) {
9383 ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember());
9384 if (!ToIFieldOrErr)
9385 return ToIFieldOrErr.takeError();
9386
9387 auto MemberLocOrErr = Import(From->getMemberLocation());
9388 if (!MemberLocOrErr)
9389 return MemberLocOrErr.takeError();
9390
9391 return new (ToContext) CXXCtorInitializer(
9392 ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
9393 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
9394 } else if (From->isDelegatingInitializer()) {
9395 auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
9396 if (!ToTInfoOrErr)
9397 return ToTInfoOrErr.takeError();
9398
9399 return new (ToContext)
9400 CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
9401 *ToExprOrErr, *RParenLocOrErr);
9402 } else {
9403 // FIXME: assert?
9404 return make_error<ImportError>();
9405 }
9406 }
9407
9408 Expected<CXXBaseSpecifier *>
Import(const CXXBaseSpecifier * BaseSpec)9409 ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
9410 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
9411 if (Pos != ImportedCXXBaseSpecifiers.end())
9412 return Pos->second;
9413
9414 Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange());
9415 if (!ToSourceRange)
9416 return ToSourceRange.takeError();
9417 Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo());
9418 if (!ToTSI)
9419 return ToTSI.takeError();
9420 ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc());
9421 if (!ToEllipsisLoc)
9422 return ToEllipsisLoc.takeError();
9423 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
9424 *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
9425 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
9426 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
9427 return Imported;
9428 }
9429
Import(const APValue & FromValue)9430 llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
9431 ASTNodeImporter Importer(*this);
9432 return Importer.ImportAPValue(FromValue);
9433 }
9434
ImportDefinition(Decl * From)9435 Error ASTImporter::ImportDefinition(Decl *From) {
9436 ExpectedDecl ToOrErr = Import(From);
9437 if (!ToOrErr)
9438 return ToOrErr.takeError();
9439 Decl *To = *ToOrErr;
9440
9441 auto *FromDC = cast<DeclContext>(From);
9442 ASTNodeImporter Importer(*this);
9443
9444 if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
9445 if (!ToRecord->getDefinition()) {
9446 return Importer.ImportDefinition(
9447 cast<RecordDecl>(FromDC), ToRecord,
9448 ASTNodeImporter::IDK_Everything);
9449 }
9450 }
9451
9452 if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
9453 if (!ToEnum->getDefinition()) {
9454 return Importer.ImportDefinition(
9455 cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything);
9456 }
9457 }
9458
9459 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
9460 if (!ToIFace->getDefinition()) {
9461 return Importer.ImportDefinition(
9462 cast<ObjCInterfaceDecl>(FromDC), ToIFace,
9463 ASTNodeImporter::IDK_Everything);
9464 }
9465 }
9466
9467 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
9468 if (!ToProto->getDefinition()) {
9469 return Importer.ImportDefinition(
9470 cast<ObjCProtocolDecl>(FromDC), ToProto,
9471 ASTNodeImporter::IDK_Everything);
9472 }
9473 }
9474
9475 return Importer.ImportDeclContext(FromDC, true);
9476 }
9477
Import(DeclarationName FromName)9478 Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
9479 if (!FromName)
9480 return DeclarationName{};
9481
9482 switch (FromName.getNameKind()) {
9483 case DeclarationName::Identifier:
9484 return DeclarationName(Import(FromName.getAsIdentifierInfo()));
9485
9486 case DeclarationName::ObjCZeroArgSelector:
9487 case DeclarationName::ObjCOneArgSelector:
9488 case DeclarationName::ObjCMultiArgSelector:
9489 if (auto ToSelOrErr = Import(FromName.getObjCSelector()))
9490 return DeclarationName(*ToSelOrErr);
9491 else
9492 return ToSelOrErr.takeError();
9493
9494 case DeclarationName::CXXConstructorName: {
9495 if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9496 return ToContext.DeclarationNames.getCXXConstructorName(
9497 ToContext.getCanonicalType(*ToTyOrErr));
9498 else
9499 return ToTyOrErr.takeError();
9500 }
9501
9502 case DeclarationName::CXXDestructorName: {
9503 if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9504 return ToContext.DeclarationNames.getCXXDestructorName(
9505 ToContext.getCanonicalType(*ToTyOrErr));
9506 else
9507 return ToTyOrErr.takeError();
9508 }
9509
9510 case DeclarationName::CXXDeductionGuideName: {
9511 if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate()))
9512 return ToContext.DeclarationNames.getCXXDeductionGuideName(
9513 cast<TemplateDecl>(*ToTemplateOrErr));
9514 else
9515 return ToTemplateOrErr.takeError();
9516 }
9517
9518 case DeclarationName::CXXConversionFunctionName: {
9519 if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9520 return ToContext.DeclarationNames.getCXXConversionFunctionName(
9521 ToContext.getCanonicalType(*ToTyOrErr));
9522 else
9523 return ToTyOrErr.takeError();
9524 }
9525
9526 case DeclarationName::CXXOperatorName:
9527 return ToContext.DeclarationNames.getCXXOperatorName(
9528 FromName.getCXXOverloadedOperator());
9529
9530 case DeclarationName::CXXLiteralOperatorName:
9531 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
9532 Import(FromName.getCXXLiteralIdentifier()));
9533
9534 case DeclarationName::CXXUsingDirective:
9535 // FIXME: STATICS!
9536 return DeclarationName::getUsingDirectiveName();
9537 }
9538
9539 llvm_unreachable("Invalid DeclarationName Kind!");
9540 }
9541
Import(const IdentifierInfo * FromId)9542 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
9543 if (!FromId)
9544 return nullptr;
9545
9546 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
9547
9548 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
9549 ToId->setBuiltinID(FromId->getBuiltinID());
9550
9551 return ToId;
9552 }
9553
Import(Selector FromSel)9554 Expected<Selector> ASTImporter::Import(Selector FromSel) {
9555 if (FromSel.isNull())
9556 return Selector{};
9557
9558 SmallVector<IdentifierInfo *, 4> Idents;
9559 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
9560 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
9561 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
9562 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
9563 }
9564
9565 llvm::Expected<APValue>
ImportAPValue(const APValue & FromValue)9566 ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
9567 APValue Result;
9568 llvm::Error Err = llvm::Error::success();
9569 auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
9570 for (unsigned Idx = 0; Idx < Size; Idx++) {
9571 APValue Tmp = importChecked(Err, From[Idx]);
9572 To[Idx] = Tmp;
9573 }
9574 };
9575 switch (FromValue.getKind()) {
9576 case APValue::None:
9577 case APValue::Indeterminate:
9578 case APValue::Int:
9579 case APValue::Float:
9580 case APValue::FixedPoint:
9581 case APValue::ComplexInt:
9582 case APValue::ComplexFloat:
9583 Result = FromValue;
9584 break;
9585 case APValue::Vector: {
9586 Result.MakeVector();
9587 MutableArrayRef<APValue> Elts =
9588 Result.setVectorUninit(FromValue.getVectorLength());
9589 ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
9590 Elts.data(), FromValue.getVectorLength());
9591 break;
9592 }
9593 case APValue::Array:
9594 Result.MakeArray(FromValue.getArrayInitializedElts(),
9595 FromValue.getArraySize());
9596 ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
9597 ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
9598 FromValue.getArrayInitializedElts());
9599 break;
9600 case APValue::Struct:
9601 Result.MakeStruct(FromValue.getStructNumBases(),
9602 FromValue.getStructNumFields());
9603 ImportLoop(
9604 ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
9605 ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
9606 FromValue.getStructNumBases() + FromValue.getStructNumFields());
9607 break;
9608 case APValue::Union: {
9609 Result.MakeUnion();
9610 const Decl *ImpFDecl = importChecked(Err, FromValue.getUnionField());
9611 APValue ImpValue = importChecked(Err, FromValue.getUnionValue());
9612 if (Err)
9613 return std::move(Err);
9614 Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
9615 break;
9616 }
9617 case APValue::AddrLabelDiff: {
9618 Result.MakeAddrLabelDiff();
9619 const Expr *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
9620 const Expr *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
9621 if (Err)
9622 return std::move(Err);
9623 Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
9624 cast<AddrLabelExpr>(ImpRHS));
9625 break;
9626 }
9627 case APValue::MemberPointer: {
9628 const Decl *ImpMemPtrDecl =
9629 importChecked(Err, FromValue.getMemberPointerDecl());
9630 if (Err)
9631 return std::move(Err);
9632 MutableArrayRef<const CXXRecordDecl *> ToPath =
9633 Result.setMemberPointerUninit(
9634 cast<const ValueDecl>(ImpMemPtrDecl),
9635 FromValue.isMemberPointerToDerivedMember(),
9636 FromValue.getMemberPointerPath().size());
9637 llvm::ArrayRef<const CXXRecordDecl *> FromPath =
9638 Result.getMemberPointerPath();
9639 for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
9640 Idx++) {
9641 const Decl *ImpDecl = importChecked(Err, FromPath[Idx]);
9642 if (Err)
9643 return std::move(Err);
9644 ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
9645 }
9646 break;
9647 }
9648 case APValue::LValue:
9649 APValue::LValueBase Base;
9650 QualType FromElemTy;
9651 if (FromValue.getLValueBase()) {
9652 assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&
9653 "in C++20 dynamic allocation are transient so they shouldn't "
9654 "appear in the AST");
9655 if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
9656 if (const auto *E =
9657 FromValue.getLValueBase().dyn_cast<const Expr *>()) {
9658 FromElemTy = E->getType();
9659 const Expr *ImpExpr = importChecked(Err, E);
9660 if (Err)
9661 return std::move(Err);
9662 Base = APValue::LValueBase(ImpExpr,
9663 FromValue.getLValueBase().getCallIndex(),
9664 FromValue.getLValueBase().getVersion());
9665 } else {
9666 FromElemTy =
9667 FromValue.getLValueBase().get<const ValueDecl *>()->getType();
9668 const Decl *ImpDecl = importChecked(
9669 Err, FromValue.getLValueBase().get<const ValueDecl *>());
9670 if (Err)
9671 return std::move(Err);
9672 Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
9673 FromValue.getLValueBase().getCallIndex(),
9674 FromValue.getLValueBase().getVersion());
9675 }
9676 } else {
9677 FromElemTy = FromValue.getLValueBase().getTypeInfoType();
9678 const Type *ImpTypeInfo = importChecked(
9679 Err, FromValue.getLValueBase().get<TypeInfoLValue>().getType());
9680 QualType ImpType =
9681 importChecked(Err, FromValue.getLValueBase().getTypeInfoType());
9682 if (Err)
9683 return std::move(Err);
9684 Base = APValue::LValueBase::getTypeInfo(TypeInfoLValue(ImpTypeInfo),
9685 ImpType);
9686 }
9687 }
9688 CharUnits Offset = FromValue.getLValueOffset();
9689 unsigned PathLength = FromValue.getLValuePath().size();
9690 Result.MakeLValue();
9691 if (FromValue.hasLValuePath()) {
9692 MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
9693 Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
9694 FromValue.isNullPointer());
9695 llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
9696 FromValue.getLValuePath();
9697 for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
9698 if (FromElemTy->isRecordType()) {
9699 const Decl *FromDecl =
9700 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
9701 const Decl *ImpDecl = importChecked(Err, FromDecl);
9702 if (Err)
9703 return std::move(Err);
9704 if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
9705 FromElemTy = Importer.FromContext.getRecordType(RD);
9706 else
9707 FromElemTy = cast<ValueDecl>(FromDecl)->getType();
9708 ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
9709 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
9710 } else {
9711 FromElemTy =
9712 Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
9713 ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
9714 FromPath[LoopIdx].getAsArrayIndex());
9715 }
9716 }
9717 } else
9718 Result.setLValue(Base, Offset, APValue::NoLValuePath{},
9719 FromValue.isNullPointer());
9720 }
9721 if (Err)
9722 return std::move(Err);
9723 return Result;
9724 }
9725
HandleNameConflict(DeclarationName Name,DeclContext * DC,unsigned IDNS,NamedDecl ** Decls,unsigned NumDecls)9726 Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
9727 DeclContext *DC,
9728 unsigned IDNS,
9729 NamedDecl **Decls,
9730 unsigned NumDecls) {
9731 if (ODRHandling == ODRHandlingType::Conservative)
9732 // Report error at any name conflict.
9733 return make_error<ImportError>(ImportError::NameConflict);
9734 else
9735 // Allow to create the new Decl with the same name.
9736 return Name;
9737 }
9738
ToDiag(SourceLocation Loc,unsigned DiagID)9739 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
9740 if (LastDiagFromFrom)
9741 ToContext.getDiagnostics().notePriorDiagnosticFrom(
9742 FromContext.getDiagnostics());
9743 LastDiagFromFrom = false;
9744 return ToContext.getDiagnostics().Report(Loc, DiagID);
9745 }
9746
FromDiag(SourceLocation Loc,unsigned DiagID)9747 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
9748 if (!LastDiagFromFrom)
9749 FromContext.getDiagnostics().notePriorDiagnosticFrom(
9750 ToContext.getDiagnostics());
9751 LastDiagFromFrom = true;
9752 return FromContext.getDiagnostics().Report(Loc, DiagID);
9753 }
9754
CompleteDecl(Decl * D)9755 void ASTImporter::CompleteDecl (Decl *D) {
9756 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9757 if (!ID->getDefinition())
9758 ID->startDefinition();
9759 }
9760 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
9761 if (!PD->getDefinition())
9762 PD->startDefinition();
9763 }
9764 else if (auto *TD = dyn_cast<TagDecl>(D)) {
9765 if (!TD->getDefinition() && !TD->isBeingDefined()) {
9766 TD->startDefinition();
9767 TD->setCompleteDefinition(true);
9768 }
9769 }
9770 else {
9771 assert(0 && "CompleteDecl called on a Decl that can't be completed");
9772 }
9773 }
9774
MapImported(Decl * From,Decl * To)9775 Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
9776 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
9777 assert((Pos == ImportedDecls.end() || Pos->second == To) &&
9778 "Try to import an already imported Decl");
9779 if (Pos != ImportedDecls.end())
9780 return Pos->second;
9781 ImportedDecls[From] = To;
9782 // This mapping should be maintained only in this function. Therefore do not
9783 // check for additional consistency.
9784 ImportedFromDecls[To] = From;
9785 // In the case of TypedefNameDecl we create the Decl first and only then we
9786 // import and set its DeclContext. So, the DC is still not set when we reach
9787 // here from GetImportedOrCreateDecl.
9788 if (To->getDeclContext())
9789 AddToLookupTable(To);
9790 return To;
9791 }
9792
9793 llvm::Optional<ImportError>
getImportDeclErrorIfAny(Decl * FromD) const9794 ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
9795 auto Pos = ImportDeclErrors.find(FromD);
9796 if (Pos != ImportDeclErrors.end())
9797 return Pos->second;
9798 else
9799 return Optional<ImportError>();
9800 }
9801
setImportDeclError(Decl * From,ImportError Error)9802 void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
9803 auto InsertRes = ImportDeclErrors.insert({From, Error});
9804 (void)InsertRes;
9805 // Either we set the error for the first time, or we already had set one and
9806 // now we want to set the same error.
9807 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
9808 }
9809
IsStructurallyEquivalent(QualType From,QualType To,bool Complain)9810 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
9811 bool Complain) {
9812 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9813 ImportedTypes.find(From.getTypePtr());
9814 if (Pos != ImportedTypes.end()) {
9815 if (ExpectedType ToFromOrErr = Import(From)) {
9816 if (ToContext.hasSameType(*ToFromOrErr, To))
9817 return true;
9818 } else {
9819 llvm::consumeError(ToFromOrErr.takeError());
9820 }
9821 }
9822
9823 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
9824 getStructuralEquivalenceKind(*this), false,
9825 Complain);
9826 return Ctx.IsEquivalent(From, To);
9827 }
9828