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