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/ASTContext.h"
16#include "clang/AST/ASTDiagnostic.h"
17#include "clang/AST/ASTImporterSharedState.h"
18#include "clang/AST/ASTLambda.h"
19#include "clang/AST/ASTStructuralEquivalence.h"
20#include "clang/AST/Attr.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclAccessPair.h"
23#include "clang/AST/DeclBase.h"
24#include "clang/AST/DeclCXX.h"
25#include "clang/AST/DeclFriend.h"
26#include "clang/AST/DeclGroup.h"
27#include "clang/AST/DeclObjC.h"
28#include "clang/AST/DeclTemplate.h"
29#include "clang/AST/DeclVisitor.h"
30#include "clang/AST/DeclarationName.h"
31#include "clang/AST/Expr.h"
32#include "clang/AST/ExprCXX.h"
33#include "clang/AST/ExprObjC.h"
34#include "clang/AST/ExternalASTSource.h"
35#include "clang/AST/LambdaCapture.h"
36#include "clang/AST/NestedNameSpecifier.h"
37#include "clang/AST/OperationKinds.h"
38#include "clang/AST/Stmt.h"
39#include "clang/AST/StmtCXX.h"
40#include "clang/AST/StmtObjC.h"
41#include "clang/AST/StmtVisitor.h"
42#include "clang/AST/TemplateBase.h"
43#include "clang/AST/TemplateName.h"
44#include "clang/AST/Type.h"
45#include "clang/AST/TypeLoc.h"
46#include "clang/AST/TypeVisitor.h"
47#include "clang/AST/UnresolvedSet.h"
48#include "clang/Basic/Builtins.h"
49#include "clang/Basic/ExceptionSpecificationType.h"
50#include "clang/Basic/FileManager.h"
51#include "clang/Basic/IdentifierTable.h"
52#include "clang/Basic/LLVM.h"
53#include "clang/Basic/LangOptions.h"
54#include "clang/Basic/SourceLocation.h"
55#include "clang/Basic/SourceManager.h"
56#include "clang/Basic/Specifiers.h"
57#include "llvm/ADT/ArrayRef.h"
58#include "llvm/ADT/DenseMap.h"
59#include "llvm/ADT/STLExtras.h"
60#include "llvm/ADT/ScopeExit.h"
61#include "llvm/ADT/SmallVector.h"
62#include "llvm/Support/ErrorHandling.h"
63#include "llvm/Support/MemoryBuffer.h"
64#include <algorithm>
65#include <cassert>
66#include <cstddef>
67#include <memory>
68#include <optional>
69#include <type_traits>
70#include <utility>
71
72namespace clang {
73
74 using llvm::make_error;
75 using llvm::Error;
76 using llvm::Expected;
77 using ExpectedTypePtr = llvm::Expected<const Type *>;
78 using ExpectedType = llvm::Expected<QualType>;
79 using ExpectedStmt = llvm::Expected<Stmt *>;
80 using ExpectedExpr = llvm::Expected<Expr *>;
81 using ExpectedDecl = llvm::Expected<Decl *>;
82 using ExpectedSLoc = llvm::Expected<SourceLocation>;
83 using ExpectedName = llvm::Expected<DeclarationName>;
84
85 std::string ASTImportError::toString() const {
86 // FIXME: Improve error texts.
87 switch (Error) {
88 case NameConflict:
89 return "NameConflict";
90 case UnsupportedConstruct:
91 return "UnsupportedConstruct";
92 case Unknown:
93 return "Unknown error";
94 }
95 llvm_unreachable("Invalid error code.");
96 return "Invalid error code.";
97 }
98
99 void ASTImportError::log(raw_ostream &OS) const { OS << toString(); }
100
101 std::error_code ASTImportError::convertToErrorCode() const {
102 llvm_unreachable("Function not implemented.");
103 }
104
105 char ASTImportError::ID;
106
107 template <class T>
108 static SmallVector<Decl *, 2>
109 getCanonicalForwardRedeclChain(Redeclarable<T> *D) {
110 SmallVector<Decl *, 2> Redecls;
111 for (auto *R : D->getFirstDecl()->redecls()) {
112 if (R != D->getFirstDecl())
113 Redecls.push_back(Elt: R);
114 }
115 Redecls.push_back(Elt: D->getFirstDecl());
116 std::reverse(first: Redecls.begin(), last: Redecls.end());
117 return Redecls;
118 }
119
120 SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
121 if (auto *FD = dyn_cast<FunctionDecl>(Val: D))
122 return getCanonicalForwardRedeclChain<FunctionDecl>(D: FD);
123 if (auto *VD = dyn_cast<VarDecl>(Val: D))
124 return getCanonicalForwardRedeclChain<VarDecl>(D: VD);
125 if (auto *TD = dyn_cast<TagDecl>(Val: D))
126 return getCanonicalForwardRedeclChain<TagDecl>(D: TD);
127 llvm_unreachable("Bad declaration kind");
128 }
129
130 static void updateFlags(const Decl *From, Decl *To) {
131 // Check if some flags or attrs are new in 'From' and copy into 'To'.
132 // FIXME: Other flags or attrs?
133 if (From->isUsed(CheckUsedAttr: false) && !To->isUsed(CheckUsedAttr: false))
134 To->setIsUsed();
135 }
136
137 /// How to handle import errors that occur when import of a child declaration
138 /// of a DeclContext fails.
139 class ChildErrorHandlingStrategy {
140 /// This context is imported (in the 'from' domain).
141 /// It is nullptr if a non-DeclContext is imported.
142 const DeclContext *const FromDC;
143 /// Ignore import errors of the children.
144 /// If true, the context can be imported successfully if a child
145 /// of it failed to import. Otherwise the import errors of the child nodes
146 /// are accumulated (joined) into the import error object of the parent.
147 /// (Import of a parent can fail in other ways.)
148 bool const IgnoreChildErrors;
149
150 public:
151 ChildErrorHandlingStrategy(const DeclContext *FromDC)
152 : FromDC(FromDC), IgnoreChildErrors(!isa<TagDecl>(Val: FromDC)) {}
153 ChildErrorHandlingStrategy(const Decl *FromD)
154 : FromDC(dyn_cast<DeclContext>(Val: FromD)),
155 IgnoreChildErrors(!isa<TagDecl>(Val: FromD)) {}
156
157 /// Process the import result of a child (of the current declaration).
158 /// \param ResultErr The import error that can be used as result of
159 /// importing the parent. This may be changed by the function.
160 /// \param ChildErr Result of importing a child. Can be success or error.
161 void handleChildImportResult(Error &ResultErr, Error &&ChildErr) {
162 if (ChildErr && !IgnoreChildErrors)
163 ResultErr = joinErrors(E1: std::move(ResultErr), E2: std::move(ChildErr));
164 else
165 consumeError(Err: std::move(ChildErr));
166 }
167
168 /// Determine if import failure of a child does not cause import failure of
169 /// its parent.
170 bool ignoreChildErrorOnParent(Decl *FromChildD) const {
171 if (!IgnoreChildErrors || !FromDC)
172 return false;
173 return FromDC->containsDecl(D: FromChildD);
174 }
175 };
176
177 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
178 public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
179 public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
180 ASTImporter &Importer;
181
182 // Use this instead of Importer.importInto .
183 template <typename ImportT>
184 [[nodiscard]] Error importInto(ImportT &To, const ImportT &From) {
185 return Importer.importInto(To, From);
186 }
187
188 Expected<FriendDecl::FriendUnion> importFriendUnion(FriendDecl *D);
189
190 // Use this to import pointers of specific type.
191 template <typename ImportT>
192 [[nodiscard]] Error importInto(ImportT *&To, ImportT *From) {
193 auto ToOrErr = Importer.Import(From);
194 if (ToOrErr)
195 To = cast_or_null<ImportT>(*ToOrErr);
196 return ToOrErr.takeError();
197 }
198
199 // Call the import function of ASTImporter for a baseclass of type `T` and
200 // cast the return value to `T`.
201 template <typename T>
202 auto import(T *From)
203 -> std::conditional_t<std::is_base_of_v<Type, T>, Expected<const T *>,
204 Expected<T *>> {
205 auto ToOrErr = Importer.Import(From);
206 if (!ToOrErr)
207 return ToOrErr.takeError();
208 return cast_or_null<T>(*ToOrErr);
209 }
210
211 template <typename T>
212 auto import(const T *From) {
213 return import(const_cast<T *>(From));
214 }
215
216 // Call the import function of ASTImporter for type `T`.
217 template <typename T>
218 Expected<T> import(const T &From) {
219 return Importer.Import(From);
220 }
221
222 // Import an std::optional<T> by importing the contained T, if any.
223 template <typename T>
224 Expected<std::optional<T>> import(std::optional<T> From) {
225 if (!From)
226 return std::nullopt;
227 return import(*From);
228 }
229
230 ExplicitSpecifier importExplicitSpecifier(Error &Err,
231 ExplicitSpecifier ESpec);
232
233 // Wrapper for an overload set.
234 template <typename ToDeclT> struct CallOverloadedCreateFun {
235 template <typename... Args> decltype(auto) operator()(Args &&... args) {
236 return ToDeclT::Create(std::forward<Args>(args)...);
237 }
238 };
239
240 // Always use these functions to create a Decl during import. There are
241 // certain tasks which must be done after the Decl was created, e.g. we
242 // must immediately register that as an imported Decl. The parameter `ToD`
243 // will be set to the newly created Decl or if had been imported before
244 // then to the already imported Decl. Returns a bool value set to true if
245 // the `FromD` had been imported before.
246 template <typename ToDeclT, typename FromDeclT, typename... Args>
247 [[nodiscard]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
248 Args &&...args) {
249 // There may be several overloads of ToDeclT::Create. We must make sure
250 // to call the one which would be chosen by the arguments, thus we use a
251 // wrapper for the overload set.
252 CallOverloadedCreateFun<ToDeclT> OC;
253 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
254 std::forward<Args>(args)...);
255 }
256 // Use this overload if a special Type is needed to be created. E.g if we
257 // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
258 // then:
259 // TypedefNameDecl *ToTypedef;
260 // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
261 template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
262 typename... Args>
263 [[nodiscard]] bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
264 Args &&...args) {
265 CallOverloadedCreateFun<NewDeclT> OC;
266 return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
267 std::forward<Args>(args)...);
268 }
269 // Use this version if a special create function must be
270 // used, e.g. CXXRecordDecl::CreateLambda .
271 template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
272 typename... Args>
273 [[nodiscard]] bool
274 GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
275 FromDeclT *FromD, Args &&...args) {
276 if (Importer.getImportDeclErrorIfAny(FromD)) {
277 ToD = nullptr;
278 return true; // Already imported but with error.
279 }
280 ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
281 if (ToD)
282 return true; // Already imported.
283 ToD = CreateFun(std::forward<Args>(args)...);
284 // Keep track of imported Decls.
285 Importer.RegisterImportedDecl(FromD, ToD);
286 Importer.SharedState->markAsNewDecl(ToD);
287 InitializeImportedDecl(FromD, ToD);
288 return false; // A new Decl is created.
289 }
290
291 void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
292 ToD->IdentifierNamespace = FromD->IdentifierNamespace;
293 if (FromD->isUsed())
294 ToD->setIsUsed();
295 if (FromD->isImplicit())
296 ToD->setImplicit();
297 }
298
299 // Check if we have found an existing definition. Returns with that
300 // definition if yes, otherwise returns null.
301 Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
302 const FunctionDecl *Definition = nullptr;
303 if (D->doesThisDeclarationHaveABody() &&
304 FoundFunction->hasBody(Definition))
305 return Importer.MapImported(From: D, To: const_cast<FunctionDecl *>(Definition));
306 return nullptr;
307 }
308
309 void addDeclToContexts(Decl *FromD, Decl *ToD) {
310 if (Importer.isMinimalImport()) {
311 // In minimal import case the decl must be added even if it is not
312 // contained in original context, for LLDB compatibility.
313 // FIXME: Check if a better solution is possible.
314 if (!FromD->getDescribedTemplate() &&
315 FromD->getFriendObjectKind() == Decl::FOK_None)
316 ToD->getLexicalDeclContext()->addDeclInternal(D: ToD);
317 return;
318 }
319
320 DeclContext *FromDC = FromD->getDeclContext();
321 DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
322 DeclContext *ToDC = ToD->getDeclContext();
323 DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
324
325 bool Visible = false;
326 if (FromDC->containsDeclAndLoad(D: FromD)) {
327 ToDC->addDeclInternal(D: ToD);
328 Visible = true;
329 }
330 if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(D: FromD)) {
331 ToLexicalDC->addDeclInternal(D: ToD);
332 Visible = true;
333 }
334
335 // If the Decl was added to any context, it was made already visible.
336 // Otherwise it is still possible that it should be visible.
337 if (!Visible) {
338 if (auto *FromNamed = dyn_cast<NamedDecl>(Val: FromD)) {
339 auto *ToNamed = cast<NamedDecl>(Val: ToD);
340 DeclContextLookupResult FromLookup =
341 FromDC->lookup(Name: FromNamed->getDeclName());
342 if (llvm::is_contained(Range&: FromLookup, Element: FromNamed))
343 ToDC->makeDeclVisibleInContext(D: ToNamed);
344 }
345 }
346 }
347
348 void updateLookupTableForTemplateParameters(TemplateParameterList &Params,
349 DeclContext *OldDC) {
350 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
351 if (!LT)
352 return;
353
354 for (NamedDecl *TP : Params)
355 LT->update(ND: TP, OldDC);
356 }
357
358 void updateLookupTableForTemplateParameters(TemplateParameterList &Params) {
359 updateLookupTableForTemplateParameters(
360 Params, OldDC: Importer.getToContext().getTranslationUnitDecl());
361 }
362
363 template <typename TemplateParmDeclT>
364 Error importTemplateParameterDefaultArgument(const TemplateParmDeclT *D,
365 TemplateParmDeclT *ToD) {
366 if (D->hasDefaultArgument()) {
367 if (D->defaultArgumentWasInherited()) {
368 Expected<TemplateParmDeclT *> ToInheritedFromOrErr =
369 import(D->getDefaultArgStorage().getInheritedFrom());
370 if (!ToInheritedFromOrErr)
371 return ToInheritedFromOrErr.takeError();
372 TemplateParmDeclT *ToInheritedFrom = *ToInheritedFromOrErr;
373 if (!ToInheritedFrom->hasDefaultArgument()) {
374 // Resolve possible circular dependency between default value of the
375 // template argument and the template declaration.
376 Expected<TemplateArgumentLoc> ToInheritedDefaultArgOrErr =
377 import(D->getDefaultArgStorage()
378 .getInheritedFrom()
379 ->getDefaultArgument());
380 if (!ToInheritedDefaultArgOrErr)
381 return ToInheritedDefaultArgOrErr.takeError();
382 ToInheritedFrom->setDefaultArgument(Importer.getToContext(),
383 *ToInheritedDefaultArgOrErr);
384 }
385 ToD->setInheritedDefaultArgument(ToD->getASTContext(),
386 ToInheritedFrom);
387 } else {
388 Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
389 import(D->getDefaultArgument());
390 if (!ToDefaultArgOrErr)
391 return ToDefaultArgOrErr.takeError();
392 // Default argument could have been set in the
393 // '!ToInheritedFrom->hasDefaultArgument()' branch above.
394 if (!ToD->hasDefaultArgument())
395 ToD->setDefaultArgument(Importer.getToContext(),
396 *ToDefaultArgOrErr);
397 }
398 }
399 return Error::success();
400 }
401
402 public:
403 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
404
405 using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
406 using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
407 using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
408
409 // Importing types
410 ExpectedType VisitType(const Type *T);
411#define TYPE(Class, Base) \
412 ExpectedType Visit##Class##Type(const Class##Type *T);
413#include "clang/AST/TypeNodes.inc"
414
415 // Importing declarations
416 Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
417 SourceLocation &Loc);
418 Error ImportDeclParts(
419 NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
420 DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc);
421 Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
422 Error ImportDeclarationNameLoc(
423 const DeclarationNameInfo &From, DeclarationNameInfo &To);
424 Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
425 Error ImportDeclContext(
426 Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
427 Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
428
429 Error ImportFieldDeclDefinition(const FieldDecl *From, const FieldDecl *To);
430 Expected<CXXCastPath> ImportCastPath(CastExpr *E);
431 Expected<APValue> ImportAPValue(const APValue &FromValue);
432
433 using Designator = DesignatedInitExpr::Designator;
434
435 /// What we should import from the definition.
436 enum ImportDefinitionKind {
437 /// Import the default subset of the definition, which might be
438 /// nothing (if minimal import is set) or might be everything (if minimal
439 /// import is not set).
440 IDK_Default,
441 /// Import everything.
442 IDK_Everything,
443 /// Import only the bare bones needed to establish a valid
444 /// DeclContext.
445 IDK_Basic
446 };
447
448 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
449 return IDK == IDK_Everything ||
450 (IDK == IDK_Default && !Importer.isMinimalImport());
451 }
452
453 Error ImportInitializer(VarDecl *From, VarDecl *To);
454 Error ImportDefinition(
455 RecordDecl *From, RecordDecl *To,
456 ImportDefinitionKind Kind = IDK_Default);
457 Error ImportDefinition(
458 EnumDecl *From, EnumDecl *To,
459 ImportDefinitionKind Kind = IDK_Default);
460 Error ImportDefinition(
461 ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
462 ImportDefinitionKind Kind = IDK_Default);
463 Error ImportDefinition(
464 ObjCProtocolDecl *From, ObjCProtocolDecl *To,
465 ImportDefinitionKind Kind = IDK_Default);
466 Error ImportTemplateArguments(ArrayRef<TemplateArgument> FromArgs,
467 SmallVectorImpl<TemplateArgument> &ToArgs);
468 Expected<TemplateArgument>
469 ImportTemplateArgument(const TemplateArgument &From);
470
471 template <typename InContainerTy>
472 Error ImportTemplateArgumentListInfo(
473 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
474
475 template<typename InContainerTy>
476 Error ImportTemplateArgumentListInfo(
477 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
478 const InContainerTy &Container, TemplateArgumentListInfo &Result);
479
480 using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
481 using FunctionTemplateAndArgsTy =
482 std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
483 Expected<FunctionTemplateAndArgsTy>
484 ImportFunctionTemplateWithTemplateArgsFromSpecialization(
485 FunctionDecl *FromFD);
486
487 template <typename DeclTy>
488 Error ImportTemplateParameterLists(const DeclTy *FromD, DeclTy *ToD);
489
490 Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
491
492 Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
493
494 Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
495 ParmVarDecl *ToParam);
496
497 Expected<InheritedConstructor>
498 ImportInheritedConstructor(const InheritedConstructor &From);
499
500 // Use for allocating string for newly imported object.
501 StringRef ImportASTStringRef(StringRef FromStr);
502 Error ImportConstraintSatisfaction(const ASTConstraintSatisfaction &FromSat,
503 ConstraintSatisfaction &ToSat);
504 Expected<concepts::Requirement *>
505 ImportTypeRequirement(concepts::TypeRequirement *From);
506 Expected<concepts::Requirement *>
507 ImportExprRequirement(concepts::ExprRequirement *From);
508 Expected<concepts::Requirement *>
509 ImportNestedRequirement(concepts::NestedRequirement *From);
510
511 template <typename T>
512 bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
513
514 bool IsStructuralMatch(Decl *From, Decl *To, bool Complain = true,
515 bool IgnoreTemplateParmDepth = false);
516 ExpectedDecl VisitDecl(Decl *D);
517 ExpectedDecl VisitImportDecl(ImportDecl *D);
518 ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
519 ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
520 ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
521 ExpectedDecl VisitCXXExpansionStmtDecl(CXXExpansionStmtDecl *D);
522 ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
523 ExpectedDecl VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
524 ExpectedDecl VisitBindingDecl(BindingDecl *D);
525 ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
526 ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
527 ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
528 ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
529 ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
530 ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
531 ExpectedDecl VisitLabelDecl(LabelDecl *D);
532 ExpectedDecl VisitEnumDecl(EnumDecl *D);
533 ExpectedDecl VisitRecordDecl(RecordDecl *D);
534 ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
535 ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
536 ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
537 ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
538 ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
539 ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
540 ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
541 ExpectedDecl VisitFieldDecl(FieldDecl *D);
542 ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
543 ExpectedDecl VisitFriendDecl(FriendDecl *D);
544 ExpectedDecl VisitFriendTemplateDecl(FriendTemplateDecl *D);
545 ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
546 ExpectedDecl VisitVarDecl(VarDecl *D);
547 ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
548 ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
549 ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
550 ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
551 ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
552 ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
553 ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
554 ExpectedDecl VisitUsingDecl(UsingDecl *D);
555 ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
556 ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
557 ExpectedDecl VisitUsingPackDecl(UsingPackDecl *D);
558 ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI);
559 ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D);
560 ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
561 ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
562 ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
563 ExpectedDecl
564 VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
565
566 Expected<ObjCTypeParamList *>
567 ImportObjCTypeParamList(ObjCTypeParamList *list);
568
569 ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
570 ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
571 ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
572 ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
573 ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
574 ExpectedDecl VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
575 ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
576 ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
577 ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
578 ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
579 ExpectedDecl VisitClassTemplateSpecializationDecl(
580 ClassTemplateSpecializationDecl *D);
581 ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
582 ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
583 ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
584 ExpectedDecl VisitConceptDecl(ConceptDecl* D);
585 ExpectedDecl VisitRequiresExprBodyDecl(RequiresExprBodyDecl* E);
586 ExpectedDecl VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl* D);
587
588 // Importing statements
589 ExpectedStmt VisitStmt(Stmt *S);
590 ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
591 ExpectedStmt VisitDeclStmt(DeclStmt *S);
592 ExpectedStmt VisitNullStmt(NullStmt *S);
593 ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
594 ExpectedStmt VisitCaseStmt(CaseStmt *S);
595 ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
596 ExpectedStmt VisitLabelStmt(LabelStmt *S);
597 ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
598 ExpectedStmt VisitIfStmt(IfStmt *S);
599 ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
600 ExpectedStmt VisitWhileStmt(WhileStmt *S);
601 ExpectedStmt VisitDoStmt(DoStmt *S);
602 ExpectedStmt VisitForStmt(ForStmt *S);
603 ExpectedStmt VisitGotoStmt(GotoStmt *S);
604 ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
605 ExpectedStmt VisitContinueStmt(ContinueStmt *S);
606 ExpectedStmt VisitBreakStmt(BreakStmt *S);
607 ExpectedStmt VisitReturnStmt(ReturnStmt *S);
608 // FIXME: MSAsmStmt
609 // FIXME: SEHExceptStmt
610 // FIXME: SEHFinallyStmt
611 // FIXME: SEHTryStmt
612 // FIXME: SEHLeaveStmt
613 // FIXME: CapturedStmt
614 ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
615 ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
616 ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
617 ExpectedStmt VisitCXXExpansionStmtPattern(CXXExpansionStmtPattern *S);
618 ExpectedStmt
619 VisitCXXExpansionStmtInstantiation(CXXExpansionStmtInstantiation *S);
620 // FIXME: MSDependentExistsStmt
621 ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
622 ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
623 ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
624 ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
625 ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
626 ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
627 ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
628
629 // Importing expressions
630 ExpectedStmt VisitExpr(Expr *E);
631 ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
632 ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
633 ExpectedStmt VisitChooseExpr(ChooseExpr *E);
634 ExpectedStmt VisitConvertVectorExpr(ConvertVectorExpr *E);
635 ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E);
636 ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
637 ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
638 ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
639 ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
640 ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
641 ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
642 ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
643 ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
644 ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
645 ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
646 ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
647 ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
648 ExpectedStmt VisitStringLiteral(StringLiteral *E);
649 ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
650 ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
651 ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
652 ExpectedStmt VisitConstantExpr(ConstantExpr *E);
653 ExpectedStmt VisitParenExpr(ParenExpr *E);
654 ExpectedStmt VisitParenListExpr(ParenListExpr *E);
655 ExpectedStmt VisitStmtExpr(StmtExpr *E);
656 ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
657 ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
658 ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
659 ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
660 ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
661 ExpectedStmt VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E);
662 ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
663 ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
664 ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
665 ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
666 ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
667 ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
668 ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
669 ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
670 ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
671 ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
672 ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
673 ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
674 ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
675 ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
676 ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
677 ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
678 ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
679 ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
680 ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
681 ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
682 ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
683 ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
684 ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
685 ExpectedStmt VisitDependentTemplateIdExpr(DependentTemplateIdExpr *E);
686 ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
687 ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
688 ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
689 ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
690 ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
691 ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
692 ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
693 ExpectedStmt VisitMemberExpr(MemberExpr *E);
694 ExpectedStmt VisitCallExpr(CallExpr *E);
695 ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
696 ExpectedStmt VisitInitListExpr(InitListExpr *E);
697 ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
698 ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
699 ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
700 ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
701 ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
702 ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
703 ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
704 ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
705 ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
706 ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
707 ExpectedStmt VisitRequiresExpr(RequiresExpr* E);
708 ExpectedStmt VisitConceptSpecializationExpr(ConceptSpecializationExpr* E);
709 ExpectedStmt
710 VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *E);
711 ExpectedStmt VisitPseudoObjectExpr(PseudoObjectExpr *E);
712 ExpectedStmt VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
713 ExpectedStmt VisitCXXExpansionSelectExpr(CXXExpansionSelectExpr *E);
714
715 // Helper for chaining together multiple imports. If an error is detected,
716 // subsequent imports will return default constructed nodes, so that failure
717 // can be detected with a single conditional branch after a sequence of
718 // imports.
719 template <typename T> T importChecked(Error &Err, const T &From) {
720 // Don't attempt to import nodes if we hit an error earlier.
721 if (Err)
722 return T{};
723 Expected<T> MaybeVal = import(From);
724 if (!MaybeVal) {
725 Err = MaybeVal.takeError();
726 return T{};
727 }
728 return *MaybeVal;
729 }
730
731 template<typename IIter, typename OIter>
732 Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
733 using ItemT = std::remove_reference_t<decltype(*Obegin)>;
734 for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
735 Expected<ItemT> ToOrErr = import(*Ibegin);
736 if (!ToOrErr)
737 return ToOrErr.takeError();
738 *Obegin = *ToOrErr;
739 }
740 return Error::success();
741 }
742
743 // Import every item from a container structure into an output container.
744 // If error occurs, stops at first error and returns the error.
745 // The output container should have space for all needed elements (it is not
746 // expanded, new items are put into from the beginning).
747 template<typename InContainerTy, typename OutContainerTy>
748 Error ImportContainerChecked(
749 const InContainerTy &InContainer, OutContainerTy &OutContainer) {
750 return ImportArrayChecked(
751 InContainer.begin(), InContainer.end(), OutContainer.begin());
752 }
753
754 template<typename InContainerTy, typename OIter>
755 Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
756 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
757 }
758
759 Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
760 CXXMethodDecl *FromMethod);
761
762 Expected<FunctionDecl *>
763 FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
764 };
765
766template <typename InContainerTy>
767Error ASTNodeImporter::ImportTemplateArgumentListInfo(
768 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
769 const InContainerTy &Container, TemplateArgumentListInfo &Result) {
770 auto ToLAngleLocOrErr = import(From: FromLAngleLoc);
771 if (!ToLAngleLocOrErr)
772 return ToLAngleLocOrErr.takeError();
773 auto ToRAngleLocOrErr = import(From: FromRAngleLoc);
774 if (!ToRAngleLocOrErr)
775 return ToRAngleLocOrErr.takeError();
776
777 TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
778 if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo))
779 return Err;
780 Result = std::move(ToTAInfo);
781 return Error::success();
782}
783
784template <>
785Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
786 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
787 return ImportTemplateArgumentListInfo(
788 FromLAngleLoc: From.getLAngleLoc(), FromRAngleLoc: From.getRAngleLoc(), Container: From.arguments(), Result);
789}
790
791template <>
792Error ASTNodeImporter::ImportTemplateArgumentListInfo<
793 ASTTemplateArgumentListInfo>(
794 const ASTTemplateArgumentListInfo &From,
795 TemplateArgumentListInfo &Result) {
796 return ImportTemplateArgumentListInfo(
797 FromLAngleLoc: From.LAngleLoc, FromRAngleLoc: From.RAngleLoc, Container: From.arguments(), Result);
798}
799
800Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
801ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
802 FunctionDecl *FromFD) {
803 assert(FromFD->getTemplatedKind() ==
804 FunctionDecl::TK_FunctionTemplateSpecialization);
805
806 FunctionTemplateAndArgsTy Result;
807
808 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
809 if (Error Err = importInto(To&: std::get<0>(t&: Result), From: FTSInfo->getTemplate()))
810 return std::move(Err);
811
812 // Import template arguments.
813 if (Error Err = ImportTemplateArguments(FromArgs: FTSInfo->TemplateArguments->asArray(),
814 ToArgs&: std::get<1>(t&: Result)))
815 return std::move(Err);
816
817 return Result;
818}
819
820template <>
821Expected<TemplateParameterList *>
822ASTNodeImporter::import(TemplateParameterList *From) {
823 SmallVector<NamedDecl *, 4> To(From->size());
824 if (Error Err = ImportContainerChecked(InContainer: *From, OutContainer&: To))
825 return std::move(Err);
826
827 ExpectedExpr ToRequiresClause = import(From: From->getRequiresClause());
828 if (!ToRequiresClause)
829 return ToRequiresClause.takeError();
830
831 auto ToTemplateLocOrErr = import(From: From->getTemplateLoc());
832 if (!ToTemplateLocOrErr)
833 return ToTemplateLocOrErr.takeError();
834 auto ToLAngleLocOrErr = import(From: From->getLAngleLoc());
835 if (!ToLAngleLocOrErr)
836 return ToLAngleLocOrErr.takeError();
837 auto ToRAngleLocOrErr = import(From: From->getRAngleLoc());
838 if (!ToRAngleLocOrErr)
839 return ToRAngleLocOrErr.takeError();
840
841 return TemplateParameterList::Create(
842 C: Importer.getToContext(),
843 TemplateLoc: *ToTemplateLocOrErr,
844 LAngleLoc: *ToLAngleLocOrErr,
845 Params: To,
846 RAngleLoc: *ToRAngleLocOrErr,
847 RequiresClause: *ToRequiresClause);
848}
849
850template <>
851Expected<TemplateArgument>
852ASTNodeImporter::import(const TemplateArgument &From) {
853 switch (From.getKind()) {
854 case TemplateArgument::Null:
855 return TemplateArgument();
856
857 case TemplateArgument::Type: {
858 ExpectedType ToTypeOrErr = import(From: From.getAsType());
859 if (!ToTypeOrErr)
860 return ToTypeOrErr.takeError();
861 return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/ false,
862 From.getIsDefaulted());
863 }
864
865 case TemplateArgument::Integral: {
866 ExpectedType ToTypeOrErr = import(From: From.getIntegralType());
867 if (!ToTypeOrErr)
868 return ToTypeOrErr.takeError();
869 return TemplateArgument(From, *ToTypeOrErr);
870 }
871
872 case TemplateArgument::Declaration: {
873 Expected<ValueDecl *> ToOrErr = import(From: From.getAsDecl());
874 if (!ToOrErr)
875 return ToOrErr.takeError();
876 ExpectedType ToTypeOrErr = import(From: From.getParamTypeForDecl());
877 if (!ToTypeOrErr)
878 return ToTypeOrErr.takeError();
879 return TemplateArgument(dyn_cast<ValueDecl>(Val: (*ToOrErr)->getCanonicalDecl()),
880 *ToTypeOrErr, From.getIsDefaulted());
881 }
882
883 case TemplateArgument::NullPtr: {
884 ExpectedType ToTypeOrErr = import(From: From.getNullPtrType());
885 if (!ToTypeOrErr)
886 return ToTypeOrErr.takeError();
887 return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/ true,
888 From.getIsDefaulted());
889 }
890
891 case TemplateArgument::StructuralValue: {
892 ExpectedType ToTypeOrErr = import(From: From.getStructuralValueType());
893 if (!ToTypeOrErr)
894 return ToTypeOrErr.takeError();
895 Expected<APValue> ToValueOrErr = import(From: From.getAsStructuralValue());
896 if (!ToValueOrErr)
897 return ToValueOrErr.takeError();
898 return TemplateArgument(Importer.getToContext(), *ToTypeOrErr,
899 *ToValueOrErr);
900 }
901
902 case TemplateArgument::Template: {
903 Expected<TemplateName> ToTemplateOrErr = import(From: From.getAsTemplate());
904 if (!ToTemplateOrErr)
905 return ToTemplateOrErr.takeError();
906
907 return TemplateArgument(*ToTemplateOrErr, From.getIsDefaulted());
908 }
909
910 case TemplateArgument::TemplateExpansion: {
911 Expected<TemplateName> ToTemplateOrErr =
912 import(From: From.getAsTemplateOrTemplatePattern());
913 if (!ToTemplateOrErr)
914 return ToTemplateOrErr.takeError();
915
916 return TemplateArgument(*ToTemplateOrErr, From.getNumTemplateExpansions(),
917 From.getIsDefaulted());
918 }
919
920 case TemplateArgument::Expression:
921 if (ExpectedExpr ToExpr = import(From: From.getAsExpr()))
922 return TemplateArgument(*ToExpr, From.isCanonicalExpr(),
923 From.getIsDefaulted());
924 else
925 return ToExpr.takeError();
926
927 case TemplateArgument::Pack: {
928 SmallVector<TemplateArgument, 2> ToPack;
929 ToPack.reserve(N: From.pack_size());
930 if (Error Err = ImportTemplateArguments(FromArgs: From.pack_elements(), ToArgs&: ToPack))
931 return std::move(Err);
932
933 return TemplateArgument(ArrayRef(ToPack).copy(A&: Importer.getToContext()));
934 }
935 }
936
937 llvm_unreachable("Invalid template argument kind");
938}
939
940template <>
941Expected<TemplateArgumentLoc>
942ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
943 Expected<TemplateArgument> ArgOrErr = import(From: TALoc.getArgument());
944 if (!ArgOrErr)
945 return ArgOrErr.takeError();
946 TemplateArgument Arg = *ArgOrErr;
947
948 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
949
950 TemplateArgumentLocInfo ToInfo;
951 if (Arg.getKind() == TemplateArgument::Expression) {
952 ExpectedExpr E = import(From: FromInfo.getAsExpr());
953 if (!E)
954 return E.takeError();
955 ToInfo = TemplateArgumentLocInfo(*E);
956 } else if (Arg.getKind() == TemplateArgument::Type) {
957 if (auto TSIOrErr = import(From: FromInfo.getAsTypeSourceInfo()))
958 ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
959 else
960 return TSIOrErr.takeError();
961 } else {
962 auto ToTemplateKWLocOrErr = import(From: FromInfo.getTemplateKwLoc());
963 if (!ToTemplateKWLocOrErr)
964 return ToTemplateKWLocOrErr.takeError();
965 auto ToTemplateQualifierLocOrErr = import(From: TALoc.getTemplateQualifierLoc());
966 if (!ToTemplateQualifierLocOrErr)
967 return ToTemplateQualifierLocOrErr.takeError();
968 auto ToTemplateNameLocOrErr = import(From: FromInfo.getTemplateNameLoc());
969 if (!ToTemplateNameLocOrErr)
970 return ToTemplateNameLocOrErr.takeError();
971 auto ToTemplateEllipsisLocOrErr =
972 import(From: FromInfo.getTemplateEllipsisLoc());
973 if (!ToTemplateEllipsisLocOrErr)
974 return ToTemplateEllipsisLocOrErr.takeError();
975 ToInfo = TemplateArgumentLocInfo(
976 Importer.getToContext(), *ToTemplateKWLocOrErr,
977 *ToTemplateQualifierLocOrErr, *ToTemplateNameLocOrErr,
978 *ToTemplateEllipsisLocOrErr);
979 }
980
981 return TemplateArgumentLoc(Arg, ToInfo);
982}
983
984template <>
985Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
986 if (DG.isNull())
987 return DeclGroupRef::Create(C&: Importer.getToContext(), Decls: nullptr, NumDecls: 0);
988 size_t NumDecls = DG.end() - DG.begin();
989 SmallVector<Decl *, 1> ToDecls;
990 ToDecls.reserve(N: NumDecls);
991 for (Decl *FromD : DG) {
992 if (auto ToDOrErr = import(From: FromD))
993 ToDecls.push_back(Elt: *ToDOrErr);
994 else
995 return ToDOrErr.takeError();
996 }
997 return DeclGroupRef::Create(C&: Importer.getToContext(),
998 Decls: ToDecls.begin(),
999 NumDecls);
1000}
1001
1002template <>
1003Expected<ASTNodeImporter::Designator>
1004ASTNodeImporter::import(const Designator &D) {
1005 if (D.isFieldDesignator()) {
1006 IdentifierInfo *ToFieldName = Importer.Import(FromId: D.getFieldName());
1007
1008 ExpectedSLoc ToDotLocOrErr = import(From: D.getDotLoc());
1009 if (!ToDotLocOrErr)
1010 return ToDotLocOrErr.takeError();
1011
1012 ExpectedSLoc ToFieldLocOrErr = import(From: D.getFieldLoc());
1013 if (!ToFieldLocOrErr)
1014 return ToFieldLocOrErr.takeError();
1015
1016 return DesignatedInitExpr::Designator::CreateFieldDesignator(
1017 FieldName: ToFieldName, DotLoc: *ToDotLocOrErr, FieldLoc: *ToFieldLocOrErr);
1018 }
1019
1020 ExpectedSLoc ToLBracketLocOrErr = import(From: D.getLBracketLoc());
1021 if (!ToLBracketLocOrErr)
1022 return ToLBracketLocOrErr.takeError();
1023
1024 ExpectedSLoc ToRBracketLocOrErr = import(From: D.getRBracketLoc());
1025 if (!ToRBracketLocOrErr)
1026 return ToRBracketLocOrErr.takeError();
1027
1028 if (D.isArrayDesignator())
1029 return Designator::CreateArrayDesignator(Index: D.getArrayIndex(),
1030 LBracketLoc: *ToLBracketLocOrErr,
1031 RBracketLoc: *ToRBracketLocOrErr);
1032
1033 ExpectedSLoc ToEllipsisLocOrErr = import(From: D.getEllipsisLoc());
1034 if (!ToEllipsisLocOrErr)
1035 return ToEllipsisLocOrErr.takeError();
1036
1037 assert(D.isArrayRangeDesignator());
1038 return Designator::CreateArrayRangeDesignator(
1039 Index: D.getArrayIndex(), LBracketLoc: *ToLBracketLocOrErr, EllipsisLoc: *ToEllipsisLocOrErr,
1040 RBracketLoc: *ToRBracketLocOrErr);
1041}
1042
1043template <>
1044Expected<ConceptReference *> ASTNodeImporter::import(ConceptReference *From) {
1045 Error Err = Error::success();
1046 auto ToNNS = importChecked(Err, From: From->getNestedNameSpecifierLoc());
1047 auto ToTemplateKWLoc = importChecked(Err, From: From->getTemplateKWLoc());
1048 auto ToConceptNameLoc =
1049 importChecked(Err, From: From->getConceptNameInfo().getLoc());
1050 auto ToConceptName = importChecked(Err, From: From->getConceptNameInfo().getName());
1051 auto ToFoundDecl = importChecked(Err, From: From->getFoundDecl());
1052 auto ToNamedConcept = importChecked(Err, From: From->getNamedConcept());
1053 if (Err)
1054 return std::move(Err);
1055 TemplateArgumentListInfo ToTAInfo;
1056 const auto *ASTTemplateArgs = From->getTemplateArgsAsWritten();
1057 if (ASTTemplateArgs)
1058 if (Error Err = ImportTemplateArgumentListInfo(From: *ASTTemplateArgs, Result&: ToTAInfo))
1059 return std::move(Err);
1060 auto *ConceptRef = ConceptReference::Create(
1061 C: Importer.getToContext(), NNS: ToNNS, TemplateKWLoc: ToTemplateKWLoc,
1062 ConceptNameInfo: DeclarationNameInfo(ToConceptName, ToConceptNameLoc), FoundDecl: ToFoundDecl,
1063 NamedConcept: ToNamedConcept,
1064 ArgsAsWritten: ASTTemplateArgs ? ASTTemplateArgumentListInfo::Create(
1065 C: Importer.getToContext(), List: ToTAInfo)
1066 : nullptr);
1067 return ConceptRef;
1068}
1069
1070StringRef ASTNodeImporter::ImportASTStringRef(StringRef FromStr) {
1071 char *ToStore = new (Importer.getToContext()) char[FromStr.size()];
1072 std::copy(first: FromStr.begin(), last: FromStr.end(), result: ToStore);
1073 return StringRef(ToStore, FromStr.size());
1074}
1075
1076Error ASTNodeImporter::ImportConstraintSatisfaction(
1077 const ASTConstraintSatisfaction &FromSat, ConstraintSatisfaction &ToSat) {
1078 ToSat.IsSatisfied = FromSat.IsSatisfied;
1079 ToSat.ContainsErrors = FromSat.ContainsErrors;
1080 if (!ToSat.IsSatisfied) {
1081 for (auto Record = FromSat.begin(); Record != FromSat.end(); ++Record) {
1082 if (const Expr *E = Record->dyn_cast<const Expr *>()) {
1083 ExpectedExpr ToSecondExpr = import(From: E);
1084 if (!ToSecondExpr)
1085 return ToSecondExpr.takeError();
1086 ToSat.Details.emplace_back(Args&: ToSecondExpr.get());
1087 } else if (auto CR = Record->dyn_cast<const ConceptReference *>()) {
1088 Expected<ConceptReference *> ToCROrErr = import(From: CR);
1089 if (!ToCROrErr)
1090 return ToCROrErr.takeError();
1091 ToSat.Details.emplace_back(Args&: ToCROrErr.get());
1092 } else {
1093 auto Pair =
1094 Record->dyn_cast<const ConstraintSubstitutionDiagnostic *>();
1095
1096 ExpectedSLoc ToPairFirst = import(From: Pair->first);
1097 if (!ToPairFirst)
1098 return ToPairFirst.takeError();
1099 StringRef ToPairSecond = ImportASTStringRef(FromStr: Pair->second);
1100 ToSat.Details.emplace_back(Args: new (Importer.getToContext())
1101 ConstraintSubstitutionDiagnostic{
1102 ToPairFirst.get(), ToPairSecond});
1103 }
1104 }
1105 }
1106 return Error::success();
1107}
1108
1109template <>
1110Expected<concepts::Requirement::SubstitutionDiagnostic *>
1111ASTNodeImporter::import(
1112 concepts::Requirement::SubstitutionDiagnostic *FromDiag) {
1113 StringRef ToEntity = ImportASTStringRef(FromStr: FromDiag->SubstitutedEntity);
1114 ExpectedSLoc ToLoc = import(From: FromDiag->DiagLoc);
1115 if (!ToLoc)
1116 return ToLoc.takeError();
1117 StringRef ToDiagMessage = ImportASTStringRef(FromStr: FromDiag->DiagMessage);
1118 return new (Importer.getToContext())
1119 concepts::Requirement::SubstitutionDiagnostic{.SubstitutedEntity: ToEntity, .DiagLoc: ToLoc.get(),
1120 .DiagMessage: ToDiagMessage};
1121}
1122
1123Expected<concepts::Requirement *>
1124ASTNodeImporter::ImportTypeRequirement(concepts::TypeRequirement *From) {
1125 using namespace concepts;
1126
1127 if (From->isSubstitutionFailure()) {
1128 auto DiagOrErr = import(FromDiag: From->getSubstitutionDiagnostic());
1129 if (!DiagOrErr)
1130 return DiagOrErr.takeError();
1131 return new (Importer.getToContext()) TypeRequirement(*DiagOrErr);
1132 } else {
1133 Expected<TypeSourceInfo *> ToType = import(From: From->getType());
1134 if (!ToType)
1135 return ToType.takeError();
1136 return new (Importer.getToContext()) TypeRequirement(*ToType);
1137 }
1138}
1139
1140Expected<concepts::Requirement *>
1141ASTNodeImporter::ImportExprRequirement(concepts::ExprRequirement *From) {
1142 using namespace concepts;
1143
1144 bool IsRKSimple = From->getKind() == Requirement::RK_Simple;
1145 ExprRequirement::SatisfactionStatus Status = From->getSatisfactionStatus();
1146
1147 std::optional<ExprRequirement::ReturnTypeRequirement> Req;
1148 ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
1149
1150 if (IsRKSimple) {
1151 Req.emplace();
1152 } else {
1153 const ExprRequirement::ReturnTypeRequirement &FromTypeRequirement =
1154 From->getReturnTypeRequirement();
1155
1156 if (FromTypeRequirement.isTypeConstraint()) {
1157 const bool IsDependent = FromTypeRequirement.isDependent();
1158 auto ParamsOrErr =
1159 import(From: FromTypeRequirement.getTypeConstraintTemplateParameterList());
1160 if (!ParamsOrErr)
1161 return ParamsOrErr.takeError();
1162 if (Status >= ExprRequirement::SS_ConstraintsNotSatisfied) {
1163 auto SubstConstraintExprOrErr =
1164 import(From: From->getReturnTypeRequirementSubstitutedConstraintExpr());
1165 if (!SubstConstraintExprOrErr)
1166 return SubstConstraintExprOrErr.takeError();
1167 SubstitutedConstraintExpr = SubstConstraintExprOrErr.get();
1168 }
1169 Req.emplace(args&: ParamsOrErr.get(), args: IsDependent);
1170 } else if (FromTypeRequirement.isSubstitutionFailure()) {
1171 auto DiagOrErr = import(FromDiag: FromTypeRequirement.getSubstitutionDiagnostic());
1172 if (!DiagOrErr)
1173 return DiagOrErr.takeError();
1174 Req.emplace(args&: DiagOrErr.get());
1175 } else {
1176 Req.emplace();
1177 }
1178 }
1179
1180 ExpectedSLoc NoexceptLocOrErr = import(From: From->getNoexceptLoc());
1181 if (!NoexceptLocOrErr)
1182 return NoexceptLocOrErr.takeError();
1183
1184 if (Status == ExprRequirement::SS_ExprSubstitutionFailure) {
1185 auto DiagOrErr = import(FromDiag: From->getExprSubstitutionDiagnostic());
1186 if (!DiagOrErr)
1187 return DiagOrErr.takeError();
1188 return new (Importer.getToContext()) ExprRequirement(
1189 *DiagOrErr, IsRKSimple, *NoexceptLocOrErr, std::move(*Req));
1190 } else {
1191 Expected<Expr *> ExprOrErr = import(From: From->getExpr());
1192 if (!ExprOrErr)
1193 return ExprOrErr.takeError();
1194 return new (Importer.getToContext()) concepts::ExprRequirement(
1195 *ExprOrErr, IsRKSimple, *NoexceptLocOrErr, std::move(*Req), Status,
1196 SubstitutedConstraintExpr);
1197 }
1198}
1199
1200Expected<concepts::Requirement *>
1201ASTNodeImporter::ImportNestedRequirement(concepts::NestedRequirement *From) {
1202 using namespace concepts;
1203
1204 const ASTConstraintSatisfaction &FromSatisfaction =
1205 From->getConstraintSatisfaction();
1206 if (From->hasInvalidConstraint()) {
1207 StringRef ToEntity = ImportASTStringRef(FromStr: From->getInvalidConstraintEntity());
1208 ASTConstraintSatisfaction *ToSatisfaction =
1209 ASTConstraintSatisfaction::Rebuild(C: Importer.getToContext(),
1210 Satisfaction: FromSatisfaction);
1211 return new (Importer.getToContext())
1212 NestedRequirement(ToEntity, ToSatisfaction);
1213 } else {
1214 ExpectedExpr ToExpr = import(From: From->getConstraintExpr());
1215 if (!ToExpr)
1216 return ToExpr.takeError();
1217 if (ToExpr.get()->isInstantiationDependent()) {
1218 return new (Importer.getToContext()) NestedRequirement(ToExpr.get());
1219 } else {
1220 ConstraintSatisfaction Satisfaction;
1221 if (Error Err =
1222 ImportConstraintSatisfaction(FromSat: FromSatisfaction, ToSat&: Satisfaction))
1223 return std::move(Err);
1224 return new (Importer.getToContext()) NestedRequirement(
1225 Importer.getToContext(), ToExpr.get(), Satisfaction);
1226 }
1227 }
1228}
1229
1230template <>
1231Expected<concepts::Requirement *>
1232ASTNodeImporter::import(concepts::Requirement *FromRequire) {
1233 switch (FromRequire->getKind()) {
1234 case concepts::Requirement::RequirementKind::RK_Type:
1235 return ImportTypeRequirement(From: cast<concepts::TypeRequirement>(Val: FromRequire));
1236 case concepts::Requirement::RequirementKind::RK_Compound:
1237 case concepts::Requirement::RequirementKind::RK_Simple:
1238 return ImportExprRequirement(From: cast<concepts::ExprRequirement>(Val: FromRequire));
1239 case concepts::Requirement::RequirementKind::RK_Nested:
1240 return ImportNestedRequirement(
1241 From: cast<concepts::NestedRequirement>(Val: FromRequire));
1242 }
1243 llvm_unreachable("Unhandled requirement kind");
1244}
1245
1246template <>
1247Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
1248 ValueDecl *Var = nullptr;
1249 if (From.capturesVariable()) {
1250 if (auto VarOrErr = import(From: From.getCapturedVar()))
1251 Var = *VarOrErr;
1252 else
1253 return VarOrErr.takeError();
1254 }
1255
1256 auto LocationOrErr = import(From: From.getLocation());
1257 if (!LocationOrErr)
1258 return LocationOrErr.takeError();
1259
1260 SourceLocation EllipsisLoc;
1261 if (From.isPackExpansion())
1262 if (Error Err = importInto(To&: EllipsisLoc, From: From.getEllipsisLoc()))
1263 return std::move(Err);
1264
1265 return LambdaCapture(
1266 *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
1267 EllipsisLoc);
1268}
1269
1270template <typename T>
1271bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
1272 if (Found->getLinkageInternal() != From->getLinkageInternal())
1273 return false;
1274
1275 if (From->hasExternalFormalLinkage())
1276 return Found->hasExternalFormalLinkage();
1277 if (Importer.GetFromTU(ToD: Found) != From->getTranslationUnitDecl())
1278 return false;
1279 if (From->isInAnonymousNamespace())
1280 return Found->isInAnonymousNamespace();
1281 else
1282 return !Found->isInAnonymousNamespace() &&
1283 !Found->hasExternalFormalLinkage();
1284}
1285
1286template <>
1287bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
1288 TypedefNameDecl *From) {
1289 if (Found->getLinkageInternal() != From->getLinkageInternal())
1290 return false;
1291
1292 if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
1293 return Importer.GetFromTU(ToD: Found) == From->getTranslationUnitDecl();
1294 return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
1295}
1296
1297} // namespace clang
1298
1299//----------------------------------------------------------------------------
1300// Import Types
1301//----------------------------------------------------------------------------
1302
1303using namespace clang;
1304
1305auto ASTImporter::FunctionDeclImportCycleDetector::makeScopedCycleDetection(
1306 const FunctionDecl *D) {
1307 const FunctionDecl *LambdaD = nullptr;
1308 if (!isCycle(D) && D) {
1309 FunctionDeclsWithImportInProgress.insert(V: D);
1310 LambdaD = D;
1311 }
1312 return llvm::scope_exit([this, LambdaD]() {
1313 if (LambdaD) {
1314 FunctionDeclsWithImportInProgress.erase(V: LambdaD);
1315 }
1316 });
1317}
1318
1319bool ASTImporter::FunctionDeclImportCycleDetector::isCycle(
1320 const FunctionDecl *D) const {
1321 return FunctionDeclsWithImportInProgress.find(V: D) !=
1322 FunctionDeclsWithImportInProgress.end();
1323}
1324
1325ExpectedType ASTNodeImporter::VisitType(const Type *T) {
1326 Importer.FromDiag(Loc: SourceLocation(), DiagID: diag::err_unsupported_ast_node)
1327 << T->getTypeClassName();
1328 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
1329}
1330
1331ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1332 ExpectedType UnderlyingTypeOrErr = import(From: T->getValueType());
1333 if (!UnderlyingTypeOrErr)
1334 return UnderlyingTypeOrErr.takeError();
1335
1336 return Importer.getToContext().getAtomicType(T: *UnderlyingTypeOrErr);
1337}
1338
1339ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1340 switch (T->getKind()) {
1341#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1342 case BuiltinType::Id: \
1343 return Importer.getToContext().SingletonId;
1344#include "clang/Basic/OpenCLImageTypes.def"
1345#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1346 case BuiltinType::Id: \
1347 return Importer.getToContext().Id##Ty;
1348#include "clang/Basic/OpenCLExtensionTypes.def"
1349#define SVE_TYPE(Name, Id, SingletonId) \
1350 case BuiltinType::Id: \
1351 return Importer.getToContext().SingletonId;
1352#include "clang/Basic/AArch64ACLETypes.def"
1353#define PPC_VECTOR_TYPE(Name, Id, Size) \
1354 case BuiltinType::Id: \
1355 return Importer.getToContext().Id##Ty;
1356#include "clang/Basic/PPCTypes.def"
1357#define RVV_TYPE(Name, Id, SingletonId) \
1358 case BuiltinType::Id: \
1359 return Importer.getToContext().SingletonId;
1360#include "clang/Basic/RISCVVTypes.def"
1361#define WASM_TYPE(Name, Id, SingletonId) \
1362 case BuiltinType::Id: \
1363 return Importer.getToContext().SingletonId;
1364#include "clang/Basic/WebAssemblyReferenceTypes.def"
1365#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
1366 case BuiltinType::Id: \
1367 return Importer.getToContext().SingletonId;
1368#include "clang/Basic/AMDGPUTypes.def"
1369#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
1370 case BuiltinType::Id: \
1371 return Importer.getToContext().SingletonId;
1372#include "clang/Basic/HLSLIntangibleTypes.def"
1373#define SPIRV_TYPE(Name, Id, SingletonId) \
1374 case BuiltinType::Id: \
1375 return Importer.getToContext().SingletonId;
1376#include "clang/Basic/SPIRVTypes.def"
1377#define SHARED_SINGLETON_TYPE(Expansion)
1378#define BUILTIN_TYPE(Id, SingletonId) \
1379 case BuiltinType::Id: return Importer.getToContext().SingletonId;
1380#include "clang/AST/BuiltinTypes.def"
1381
1382 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1383 // context supports C++.
1384
1385 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1386 // context supports ObjC.
1387
1388 case BuiltinType::Char_U:
1389 // The context we're importing from has an unsigned 'char'. If we're
1390 // importing into a context with a signed 'char', translate to
1391 // 'unsigned char' instead.
1392 if (Importer.getToContext().getLangOpts().CharIsSigned)
1393 return Importer.getToContext().UnsignedCharTy;
1394
1395 return Importer.getToContext().CharTy;
1396
1397 case BuiltinType::Char_S:
1398 // The context we're importing from has an unsigned 'char'. If we're
1399 // importing into a context with a signed 'char', translate to
1400 // 'unsigned char' instead.
1401 if (!Importer.getToContext().getLangOpts().CharIsSigned)
1402 return Importer.getToContext().SignedCharTy;
1403
1404 return Importer.getToContext().CharTy;
1405
1406 case BuiltinType::WChar_S:
1407 case BuiltinType::WChar_U:
1408 // FIXME: If not in C++, shall we translate to the C equivalent of
1409 // wchar_t?
1410 return Importer.getToContext().WCharTy;
1411 }
1412
1413 llvm_unreachable("Invalid BuiltinType Kind!");
1414}
1415
1416ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1417 ExpectedType ToOriginalTypeOrErr = import(From: T->getOriginalType());
1418 if (!ToOriginalTypeOrErr)
1419 return ToOriginalTypeOrErr.takeError();
1420
1421 return Importer.getToContext().getDecayedType(T: *ToOriginalTypeOrErr);
1422}
1423
1424ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1425 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
1426 if (!ToElementTypeOrErr)
1427 return ToElementTypeOrErr.takeError();
1428
1429 return Importer.getToContext().getComplexType(T: *ToElementTypeOrErr);
1430}
1431
1432ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1433 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeType());
1434 if (!ToPointeeTypeOrErr)
1435 return ToPointeeTypeOrErr.takeError();
1436
1437 return Importer.getToContext().getPointerType(T: *ToPointeeTypeOrErr);
1438}
1439
1440ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1441 // FIXME: Check for blocks support in "to" context.
1442 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeType());
1443 if (!ToPointeeTypeOrErr)
1444 return ToPointeeTypeOrErr.takeError();
1445
1446 return Importer.getToContext().getBlockPointerType(T: *ToPointeeTypeOrErr);
1447}
1448
1449ExpectedType
1450ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1451 // FIXME: Check for C++ support in "to" context.
1452 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeTypeAsWritten());
1453 if (!ToPointeeTypeOrErr)
1454 return ToPointeeTypeOrErr.takeError();
1455
1456 return Importer.getToContext().getLValueReferenceType(T: *ToPointeeTypeOrErr);
1457}
1458
1459ExpectedType
1460ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1461 // FIXME: Check for C++0x support in "to" context.
1462 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeTypeAsWritten());
1463 if (!ToPointeeTypeOrErr)
1464 return ToPointeeTypeOrErr.takeError();
1465
1466 return Importer.getToContext().getRValueReferenceType(T: *ToPointeeTypeOrErr);
1467}
1468
1469ExpectedType
1470ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1471 // FIXME: Check for C++ support in "to" context.
1472 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeType());
1473 if (!ToPointeeTypeOrErr)
1474 return ToPointeeTypeOrErr.takeError();
1475
1476 auto QualifierOrErr = import(From: T->getQualifier());
1477 if (!QualifierOrErr)
1478 return QualifierOrErr.takeError();
1479
1480 auto ClsOrErr = import(From: T->getMostRecentCXXRecordDecl());
1481 if (!ClsOrErr)
1482 return ClsOrErr.takeError();
1483
1484 return Importer.getToContext().getMemberPointerType(
1485 T: *ToPointeeTypeOrErr, Qualifier: *QualifierOrErr, Cls: *ClsOrErr);
1486}
1487
1488ExpectedType
1489ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1490 Error Err = Error::success();
1491 auto ToElementType = importChecked(Err, From: T->getElementType());
1492 auto ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
1493 if (Err)
1494 return std::move(Err);
1495
1496 return Importer.getToContext().getConstantArrayType(
1497 EltTy: ToElementType, ArySize: T->getSize(), SizeExpr: ToSizeExpr, ASM: T->getSizeModifier(),
1498 IndexTypeQuals: T->getIndexTypeCVRQualifiers());
1499}
1500
1501ExpectedType
1502ASTNodeImporter::VisitArrayParameterType(const ArrayParameterType *T) {
1503 ExpectedType ToArrayTypeOrErr = VisitConstantArrayType(T);
1504 if (!ToArrayTypeOrErr)
1505 return ToArrayTypeOrErr.takeError();
1506
1507 return Importer.getToContext().getArrayParameterType(Ty: *ToArrayTypeOrErr);
1508}
1509
1510ExpectedType
1511ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1512 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
1513 if (!ToElementTypeOrErr)
1514 return ToElementTypeOrErr.takeError();
1515
1516 return Importer.getToContext().getIncompleteArrayType(EltTy: *ToElementTypeOrErr,
1517 ASM: T->getSizeModifier(),
1518 IndexTypeQuals: T->getIndexTypeCVRQualifiers());
1519}
1520
1521ExpectedType
1522ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1523 Error Err = Error::success();
1524 QualType ToElementType = importChecked(Err, From: T->getElementType());
1525 Expr *ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
1526 if (Err)
1527 return std::move(Err);
1528 return Importer.getToContext().getVariableArrayType(
1529 EltTy: ToElementType, NumElts: ToSizeExpr, ASM: T->getSizeModifier(),
1530 IndexTypeQuals: T->getIndexTypeCVRQualifiers());
1531}
1532
1533ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1534 const DependentSizedArrayType *T) {
1535 Error Err = Error::success();
1536 QualType ToElementType = importChecked(Err, From: T->getElementType());
1537 Expr *ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
1538 if (Err)
1539 return std::move(Err);
1540 // SizeExpr may be null if size is not specified directly.
1541 // For example, 'int a[]'.
1542
1543 return Importer.getToContext().getDependentSizedArrayType(
1544 EltTy: ToElementType, NumElts: ToSizeExpr, ASM: T->getSizeModifier(),
1545 IndexTypeQuals: T->getIndexTypeCVRQualifiers());
1546}
1547
1548ExpectedType ASTNodeImporter::VisitDependentSizedExtVectorType(
1549 const DependentSizedExtVectorType *T) {
1550 Error Err = Error::success();
1551 QualType ToElementType = importChecked(Err, From: T->getElementType());
1552 Expr *ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
1553 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
1554 if (Err)
1555 return std::move(Err);
1556 return Importer.getToContext().getDependentSizedExtVectorType(
1557 VectorType: ToElementType, SizeExpr: ToSizeExpr, AttrLoc: ToAttrLoc);
1558}
1559
1560ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1561 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
1562 if (!ToElementTypeOrErr)
1563 return ToElementTypeOrErr.takeError();
1564
1565 return Importer.getToContext().getVectorType(VectorType: *ToElementTypeOrErr,
1566 NumElts: T->getNumElements(),
1567 VecKind: T->getVectorKind());
1568}
1569
1570ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1571 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
1572 if (!ToElementTypeOrErr)
1573 return ToElementTypeOrErr.takeError();
1574
1575 return Importer.getToContext().getExtVectorType(VectorType: *ToElementTypeOrErr,
1576 NumElts: T->getNumElements());
1577}
1578
1579ExpectedType
1580ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1581 // FIXME: What happens if we're importing a function without a prototype
1582 // into C++? Should we make it variadic?
1583 ExpectedType ToReturnTypeOrErr = import(From: T->getReturnType());
1584 if (!ToReturnTypeOrErr)
1585 return ToReturnTypeOrErr.takeError();
1586
1587 return Importer.getToContext().getFunctionNoProtoType(ResultTy: *ToReturnTypeOrErr,
1588 Info: T->getExtInfo());
1589}
1590
1591ExpectedType
1592ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1593 ExpectedType ToReturnTypeOrErr = import(From: T->getReturnType());
1594 if (!ToReturnTypeOrErr)
1595 return ToReturnTypeOrErr.takeError();
1596
1597 // Import argument types
1598 SmallVector<QualType, 4> ArgTypes;
1599 for (const auto &A : T->param_types()) {
1600 ExpectedType TyOrErr = import(From: A);
1601 if (!TyOrErr)
1602 return TyOrErr.takeError();
1603 ArgTypes.push_back(Elt: *TyOrErr);
1604 }
1605
1606 // Import exception types
1607 SmallVector<QualType, 4> ExceptionTypes;
1608 for (const auto &E : T->exceptions()) {
1609 ExpectedType TyOrErr = import(From: E);
1610 if (!TyOrErr)
1611 return TyOrErr.takeError();
1612 ExceptionTypes.push_back(Elt: *TyOrErr);
1613 }
1614
1615 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1616 Error Err = Error::success();
1617 FunctionProtoType::ExtProtoInfo ToEPI;
1618 ToEPI.ExtInfo = FromEPI.ExtInfo;
1619 ToEPI.Variadic = FromEPI.Variadic;
1620 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1621 ToEPI.TypeQuals = FromEPI.TypeQuals;
1622 ToEPI.RefQualifier = FromEPI.RefQualifier;
1623 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1624 ToEPI.ExceptionSpec.NoexceptExpr =
1625 importChecked(Err, From: FromEPI.ExceptionSpec.NoexceptExpr);
1626 ToEPI.ExceptionSpec.SourceDecl =
1627 importChecked(Err, From: FromEPI.ExceptionSpec.SourceDecl);
1628 ToEPI.ExceptionSpec.SourceTemplate =
1629 importChecked(Err, From: FromEPI.ExceptionSpec.SourceTemplate);
1630 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1631
1632 if (Err)
1633 return std::move(Err);
1634
1635 return Importer.getToContext().getFunctionType(
1636 ResultTy: *ToReturnTypeOrErr, Args: ArgTypes, EPI: ToEPI);
1637}
1638
1639ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
1640 const UnresolvedUsingType *T) {
1641 auto ToQualifierOrErr = import(From: T->getQualifier());
1642 if (!ToQualifierOrErr)
1643 return ToQualifierOrErr.takeError();
1644 auto ToDeclOrErr = import(From: T->getDecl());
1645 if (!ToDeclOrErr)
1646 return ToDeclOrErr.takeError();
1647
1648 if (T->isCanonicalUnqualified())
1649 return Importer.getToContext().getCanonicalUnresolvedUsingType(
1650 D: *ToDeclOrErr);
1651 return Importer.getToContext().getUnresolvedUsingType(
1652 Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr, D: *ToDeclOrErr);
1653}
1654
1655ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
1656 ExpectedType ToInnerTypeOrErr = import(From: T->getInnerType());
1657 if (!ToInnerTypeOrErr)
1658 return ToInnerTypeOrErr.takeError();
1659
1660 return Importer.getToContext().getParenType(NamedType: *ToInnerTypeOrErr);
1661}
1662
1663ExpectedType
1664ASTNodeImporter::VisitPackIndexingType(clang::PackIndexingType const *T) {
1665
1666 ExpectedType Pattern = import(From: T->getPattern());
1667 if (!Pattern)
1668 return Pattern.takeError();
1669 ExpectedExpr Index = import(From: T->getIndexExpr());
1670 if (!Index)
1671 return Index.takeError();
1672 return Importer.getToContext().getPackIndexingType(Pattern: *Pattern, IndexExpr: *Index);
1673}
1674
1675ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1676 Expected<TypedefNameDecl *> ToDeclOrErr = import(From: T->getDecl());
1677 if (!ToDeclOrErr)
1678 return ToDeclOrErr.takeError();
1679
1680 auto ToQualifierOrErr = import(From: T->getQualifier());
1681 if (!ToQualifierOrErr)
1682 return ToQualifierOrErr.takeError();
1683
1684 ExpectedType ToUnderlyingTypeOrErr =
1685 T->typeMatchesDecl() ? QualType() : import(From: T->desugar());
1686 if (!ToUnderlyingTypeOrErr)
1687 return ToUnderlyingTypeOrErr.takeError();
1688
1689 return Importer.getToContext().getTypedefType(
1690 Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr, Decl: *ToDeclOrErr, UnderlyingType: *ToUnderlyingTypeOrErr);
1691}
1692
1693ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1694 ExpectedExpr ToExprOrErr = import(From: T->getUnderlyingExpr());
1695 if (!ToExprOrErr)
1696 return ToExprOrErr.takeError();
1697 return Importer.getToContext().getTypeOfExprType(E: *ToExprOrErr, Kind: T->getKind());
1698}
1699
1700ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1701 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnmodifiedType());
1702 if (!ToUnderlyingTypeOrErr)
1703 return ToUnderlyingTypeOrErr.takeError();
1704 return Importer.getToContext().getTypeOfType(QT: *ToUnderlyingTypeOrErr,
1705 Kind: T->getKind());
1706}
1707
1708ExpectedType ASTNodeImporter::VisitUsingType(const UsingType *T) {
1709 auto ToQualifierOrErr = import(From: T->getQualifier());
1710 if (!ToQualifierOrErr)
1711 return ToQualifierOrErr.takeError();
1712 auto ToDeclOrErr = import(From: T->getDecl());
1713 if (!ToDeclOrErr)
1714 return ToDeclOrErr.takeError();
1715
1716 ExpectedType ToTypeOrErr = import(From: T->desugar());
1717 if (!ToTypeOrErr)
1718 return ToTypeOrErr.takeError();
1719 return Importer.getToContext().getUsingType(
1720 Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr, D: *ToDeclOrErr, UnderlyingType: *ToTypeOrErr);
1721}
1722
1723ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1724 // FIXME: Make sure that the "to" context supports C++0x!
1725 ExpectedExpr ToExprOrErr = import(From: T->getUnderlyingExpr());
1726 if (!ToExprOrErr)
1727 return ToExprOrErr.takeError();
1728
1729 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
1730 if (!ToUnderlyingTypeOrErr)
1731 return ToUnderlyingTypeOrErr.takeError();
1732
1733 return Importer.getToContext().getDecltypeType(
1734 e: *ToExprOrErr, UnderlyingType: *ToUnderlyingTypeOrErr);
1735}
1736
1737ExpectedType
1738ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1739 ExpectedType ToBaseTypeOrErr = import(From: T->getBaseType());
1740 if (!ToBaseTypeOrErr)
1741 return ToBaseTypeOrErr.takeError();
1742
1743 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
1744 if (!ToUnderlyingTypeOrErr)
1745 return ToUnderlyingTypeOrErr.takeError();
1746
1747 return Importer.getToContext().getUnaryTransformType(
1748 BaseType: *ToBaseTypeOrErr, UnderlyingType: *ToUnderlyingTypeOrErr, UKind: T->getUTTKind());
1749}
1750
1751ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1752 // FIXME: Make sure that the "to" context supports C++11!
1753 ExpectedType ToDeducedTypeOrErr = import(From: T->getDeducedType());
1754 if (!ToDeducedTypeOrErr)
1755 return ToDeducedTypeOrErr.takeError();
1756
1757 TemplateName ToTypeConstraint;
1758 if (TemplateName FromTypeConstraint = T->getTypeConstraintConcept();
1759 !FromTypeConstraint.isNull()) {
1760 Expected<TemplateName> ToTypeConstraintOrErr = import(From: FromTypeConstraint);
1761 if (!ToTypeConstraintOrErr)
1762 return ToTypeConstraintOrErr.takeError();
1763 ToTypeConstraint = *ToTypeConstraintOrErr;
1764 }
1765
1766 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1767 if (Error Err = ImportTemplateArguments(FromArgs: T->getTypeConstraintArguments(),
1768 ToArgs&: ToTemplateArgs))
1769 return std::move(Err);
1770
1771 return Importer.getToContext().getAutoType(
1772 DK: T->getDeducedKind(), DeducedAsType: *ToDeducedTypeOrErr, Keyword: T->getKeyword(),
1773 TypeConstraintConcept: ToTypeConstraint, TypeConstraintArgs: ToTemplateArgs);
1774}
1775
1776ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1777 const DeducedTemplateSpecializationType *T) {
1778 // FIXME: Make sure that the "to" context supports C++17!
1779 Expected<TemplateName> ToTemplateNameOrErr = import(From: T->getTemplateName());
1780 if (!ToTemplateNameOrErr)
1781 return ToTemplateNameOrErr.takeError();
1782 ExpectedType ToDeducedTypeOrErr = import(From: T->getDeducedType());
1783 if (!ToDeducedTypeOrErr)
1784 return ToDeducedTypeOrErr.takeError();
1785
1786 return Importer.getToContext().getDeducedTemplateSpecializationType(
1787 DK: T->getDeducedKind(), DeducedAsType: *ToDeducedTypeOrErr, Keyword: T->getKeyword(),
1788 Template: *ToTemplateNameOrErr);
1789}
1790
1791ExpectedType ASTNodeImporter::VisitTagType(const TagType *T) {
1792 TagDecl *DeclForType = T->getDecl();
1793 Expected<TagDecl *> ToDeclOrErr = import(From: DeclForType);
1794 if (!ToDeclOrErr)
1795 return ToDeclOrErr.takeError();
1796
1797 // If there is a definition of the 'OriginalDecl', it should be imported to
1798 // have all information for the type in the "To" AST. (In some cases no
1799 // other reference may exist to the definition decl and it would not be
1800 // imported otherwise.)
1801 Expected<TagDecl *> ToDefDeclOrErr = import(From: DeclForType->getDefinition());
1802 if (!ToDefDeclOrErr)
1803 return ToDefDeclOrErr.takeError();
1804
1805 if (T->isCanonicalUnqualified())
1806 return Importer.getToContext().getCanonicalTagType(TD: *ToDeclOrErr);
1807
1808 auto ToQualifierOrErr = import(From: T->getQualifier());
1809 if (!ToQualifierOrErr)
1810 return ToQualifierOrErr.takeError();
1811
1812 return Importer.getToContext().getTagType(Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr,
1813 TD: *ToDeclOrErr, OwnsTag: T->isTagOwned());
1814}
1815
1816ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1817 return VisitTagType(T);
1818}
1819
1820ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1821 return VisitTagType(T);
1822}
1823
1824ExpectedType
1825ASTNodeImporter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
1826 return VisitTagType(T);
1827}
1828
1829ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1830 ExpectedType ToModifiedTypeOrErr = import(From: T->getModifiedType());
1831 if (!ToModifiedTypeOrErr)
1832 return ToModifiedTypeOrErr.takeError();
1833 ExpectedType ToEquivalentTypeOrErr = import(From: T->getEquivalentType());
1834 if (!ToEquivalentTypeOrErr)
1835 return ToEquivalentTypeOrErr.takeError();
1836
1837 return Importer.getToContext().getAttributedType(
1838 attrKind: T->getAttrKind(), modifiedType: *ToModifiedTypeOrErr, equivalentType: *ToEquivalentTypeOrErr,
1839 attr: T->getAttr());
1840}
1841
1842ExpectedType
1843ASTNodeImporter::VisitCountAttributedType(const CountAttributedType *T) {
1844 ExpectedType ToWrappedTypeOrErr = import(From: T->desugar());
1845 if (!ToWrappedTypeOrErr)
1846 return ToWrappedTypeOrErr.takeError();
1847
1848 Error Err = Error::success();
1849 Expr *CountExpr = importChecked(Err, From: T->getCountExpr());
1850
1851 SmallVector<TypeCoupledDeclRefInfo, 1> CoupledDecls;
1852 for (const TypeCoupledDeclRefInfo &TI : T->dependent_decls()) {
1853 Expected<ValueDecl *> ToDeclOrErr = import(From: TI.getDecl());
1854 if (!ToDeclOrErr)
1855 return ToDeclOrErr.takeError();
1856 CoupledDecls.emplace_back(Args&: *ToDeclOrErr, Args: TI.isDeref());
1857 }
1858
1859 return Importer.getToContext().getCountAttributedType(
1860 T: *ToWrappedTypeOrErr, CountExpr, CountInBytes: T->isCountInBytes(), OrNull: T->isOrNull(),
1861 DependentDecls: ArrayRef(CoupledDecls));
1862}
1863
1864ExpectedType
1865ASTNodeImporter::VisitLateParsedAttrType(const LateParsedAttrType *T) {
1866 llvm_unreachable("should be replaced with a concrete type before AST import");
1867}
1868
1869ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1870 const TemplateTypeParmType *T) {
1871 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(From: T->getDecl());
1872 if (!ToDeclOrErr)
1873 return ToDeclOrErr.takeError();
1874
1875 return Importer.getToContext().getTemplateTypeParmType(
1876 Depth: T->getDepth(), Index: T->getIndex(), ParameterPack: T->isParameterPack(), ParmDecl: *ToDeclOrErr);
1877}
1878
1879ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1880 const SubstTemplateTypeParmType *T) {
1881 Expected<Decl *> ReplacedOrErr = import(From: T->getAssociatedDecl());
1882 if (!ReplacedOrErr)
1883 return ReplacedOrErr.takeError();
1884
1885 ExpectedType ToReplacementTypeOrErr = import(From: T->getReplacementType());
1886 if (!ToReplacementTypeOrErr)
1887 return ToReplacementTypeOrErr.takeError();
1888
1889 return Importer.getToContext().getSubstTemplateTypeParmType(
1890 Replacement: *ToReplacementTypeOrErr, AssociatedDecl: *ReplacedOrErr, Index: T->getIndex(), PackIndex: T->getPackIndex(),
1891 Final: T->getFinal());
1892}
1893
1894ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1895 const SubstTemplateTypeParmPackType *T) {
1896 Expected<Decl *> ReplacedOrErr = import(From: T->getAssociatedDecl());
1897 if (!ReplacedOrErr)
1898 return ReplacedOrErr.takeError();
1899
1900 Expected<TemplateArgument> ToArgumentPack = import(From: T->getArgumentPack());
1901 if (!ToArgumentPack)
1902 return ToArgumentPack.takeError();
1903
1904 return Importer.getToContext().getSubstTemplateTypeParmPackType(
1905 AssociatedDecl: *ReplacedOrErr, Index: T->getIndex(), Final: T->getFinal(), ArgPack: *ToArgumentPack);
1906}
1907
1908ExpectedType ASTNodeImporter::VisitSubstBuiltinTemplatePackType(
1909 const SubstBuiltinTemplatePackType *T) {
1910 Expected<TemplateArgument> ToArgumentPack = import(From: T->getArgumentPack());
1911 if (!ToArgumentPack)
1912 return ToArgumentPack.takeError();
1913 return Importer.getToContext().getSubstBuiltinTemplatePack(ArgPack: *ToArgumentPack);
1914}
1915
1916ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1917 const TemplateSpecializationType *T) {
1918 auto ToTemplateOrErr = import(From: T->getTemplateName());
1919 if (!ToTemplateOrErr)
1920 return ToTemplateOrErr.takeError();
1921
1922 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1923 if (Error Err =
1924 ImportTemplateArguments(FromArgs: T->template_arguments(), ToArgs&: ToTemplateArgs))
1925 return std::move(Err);
1926
1927 ExpectedType ToUnderlyingOrErr =
1928 T->isCanonicalUnqualified() ? QualType() : import(From: T->desugar());
1929 if (!ToUnderlyingOrErr)
1930 return ToUnderlyingOrErr.takeError();
1931 return Importer.getToContext().getTemplateSpecializationType(
1932 Keyword: T->getKeyword(), T: *ToTemplateOrErr, SpecifiedArgs: ToTemplateArgs, CanonicalArgs: {},
1933 Underlying: *ToUnderlyingOrErr);
1934}
1935
1936ExpectedType
1937ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1938 ExpectedType ToPatternOrErr = import(From: T->getPattern());
1939 if (!ToPatternOrErr)
1940 return ToPatternOrErr.takeError();
1941
1942 return Importer.getToContext().getPackExpansionType(Pattern: *ToPatternOrErr,
1943 NumExpansions: T->getNumExpansions(),
1944 /*ExpactPack=*/ExpectPackInType: false);
1945}
1946
1947ExpectedType
1948ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1949 auto ToQualifierOrErr = import(From: T->getQualifier());
1950 if (!ToQualifierOrErr)
1951 return ToQualifierOrErr.takeError();
1952
1953 IdentifierInfo *Name = Importer.Import(FromId: T->getIdentifier());
1954 return Importer.getToContext().getDependentNameType(Keyword: T->getKeyword(),
1955 NNS: *ToQualifierOrErr, Name);
1956}
1957
1958ExpectedType
1959ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1960 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(From: T->getDecl());
1961 if (!ToDeclOrErr)
1962 return ToDeclOrErr.takeError();
1963
1964 return Importer.getToContext().getObjCInterfaceType(Decl: *ToDeclOrErr);
1965}
1966
1967ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1968 ExpectedType ToBaseTypeOrErr = import(From: T->getBaseType());
1969 if (!ToBaseTypeOrErr)
1970 return ToBaseTypeOrErr.takeError();
1971
1972 SmallVector<QualType, 4> TypeArgs;
1973 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1974 if (ExpectedType TyOrErr = import(From: TypeArg))
1975 TypeArgs.push_back(Elt: *TyOrErr);
1976 else
1977 return TyOrErr.takeError();
1978 }
1979
1980 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1981 for (auto *P : T->quals()) {
1982 if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(From: P))
1983 Protocols.push_back(Elt: *ProtocolOrErr);
1984 else
1985 return ProtocolOrErr.takeError();
1986
1987 }
1988
1989 return Importer.getToContext().getObjCObjectType(Base: *ToBaseTypeOrErr, typeArgs: TypeArgs,
1990 protocols: Protocols,
1991 isKindOf: T->isKindOfTypeAsWritten());
1992}
1993
1994ExpectedType
1995ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1996 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeType());
1997 if (!ToPointeeTypeOrErr)
1998 return ToPointeeTypeOrErr.takeError();
1999
2000 return Importer.getToContext().getObjCObjectPointerType(OIT: *ToPointeeTypeOrErr);
2001}
2002
2003ExpectedType
2004ASTNodeImporter::VisitMacroQualifiedType(const MacroQualifiedType *T) {
2005 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
2006 if (!ToUnderlyingTypeOrErr)
2007 return ToUnderlyingTypeOrErr.takeError();
2008
2009 IdentifierInfo *ToIdentifier = Importer.Import(FromId: T->getMacroIdentifier());
2010 return Importer.getToContext().getMacroQualifiedType(UnderlyingTy: *ToUnderlyingTypeOrErr,
2011 MacroII: ToIdentifier);
2012}
2013
2014ExpectedType clang::ASTNodeImporter::VisitAdjustedType(const AdjustedType *T) {
2015 Error Err = Error::success();
2016 QualType ToOriginalType = importChecked(Err, From: T->getOriginalType());
2017 QualType ToAdjustedType = importChecked(Err, From: T->getAdjustedType());
2018 if (Err)
2019 return std::move(Err);
2020
2021 return Importer.getToContext().getAdjustedType(Orig: ToOriginalType,
2022 New: ToAdjustedType);
2023}
2024
2025ExpectedType clang::ASTNodeImporter::VisitBitIntType(const BitIntType *T) {
2026 return Importer.getToContext().getBitIntType(Unsigned: T->isUnsigned(),
2027 NumBits: T->getNumBits());
2028}
2029
2030ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
2031 const clang::BTFTagAttributedType *T) {
2032 Error Err = Error::success();
2033 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err, From: T->getAttr());
2034 QualType ToWrappedType = importChecked(Err, From: T->getWrappedType());
2035 if (Err)
2036 return std::move(Err);
2037
2038 return Importer.getToContext().getBTFTagAttributedType(BTFAttr: ToBTFAttr,
2039 Wrapped: ToWrappedType);
2040}
2041
2042ExpectedType clang::ASTNodeImporter::VisitOverflowBehaviorType(
2043 const clang::OverflowBehaviorType *T) {
2044 Error Err = Error::success();
2045 OverflowBehaviorType::OverflowBehaviorKind ToKind = T->getBehaviorKind();
2046 QualType ToUnderlyingType = importChecked(Err, From: T->getUnderlyingType());
2047 if (Err)
2048 return std::move(Err);
2049
2050 return Importer.getToContext().getOverflowBehaviorType(Kind: ToKind,
2051 Wrapped: ToUnderlyingType);
2052}
2053
2054ExpectedType clang::ASTNodeImporter::VisitHLSLAttributedResourceType(
2055 const clang::HLSLAttributedResourceType *T) {
2056 Error Err = Error::success();
2057 HLSLAttributedResourceType::Attributes ToAttrs = T->getAttrs();
2058 QualType ToWrappedType = importChecked(Err, From: T->getWrappedType());
2059 QualType ToContainedType = importChecked(Err, From: T->getContainedType());
2060 ToAttrs.SampleCountExpr = importChecked(Err, From: T->getSampleCountExpr());
2061 if (Err)
2062 return std::move(Err);
2063
2064 return Importer.getToContext().getHLSLAttributedResourceType(
2065 Wrapped: ToWrappedType, Contained: ToContainedType, Attrs: ToAttrs);
2066}
2067
2068ExpectedType clang::ASTNodeImporter::VisitHLSLInlineSpirvType(
2069 const clang::HLSLInlineSpirvType *T) {
2070 Error Err = Error::success();
2071
2072 uint32_t ToOpcode = T->getOpcode();
2073 uint32_t ToSize = T->getSize();
2074 uint32_t ToAlignment = T->getAlignment();
2075
2076 llvm::SmallVector<SpirvOperand> ToOperands;
2077
2078 for (auto &Operand : T->getOperands()) {
2079 using SpirvOperandKind = SpirvOperand::SpirvOperandKind;
2080
2081 switch (Operand.getKind()) {
2082 case SpirvOperandKind::ConstantId:
2083 ToOperands.push_back(Elt: SpirvOperand::createConstant(
2084 ResultType: importChecked(Err, From: Operand.getResultType()), Val: Operand.getValue()));
2085 break;
2086 case SpirvOperandKind::Literal:
2087 ToOperands.push_back(Elt: SpirvOperand::createLiteral(Val: Operand.getValue()));
2088 break;
2089 case SpirvOperandKind::TypeId:
2090 ToOperands.push_back(Elt: SpirvOperand::createType(
2091 T: importChecked(Err, From: Operand.getResultType())));
2092 break;
2093 default:
2094 llvm_unreachable("Invalid SpirvOperand kind");
2095 }
2096
2097 if (Err)
2098 return std::move(Err);
2099 }
2100
2101 return Importer.getToContext().getHLSLInlineSpirvType(
2102 Opcode: ToOpcode, Size: ToSize, Alignment: ToAlignment, Operands: ToOperands);
2103}
2104
2105ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
2106 const clang::ConstantMatrixType *T) {
2107 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
2108 if (!ToElementTypeOrErr)
2109 return ToElementTypeOrErr.takeError();
2110
2111 return Importer.getToContext().getConstantMatrixType(
2112 ElementType: *ToElementTypeOrErr, NumRows: T->getNumRows(), NumColumns: T->getNumColumns());
2113}
2114
2115ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
2116 const clang::DependentAddressSpaceType *T) {
2117 Error Err = Error::success();
2118 QualType ToPointeeType = importChecked(Err, From: T->getPointeeType());
2119 Expr *ToAddrSpaceExpr = importChecked(Err, From: T->getAddrSpaceExpr());
2120 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2121 if (Err)
2122 return std::move(Err);
2123
2124 return Importer.getToContext().getDependentAddressSpaceType(
2125 PointeeType: ToPointeeType, AddrSpaceExpr: ToAddrSpaceExpr, AttrLoc: ToAttrLoc);
2126}
2127
2128ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
2129 const clang::DependentBitIntType *T) {
2130 ExpectedExpr ToNumBitsExprOrErr = import(From: T->getNumBitsExpr());
2131 if (!ToNumBitsExprOrErr)
2132 return ToNumBitsExprOrErr.takeError();
2133 return Importer.getToContext().getDependentBitIntType(Unsigned: T->isUnsigned(),
2134 BitsExpr: *ToNumBitsExprOrErr);
2135}
2136
2137ExpectedType clang::ASTNodeImporter::VisitPredefinedSugarType(
2138 const clang::PredefinedSugarType *T) {
2139 return Importer.getToContext().getPredefinedSugarType(KD: T->getKind());
2140}
2141
2142ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
2143 const clang::DependentSizedMatrixType *T) {
2144 Error Err = Error::success();
2145 QualType ToElementType = importChecked(Err, From: T->getElementType());
2146 Expr *ToRowExpr = importChecked(Err, From: T->getRowExpr());
2147 Expr *ToColumnExpr = importChecked(Err, From: T->getColumnExpr());
2148 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2149 if (Err)
2150 return std::move(Err);
2151
2152 return Importer.getToContext().getDependentSizedMatrixType(
2153 ElementType: ToElementType, RowExpr: ToRowExpr, ColumnExpr: ToColumnExpr, AttrLoc: ToAttrLoc);
2154}
2155
2156ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
2157 const clang::DependentVectorType *T) {
2158 Error Err = Error::success();
2159 QualType ToElementType = importChecked(Err, From: T->getElementType());
2160 Expr *ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
2161 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2162 if (Err)
2163 return std::move(Err);
2164
2165 return Importer.getToContext().getDependentVectorType(
2166 VectorType: ToElementType, SizeExpr: ToSizeExpr, AttrLoc: ToAttrLoc, VecKind: T->getVectorKind());
2167}
2168
2169ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
2170 const clang::ObjCTypeParamType *T) {
2171 Expected<ObjCTypeParamDecl *> ToDeclOrErr = import(From: T->getDecl());
2172 if (!ToDeclOrErr)
2173 return ToDeclOrErr.takeError();
2174
2175 SmallVector<ObjCProtocolDecl *, 4> ToProtocols;
2176 for (ObjCProtocolDecl *FromProtocol : T->getProtocols()) {
2177 Expected<ObjCProtocolDecl *> ToProtocolOrErr = import(From: FromProtocol);
2178 if (!ToProtocolOrErr)
2179 return ToProtocolOrErr.takeError();
2180 ToProtocols.push_back(Elt: *ToProtocolOrErr);
2181 }
2182
2183 return Importer.getToContext().getObjCTypeParamType(Decl: *ToDeclOrErr,
2184 protocols: ToProtocols);
2185}
2186
2187ExpectedType clang::ASTNodeImporter::VisitPipeType(const clang::PipeType *T) {
2188 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
2189 if (!ToElementTypeOrErr)
2190 return ToElementTypeOrErr.takeError();
2191
2192 ASTContext &ToCtx = Importer.getToContext();
2193 if (T->isReadOnly())
2194 return ToCtx.getReadPipeType(T: *ToElementTypeOrErr);
2195 else
2196 return ToCtx.getWritePipeType(T: *ToElementTypeOrErr);
2197}
2198
2199//----------------------------------------------------------------------------
2200// Import Declarations
2201//----------------------------------------------------------------------------
2202Error ASTNodeImporter::ImportDeclParts(
2203 NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
2204 DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
2205 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
2206 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
2207 // FIXME: We could support these constructs by importing a different type of
2208 // this parameter and by importing the original type of the parameter only
2209 // after the FunctionDecl is created. See
2210 // VisitFunctionDecl::UsedDifferentProtoType.
2211 DeclContext *OrigDC = D->getDeclContext();
2212 FunctionDecl *FunDecl;
2213 if (isa<RecordDecl>(Val: D) && (FunDecl = dyn_cast<FunctionDecl>(Val: OrigDC)) &&
2214 FunDecl->hasBody()) {
2215 auto getLeafPointeeType = [](const Type *T) {
2216 while (T->isPointerType() || T->isArrayType()) {
2217 T = T->getPointeeOrArrayElementType();
2218 }
2219 return T;
2220 };
2221 for (const ParmVarDecl *P : FunDecl->parameters()) {
2222 const Type *LeafT =
2223 getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
2224 auto *RT = dyn_cast<RecordType>(Val: LeafT);
2225 if (RT && RT->getDecl() == D) {
2226 Importer.FromDiag(Loc: D->getLocation(), DiagID: diag::err_unsupported_ast_node)
2227 << D->getDeclKindName();
2228 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
2229 }
2230 }
2231 }
2232
2233 // Import the context of this declaration.
2234 if (Error Err = ImportDeclContext(From: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
2235 return Err;
2236
2237 // Import the name of this declaration.
2238 if (Error Err = importInto(To&: Name, From: D->getDeclName()))
2239 return Err;
2240
2241 // Import the location of this declaration.
2242 if (Error Err = importInto(To&: Loc, From: D->getLocation()))
2243 return Err;
2244
2245 ToD = cast_or_null<NamedDecl>(Val: Importer.GetAlreadyImportedOrNull(FromD: D));
2246 if (ToD)
2247 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD: D, ToD))
2248 return Err;
2249
2250 return Error::success();
2251}
2252
2253Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
2254 NamedDecl *&ToD, SourceLocation &Loc) {
2255
2256 // Import the name of this declaration.
2257 if (Error Err = importInto(To&: Name, From: D->getDeclName()))
2258 return Err;
2259
2260 // Import the location of this declaration.
2261 if (Error Err = importInto(To&: Loc, From: D->getLocation()))
2262 return Err;
2263
2264 ToD = cast_or_null<NamedDecl>(Val: Importer.GetAlreadyImportedOrNull(FromD: D));
2265 if (ToD)
2266 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD: D, ToD))
2267 return Err;
2268
2269 return Error::success();
2270}
2271
2272Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2273 if (!FromD)
2274 return Error::success();
2275
2276 if (!ToD)
2277 if (Error Err = importInto(To&: ToD, From: FromD))
2278 return Err;
2279
2280 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(Val: FromD)) {
2281 if (RecordDecl *ToRecord = cast<RecordDecl>(Val: ToD)) {
2282 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
2283 !ToRecord->getDefinition()) {
2284 if (Error Err = ImportDefinition(From: FromRecord, To: ToRecord))
2285 return Err;
2286 }
2287 }
2288 return Error::success();
2289 }
2290
2291 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(Val: FromD)) {
2292 if (EnumDecl *ToEnum = cast<EnumDecl>(Val: ToD)) {
2293 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2294 if (Error Err = ImportDefinition(From: FromEnum, To: ToEnum))
2295 return Err;
2296 }
2297 }
2298 return Error::success();
2299 }
2300
2301 return Error::success();
2302}
2303
2304Error
2305ASTNodeImporter::ImportDeclarationNameLoc(
2306 const DeclarationNameInfo &From, DeclarationNameInfo& To) {
2307 // NOTE: To.Name and To.Loc are already imported.
2308 // We only have to import To.LocInfo.
2309 switch (To.getName().getNameKind()) {
2310 case DeclarationName::Identifier:
2311 case DeclarationName::ObjCZeroArgSelector:
2312 case DeclarationName::ObjCOneArgSelector:
2313 case DeclarationName::ObjCMultiArgSelector:
2314 case DeclarationName::CXXUsingDirective:
2315 case DeclarationName::CXXDeductionGuideName:
2316 return Error::success();
2317
2318 case DeclarationName::CXXOperatorName: {
2319 if (auto ToRangeOrErr = import(From: From.getCXXOperatorNameRange()))
2320 To.setCXXOperatorNameRange(*ToRangeOrErr);
2321 else
2322 return ToRangeOrErr.takeError();
2323 return Error::success();
2324 }
2325 case DeclarationName::CXXLiteralOperatorName: {
2326 if (ExpectedSLoc LocOrErr = import(From: From.getCXXLiteralOperatorNameLoc()))
2327 To.setCXXLiteralOperatorNameLoc(*LocOrErr);
2328 else
2329 return LocOrErr.takeError();
2330 return Error::success();
2331 }
2332 case DeclarationName::CXXConstructorName:
2333 case DeclarationName::CXXDestructorName:
2334 case DeclarationName::CXXConversionFunctionName: {
2335 if (auto ToTInfoOrErr = import(From: From.getNamedTypeInfo()))
2336 To.setNamedTypeInfo(*ToTInfoOrErr);
2337 else
2338 return ToTInfoOrErr.takeError();
2339 return Error::success();
2340 }
2341 }
2342 llvm_unreachable("Unknown name kind.");
2343}
2344
2345Error
2346ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2347 if (Importer.isMinimalImport() && !ForceImport) {
2348 auto ToDCOrErr = Importer.ImportContext(FromDC);
2349 return ToDCOrErr.takeError();
2350 }
2351
2352 // We use strict error handling in case of records and enums, but not
2353 // with e.g. namespaces.
2354 //
2355 // FIXME Clients of the ASTImporter should be able to choose an
2356 // appropriate error handling strategy for their needs. For instance,
2357 // they may not want to mark an entire namespace as erroneous merely
2358 // because there is an ODR error with two typedefs. As another example,
2359 // the client may allow EnumConstantDecls with same names but with
2360 // different values in two distinct translation units.
2361 ChildErrorHandlingStrategy HandleChildErrors(FromDC);
2362
2363 auto MightNeedReordering = [](const Decl *D) {
2364 return isa<FieldDecl>(Val: D) || isa<IndirectFieldDecl>(Val: D) || isa<FriendDecl>(Val: D);
2365 };
2366
2367 // Import everything that might need reordering first.
2368 Error ChildErrors = Error::success();
2369 for (auto *From : FromDC->decls()) {
2370 if (!MightNeedReordering(From))
2371 continue;
2372
2373 ExpectedDecl ImportedOrErr = import(From);
2374
2375 // If we are in the process of ImportDefinition(...) for a RecordDecl we
2376 // want to make sure that we are also completing each FieldDecl. There
2377 // are currently cases where this does not happen and this is correctness
2378 // fix since operations such as code generation will expect this to be so.
2379 if (!ImportedOrErr) {
2380 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors,
2381 ChildErr: ImportedOrErr.takeError());
2382 continue;
2383 }
2384 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(Val: From);
2385 Decl *ImportedDecl = *ImportedOrErr;
2386 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(Val: ImportedDecl);
2387 if (FieldFrom && FieldTo) {
2388 Error Err = ImportFieldDeclDefinition(From: FieldFrom, To: FieldTo);
2389 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors, ChildErr: std::move(Err));
2390 }
2391 }
2392
2393 // We reorder declarations in RecordDecls because they may have another order
2394 // in the "to" context than they have in the "from" context. This may happen
2395 // e.g when we import a class like this:
2396 // struct declToImport {
2397 // int a = c + b;
2398 // int b = 1;
2399 // int c = 2;
2400 // };
2401 // During the import of `a` we import first the dependencies in sequence,
2402 // thus the order would be `c`, `b`, `a`. We will get the normal order by
2403 // first removing the already imported members and then adding them in the
2404 // order as they appear in the "from" context.
2405 //
2406 // Keeping field order is vital because it determines structure layout.
2407 //
2408 // Here and below, we cannot call field_begin() method and its callers on
2409 // ToDC if it has an external storage. Calling field_begin() will
2410 // automatically load all the fields by calling
2411 // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
2412 // call ASTImporter::Import(). This is because the ExternalASTSource
2413 // interface in LLDB is implemented by the means of the ASTImporter. However,
2414 // calling an import at this point would result in an uncontrolled import, we
2415 // must avoid that.
2416
2417 auto ToDCOrErr = Importer.ImportContext(FromDC);
2418 if (!ToDCOrErr) {
2419 consumeError(Err: std::move(ChildErrors));
2420 return ToDCOrErr.takeError();
2421 }
2422
2423 if (const auto *FromRD = dyn_cast<RecordDecl>(Val: FromDC)) {
2424 DeclContext *ToDC = *ToDCOrErr;
2425 // Remove all declarations, which may be in wrong order in the
2426 // lexical DeclContext and then add them in the proper order.
2427 for (auto *D : FromRD->decls()) {
2428 if (!MightNeedReordering(D))
2429 continue;
2430
2431 assert(D && "DC contains a null decl");
2432 if (Decl *ToD = Importer.GetAlreadyImportedOrNull(FromD: D)) {
2433 // Remove only the decls which we successfully imported.
2434 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
2435 // Remove the decl from its wrong place in the linked list.
2436 ToDC->removeDecl(D: ToD);
2437 // Add the decl to the end of the linked list.
2438 // This time it will be at the proper place because the enclosing for
2439 // loop iterates in the original (good) order of the decls.
2440 ToDC->addDeclInternal(D: ToD);
2441 }
2442 }
2443 }
2444
2445 // Import everything else.
2446 for (auto *From : FromDC->decls()) {
2447 if (MightNeedReordering(From))
2448 continue;
2449
2450 ExpectedDecl ImportedOrErr = import(From);
2451 if (!ImportedOrErr)
2452 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors,
2453 ChildErr: ImportedOrErr.takeError());
2454 }
2455
2456 return ChildErrors;
2457}
2458
2459Error ASTNodeImporter::ImportFieldDeclDefinition(const FieldDecl *From,
2460 const FieldDecl *To) {
2461 RecordDecl *FromRecordDecl = nullptr;
2462 RecordDecl *ToRecordDecl = nullptr;
2463 // If we have a field that is an ArrayType we need to check if the array
2464 // element is a RecordDecl and if so we need to import the definition.
2465 QualType FromType = From->getType();
2466 QualType ToType = To->getType();
2467 if (FromType->isArrayType()) {
2468 // getBaseElementTypeUnsafe(...) handles multi-dimensional arrays for us.
2469 FromRecordDecl = FromType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2470 ToRecordDecl = ToType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2471 }
2472
2473 if (!FromRecordDecl || !ToRecordDecl) {
2474 const RecordType *RecordFrom = FromType->getAs<RecordType>();
2475 const RecordType *RecordTo = ToType->getAs<RecordType>();
2476
2477 if (RecordFrom && RecordTo) {
2478 FromRecordDecl = RecordFrom->getDecl();
2479 ToRecordDecl = RecordTo->getDecl();
2480 }
2481 }
2482
2483 if (FromRecordDecl && ToRecordDecl) {
2484 if (FromRecordDecl->isCompleteDefinition() &&
2485 !ToRecordDecl->isCompleteDefinition())
2486 return ImportDefinition(From: FromRecordDecl, To: ToRecordDecl);
2487 }
2488
2489 return Error::success();
2490}
2491
2492Error ASTNodeImporter::ImportDeclContext(
2493 Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
2494 auto ToDCOrErr = Importer.ImportContext(FromDC: FromD->getDeclContext());
2495 if (!ToDCOrErr)
2496 return ToDCOrErr.takeError();
2497 ToDC = *ToDCOrErr;
2498
2499 if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
2500 auto ToLexicalDCOrErr = Importer.ImportContext(
2501 FromDC: FromD->getLexicalDeclContext());
2502 if (!ToLexicalDCOrErr)
2503 return ToLexicalDCOrErr.takeError();
2504 ToLexicalDC = *ToLexicalDCOrErr;
2505 } else
2506 ToLexicalDC = ToDC;
2507
2508 return Error::success();
2509}
2510
2511Error ASTNodeImporter::ImportImplicitMethods(
2512 const CXXRecordDecl *From, CXXRecordDecl *To) {
2513 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
2514 "Import implicit methods to or from non-definition");
2515
2516 for (CXXMethodDecl *FromM : From->methods())
2517 if (FromM->isImplicit()) {
2518 Expected<CXXMethodDecl *> ToMOrErr = import(From: FromM);
2519 if (!ToMOrErr)
2520 return ToMOrErr.takeError();
2521 }
2522
2523 return Error::success();
2524}
2525
2526static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
2527 ASTImporter &Importer) {
2528 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
2529 if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromD: FromTypedef))
2530 To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(Val: *ToTypedefOrErr));
2531 else
2532 return ToTypedefOrErr.takeError();
2533 }
2534 return Error::success();
2535}
2536
2537Error ASTNodeImporter::ImportDefinition(
2538 RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
2539 auto DefinitionCompleter = [To]() {
2540 // There are cases in LLDB when we first import a class without its
2541 // members. The class will have DefinitionData, but no members. Then,
2542 // importDefinition is called from LLDB, which tries to get the members, so
2543 // when we get here, the class already has the DefinitionData set, so we
2544 // must unset the CompleteDefinition here to be able to complete again the
2545 // definition.
2546 To->setCompleteDefinition(false);
2547 To->completeDefinition();
2548 };
2549
2550 if (To->getDefinition() || To->isBeingDefined()) {
2551 if (Kind == IDK_Everything ||
2552 // In case of lambdas, the class already has a definition ptr set, but
2553 // the contained decls are not imported yet. Also, isBeingDefined was
2554 // set in CXXRecordDecl::CreateLambda. We must import the contained
2555 // decls here and finish the definition.
2556 (To->isLambda() && shouldForceImportDeclContext(IDK: Kind))) {
2557 if (To->isLambda()) {
2558 auto *FromCXXRD = cast<CXXRecordDecl>(Val: From);
2559 SmallVector<LambdaCapture, 8> ToCaptures;
2560 ToCaptures.reserve(N: FromCXXRD->capture_size());
2561 for (const auto &FromCapture : FromCXXRD->captures()) {
2562 if (auto ToCaptureOrErr = import(From: FromCapture))
2563 ToCaptures.push_back(Elt: *ToCaptureOrErr);
2564 else
2565 return ToCaptureOrErr.takeError();
2566 }
2567 cast<CXXRecordDecl>(Val: To)->setCaptures(Context&: Importer.getToContext(),
2568 Captures: ToCaptures);
2569 }
2570
2571 Error Result = ImportDeclContext(FromDC: From, /*ForceImport=*/true);
2572 // Finish the definition of the lambda, set isBeingDefined to false.
2573 if (To->isLambda())
2574 DefinitionCompleter();
2575 return Result;
2576 }
2577
2578 return Error::success();
2579 }
2580
2581 To->startDefinition();
2582 // Set the definition to complete even if it is really not complete during
2583 // import. Some AST constructs (expressions) require the record layout
2584 // to be calculated (see 'clang::computeDependence') at the time they are
2585 // constructed. Import of such AST node is possible during import of the
2586 // same record, there is no way to have a completely defined record (all
2587 // fields imported) at that time without multiple AST import passes.
2588 if (!Importer.isMinimalImport())
2589 To->setCompleteDefinition(true);
2590 // Complete the definition even if error is returned.
2591 // The RecordDecl may be already part of the AST so it is better to
2592 // have it in complete state even if something is wrong with it.
2593 llvm::scope_exit DefinitionCompleterScopeExit(DefinitionCompleter);
2594
2595 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2596 return Err;
2597
2598 // Add base classes.
2599 auto *ToCXX = dyn_cast<CXXRecordDecl>(Val: To);
2600 auto *FromCXX = dyn_cast<CXXRecordDecl>(Val: From);
2601 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2602
2603 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2604 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2605
2606 #define FIELD(Name, Width, Merge) \
2607 ToData.Name = FromData.Name;
2608 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2609
2610 // Copy over the data stored in RecordDeclBits
2611 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2612
2613 SmallVector<CXXBaseSpecifier *, 4> Bases;
2614 for (const auto &Base1 : FromCXX->bases()) {
2615 ExpectedType TyOrErr = import(From: Base1.getType());
2616 if (!TyOrErr)
2617 return TyOrErr.takeError();
2618
2619 SourceLocation EllipsisLoc;
2620 if (Base1.isPackExpansion()) {
2621 if (ExpectedSLoc LocOrErr = import(From: Base1.getEllipsisLoc()))
2622 EllipsisLoc = *LocOrErr;
2623 else
2624 return LocOrErr.takeError();
2625 }
2626
2627 // Ensure that we have a definition for the base.
2628 if (Error Err =
2629 ImportDefinitionIfNeeded(FromD: Base1.getType()->getAsCXXRecordDecl()))
2630 return Err;
2631
2632 auto RangeOrErr = import(From: Base1.getSourceRange());
2633 if (!RangeOrErr)
2634 return RangeOrErr.takeError();
2635
2636 auto TSIOrErr = import(From: Base1.getTypeSourceInfo());
2637 if (!TSIOrErr)
2638 return TSIOrErr.takeError();
2639
2640 Bases.push_back(
2641 Elt: new (Importer.getToContext()) CXXBaseSpecifier(
2642 *RangeOrErr,
2643 Base1.isVirtual(),
2644 Base1.isBaseOfClass(),
2645 Base1.getAccessSpecifierAsWritten(),
2646 *TSIOrErr,
2647 EllipsisLoc));
2648 }
2649 if (!Bases.empty())
2650 ToCXX->setBases(Bases: Bases.data(), NumBases: Bases.size());
2651 }
2652
2653 if (shouldForceImportDeclContext(IDK: Kind)) {
2654 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
2655 return Err;
2656 }
2657
2658 return Error::success();
2659}
2660
2661Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
2662 if (To->getAnyInitializer())
2663 return Error::success();
2664
2665 Expr *FromInit = From->getInit();
2666 if (!FromInit)
2667 return Error::success();
2668
2669 ExpectedExpr ToInitOrErr = import(From: FromInit);
2670 if (!ToInitOrErr)
2671 return ToInitOrErr.takeError();
2672
2673 To->setInit(*ToInitOrErr);
2674 if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2675 EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2676 ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2677 ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2678 // FIXME: Also import the initializer value.
2679 }
2680
2681 // FIXME: Other bits to merge?
2682 return Error::success();
2683}
2684
2685Error ASTNodeImporter::ImportDefinition(
2686 EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
2687 if (To->getDefinition() || To->isBeingDefined()) {
2688 if (Kind == IDK_Everything)
2689 return ImportDeclContext(FromDC: From, /*ForceImport=*/true);
2690 return Error::success();
2691 }
2692
2693 To->startDefinition();
2694
2695 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2696 return Err;
2697
2698 ExpectedType ToTypeOrErr =
2699 import(From: QualType(Importer.getFromContext().getCanonicalTagType(TD: From)));
2700 if (!ToTypeOrErr)
2701 return ToTypeOrErr.takeError();
2702
2703 ExpectedType ToPromotionTypeOrErr = import(From: From->getPromotionType());
2704 if (!ToPromotionTypeOrErr)
2705 return ToPromotionTypeOrErr.takeError();
2706
2707 if (shouldForceImportDeclContext(IDK: Kind))
2708 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
2709 return Err;
2710
2711 // FIXME: we might need to merge the number of positive or negative bits
2712 // if the enumerator lists don't match.
2713 To->completeDefinition(NewType: *ToTypeOrErr, PromotionType: *ToPromotionTypeOrErr,
2714 NumPositiveBits: From->getNumPositiveBits(),
2715 NumNegativeBits: From->getNumNegativeBits());
2716 return Error::success();
2717}
2718
2719Error ASTNodeImporter::ImportTemplateArguments(
2720 ArrayRef<TemplateArgument> FromArgs,
2721 SmallVectorImpl<TemplateArgument> &ToArgs) {
2722 for (const auto &Arg : FromArgs) {
2723 if (auto ToOrErr = import(From: Arg))
2724 ToArgs.push_back(Elt: *ToOrErr);
2725 else
2726 return ToOrErr.takeError();
2727 }
2728
2729 return Error::success();
2730}
2731
2732// FIXME: Do not forget to remove this and use only 'import'.
2733Expected<TemplateArgument>
2734ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2735 return import(From);
2736}
2737
2738template <typename InContainerTy>
2739Error ASTNodeImporter::ImportTemplateArgumentListInfo(
2740 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
2741 for (const auto &FromLoc : Container) {
2742 if (auto ToLocOrErr = import(FromLoc))
2743 ToTAInfo.addArgument(Loc: *ToLocOrErr);
2744 else
2745 return ToLocOrErr.takeError();
2746 }
2747 return Error::success();
2748}
2749
2750static StructuralEquivalenceKind
2751getStructuralEquivalenceKind(const ASTImporter &Importer) {
2752 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
2753 : StructuralEquivalenceKind::Default;
2754}
2755
2756bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain,
2757 bool IgnoreTemplateParmDepth) {
2758 // Eliminate a potential failure point where we attempt to re-import
2759 // something we're trying to import while completing ToRecord.
2760 Decl *ToOrigin = Importer.GetOriginalDecl(To);
2761 if (ToOrigin) {
2762 To = ToOrigin;
2763 }
2764
2765 StructuralEquivalenceContext Ctx(
2766 Importer.getToContext().getLangOpts(), Importer.getFromContext(),
2767 Importer.getToContext(), Importer.getNonEquivalentDecls(),
2768 getStructuralEquivalenceKind(Importer),
2769 /*StrictTypeSpelling=*/false, Complain, /*ErrorOnTagTypeMismatch=*/false,
2770 IgnoreTemplateParmDepth);
2771 return Ctx.IsEquivalent(D1: From, D2: To);
2772}
2773
2774ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
2775 Importer.FromDiag(Loc: D->getLocation(), DiagID: diag::err_unsupported_ast_node)
2776 << D->getDeclKindName();
2777 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
2778}
2779
2780ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
2781 Importer.FromDiag(Loc: D->getLocation(), DiagID: diag::err_unsupported_ast_node)
2782 << D->getDeclKindName();
2783 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
2784}
2785
2786ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
2787 // Import the context of this declaration.
2788 DeclContext *DC, *LexicalDC;
2789 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
2790 return std::move(Err);
2791
2792 // Import the location of this declaration.
2793 ExpectedSLoc LocOrErr = import(From: D->getLocation());
2794 if (!LocOrErr)
2795 return LocOrErr.takeError();
2796
2797 EmptyDecl *ToD;
2798 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: *LocOrErr))
2799 return ToD;
2800
2801 ToD->setLexicalDeclContext(LexicalDC);
2802 LexicalDC->addDeclInternal(D: ToD);
2803 return ToD;
2804}
2805
2806ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2807 TranslationUnitDecl *ToD =
2808 Importer.getToContext().getTranslationUnitDecl();
2809
2810 Importer.MapImported(From: D, To: ToD);
2811
2812 return ToD;
2813}
2814
2815ExpectedDecl ASTNodeImporter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
2816 Error Err = Error::success();
2817 Expr *ToAsmString = importChecked(Err, From: D->getAsmStringExpr());
2818 SourceLocation ToAsmLoc = importChecked(Err, From: D->getAsmLoc());
2819 SourceLocation ToRParenLoc = importChecked(Err, From: D->getRParenLoc());
2820 if (Err)
2821 return std::move(Err);
2822
2823 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2824 if (!DCOrErr)
2825 return DCOrErr.takeError();
2826 DeclContext *DC = *DCOrErr;
2827
2828 FileScopeAsmDecl *ToD;
2829 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToAsmString,
2830 args&: ToAsmLoc, args&: ToRParenLoc))
2831 return ToD;
2832
2833 ToD->setLexicalDeclContext(DC);
2834 DC->addDeclInternal(D: ToD);
2835
2836 return ToD;
2837}
2838
2839ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
2840 DeclContext *DC, *LexicalDC;
2841 DeclarationName Name;
2842 SourceLocation Loc;
2843 NamedDecl *ToND;
2844 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: ToND, Loc))
2845 return std::move(Err);
2846 if (ToND)
2847 return ToND;
2848
2849 BindingDecl *ToD;
2850 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
2851 args: Name.getAsIdentifierInfo(), args: D->getType()))
2852 return ToD;
2853
2854 Error Err = Error::success();
2855 QualType ToType = importChecked(Err, From: D->getType());
2856 Expr *ToBinding = importChecked(Err, From: D->getBinding());
2857 DecompositionDecl *ToDecomposedDecl =
2858 importChecked(Err, From: D->getDecomposedDecl());
2859 if (Err)
2860 return std::move(Err);
2861
2862 ToD->setBinding(DeclaredType: ToType, Binding: ToBinding);
2863 ToD->setDecomposedDecl(ToDecomposedDecl);
2864 addDeclToContexts(FromD: D, ToD);
2865
2866 return ToD;
2867}
2868
2869ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2870 ExpectedSLoc LocOrErr = import(From: D->getLocation());
2871 if (!LocOrErr)
2872 return LocOrErr.takeError();
2873 auto ColonLocOrErr = import(From: D->getColonLoc());
2874 if (!ColonLocOrErr)
2875 return ColonLocOrErr.takeError();
2876
2877 // Import the context of this declaration.
2878 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2879 if (!DCOrErr)
2880 return DCOrErr.takeError();
2881 DeclContext *DC = *DCOrErr;
2882
2883 AccessSpecDecl *ToD;
2884 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args: D->getAccess(),
2885 args&: DC, args&: *LocOrErr, args&: *ColonLocOrErr))
2886 return ToD;
2887
2888 // Lexical DeclContext and Semantic DeclContext
2889 // is always the same for the accessSpec.
2890 ToD->setLexicalDeclContext(DC);
2891 DC->addDeclInternal(D: ToD);
2892
2893 return ToD;
2894}
2895
2896ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2897 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2898 if (!DCOrErr)
2899 return DCOrErr.takeError();
2900 DeclContext *DC = *DCOrErr;
2901 DeclContext *LexicalDC = DC;
2902
2903 Error Err = Error::success();
2904 auto ToLocation = importChecked(Err, From: D->getLocation());
2905 auto ToRParenLoc = importChecked(Err, From: D->getRParenLoc());
2906 auto ToAssertExpr = importChecked(Err, From: D->getAssertExpr());
2907 auto ToMessage = importChecked(Err, From: D->getMessage());
2908 if (Err)
2909 return std::move(Err);
2910
2911 StaticAssertDecl *ToD;
2912 if (GetImportedOrCreateDecl(
2913 ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToLocation, args&: ToAssertExpr, args&: ToMessage,
2914 args&: ToRParenLoc, args: D->isFailed()))
2915 return ToD;
2916
2917 ToD->setLexicalDeclContext(LexicalDC);
2918 LexicalDC->addDeclInternal(D: ToD);
2919 return ToD;
2920}
2921
2922ExpectedDecl
2923ASTNodeImporter::VisitCXXExpansionStmtDecl(CXXExpansionStmtDecl *D) {
2924 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2925 if (!DCOrErr)
2926 return DCOrErr.takeError();
2927 DeclContext *DC = *DCOrErr;
2928 DeclContext *LexicalDC = DC;
2929
2930 Error Err = Error::success();
2931 auto ToLocation = importChecked(Err, From: D->getLocation());
2932 auto ToExpansion = importChecked(Err, From: D->getExpansionPattern());
2933 auto ToIndex = importChecked(Err, From: D->getIndexTemplateParm());
2934 auto ToInstantiations = importChecked(Err, From: D->getInstantiations());
2935 if (Err)
2936 return std::move(Err);
2937
2938 CXXExpansionStmtDecl *ToD;
2939 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToLocation,
2940 args&: ToIndex))
2941 return ToD;
2942
2943 ToD->setExpansionPattern(ToExpansion);
2944 ToD->setInstantiations(ToInstantiations);
2945 ToD->setLexicalDeclContext(LexicalDC);
2946 LexicalDC->addDeclInternal(D: ToD);
2947 return ToD;
2948}
2949
2950ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2951 // Import the major distinguishing characteristics of this namespace.
2952 DeclContext *DC, *LexicalDC;
2953 DeclarationName Name;
2954 SourceLocation Loc;
2955 NamedDecl *ToD;
2956 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2957 return std::move(Err);
2958 if (ToD)
2959 return ToD;
2960
2961 NamespaceDecl *MergeWithNamespace = nullptr;
2962 if (!Name) {
2963 // This is an anonymous namespace. Adopt an existing anonymous
2964 // namespace if we can.
2965 DeclContext *EnclosingDC = DC->getEnclosingNamespaceContext();
2966 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: EnclosingDC))
2967 MergeWithNamespace = TU->getAnonymousNamespace();
2968 else
2969 MergeWithNamespace =
2970 cast<NamespaceDecl>(Val: EnclosingDC)->getAnonymousNamespace();
2971 } else {
2972 SmallVector<NamedDecl *, 4> ConflictingDecls;
2973 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2974 for (auto *FoundDecl : FoundDecls) {
2975 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Namespace))
2976 continue;
2977
2978 if (auto *FoundNS = dyn_cast<NamespaceDecl>(Val: FoundDecl)) {
2979 MergeWithNamespace = FoundNS;
2980 ConflictingDecls.clear();
2981 break;
2982 }
2983
2984 ConflictingDecls.push_back(Elt: FoundDecl);
2985 }
2986
2987 if (!ConflictingDecls.empty()) {
2988 ExpectedName NameOrErr = Importer.HandleNameConflict(
2989 Name, DC, IDNS: Decl::IDNS_Namespace, Decls: ConflictingDecls.data(),
2990 NumDecls: ConflictingDecls.size());
2991 if (NameOrErr)
2992 Name = NameOrErr.get();
2993 else
2994 return NameOrErr.takeError();
2995 }
2996 }
2997
2998 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
2999 if (!BeginLocOrErr)
3000 return BeginLocOrErr.takeError();
3001 ExpectedSLoc RBraceLocOrErr = import(From: D->getRBraceLoc());
3002 if (!RBraceLocOrErr)
3003 return RBraceLocOrErr.takeError();
3004
3005 // Create the "to" namespace, if needed.
3006 NamespaceDecl *ToNamespace = MergeWithNamespace;
3007 if (!ToNamespace) {
3008 if (GetImportedOrCreateDecl(ToD&: ToNamespace, FromD: D, args&: Importer.getToContext(), args&: DC,
3009 args: D->isInline(), args&: *BeginLocOrErr, args&: Loc,
3010 args: Name.getAsIdentifierInfo(),
3011 /*PrevDecl=*/args: nullptr, args: D->isNested()))
3012 return ToNamespace;
3013 ToNamespace->setRBraceLoc(*RBraceLocOrErr);
3014 ToNamespace->setLexicalDeclContext(LexicalDC);
3015 LexicalDC->addDeclInternal(D: ToNamespace);
3016
3017 // If this is an anonymous namespace, register it as the anonymous
3018 // namespace within its context.
3019 if (!Name) {
3020 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: DC))
3021 TU->setAnonymousNamespace(ToNamespace);
3022 else
3023 cast<NamespaceDecl>(Val: DC)->setAnonymousNamespace(ToNamespace);
3024 }
3025 }
3026 Importer.MapImported(From: D, To: ToNamespace);
3027
3028 if (Error Err = ImportDeclContext(FromDC: D))
3029 return std::move(Err);
3030
3031 return ToNamespace;
3032}
3033
3034ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
3035 // Import the major distinguishing characteristics of this namespace.
3036 DeclContext *DC, *LexicalDC;
3037 DeclarationName Name;
3038 SourceLocation Loc;
3039 NamedDecl *LookupD;
3040 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: LookupD, Loc))
3041 return std::move(Err);
3042 if (LookupD)
3043 return LookupD;
3044
3045 // NOTE: No conflict resolution is done for namespace aliases now.
3046
3047 Error Err = Error::success();
3048 auto ToNamespaceLoc = importChecked(Err, From: D->getNamespaceLoc());
3049 auto ToAliasLoc = importChecked(Err, From: D->getAliasLoc());
3050 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3051 auto ToTargetNameLoc = importChecked(Err, From: D->getTargetNameLoc());
3052 auto ToNamespace = importChecked(Err, From: D->getNamespace());
3053 if (Err)
3054 return std::move(Err);
3055
3056 IdentifierInfo *ToIdentifier = Importer.Import(FromId: D->getIdentifier());
3057
3058 NamespaceAliasDecl *ToD;
3059 if (GetImportedOrCreateDecl(
3060 ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToNamespaceLoc, args&: ToAliasLoc,
3061 args&: ToIdentifier, args&: ToQualifierLoc, args&: ToTargetNameLoc, args&: ToNamespace))
3062 return ToD;
3063
3064 ToD->setLexicalDeclContext(LexicalDC);
3065 LexicalDC->addDeclInternal(D: ToD);
3066
3067 return ToD;
3068}
3069
3070ExpectedDecl
3071ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
3072 // Import the major distinguishing characteristics of this typedef.
3073 DeclarationName Name;
3074 SourceLocation Loc;
3075 NamedDecl *ToD;
3076 // Do not import the DeclContext, we will import it once the TypedefNameDecl
3077 // is created.
3078 if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
3079 return std::move(Err);
3080 if (ToD)
3081 return ToD;
3082
3083 DeclContext *DC = cast_or_null<DeclContext>(
3084 Val: Importer.GetAlreadyImportedOrNull(FromD: cast<Decl>(Val: D->getDeclContext())));
3085 DeclContext *LexicalDC =
3086 cast_or_null<DeclContext>(Val: Importer.GetAlreadyImportedOrNull(
3087 FromD: cast<Decl>(Val: D->getLexicalDeclContext())));
3088
3089 // If this typedef is not in block scope, determine whether we've
3090 // seen a typedef with the same name (that we can merge with) or any
3091 // other entity by that name (which name lookup could conflict with).
3092 // Note: Repeated typedefs are not valid in C99:
3093 // 'typedef int T; typedef int T;' is invalid
3094 // We do not care about this now.
3095 if (DC && !DC->isFunctionOrMethod()) {
3096 SmallVector<NamedDecl *, 4> ConflictingDecls;
3097 unsigned IDNS = Decl::IDNS_Ordinary;
3098 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3099 for (auto *FoundDecl : FoundDecls) {
3100 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3101 continue;
3102 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(Val: FoundDecl)) {
3103 if (!hasSameVisibilityContextAndLinkage(Found: FoundTypedef, From: D))
3104 continue;
3105
3106 QualType FromUT = D->getUnderlyingType();
3107 QualType FoundUT = FoundTypedef->getUnderlyingType();
3108 if (Importer.IsStructurallyEquivalent(From: FromUT, To: FoundUT)) {
3109 // If the underlying declarations are unnamed records these can be
3110 // imported as different types. We should create a distinct typedef
3111 // node in this case.
3112 // If we found an existing underlying type with a record in a
3113 // different context (than the imported), this is already reason for
3114 // having distinct typedef nodes for these.
3115 // Again this can create situation like
3116 // 'typedef int T; typedef int T;' but this is hard to avoid without
3117 // a rename strategy at import.
3118 if (!FromUT.isNull() && !FoundUT.isNull()) {
3119 RecordDecl *FromR = FromUT->getAsRecordDecl();
3120 RecordDecl *FoundR = FoundUT->getAsRecordDecl();
3121 if (FromR && FoundR &&
3122 !hasSameVisibilityContextAndLinkage(Found: FoundR, From: FromR))
3123 continue;
3124 }
3125 // If the "From" context has a complete underlying type but we
3126 // already have a complete underlying type then return with that.
3127 if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
3128 return Importer.MapImported(From: D, To: FoundTypedef);
3129 // FIXME Handle redecl chain. When you do that make consistent changes
3130 // in ASTImporterLookupTable too.
3131 } else {
3132 ConflictingDecls.push_back(Elt: FoundDecl);
3133 }
3134 }
3135 }
3136
3137 if (!ConflictingDecls.empty()) {
3138 ExpectedName NameOrErr = Importer.HandleNameConflict(
3139 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3140 if (NameOrErr)
3141 Name = NameOrErr.get();
3142 else
3143 return NameOrErr.takeError();
3144 }
3145 }
3146
3147 Error Err = Error::success();
3148 auto ToUnderlyingType = importChecked(Err, From: D->getUnderlyingType());
3149 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
3150 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
3151 if (Err)
3152 return std::move(Err);
3153
3154 // Create the new typedef node.
3155 // FIXME: ToUnderlyingType is not used.
3156 (void)ToUnderlyingType;
3157 TypedefNameDecl *ToTypedef;
3158 if (IsAlias) {
3159 if (GetImportedOrCreateDecl<TypeAliasDecl>(
3160 ToD&: ToTypedef, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc, args&: Loc,
3161 args: Name.getAsIdentifierInfo(), args&: ToTypeSourceInfo))
3162 return ToTypedef;
3163 } else if (GetImportedOrCreateDecl<TypedefDecl>(
3164 ToD&: ToTypedef, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc, args&: Loc,
3165 args: Name.getAsIdentifierInfo(), args&: ToTypeSourceInfo))
3166 return ToTypedef;
3167
3168 // Import the DeclContext and set it to the Typedef.
3169 if ((Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC)))
3170 return std::move(Err);
3171 ToTypedef->setDeclContext(DC);
3172 ToTypedef->setLexicalDeclContext(LexicalDC);
3173 // Add to the lookupTable because we could not do that in MapImported.
3174 Importer.AddToLookupTable(ToD: ToTypedef);
3175
3176 ToTypedef->setAccess(D->getAccess());
3177
3178 // Templated declarations should not appear in DeclContext.
3179 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(Val: D) : nullptr;
3180 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
3181 LexicalDC->addDeclInternal(D: ToTypedef);
3182
3183 return ToTypedef;
3184}
3185
3186ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
3187 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
3188}
3189
3190ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
3191 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
3192}
3193
3194ExpectedDecl
3195ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
3196 // Import the major distinguishing characteristics of this typedef.
3197 DeclContext *DC, *LexicalDC;
3198 DeclarationName Name;
3199 SourceLocation Loc;
3200 NamedDecl *FoundD;
3201 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: FoundD, Loc))
3202 return std::move(Err);
3203 if (FoundD)
3204 return FoundD;
3205
3206 // If this typedef is not in block scope, determine whether we've
3207 // seen a typedef with the same name (that we can merge with) or any
3208 // other entity by that name (which name lookup could conflict with).
3209 if (!DC->isFunctionOrMethod()) {
3210 SmallVector<NamedDecl *, 4> ConflictingDecls;
3211 unsigned IDNS = Decl::IDNS_Ordinary;
3212 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3213 for (auto *FoundDecl : FoundDecls) {
3214 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3215 continue;
3216 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(Val: FoundDecl)) {
3217 if (IsStructuralMatch(From: D, To: FoundAlias))
3218 return Importer.MapImported(From: D, To: FoundAlias);
3219 ConflictingDecls.push_back(Elt: FoundDecl);
3220 }
3221 }
3222
3223 if (!ConflictingDecls.empty()) {
3224 ExpectedName NameOrErr = Importer.HandleNameConflict(
3225 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3226 if (NameOrErr)
3227 Name = NameOrErr.get();
3228 else
3229 return NameOrErr.takeError();
3230 }
3231 }
3232
3233 Error Err = Error::success();
3234 auto ToTemplateParameters = importChecked(Err, From: D->getTemplateParameters());
3235 auto ToTemplatedDecl = importChecked(Err, From: D->getTemplatedDecl());
3236 if (Err)
3237 return std::move(Err);
3238
3239 TypeAliasTemplateDecl *ToAlias;
3240 if (GetImportedOrCreateDecl(ToD&: ToAlias, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3241 args&: Name, args&: ToTemplateParameters, args&: ToTemplatedDecl))
3242 return ToAlias;
3243
3244 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
3245
3246 ToAlias->setAccess(D->getAccess());
3247 ToAlias->setLexicalDeclContext(LexicalDC);
3248 LexicalDC->addDeclInternal(D: ToAlias);
3249 if (DC != Importer.getToContext().getTranslationUnitDecl())
3250 updateLookupTableForTemplateParameters(Params&: *ToTemplateParameters);
3251 return ToAlias;
3252}
3253
3254ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
3255 // Import the major distinguishing characteristics of this label.
3256 DeclContext *DC, *LexicalDC;
3257 DeclarationName Name;
3258 SourceLocation Loc;
3259 NamedDecl *ToD;
3260 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3261 return std::move(Err);
3262 if (ToD)
3263 return ToD;
3264
3265 assert(LexicalDC->isFunctionOrMethod());
3266
3267 LabelDecl *ToLabel;
3268 if (D->isGnuLocal()) {
3269 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
3270 if (!BeginLocOrErr)
3271 return BeginLocOrErr.takeError();
3272 if (GetImportedOrCreateDecl(ToD&: ToLabel, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3273 args: Name.getAsIdentifierInfo(), args&: *BeginLocOrErr))
3274 return ToLabel;
3275
3276 } else {
3277 if (GetImportedOrCreateDecl(ToD&: ToLabel, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3278 args: Name.getAsIdentifierInfo()))
3279 return ToLabel;
3280
3281 }
3282
3283 Expected<LabelStmt *> ToStmtOrErr = import(From: D->getStmt());
3284 if (!ToStmtOrErr)
3285 return ToStmtOrErr.takeError();
3286
3287 ToLabel->setStmt(*ToStmtOrErr);
3288 ToLabel->setLexicalDeclContext(LexicalDC);
3289 LexicalDC->addDeclInternal(D: ToLabel);
3290 return ToLabel;
3291}
3292
3293ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
3294 // Import the major distinguishing characteristics of this enum.
3295 DeclContext *DC, *LexicalDC;
3296 DeclarationName Name;
3297 SourceLocation Loc;
3298 NamedDecl *ToD;
3299 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3300 return std::move(Err);
3301 if (ToD)
3302 return ToD;
3303
3304 // Figure out what enum name we're looking for.
3305 unsigned IDNS = Decl::IDNS_Tag;
3306 DeclarationName SearchName = Name;
3307 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3308 if (Error Err = importInto(
3309 To&: SearchName, From: D->getTypedefNameForAnonDecl()->getDeclName()))
3310 return std::move(Err);
3311 IDNS = Decl::IDNS_Ordinary;
3312 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3313 IDNS |= Decl::IDNS_Ordinary;
3314
3315 // We may already have an enum of the same name; try to find and match it.
3316 EnumDecl *PrevDecl = nullptr;
3317 if (!DC->isFunctionOrMethod()) {
3318 SmallVector<NamedDecl *, 4> ConflictingDecls;
3319 auto FoundDecls =
3320 Importer.findDeclsInToCtx(DC, Name: SearchName);
3321 for (auto *FoundDecl : FoundDecls) {
3322 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3323 continue;
3324
3325 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Val: FoundDecl)) {
3326 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3327 FoundDecl = Tag->getDecl();
3328 }
3329
3330 if (auto *FoundEnum = dyn_cast<EnumDecl>(Val: FoundDecl)) {
3331 if (!hasSameVisibilityContextAndLinkage(Found: FoundEnum, From: D))
3332 continue;
3333 if (IsStructuralMatch(From: D, To: FoundEnum, Complain: !SearchName.isEmpty())) {
3334 EnumDecl *FoundDef = FoundEnum->getDefinition();
3335 if (D->isThisDeclarationADefinition() && FoundDef)
3336 return Importer.MapImported(From: D, To: FoundDef);
3337 PrevDecl = FoundEnum->getMostRecentDecl();
3338 break;
3339 }
3340 ConflictingDecls.push_back(Elt: FoundDecl);
3341 }
3342 }
3343
3344 // In case of unnamed enums, we try to find an existing similar one, if none
3345 // was found, perform the import always.
3346 // Structural in-equivalence is not detected in this way here, but it may
3347 // be found when the parent decl is imported (if the enum is part of a
3348 // class). To make this totally exact a more difficult solution is needed.
3349 if (SearchName && !ConflictingDecls.empty()) {
3350 ExpectedName NameOrErr = Importer.HandleNameConflict(
3351 Name: SearchName, DC, IDNS, Decls: ConflictingDecls.data(),
3352 NumDecls: ConflictingDecls.size());
3353 if (NameOrErr)
3354 Name = NameOrErr.get();
3355 else
3356 return NameOrErr.takeError();
3357 }
3358 }
3359
3360 Error Err = Error::success();
3361 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
3362 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3363 auto ToIntegerType = importChecked(Err, From: D->getIntegerType());
3364 auto ToBraceRange = importChecked(Err, From: D->getBraceRange());
3365 if (Err)
3366 return std::move(Err);
3367
3368 // Create the enum declaration.
3369 EnumDecl *D2;
3370 if (GetImportedOrCreateDecl(
3371 ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc,
3372 args&: Loc, args: Name.getAsIdentifierInfo(), args&: PrevDecl, args: D->isScoped(),
3373 args: D->isScopedUsingClassTag(), args: D->isFixed()))
3374 return D2;
3375
3376 D2->setQualifierInfo(ToQualifierLoc);
3377 D2->setIntegerType(ToIntegerType);
3378 D2->setBraceRange(ToBraceRange);
3379 D2->setAccess(D->getAccess());
3380 D2->setLexicalDeclContext(LexicalDC);
3381 addDeclToContexts(FromD: D, ToD: D2);
3382
3383 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
3384 TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
3385 EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
3386 if (Expected<EnumDecl *> ToInstOrErr = import(From: FromInst))
3387 D2->setInstantiationOfMemberEnum(ED: *ToInstOrErr, TSK: SK);
3388 else
3389 return ToInstOrErr.takeError();
3390 if (ExpectedSLoc POIOrErr = import(From: MemberInfo->getPointOfInstantiation()))
3391 D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3392 else
3393 return POIOrErr.takeError();
3394 }
3395
3396 // Import the definition
3397 if (D->isCompleteDefinition())
3398 if (Error Err = ImportDefinition(From: D, To: D2))
3399 return std::move(Err);
3400
3401 return D2;
3402}
3403
3404ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
3405 bool IsFriendTemplate = false;
3406 if (auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3407 IsFriendTemplate =
3408 DCXX->getDescribedClassTemplate() &&
3409 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3410 Decl::FOK_None;
3411 }
3412
3413 // Import the major distinguishing characteristics of this record.
3414 DeclContext *DC = nullptr, *LexicalDC = nullptr;
3415 DeclarationName Name;
3416 SourceLocation Loc;
3417 NamedDecl *ToD = nullptr;
3418 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3419 return std::move(Err);
3420 if (ToD)
3421 return ToD;
3422
3423 // Figure out what structure name we're looking for.
3424 unsigned IDNS = Decl::IDNS_Tag;
3425 DeclarationName SearchName = Name;
3426 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3427 if (Error Err = importInto(
3428 To&: SearchName, From: D->getTypedefNameForAnonDecl()->getDeclName()))
3429 return std::move(Err);
3430 IDNS = Decl::IDNS_Ordinary;
3431 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3432 IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
3433
3434 bool IsDependentContext = DC != LexicalDC ? LexicalDC->isDependentContext()
3435 : DC->isDependentContext();
3436 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3437
3438 // We may already have a record of the same name; try to find and match it.
3439 RecordDecl *PrevDecl = nullptr;
3440 if (!DependentFriend && !DC->isFunctionOrMethod() && !D->isLambda()) {
3441 SmallVector<NamedDecl *, 4> ConflictingDecls;
3442 auto FoundDecls =
3443 Importer.findDeclsInToCtx(DC, Name: SearchName);
3444 if (!FoundDecls.empty()) {
3445 // We're going to have to compare D against potentially conflicting Decls,
3446 // so complete it.
3447 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
3448 D->getASTContext().getExternalSource()->CompleteType(Tag: D);
3449 }
3450
3451 for (auto *FoundDecl : FoundDecls) {
3452 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3453 continue;
3454
3455 Decl *Found = FoundDecl;
3456 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Val: Found)) {
3457 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3458 Found = Tag->getDecl();
3459 }
3460
3461 if (auto *FoundRecord = dyn_cast<RecordDecl>(Val: Found)) {
3462 // Do not emit false positive diagnostic in case of unnamed
3463 // struct/union and in case of anonymous structs. Would be false
3464 // because there may be several anonymous/unnamed structs in a class.
3465 // E.g. these are both valid:
3466 // struct A { // unnamed structs
3467 // struct { struct A *next; } entry0;
3468 // struct { struct A *next; } entry1;
3469 // };
3470 // struct X { struct { int a; }; struct { int b; }; }; // anon structs
3471 if (!SearchName)
3472 if (!IsStructuralMatch(From: D, To: FoundRecord, Complain: false))
3473 continue;
3474
3475 if (!hasSameVisibilityContextAndLinkage(Found: FoundRecord, From: D))
3476 continue;
3477
3478 if (IsStructuralMatch(From: D, To: FoundRecord)) {
3479 RecordDecl *FoundDef = FoundRecord->getDefinition();
3480 if (D->isThisDeclarationADefinition() && FoundDef) {
3481 // FIXME: Structural equivalence check should check for same
3482 // user-defined methods.
3483 Importer.MapImported(From: D, To: FoundDef);
3484 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3485 auto *FoundCXX = dyn_cast<CXXRecordDecl>(Val: FoundDef);
3486 assert(FoundCXX && "Record type mismatch");
3487
3488 if (!Importer.isMinimalImport())
3489 // FoundDef may not have every implicit method that D has
3490 // because implicit methods are created only if they are used.
3491 if (Error Err = ImportImplicitMethods(From: DCXX, To: FoundCXX))
3492 return std::move(Err);
3493 }
3494 // FIXME: We can return FoundDef here.
3495 }
3496 PrevDecl = FoundRecord->getMostRecentDecl();
3497 break;
3498 }
3499 ConflictingDecls.push_back(Elt: FoundDecl);
3500 } // kind is RecordDecl
3501 } // for
3502
3503 if (!ConflictingDecls.empty() && SearchName) {
3504 ExpectedName NameOrErr = Importer.HandleNameConflict(
3505 Name: SearchName, DC, IDNS, Decls: ConflictingDecls.data(),
3506 NumDecls: ConflictingDecls.size());
3507 if (NameOrErr)
3508 Name = NameOrErr.get();
3509 else
3510 return NameOrErr.takeError();
3511 }
3512 }
3513
3514 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
3515 if (!BeginLocOrErr)
3516 return BeginLocOrErr.takeError();
3517
3518 // Create the record declaration.
3519 RecordDecl *D2 = nullptr;
3520 CXXRecordDecl *D2CXX = nullptr;
3521 if (auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3522 if (DCXX->isLambda()) {
3523 auto TInfoOrErr = import(From: DCXX->getLambdaTypeInfo());
3524 if (!TInfoOrErr)
3525 return TInfoOrErr.takeError();
3526 if (GetImportedOrCreateSpecialDecl(
3527 ToD&: D2CXX, CreateFun: CXXRecordDecl::CreateLambda, FromD: D, args&: Importer.getToContext(),
3528 args&: DC, args&: *TInfoOrErr, args&: Loc, args: DCXX->getLambdaDependencyKind(),
3529 args: DCXX->isGenericLambda(), args: DCXX->getLambdaCaptureDefault()))
3530 return D2CXX;
3531 Decl *ContextDecl = DCXX->getLambdaContextDecl();
3532 ExpectedDecl CDeclOrErr = import(From: ContextDecl);
3533 if (!CDeclOrErr)
3534 return CDeclOrErr.takeError();
3535 if (ContextDecl != nullptr) {
3536 D2CXX->setLambdaContextDecl(*CDeclOrErr);
3537 }
3538 D2CXX->setLambdaNumbering(DCXX->getLambdaNumbering());
3539 } else {
3540 if (GetImportedOrCreateDecl(ToD&: D2CXX, FromD: D, args&: Importer.getToContext(),
3541 args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr, args&: Loc,
3542 args: Name.getAsIdentifierInfo(),
3543 args: cast_or_null<CXXRecordDecl>(Val: PrevDecl)))
3544 return D2CXX;
3545 }
3546
3547 D2 = D2CXX;
3548 D2->setAccess(D->getAccess());
3549 D2->setLexicalDeclContext(LexicalDC);
3550 addDeclToContexts(FromD: D, ToD: D2);
3551
3552 if (ClassTemplateDecl *FromDescribed =
3553 DCXX->getDescribedClassTemplate()) {
3554 ClassTemplateDecl *ToDescribed;
3555 if (Error Err = importInto(To&: ToDescribed, From: FromDescribed))
3556 return std::move(Err);
3557 D2CXX->setDescribedClassTemplate(ToDescribed);
3558 } else if (MemberSpecializationInfo *MemberInfo =
3559 DCXX->getMemberSpecializationInfo()) {
3560 TemplateSpecializationKind SK =
3561 MemberInfo->getTemplateSpecializationKind();
3562 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
3563
3564 if (Expected<CXXRecordDecl *> ToInstOrErr = import(From: FromInst))
3565 D2CXX->setInstantiationOfMemberClass(RD: *ToInstOrErr, TSK: SK);
3566 else
3567 return ToInstOrErr.takeError();
3568
3569 if (ExpectedSLoc POIOrErr =
3570 import(From: MemberInfo->getPointOfInstantiation()))
3571 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
3572 *POIOrErr);
3573 else
3574 return POIOrErr.takeError();
3575 }
3576
3577 } else {
3578 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(),
3579 args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr, args&: Loc,
3580 args: Name.getAsIdentifierInfo(), args&: PrevDecl))
3581 return D2;
3582 D2->setLexicalDeclContext(LexicalDC);
3583 addDeclToContexts(FromD: D, ToD: D2);
3584 }
3585
3586 if (auto BraceRangeOrErr = import(From: D->getBraceRange()))
3587 D2->setBraceRange(*BraceRangeOrErr);
3588 else
3589 return BraceRangeOrErr.takeError();
3590 if (auto QualifierLocOrErr = import(From: D->getQualifierLoc()))
3591 D2->setQualifierInfo(*QualifierLocOrErr);
3592 else
3593 return QualifierLocOrErr.takeError();
3594
3595 if (D->isAnonymousStructOrUnion())
3596 D2->setAnonymousStructOrUnion(true);
3597
3598 if (D->isCompleteDefinition())
3599 if (Error Err = ImportDefinition(From: D, To: D2, Kind: IDK_Default))
3600 return std::move(Err);
3601
3602 return D2;
3603}
3604
3605ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3606 // Import the major distinguishing characteristics of this enumerator.
3607 DeclContext *DC, *LexicalDC;
3608 DeclarationName Name;
3609 SourceLocation Loc;
3610 NamedDecl *ToD;
3611 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3612 return std::move(Err);
3613 if (ToD)
3614 return ToD;
3615
3616 // Determine whether there are any other declarations with the same name and
3617 // in the same context.
3618 if (!LexicalDC->isFunctionOrMethod()) {
3619 SmallVector<NamedDecl *, 4> ConflictingDecls;
3620 unsigned IDNS = Decl::IDNS_Ordinary;
3621 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3622 for (auto *FoundDecl : FoundDecls) {
3623 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3624 continue;
3625
3626 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(Val: FoundDecl)) {
3627 if (IsStructuralMatch(From: D, To: FoundEnumConstant))
3628 return Importer.MapImported(From: D, To: FoundEnumConstant);
3629 ConflictingDecls.push_back(Elt: FoundDecl);
3630 }
3631 }
3632
3633 if (!ConflictingDecls.empty()) {
3634 ExpectedName NameOrErr = Importer.HandleNameConflict(
3635 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3636 if (NameOrErr)
3637 Name = NameOrErr.get();
3638 else
3639 return NameOrErr.takeError();
3640 }
3641 }
3642
3643 ExpectedType TypeOrErr = import(From: D->getType());
3644 if (!TypeOrErr)
3645 return TypeOrErr.takeError();
3646
3647 ExpectedExpr InitOrErr = import(From: D->getInitExpr());
3648 if (!InitOrErr)
3649 return InitOrErr.takeError();
3650
3651 EnumConstantDecl *ToEnumerator;
3652 if (GetImportedOrCreateDecl(
3653 ToD&: ToEnumerator, FromD: D, args&: Importer.getToContext(), args: cast<EnumDecl>(Val: DC), args&: Loc,
3654 args: Name.getAsIdentifierInfo(), args&: *TypeOrErr, args&: *InitOrErr, args: D->getInitVal()))
3655 return ToEnumerator;
3656
3657 ToEnumerator->setAccess(D->getAccess());
3658 ToEnumerator->setLexicalDeclContext(LexicalDC);
3659 LexicalDC->addDeclInternal(D: ToEnumerator);
3660 return ToEnumerator;
3661}
3662
3663template <typename DeclTy>
3664Error ASTNodeImporter::ImportTemplateParameterLists(const DeclTy *FromD,
3665 DeclTy *ToD) {
3666 ArrayRef<TemplateParameterList *> FromTPLs =
3667 FromD->getTemplateParameterLists();
3668 if (FromTPLs.empty())
3669 return Error::success();
3670 SmallVector<TemplateParameterList *, 2> ToTPLists(FromTPLs.size());
3671 for (unsigned int I = 0; I < FromTPLs.size(); ++I)
3672 if (Expected<TemplateParameterList *> ToTPListOrErr = import(From: FromTPLs[I]))
3673 ToTPLists[I] = *ToTPListOrErr;
3674 else
3675 return ToTPListOrErr.takeError();
3676 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3677 return Error::success();
3678}
3679
3680Error ASTNodeImporter::ImportTemplateInformation(
3681 FunctionDecl *FromFD, FunctionDecl *ToFD) {
3682 switch (FromFD->getTemplatedKind()) {
3683 case FunctionDecl::TK_NonTemplate:
3684 case FunctionDecl::TK_FunctionTemplate:
3685 return Error::success();
3686
3687 case FunctionDecl::TK_DependentNonTemplate:
3688 if (Expected<FunctionDecl *> InstFDOrErr =
3689 import(From: FromFD->getInstantiatedFromDecl()))
3690 ToFD->setInstantiatedFromDecl(*InstFDOrErr);
3691 return Error::success();
3692 case FunctionDecl::TK_MemberSpecialization: {
3693 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3694
3695 if (Expected<FunctionDecl *> InstFDOrErr =
3696 import(From: FromFD->getInstantiatedFromMemberFunction()))
3697 ToFD->setInstantiationOfMemberFunction(FD: *InstFDOrErr, TSK);
3698 else
3699 return InstFDOrErr.takeError();
3700
3701 if (ExpectedSLoc POIOrErr = import(
3702 From: FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3703 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3704 else
3705 return POIOrErr.takeError();
3706
3707 return Error::success();
3708 }
3709
3710 case FunctionDecl::TK_FunctionTemplateSpecialization: {
3711 auto FunctionAndArgsOrErr =
3712 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3713 if (!FunctionAndArgsOrErr)
3714 return FunctionAndArgsOrErr.takeError();
3715
3716 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
3717 Context&: Importer.getToContext(), Args: std::get<1>(t&: *FunctionAndArgsOrErr));
3718
3719 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3720 TemplateArgumentListInfo ToTAInfo;
3721 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3722 if (FromTAArgsAsWritten)
3723 if (Error Err = ImportTemplateArgumentListInfo(
3724 From: *FromTAArgsAsWritten, Result&: ToTAInfo))
3725 return Err;
3726
3727 ExpectedSLoc POIOrErr = import(From: FTSInfo->getPointOfInstantiation());
3728 if (!POIOrErr)
3729 return POIOrErr.takeError();
3730
3731 if (Error Err = ImportTemplateParameterLists(FromD: FromFD, ToD: ToFD))
3732 return Err;
3733
3734 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3735 ToFD->setFunctionTemplateSpecialization(
3736 Template: std::get<0>(t&: *FunctionAndArgsOrErr), TemplateArgs: ToTAList, /*InsertToken=*/{}, TSK,
3737 TemplateArgsAsWritten: FromTAArgsAsWritten ? &ToTAInfo : nullptr, PointOfInstantiation: *POIOrErr);
3738 return Error::success();
3739 }
3740
3741 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
3742 auto *FromInfo = FromFD->getDependentSpecializationInfo();
3743 UnresolvedSet<8> Candidates;
3744 for (FunctionTemplateDecl *FTD : FromInfo->getCandidates()) {
3745 if (Expected<FunctionTemplateDecl *> ToFTDOrErr = import(From: FTD))
3746 Candidates.addDecl(D: *ToFTDOrErr);
3747 else
3748 return ToFTDOrErr.takeError();
3749 }
3750
3751 // Import TemplateArgumentListInfo.
3752 TemplateArgumentListInfo ToTAInfo;
3753 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3754 if (FromTAArgsAsWritten)
3755 if (Error Err =
3756 ImportTemplateArgumentListInfo(From: *FromTAArgsAsWritten, Result&: ToTAInfo))
3757 return Err;
3758
3759 ToFD->setDependentTemplateSpecialization(
3760 Context&: Importer.getToContext(), Templates: Candidates,
3761 TemplateArgs: FromTAArgsAsWritten ? &ToTAInfo : nullptr);
3762 return Error::success();
3763 }
3764 }
3765 llvm_unreachable("All cases should be covered!");
3766}
3767
3768Expected<FunctionDecl *>
3769ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
3770 auto FunctionAndArgsOrErr =
3771 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3772 if (!FunctionAndArgsOrErr)
3773 return FunctionAndArgsOrErr.takeError();
3774
3775 FunctionTemplateDecl *Template;
3776 TemplateArgsTy ToTemplArgs;
3777 std::tie(args&: Template, args&: ToTemplArgs) = *FunctionAndArgsOrErr;
3778 llvm::FoldingSetInsertToken InsertToken;
3779 auto *FoundSpec = Template->findSpecialization(Args: ToTemplArgs, InsertToken);
3780 return FoundSpec;
3781}
3782
3783Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
3784 FunctionDecl *ToFD) {
3785 if (Stmt *FromBody = FromFD->getBody()) {
3786 if (ExpectedStmt ToBodyOrErr = import(From: FromBody))
3787 ToFD->setBody(*ToBodyOrErr);
3788 else
3789 return ToBodyOrErr.takeError();
3790 }
3791 return Error::success();
3792}
3793
3794ExplicitSpecifier
3795ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
3796 Expr *ExplicitExpr = ESpec.getExpr();
3797 if (ExplicitExpr)
3798 ExplicitExpr = importChecked(Err, From: ESpec.getExpr());
3799 return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3800}
3801
3802ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3803
3804 SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
3805 auto RedeclIt = Redecls.begin();
3806 // Import the first part of the decl chain. I.e. import all previous
3807 // declarations starting from the canonical decl.
3808 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3809 ExpectedDecl ToRedeclOrErr = import(From: *RedeclIt);
3810 if (!ToRedeclOrErr)
3811 return ToRedeclOrErr.takeError();
3812 }
3813 assert(*RedeclIt == D);
3814
3815 // Import the major distinguishing characteristics of this function.
3816 DeclContext *DC, *LexicalDC;
3817 DeclarationName Name;
3818 SourceLocation Loc;
3819 NamedDecl *ToD;
3820 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3821 return std::move(Err);
3822 if (ToD)
3823 return ToD;
3824
3825 FunctionDecl *FoundByLookup = nullptr;
3826 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3827
3828 // If this is a function template specialization, then try to find the same
3829 // existing specialization in the "to" context. The lookup below will not
3830 // find any specialization, but would find the primary template; thus, we
3831 // have to skip normal lookup in case of specializations.
3832 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
3833 if (D->getTemplatedKind() ==
3834 FunctionDecl::TK_FunctionTemplateSpecialization) {
3835 auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(FromFD: D);
3836 if (!FoundFunctionOrErr)
3837 return FoundFunctionOrErr.takeError();
3838 if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3839 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3840 return Def;
3841 FoundByLookup = FoundFunction;
3842 }
3843 }
3844 // Try to find a function in our own ("to") context with the same name, same
3845 // type, and in the same context as the function we're importing.
3846 else if (!LexicalDC->isFunctionOrMethod()) {
3847 SmallVector<NamedDecl *, 4> ConflictingDecls;
3848 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
3849 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3850 for (auto *FoundDecl : FoundDecls) {
3851 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3852 continue;
3853
3854 if (auto *FoundFunction = dyn_cast<FunctionDecl>(Val: FoundDecl)) {
3855 if (!hasSameVisibilityContextAndLinkage(Found: FoundFunction, From: D))
3856 continue;
3857
3858 if (IsStructuralMatch(From: D, To: FoundFunction)) {
3859 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3860 return Def;
3861 FoundByLookup = FoundFunction;
3862 break;
3863 }
3864 // FIXME: Check for overloading more carefully, e.g., by boosting
3865 // Sema::IsOverload out to the AST library.
3866
3867 // Function overloading is okay in C++.
3868 if (Importer.getToContext().getLangOpts().CPlusPlus)
3869 continue;
3870
3871 // Complain about inconsistent function types.
3872 Importer.ToDiag(Loc, DiagID: diag::warn_odr_function_type_inconsistent)
3873 << Name << D->getType() << FoundFunction->getType();
3874 Importer.ToDiag(Loc: FoundFunction->getLocation(), DiagID: diag::note_odr_value_here)
3875 << FoundFunction->getType();
3876 ConflictingDecls.push_back(Elt: FoundDecl);
3877 }
3878 }
3879
3880 if (!ConflictingDecls.empty()) {
3881 ExpectedName NameOrErr = Importer.HandleNameConflict(
3882 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3883 if (NameOrErr)
3884 Name = NameOrErr.get();
3885 else
3886 return NameOrErr.takeError();
3887 }
3888 }
3889
3890 // We do not allow more than one in-class declaration of a function. This is
3891 // because AST clients like VTableBuilder asserts on this. VTableBuilder
3892 // assumes there is only one in-class declaration. Building a redecl
3893 // chain would result in more than one in-class declaration for
3894 // overrides (even if they are part of the same redecl chain inside the
3895 // derived class.)
3896 if (FoundByLookup) {
3897 if (isa<CXXMethodDecl>(Val: FoundByLookup)) {
3898 if (D->getLexicalDeclContext() == D->getDeclContext()) {
3899 if (!D->doesThisDeclarationHaveABody()) {
3900 if (FunctionTemplateDecl *DescribedD =
3901 D->getDescribedFunctionTemplate()) {
3902 // Handle a "templated" function together with its described
3903 // template. This avoids need for a similar check at import of the
3904 // described template.
3905 assert(FoundByLookup->getDescribedFunctionTemplate() &&
3906 "Templated function mapped to non-templated?");
3907 Importer.MapImported(From: DescribedD,
3908 To: FoundByLookup->getDescribedFunctionTemplate());
3909 }
3910 return Importer.MapImported(From: D, To: FoundByLookup);
3911 } else {
3912 // Let's continue and build up the redecl chain in this case.
3913 // FIXME Merge the functions into one decl.
3914 }
3915 }
3916 }
3917 }
3918
3919 DeclarationNameInfo NameInfo(Name, Loc);
3920 // Import additional name location/type info.
3921 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
3922 return std::move(Err);
3923
3924 QualType FromTy = D->getType();
3925 TypeSourceInfo *FromTSI = D->getTypeSourceInfo();
3926 // Set to true if we do not import the type of the function as is. There are
3927 // cases when the original type would result in an infinite recursion during
3928 // the import. To avoid an infinite recursion when importing, we create the
3929 // FunctionDecl with a simplified function type and update it only after the
3930 // relevant AST nodes are already imported.
3931 // The type is related to TypeSourceInfo (it references the type), so we must
3932 // do the same with TypeSourceInfo.
3933 bool UsedDifferentProtoType = false;
3934 if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3935 QualType FromReturnTy = FromFPT->getReturnType();
3936 // Functions with auto return type may define a struct inside their body
3937 // and the return type could refer to that struct.
3938 // E.g.: auto foo() { struct X{}; return X(); }
3939 // There are many more cases when types inside the function declaration
3940 // can appear in the return type, like types declared as typenames from
3941 // template params.
3942 // All such cases are tracked in FindFunctionDeclImportCycle.
3943 if (Importer.FindFunctionDeclImportCycle.isCycle(D)) {
3944 FromReturnTy = Importer.getFromContext().VoidTy;
3945 UsedDifferentProtoType = true;
3946 }
3947 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3948 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3949 // FunctionDecl that we are importing the FunctionProtoType for.
3950 // To avoid an infinite recursion when importing, create the FunctionDecl
3951 // with a simplified function type.
3952 if (FromEPI.ExceptionSpec.SourceDecl ||
3953 FromEPI.ExceptionSpec.SourceTemplate ||
3954 FromEPI.ExceptionSpec.NoexceptExpr) {
3955 FunctionProtoType::ExtProtoInfo DefaultEPI;
3956 FromEPI = DefaultEPI;
3957 UsedDifferentProtoType = true;
3958 }
3959 FromTy = Importer.getFromContext().getFunctionType(
3960 ResultTy: FromReturnTy, Args: FromFPT->getParamTypes(), EPI: FromEPI);
3961 FromTSI = Importer.getFromContext().getTrivialTypeSourceInfo(
3962 T: FromTy, Loc: D->getBeginLoc());
3963 }
3964
3965 Error Err = Error::success();
3966 auto ScopedReturnTypeDeclCycleDetector =
3967 Importer.FindFunctionDeclImportCycle.makeScopedCycleDetection(D);
3968 auto T = importChecked(Err, From: FromTy);
3969 auto TInfo = importChecked(Err, From: FromTSI);
3970 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
3971 auto ToEndLoc = importChecked(Err, From: D->getEndLoc());
3972 auto ToDefaultLoc = importChecked(Err, From: D->getDefaultLoc());
3973 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3974 AssociatedConstraint TrailingRequiresClause = D->getTrailingRequiresClause();
3975 TrailingRequiresClause.ConstraintExpr =
3976 importChecked(Err, From: TrailingRequiresClause.ConstraintExpr);
3977 if (Err)
3978 return std::move(Err);
3979
3980 // Import the function parameters.
3981 SmallVector<ParmVarDecl *, 8> Parameters;
3982 for (auto *P : D->parameters()) {
3983 if (Expected<ParmVarDecl *> ToPOrErr = import(From: P))
3984 Parameters.push_back(Elt: *ToPOrErr);
3985 else
3986 return ToPOrErr.takeError();
3987 }
3988
3989 // Create the imported function.
3990 FunctionDecl *ToFunction = nullptr;
3991 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(Val: D)) {
3992 ExplicitSpecifier ESpec =
3993 importExplicitSpecifier(Err, ESpec: FromConstructor->getExplicitSpecifier());
3994 if (Err)
3995 return std::move(Err);
3996 auto ToInheritedConstructor = InheritedConstructor();
3997 if (FromConstructor->isInheritingConstructor()) {
3998 Expected<InheritedConstructor> ImportedInheritedCtor =
3999 import(From: FromConstructor->getInheritedConstructor());
4000 if (!ImportedInheritedCtor)
4001 return ImportedInheritedCtor.takeError();
4002 ToInheritedConstructor = *ImportedInheritedCtor;
4003 }
4004 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
4005 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4006 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args&: ESpec, args: D->UsesFPIntrin(),
4007 args: D->isInlineSpecified(), args: D->isImplicit(), args: D->getConstexprKind(),
4008 args&: ToInheritedConstructor, args&: TrailingRequiresClause))
4009 return ToFunction;
4010 } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(Val: D)) {
4011
4012 Error Err = Error::success();
4013 auto ToOperatorDelete = importChecked(
4014 Err, From: const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
4015 auto ToThisArg = importChecked(Err, From: FromDtor->getOperatorDeleteThisArg());
4016 if (Err)
4017 return std::move(Err);
4018
4019 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
4020 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4021 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: D->UsesFPIntrin(),
4022 args: D->isInlineSpecified(), args: D->isImplicit(), args: D->getConstexprKind(),
4023 args&: TrailingRequiresClause))
4024 return ToFunction;
4025
4026 CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(Val: ToFunction);
4027
4028 ToDtor->setOperatorDelete(OD: ToOperatorDelete, ThisArg: ToThisArg);
4029 } else if (CXXConversionDecl *FromConversion =
4030 dyn_cast<CXXConversionDecl>(Val: D)) {
4031 ExplicitSpecifier ESpec =
4032 importExplicitSpecifier(Err, ESpec: FromConversion->getExplicitSpecifier());
4033 if (Err)
4034 return std::move(Err);
4035 if (GetImportedOrCreateDecl<CXXConversionDecl>(
4036 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4037 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: D->UsesFPIntrin(),
4038 args: D->isInlineSpecified(), args&: ESpec, args: D->getConstexprKind(),
4039 args: SourceLocation(), args&: TrailingRequiresClause))
4040 return ToFunction;
4041 } else if (auto *Method = dyn_cast<CXXMethodDecl>(Val: D)) {
4042 if (GetImportedOrCreateDecl<CXXMethodDecl>(
4043 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4044 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: Method->getStorageClass(),
4045 args: Method->UsesFPIntrin(), args: Method->isInlineSpecified(),
4046 args: D->getConstexprKind(), args: SourceLocation(), args&: TrailingRequiresClause))
4047 return ToFunction;
4048 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(Val: D)) {
4049 ExplicitSpecifier ESpec =
4050 importExplicitSpecifier(Err, ESpec: Guide->getExplicitSpecifier());
4051 CXXConstructorDecl *Ctor =
4052 importChecked(Err, From: Guide->getCorrespondingConstructor());
4053 const CXXDeductionGuideDecl *SourceDG =
4054 importChecked(Err, From: Guide->getSourceDeductionGuide());
4055 if (Err)
4056 return std::move(Err);
4057 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
4058 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart, args&: ESpec,
4059 args&: NameInfo, args&: T, args&: TInfo, args&: ToEndLoc, args&: Ctor,
4060 args: Guide->getDeductionCandidateKind(), args&: TrailingRequiresClause,
4061 args&: SourceDG, args: Guide->getSourceDeductionGuideKind()))
4062 return ToFunction;
4063 } else {
4064 if (GetImportedOrCreateDecl(
4065 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart,
4066 args&: NameInfo, args&: T, args&: TInfo, args: D->getStorageClass(), args: D->UsesFPIntrin(),
4067 args: D->isInlineSpecified(), args: D->hasWrittenPrototype(),
4068 args: D->getConstexprKind(), args&: TrailingRequiresClause))
4069 return ToFunction;
4070 }
4071
4072 // Connect the redecl chain.
4073 if (FoundByLookup) {
4074 auto *Recent = const_cast<FunctionDecl *>(
4075 FoundByLookup->getMostRecentDecl());
4076 ToFunction->setPreviousDecl(Recent);
4077 // FIXME Probably we should merge exception specifications. E.g. In the
4078 // "To" context the existing function may have exception specification with
4079 // noexcept-unevaluated, while the newly imported function may have an
4080 // evaluated noexcept. A call to adjustExceptionSpec() on the imported
4081 // decl and its redeclarations may be required.
4082 }
4083
4084 // We will import DefaultedOrDeletedInfo later.
4085
4086 ToFunction->setQualifierInfo(ToQualifierLoc);
4087 ToFunction->setAccess(D->getAccess());
4088 ToFunction->setLexicalDeclContext(LexicalDC);
4089 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
4090 ToFunction->setTrivial(D->isTrivial());
4091 ToFunction->setIsPureVirtual(D->isPureVirtual());
4092 ToFunction->setDefaulted(D->isDefaulted());
4093 ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
4094 ToFunction->setDeletedAsWritten(D: D->isDeletedAsWritten());
4095 ToFunction->setFriendConstraintRefersToEnclosingTemplate(
4096 D->FriendConstraintRefersToEnclosingTemplate());
4097 ToFunction->setIsDestroyingOperatorDelete(D->isDestroyingOperatorDelete());
4098 ToFunction->setIsTypeAwareOperatorNewOrDelete(
4099 D->isTypeAwareOperatorNewOrDelete());
4100 ToFunction->setRangeEnd(ToEndLoc);
4101 ToFunction->setDefaultLoc(ToDefaultLoc);
4102
4103 if (auto *Info = D->getDefaultedOrDeletedInfo()) {
4104 StringLiteral *Msg = nullptr;
4105 if (StringLiteral *M = Info->getDeletedMessage()) {
4106 auto Imported = import(From: M);
4107 if (!Imported)
4108 return Imported.takeError();
4109 Msg = *Imported;
4110 }
4111
4112 SmallVector<DeclAccessPair, 4> Lookups;
4113 for (DeclAccessPair P : Info->getUnqualifiedLookups()) {
4114 auto Imported = import(From: P.getDecl());
4115 if (!Imported)
4116 return Imported.takeError();
4117 Lookups.push_back(
4118 Elt: DeclAccessPair::make(D: cast<NamedDecl>(Val: *Imported), AS: P.getAccess()));
4119 }
4120
4121 ToFunction->setDefaultedOrDeletedInfo(
4122 FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
4123 Context&: Importer.getToContext(), Lookups, FPFeatures: Info->getFPFeatures(), DeletedMessage: Msg));
4124 }
4125
4126 // Set the parameters.
4127 for (auto *Param : Parameters) {
4128 Param->setOwningFunction(ToFunction);
4129 ToFunction->addDeclInternal(D: Param);
4130 if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
4131 LT->update(ND: Param, OldDC: Importer.getToContext().getTranslationUnitDecl());
4132 }
4133 ToFunction->setParams(Parameters);
4134
4135 // We need to complete creation of FunctionProtoTypeLoc manually with setting
4136 // params it refers to.
4137 if (TInfo) {
4138 if (auto ProtoLoc =
4139 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
4140 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
4141 ProtoLoc.setParam(i: I, VD: Parameters[I]);
4142 }
4143 }
4144
4145 // Import the describing template function, if any.
4146 if (FromFT) {
4147 auto ToFTOrErr = import(From: FromFT);
4148 if (!ToFTOrErr)
4149 return ToFTOrErr.takeError();
4150 }
4151
4152 // Import Ctor initializers.
4153 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(Val: D)) {
4154 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
4155 SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
4156 // Import first, then allocate memory and copy if there was no error.
4157 if (Error Err = ImportContainerChecked(
4158 InContainer: FromConstructor->inits(), OutContainer&: CtorInitializers))
4159 return std::move(Err);
4160 auto **Memory =
4161 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
4162 llvm::copy(Range&: CtorInitializers, Out: Memory);
4163 auto *ToCtor = cast<CXXConstructorDecl>(Val: ToFunction);
4164 ToCtor->setCtorInitializers(Memory);
4165 ToCtor->setNumCtorInitializers(NumInitializers);
4166 }
4167 }
4168
4169 // If it is a template, import all related things.
4170 if (Error Err = ImportTemplateInformation(FromFD: D, ToFD: ToFunction))
4171 return std::move(Err);
4172
4173 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(Val: D))
4174 if (Error Err = ImportOverriddenMethods(ToMethod: cast<CXXMethodDecl>(Val: ToFunction),
4175 FromMethod: FromCXXMethod))
4176 return std::move(Err);
4177
4178 if (D->doesThisDeclarationHaveABody()) {
4179 Error Err = ImportFunctionDeclBody(FromFD: D, ToFD: ToFunction);
4180
4181 if (Err)
4182 return std::move(Err);
4183 }
4184
4185 // Import and set the original type in case we used another type.
4186 if (UsedDifferentProtoType) {
4187 if (ExpectedType TyOrErr = import(From: D->getType()))
4188 ToFunction->setType(*TyOrErr);
4189 else
4190 return TyOrErr.takeError();
4191 if (Expected<TypeSourceInfo *> TSIOrErr = import(From: D->getTypeSourceInfo()))
4192 ToFunction->setTypeSourceInfo(*TSIOrErr);
4193 else
4194 return TSIOrErr.takeError();
4195 }
4196
4197 // FIXME: Other bits to merge?
4198
4199 addDeclToContexts(FromD: D, ToD: ToFunction);
4200
4201 // Import the rest of the chain. I.e. import all subsequent declarations.
4202 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4203 ExpectedDecl ToRedeclOrErr = import(From: *RedeclIt);
4204 if (!ToRedeclOrErr)
4205 return ToRedeclOrErr.takeError();
4206 }
4207
4208 return ToFunction;
4209}
4210
4211ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
4212 return VisitFunctionDecl(D);
4213}
4214
4215ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
4216 return VisitCXXMethodDecl(D);
4217}
4218
4219ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
4220 return VisitCXXMethodDecl(D);
4221}
4222
4223ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
4224 return VisitCXXMethodDecl(D);
4225}
4226
4227ExpectedDecl
4228ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
4229 return VisitFunctionDecl(D);
4230}
4231
4232ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
4233 // Import the major distinguishing characteristics of a variable.
4234 DeclContext *DC, *LexicalDC;
4235 DeclarationName Name;
4236 SourceLocation Loc;
4237 NamedDecl *ToD;
4238 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4239 return std::move(Err);
4240 if (ToD)
4241 return ToD;
4242
4243 // Determine whether we've already imported this field.
4244 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4245 for (auto *FoundDecl : FoundDecls) {
4246 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(Val: FoundDecl)) {
4247 // For anonymous fields, match up by index.
4248 if (!Name &&
4249 ASTImporter::getFieldIndex(F: D) !=
4250 ASTImporter::getFieldIndex(F: FoundField))
4251 continue;
4252
4253 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4254 To: FoundField->getType())) {
4255 Importer.MapImported(From: D, To: FoundField);
4256 // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
4257 // initializer of a FieldDecl might not had been instantiated in the
4258 // "To" context. However, the "From" context might instantiated that,
4259 // thus we have to merge that.
4260 // Note: `hasInClassInitializer()` is not the same as non-null
4261 // `getInClassInitializer()` value.
4262 if (Expr *FromInitializer = D->getInClassInitializer()) {
4263 if (ExpectedExpr ToInitializerOrErr = import(From: FromInitializer)) {
4264 // Import of the FromInitializer may result in the setting of
4265 // InClassInitializer. If not, set it here.
4266 assert(FoundField->hasInClassInitializer() &&
4267 "Field should have an in-class initializer if it has an "
4268 "expression for it.");
4269 if (!FoundField->getInClassInitializer())
4270 FoundField->setInClassInitializer(*ToInitializerOrErr);
4271 } else {
4272 return ToInitializerOrErr.takeError();
4273 }
4274 }
4275 return FoundField;
4276 }
4277
4278 // FIXME: Why is this case not handled with calling HandleNameConflict?
4279 Importer.ToDiag(Loc, DiagID: diag::warn_odr_field_type_inconsistent)
4280 << Name << D->getType() << FoundField->getType();
4281 Importer.ToDiag(Loc: FoundField->getLocation(), DiagID: diag::note_odr_value_here)
4282 << FoundField->getType();
4283
4284 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4285 }
4286 }
4287
4288 Error Err = Error::success();
4289 auto ToType = importChecked(Err, From: D->getType());
4290 auto ToTInfo = importChecked(Err, From: D->getTypeSourceInfo());
4291 auto ToBitWidth = importChecked(Err, From: D->getBitWidth());
4292 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4293 if (Err)
4294 return std::move(Err);
4295 const Type *ToCapturedVLAType = nullptr;
4296 if (Error Err = Importer.importInto(
4297 To&: ToCapturedVLAType, From: cast_or_null<Type>(Val: D->getCapturedVLAType())))
4298 return std::move(Err);
4299
4300 FieldDecl *ToField;
4301 if (GetImportedOrCreateDecl(ToD&: ToField, FromD: D, args&: Importer.getToContext(), args&: DC,
4302 args&: ToInnerLocStart, args&: Loc, args: Name.getAsIdentifierInfo(),
4303 args&: ToType, args&: ToTInfo, args&: ToBitWidth, args: D->isMutable(),
4304 args: D->getInClassInitStyle()))
4305 return ToField;
4306
4307 ToField->setAccess(D->getAccess());
4308 ToField->setLexicalDeclContext(LexicalDC);
4309 ToField->setImplicit(D->isImplicit());
4310 if (ToCapturedVLAType)
4311 ToField->setCapturedVLAType(cast<VariableArrayType>(Val: ToCapturedVLAType));
4312 LexicalDC->addDeclInternal(D: ToField);
4313 // Import initializer only after the field was created, it may have recursive
4314 // reference to the field.
4315 auto ToInitializer = importChecked(Err, From: D->getInClassInitializer());
4316 if (Err)
4317 return std::move(Err);
4318 if (ToInitializer) {
4319 auto *AlreadyImported = ToField->getInClassInitializer();
4320 if (AlreadyImported)
4321 assert(ToInitializer == AlreadyImported &&
4322 "Duplicate import of in-class initializer.");
4323 else
4324 ToField->setInClassInitializer(ToInitializer);
4325 }
4326
4327 return ToField;
4328}
4329
4330ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
4331 // Import the major distinguishing characteristics of a variable.
4332 DeclContext *DC, *LexicalDC;
4333 DeclarationName Name;
4334 SourceLocation Loc;
4335 NamedDecl *ToD;
4336 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4337 return std::move(Err);
4338 if (ToD)
4339 return ToD;
4340
4341 // Determine whether we've already imported this field.
4342 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4343 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4344 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(Val: FoundDecls[I])) {
4345 // For anonymous indirect fields, match up by index.
4346 if (!Name &&
4347 ASTImporter::getFieldIndex(F: D) !=
4348 ASTImporter::getFieldIndex(F: FoundField))
4349 continue;
4350
4351 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4352 To: FoundField->getType(),
4353 Complain: !Name.isEmpty())) {
4354 Importer.MapImported(From: D, To: FoundField);
4355 return FoundField;
4356 }
4357
4358 // If there are more anonymous fields to check, continue.
4359 if (!Name && I < N-1)
4360 continue;
4361
4362 // FIXME: Why is this case not handled with calling HandleNameConflict?
4363 Importer.ToDiag(Loc, DiagID: diag::warn_odr_field_type_inconsistent)
4364 << Name << D->getType() << FoundField->getType();
4365 Importer.ToDiag(Loc: FoundField->getLocation(), DiagID: diag::note_odr_value_here)
4366 << FoundField->getType();
4367
4368 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4369 }
4370 }
4371
4372 // Import the type.
4373 auto TypeOrErr = import(From: D->getType());
4374 if (!TypeOrErr)
4375 return TypeOrErr.takeError();
4376
4377 auto **NamedChain =
4378 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
4379
4380 unsigned i = 0;
4381 for (auto *PI : D->chain())
4382 if (Expected<NamedDecl *> ToD = import(From: PI))
4383 NamedChain[i++] = *ToD;
4384 else
4385 return ToD.takeError();
4386
4387 MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
4388 IndirectFieldDecl *ToIndirectField;
4389 if (GetImportedOrCreateDecl(ToD&: ToIndirectField, FromD: D, args&: Importer.getToContext(), args&: DC,
4390 args&: Loc, args: Name.getAsIdentifierInfo(), args&: *TypeOrErr, args&: CH))
4391 // FIXME here we leak `NamedChain` which is allocated before
4392 return ToIndirectField;
4393
4394 ToIndirectField->setAccess(D->getAccess());
4395 ToIndirectField->setLexicalDeclContext(LexicalDC);
4396 LexicalDC->addDeclInternal(D: ToIndirectField);
4397 return ToIndirectField;
4398}
4399
4400/// Used as return type of getFriendCountAndPosition.
4401struct FriendCountAndPosition {
4402 /// Number of similar looking friends.
4403 unsigned int TotalCount;
4404 /// Index of the specific FriendDecl.
4405 unsigned int IndexOfDecl;
4406};
4407
4408static bool IsEquivalentFriend(ASTImporter &Importer, FriendDecl *FD1,
4409 FriendDecl *FD2) {
4410 if (FD1->getKind() != FD2->getKind())
4411 return false;
4412
4413 ASTImporter::NonEquivalentDeclSet NonEquivalentDecls;
4414 StructuralEquivalenceContext Ctx(
4415 Importer.getToContext().getLangOpts(), FD1->getASTContext(),
4416 FD2->getASTContext(), NonEquivalentDecls,
4417 StructuralEquivalenceKind::Default,
4418 /*StrictTypeSpelling=*/false, /*Complain=*/false);
4419 return Ctx.IsEquivalent(D1: FD1, D2: FD2);
4420}
4421
4422static FriendCountAndPosition getFriendCountAndPosition(ASTImporter &Importer,
4423 FriendDecl *FD) {
4424 unsigned int FriendCount = 0;
4425 UnsignedOrNone FriendPosition = std::nullopt;
4426 const auto *RD = cast<CXXRecordDecl>(Val: FD->getLexicalDeclContext());
4427
4428 for (FriendDecl *FoundFriend : RD->friends()) {
4429 if (FoundFriend == FD) {
4430 FriendPosition = FriendCount;
4431 ++FriendCount;
4432 } else if (IsEquivalentFriend(Importer, FD1: FD, FD2: FoundFriend)) {
4433 ++FriendCount;
4434 }
4435 }
4436
4437 assert(FriendPosition && "Friend decl not found in own parent.");
4438 return {.TotalCount: FriendCount, .IndexOfDecl: *FriendPosition};
4439}
4440
4441Expected<FriendDecl::FriendUnion>
4442ASTNodeImporter::importFriendUnion(FriendDecl *D) {
4443 if (NamedDecl *FriendD = D->getFriendDecl()) {
4444 NamedDecl *ToFriendD;
4445 if (Error Err = importInto(To&: ToFriendD, From: FriendD))
4446 return std::move(Err);
4447
4448 if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
4449 !FriendD->isInIdentifierNamespace(NS: Decl::IDNS_NonMemberOperator))
4450 ToFriendD->setObjectOfFriendDecl(false);
4451
4452 return ToFriendD;
4453 }
4454
4455 // The friend is a type, not a decl.
4456 auto TSIOrErr = import(From: D->getFriendType());
4457 if (TSIOrErr)
4458 return *TSIOrErr;
4459 return TSIOrErr.takeError();
4460}
4461
4462ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
4463 // Import the major distinguishing characteristics of a declaration.
4464 DeclContext *DC, *LexicalDC;
4465 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
4466 return std::move(Err);
4467
4468 // Determine whether we've already imported this decl.
4469 // FriendDecl is not a NamedDecl so we cannot use lookup.
4470 // We try to maintain order and count of redundant friend declarations.
4471 const auto *RD = cast<CXXRecordDecl>(Val: DC);
4472 SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
4473 for (FriendDecl *ImportedFriend : RD->friends())
4474 if (IsEquivalentFriend(Importer, FD1: D, FD2: ImportedFriend))
4475 ImportedEquivalentFriends.push_back(Elt: ImportedFriend);
4476
4477 FriendCountAndPosition CountAndPosition =
4478 getFriendCountAndPosition(Importer, FD: D);
4479
4480 assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
4481 "Class with non-matching friends is imported, ODR check wrong?");
4482 if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
4483 return Importer.MapImported(
4484 From: D, To: ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
4485
4486 // Not found. Create it.
4487 // The declarations will be put into order later by ImportDeclContext.
4488 auto ToFUOrErr = importFriendUnion(D);
4489 if (!ToFUOrErr)
4490 return ToFUOrErr.takeError();
4491 FriendDecl::FriendUnion ToFU = *ToFUOrErr;
4492
4493 auto LocationOrErr = import(From: D->getLocation());
4494 if (!LocationOrErr)
4495 return LocationOrErr.takeError();
4496 auto FriendLocOrErr = import(From: D->getFriendLoc());
4497 if (!FriendLocOrErr)
4498 return FriendLocOrErr.takeError();
4499 auto EllipsisLocOrErr = import(From: D->getEllipsisLoc());
4500 if (!EllipsisLocOrErr)
4501 return EllipsisLocOrErr.takeError();
4502
4503 FriendDecl *FrD;
4504 if (GetImportedOrCreateDecl(ToD&: FrD, FromD: D, args&: Importer.getToContext(), args&: DC,
4505 args&: *LocationOrErr, args&: ToFU, args&: *FriendLocOrErr,
4506 args&: *EllipsisLocOrErr))
4507 return FrD;
4508
4509 FrD->setAccess(D->getAccess());
4510 FrD->setLexicalDeclContext(LexicalDC);
4511 LexicalDC->addDeclInternal(D: FrD);
4512 return FrD;
4513}
4514
4515ExpectedDecl ASTNodeImporter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
4516 DeclContext *DC, *LexicalDC;
4517 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
4518 return std::move(Err);
4519
4520 const auto *RD = cast<CXXRecordDecl>(Val: DC);
4521 SmallVector<FriendTemplateDecl *, 2> ImportedEquivalentFriends;
4522 for (FriendDecl *ImportedFriend : RD->friends()) {
4523 auto *ImportedFriendTemplate = dyn_cast<FriendTemplateDecl>(Val: ImportedFriend);
4524 if (ImportedFriendTemplate &&
4525 IsEquivalentFriend(Importer, FD1: D, FD2: ImportedFriendTemplate))
4526 ImportedEquivalentFriends.push_back(Elt: ImportedFriendTemplate);
4527 }
4528
4529 FriendCountAndPosition CountAndPosition =
4530 getFriendCountAndPosition(Importer, FD: D);
4531 assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
4532 "Class with non-matching friends is imported, ODR check wrong?");
4533
4534 if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
4535 return Importer.MapImported(
4536 From: D, To: ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
4537
4538 FriendTemplateDecl::FriendUnion ToFU;
4539 if (D->getFriendKind() !=
4540 FriendTemplateDecl::FriendTemplateEntityKind::Template) {
4541 auto ToFUOrErr = importFriendUnion(D);
4542 if (!ToFUOrErr)
4543 return ToFUOrErr.takeError();
4544 ToFU = *ToFUOrErr;
4545 }
4546
4547 TemplateName ToTemplate;
4548 const TemplateName FromTemplate = D->getFriendTemplateName();
4549 if (!FromTemplate.isNull()) {
4550 if (Error Err = importInto(To&: ToTemplate, From: FromTemplate))
4551 return std::move(Err);
4552 }
4553
4554 ArrayRef<TemplateParameterList *> FromTPLs = D->getTemplateParameterLists();
4555 SmallVector<TemplateParameterList *, 1> ToTPLs(FromTPLs.size());
4556 if (Error Err = ImportContainerChecked(InContainer: FromTPLs, OutContainer&: ToTPLs))
4557 return std::move(Err);
4558
4559 auto LocationOrErr = import(From: D->getLocation());
4560 if (!LocationOrErr)
4561 return LocationOrErr.takeError();
4562
4563 auto FriendLocOrErr = import(From: D->getFriendLoc());
4564 if (!FriendLocOrErr)
4565 return FriendLocOrErr.takeError();
4566
4567 auto EllipsisLocOrErr = import(From: D->getEllipsisLoc());
4568 if (!EllipsisLocOrErr)
4569 return EllipsisLocOrErr.takeError();
4570
4571 FriendTemplateDecl *FTD;
4572 if (GetImportedOrCreateDecl(ToD&: FTD, FromD: D, args&: Importer.getToContext(), args&: DC,
4573 args&: *LocationOrErr, args&: ToFU, args&: *FriendLocOrErr, args&: ToTPLs,
4574 args&: *EllipsisLocOrErr, args&: ToTemplate))
4575 return FTD;
4576
4577 FTD->setAccess(D->getAccess());
4578 FTD->setLexicalDeclContext(LexicalDC);
4579 LexicalDC->addDeclInternal(D: FTD);
4580 return FTD;
4581}
4582
4583ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
4584 // Import the major distinguishing characteristics of an ivar.
4585 DeclContext *DC, *LexicalDC;
4586 DeclarationName Name;
4587 SourceLocation Loc;
4588 NamedDecl *ToD;
4589 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4590 return std::move(Err);
4591 if (ToD)
4592 return ToD;
4593
4594 // Determine whether we've already imported this ivar
4595 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4596 for (auto *FoundDecl : FoundDecls) {
4597 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(Val: FoundDecl)) {
4598 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4599 To: FoundIvar->getType())) {
4600 Importer.MapImported(From: D, To: FoundIvar);
4601 return FoundIvar;
4602 }
4603
4604 Importer.ToDiag(Loc, DiagID: diag::warn_odr_ivar_type_inconsistent)
4605 << Name << D->getType() << FoundIvar->getType();
4606 Importer.ToDiag(Loc: FoundIvar->getLocation(), DiagID: diag::note_odr_value_here)
4607 << FoundIvar->getType();
4608
4609 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4610 }
4611 }
4612
4613 Error Err = Error::success();
4614 auto ToType = importChecked(Err, From: D->getType());
4615 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4616 auto ToBitWidth = importChecked(Err, From: D->getBitWidth());
4617 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4618 if (Err)
4619 return std::move(Err);
4620
4621 ObjCIvarDecl *ToIvar;
4622 if (GetImportedOrCreateDecl(
4623 ToD&: ToIvar, FromD: D, args&: Importer.getToContext(), args: cast<ObjCContainerDecl>(Val: DC),
4624 args&: ToInnerLocStart, args&: Loc, args: Name.getAsIdentifierInfo(),
4625 args&: ToType, args&: ToTypeSourceInfo,
4626 args: D->getAccessControl(),args&: ToBitWidth, args: D->getSynthesize()))
4627 return ToIvar;
4628
4629 ToIvar->setLexicalDeclContext(LexicalDC);
4630 LexicalDC->addDeclInternal(D: ToIvar);
4631 return ToIvar;
4632}
4633
4634ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
4635
4636 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
4637 auto RedeclIt = Redecls.begin();
4638 // Import the first part of the decl chain. I.e. import all previous
4639 // declarations starting from the canonical decl.
4640 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4641 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
4642 if (!RedeclOrErr)
4643 return RedeclOrErr.takeError();
4644 }
4645 assert(*RedeclIt == D);
4646
4647 // Import the major distinguishing characteristics of a variable.
4648 DeclContext *DC, *LexicalDC;
4649 DeclarationName Name;
4650 SourceLocation Loc;
4651 NamedDecl *ToD;
4652 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4653 return std::move(Err);
4654 if (ToD)
4655 return ToD;
4656
4657 // Try to find a variable in our own ("to") context with the same name and
4658 // in the same context as the variable we're importing.
4659 VarDecl *FoundByLookup = nullptr;
4660 if (D->isFileVarDecl()) {
4661 SmallVector<NamedDecl *, 4> ConflictingDecls;
4662 unsigned IDNS = Decl::IDNS_Ordinary;
4663 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4664 for (auto *FoundDecl : FoundDecls) {
4665 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
4666 continue;
4667
4668 if (auto *FoundVar = dyn_cast<VarDecl>(Val: FoundDecl)) {
4669 if (!hasSameVisibilityContextAndLinkage(Found: FoundVar, From: D))
4670 continue;
4671 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4672 To: FoundVar->getType())) {
4673
4674 // The VarDecl in the "From" context has a definition, but in the
4675 // "To" context we already have a definition.
4676 VarDecl *FoundDef = FoundVar->getDefinition();
4677 if (D->isThisDeclarationADefinition() && FoundDef)
4678 // FIXME Check for ODR error if the two definitions have
4679 // different initializers?
4680 return Importer.MapImported(From: D, To: FoundDef);
4681
4682 // The VarDecl in the "From" context has an initializer, but in the
4683 // "To" context we already have an initializer.
4684 const VarDecl *FoundDInit = nullptr;
4685 if (D->getInit() && FoundVar->getAnyInitializer(D&: FoundDInit))
4686 // FIXME Diagnose ODR error if the two initializers are different?
4687 return Importer.MapImported(From: D, To: const_cast<VarDecl*>(FoundDInit));
4688
4689 FoundByLookup = FoundVar;
4690 break;
4691 }
4692
4693 const ArrayType *FoundArray
4694 = Importer.getToContext().getAsArrayType(T: FoundVar->getType());
4695 const ArrayType *TArray
4696 = Importer.getToContext().getAsArrayType(T: D->getType());
4697 if (FoundArray && TArray) {
4698 if (isa<IncompleteArrayType>(Val: FoundArray) &&
4699 isa<ConstantArrayType>(Val: TArray)) {
4700 // Import the type.
4701 if (auto TyOrErr = import(From: D->getType()))
4702 FoundVar->setType(*TyOrErr);
4703 else
4704 return TyOrErr.takeError();
4705
4706 FoundByLookup = FoundVar;
4707 break;
4708 } else if (isa<IncompleteArrayType>(Val: TArray) &&
4709 isa<ConstantArrayType>(Val: FoundArray)) {
4710 FoundByLookup = FoundVar;
4711 break;
4712 }
4713 }
4714
4715 Importer.ToDiag(Loc, DiagID: diag::warn_odr_variable_type_inconsistent)
4716 << Name << D->getType() << FoundVar->getType();
4717 Importer.ToDiag(Loc: FoundVar->getLocation(), DiagID: diag::note_odr_value_here)
4718 << FoundVar->getType();
4719 ConflictingDecls.push_back(Elt: FoundDecl);
4720 }
4721 }
4722
4723 if (!ConflictingDecls.empty()) {
4724 ExpectedName NameOrErr = Importer.HandleNameConflict(
4725 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
4726 if (NameOrErr)
4727 Name = NameOrErr.get();
4728 else
4729 return NameOrErr.takeError();
4730 }
4731 }
4732
4733 Error Err = Error::success();
4734 auto ToType = importChecked(Err, From: D->getType());
4735 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4736 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4737 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
4738 if (Err)
4739 return std::move(Err);
4740
4741 VarDecl *ToVar;
4742 if (auto *FromDecomp = dyn_cast<DecompositionDecl>(Val: D)) {
4743 SmallVector<BindingDecl *> Bindings(FromDecomp->bindings().size());
4744 if (Error Err =
4745 ImportArrayChecked(InContainer: FromDecomp->bindings(), Obegin: Bindings.begin()))
4746 return std::move(Err);
4747 DecompositionDecl *ToDecomp;
4748 if (GetImportedOrCreateDecl(
4749 ToD&: ToDecomp, FromD: FromDecomp, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart,
4750 args&: Loc, args: FromDecomp->getRSquareLoc(), args&: ToType, args&: ToTypeSourceInfo,
4751 args: D->getStorageClass(), args&: Bindings))
4752 return ToDecomp;
4753 ToVar = ToDecomp;
4754 } else {
4755 // Create the imported variable.
4756 if (GetImportedOrCreateDecl(ToD&: ToVar, FromD: D, args&: Importer.getToContext(), args&: DC,
4757 args&: ToInnerLocStart, args&: Loc,
4758 args: Name.getAsIdentifierInfo(), args&: ToType,
4759 args&: ToTypeSourceInfo, args: D->getStorageClass()))
4760 return ToVar;
4761 }
4762
4763 ToVar->setTSCSpec(D->getTSCSpec());
4764 ToVar->setQualifierInfo(ToQualifierLoc);
4765 ToVar->setAccess(D->getAccess());
4766 ToVar->setLexicalDeclContext(LexicalDC);
4767 if (D->isInlineSpecified())
4768 ToVar->setInlineSpecified();
4769 if (D->isInline())
4770 ToVar->setImplicitlyInline();
4771
4772 if (FoundByLookup) {
4773 auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4774 ToVar->setPreviousDecl(Recent);
4775 }
4776
4777 // Import the described template, if any.
4778 if (D->getDescribedVarTemplate()) {
4779 auto ToVTOrErr = import(From: D->getDescribedVarTemplate());
4780 if (!ToVTOrErr)
4781 return ToVTOrErr.takeError();
4782 } else if (MemberSpecializationInfo *MSI = D->getMemberSpecializationInfo()) {
4783 TemplateSpecializationKind SK = MSI->getTemplateSpecializationKind();
4784 VarDecl *FromInst = D->getInstantiatedFromStaticDataMember();
4785 if (Expected<VarDecl *> ToInstOrErr = import(From: FromInst))
4786 ToVar->setInstantiationOfStaticDataMember(VD: *ToInstOrErr, TSK: SK);
4787 else
4788 return ToInstOrErr.takeError();
4789 if (ExpectedSLoc POIOrErr = import(From: MSI->getPointOfInstantiation()))
4790 ToVar->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
4791 else
4792 return POIOrErr.takeError();
4793 }
4794
4795 if (Error Err = ImportInitializer(From: D, To: ToVar))
4796 return std::move(Err);
4797
4798 if (D->isConstexpr())
4799 ToVar->setConstexpr(true);
4800
4801 addDeclToContexts(FromD: D, ToD: ToVar);
4802
4803 // Import the rest of the chain. I.e. import all subsequent declarations.
4804 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4805 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
4806 if (!RedeclOrErr)
4807 return RedeclOrErr.takeError();
4808 }
4809
4810 return ToVar;
4811}
4812
4813ExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
4814 // Parameters are created in the translation unit's context, then moved
4815 // into the function declaration's context afterward.
4816 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4817
4818 Error Err = Error::success();
4819 auto ToDeclName = importChecked(Err, From: D->getDeclName());
4820 auto ToLocation = importChecked(Err, From: D->getLocation());
4821 auto ToType = importChecked(Err, From: D->getType());
4822 if (Err)
4823 return std::move(Err);
4824
4825 // Create the imported parameter.
4826 ImplicitParamDecl *ToParm = nullptr;
4827 if (GetImportedOrCreateDecl(ToD&: ToParm, FromD: D, args&: Importer.getToContext(), args&: DC,
4828 args&: ToLocation, args: ToDeclName.getAsIdentifierInfo(),
4829 args&: ToType, args: D->getParameterKind()))
4830 return ToParm;
4831 return ToParm;
4832}
4833
4834Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
4835 const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
4836
4837 if (auto LocOrErr = import(From: FromParam->getExplicitObjectParamThisLoc()))
4838 ToParam->setExplicitObjectParameterLoc(*LocOrErr);
4839 else
4840 return LocOrErr.takeError();
4841
4842 ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4843 ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4844
4845 if (FromParam->hasUninstantiatedDefaultArg()) {
4846 if (auto ToDefArgOrErr = import(From: FromParam->getUninstantiatedDefaultArg()))
4847 ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4848 else
4849 return ToDefArgOrErr.takeError();
4850 } else if (FromParam->hasUnparsedDefaultArg()) {
4851 ToParam->setUnparsedDefaultArg();
4852 } else if (FromParam->hasDefaultArg()) {
4853 if (auto ToDefArgOrErr = import(From: FromParam->getDefaultArg()))
4854 ToParam->setDefaultArg(*ToDefArgOrErr);
4855 else
4856 return ToDefArgOrErr.takeError();
4857 }
4858
4859 return Error::success();
4860}
4861
4862Expected<InheritedConstructor>
4863ASTNodeImporter::ImportInheritedConstructor(const InheritedConstructor &From) {
4864 Error Err = Error::success();
4865 CXXConstructorDecl *ToBaseCtor = importChecked(Err, From: From.getConstructor());
4866 ConstructorUsingShadowDecl *ToShadow =
4867 importChecked(Err, From: From.getShadowDecl());
4868 if (Err)
4869 return std::move(Err);
4870 return InheritedConstructor(ToShadow, ToBaseCtor);
4871}
4872
4873ExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
4874 // Parameters are created in the translation unit's context, then moved
4875 // into the function declaration's context afterward.
4876 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4877
4878 Error Err = Error::success();
4879 auto ToDeclName = importChecked(Err, From: D->getDeclName());
4880 auto ToLocation = importChecked(Err, From: D->getLocation());
4881 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4882 auto ToType = importChecked(Err, From: D->getType());
4883 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4884 if (Err)
4885 return std::move(Err);
4886
4887 ParmVarDecl *ToParm;
4888 if (GetImportedOrCreateDecl(ToD&: ToParm, FromD: D, args&: Importer.getToContext(), args&: DC,
4889 args&: ToInnerLocStart, args&: ToLocation,
4890 args: ToDeclName.getAsIdentifierInfo(), args&: ToType,
4891 args&: ToTypeSourceInfo, args: D->getStorageClass(),
4892 /*DefaultArg*/ args: nullptr))
4893 return ToParm;
4894
4895 // Set the default argument. It should be no problem if it was already done.
4896 // Do not import the default expression before GetImportedOrCreateDecl call
4897 // to avoid possible infinite import loop because circular dependency.
4898 if (Error Err = ImportDefaultArgOfParmVarDecl(FromParam: D, ToParam: ToParm))
4899 return std::move(Err);
4900
4901 if (D->isObjCMethodParameter()) {
4902 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4903 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4904 } else {
4905 ToParm->setScopeInfo(scopeDepth: D->getFunctionScopeDepth(),
4906 parameterIndex: D->getFunctionScopeIndex());
4907 }
4908
4909 return ToParm;
4910}
4911
4912ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
4913 // Import the major distinguishing characteristics of a method.
4914 DeclContext *DC, *LexicalDC;
4915 DeclarationName Name;
4916 SourceLocation Loc;
4917 NamedDecl *ToD;
4918 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4919 return std::move(Err);
4920 if (ToD)
4921 return ToD;
4922
4923 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4924 for (auto *FoundDecl : FoundDecls) {
4925 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(Val: FoundDecl)) {
4926 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4927 continue;
4928
4929 // Check return types.
4930 if (!Importer.IsStructurallyEquivalent(From: D->getReturnType(),
4931 To: FoundMethod->getReturnType())) {
4932 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_result_type_inconsistent)
4933 << D->isInstanceMethod() << Name << D->getReturnType()
4934 << FoundMethod->getReturnType();
4935 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4936 DiagID: diag::note_odr_objc_method_here)
4937 << D->isInstanceMethod() << Name;
4938
4939 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4940 }
4941
4942 // Check the number of parameters.
4943 if (D->param_size() != FoundMethod->param_size()) {
4944 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_num_params_inconsistent)
4945 << D->isInstanceMethod() << Name
4946 << D->param_size() << FoundMethod->param_size();
4947 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4948 DiagID: diag::note_odr_objc_method_here)
4949 << D->isInstanceMethod() << Name;
4950
4951 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4952 }
4953
4954 // Check parameter types.
4955 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4956 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4957 P != PEnd; ++P, ++FoundP) {
4958 if (!Importer.IsStructurallyEquivalent(From: (*P)->getType(),
4959 To: (*FoundP)->getType())) {
4960 Importer.FromDiag(Loc: (*P)->getLocation(),
4961 DiagID: diag::warn_odr_objc_method_param_type_inconsistent)
4962 << D->isInstanceMethod() << Name
4963 << (*P)->getType() << (*FoundP)->getType();
4964 Importer.ToDiag(Loc: (*FoundP)->getLocation(), DiagID: diag::note_odr_value_here)
4965 << (*FoundP)->getType();
4966
4967 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4968 }
4969 }
4970
4971 // Check variadic/non-variadic.
4972 // Check the number of parameters.
4973 if (D->isVariadic() != FoundMethod->isVariadic()) {
4974 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_variadic_inconsistent)
4975 << D->isInstanceMethod() << Name;
4976 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4977 DiagID: diag::note_odr_objc_method_here)
4978 << D->isInstanceMethod() << Name;
4979
4980 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4981 }
4982
4983 // FIXME: Any other bits we need to merge?
4984 return Importer.MapImported(From: D, To: FoundMethod);
4985 }
4986 }
4987
4988 Error Err = Error::success();
4989 auto ToEndLoc = importChecked(Err, From: D->getEndLoc());
4990 auto ToReturnType = importChecked(Err, From: D->getReturnType());
4991 auto ToReturnTypeSourceInfo =
4992 importChecked(Err, From: D->getReturnTypeSourceInfo());
4993 if (Err)
4994 return std::move(Err);
4995
4996 ObjCMethodDecl *ToMethod;
4997 if (GetImportedOrCreateDecl(
4998 ToD&: ToMethod, FromD: D, args&: Importer.getToContext(), args&: Loc, args&: ToEndLoc,
4999 args: Name.getObjCSelector(), args&: ToReturnType, args&: ToReturnTypeSourceInfo, args&: DC,
5000 args: D->isInstanceMethod(), args: D->isVariadic(), args: D->isPropertyAccessor(),
5001 args: D->isSynthesizedAccessorStub(), args: D->isImplicit(), args: D->isDefined(),
5002 args: D->getImplementationControl(), args: D->hasRelatedResultType()))
5003 return ToMethod;
5004
5005 // FIXME: When we decide to merge method definitions, we'll need to
5006 // deal with implicit parameters.
5007
5008 // Import the parameters
5009 SmallVector<ParmVarDecl *, 5> ToParams;
5010 for (auto *FromP : D->parameters()) {
5011 if (Expected<ParmVarDecl *> ToPOrErr = import(From: FromP))
5012 ToParams.push_back(Elt: *ToPOrErr);
5013 else
5014 return ToPOrErr.takeError();
5015 }
5016
5017 // Set the parameters.
5018 for (auto *ToParam : ToParams) {
5019 ToParam->setOwningFunction(ToMethod);
5020 ToMethod->addDeclInternal(D: ToParam);
5021 }
5022
5023 SmallVector<SourceLocation, 12> FromSelLocs;
5024 D->getSelectorLocs(SelLocs&: FromSelLocs);
5025 SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
5026 if (Error Err = ImportContainerChecked(InContainer: FromSelLocs, OutContainer&: ToSelLocs))
5027 return std::move(Err);
5028
5029 ToMethod->setMethodParams(C&: Importer.getToContext(), Params: ToParams, SelLocs: ToSelLocs);
5030
5031 ToMethod->setLexicalDeclContext(LexicalDC);
5032 LexicalDC->addDeclInternal(D: ToMethod);
5033
5034 // Implicit params are declared when Sema encounters the definition but this
5035 // never happens when the method is imported. Manually declare the implicit
5036 // params now that the MethodDecl knows its class interface.
5037 if (D->getSelfDecl())
5038 ToMethod->createImplicitParams(Context&: Importer.getToContext(),
5039 ID: ToMethod->getClassInterface());
5040
5041 return ToMethod;
5042}
5043
5044ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
5045 // Import the major distinguishing characteristics of a category.
5046 DeclContext *DC, *LexicalDC;
5047 DeclarationName Name;
5048 SourceLocation Loc;
5049 NamedDecl *ToD;
5050 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5051 return std::move(Err);
5052 if (ToD)
5053 return ToD;
5054
5055 Error Err = Error::success();
5056 auto ToVarianceLoc = importChecked(Err, From: D->getVarianceLoc());
5057 auto ToLocation = importChecked(Err, From: D->getLocation());
5058 auto ToColonLoc = importChecked(Err, From: D->getColonLoc());
5059 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
5060 if (Err)
5061 return std::move(Err);
5062
5063 ObjCTypeParamDecl *Result;
5064 if (GetImportedOrCreateDecl(
5065 ToD&: Result, FromD: D, args&: Importer.getToContext(), args&: DC, args: D->getVariance(),
5066 args&: ToVarianceLoc, args: D->getIndex(),
5067 args&: ToLocation, args: Name.getAsIdentifierInfo(),
5068 args&: ToColonLoc, args&: ToTypeSourceInfo))
5069 return Result;
5070
5071 // Only import 'ObjCTypeParamType' after the decl is created.
5072 auto ToTypeForDecl = importChecked(Err, From: D->getTypeForDecl());
5073 if (Err)
5074 return std::move(Err);
5075 Result->setTypeForDecl(ToTypeForDecl);
5076 Result->setLexicalDeclContext(LexicalDC);
5077 return Result;
5078}
5079
5080ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
5081 // Import the major distinguishing characteristics of a category.
5082 DeclContext *DC, *LexicalDC;
5083 DeclarationName Name;
5084 SourceLocation Loc;
5085 NamedDecl *ToD;
5086 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5087 return std::move(Err);
5088 if (ToD)
5089 return ToD;
5090
5091 ObjCInterfaceDecl *ToInterface;
5092 if (Error Err = importInto(To&: ToInterface, From: D->getClassInterface()))
5093 return std::move(Err);
5094
5095 // Determine if we've already encountered this category.
5096 ObjCCategoryDecl *MergeWithCategory
5097 = ToInterface->FindCategoryDeclaration(CategoryId: Name.getAsIdentifierInfo());
5098 ObjCCategoryDecl *ToCategory = MergeWithCategory;
5099 if (!ToCategory) {
5100
5101 Error Err = Error::success();
5102 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5103 auto ToCategoryNameLoc = importChecked(Err, From: D->getCategoryNameLoc());
5104 auto ToIvarLBraceLoc = importChecked(Err, From: D->getIvarLBraceLoc());
5105 auto ToIvarRBraceLoc = importChecked(Err, From: D->getIvarRBraceLoc());
5106 if (Err)
5107 return std::move(Err);
5108
5109 if (GetImportedOrCreateDecl(ToD&: ToCategory, FromD: D, args&: Importer.getToContext(), args&: DC,
5110 args&: ToAtStartLoc, args&: Loc,
5111 args&: ToCategoryNameLoc,
5112 args: Name.getAsIdentifierInfo(), args&: ToInterface,
5113 /*TypeParamList=*/args: nullptr,
5114 args&: ToIvarLBraceLoc,
5115 args&: ToIvarRBraceLoc))
5116 return ToCategory;
5117
5118 ToCategory->setLexicalDeclContext(LexicalDC);
5119 LexicalDC->addDeclInternal(D: ToCategory);
5120 // Import the type parameter list after MapImported, to avoid
5121 // loops when bringing in their DeclContext.
5122 if (auto PListOrErr = ImportObjCTypeParamList(list: D->getTypeParamList()))
5123 ToCategory->setTypeParamList(*PListOrErr);
5124 else
5125 return PListOrErr.takeError();
5126
5127 // Import protocols
5128 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5129 SmallVector<SourceLocation, 4> ProtocolLocs;
5130 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
5131 = D->protocol_loc_begin();
5132 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
5133 FromProtoEnd = D->protocol_end();
5134 FromProto != FromProtoEnd;
5135 ++FromProto, ++FromProtoLoc) {
5136 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5137 Protocols.push_back(Elt: *ToProtoOrErr);
5138 else
5139 return ToProtoOrErr.takeError();
5140
5141 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5142 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5143 else
5144 return ToProtoLocOrErr.takeError();
5145 }
5146
5147 // FIXME: If we're merging, make sure that the protocol list is the same.
5148 ToCategory->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5149 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5150
5151 } else {
5152 Importer.MapImported(From: D, To: ToCategory);
5153 }
5154
5155 // Import all of the members of this category.
5156 if (Error Err = ImportDeclContext(FromDC: D))
5157 return std::move(Err);
5158
5159 // If we have an implementation, import it as well.
5160 if (D->getImplementation()) {
5161 if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
5162 import(From: D->getImplementation()))
5163 ToCategory->setImplementation(*ToImplOrErr);
5164 else
5165 return ToImplOrErr.takeError();
5166 }
5167
5168 return ToCategory;
5169}
5170
5171Error ASTNodeImporter::ImportDefinition(
5172 ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
5173 if (To->getDefinition()) {
5174 if (shouldForceImportDeclContext(IDK: Kind))
5175 if (Error Err = ImportDeclContext(FromDC: From))
5176 return Err;
5177 return Error::success();
5178 }
5179
5180 // Start the protocol definition
5181 To->startDefinition();
5182
5183 // Import protocols
5184 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5185 SmallVector<SourceLocation, 4> ProtocolLocs;
5186 ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
5187 From->protocol_loc_begin();
5188 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
5189 FromProtoEnd = From->protocol_end();
5190 FromProto != FromProtoEnd;
5191 ++FromProto, ++FromProtoLoc) {
5192 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5193 Protocols.push_back(Elt: *ToProtoOrErr);
5194 else
5195 return ToProtoOrErr.takeError();
5196
5197 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5198 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5199 else
5200 return ToProtoLocOrErr.takeError();
5201
5202 }
5203
5204 // FIXME: If we're merging, make sure that the protocol list is the same.
5205 To->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5206 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5207
5208 if (shouldForceImportDeclContext(IDK: Kind)) {
5209 // Import all of the members of this protocol.
5210 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
5211 return Err;
5212 }
5213 return Error::success();
5214}
5215
5216ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
5217 // If this protocol has a definition in the translation unit we're coming
5218 // from, but this particular declaration is not that definition, import the
5219 // definition and map to that.
5220 ObjCProtocolDecl *Definition = D->getDefinition();
5221 if (Definition && Definition != D) {
5222 if (ExpectedDecl ImportedDefOrErr = import(From: Definition))
5223 return Importer.MapImported(From: D, To: *ImportedDefOrErr);
5224 else
5225 return ImportedDefOrErr.takeError();
5226 }
5227
5228 // Import the major distinguishing characteristics of a protocol.
5229 DeclContext *DC, *LexicalDC;
5230 DeclarationName Name;
5231 SourceLocation Loc;
5232 NamedDecl *ToD;
5233 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5234 return std::move(Err);
5235 if (ToD)
5236 return ToD;
5237
5238 ObjCProtocolDecl *MergeWithProtocol = nullptr;
5239 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5240 for (auto *FoundDecl : FoundDecls) {
5241 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_ObjCProtocol))
5242 continue;
5243
5244 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(Val: FoundDecl)))
5245 break;
5246 }
5247
5248 ObjCProtocolDecl *ToProto = MergeWithProtocol;
5249 if (!ToProto) {
5250 auto ToAtBeginLocOrErr = import(From: D->getAtStartLoc());
5251 if (!ToAtBeginLocOrErr)
5252 return ToAtBeginLocOrErr.takeError();
5253
5254 if (GetImportedOrCreateDecl(ToD&: ToProto, FromD: D, args&: Importer.getToContext(), args&: DC,
5255 args: Name.getAsIdentifierInfo(), args&: Loc,
5256 args&: *ToAtBeginLocOrErr,
5257 /*PrevDecl=*/args: nullptr))
5258 return ToProto;
5259 ToProto->setLexicalDeclContext(LexicalDC);
5260 LexicalDC->addDeclInternal(D: ToProto);
5261 }
5262
5263 Importer.MapImported(From: D, To: ToProto);
5264
5265 if (D->isThisDeclarationADefinition())
5266 if (Error Err = ImportDefinition(From: D, To: ToProto))
5267 return std::move(Err);
5268
5269 return ToProto;
5270}
5271
5272ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
5273 DeclContext *DC, *LexicalDC;
5274 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5275 return std::move(Err);
5276
5277 ExpectedSLoc ExternLocOrErr = import(From: D->getExternLoc());
5278 if (!ExternLocOrErr)
5279 return ExternLocOrErr.takeError();
5280
5281 ExpectedSLoc LangLocOrErr = import(From: D->getLocation());
5282 if (!LangLocOrErr)
5283 return LangLocOrErr.takeError();
5284
5285 bool HasBraces = D->hasBraces();
5286
5287 LinkageSpecDecl *ToLinkageSpec;
5288 if (GetImportedOrCreateDecl(ToD&: ToLinkageSpec, FromD: D, args&: Importer.getToContext(), args&: DC,
5289 args&: *ExternLocOrErr, args&: *LangLocOrErr,
5290 args: D->getLanguage(), args&: HasBraces))
5291 return ToLinkageSpec;
5292
5293 if (HasBraces) {
5294 ExpectedSLoc RBraceLocOrErr = import(From: D->getRBraceLoc());
5295 if (!RBraceLocOrErr)
5296 return RBraceLocOrErr.takeError();
5297 ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
5298 }
5299
5300 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
5301 LexicalDC->addDeclInternal(D: ToLinkageSpec);
5302
5303 return ToLinkageSpec;
5304}
5305
5306ExpectedDecl ASTNodeImporter::ImportUsingShadowDecls(BaseUsingDecl *D,
5307 BaseUsingDecl *ToSI) {
5308 for (UsingShadowDecl *FromShadow : D->shadows()) {
5309 if (Expected<UsingShadowDecl *> ToShadowOrErr = import(From: FromShadow))
5310 ToSI->addShadowDecl(S: *ToShadowOrErr);
5311 else
5312 // FIXME: We return error here but the definition is already created
5313 // and available with lookups. How to fix this?..
5314 return ToShadowOrErr.takeError();
5315 }
5316 return ToSI;
5317}
5318
5319ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
5320 DeclContext *DC, *LexicalDC;
5321 DeclarationName Name;
5322 SourceLocation Loc;
5323 NamedDecl *ToD = nullptr;
5324 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5325 return std::move(Err);
5326 if (ToD)
5327 return ToD;
5328
5329 Error Err = Error::success();
5330 auto ToLoc = importChecked(Err, From: D->getNameInfo().getLoc());
5331 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5332 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5333 if (Err)
5334 return std::move(Err);
5335
5336 DeclarationNameInfo NameInfo(Name, ToLoc);
5337 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
5338 return std::move(Err);
5339
5340 UsingDecl *ToUsing;
5341 if (GetImportedOrCreateDecl(ToD&: ToUsing, FromD: D, args&: Importer.getToContext(), args&: DC,
5342 args&: ToUsingLoc, args&: ToQualifierLoc, args&: NameInfo,
5343 args: D->hasTypename()))
5344 return ToUsing;
5345
5346 ToUsing->setLexicalDeclContext(LexicalDC);
5347 LexicalDC->addDeclInternal(D: ToUsing);
5348
5349 if (NamedDecl *FromPattern =
5350 Importer.getFromContext().getInstantiatedFromUsingDecl(Inst: D)) {
5351 if (Expected<NamedDecl *> ToPatternOrErr = import(From: FromPattern))
5352 Importer.getToContext().setInstantiatedFromUsingDecl(
5353 Inst: ToUsing, Pattern: *ToPatternOrErr);
5354 else
5355 return ToPatternOrErr.takeError();
5356 }
5357
5358 return ImportUsingShadowDecls(D, ToSI: ToUsing);
5359}
5360
5361ExpectedDecl ASTNodeImporter::VisitUsingEnumDecl(UsingEnumDecl *D) {
5362 DeclContext *DC, *LexicalDC;
5363 DeclarationName Name;
5364 SourceLocation Loc;
5365 NamedDecl *ToD = nullptr;
5366 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5367 return std::move(Err);
5368 if (ToD)
5369 return ToD;
5370
5371 Error Err = Error::success();
5372 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5373 auto ToEnumLoc = importChecked(Err, From: D->getEnumLoc());
5374 auto ToNameLoc = importChecked(Err, From: D->getLocation());
5375 auto *ToEnumType = importChecked(Err, From: D->getEnumType());
5376 if (Err)
5377 return std::move(Err);
5378
5379 UsingEnumDecl *ToUsingEnum;
5380 if (GetImportedOrCreateDecl(ToD&: ToUsingEnum, FromD: D, args&: Importer.getToContext(), args&: DC,
5381 args&: ToUsingLoc, args&: ToEnumLoc, args&: ToNameLoc, args&: ToEnumType))
5382 return ToUsingEnum;
5383
5384 ToUsingEnum->setLexicalDeclContext(LexicalDC);
5385 LexicalDC->addDeclInternal(D: ToUsingEnum);
5386
5387 if (UsingEnumDecl *FromPattern =
5388 Importer.getFromContext().getInstantiatedFromUsingEnumDecl(Inst: D)) {
5389 if (Expected<UsingEnumDecl *> ToPatternOrErr = import(From: FromPattern))
5390 Importer.getToContext().setInstantiatedFromUsingEnumDecl(Inst: ToUsingEnum,
5391 Pattern: *ToPatternOrErr);
5392 else
5393 return ToPatternOrErr.takeError();
5394 }
5395
5396 return ImportUsingShadowDecls(D, ToSI: ToUsingEnum);
5397}
5398
5399ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
5400 DeclContext *DC, *LexicalDC;
5401 DeclarationName Name;
5402 SourceLocation Loc;
5403 NamedDecl *ToD = nullptr;
5404 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5405 return std::move(Err);
5406 if (ToD)
5407 return ToD;
5408
5409 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(From: D->getIntroducer());
5410 if (!ToIntroducerOrErr)
5411 return ToIntroducerOrErr.takeError();
5412
5413 Expected<NamedDecl *> ToTargetOrErr = import(From: D->getTargetDecl());
5414 if (!ToTargetOrErr)
5415 return ToTargetOrErr.takeError();
5416
5417 UsingShadowDecl *ToShadow;
5418 if (auto *FromConstructorUsingShadow =
5419 dyn_cast<ConstructorUsingShadowDecl>(Val: D)) {
5420 Error Err = Error::success();
5421 ConstructorUsingShadowDecl *Nominated = importChecked(
5422 Err, From: FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5423 if (Err)
5424 return std::move(Err);
5425 // The 'Target' parameter of ConstructorUsingShadowDecl constructor
5426 // is really the "NominatedBaseClassShadowDecl" value if it exists
5427 // (see code of ConstructorUsingShadowDecl::ConstructorUsingShadowDecl).
5428 // We should pass the NominatedBaseClassShadowDecl to it (if non-null) to
5429 // get the correct values.
5430 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
5431 ToD&: ToShadow, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5432 args: cast<UsingDecl>(Val: *ToIntroducerOrErr),
5433 args: Nominated ? Nominated : *ToTargetOrErr,
5434 args: FromConstructorUsingShadow->constructsVirtualBase()))
5435 return ToShadow;
5436 } else {
5437 if (GetImportedOrCreateDecl(ToD&: ToShadow, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5438 args&: Name, args&: *ToIntroducerOrErr, args&: *ToTargetOrErr))
5439 return ToShadow;
5440 }
5441
5442 ToShadow->setLexicalDeclContext(LexicalDC);
5443 ToShadow->setAccess(D->getAccess());
5444
5445 if (UsingShadowDecl *FromPattern =
5446 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(Inst: D)) {
5447 if (Expected<UsingShadowDecl *> ToPatternOrErr = import(From: FromPattern))
5448 Importer.getToContext().setInstantiatedFromUsingShadowDecl(
5449 Inst: ToShadow, Pattern: *ToPatternOrErr);
5450 else
5451 // FIXME: We return error here but the definition is already created
5452 // and available with lookups. How to fix this?..
5453 return ToPatternOrErr.takeError();
5454 }
5455
5456 LexicalDC->addDeclInternal(D: ToShadow);
5457
5458 return ToShadow;
5459}
5460
5461ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
5462 DeclContext *DC, *LexicalDC;
5463 DeclarationName Name;
5464 SourceLocation Loc;
5465 NamedDecl *ToD = nullptr;
5466 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5467 return std::move(Err);
5468 if (ToD)
5469 return ToD;
5470
5471 auto ToComAncestorOrErr = Importer.ImportContext(FromDC: D->getCommonAncestor());
5472 if (!ToComAncestorOrErr)
5473 return ToComAncestorOrErr.takeError();
5474
5475 Error Err = Error::success();
5476 auto ToNominatedNamespace = importChecked(Err, From: D->getNominatedNamespace());
5477 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5478 auto ToNamespaceKeyLocation =
5479 importChecked(Err, From: D->getNamespaceKeyLocation());
5480 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5481 auto ToIdentLocation = importChecked(Err, From: D->getIdentLocation());
5482 if (Err)
5483 return std::move(Err);
5484
5485 UsingDirectiveDecl *ToUsingDir;
5486 if (GetImportedOrCreateDecl(ToD&: ToUsingDir, FromD: D, args&: Importer.getToContext(), args&: DC,
5487 args&: ToUsingLoc,
5488 args&: ToNamespaceKeyLocation,
5489 args&: ToQualifierLoc,
5490 args&: ToIdentLocation,
5491 args&: ToNominatedNamespace, args&: *ToComAncestorOrErr))
5492 return ToUsingDir;
5493
5494 ToUsingDir->setLexicalDeclContext(LexicalDC);
5495 LexicalDC->addDeclInternal(D: ToUsingDir);
5496
5497 return ToUsingDir;
5498}
5499
5500ExpectedDecl ASTNodeImporter::VisitUsingPackDecl(UsingPackDecl *D) {
5501 DeclContext *DC, *LexicalDC;
5502 DeclarationName Name;
5503 SourceLocation Loc;
5504 NamedDecl *ToD = nullptr;
5505 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5506 return std::move(Err);
5507 if (ToD)
5508 return ToD;
5509
5510 auto ToInstantiatedFromUsingOrErr =
5511 Importer.Import(FromD: D->getInstantiatedFromUsingDecl());
5512 if (!ToInstantiatedFromUsingOrErr)
5513 return ToInstantiatedFromUsingOrErr.takeError();
5514 SmallVector<NamedDecl *, 4> Expansions(D->expansions().size());
5515 if (Error Err = ImportArrayChecked(InContainer: D->expansions(), Obegin: Expansions.begin()))
5516 return std::move(Err);
5517
5518 UsingPackDecl *ToUsingPack;
5519 if (GetImportedOrCreateDecl(ToD&: ToUsingPack, FromD: D, args&: Importer.getToContext(), args&: DC,
5520 args: cast<NamedDecl>(Val: *ToInstantiatedFromUsingOrErr),
5521 args&: Expansions))
5522 return ToUsingPack;
5523
5524 addDeclToContexts(FromD: D, ToD: ToUsingPack);
5525
5526 return ToUsingPack;
5527}
5528
5529ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
5530 UnresolvedUsingValueDecl *D) {
5531 DeclContext *DC, *LexicalDC;
5532 DeclarationName Name;
5533 SourceLocation Loc;
5534 NamedDecl *ToD = nullptr;
5535 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5536 return std::move(Err);
5537 if (ToD)
5538 return ToD;
5539
5540 Error Err = Error::success();
5541 auto ToLoc = importChecked(Err, From: D->getNameInfo().getLoc());
5542 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5543 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5544 auto ToEllipsisLoc = importChecked(Err, From: D->getEllipsisLoc());
5545 if (Err)
5546 return std::move(Err);
5547
5548 DeclarationNameInfo NameInfo(Name, ToLoc);
5549 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
5550 return std::move(Err);
5551
5552 UnresolvedUsingValueDecl *ToUsingValue;
5553 if (GetImportedOrCreateDecl(ToD&: ToUsingValue, FromD: D, args&: Importer.getToContext(), args&: DC,
5554 args&: ToUsingLoc, args&: ToQualifierLoc, args&: NameInfo,
5555 args&: ToEllipsisLoc))
5556 return ToUsingValue;
5557
5558 ToUsingValue->setAccess(D->getAccess());
5559 ToUsingValue->setLexicalDeclContext(LexicalDC);
5560 LexicalDC->addDeclInternal(D: ToUsingValue);
5561
5562 return ToUsingValue;
5563}
5564
5565ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
5566 UnresolvedUsingTypenameDecl *D) {
5567 DeclContext *DC, *LexicalDC;
5568 DeclarationName Name;
5569 SourceLocation Loc;
5570 NamedDecl *ToD = nullptr;
5571 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5572 return std::move(Err);
5573 if (ToD)
5574 return ToD;
5575
5576 Error Err = Error::success();
5577 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5578 auto ToTypenameLoc = importChecked(Err, From: D->getTypenameLoc());
5579 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5580 auto ToEllipsisLoc = importChecked(Err, From: D->getEllipsisLoc());
5581 if (Err)
5582 return std::move(Err);
5583
5584 UnresolvedUsingTypenameDecl *ToUsing;
5585 if (GetImportedOrCreateDecl(ToD&: ToUsing, FromD: D, args&: Importer.getToContext(), args&: DC,
5586 args&: ToUsingLoc, args&: ToTypenameLoc,
5587 args&: ToQualifierLoc, args&: Loc, args&: Name, args&: ToEllipsisLoc))
5588 return ToUsing;
5589
5590 ToUsing->setAccess(D->getAccess());
5591 ToUsing->setLexicalDeclContext(LexicalDC);
5592 LexicalDC->addDeclInternal(D: ToUsing);
5593
5594 return ToUsing;
5595}
5596
5597ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
5598 Decl* ToD = nullptr;
5599 switch (D->getBuiltinTemplateKind()) {
5600#define BuiltinTemplate(BTName) \
5601 case BuiltinTemplateKind::BTK##BTName: \
5602 ToD = Importer.getToContext().get##BTName##Decl(); \
5603 break;
5604#include "clang/Basic/BuiltinTemplates.inc"
5605 }
5606 assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
5607 Importer.MapImported(From: D, To: ToD);
5608 return ToD;
5609}
5610
5611Error ASTNodeImporter::ImportDefinition(
5612 ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
5613 if (To->getDefinition()) {
5614 // Check consistency of superclass.
5615 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
5616 if (FromSuper) {
5617 if (auto FromSuperOrErr = import(From: FromSuper))
5618 FromSuper = *FromSuperOrErr;
5619 else
5620 return FromSuperOrErr.takeError();
5621 }
5622
5623 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
5624 if ((bool)FromSuper != (bool)ToSuper ||
5625 (FromSuper && !declaresSameEntity(D1: FromSuper, D2: ToSuper))) {
5626 Importer.ToDiag(Loc: To->getLocation(),
5627 DiagID: diag::warn_odr_objc_superclass_inconsistent)
5628 << To->getDeclName();
5629 if (ToSuper)
5630 Importer.ToDiag(Loc: To->getSuperClassLoc(), DiagID: diag::note_odr_objc_superclass)
5631 << To->getSuperClass()->getDeclName();
5632 else
5633 Importer.ToDiag(Loc: To->getLocation(),
5634 DiagID: diag::note_odr_objc_missing_superclass);
5635 if (From->getSuperClass())
5636 Importer.FromDiag(Loc: From->getSuperClassLoc(),
5637 DiagID: diag::note_odr_objc_superclass)
5638 << From->getSuperClass()->getDeclName();
5639 else
5640 Importer.FromDiag(Loc: From->getLocation(),
5641 DiagID: diag::note_odr_objc_missing_superclass);
5642 }
5643
5644 if (shouldForceImportDeclContext(IDK: Kind))
5645 if (Error Err = ImportDeclContext(FromDC: From))
5646 return Err;
5647 return Error::success();
5648 }
5649
5650 // Start the definition.
5651 To->startDefinition();
5652
5653 // If this class has a superclass, import it.
5654 if (From->getSuperClass()) {
5655 if (auto SuperTInfoOrErr = import(From: From->getSuperClassTInfo()))
5656 To->setSuperClass(*SuperTInfoOrErr);
5657 else
5658 return SuperTInfoOrErr.takeError();
5659 }
5660
5661 // Import protocols
5662 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5663 SmallVector<SourceLocation, 4> ProtocolLocs;
5664 ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc =
5665 From->protocol_loc_begin();
5666
5667 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
5668 FromProtoEnd = From->protocol_end();
5669 FromProto != FromProtoEnd;
5670 ++FromProto, ++FromProtoLoc) {
5671 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5672 Protocols.push_back(Elt: *ToProtoOrErr);
5673 else
5674 return ToProtoOrErr.takeError();
5675
5676 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5677 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5678 else
5679 return ToProtoLocOrErr.takeError();
5680
5681 }
5682
5683 // FIXME: If we're merging, make sure that the protocol list is the same.
5684 To->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5685 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5686
5687 // Import categories. When the categories themselves are imported, they'll
5688 // hook themselves into this interface.
5689 for (auto *Cat : From->known_categories()) {
5690 auto ToCatOrErr = import(From: Cat);
5691 if (!ToCatOrErr)
5692 return ToCatOrErr.takeError();
5693 }
5694
5695 // If we have an @implementation, import it as well.
5696 if (From->getImplementation()) {
5697 if (Expected<ObjCImplementationDecl *> ToImplOrErr =
5698 import(From: From->getImplementation()))
5699 To->setImplementation(*ToImplOrErr);
5700 else
5701 return ToImplOrErr.takeError();
5702 }
5703
5704 // Import all of the members of this class.
5705 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
5706 return Err;
5707
5708 return Error::success();
5709}
5710
5711Expected<ObjCTypeParamList *>
5712ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
5713 if (!list)
5714 return nullptr;
5715
5716 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
5717 for (auto *fromTypeParam : *list) {
5718 if (auto toTypeParamOrErr = import(From: fromTypeParam))
5719 toTypeParams.push_back(Elt: *toTypeParamOrErr);
5720 else
5721 return toTypeParamOrErr.takeError();
5722 }
5723
5724 auto LAngleLocOrErr = import(From: list->getLAngleLoc());
5725 if (!LAngleLocOrErr)
5726 return LAngleLocOrErr.takeError();
5727
5728 auto RAngleLocOrErr = import(From: list->getRAngleLoc());
5729 if (!RAngleLocOrErr)
5730 return RAngleLocOrErr.takeError();
5731
5732 return ObjCTypeParamList::create(ctx&: Importer.getToContext(),
5733 lAngleLoc: *LAngleLocOrErr,
5734 typeParams: toTypeParams,
5735 rAngleLoc: *RAngleLocOrErr);
5736}
5737
5738ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
5739 // If this class has a definition in the translation unit we're coming from,
5740 // but this particular declaration is not that definition, import the
5741 // definition and map to that.
5742 ObjCInterfaceDecl *Definition = D->getDefinition();
5743 if (Definition && Definition != D) {
5744 if (ExpectedDecl ImportedDefOrErr = import(From: Definition))
5745 return Importer.MapImported(From: D, To: *ImportedDefOrErr);
5746 else
5747 return ImportedDefOrErr.takeError();
5748 }
5749
5750 // Import the major distinguishing characteristics of an @interface.
5751 DeclContext *DC, *LexicalDC;
5752 DeclarationName Name;
5753 SourceLocation Loc;
5754 NamedDecl *ToD;
5755 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5756 return std::move(Err);
5757 if (ToD)
5758 return ToD;
5759
5760 // Look for an existing interface with the same name.
5761 ObjCInterfaceDecl *MergeWithIface = nullptr;
5762 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5763 for (auto *FoundDecl : FoundDecls) {
5764 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary))
5765 continue;
5766
5767 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(Val: FoundDecl)))
5768 break;
5769 }
5770
5771 // Create an interface declaration, if one does not already exist.
5772 ObjCInterfaceDecl *ToIface = MergeWithIface;
5773 if (!ToIface) {
5774 ExpectedSLoc AtBeginLocOrErr = import(From: D->getAtStartLoc());
5775 if (!AtBeginLocOrErr)
5776 return AtBeginLocOrErr.takeError();
5777
5778 if (GetImportedOrCreateDecl(
5779 ToD&: ToIface, FromD: D, args&: Importer.getToContext(), args&: DC,
5780 args&: *AtBeginLocOrErr, args: Name.getAsIdentifierInfo(),
5781 /*TypeParamList=*/args: nullptr,
5782 /*PrevDecl=*/args: nullptr, args&: Loc, args: D->isImplicitInterfaceDecl()))
5783 return ToIface;
5784 ToIface->setLexicalDeclContext(LexicalDC);
5785 LexicalDC->addDeclInternal(D: ToIface);
5786 }
5787 Importer.MapImported(From: D, To: ToIface);
5788 // Import the type parameter list after MapImported, to avoid
5789 // loops when bringing in their DeclContext.
5790 if (auto ToPListOrErr =
5791 ImportObjCTypeParamList(list: D->getTypeParamListAsWritten()))
5792 ToIface->setTypeParamList(*ToPListOrErr);
5793 else
5794 return ToPListOrErr.takeError();
5795
5796 if (D->isThisDeclarationADefinition())
5797 if (Error Err = ImportDefinition(From: D, To: ToIface))
5798 return std::move(Err);
5799
5800 return ToIface;
5801}
5802
5803ExpectedDecl
5804ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
5805 ObjCCategoryDecl *Category;
5806 if (Error Err = importInto(To&: Category, From: D->getCategoryDecl()))
5807 return std::move(Err);
5808
5809 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
5810 if (!ToImpl) {
5811 DeclContext *DC, *LexicalDC;
5812 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5813 return std::move(Err);
5814
5815 Error Err = Error::success();
5816 auto ToLocation = importChecked(Err, From: D->getLocation());
5817 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5818 auto ToCategoryNameLoc = importChecked(Err, From: D->getCategoryNameLoc());
5819 if (Err)
5820 return std::move(Err);
5821
5822 if (GetImportedOrCreateDecl(
5823 ToD&: ToImpl, FromD: D, args&: Importer.getToContext(), args&: DC,
5824 args: Importer.Import(FromId: D->getIdentifier()), args: Category->getClassInterface(),
5825 args&: ToLocation, args&: ToAtStartLoc, args&: ToCategoryNameLoc))
5826 return ToImpl;
5827
5828 ToImpl->setLexicalDeclContext(LexicalDC);
5829 LexicalDC->addDeclInternal(D: ToImpl);
5830 Category->setImplementation(ToImpl);
5831 }
5832
5833 Importer.MapImported(From: D, To: ToImpl);
5834 if (Error Err = ImportDeclContext(FromDC: D))
5835 return std::move(Err);
5836
5837 return ToImpl;
5838}
5839
5840ExpectedDecl
5841ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
5842 // Find the corresponding interface.
5843 ObjCInterfaceDecl *Iface;
5844 if (Error Err = importInto(To&: Iface, From: D->getClassInterface()))
5845 return std::move(Err);
5846
5847 // Import the superclass, if any.
5848 ObjCInterfaceDecl *Super;
5849 if (Error Err = importInto(To&: Super, From: D->getSuperClass()))
5850 return std::move(Err);
5851
5852 ObjCImplementationDecl *Impl = Iface->getImplementation();
5853 if (!Impl) {
5854 // We haven't imported an implementation yet. Create a new @implementation
5855 // now.
5856 DeclContext *DC, *LexicalDC;
5857 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5858 return std::move(Err);
5859
5860 Error Err = Error::success();
5861 auto ToLocation = importChecked(Err, From: D->getLocation());
5862 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5863 auto ToSuperClassLoc = importChecked(Err, From: D->getSuperClassLoc());
5864 auto ToIvarLBraceLoc = importChecked(Err, From: D->getIvarLBraceLoc());
5865 auto ToIvarRBraceLoc = importChecked(Err, From: D->getIvarRBraceLoc());
5866 if (Err)
5867 return std::move(Err);
5868
5869 if (GetImportedOrCreateDecl(ToD&: Impl, FromD: D, args&: Importer.getToContext(),
5870 args&: DC, args&: Iface, args&: Super,
5871 args&: ToLocation,
5872 args&: ToAtStartLoc,
5873 args&: ToSuperClassLoc,
5874 args&: ToIvarLBraceLoc,
5875 args&: ToIvarRBraceLoc))
5876 return Impl;
5877
5878 Impl->setLexicalDeclContext(LexicalDC);
5879
5880 // Associate the implementation with the class it implements.
5881 Iface->setImplementation(Impl);
5882 Importer.MapImported(From: D, To: Iface->getImplementation());
5883 } else {
5884 Importer.MapImported(From: D, To: Iface->getImplementation());
5885
5886 // Verify that the existing @implementation has the same superclass.
5887 if ((Super && !Impl->getSuperClass()) ||
5888 (!Super && Impl->getSuperClass()) ||
5889 (Super && Impl->getSuperClass() &&
5890 !declaresSameEntity(D1: Super->getCanonicalDecl(),
5891 D2: Impl->getSuperClass()))) {
5892 Importer.ToDiag(Loc: Impl->getLocation(),
5893 DiagID: diag::warn_odr_objc_superclass_inconsistent)
5894 << Iface->getDeclName();
5895 // FIXME: It would be nice to have the location of the superclass
5896 // below.
5897 if (Impl->getSuperClass())
5898 Importer.ToDiag(Loc: Impl->getLocation(),
5899 DiagID: diag::note_odr_objc_superclass)
5900 << Impl->getSuperClass()->getDeclName();
5901 else
5902 Importer.ToDiag(Loc: Impl->getLocation(),
5903 DiagID: diag::note_odr_objc_missing_superclass);
5904 if (D->getSuperClass())
5905 Importer.FromDiag(Loc: D->getLocation(),
5906 DiagID: diag::note_odr_objc_superclass)
5907 << D->getSuperClass()->getDeclName();
5908 else
5909 Importer.FromDiag(Loc: D->getLocation(),
5910 DiagID: diag::note_odr_objc_missing_superclass);
5911
5912 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
5913 }
5914 }
5915
5916 // Import all of the members of this @implementation.
5917 if (Error Err = ImportDeclContext(FromDC: D))
5918 return std::move(Err);
5919
5920 return Impl;
5921}
5922
5923ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
5924 // Import the major distinguishing characteristics of an @property.
5925 DeclContext *DC, *LexicalDC;
5926 DeclarationName Name;
5927 SourceLocation Loc;
5928 NamedDecl *ToD;
5929 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5930 return std::move(Err);
5931 if (ToD)
5932 return ToD;
5933
5934 // Check whether we have already imported this property.
5935 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5936 for (auto *FoundDecl : FoundDecls) {
5937 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(Val: FoundDecl)) {
5938 // Instance and class properties can share the same name but are different
5939 // declarations.
5940 if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
5941 continue;
5942
5943 // Check property types.
5944 if (!Importer.IsStructurallyEquivalent(From: D->getType(),
5945 To: FoundProp->getType())) {
5946 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_property_type_inconsistent)
5947 << Name << D->getType() << FoundProp->getType();
5948 Importer.ToDiag(Loc: FoundProp->getLocation(), DiagID: diag::note_odr_value_here)
5949 << FoundProp->getType();
5950
5951 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
5952 }
5953
5954 // FIXME: Check property attributes, getters, setters, etc.?
5955
5956 // Consider these properties to be equivalent.
5957 Importer.MapImported(From: D, To: FoundProp);
5958 return FoundProp;
5959 }
5960 }
5961
5962 Error Err = Error::success();
5963 auto ToType = importChecked(Err, From: D->getType());
5964 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
5965 auto ToAtLoc = importChecked(Err, From: D->getAtLoc());
5966 auto ToLParenLoc = importChecked(Err, From: D->getLParenLoc());
5967 if (Err)
5968 return std::move(Err);
5969
5970 // Create the new property.
5971 ObjCPropertyDecl *ToProperty;
5972 if (GetImportedOrCreateDecl(
5973 ToD&: ToProperty, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5974 args: Name.getAsIdentifierInfo(), args&: ToAtLoc,
5975 args&: ToLParenLoc, args&: ToType,
5976 args&: ToTypeSourceInfo, args: D->getPropertyImplementation()))
5977 return ToProperty;
5978
5979 auto ToGetterName = importChecked(Err, From: D->getGetterName());
5980 auto ToSetterName = importChecked(Err, From: D->getSetterName());
5981 auto ToGetterNameLoc = importChecked(Err, From: D->getGetterNameLoc());
5982 auto ToSetterNameLoc = importChecked(Err, From: D->getSetterNameLoc());
5983 auto ToGetterMethodDecl = importChecked(Err, From: D->getGetterMethodDecl());
5984 auto ToSetterMethodDecl = importChecked(Err, From: D->getSetterMethodDecl());
5985 auto ToPropertyIvarDecl = importChecked(Err, From: D->getPropertyIvarDecl());
5986 if (Err)
5987 return std::move(Err);
5988
5989 ToProperty->setLexicalDeclContext(LexicalDC);
5990 LexicalDC->addDeclInternal(D: ToProperty);
5991
5992 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5993 ToProperty->setPropertyAttributesAsWritten(
5994 D->getPropertyAttributesAsWritten());
5995 ToProperty->setGetterName(Sel: ToGetterName, Loc: ToGetterNameLoc);
5996 ToProperty->setSetterName(Sel: ToSetterName, Loc: ToSetterNameLoc);
5997 ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5998 ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5999 ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
6000 return ToProperty;
6001}
6002
6003ExpectedDecl
6004ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
6005 ObjCPropertyDecl *Property;
6006 if (Error Err = importInto(To&: Property, From: D->getPropertyDecl()))
6007 return std::move(Err);
6008
6009 DeclContext *DC, *LexicalDC;
6010 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6011 return std::move(Err);
6012
6013 auto *InImpl = cast<ObjCImplDecl>(Val: LexicalDC);
6014
6015 // Import the ivar (for an @synthesize).
6016 ObjCIvarDecl *Ivar = nullptr;
6017 if (Error Err = importInto(To&: Ivar, From: D->getPropertyIvarDecl()))
6018 return std::move(Err);
6019
6020 ObjCPropertyImplDecl *ToImpl
6021 = InImpl->FindPropertyImplDecl(propertyId: Property->getIdentifier(),
6022 queryKind: Property->getQueryKind());
6023 if (!ToImpl) {
6024
6025 Error Err = Error::success();
6026 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
6027 auto ToLocation = importChecked(Err, From: D->getLocation());
6028 auto ToPropertyIvarDeclLoc =
6029 importChecked(Err, From: D->getPropertyIvarDeclLoc());
6030 if (Err)
6031 return std::move(Err);
6032
6033 if (GetImportedOrCreateDecl(ToD&: ToImpl, FromD: D, args&: Importer.getToContext(), args&: DC,
6034 args&: ToBeginLoc,
6035 args&: ToLocation, args&: Property,
6036 args: D->getPropertyImplementation(), args&: Ivar,
6037 args&: ToPropertyIvarDeclLoc))
6038 return ToImpl;
6039
6040 ToImpl->setLexicalDeclContext(LexicalDC);
6041 LexicalDC->addDeclInternal(D: ToImpl);
6042 } else {
6043 // Check that we have the same kind of property implementation (@synthesize
6044 // vs. @dynamic).
6045 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
6046 Importer.ToDiag(Loc: ToImpl->getLocation(),
6047 DiagID: diag::warn_odr_objc_property_impl_kind_inconsistent)
6048 << Property->getDeclName()
6049 << (ToImpl->getPropertyImplementation()
6050 == ObjCPropertyImplDecl::Dynamic);
6051 Importer.FromDiag(Loc: D->getLocation(),
6052 DiagID: diag::note_odr_objc_property_impl_kind)
6053 << D->getPropertyDecl()->getDeclName()
6054 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
6055
6056 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6057 }
6058
6059 // For @synthesize, check that we have the same
6060 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
6061 Ivar != ToImpl->getPropertyIvarDecl()) {
6062 Importer.ToDiag(Loc: ToImpl->getPropertyIvarDeclLoc(),
6063 DiagID: diag::warn_odr_objc_synthesize_ivar_inconsistent)
6064 << Property->getDeclName()
6065 << ToImpl->getPropertyIvarDecl()->getDeclName()
6066 << Ivar->getDeclName();
6067 Importer.FromDiag(Loc: D->getPropertyIvarDeclLoc(),
6068 DiagID: diag::note_odr_objc_synthesize_ivar_here)
6069 << D->getPropertyIvarDecl()->getDeclName();
6070
6071 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6072 }
6073
6074 // Merge the existing implementation with the new implementation.
6075 Importer.MapImported(From: D, To: ToImpl);
6076 }
6077
6078 return ToImpl;
6079}
6080
6081ExpectedDecl
6082ASTNodeImporter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
6083 Error Err = Error::success();
6084 auto ToType = importChecked(Err, From: D->getType());
6085 auto ToValue = importChecked(Err, From: D->getValue());
6086 if (Err)
6087 return std::move(Err);
6088
6089 TemplateParamObjectDecl *ToD;
6090 auto Create = [this](QualType T, const APValue &V) {
6091 return Importer.ToContext.getTemplateParamObjectDecl(T, V);
6092 };
6093 (void)GetImportedOrCreateSpecialDecl(ToD, CreateFun: Create, FromD: D, args&: ToType, args&: ToValue);
6094 return ToD;
6095}
6096
6097ExpectedDecl
6098ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
6099 // For template arguments, we adopt the translation unit as our declaration
6100 // context. This context will be fixed when (during) the actual template
6101 // declaration is created.
6102
6103 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6104 if (!BeginLocOrErr)
6105 return BeginLocOrErr.takeError();
6106
6107 ExpectedSLoc LocationOrErr = import(From: D->getLocation());
6108 if (!LocationOrErr)
6109 return LocationOrErr.takeError();
6110
6111 TemplateTypeParmDecl *ToD = nullptr;
6112 if (GetImportedOrCreateDecl(
6113 ToD, FromD: D, args&: Importer.getToContext(),
6114 args: Importer.getToContext().getTranslationUnitDecl(),
6115 args&: *BeginLocOrErr, args&: *LocationOrErr,
6116 args: D->getDepth(), args: D->getIndex(), args: Importer.Import(FromId: D->getIdentifier()),
6117 args: D->wasDeclaredWithTypename(), args: D->isParameterPack(),
6118 args: D->hasTypeConstraint()))
6119 return ToD;
6120
6121 // Import the type-constraint
6122 if (const TypeConstraint *TC = D->getTypeConstraint()) {
6123
6124 Error Err = Error::success();
6125 auto ToConceptRef = importChecked(Err, From: TC->getConceptReference());
6126 auto ToIDC = importChecked(Err, From: TC->getImmediatelyDeclaredConstraint());
6127 if (Err)
6128 return std::move(Err);
6129
6130 ToD->setTypeConstraint(CR: ToConceptRef, ImmediatelyDeclaredConstraint: ToIDC, ArgPackSubstIndex: TC->getArgPackSubstIndex());
6131 }
6132
6133 if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
6134 return Err;
6135
6136 return ToD;
6137}
6138
6139ExpectedDecl
6140ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
6141
6142 Error Err = Error::success();
6143 auto ToDeclName = importChecked(Err, From: D->getDeclName());
6144 auto ToLocation = importChecked(Err, From: D->getLocation());
6145 auto ToType = importChecked(Err, From: D->getType());
6146 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
6147 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
6148 if (Err)
6149 return std::move(Err);
6150
6151 NonTypeTemplateParmDecl *ToD = nullptr;
6152 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(),
6153 args: Importer.getToContext().getTranslationUnitDecl(),
6154 args&: ToInnerLocStart, args&: ToLocation, args: D->getDepth(),
6155 args: D->getPosition(),
6156 args: ToDeclName.getAsIdentifierInfo(), args&: ToType,
6157 args: D->isParameterPack(), args&: ToTypeSourceInfo))
6158 return ToD;
6159
6160 Err = importTemplateParameterDefaultArgument(D, ToD);
6161 if (Err)
6162 return Err;
6163
6164 return ToD;
6165}
6166
6167ExpectedDecl
6168ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
6169 bool IsCanonical = false;
6170 if (auto *CanonD = Importer.getFromContext()
6171 .findCanonicalTemplateTemplateParmDeclInternal(TTP: D);
6172 CanonD == D)
6173 IsCanonical = true;
6174
6175 // Import the name of this declaration.
6176 auto NameOrErr = import(From: D->getDeclName());
6177 if (!NameOrErr)
6178 return NameOrErr.takeError();
6179
6180 // Import the location of this declaration.
6181 ExpectedSLoc LocationOrErr = import(From: D->getLocation());
6182 if (!LocationOrErr)
6183 return LocationOrErr.takeError();
6184
6185 // Import template parameters.
6186 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6187 if (!TemplateParamsOrErr)
6188 return TemplateParamsOrErr.takeError();
6189
6190 TemplateTemplateParmDecl *ToD = nullptr;
6191 if (GetImportedOrCreateDecl(
6192 ToD, FromD: D, args&: Importer.getToContext(),
6193 args: Importer.getToContext().getTranslationUnitDecl(), args&: *LocationOrErr,
6194 args: D->getDepth(), args: D->getPosition(), args: D->isParameterPack(),
6195 args: (*NameOrErr).getAsIdentifierInfo(), args: D->templateParameterKind(),
6196 args: D->wasDeclaredWithTypename(), args&: *TemplateParamsOrErr))
6197 return ToD;
6198
6199 if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
6200 return Err;
6201
6202 if (IsCanonical)
6203 return Importer.getToContext()
6204 .insertCanonicalTemplateTemplateParmDeclInternal(CanonTTP: ToD);
6205
6206 return ToD;
6207}
6208
6209// Returns the definition for a (forward) declaration of a TemplateDecl, if
6210// it has any definition in the redecl chain.
6211template <typename T> static auto getTemplateDefinition(T *D) -> T * {
6212 assert(D->getTemplatedDecl() && "Should be called on templates only");
6213 auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
6214 if (!ToTemplatedDef)
6215 return nullptr;
6216 auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
6217 return cast_or_null<T>(TemplateWithDef);
6218}
6219
6220ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
6221
6222 // Import the major distinguishing characteristics of this class template.
6223 DeclContext *DC, *LexicalDC;
6224 DeclarationName Name;
6225 SourceLocation Loc;
6226 NamedDecl *ToD;
6227 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6228 return std::move(Err);
6229 if (ToD)
6230 return ToD;
6231
6232 // Should check if a declaration is friend in a dependent context.
6233 // Such templates are not linked together in a declaration chain.
6234 // The ASTImporter strategy is to map existing forward declarations to
6235 // imported ones only if strictly necessary, otherwise import these as new
6236 // forward declarations. In case of the "dependent friend" declarations, new
6237 // declarations are created, but not linked in a declaration chain.
6238 auto IsDependentFriend = [](ClassTemplateDecl *TD) {
6239 return TD->getFriendObjectKind() != Decl::FOK_None &&
6240 TD->getLexicalDeclContext()->isDependentContext();
6241 };
6242 bool DependentFriend = IsDependentFriend(D);
6243
6244 ClassTemplateDecl *FoundByLookup = nullptr;
6245
6246 // We may already have a template of the same name; try to find and match it.
6247 if (!DC->isFunctionOrMethod()) {
6248 SmallVector<NamedDecl *, 4> ConflictingDecls;
6249 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6250 for (auto *FoundDecl : FoundDecls) {
6251 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary |
6252 Decl::IDNS_TagFriend))
6253 continue;
6254
6255 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Val: FoundDecl);
6256 if (FoundTemplate) {
6257 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate, From: D))
6258 continue;
6259
6260 // FIXME: sufficient condition for 'IgnoreTemplateParmDepth'?
6261 bool IgnoreTemplateParmDepth =
6262 (FoundTemplate->getFriendObjectKind() != Decl::FOK_None) !=
6263 (D->getFriendObjectKind() != Decl::FOK_None);
6264 if (IsStructuralMatch(From: D, To: FoundTemplate, /*Complain=*/true,
6265 IgnoreTemplateParmDepth)) {
6266 if (DependentFriend || IsDependentFriend(FoundTemplate))
6267 continue;
6268
6269 ClassTemplateDecl *TemplateWithDef =
6270 getTemplateDefinition(D: FoundTemplate);
6271 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6272 return Importer.MapImported(From: D, To: TemplateWithDef);
6273 if (!FoundByLookup)
6274 FoundByLookup = FoundTemplate;
6275 // Search in all matches because there may be multiple decl chains,
6276 // see ASTTests test ImportExistingFriendClassTemplateDef.
6277 continue;
6278 }
6279 // When importing a friend, it is possible that multiple declarations
6280 // with same name can co-exist in specific cases (if a template contains
6281 // a friend template and has a specialization). For this case the
6282 // declarations should match, except that the "template depth" is
6283 // different. No linking of previous declaration is needed in this case.
6284 // FIXME: This condition may need refinement.
6285 if (D->getFriendObjectKind() != Decl::FOK_None &&
6286 FoundTemplate->getFriendObjectKind() != Decl::FOK_None &&
6287 D->getFriendObjectKind() != FoundTemplate->getFriendObjectKind() &&
6288 IsStructuralMatch(From: D, To: FoundTemplate, /*Complain=*/false,
6289 /*IgnoreTemplateParmDepth=*/true))
6290 continue;
6291
6292 ConflictingDecls.push_back(Elt: FoundDecl);
6293 }
6294 }
6295
6296 if (!ConflictingDecls.empty()) {
6297 ExpectedName NameOrErr = Importer.HandleNameConflict(
6298 Name, DC, IDNS: Decl::IDNS_Ordinary, Decls: ConflictingDecls.data(),
6299 NumDecls: ConflictingDecls.size());
6300 if (NameOrErr)
6301 Name = NameOrErr.get();
6302 else
6303 return NameOrErr.takeError();
6304 }
6305 }
6306
6307 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
6308
6309 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6310 if (!TemplateParamsOrErr)
6311 return TemplateParamsOrErr.takeError();
6312
6313 // Create the declaration that is being templated.
6314 CXXRecordDecl *ToTemplated;
6315 if (Error Err = importInto(To&: ToTemplated, From: FromTemplated))
6316 return std::move(Err);
6317
6318 // Create the class template declaration itself.
6319 ClassTemplateDecl *D2;
6320 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc, args&: Name,
6321 args&: *TemplateParamsOrErr, args&: ToTemplated))
6322 return D2;
6323
6324 ToTemplated->setDescribedClassTemplate(D2);
6325
6326 D2->setAccess(D->getAccess());
6327 D2->setLexicalDeclContext(LexicalDC);
6328
6329 addDeclToContexts(FromD: D, ToD: D2);
6330 updateLookupTableForTemplateParameters(Params&: **TemplateParamsOrErr);
6331
6332 if (FoundByLookup) {
6333 auto *Recent =
6334 const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6335
6336 // It is possible that during the import of the class template definition
6337 // we start the import of a fwd friend decl of the very same class template
6338 // and we add the fwd friend decl to the lookup table. But the ToTemplated
6339 // had been created earlier and by that time the lookup could not find
6340 // anything existing, so it has no previous decl. Later, (still during the
6341 // import of the fwd friend decl) we start to import the definition again
6342 // and this time the lookup finds the previous fwd friend class template.
6343 // In this case we must set up the previous decl for the templated decl.
6344 if (!ToTemplated->getPreviousDecl()) {
6345 assert(FoundByLookup->getTemplatedDecl() &&
6346 "Found decl must have its templated decl set");
6347 CXXRecordDecl *PrevTemplated =
6348 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6349 if (ToTemplated != PrevTemplated)
6350 ToTemplated->setPreviousDecl(PrevTemplated);
6351 }
6352
6353 D2->setPreviousDecl(Recent);
6354 }
6355
6356 return D2;
6357}
6358
6359ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
6360 ClassTemplateSpecializationDecl *D) {
6361 ClassTemplateDecl *ClassTemplate;
6362 if (Error Err = importInto(To&: ClassTemplate, From: D->getSpecializedTemplate()))
6363 return std::move(Err);
6364
6365 // Import the context of this declaration.
6366 DeclContext *DC, *LexicalDC;
6367 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6368 return std::move(Err);
6369
6370 // Import template arguments.
6371 SmallVector<TemplateArgument, 2> TemplateArgs;
6372 if (Error Err =
6373 ImportTemplateArguments(FromArgs: D->getTemplateArgs().asArray(), ToArgs&: TemplateArgs))
6374 return std::move(Err);
6375 // Try to find an existing specialization with these template arguments and
6376 // template parameter list.
6377 llvm::FoldingSetInsertToken InsertToken;
6378 ClassTemplateSpecializationDecl *PrevDecl = nullptr;
6379 ClassTemplatePartialSpecializationDecl *PartialSpec =
6380 dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: D);
6381
6382 // Import template parameters.
6383 TemplateParameterList *ToTPList = nullptr;
6384
6385 if (PartialSpec) {
6386 auto ToTPListOrErr = import(From: PartialSpec->getTemplateParameters());
6387 if (!ToTPListOrErr)
6388 return ToTPListOrErr.takeError();
6389 ToTPList = *ToTPListOrErr;
6390 PrevDecl = ClassTemplate->findPartialSpecialization(
6391 Args: TemplateArgs, TPL: *ToTPListOrErr, InsertToken);
6392 } else
6393 PrevDecl = ClassTemplate->findSpecialization(Args: TemplateArgs, InsertToken);
6394
6395 if (PrevDecl) {
6396 if (IsStructuralMatch(From: D, To: PrevDecl)) {
6397 CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
6398 if (D->isThisDeclarationADefinition() && PrevDefinition) {
6399 Importer.MapImported(From: D, To: PrevDefinition);
6400 // Import those default field initializers which have been
6401 // instantiated in the "From" context, but not in the "To" context.
6402 for (auto *FromField : D->fields()) {
6403 auto ToOrErr = import(From: FromField);
6404 if (!ToOrErr)
6405 return ToOrErr.takeError();
6406 }
6407
6408 // Import those methods which have been instantiated in the
6409 // "From" context, but not in the "To" context.
6410 for (CXXMethodDecl *FromM : D->methods()) {
6411 auto ToOrErr = import(From: FromM);
6412 if (!ToOrErr)
6413 return ToOrErr.takeError();
6414 }
6415
6416 // TODO Import instantiated default arguments.
6417 // TODO Import instantiated exception specifications.
6418 //
6419 // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
6420 // what else could be fused during an AST merge.
6421 return PrevDefinition;
6422 }
6423 } else { // ODR violation.
6424 // FIXME HandleNameConflict
6425 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6426 }
6427 }
6428
6429 // Import the location of this declaration.
6430 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6431 if (!BeginLocOrErr)
6432 return BeginLocOrErr.takeError();
6433 ExpectedSLoc IdLocOrErr = import(From: D->getLocation());
6434 if (!IdLocOrErr)
6435 return IdLocOrErr.takeError();
6436
6437 // Import TemplateArgumentListInfo.
6438 TemplateArgumentListInfo ToTAInfo;
6439 if (const auto *ASTTemplateArgs = D->getTemplateArgsAsWritten()) {
6440 if (Error Err = ImportTemplateArgumentListInfo(From: *ASTTemplateArgs, Result&: ToTAInfo))
6441 return std::move(Err);
6442 }
6443
6444 // Create the specialization.
6445 ClassTemplateSpecializationDecl *D2 = nullptr;
6446 if (PartialSpec) {
6447 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
6448 ToD&: D2, FromD: D, args&: Importer.getToContext(), args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr,
6449 args&: *IdLocOrErr, args&: ToTPList, args&: ClassTemplate, args: ArrayRef(TemplateArgs),
6450 /*CanonInjectedTST=*/args: CanQualType(),
6451 args: cast_or_null<ClassTemplatePartialSpecializationDecl>(Val: PrevDecl)))
6452 return D2;
6453
6454 // Update InsertToken, because preceding import calls may have invalidated
6455 // it by adding new specializations.
6456 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(Val: D2);
6457 if (!ClassTemplate->findPartialSpecialization(Args: TemplateArgs, TPL: ToTPList,
6458 InsertToken))
6459 // Add this partial specialization to the class template.
6460 ClassTemplate->AddPartialSpecialization(D: PartSpec2, InsertToken);
6461 if (Expected<ClassTemplatePartialSpecializationDecl *> ToInstOrErr =
6462 import(From: PartialSpec->getInstantiatedFromMember()))
6463 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6464 else
6465 return ToInstOrErr.takeError();
6466
6467 updateLookupTableForTemplateParameters(Params&: *ToTPList);
6468 } else { // Not a partial specialization.
6469 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args: D->getTagKind(),
6470 args&: DC, args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: ClassTemplate,
6471 args&: TemplateArgs, args: D->hasStrictPackMatch(),
6472 args&: PrevDecl))
6473 return D2;
6474
6475 // Update InsertToken, because preceding import calls may have invalidated
6476 // it by adding new specializations.
6477 if (!ClassTemplate->findSpecialization(Args: TemplateArgs, InsertToken))
6478 // Add this specialization to the class template.
6479 ClassTemplate->AddSpecialization(D: D2, InsertToken);
6480 }
6481
6482 D2->setSpecializationKind(D->getSpecializationKind());
6483
6484 // Set the context of this specialization/instantiation.
6485 D2->setLexicalDeclContext(LexicalDC);
6486
6487 // Add to the DC only if it was an explicit specialization/instantiation.
6488 if (D2->isExplicitInstantiationOrSpecialization()) {
6489 LexicalDC->addDeclInternal(D: D2);
6490 }
6491
6492 if (auto BraceRangeOrErr = import(From: D->getBraceRange()))
6493 D2->setBraceRange(*BraceRangeOrErr);
6494 else
6495 return BraceRangeOrErr.takeError();
6496
6497 if (Error Err = ImportTemplateParameterLists(FromD: D, ToD: D2))
6498 return std::move(Err);
6499
6500 // Import the qualifier, if any.
6501 if (auto LocOrErr = import(From: D->getQualifierLoc()))
6502 D2->setQualifierInfo(*LocOrErr);
6503 else
6504 return LocOrErr.takeError();
6505
6506 if (D->getTemplateArgsAsWritten())
6507 D2->setTemplateArgsAsWritten(ToTAInfo);
6508
6509 if (auto LocOrErr = import(From: D->getTemplateKeywordLoc()))
6510 D2->setTemplateKeywordLoc(*LocOrErr);
6511 else
6512 return LocOrErr.takeError();
6513
6514 if (auto LocOrErr = import(From: D->getExternKeywordLoc()))
6515 D2->setExternKeywordLoc(*LocOrErr);
6516 else
6517 return LocOrErr.takeError();
6518
6519 if (D->getPointOfInstantiation().isValid()) {
6520 if (auto POIOrErr = import(From: D->getPointOfInstantiation()))
6521 D2->setPointOfInstantiation(*POIOrErr);
6522 else
6523 return POIOrErr.takeError();
6524 }
6525
6526 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
6527
6528 if (auto P = D->getInstantiatedFrom()) {
6529 if (auto *CTD = dyn_cast<ClassTemplateDecl *>(Val&: P)) {
6530 if (auto CTDorErr = import(From: CTD))
6531 D2->setInstantiationOf(*CTDorErr);
6532 } else {
6533 auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(Val&: P);
6534 auto CTPSDOrErr = import(From: CTPSD);
6535 if (!CTPSDOrErr)
6536 return CTPSDOrErr.takeError();
6537 const TemplateArgumentList &DArgs = D->getTemplateInstantiationArgs();
6538 SmallVector<TemplateArgument, 2> D2ArgsVec(DArgs.size());
6539 for (unsigned I = 0; I < DArgs.size(); ++I) {
6540 const TemplateArgument &DArg = DArgs[I];
6541 if (auto ArgOrErr = import(From: DArg))
6542 D2ArgsVec[I] = *ArgOrErr;
6543 else
6544 return ArgOrErr.takeError();
6545 }
6546 D2->setInstantiationOf(
6547 PartialSpec: *CTPSDOrErr,
6548 TemplateArgs: TemplateArgumentList::CreateCopy(Context&: Importer.getToContext(), Args: D2ArgsVec));
6549 }
6550 }
6551
6552 if (D->isCompleteDefinition())
6553 if (Error Err = ImportDefinition(From: D, To: D2))
6554 return std::move(Err);
6555
6556 return D2;
6557}
6558
6559ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
6560 // Import the major distinguishing characteristics of this variable template.
6561 DeclContext *DC, *LexicalDC;
6562 DeclarationName Name;
6563 SourceLocation Loc;
6564 NamedDecl *ToD;
6565 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6566 return std::move(Err);
6567 if (ToD)
6568 return ToD;
6569
6570 // We may already have a template of the same name; try to find and match it.
6571 assert(!DC->isFunctionOrMethod() &&
6572 "Variable templates cannot be declared at function scope");
6573
6574 SmallVector<NamedDecl *, 4> ConflictingDecls;
6575 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6576 VarTemplateDecl *FoundByLookup = nullptr;
6577 for (auto *FoundDecl : FoundDecls) {
6578 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary))
6579 continue;
6580
6581 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Val: FoundDecl)) {
6582 // Use the templated decl, some linkage flags are set only there.
6583 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate->getTemplatedDecl(),
6584 From: D->getTemplatedDecl()))
6585 continue;
6586 if (IsStructuralMatch(From: D, To: FoundTemplate)) {
6587 // FIXME Check for ODR error if the two definitions have
6588 // different initializers?
6589 VarTemplateDecl *FoundDef = getTemplateDefinition(D: FoundTemplate);
6590 if (D->getDeclContext()->isRecord()) {
6591 assert(FoundTemplate->getDeclContext()->isRecord() &&
6592 "Member variable template imported as non-member, "
6593 "inconsistent imported AST?");
6594 if (FoundDef)
6595 return Importer.MapImported(From: D, To: FoundDef);
6596 if (!D->isThisDeclarationADefinition())
6597 return Importer.MapImported(From: D, To: FoundTemplate);
6598 } else {
6599 if (FoundDef && D->isThisDeclarationADefinition())
6600 return Importer.MapImported(From: D, To: FoundDef);
6601 }
6602 FoundByLookup = FoundTemplate;
6603 break;
6604 }
6605 ConflictingDecls.push_back(Elt: FoundDecl);
6606 }
6607 }
6608
6609 if (!ConflictingDecls.empty()) {
6610 ExpectedName NameOrErr = Importer.HandleNameConflict(
6611 Name, DC, IDNS: Decl::IDNS_Ordinary, Decls: ConflictingDecls.data(),
6612 NumDecls: ConflictingDecls.size());
6613 if (NameOrErr)
6614 Name = NameOrErr.get();
6615 else
6616 return NameOrErr.takeError();
6617 }
6618
6619 VarDecl *DTemplated = D->getTemplatedDecl();
6620
6621 // Import the type.
6622 // FIXME: Value not used?
6623 ExpectedType TypeOrErr = import(From: DTemplated->getType());
6624 if (!TypeOrErr)
6625 return TypeOrErr.takeError();
6626
6627 // Create the declaration that is being templated.
6628 VarDecl *ToTemplated;
6629 if (Error Err = importInto(To&: ToTemplated, From: DTemplated))
6630 return std::move(Err);
6631
6632 // Create the variable template declaration itself.
6633 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6634 if (!TemplateParamsOrErr)
6635 return TemplateParamsOrErr.takeError();
6636
6637 VarTemplateDecl *ToVarTD;
6638 if (GetImportedOrCreateDecl(ToD&: ToVarTD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
6639 args&: Name, args&: *TemplateParamsOrErr, args&: ToTemplated))
6640 return ToVarTD;
6641
6642 ToTemplated->setDescribedVarTemplate(ToVarTD);
6643
6644 ToVarTD->setAccess(D->getAccess());
6645 ToVarTD->setLexicalDeclContext(LexicalDC);
6646 LexicalDC->addDeclInternal(D: ToVarTD);
6647 if (DC != Importer.getToContext().getTranslationUnitDecl())
6648 updateLookupTableForTemplateParameters(Params&: **TemplateParamsOrErr);
6649
6650 if (FoundByLookup) {
6651 auto *Recent =
6652 const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6653 if (!ToTemplated->getPreviousDecl()) {
6654 auto *PrevTemplated =
6655 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6656 if (ToTemplated != PrevTemplated)
6657 ToTemplated->setPreviousDecl(PrevTemplated);
6658 }
6659 ToVarTD->setPreviousDecl(Recent);
6660 }
6661
6662 return ToVarTD;
6663}
6664
6665ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
6666 VarTemplateSpecializationDecl *D) {
6667 // A VarTemplateSpecializationDecl inherits from VarDecl, the import is done
6668 // in an analog way (but specialized for this case).
6669
6670 SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
6671 auto RedeclIt = Redecls.begin();
6672 // Import the first part of the decl chain. I.e. import all previous
6673 // declarations starting from the canonical decl.
6674 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
6675 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
6676 if (!RedeclOrErr)
6677 return RedeclOrErr.takeError();
6678 }
6679 assert(*RedeclIt == D);
6680
6681 VarTemplateDecl *VarTemplate = nullptr;
6682 if (Error Err = importInto(To&: VarTemplate, From: D->getSpecializedTemplate()))
6683 return std::move(Err);
6684
6685 // Import the context of this declaration.
6686 DeclContext *DC, *LexicalDC;
6687 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6688 return std::move(Err);
6689
6690 // Import the location of this declaration.
6691 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6692 if (!BeginLocOrErr)
6693 return BeginLocOrErr.takeError();
6694
6695 auto IdLocOrErr = import(From: D->getLocation());
6696 if (!IdLocOrErr)
6697 return IdLocOrErr.takeError();
6698
6699 // Import template arguments.
6700 SmallVector<TemplateArgument, 2> TemplateArgs;
6701 if (Error Err =
6702 ImportTemplateArguments(FromArgs: D->getTemplateArgs().asArray(), ToArgs&: TemplateArgs))
6703 return std::move(Err);
6704
6705 // Try to find an existing specialization with these template arguments.
6706 llvm::FoldingSetInsertToken InsertToken;
6707 VarTemplateSpecializationDecl *FoundSpecialization =
6708 VarTemplate->findSpecialization(Args: TemplateArgs, InsertToken);
6709 if (FoundSpecialization) {
6710 if (IsStructuralMatch(From: D, To: FoundSpecialization)) {
6711 VarDecl *FoundDef = FoundSpecialization->getDefinition();
6712 if (D->getDeclContext()->isRecord()) {
6713 // In a record, it is allowed only to have one optional declaration and
6714 // one definition of the (static or constexpr) variable template.
6715 assert(
6716 FoundSpecialization->getDeclContext()->isRecord() &&
6717 "Member variable template specialization imported as non-member, "
6718 "inconsistent imported AST?");
6719 if (FoundDef)
6720 return Importer.MapImported(From: D, To: FoundDef);
6721 if (!D->isThisDeclarationADefinition())
6722 return Importer.MapImported(From: D, To: FoundSpecialization);
6723 } else {
6724 // If definition is imported and there is already one, map to it.
6725 // Otherwise create a new variable and link it to the existing.
6726 if (FoundDef && D->isThisDeclarationADefinition())
6727 return Importer.MapImported(From: D, To: FoundDef);
6728 }
6729 } else {
6730 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6731 }
6732 }
6733
6734 VarTemplateSpecializationDecl *D2 = nullptr;
6735
6736 TemplateArgumentListInfo ToTAInfo;
6737 if (const auto *Args = D->getTemplateArgsAsWritten()) {
6738 if (Error Err = ImportTemplateArgumentListInfo(From: *Args, Result&: ToTAInfo))
6739 return std::move(Err);
6740 }
6741
6742 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
6743 // Create a new specialization.
6744 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(Val: D)) {
6745 auto ToTPListOrErr = import(From: FromPartial->getTemplateParameters());
6746 if (!ToTPListOrErr)
6747 return ToTPListOrErr.takeError();
6748
6749 PartVarSpecDecl *ToPartial;
6750 if (GetImportedOrCreateDecl(ToD&: ToPartial, FromD: D, args&: Importer.getToContext(), args&: DC,
6751 args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: *ToTPListOrErr,
6752 args&: VarTemplate, args: QualType(), args: nullptr,
6753 args: D->getStorageClass(), args&: TemplateArgs))
6754 return ToPartial;
6755
6756 if (Expected<PartVarSpecDecl *> ToInstOrErr =
6757 import(From: FromPartial->getInstantiatedFromMember()))
6758 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
6759 else
6760 return ToInstOrErr.takeError();
6761
6762 if (FromPartial->isMemberSpecialization())
6763 ToPartial->setMemberSpecialization();
6764
6765 D2 = ToPartial;
6766
6767 // FIXME: Use this update if VarTemplatePartialSpecializationDecl is fixed
6768 // to adopt template parameters.
6769 // updateLookupTableForTemplateParameters(**ToTPListOrErr);
6770 } else { // Full specialization
6771 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC,
6772 args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: VarTemplate,
6773 args: QualType(), args: nullptr, args: D->getStorageClass(),
6774 args&: TemplateArgs))
6775 return D2;
6776 }
6777
6778 // Update InsertToken, because preceding import calls may have invalidated
6779 // it by adding new specializations.
6780 if (!VarTemplate->findSpecialization(Args: TemplateArgs, InsertToken))
6781 VarTemplate->AddSpecialization(D: D2, InsertToken);
6782
6783 QualType T;
6784 if (Error Err = importInto(To&: T, From: D->getType()))
6785 return std::move(Err);
6786 D2->setType(T);
6787
6788 auto TInfoOrErr = import(From: D->getTypeSourceInfo());
6789 if (!TInfoOrErr)
6790 return TInfoOrErr.takeError();
6791 D2->setTypeSourceInfo(*TInfoOrErr);
6792
6793 if (D->getPointOfInstantiation().isValid()) {
6794 if (ExpectedSLoc POIOrErr = import(From: D->getPointOfInstantiation()))
6795 D2->setPointOfInstantiation(*POIOrErr);
6796 else
6797 return POIOrErr.takeError();
6798 }
6799
6800 D2->setSpecializationKind(D->getSpecializationKind());
6801
6802 if (D->getTemplateArgsAsWritten())
6803 D2->setTemplateArgsAsWritten(ToTAInfo);
6804
6805 if (auto LocOrErr = import(From: D->getQualifierLoc()))
6806 D2->setQualifierInfo(*LocOrErr);
6807 else
6808 return LocOrErr.takeError();
6809
6810 if (D->isConstexpr())
6811 D2->setConstexpr(true);
6812
6813 D2->setAccess(D->getAccess());
6814
6815 if (Error Err = ImportInitializer(From: D, To: D2))
6816 return std::move(Err);
6817
6818 if (FoundSpecialization)
6819 D2->setPreviousDecl(FoundSpecialization->getMostRecentDecl());
6820
6821 addDeclToContexts(FromD: D, ToD: D2);
6822
6823 // Import the rest of the chain. I.e. import all subsequent declarations.
6824 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
6825 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
6826 if (!RedeclOrErr)
6827 return RedeclOrErr.takeError();
6828 }
6829
6830 return D2;
6831}
6832
6833ExpectedDecl
6834ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
6835 DeclContext *DC, *LexicalDC;
6836 DeclarationName Name;
6837 SourceLocation Loc;
6838 NamedDecl *ToD;
6839
6840 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6841 return std::move(Err);
6842
6843 if (ToD)
6844 return ToD;
6845
6846 const FunctionTemplateDecl *FoundByLookup = nullptr;
6847
6848 // Try to find a function in our own ("to") context with the same name, same
6849 // type, and in the same context as the function we're importing.
6850 // FIXME Split this into a separate function.
6851 if (!LexicalDC->isFunctionOrMethod()) {
6852 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
6853 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6854 for (auto *FoundDecl : FoundDecls) {
6855 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
6856 continue;
6857
6858 if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(Val: FoundDecl)) {
6859 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate, From: D))
6860 continue;
6861 if (IsStructuralMatch(From: D, To: FoundTemplate)) {
6862 FunctionTemplateDecl *TemplateWithDef =
6863 getTemplateDefinition(D: FoundTemplate);
6864 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6865 return Importer.MapImported(From: D, To: TemplateWithDef);
6866
6867 FoundByLookup = FoundTemplate;
6868 break;
6869 // TODO: handle conflicting names
6870 }
6871 }
6872 }
6873 }
6874
6875 auto ParamsOrErr = import(From: D->getTemplateParameters());
6876 if (!ParamsOrErr)
6877 return ParamsOrErr.takeError();
6878 TemplateParameterList *Params = *ParamsOrErr;
6879
6880 FunctionDecl *TemplatedFD;
6881 if (Error Err = importInto(To&: TemplatedFD, From: D->getTemplatedDecl()))
6882 return std::move(Err);
6883
6884 // At creation of the template the template parameters are "adopted"
6885 // (DeclContext is changed). After this possible change the lookup table
6886 // must be updated.
6887 // At deduction guides the DeclContext of the template parameters may be
6888 // different from what we would expect, it may be the class template, or a
6889 // probably different CXXDeductionGuideDecl. This may come from the fact that
6890 // the template parameter objects may be shared between deduction guides or
6891 // the class template, and at creation of multiple FunctionTemplateDecl
6892 // objects (for deduction guides) the same parameters are re-used. The
6893 // "adoption" happens multiple times with different parent, even recursively
6894 // for TemplateTemplateParmDecl. The same happens at import when the
6895 // FunctionTemplateDecl objects are created, but in different order.
6896 // In this way the DeclContext of these template parameters is not necessarily
6897 // the same as in the "from" context.
6898 SmallVector<DeclContext *, 2> OldParamDC;
6899 OldParamDC.reserve(N: Params->size());
6900 llvm::transform(Range&: *Params, d_first: std::back_inserter(x&: OldParamDC),
6901 F: [](NamedDecl *ND) { return ND->getDeclContext(); });
6902
6903 FunctionTemplateDecl *ToFunc;
6904 if (GetImportedOrCreateDecl(ToD&: ToFunc, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc, args&: Name,
6905 args&: Params, args&: TemplatedFD))
6906 return ToFunc;
6907
6908 // Fail if TemplatedFD is already part of a template.
6909 // The template should have been found by structural equivalence check before,
6910 // or ToFunc should be already imported.
6911 // If not, there is AST incompatibility that can be caused by previous import
6912 // errors. (NameConflict is not exact here.)
6913 if (TemplatedFD->getDescribedTemplate())
6914 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6915
6916 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
6917
6918 ToFunc->setAccess(D->getAccess());
6919 ToFunc->setLexicalDeclContext(LexicalDC);
6920 addDeclToContexts(FromD: D, ToD: ToFunc);
6921
6922 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
6923 if (LT && !OldParamDC.empty()) {
6924 for (unsigned int I = 0; I < OldParamDC.size(); ++I)
6925 LT->updateForced(ND: Params->getParam(Idx: I), OldDC: OldParamDC[I]);
6926 }
6927
6928 if (FoundByLookup) {
6929 auto *Recent =
6930 const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6931 if (!TemplatedFD->getPreviousDecl()) {
6932 assert(FoundByLookup->getTemplatedDecl() &&
6933 "Found decl must have its templated decl set");
6934 auto *PrevTemplated =
6935 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6936 if (TemplatedFD != PrevTemplated)
6937 TemplatedFD->setPreviousDecl(PrevTemplated);
6938 }
6939 ToFunc->setPreviousDecl(Recent);
6940 }
6941
6942 return ToFunc;
6943}
6944
6945ExpectedDecl ASTNodeImporter::VisitConceptDecl(ConceptDecl *D) {
6946 DeclContext *DC, *LexicalDC;
6947 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6948 auto LocationOrErr = importChecked(Err, From: D->getLocation());
6949 auto NameDeclOrErr = importChecked(Err, From: D->getDeclName());
6950 auto ToTemplateParameters = importChecked(Err, From: D->getTemplateParameters());
6951 auto ConstraintExpr = importChecked(Err, From: D->getConstraintExpr());
6952 if (Err)
6953 return std::move(Err);
6954
6955 ConceptDecl *To;
6956 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: LocationOrErr,
6957 args&: NameDeclOrErr, args&: ToTemplateParameters,
6958 args&: ConstraintExpr))
6959 return To;
6960 To->setLexicalDeclContext(LexicalDC);
6961 LexicalDC->addDeclInternal(D: To);
6962 return To;
6963}
6964
6965ExpectedDecl
6966ASTNodeImporter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
6967 DeclContext *DC, *LexicalDC;
6968 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6969 auto RequiresLoc = importChecked(Err, From: D->getLocation());
6970 if (Err)
6971 return std::move(Err);
6972
6973 RequiresExprBodyDecl *To;
6974 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: RequiresLoc))
6975 return To;
6976 To->setLexicalDeclContext(LexicalDC);
6977 LexicalDC->addDeclInternal(D: To);
6978 return To;
6979}
6980
6981ExpectedDecl ASTNodeImporter::VisitImplicitConceptSpecializationDecl(
6982 ImplicitConceptSpecializationDecl *D) {
6983 DeclContext *DC, *LexicalDC;
6984 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6985 auto ToSL = importChecked(Err, From: D->getLocation());
6986 if (Err)
6987 return std::move(Err);
6988
6989 SmallVector<TemplateArgument, 2> ToArgs(D->getTemplateArguments().size());
6990 if (Error Err = ImportTemplateArguments(FromArgs: D->getTemplateArguments(), ToArgs))
6991 return std::move(Err);
6992
6993 ImplicitConceptSpecializationDecl *To;
6994 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToSL, args&: ToArgs))
6995 return To;
6996 To->setLexicalDeclContext(LexicalDC);
6997 LexicalDC->addDeclInternal(D: To);
6998 return To;
6999}
7000
7001//----------------------------------------------------------------------------
7002// Import Statements
7003//----------------------------------------------------------------------------
7004
7005ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
7006 Importer.FromDiag(Loc: S->getBeginLoc(), DiagID: diag::err_unsupported_ast_node)
7007 << S->getStmtClassName();
7008 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7009}
7010
7011
7012ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
7013 if (Importer.returnWithErrorInTest())
7014 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7015 SmallVector<IdentifierInfo *, 4> Names;
7016 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
7017 IdentifierInfo *ToII = Importer.Import(FromId: S->getOutputIdentifier(i: I));
7018 // ToII is nullptr when no symbolic name is given for output operand
7019 // see ParseStmtAsm::ParseAsmOperandsOpt
7020 Names.push_back(Elt: ToII);
7021 }
7022
7023 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
7024 IdentifierInfo *ToII = Importer.Import(FromId: S->getInputIdentifier(i: I));
7025 // ToII is nullptr when no symbolic name is given for input operand
7026 // see ParseStmtAsm::ParseAsmOperandsOpt
7027 Names.push_back(Elt: ToII);
7028 }
7029
7030 SmallVector<Expr *, 4> Clobbers;
7031 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
7032 if (auto ClobberOrErr = import(From: S->getClobberExpr(i: I)))
7033 Clobbers.push_back(Elt: *ClobberOrErr);
7034 else
7035 return ClobberOrErr.takeError();
7036
7037 }
7038
7039 SmallVector<Expr *, 4> Constraints;
7040 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
7041 if (auto OutputOrErr = import(From: S->getOutputConstraintExpr(i: I)))
7042 Constraints.push_back(Elt: *OutputOrErr);
7043 else
7044 return OutputOrErr.takeError();
7045 }
7046
7047 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
7048 if (auto InputOrErr = import(From: S->getInputConstraintExpr(i: I)))
7049 Constraints.push_back(Elt: *InputOrErr);
7050 else
7051 return InputOrErr.takeError();
7052 }
7053
7054 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
7055 S->getNumLabels());
7056 if (Error Err = ImportContainerChecked(InContainer: S->outputs(), OutContainer&: Exprs))
7057 return std::move(Err);
7058
7059 if (Error Err =
7060 ImportArrayChecked(InContainer: S->inputs(), Obegin: Exprs.begin() + S->getNumOutputs()))
7061 return std::move(Err);
7062
7063 if (Error Err = ImportArrayChecked(
7064 InContainer: S->labels(), Obegin: Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
7065 return std::move(Err);
7066
7067 ExpectedSLoc AsmLocOrErr = import(From: S->getAsmLoc());
7068 if (!AsmLocOrErr)
7069 return AsmLocOrErr.takeError();
7070 auto AsmStrOrErr = import(From: S->getAsmStringExpr());
7071 if (!AsmStrOrErr)
7072 return AsmStrOrErr.takeError();
7073 ExpectedSLoc RParenLocOrErr = import(From: S->getRParenLoc());
7074 if (!RParenLocOrErr)
7075 return RParenLocOrErr.takeError();
7076
7077 return new (Importer.getToContext()) GCCAsmStmt(
7078 Importer.getToContext(),
7079 *AsmLocOrErr,
7080 S->isSimple(),
7081 S->isVolatile(),
7082 S->getNumOutputs(),
7083 S->getNumInputs(),
7084 Names.data(),
7085 Constraints.data(),
7086 Exprs.data(),
7087 *AsmStrOrErr,
7088 S->getNumClobbers(),
7089 Clobbers.data(),
7090 S->getNumLabels(),
7091 *RParenLocOrErr);
7092}
7093
7094ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
7095
7096 Error Err = Error::success();
7097 auto ToDG = importChecked(Err, From: S->getDeclGroup());
7098 auto ToBeginLoc = importChecked(Err, From: S->getBeginLoc());
7099 auto ToEndLoc = importChecked(Err, From: S->getEndLoc());
7100 if (Err)
7101 return std::move(Err);
7102 return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
7103}
7104
7105ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
7106 ExpectedSLoc ToSemiLocOrErr = import(From: S->getSemiLoc());
7107 if (!ToSemiLocOrErr)
7108 return ToSemiLocOrErr.takeError();
7109 return new (Importer.getToContext()) NullStmt(
7110 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
7111}
7112
7113ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
7114 SmallVector<Stmt *, 8> ToStmts(S->size());
7115
7116 if (Error Err = ImportContainerChecked(InContainer: S->body(), OutContainer&: ToStmts))
7117 return std::move(Err);
7118
7119 ExpectedSLoc ToLBracLocOrErr = import(From: S->getLBracLoc());
7120 if (!ToLBracLocOrErr)
7121 return ToLBracLocOrErr.takeError();
7122
7123 ExpectedSLoc ToRBracLocOrErr = import(From: S->getRBracLoc());
7124 if (!ToRBracLocOrErr)
7125 return ToRBracLocOrErr.takeError();
7126
7127 FPOptionsOverride FPO =
7128 S->hasStoredFPFeatures() ? S->getStoredFPFeatures() : FPOptionsOverride();
7129 return CompoundStmt::Create(C: Importer.getToContext(), Stmts: ToStmts, FPFeatures: FPO,
7130 LB: *ToLBracLocOrErr, RB: *ToRBracLocOrErr);
7131}
7132
7133ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
7134
7135 Error Err = Error::success();
7136 auto ToLHS = importChecked(Err, From: S->getLHS());
7137 auto ToRHS = importChecked(Err, From: S->getRHS());
7138 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7139 auto ToCaseLoc = importChecked(Err, From: S->getCaseLoc());
7140 auto ToEllipsisLoc = importChecked(Err, From: S->getEllipsisLoc());
7141 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7142 if (Err)
7143 return std::move(Err);
7144
7145 auto *ToStmt = CaseStmt::Create(Ctx: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS,
7146 caseLoc: ToCaseLoc, ellipsisLoc: ToEllipsisLoc, colonLoc: ToColonLoc);
7147 ToStmt->setSubStmt(ToSubStmt);
7148
7149 return ToStmt;
7150}
7151
7152ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
7153
7154 Error Err = Error::success();
7155 auto ToDefaultLoc = importChecked(Err, From: S->getDefaultLoc());
7156 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7157 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7158 if (Err)
7159 return std::move(Err);
7160
7161 return new (Importer.getToContext()) DefaultStmt(
7162 ToDefaultLoc, ToColonLoc, ToSubStmt);
7163}
7164
7165ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
7166
7167 Error Err = Error::success();
7168 auto ToIdentLoc = importChecked(Err, From: S->getIdentLoc());
7169 auto ToLabelDecl = importChecked(Err, From: S->getDecl());
7170 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7171 if (Err)
7172 return std::move(Err);
7173
7174 return new (Importer.getToContext()) LabelStmt(
7175 ToIdentLoc, ToLabelDecl, ToSubStmt);
7176}
7177
7178ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
7179 ExpectedSLoc ToAttrLocOrErr = import(From: S->getAttrLoc());
7180 if (!ToAttrLocOrErr)
7181 return ToAttrLocOrErr.takeError();
7182 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
7183 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
7184 if (Error Err = ImportContainerChecked(InContainer: FromAttrs, OutContainer&: ToAttrs))
7185 return std::move(Err);
7186 ExpectedStmt ToSubStmtOrErr = import(From: S->getSubStmt());
7187 if (!ToSubStmtOrErr)
7188 return ToSubStmtOrErr.takeError();
7189
7190 return AttributedStmt::Create(
7191 C: Importer.getToContext(), Loc: *ToAttrLocOrErr, Attrs: ToAttrs, SubStmt: *ToSubStmtOrErr);
7192}
7193
7194ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
7195
7196 Error Err = Error::success();
7197 auto ToIfLoc = importChecked(Err, From: S->getIfLoc());
7198 auto ToInit = importChecked(Err, From: S->getInit());
7199 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7200 auto ToCond = importChecked(Err, From: S->getCond());
7201 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7202 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7203 auto ToThen = importChecked(Err, From: S->getThen());
7204 auto ToElseLoc = importChecked(Err, From: S->getElseLoc());
7205 auto ToElse = importChecked(Err, From: S->getElse());
7206 if (Err)
7207 return std::move(Err);
7208
7209 return IfStmt::Create(Ctx: Importer.getToContext(), IL: ToIfLoc, Kind: S->getStatementKind(),
7210 Init: ToInit, Var: ToConditionVariable, Cond: ToCond, LPL: ToLParenLoc,
7211 RPL: ToRParenLoc, Then: ToThen, EL: ToElseLoc, Else: ToElse);
7212}
7213
7214ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
7215
7216 Error Err = Error::success();
7217 auto ToInit = importChecked(Err, From: S->getInit());
7218 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7219 auto ToCond = importChecked(Err, From: S->getCond());
7220 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7221 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7222 auto ToBody = importChecked(Err, From: S->getBody());
7223 auto ToSwitchLoc = importChecked(Err, From: S->getSwitchLoc());
7224 if (Err)
7225 return std::move(Err);
7226
7227 auto *ToStmt =
7228 SwitchStmt::Create(Ctx: Importer.getToContext(), Init: ToInit, Var: ToConditionVariable,
7229 Cond: ToCond, LParenLoc: ToLParenLoc, RParenLoc: ToRParenLoc);
7230 ToStmt->setBody(ToBody);
7231 ToStmt->setSwitchLoc(ToSwitchLoc);
7232
7233 // Now we have to re-chain the cases.
7234 SwitchCase *LastChainedSwitchCase = nullptr;
7235 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
7236 SC = SC->getNextSwitchCase()) {
7237 Expected<SwitchCase *> ToSCOrErr = import(From: SC);
7238 if (!ToSCOrErr)
7239 return ToSCOrErr.takeError();
7240 if (LastChainedSwitchCase)
7241 LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
7242 else
7243 ToStmt->setSwitchCaseList(*ToSCOrErr);
7244 LastChainedSwitchCase = *ToSCOrErr;
7245 }
7246
7247 return ToStmt;
7248}
7249
7250ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
7251
7252 Error Err = Error::success();
7253 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7254 auto ToCond = importChecked(Err, From: S->getCond());
7255 auto ToBody = importChecked(Err, From: S->getBody());
7256 auto ToWhileLoc = importChecked(Err, From: S->getWhileLoc());
7257 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7258 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7259 if (Err)
7260 return std::move(Err);
7261
7262 return WhileStmt::Create(Ctx: Importer.getToContext(), Var: ToConditionVariable, Cond: ToCond,
7263 Body: ToBody, WL: ToWhileLoc, LParenLoc: ToLParenLoc, RParenLoc: ToRParenLoc);
7264}
7265
7266ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
7267
7268 Error Err = Error::success();
7269 auto ToBody = importChecked(Err, From: S->getBody());
7270 auto ToCond = importChecked(Err, From: S->getCond());
7271 auto ToDoLoc = importChecked(Err, From: S->getDoLoc());
7272 auto ToWhileLoc = importChecked(Err, From: S->getWhileLoc());
7273 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7274 if (Err)
7275 return std::move(Err);
7276
7277 return new (Importer.getToContext()) DoStmt(
7278 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
7279}
7280
7281ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
7282
7283 Error Err = Error::success();
7284 auto ToInit = importChecked(Err, From: S->getInit());
7285 auto ToCond = importChecked(Err, From: S->getCond());
7286 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7287 auto ToInc = importChecked(Err, From: S->getInc());
7288 auto ToBody = importChecked(Err, From: S->getBody());
7289 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7290 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7291 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7292 if (Err)
7293 return std::move(Err);
7294
7295 return new (Importer.getToContext()) ForStmt(
7296 Importer.getToContext(),
7297 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
7298 ToRParenLoc);
7299}
7300
7301ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
7302
7303 Error Err = Error::success();
7304 auto ToLabel = importChecked(Err, From: S->getLabel());
7305 auto ToGotoLoc = importChecked(Err, From: S->getGotoLoc());
7306 auto ToLabelLoc = importChecked(Err, From: S->getLabelLoc());
7307 if (Err)
7308 return std::move(Err);
7309
7310 return new (Importer.getToContext()) GotoStmt(
7311 ToLabel, ToGotoLoc, ToLabelLoc);
7312}
7313
7314ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
7315
7316 Error Err = Error::success();
7317 auto ToGotoLoc = importChecked(Err, From: S->getGotoLoc());
7318 auto ToStarLoc = importChecked(Err, From: S->getStarLoc());
7319 auto ToTarget = importChecked(Err, From: S->getTarget());
7320 if (Err)
7321 return std::move(Err);
7322
7323 return new (Importer.getToContext()) IndirectGotoStmt(
7324 ToGotoLoc, ToStarLoc, ToTarget);
7325}
7326
7327template <typename StmtClass>
7328static ExpectedStmt ImportLoopControlStmt(ASTNodeImporter &NodeImporter,
7329 ASTImporter &Importer, StmtClass *S) {
7330 Error Err = Error::success();
7331 auto ToLoc = NodeImporter.importChecked(Err, S->getKwLoc());
7332 auto ToLabelLoc = S->hasLabelTarget()
7333 ? NodeImporter.importChecked(Err, S->getLabelLoc())
7334 : SourceLocation();
7335 auto ToDecl = S->hasLabelTarget()
7336 ? NodeImporter.importChecked(Err, S->getLabelDecl())
7337 : nullptr;
7338 if (Err)
7339 return std::move(Err);
7340 return new (Importer.getToContext()) StmtClass(ToLoc, ToLabelLoc, ToDecl);
7341}
7342
7343ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
7344 return ImportLoopControlStmt(NodeImporter&: *this, Importer, S);
7345}
7346
7347ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
7348 return ImportLoopControlStmt(NodeImporter&: *this, Importer, S);
7349}
7350
7351ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
7352
7353 Error Err = Error::success();
7354 auto ToReturnLoc = importChecked(Err, From: S->getReturnLoc());
7355 auto ToRetValue = importChecked(Err, From: S->getRetValue());
7356 auto ToNRVOCandidate = importChecked(Err, From: S->getNRVOCandidate());
7357 if (Err)
7358 return std::move(Err);
7359
7360 return ReturnStmt::Create(Ctx: Importer.getToContext(), RL: ToReturnLoc, E: ToRetValue,
7361 NRVOCandidate: ToNRVOCandidate);
7362}
7363
7364ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
7365
7366 Error Err = Error::success();
7367 auto ToCatchLoc = importChecked(Err, From: S->getCatchLoc());
7368 auto ToExceptionDecl = importChecked(Err, From: S->getExceptionDecl());
7369 auto ToHandlerBlock = importChecked(Err, From: S->getHandlerBlock());
7370 if (Err)
7371 return std::move(Err);
7372
7373 return new (Importer.getToContext()) CXXCatchStmt (
7374 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7375}
7376
7377ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
7378 ExpectedSLoc ToTryLocOrErr = import(From: S->getTryLoc());
7379 if (!ToTryLocOrErr)
7380 return ToTryLocOrErr.takeError();
7381
7382 ExpectedStmt ToTryBlockOrErr = import(From: S->getTryBlock());
7383 if (!ToTryBlockOrErr)
7384 return ToTryBlockOrErr.takeError();
7385
7386 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
7387 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7388 CXXCatchStmt *FromHandler = S->getHandler(i: HI);
7389 if (auto ToHandlerOrErr = import(From: FromHandler))
7390 ToHandlers[HI] = *ToHandlerOrErr;
7391 else
7392 return ToHandlerOrErr.takeError();
7393 }
7394
7395 return CXXTryStmt::Create(C: Importer.getToContext(), tryLoc: *ToTryLocOrErr,
7396 tryBlock: cast<CompoundStmt>(Val: *ToTryBlockOrErr), handlers: ToHandlers);
7397}
7398
7399ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
7400
7401 Error Err = Error::success();
7402 auto ToInit = importChecked(Err, From: S->getInit());
7403 auto ToRangeStmt = importChecked(Err, From: S->getRangeStmt());
7404 auto ToBeginStmt = importChecked(Err, From: S->getBeginStmt());
7405 auto ToEndStmt = importChecked(Err, From: S->getEndStmt());
7406 auto ToCond = importChecked(Err, From: S->getCond());
7407 auto ToInc = importChecked(Err, From: S->getInc());
7408 auto ToLoopVarStmt = importChecked(Err, From: S->getLoopVarStmt());
7409 auto ToBody = importChecked(Err, From: S->getBody());
7410 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7411 auto ToCoawaitLoc = importChecked(Err, From: S->getCoawaitLoc());
7412 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7413 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7414 if (Err)
7415 return std::move(Err);
7416
7417 return new (Importer.getToContext()) CXXForRangeStmt(
7418 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7419 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7420}
7421
7422ExpectedStmt
7423ASTNodeImporter::VisitCXXExpansionStmtPattern(CXXExpansionStmtPattern *S) {
7424 Error Err = Error::success();
7425 auto ToESD = importChecked(Err, From: S->getDecl());
7426 auto ToInit = importChecked(Err, From: S->getInit());
7427 auto ToExpansionVar = importChecked(Err, From: S->getExpansionVarStmt());
7428 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7429 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7430 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7431 if (Err)
7432 return std::move(Err);
7433
7434 switch (S->getKind()) {
7435 case CXXExpansionStmtPattern::ExpansionStmtKind::Enumerating:
7436 return CXXExpansionStmtPattern::CreateEnumerating(
7437 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar, LParenLoc: ToLParenLoc,
7438 ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7439
7440 case CXXExpansionStmtPattern::ExpansionStmtKind::Iterating: {
7441 auto ToRange = importChecked(Err, From: S->getRangeVarStmt());
7442 auto ToBegin = importChecked(Err, From: S->getBeginVarStmt());
7443 auto ToIter = importChecked(Err, From: S->getIterVarStmt());
7444 if (Err)
7445 return std::move(Err);
7446
7447 return CXXExpansionStmtPattern::CreateIterating(
7448 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar, Range: ToRange,
7449 Begin: ToBegin, Iter: ToIter, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7450 }
7451
7452 case CXXExpansionStmtPattern::ExpansionStmtKind::Destructuring: {
7453 auto ToDecompositionDeclStmt =
7454 importChecked(Err, From: S->getDecompositionDeclStmt());
7455 if (Err)
7456 return std::move(Err);
7457
7458 return CXXExpansionStmtPattern::CreateDestructuring(
7459 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar,
7460 DecompositionDeclStmt: ToDecompositionDeclStmt, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7461 }
7462
7463 case CXXExpansionStmtPattern::ExpansionStmtKind::Dependent: {
7464 auto ToExpansionInitializer =
7465 importChecked(Err, From: S->getExpansionInitializer());
7466 if (Err)
7467 return std::move(Err);
7468 return CXXExpansionStmtPattern::CreateDependent(
7469 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar,
7470 ExpansionInitializer: ToExpansionInitializer, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7471 }
7472 }
7473
7474 llvm_unreachable("invalid pattern kind");
7475}
7476
7477ExpectedStmt ASTNodeImporter::VisitCXXExpansionStmtInstantiation(
7478 CXXExpansionStmtInstantiation *S) {
7479 Error Err = Error::success();
7480 SmallVector<Stmt *> ToInstantiations;
7481 SmallVector<Stmt *> ToSharedStmts;
7482 auto ToParent = importChecked(Err, From: S->getParent());
7483 for (Stmt *FromInst : S->getInstantiations())
7484 ToInstantiations.push_back(Elt: importChecked(Err, From: FromInst));
7485 for (Stmt *FromShared : S->getPreambleStmts())
7486 ToSharedStmts.push_back(Elt: importChecked(Err, From: FromShared));
7487
7488 if (Err)
7489 return std::move(Err);
7490
7491 return CXXExpansionStmtInstantiation::Create(
7492 C&: Importer.getToContext(), Parent: ToParent, Instantiations: ToInstantiations, PreambleStmts: ToSharedStmts,
7493 ShouldApplyLifetimeExtensionToPreamble: S->shouldApplyLifetimeExtensionToPreamble());
7494}
7495
7496ExpectedStmt
7497ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
7498 Error Err = Error::success();
7499 auto ToElement = importChecked(Err, From: S->getElement());
7500 auto ToCollection = importChecked(Err, From: S->getCollection());
7501 auto ToBody = importChecked(Err, From: S->getBody());
7502 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7503 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7504 if (Err)
7505 return std::move(Err);
7506
7507 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
7508 ToCollection,
7509 ToBody,
7510 ToForLoc,
7511 ToRParenLoc);
7512}
7513
7514ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
7515
7516 Error Err = Error::success();
7517 auto ToAtCatchLoc = importChecked(Err, From: S->getAtCatchLoc());
7518 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7519 auto ToCatchParamDecl = importChecked(Err, From: S->getCatchParamDecl());
7520 auto ToCatchBody = importChecked(Err, From: S->getCatchBody());
7521 if (Err)
7522 return std::move(Err);
7523
7524 return new (Importer.getToContext()) ObjCAtCatchStmt (
7525 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7526}
7527
7528ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
7529 ExpectedSLoc ToAtFinallyLocOrErr = import(From: S->getAtFinallyLoc());
7530 if (!ToAtFinallyLocOrErr)
7531 return ToAtFinallyLocOrErr.takeError();
7532 ExpectedStmt ToAtFinallyStmtOrErr = import(From: S->getFinallyBody());
7533 if (!ToAtFinallyStmtOrErr)
7534 return ToAtFinallyStmtOrErr.takeError();
7535 return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
7536 *ToAtFinallyStmtOrErr);
7537}
7538
7539ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
7540
7541 Error Err = Error::success();
7542 auto ToAtTryLoc = importChecked(Err, From: S->getAtTryLoc());
7543 auto ToTryBody = importChecked(Err, From: S->getTryBody());
7544 auto ToFinallyStmt = importChecked(Err, From: S->getFinallyStmt());
7545 if (Err)
7546 return std::move(Err);
7547
7548 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
7549 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7550 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(I: CI);
7551 if (ExpectedStmt ToCatchStmtOrErr = import(From: FromCatchStmt))
7552 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7553 else
7554 return ToCatchStmtOrErr.takeError();
7555 }
7556
7557 return ObjCAtTryStmt::Create(Context: Importer.getToContext(),
7558 atTryLoc: ToAtTryLoc, atTryStmt: ToTryBody,
7559 CatchStmts: ToCatchStmts.begin(), NumCatchStmts: ToCatchStmts.size(),
7560 atFinallyStmt: ToFinallyStmt);
7561}
7562
7563ExpectedStmt
7564ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
7565
7566 Error Err = Error::success();
7567 auto ToAtSynchronizedLoc = importChecked(Err, From: S->getAtSynchronizedLoc());
7568 auto ToSynchExpr = importChecked(Err, From: S->getSynchExpr());
7569 auto ToSynchBody = importChecked(Err, From: S->getSynchBody());
7570 if (Err)
7571 return std::move(Err);
7572
7573 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
7574 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7575}
7576
7577ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
7578 ExpectedSLoc ToThrowLocOrErr = import(From: S->getThrowLoc());
7579 if (!ToThrowLocOrErr)
7580 return ToThrowLocOrErr.takeError();
7581 ExpectedExpr ToThrowExprOrErr = import(From: S->getThrowExpr());
7582 if (!ToThrowExprOrErr)
7583 return ToThrowExprOrErr.takeError();
7584 return new (Importer.getToContext()) ObjCAtThrowStmt(
7585 *ToThrowLocOrErr, *ToThrowExprOrErr);
7586}
7587
7588ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
7589 ObjCAutoreleasePoolStmt *S) {
7590 ExpectedSLoc ToAtLocOrErr = import(From: S->getAtLoc());
7591 if (!ToAtLocOrErr)
7592 return ToAtLocOrErr.takeError();
7593 ExpectedStmt ToSubStmtOrErr = import(From: S->getSubStmt());
7594 if (!ToSubStmtOrErr)
7595 return ToSubStmtOrErr.takeError();
7596 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
7597 *ToSubStmtOrErr);
7598}
7599
7600//----------------------------------------------------------------------------
7601// Import Expressions
7602//----------------------------------------------------------------------------
7603ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
7604 Importer.FromDiag(Loc: E->getBeginLoc(), DiagID: diag::err_unsupported_ast_node)
7605 << E->getStmtClassName();
7606 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7607}
7608
7609ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
7610 Error Err = Error::success();
7611 auto ToType = importChecked(Err, From: E->getType());
7612 auto BLoc = importChecked(Err, From: E->getBeginLoc());
7613 auto RParenLoc = importChecked(Err, From: E->getEndLoc());
7614 if (Err)
7615 return std::move(Err);
7616 auto ParentContextOrErr = Importer.ImportContext(FromDC: E->getParentContext());
7617 if (!ParentContextOrErr)
7618 return ParentContextOrErr.takeError();
7619
7620 return new (Importer.getToContext())
7621 SourceLocExpr(Importer.getToContext(), E->getIdentKind(), ToType, BLoc,
7622 RParenLoc, *ParentContextOrErr);
7623}
7624
7625ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
7626
7627 Error Err = Error::success();
7628 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7629 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
7630 auto ToWrittenTypeInfo = importChecked(Err, From: E->getWrittenTypeInfo());
7631 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7632 auto ToType = importChecked(Err, From: E->getType());
7633 if (Err)
7634 return std::move(Err);
7635
7636 return new (Importer.getToContext())
7637 VAArgExpr(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7638 E->getVarargABI());
7639}
7640
7641ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
7642
7643 Error Err = Error::success();
7644 auto ToCond = importChecked(Err, From: E->getCond());
7645 auto ToLHS = importChecked(Err, From: E->getLHS());
7646 auto ToRHS = importChecked(Err, From: E->getRHS());
7647 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7648 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7649 auto ToType = importChecked(Err, From: E->getType());
7650 if (Err)
7651 return std::move(Err);
7652
7653 ExprValueKind VK = E->getValueKind();
7654 ExprObjectKind OK = E->getObjectKind();
7655
7656 // The value of CondIsTrue only matters if the value is not
7657 // condition-dependent.
7658 bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
7659
7660 return new (Importer.getToContext())
7661 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7662 ToRParenLoc, CondIsTrue);
7663}
7664
7665ExpectedStmt ASTNodeImporter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
7666 Error Err = Error::success();
7667 auto *ToSrcExpr = importChecked(Err, From: E->getSrcExpr());
7668 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7669 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7670 auto ToType = importChecked(Err, From: E->getType());
7671 auto *ToTSI = importChecked(Err, From: E->getTypeSourceInfo());
7672 if (Err)
7673 return std::move(Err);
7674
7675 return ConvertVectorExpr::Create(
7676 C: Importer.getToContext(), SrcExpr: ToSrcExpr, TI: ToTSI, DstType: ToType, VK: E->getValueKind(),
7677 OK: E->getObjectKind(), BuiltinLoc: ToBuiltinLoc, RParenLoc: ToRParenLoc,
7678 FPFeatures: E->getStoredFPFeaturesOrDefault());
7679}
7680
7681ExpectedStmt ASTNodeImporter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
7682 Error Err = Error::success();
7683 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7684 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
7685 auto ToType = importChecked(Err, From: E->getType());
7686 const unsigned NumSubExprs = E->getNumSubExprs();
7687
7688 llvm::SmallVector<Expr *, 8> ToSubExprs;
7689 ArrayRef<Expr *> FromSubExprs(E->getSubExprs(), NumSubExprs);
7690 ToSubExprs.resize(N: NumSubExprs);
7691
7692 if ((Err = ImportContainerChecked(InContainer: FromSubExprs, OutContainer&: ToSubExprs)))
7693 return std::move(Err);
7694
7695 return new (Importer.getToContext()) ShuffleVectorExpr(
7696 Importer.getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7697}
7698
7699ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
7700 ExpectedType TypeOrErr = import(From: E->getType());
7701 if (!TypeOrErr)
7702 return TypeOrErr.takeError();
7703
7704 ExpectedSLoc BeginLocOrErr = import(From: E->getBeginLoc());
7705 if (!BeginLocOrErr)
7706 return BeginLocOrErr.takeError();
7707
7708 return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
7709}
7710
7711ExpectedStmt
7712ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
7713 Error Err = Error::success();
7714 auto ToGenericLoc = importChecked(Err, From: E->getGenericLoc());
7715 Expr *ToControllingExpr = nullptr;
7716 TypeSourceInfo *ToControllingType = nullptr;
7717 if (E->isExprPredicate())
7718 ToControllingExpr = importChecked(Err, From: E->getControllingExpr());
7719 else
7720 ToControllingType = importChecked(Err, From: E->getControllingType());
7721 assert((ToControllingExpr || ToControllingType) &&
7722 "Either the controlling expr or type must be nonnull");
7723 auto ToDefaultLoc = importChecked(Err, From: E->getDefaultLoc());
7724 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7725 if (Err)
7726 return std::move(Err);
7727
7728 ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
7729 SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
7730 if (Error Err = ImportContainerChecked(InContainer: FromAssocTypes, OutContainer&: ToAssocTypes))
7731 return std::move(Err);
7732
7733 ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
7734 SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
7735 if (Error Err = ImportContainerChecked(InContainer: FromAssocExprs, OutContainer&: ToAssocExprs))
7736 return std::move(Err);
7737
7738 const ASTContext &ToCtx = Importer.getToContext();
7739 if (E->isResultDependent()) {
7740 if (ToControllingExpr) {
7741 return GenericSelectionExpr::Create(
7742 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingExpr: ToControllingExpr, AssocTypes: ArrayRef(ToAssocTypes),
7743 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7744 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
7745 }
7746 return GenericSelectionExpr::Create(
7747 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingType: ToControllingType, AssocTypes: ArrayRef(ToAssocTypes),
7748 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7749 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
7750 }
7751
7752 if (ToControllingExpr) {
7753 return GenericSelectionExpr::Create(
7754 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingExpr: ToControllingExpr, AssocTypes: ArrayRef(ToAssocTypes),
7755 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7756 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack(), ResultIndex: E->getResultIndex());
7757 }
7758 return GenericSelectionExpr::Create(
7759 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingType: ToControllingType, AssocTypes: ArrayRef(ToAssocTypes),
7760 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7761 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack(), ResultIndex: E->getResultIndex());
7762}
7763
7764ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
7765
7766 Error Err = Error::success();
7767 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
7768 auto ToType = importChecked(Err, From: E->getType());
7769 auto ToFunctionName = importChecked(Err, From: E->getFunctionName());
7770 if (Err)
7771 return std::move(Err);
7772
7773 return PredefinedExpr::Create(Ctx: Importer.getToContext(), L: ToBeginLoc, FNTy: ToType,
7774 IK: E->getIdentKind(), IsTransparent: E->isTransparent(),
7775 SL: ToFunctionName);
7776}
7777
7778ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
7779
7780 Error Err = Error::success();
7781 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
7782 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
7783 auto ToDecl = importChecked(Err, From: E->getDecl());
7784 auto ToLocation = importChecked(Err, From: E->getLocation());
7785 auto ToType = importChecked(Err, From: E->getType());
7786 if (Err)
7787 return std::move(Err);
7788
7789 NamedDecl *ToFoundD = nullptr;
7790 if (E->getDecl() != E->getFoundDecl()) {
7791 auto FoundDOrErr = import(From: E->getFoundDecl());
7792 if (!FoundDOrErr)
7793 return FoundDOrErr.takeError();
7794 ToFoundD = *FoundDOrErr;
7795 }
7796
7797 TemplateArgumentListInfo ToTAInfo;
7798 TemplateArgumentListInfo *ToResInfo = nullptr;
7799 if (E->hasExplicitTemplateArgs()) {
7800 if (Error Err =
7801 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
7802 Container: E->template_arguments(), Result&: ToTAInfo))
7803 return std::move(Err);
7804 ToResInfo = &ToTAInfo;
7805 }
7806
7807 auto *ToE = DeclRefExpr::Create(
7808 Context: Importer.getToContext(), QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc, D: ToDecl,
7809 RefersToEnclosingVariableOrCapture: E->refersToEnclosingVariableOrCapture(), NameLoc: ToLocation, T: ToType,
7810 VK: E->getValueKind(), FoundD: ToFoundD, TemplateArgs: ToResInfo, NOUR: E->isNonOdrUse());
7811 if (E->hadMultipleCandidates())
7812 ToE->setHadMultipleCandidates(true);
7813 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
7814 return ToE;
7815}
7816
7817ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
7818 ExpectedType TypeOrErr = import(From: E->getType());
7819 if (!TypeOrErr)
7820 return TypeOrErr.takeError();
7821
7822 return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
7823}
7824
7825ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
7826 ExpectedExpr ToInitOrErr = import(From: E->getInit());
7827 if (!ToInitOrErr)
7828 return ToInitOrErr.takeError();
7829
7830 ExpectedSLoc ToEqualOrColonLocOrErr = import(From: E->getEqualOrColonLoc());
7831 if (!ToEqualOrColonLocOrErr)
7832 return ToEqualOrColonLocOrErr.takeError();
7833
7834 SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
7835 // List elements from the second, the first is Init itself
7836 for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
7837 if (ExpectedExpr ToArgOrErr = import(From: E->getSubExpr(Idx: I)))
7838 ToIndexExprs[I - 1] = *ToArgOrErr;
7839 else
7840 return ToArgOrErr.takeError();
7841 }
7842
7843 SmallVector<Designator, 4> ToDesignators(E->size());
7844 if (Error Err = ImportContainerChecked(InContainer: E->designators(), OutContainer&: ToDesignators))
7845 return std::move(Err);
7846
7847 return DesignatedInitExpr::Create(
7848 C: Importer.getToContext(), Designators: ToDesignators,
7849 IndexExprs: ToIndexExprs, EqualOrColonLoc: *ToEqualOrColonLocOrErr,
7850 GNUSyntax: E->usesGNUSyntax(), Init: *ToInitOrErr);
7851}
7852
7853ExpectedStmt
7854ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
7855 ExpectedType ToTypeOrErr = import(From: E->getType());
7856 if (!ToTypeOrErr)
7857 return ToTypeOrErr.takeError();
7858
7859 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7860 if (!ToLocationOrErr)
7861 return ToLocationOrErr.takeError();
7862
7863 return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
7864 *ToTypeOrErr, *ToLocationOrErr);
7865}
7866
7867ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
7868 ExpectedType ToTypeOrErr = import(From: E->getType());
7869 if (!ToTypeOrErr)
7870 return ToTypeOrErr.takeError();
7871
7872 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7873 if (!ToLocationOrErr)
7874 return ToLocationOrErr.takeError();
7875
7876 return IntegerLiteral::Create(
7877 C: Importer.getToContext(), V: E->getValue(), type: *ToTypeOrErr, l: *ToLocationOrErr);
7878}
7879
7880
7881ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
7882 ExpectedType ToTypeOrErr = import(From: E->getType());
7883 if (!ToTypeOrErr)
7884 return ToTypeOrErr.takeError();
7885
7886 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7887 if (!ToLocationOrErr)
7888 return ToLocationOrErr.takeError();
7889
7890 return FloatingLiteral::Create(
7891 C: Importer.getToContext(), V: E->getValue(), isexact: E->isExact(),
7892 Type: *ToTypeOrErr, L: *ToLocationOrErr);
7893}
7894
7895ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
7896 auto ToTypeOrErr = import(From: E->getType());
7897 if (!ToTypeOrErr)
7898 return ToTypeOrErr.takeError();
7899
7900 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
7901 if (!ToSubExprOrErr)
7902 return ToSubExprOrErr.takeError();
7903
7904 return new (Importer.getToContext()) ImaginaryLiteral(
7905 *ToSubExprOrErr, *ToTypeOrErr);
7906}
7907
7908ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
7909 auto ToTypeOrErr = import(From: E->getType());
7910 if (!ToTypeOrErr)
7911 return ToTypeOrErr.takeError();
7912
7913 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7914 if (!ToLocationOrErr)
7915 return ToLocationOrErr.takeError();
7916
7917 return new (Importer.getToContext()) FixedPointLiteral(
7918 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7919 Importer.getToContext().getFixedPointScale(Ty: *ToTypeOrErr));
7920}
7921
7922ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
7923 ExpectedType ToTypeOrErr = import(From: E->getType());
7924 if (!ToTypeOrErr)
7925 return ToTypeOrErr.takeError();
7926
7927 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7928 if (!ToLocationOrErr)
7929 return ToLocationOrErr.takeError();
7930
7931 return new (Importer.getToContext()) CharacterLiteral(
7932 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7933}
7934
7935ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
7936 ExpectedType ToTypeOrErr = import(From: E->getType());
7937 if (!ToTypeOrErr)
7938 return ToTypeOrErr.takeError();
7939
7940 SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
7941 if (Error Err = ImportArrayChecked(
7942 Ibegin: E->tokloc_begin(), Iend: E->tokloc_end(), Obegin: ToLocations.begin()))
7943 return std::move(Err);
7944
7945 return StringLiteral::Create(Ctx: Importer.getToContext(), Str: E->getBytes(),
7946 Kind: E->getKind(), Pascal: E->isPascal(), Ty: *ToTypeOrErr,
7947 Locs: ToLocations);
7948}
7949
7950ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
7951
7952 Error Err = Error::success();
7953 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
7954 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
7955 auto ToType = importChecked(Err, From: E->getType());
7956 auto ToInitializer = importChecked(Err, From: E->getInitializer());
7957 if (Err)
7958 return std::move(Err);
7959
7960 return new (Importer.getToContext()) CompoundLiteralExpr(
7961 ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
7962 ToInitializer, E->isFileScope());
7963}
7964
7965ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
7966
7967 Error Err = Error::success();
7968 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7969 auto ToType = importChecked(Err, From: E->getType());
7970 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7971 if (Err)
7972 return std::move(Err);
7973
7974 SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
7975 if (Error Err = ImportArrayChecked(
7976 Ibegin: E->getSubExprs(), Iend: E->getSubExprs() + E->getNumSubExprs(),
7977 Obegin: ToExprs.begin()))
7978 return std::move(Err);
7979
7980 return new (Importer.getToContext()) AtomicExpr(
7981
7982 ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
7983}
7984
7985ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
7986 Error Err = Error::success();
7987 auto ToAmpAmpLoc = importChecked(Err, From: E->getAmpAmpLoc());
7988 auto ToLabelLoc = importChecked(Err, From: E->getLabelLoc());
7989 auto ToLabel = importChecked(Err, From: E->getLabel());
7990 auto ToType = importChecked(Err, From: E->getType());
7991 if (Err)
7992 return std::move(Err);
7993
7994 return new (Importer.getToContext()) AddrLabelExpr(
7995 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7996}
7997ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
7998 Error Err = Error::success();
7999 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8000 auto ToResult = importChecked(Err, From: E->getAPValueResult());
8001 if (Err)
8002 return std::move(Err);
8003
8004 return ConstantExpr::Create(Context: Importer.getToContext(), E: ToSubExpr, Result: ToResult);
8005}
8006ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
8007 Error Err = Error::success();
8008 auto ToLParen = importChecked(Err, From: E->getLParen());
8009 auto ToRParen = importChecked(Err, From: E->getRParen());
8010 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8011 if (Err)
8012 return std::move(Err);
8013
8014 return new (Importer.getToContext())
8015 ParenExpr(ToLParen, ToRParen, ToSubExpr);
8016}
8017
8018ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
8019 SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
8020 if (Error Err = ImportContainerChecked(InContainer: E->exprs(), OutContainer&: ToExprs))
8021 return std::move(Err);
8022
8023 ExpectedSLoc ToLParenLocOrErr = import(From: E->getLParenLoc());
8024 if (!ToLParenLocOrErr)
8025 return ToLParenLocOrErr.takeError();
8026
8027 ExpectedSLoc ToRParenLocOrErr = import(From: E->getRParenLoc());
8028 if (!ToRParenLocOrErr)
8029 return ToRParenLocOrErr.takeError();
8030
8031 return ParenListExpr::Create(Ctx: Importer.getToContext(), LParenLoc: *ToLParenLocOrErr,
8032 Exprs: ToExprs, RParenLoc: *ToRParenLocOrErr);
8033}
8034
8035ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
8036 Error Err = Error::success();
8037 auto ToSubStmt = importChecked(Err, From: E->getSubStmt());
8038 auto ToType = importChecked(Err, From: E->getType());
8039 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
8040 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8041 if (Err)
8042 return std::move(Err);
8043
8044 return new (Importer.getToContext())
8045 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
8046 E->getTemplateDepth());
8047}
8048
8049ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
8050 Error Err = Error::success();
8051 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8052 auto ToType = importChecked(Err, From: E->getType());
8053 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8054 if (Err)
8055 return std::move(Err);
8056
8057 auto *UO = UnaryOperator::CreateEmpty(C: Importer.getToContext(),
8058 hasFPFeatures: E->hasStoredFPFeatures());
8059 UO->setType(ToType);
8060 UO->setSubExpr(ToSubExpr);
8061 UO->setOpcode(E->getOpcode());
8062 UO->setOperatorLoc(ToOperatorLoc);
8063 UO->setCanOverflow(E->canOverflow());
8064 if (E->hasStoredFPFeatures())
8065 UO->setStoredFPFeatures(E->getStoredFPFeatures());
8066
8067 return UO;
8068}
8069
8070ExpectedStmt
8071
8072ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
8073 Error Err = Error::success();
8074 auto ToType = importChecked(Err, From: E->getType());
8075 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8076 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8077 if (Err)
8078 return std::move(Err);
8079
8080 if (E->isArgumentType()) {
8081 Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
8082 import(From: E->getArgumentTypeInfo());
8083 if (!ToArgumentTypeInfoOrErr)
8084 return ToArgumentTypeInfoOrErr.takeError();
8085
8086 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
8087 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
8088 ToRParenLoc);
8089 }
8090
8091 ExpectedExpr ToArgumentExprOrErr = import(From: E->getArgumentExpr());
8092 if (!ToArgumentExprOrErr)
8093 return ToArgumentExprOrErr.takeError();
8094
8095 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
8096 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
8097}
8098
8099ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
8100 Error Err = Error::success();
8101 auto ToLHS = importChecked(Err, From: E->getLHS());
8102 auto ToRHS = importChecked(Err, From: E->getRHS());
8103 auto ToType = importChecked(Err, From: E->getType());
8104 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8105 if (Err)
8106 return std::move(Err);
8107
8108 return BinaryOperator::Create(
8109 C: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS, opc: E->getOpcode(), ResTy: ToType,
8110 VK: E->getValueKind(), OK: E->getObjectKind(), opLoc: ToOperatorLoc,
8111 FPFeatures: E->getFPFeatures());
8112}
8113
8114ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
8115 Error Err = Error::success();
8116 auto ToCond = importChecked(Err, From: E->getCond());
8117 auto ToQuestionLoc = importChecked(Err, From: E->getQuestionLoc());
8118 auto ToLHS = importChecked(Err, From: E->getLHS());
8119 auto ToColonLoc = importChecked(Err, From: E->getColonLoc());
8120 auto ToRHS = importChecked(Err, From: E->getRHS());
8121 auto ToType = importChecked(Err, From: E->getType());
8122 if (Err)
8123 return std::move(Err);
8124
8125 return new (Importer.getToContext()) ConditionalOperator(
8126 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
8127 E->getValueKind(), E->getObjectKind());
8128}
8129
8130ExpectedStmt
8131ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
8132 Error Err = Error::success();
8133 auto ToCommon = importChecked(Err, From: E->getCommon());
8134 auto ToOpaqueValue = importChecked(Err, From: E->getOpaqueValue());
8135 auto ToCond = importChecked(Err, From: E->getCond());
8136 auto ToTrueExpr = importChecked(Err, From: E->getTrueExpr());
8137 auto ToFalseExpr = importChecked(Err, From: E->getFalseExpr());
8138 auto ToQuestionLoc = importChecked(Err, From: E->getQuestionLoc());
8139 auto ToColonLoc = importChecked(Err, From: E->getColonLoc());
8140 auto ToType = importChecked(Err, From: E->getType());
8141 if (Err)
8142 return std::move(Err);
8143
8144 return new (Importer.getToContext()) BinaryConditionalOperator(
8145 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
8146 ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
8147 E->getObjectKind());
8148}
8149
8150ExpectedStmt ASTNodeImporter::VisitCXXRewrittenBinaryOperator(
8151 CXXRewrittenBinaryOperator *E) {
8152 Error Err = Error::success();
8153 auto ToSemanticForm = importChecked(Err, From: E->getSemanticForm());
8154 if (Err)
8155 return std::move(Err);
8156
8157 return new (Importer.getToContext())
8158 CXXRewrittenBinaryOperator(ToSemanticForm, E->isReversed());
8159}
8160
8161ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
8162 Error Err = Error::success();
8163 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8164 auto ToQueriedTypeSourceInfo =
8165 importChecked(Err, From: E->getQueriedTypeSourceInfo());
8166 auto ToDimensionExpression = importChecked(Err, From: E->getDimensionExpression());
8167 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8168 auto ToType = importChecked(Err, From: E->getType());
8169 if (Err)
8170 return std::move(Err);
8171
8172 return new (Importer.getToContext()) ArrayTypeTraitExpr(
8173 ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
8174 ToDimensionExpression, ToEndLoc, ToType);
8175}
8176
8177ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
8178 Error Err = Error::success();
8179 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8180 auto ToQueriedExpression = importChecked(Err, From: E->getQueriedExpression());
8181 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8182 auto ToType = importChecked(Err, From: E->getType());
8183 if (Err)
8184 return std::move(Err);
8185
8186 return new (Importer.getToContext()) ExpressionTraitExpr(
8187 ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
8188 ToEndLoc, ToType);
8189}
8190
8191ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
8192 Error Err = Error::success();
8193 auto ToLocation = importChecked(Err, From: E->getLocation());
8194 auto ToType = importChecked(Err, From: E->getType());
8195 auto ToSourceExpr = importChecked(Err, From: E->getSourceExpr());
8196 if (Err)
8197 return std::move(Err);
8198
8199 return new (Importer.getToContext()) OpaqueValueExpr(
8200 ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
8201}
8202
8203ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
8204 Error Err = Error::success();
8205 auto ToLHS = importChecked(Err, From: E->getLHS());
8206 auto ToRHS = importChecked(Err, From: E->getRHS());
8207 auto ToType = importChecked(Err, From: E->getType());
8208 auto ToRBracketLoc = importChecked(Err, From: E->getRBracketLoc());
8209 if (Err)
8210 return std::move(Err);
8211
8212 return new (Importer.getToContext()) ArraySubscriptExpr(
8213 ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
8214 ToRBracketLoc);
8215}
8216
8217ExpectedStmt
8218ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
8219 Error Err = Error::success();
8220 auto ToLHS = importChecked(Err, From: E->getLHS());
8221 auto ToRHS = importChecked(Err, From: E->getRHS());
8222 auto ToType = importChecked(Err, From: E->getType());
8223 auto ToComputationLHSType = importChecked(Err, From: E->getComputationLHSType());
8224 auto ToComputationResultType =
8225 importChecked(Err, From: E->getComputationResultType());
8226 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8227 if (Err)
8228 return std::move(Err);
8229
8230 return CompoundAssignOperator::Create(
8231 C: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS, opc: E->getOpcode(), ResTy: ToType,
8232 VK: E->getValueKind(), OK: E->getObjectKind(), opLoc: ToOperatorLoc,
8233 FPFeatures: E->getFPFeatures(),
8234 CompLHSType: ToComputationLHSType, CompResultType: ToComputationResultType);
8235}
8236
8237Expected<CXXCastPath>
8238ASTNodeImporter::ImportCastPath(CastExpr *CE) {
8239 CXXCastPath Path;
8240 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
8241 if (auto SpecOrErr = import(From: *I))
8242 Path.push_back(Elt: *SpecOrErr);
8243 else
8244 return SpecOrErr.takeError();
8245 }
8246 return Path;
8247}
8248
8249ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
8250 ExpectedType ToTypeOrErr = import(From: E->getType());
8251 if (!ToTypeOrErr)
8252 return ToTypeOrErr.takeError();
8253
8254 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8255 if (!ToSubExprOrErr)
8256 return ToSubExprOrErr.takeError();
8257
8258 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(CE: E);
8259 if (!ToBasePathOrErr)
8260 return ToBasePathOrErr.takeError();
8261
8262 return ImplicitCastExpr::Create(
8263 Context: Importer.getToContext(), T: *ToTypeOrErr, Kind: E->getCastKind(), Operand: *ToSubExprOrErr,
8264 BasePath: &(*ToBasePathOrErr), Cat: E->getValueKind(), FPO: E->getFPFeatures());
8265}
8266
8267ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
8268 Error Err = Error::success();
8269 auto ToType = importChecked(Err, From: E->getType());
8270 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8271 auto ToTypeInfoAsWritten = importChecked(Err, From: E->getTypeInfoAsWritten());
8272 if (Err)
8273 return std::move(Err);
8274
8275 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(CE: E);
8276 if (!ToBasePathOrErr)
8277 return ToBasePathOrErr.takeError();
8278 CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
8279
8280 switch (E->getStmtClass()) {
8281 case Stmt::CStyleCastExprClass: {
8282 auto *CCE = cast<CStyleCastExpr>(Val: E);
8283 ExpectedSLoc ToLParenLocOrErr = import(From: CCE->getLParenLoc());
8284 if (!ToLParenLocOrErr)
8285 return ToLParenLocOrErr.takeError();
8286 ExpectedSLoc ToRParenLocOrErr = import(From: CCE->getRParenLoc());
8287 if (!ToRParenLocOrErr)
8288 return ToRParenLocOrErr.takeError();
8289 return CStyleCastExpr::Create(
8290 Context: Importer.getToContext(), T: ToType, VK: E->getValueKind(), K: E->getCastKind(),
8291 Op: ToSubExpr, BasePath: ToBasePath, FPO: CCE->getFPFeatures(), WrittenTy: ToTypeInfoAsWritten,
8292 L: *ToLParenLocOrErr, R: *ToRParenLocOrErr);
8293 }
8294
8295 case Stmt::CXXFunctionalCastExprClass: {
8296 auto *FCE = cast<CXXFunctionalCastExpr>(Val: E);
8297 ExpectedSLoc ToLParenLocOrErr = import(From: FCE->getLParenLoc());
8298 if (!ToLParenLocOrErr)
8299 return ToLParenLocOrErr.takeError();
8300 ExpectedSLoc ToRParenLocOrErr = import(From: FCE->getRParenLoc());
8301 if (!ToRParenLocOrErr)
8302 return ToRParenLocOrErr.takeError();
8303 return CXXFunctionalCastExpr::Create(
8304 Context: Importer.getToContext(), T: ToType, VK: E->getValueKind(), Written: ToTypeInfoAsWritten,
8305 Kind: E->getCastKind(), Op: ToSubExpr, Path: ToBasePath, FPO: FCE->getFPFeatures(),
8306 LPLoc: *ToLParenLocOrErr, RPLoc: *ToRParenLocOrErr);
8307 }
8308
8309 case Stmt::ObjCBridgedCastExprClass: {
8310 auto *OCE = cast<ObjCBridgedCastExpr>(Val: E);
8311 ExpectedSLoc ToLParenLocOrErr = import(From: OCE->getLParenLoc());
8312 if (!ToLParenLocOrErr)
8313 return ToLParenLocOrErr.takeError();
8314 ExpectedSLoc ToBridgeKeywordLocOrErr = import(From: OCE->getBridgeKeywordLoc());
8315 if (!ToBridgeKeywordLocOrErr)
8316 return ToBridgeKeywordLocOrErr.takeError();
8317 return new (Importer.getToContext()) ObjCBridgedCastExpr(
8318 *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
8319 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
8320 }
8321 case Stmt::BuiltinBitCastExprClass: {
8322 auto *BBC = cast<BuiltinBitCastExpr>(Val: E);
8323 ExpectedSLoc ToKWLocOrErr = import(From: BBC->getBeginLoc());
8324 if (!ToKWLocOrErr)
8325 return ToKWLocOrErr.takeError();
8326 ExpectedSLoc ToRParenLocOrErr = import(From: BBC->getEndLoc());
8327 if (!ToRParenLocOrErr)
8328 return ToRParenLocOrErr.takeError();
8329 return new (Importer.getToContext()) BuiltinBitCastExpr(
8330 ToType, E->getValueKind(), E->getCastKind(), ToSubExpr,
8331 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
8332 }
8333 default:
8334 llvm_unreachable("Cast expression of unsupported type!");
8335 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
8336 }
8337}
8338
8339ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
8340 SmallVector<OffsetOfNode, 4> ToNodes;
8341 for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
8342 const OffsetOfNode &FromNode = E->getComponent(Idx: I);
8343
8344 SourceLocation ToBeginLoc, ToEndLoc;
8345
8346 if (FromNode.getKind() != OffsetOfNode::Base) {
8347 Error Err = Error::success();
8348 ToBeginLoc = importChecked(Err, From: FromNode.getBeginLoc());
8349 ToEndLoc = importChecked(Err, From: FromNode.getEndLoc());
8350 if (Err)
8351 return std::move(Err);
8352 }
8353
8354 switch (FromNode.getKind()) {
8355 case OffsetOfNode::Array:
8356 ToNodes.push_back(
8357 Elt: OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
8358 break;
8359 case OffsetOfNode::Base: {
8360 auto ToBSOrErr = import(From: FromNode.getBase());
8361 if (!ToBSOrErr)
8362 return ToBSOrErr.takeError();
8363 ToNodes.push_back(Elt: OffsetOfNode(*ToBSOrErr));
8364 break;
8365 }
8366 case OffsetOfNode::Field: {
8367 auto ToFieldOrErr = import(From: FromNode.getField());
8368 if (!ToFieldOrErr)
8369 return ToFieldOrErr.takeError();
8370 ToNodes.push_back(Elt: OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
8371 break;
8372 }
8373 case OffsetOfNode::Identifier: {
8374 IdentifierInfo *ToII = Importer.Import(FromId: FromNode.getFieldName());
8375 ToNodes.push_back(Elt: OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
8376 break;
8377 }
8378 }
8379 }
8380
8381 SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
8382 for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
8383 ExpectedExpr ToIndexExprOrErr = import(From: E->getIndexExpr(Idx: I));
8384 if (!ToIndexExprOrErr)
8385 return ToIndexExprOrErr.takeError();
8386 ToExprs[I] = *ToIndexExprOrErr;
8387 }
8388
8389 Error Err = Error::success();
8390 auto ToType = importChecked(Err, From: E->getType());
8391 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8392 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8393 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8394 if (Err)
8395 return std::move(Err);
8396
8397 return OffsetOfExpr::Create(
8398 C: Importer.getToContext(), type: ToType, OperatorLoc: ToOperatorLoc, tsi: ToTypeSourceInfo, comps: ToNodes,
8399 exprs: ToExprs, RParenLoc: ToRParenLoc);
8400}
8401
8402ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
8403 Error Err = Error::success();
8404 auto ToType = importChecked(Err, From: E->getType());
8405 auto ToOperand = importChecked(Err, From: E->getOperand());
8406 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8407 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8408 if (Err)
8409 return std::move(Err);
8410
8411 CanThrowResult ToCanThrow;
8412 if (E->isValueDependent())
8413 ToCanThrow = CT_Dependent;
8414 else
8415 ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
8416
8417 return new (Importer.getToContext()) CXXNoexceptExpr(
8418 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
8419}
8420
8421ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
8422 Error Err = Error::success();
8423 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8424 auto ToType = importChecked(Err, From: E->getType());
8425 auto ToThrowLoc = importChecked(Err, From: E->getThrowLoc());
8426 if (Err)
8427 return std::move(Err);
8428
8429 return new (Importer.getToContext()) CXXThrowExpr(
8430 ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
8431}
8432
8433ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
8434 ExpectedSLoc ToUsedLocOrErr = import(From: E->getUsedLocation());
8435 if (!ToUsedLocOrErr)
8436 return ToUsedLocOrErr.takeError();
8437
8438 auto ToParamOrErr = import(From: E->getParam());
8439 if (!ToParamOrErr)
8440 return ToParamOrErr.takeError();
8441
8442 auto UsedContextOrErr = Importer.ImportContext(FromDC: E->getUsedContext());
8443 if (!UsedContextOrErr)
8444 return UsedContextOrErr.takeError();
8445
8446 // Import the default arg if it was not imported yet.
8447 // This is needed because it can happen that during the import of the
8448 // default expression (from VisitParmVarDecl) the same ParmVarDecl is
8449 // encountered here. The default argument for a ParmVarDecl is set in the
8450 // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
8451 // see VisitParmVarDecl).
8452 ParmVarDecl *ToParam = *ToParamOrErr;
8453 if (!ToParam->getDefaultArg()) {
8454 std::optional<ParmVarDecl *> FromParam =
8455 Importer.getImportedFromDecl(ToD: ToParam);
8456 assert(FromParam && "ParmVarDecl was not imported?");
8457
8458 if (Error Err = ImportDefaultArgOfParmVarDecl(FromParam: *FromParam, ToParam))
8459 return std::move(Err);
8460 }
8461 Expr *RewrittenInit = nullptr;
8462 if (E->hasRewrittenInit()) {
8463 ExpectedExpr ExprOrErr = import(From: E->getRewrittenExpr());
8464 if (!ExprOrErr)
8465 return ExprOrErr.takeError();
8466 RewrittenInit = ExprOrErr.get();
8467 }
8468 return CXXDefaultArgExpr::Create(C: Importer.getToContext(), Loc: *ToUsedLocOrErr,
8469 Param: *ToParamOrErr, RewrittenExpr: RewrittenInit,
8470 UsedContext: *UsedContextOrErr);
8471}
8472
8473ExpectedStmt
8474ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
8475 Error Err = Error::success();
8476 auto ToType = importChecked(Err, From: E->getType());
8477 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8478 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8479 if (Err)
8480 return std::move(Err);
8481
8482 return new (Importer.getToContext()) CXXScalarValueInitExpr(
8483 ToType, ToTypeSourceInfo, ToRParenLoc);
8484}
8485
8486ExpectedStmt
8487ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
8488 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8489 if (!ToSubExprOrErr)
8490 return ToSubExprOrErr.takeError();
8491
8492 auto ToDtorOrErr = import(From: E->getTemporary()->getDestructor());
8493 if (!ToDtorOrErr)
8494 return ToDtorOrErr.takeError();
8495
8496 ASTContext &ToCtx = Importer.getToContext();
8497 CXXTemporary *Temp = CXXTemporary::Create(C: ToCtx, Destructor: *ToDtorOrErr);
8498 return CXXBindTemporaryExpr::Create(C: ToCtx, Temp, SubExpr: *ToSubExprOrErr);
8499}
8500
8501ExpectedStmt
8502
8503ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
8504 Error Err = Error::success();
8505 auto ToConstructor = importChecked(Err, From: E->getConstructor());
8506 auto ToType = importChecked(Err, From: E->getType());
8507 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8508 auto ToParenOrBraceRange = importChecked(Err, From: E->getParenOrBraceRange());
8509 if (Err)
8510 return std::move(Err);
8511
8512 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8513 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8514 return std::move(Err);
8515
8516 return CXXTemporaryObjectExpr::Create(
8517 Ctx: Importer.getToContext(), Cons: ToConstructor, Ty: ToType, TSI: ToTypeSourceInfo, Args: ToArgs,
8518 ParenOrBraceRange: ToParenOrBraceRange, HadMultipleCandidates: E->hadMultipleCandidates(),
8519 ListInitialization: E->isListInitialization(), StdInitListInitialization: E->isStdInitListInitialization(),
8520 ZeroInitialization: E->requiresZeroInitialization());
8521}
8522
8523ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
8524 LifetimeExtendedTemporaryDecl *D) {
8525 DeclContext *DC, *LexicalDC;
8526 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
8527 return std::move(Err);
8528
8529 Error Err = Error::success();
8530 auto Temporary = importChecked(Err, From: D->getTemporaryExpr());
8531 auto ExtendingDecl = importChecked(Err, From: D->getExtendingDecl());
8532 if (Err)
8533 return std::move(Err);
8534 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
8535
8536 LifetimeExtendedTemporaryDecl *To;
8537 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Temporary, args&: ExtendingDecl,
8538 args: D->getManglingNumber()))
8539 return To;
8540
8541 To->setLexicalDeclContext(LexicalDC);
8542 LexicalDC->addDeclInternal(D: To);
8543 return To;
8544}
8545
8546ExpectedStmt
8547ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
8548 Error Err = Error::success();
8549 auto ToType = importChecked(Err, From: E->getType());
8550 Expr *ToTemporaryExpr = importChecked(
8551 Err, From: E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
8552 auto ToMaterializedDecl =
8553 importChecked(Err, From: E->getLifetimeExtendedTemporaryDecl());
8554 if (Err)
8555 return std::move(Err);
8556
8557 if (!ToTemporaryExpr)
8558 ToTemporaryExpr = cast<Expr>(Val: ToMaterializedDecl->getTemporaryExpr());
8559
8560 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
8561 ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
8562 ToMaterializedDecl);
8563
8564 return ToMTE;
8565}
8566
8567ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
8568 Error Err = Error::success();
8569 auto *ToPattern = importChecked(Err, From: E->getPattern());
8570 auto ToEllipsisLoc = importChecked(Err, From: E->getEllipsisLoc());
8571 if (Err)
8572 return std::move(Err);
8573
8574 return new (Importer.getToContext())
8575 PackExpansionExpr(ToPattern, ToEllipsisLoc, E->getNumExpansions());
8576}
8577
8578ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
8579 Error Err = Error::success();
8580 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8581 auto ToPack = importChecked(Err, From: E->getPack());
8582 auto ToPackLoc = importChecked(Err, From: E->getPackLoc());
8583 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8584 if (Err)
8585 return std::move(Err);
8586
8587 UnsignedOrNone Length = std::nullopt;
8588 if (!E->isValueDependent())
8589 Length = E->getPackLength();
8590
8591 SmallVector<TemplateArgument, 8> ToPartialArguments;
8592 if (E->isPartiallySubstituted()) {
8593 if (Error Err = ImportTemplateArguments(FromArgs: E->getPartialArguments(),
8594 ToArgs&: ToPartialArguments))
8595 return std::move(Err);
8596 }
8597
8598 return SizeOfPackExpr::Create(
8599 Context&: Importer.getToContext(), OperatorLoc: ToOperatorLoc, Pack: ToPack, PackLoc: ToPackLoc, RParenLoc: ToRParenLoc,
8600 Length, PartialArgs: ToPartialArguments);
8601}
8602
8603
8604ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
8605 Error Err = Error::success();
8606 auto ToOperatorNew = importChecked(Err, From: E->getOperatorNew());
8607 auto ToOperatorDelete = importChecked(Err, From: E->getOperatorDelete());
8608 auto ToTypeIdParens = importChecked(Err, From: E->getTypeIdParens());
8609 auto ToArraySize = importChecked(Err, From: E->getArraySize());
8610 auto ToInitializer = importChecked(Err, From: E->getInitializer());
8611 auto ToType = importChecked(Err, From: E->getType());
8612 auto ToAllocatedTypeSourceInfo =
8613 importChecked(Err, From: E->getAllocatedTypeSourceInfo());
8614 auto ToSourceRange = importChecked(Err, From: E->getSourceRange());
8615 auto ToDirectInitRange = importChecked(Err, From: E->getDirectInitRange());
8616 if (Err)
8617 return std::move(Err);
8618
8619 SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
8620 if (Error Err =
8621 ImportContainerChecked(InContainer: E->placement_arguments(), OutContainer&: ToPlacementArgs))
8622 return std::move(Err);
8623
8624 return CXXNewExpr::Create(
8625 Ctx: Importer.getToContext(), IsGlobalNew: E->isGlobalNew(), OperatorNew: ToOperatorNew,
8626 OperatorDelete: ToOperatorDelete, IAP: E->implicitAllocationParameters(),
8627 UsualArrayDeleteWantsSize: E->doesUsualArrayDeleteWantSize(), PlacementArgs: ToPlacementArgs, TypeIdParens: ToTypeIdParens,
8628 ArraySize: ToArraySize, InitializationStyle: E->getInitializationStyle(), Initializer: ToInitializer, Ty: ToType,
8629 AllocatedTypeInfo: ToAllocatedTypeSourceInfo, Range: ToSourceRange, DirectInitRange: ToDirectInitRange);
8630}
8631
8632ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
8633 Error Err = Error::success();
8634 auto ToType = importChecked(Err, From: E->getType());
8635 auto ToOperatorDelete = importChecked(Err, From: E->getOperatorDelete());
8636 auto ToArgument = importChecked(Err, From: E->getArgument());
8637 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8638 if (Err)
8639 return std::move(Err);
8640
8641 return new (Importer.getToContext()) CXXDeleteExpr(
8642 ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
8643 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8644 ToBeginLoc);
8645}
8646
8647ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
8648 Error Err = Error::success();
8649 auto ToType = importChecked(Err, From: E->getType());
8650 auto ToLocation = importChecked(Err, From: E->getLocation());
8651 auto ToConstructor = importChecked(Err, From: E->getConstructor());
8652 auto ToParenOrBraceRange = importChecked(Err, From: E->getParenOrBraceRange());
8653 if (Err)
8654 return std::move(Err);
8655
8656 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
8657 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8658 return std::move(Err);
8659
8660 CXXConstructExpr *ToE = CXXConstructExpr::Create(
8661 Ctx: Importer.getToContext(), Ty: ToType, Loc: ToLocation, Ctor: ToConstructor,
8662 Elidable: E->isElidable(), Args: ToArgs, HadMultipleCandidates: E->hadMultipleCandidates(),
8663 ListInitialization: E->isListInitialization(), StdInitListInitialization: E->isStdInitListInitialization(),
8664 ZeroInitialization: E->requiresZeroInitialization(), ConstructKind: E->getConstructionKind(),
8665 ParenOrBraceRange: ToParenOrBraceRange);
8666 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
8667 return ToE;
8668}
8669
8670ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
8671 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8672 if (!ToSubExprOrErr)
8673 return ToSubExprOrErr.takeError();
8674
8675 SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
8676 if (Error Err = ImportContainerChecked(InContainer: E->getObjects(), OutContainer&: ToObjects))
8677 return std::move(Err);
8678
8679 return ExprWithCleanups::Create(
8680 C: Importer.getToContext(), subexpr: *ToSubExprOrErr, CleanupsHaveSideEffects: E->cleanupsHaveSideEffects(),
8681 objects: ToObjects);
8682}
8683
8684ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
8685 Error Err = Error::success();
8686 auto ToCallee = importChecked(Err, From: E->getCallee());
8687 auto ToType = importChecked(Err, From: E->getType());
8688 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8689 if (Err)
8690 return std::move(Err);
8691
8692 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
8693 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8694 return std::move(Err);
8695
8696 return CXXMemberCallExpr::Create(Ctx: Importer.getToContext(), Fn: ToCallee, Args: ToArgs,
8697 Ty: ToType, VK: E->getValueKind(), RP: ToRParenLoc,
8698 FPFeatures: E->getFPFeatures());
8699}
8700
8701ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
8702 ExpectedType ToTypeOrErr = import(From: E->getType());
8703 if (!ToTypeOrErr)
8704 return ToTypeOrErr.takeError();
8705
8706 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
8707 if (!ToLocationOrErr)
8708 return ToLocationOrErr.takeError();
8709
8710 return CXXThisExpr::Create(Ctx: Importer.getToContext(), L: *ToLocationOrErr,
8711 Ty: *ToTypeOrErr, IsImplicit: E->isImplicit());
8712}
8713
8714ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
8715 ExpectedType ToTypeOrErr = import(From: E->getType());
8716 if (!ToTypeOrErr)
8717 return ToTypeOrErr.takeError();
8718
8719 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
8720 if (!ToLocationOrErr)
8721 return ToLocationOrErr.takeError();
8722
8723 return CXXBoolLiteralExpr::Create(C: Importer.getToContext(), Val: E->getValue(),
8724 Ty: *ToTypeOrErr, Loc: *ToLocationOrErr);
8725}
8726
8727ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
8728 Error Err = Error::success();
8729 auto ToBase = importChecked(Err, From: E->getBase());
8730 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8731 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8732 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8733 auto ToMemberDecl = importChecked(Err, From: E->getMemberDecl());
8734 auto ToType = importChecked(Err, From: E->getType());
8735 auto ToDecl = importChecked(Err, From: E->getFoundDecl().getDecl());
8736 auto ToName = importChecked(Err, From: E->getMemberNameInfo().getName());
8737 auto ToLoc = importChecked(Err, From: E->getMemberNameInfo().getLoc());
8738 if (Err)
8739 return std::move(Err);
8740
8741 DeclAccessPair ToFoundDecl =
8742 DeclAccessPair::make(D: ToDecl, AS: E->getFoundDecl().getAccess());
8743
8744 DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
8745
8746 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
8747 if (E->hasExplicitTemplateArgs()) {
8748 if (Error Err =
8749 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8750 Container: E->template_arguments(), Result&: ToTAInfo))
8751 return std::move(Err);
8752 ResInfo = &ToTAInfo;
8753 }
8754
8755 return MemberExpr::Create(C: Importer.getToContext(), Base: ToBase, IsArrow: E->isArrow(),
8756 OperatorLoc: ToOperatorLoc, QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
8757 MemberDecl: ToMemberDecl, FoundDecl: ToFoundDecl, MemberNameInfo: ToMemberNameInfo,
8758 TemplateArgs: ResInfo, T: ToType, VK: E->getValueKind(),
8759 OK: E->getObjectKind(), NOUR: E->isNonOdrUse());
8760}
8761
8762ExpectedStmt
8763ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
8764 Error Err = Error::success();
8765 auto ToBase = importChecked(Err, From: E->getBase());
8766 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8767 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8768 auto ToScopeTypeInfo = importChecked(Err, From: E->getScopeTypeInfo());
8769 auto ToColonColonLoc = importChecked(Err, From: E->getColonColonLoc());
8770 auto ToTildeLoc = importChecked(Err, From: E->getTildeLoc());
8771 if (Err)
8772 return std::move(Err);
8773
8774 PseudoDestructorTypeStorage Storage;
8775 if (const IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
8776 const IdentifierInfo *ToII = Importer.Import(FromId: FromII);
8777 ExpectedSLoc ToDestroyedTypeLocOrErr = import(From: E->getDestroyedTypeLoc());
8778 if (!ToDestroyedTypeLocOrErr)
8779 return ToDestroyedTypeLocOrErr.takeError();
8780 Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
8781 } else {
8782 if (auto ToTIOrErr = import(From: E->getDestroyedTypeInfo()))
8783 Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
8784 else
8785 return ToTIOrErr.takeError();
8786 }
8787
8788 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
8789 Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
8790 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8791}
8792
8793ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
8794 CXXDependentScopeMemberExpr *E) {
8795 Error Err = Error::success();
8796 auto ToType = importChecked(Err, From: E->getType());
8797 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8798 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8799 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8800 auto ToFirstQualifierFoundInScope =
8801 importChecked(Err, From: E->getFirstQualifierFoundInScope());
8802 if (Err)
8803 return std::move(Err);
8804
8805 Expr *ToBase = nullptr;
8806 if (!E->isImplicitAccess()) {
8807 if (ExpectedExpr ToBaseOrErr = import(From: E->getBase()))
8808 ToBase = *ToBaseOrErr;
8809 else
8810 return ToBaseOrErr.takeError();
8811 }
8812
8813 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
8814
8815 if (E->hasExplicitTemplateArgs()) {
8816 if (Error Err =
8817 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8818 Container: E->template_arguments(), Result&: ToTAInfo))
8819 return std::move(Err);
8820 ResInfo = &ToTAInfo;
8821 }
8822 auto ToMember = importChecked(Err, From: E->getMember());
8823 auto ToMemberLoc = importChecked(Err, From: E->getMemberLoc());
8824 if (Err)
8825 return std::move(Err);
8826 DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);
8827
8828 // Import additional name location/type info.
8829 if (Error Err =
8830 ImportDeclarationNameLoc(From: E->getMemberNameInfo(), To&: ToMemberNameInfo))
8831 return std::move(Err);
8832
8833 return CXXDependentScopeMemberExpr::Create(
8834 Ctx: Importer.getToContext(), Base: ToBase, BaseType: ToType, IsArrow: E->isArrow(), OperatorLoc: ToOperatorLoc,
8835 QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc, FirstQualifierFoundInScope: ToFirstQualifierFoundInScope,
8836 MemberNameInfo: ToMemberNameInfo, TemplateArgs: ResInfo);
8837}
8838
8839ExpectedStmt
8840ASTNodeImporter::VisitDependentTemplateIdExpr(DependentTemplateIdExpr *E) {
8841 Error Err = Error::success();
8842 auto ToName = importChecked(Err, From: E->getTemplateName());
8843 auto ToDeclName = importChecked(Err, From: E->getName());
8844 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8845 if (Err)
8846 return std::move(Err);
8847
8848 DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
8849 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8850 return std::move(Err);
8851
8852 TemplateArgumentListInfo ToTAInfo;
8853 if (Error Err =
8854 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8855 Container: E->template_arguments(), Result&: ToTAInfo))
8856 return std::move(Err);
8857
8858 return DependentTemplateIdExpr::Create(Context: Importer.getToContext(), NameInfo: ToNameInfo,
8859 Name: ToName, TemplateArgs: ToTAInfo);
8860}
8861
8862ExpectedStmt
8863ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
8864 Error Err = Error::success();
8865 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8866 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8867 auto ToDeclName = importChecked(Err, From: E->getDeclName());
8868 auto ToNameLoc = importChecked(Err, From: E->getNameInfo().getLoc());
8869 auto ToLAngleLoc = importChecked(Err, From: E->getLAngleLoc());
8870 auto ToRAngleLoc = importChecked(Err, From: E->getRAngleLoc());
8871 if (Err)
8872 return std::move(Err);
8873
8874 DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
8875 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8876 return std::move(Err);
8877
8878 TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
8879 TemplateArgumentListInfo *ResInfo = nullptr;
8880 if (E->hasExplicitTemplateArgs()) {
8881 if (Error Err =
8882 ImportTemplateArgumentListInfo(Container: E->template_arguments(), ToTAInfo))
8883 return std::move(Err);
8884 ResInfo = &ToTAInfo;
8885 }
8886
8887 return DependentScopeDeclRefExpr::Create(
8888 Context: Importer.getToContext(), QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
8889 NameInfo: ToNameInfo, TemplateArgs: ResInfo);
8890}
8891
8892ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
8893 CXXUnresolvedConstructExpr *E) {
8894 Error Err = Error::success();
8895 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
8896 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8897 auto ToType = importChecked(Err, From: E->getType());
8898 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8899 if (Err)
8900 return std::move(Err);
8901
8902 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8903 if (Error Err =
8904 ImportArrayChecked(Ibegin: E->arg_begin(), Iend: E->arg_end(), Obegin: ToArgs.begin()))
8905 return std::move(Err);
8906
8907 return CXXUnresolvedConstructExpr::Create(
8908 Context: Importer.getToContext(), T: ToType, TSI: ToTypeSourceInfo, LParenLoc: ToLParenLoc,
8909 Args: ArrayRef(ToArgs), RParenLoc: ToRParenLoc, IsListInit: E->isListInitialization());
8910}
8911
8912ExpectedStmt
8913ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
8914 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(From: E->getNamingClass());
8915 if (!ToNamingClassOrErr)
8916 return ToNamingClassOrErr.takeError();
8917
8918 auto ToQualifierLocOrErr = import(From: E->getQualifierLoc());
8919 if (!ToQualifierLocOrErr)
8920 return ToQualifierLocOrErr.takeError();
8921
8922 Error Err = Error::success();
8923 auto ToName = importChecked(Err, From: E->getName());
8924 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8925 if (Err)
8926 return std::move(Err);
8927 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
8928
8929 // Import additional name location/type info.
8930 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8931 return std::move(Err);
8932
8933 UnresolvedSet<8> ToDecls;
8934 for (auto *D : E->decls())
8935 if (auto ToDOrErr = import(From: D))
8936 ToDecls.addDecl(D: cast<NamedDecl>(Val: *ToDOrErr));
8937 else
8938 return ToDOrErr.takeError();
8939
8940 if (E->hasExplicitTemplateArgs()) {
8941 TemplateArgumentListInfo ToTAInfo;
8942 if (Error Err = ImportTemplateArgumentListInfo(
8943 FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(), Container: E->template_arguments(),
8944 Result&: ToTAInfo))
8945 return std::move(Err);
8946
8947 ExpectedSLoc ToTemplateKeywordLocOrErr = import(From: E->getTemplateKeywordLoc());
8948 if (!ToTemplateKeywordLocOrErr)
8949 return ToTemplateKeywordLocOrErr.takeError();
8950
8951 const bool KnownDependent =
8952 (E->getDependence() & ExprDependence::TypeValue) ==
8953 ExprDependence::TypeValue;
8954 return UnresolvedLookupExpr::Create(
8955 Context: Importer.getToContext(), NamingClass: *ToNamingClassOrErr, QualifierLoc: *ToQualifierLocOrErr,
8956 TemplateKWLoc: *ToTemplateKeywordLocOrErr, NameInfo: ToNameInfo, RequiresADL: E->requiresADL(), Args: &ToTAInfo,
8957 Begin: ToDecls.begin(), End: ToDecls.end(), KnownDependent,
8958 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8959 }
8960
8961 return UnresolvedLookupExpr::Create(
8962 Context: Importer.getToContext(), NamingClass: *ToNamingClassOrErr, QualifierLoc: *ToQualifierLocOrErr,
8963 NameInfo: ToNameInfo, RequiresADL: E->requiresADL(), Begin: ToDecls.begin(), End: ToDecls.end(),
8964 /*KnownDependent=*/E->isTypeDependent(),
8965 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8966}
8967
8968ExpectedStmt
8969ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
8970 Error Err = Error::success();
8971 auto ToType = importChecked(Err, From: E->getType());
8972 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8973 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8974 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8975 auto ToName = importChecked(Err, From: E->getName());
8976 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8977 if (Err)
8978 return std::move(Err);
8979
8980 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
8981 // Import additional name location/type info.
8982 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8983 return std::move(Err);
8984
8985 UnresolvedSet<8> ToDecls;
8986 for (Decl *D : E->decls())
8987 if (auto ToDOrErr = import(From: D))
8988 ToDecls.addDecl(D: cast<NamedDecl>(Val: *ToDOrErr));
8989 else
8990 return ToDOrErr.takeError();
8991
8992 TemplateArgumentListInfo ToTAInfo;
8993 TemplateArgumentListInfo *ResInfo = nullptr;
8994 if (E->hasExplicitTemplateArgs()) {
8995 TemplateArgumentListInfo FromTAInfo;
8996 E->copyTemplateArgumentsInto(List&: FromTAInfo);
8997 if (Error Err = ImportTemplateArgumentListInfo(From: FromTAInfo, Result&: ToTAInfo))
8998 return std::move(Err);
8999 ResInfo = &ToTAInfo;
9000 }
9001
9002 Expr *ToBase = nullptr;
9003 if (!E->isImplicitAccess()) {
9004 if (ExpectedExpr ToBaseOrErr = import(From: E->getBase()))
9005 ToBase = *ToBaseOrErr;
9006 else
9007 return ToBaseOrErr.takeError();
9008 }
9009
9010 return UnresolvedMemberExpr::Create(
9011 Context: Importer.getToContext(), HasUnresolvedUsing: E->hasUnresolvedUsing(), Base: ToBase, BaseType: ToType,
9012 IsArrow: E->isArrow(), OperatorLoc: ToOperatorLoc, QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
9013 MemberNameInfo: ToNameInfo, TemplateArgs: ResInfo, Begin: ToDecls.begin(), End: ToDecls.end());
9014}
9015
9016ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
9017 Error Err = Error::success();
9018 auto ToCallee = importChecked(Err, From: E->getCallee());
9019 auto ToType = importChecked(Err, From: E->getType());
9020 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9021 if (Err)
9022 return std::move(Err);
9023
9024 unsigned NumArgs = E->getNumArgs();
9025 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
9026 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
9027 return std::move(Err);
9028
9029 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(Val: E)) {
9030 return CXXOperatorCallExpr::Create(
9031 Ctx: Importer.getToContext(), OpKind: OCE->getOperator(), Fn: ToCallee, Args: ToArgs, Ty: ToType,
9032 VK: OCE->getValueKind(), OperatorLoc: ToRParenLoc, FPFeatures: OCE->getFPFeatures(),
9033 UsesADL: OCE->getADLCallKind());
9034 }
9035
9036 return CallExpr::Create(Ctx: Importer.getToContext(), Fn: ToCallee, Args: ToArgs, Ty: ToType,
9037 VK: E->getValueKind(), RParenLoc: ToRParenLoc, FPFeatures: E->getFPFeatures(),
9038 /*MinNumArgs=*/0, UsesADL: E->getADLCallKind());
9039}
9040
9041ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
9042 CXXRecordDecl *FromClass = E->getLambdaClass();
9043 auto ToClassOrErr = import(From: FromClass);
9044 if (!ToClassOrErr)
9045 return ToClassOrErr.takeError();
9046 CXXRecordDecl *ToClass = *ToClassOrErr;
9047
9048 auto ToCallOpOrErr = import(From: E->getCallOperator());
9049 if (!ToCallOpOrErr)
9050 return ToCallOpOrErr.takeError();
9051
9052 SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
9053 if (Error Err = ImportContainerChecked(InContainer: E->capture_inits(), OutContainer&: ToCaptureInits))
9054 return std::move(Err);
9055
9056 Error Err = Error::success();
9057 auto ToIntroducerRange = importChecked(Err, From: E->getIntroducerRange());
9058 auto ToCaptureDefaultLoc = importChecked(Err, From: E->getCaptureDefaultLoc());
9059 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9060 if (Err)
9061 return std::move(Err);
9062
9063 return LambdaExpr::Create(C: Importer.getToContext(), Class: ToClass, IntroducerRange: ToIntroducerRange,
9064 CaptureDefault: E->getCaptureDefault(), CaptureDefaultLoc: ToCaptureDefaultLoc,
9065 ExplicitParams: E->hasExplicitParameters(),
9066 ExplicitResultType: E->hasExplicitResultType(), CaptureInits: ToCaptureInits,
9067 ClosingBrace: ToEndLoc, ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
9068}
9069
9070
9071ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
9072 Error Err = Error::success();
9073 auto ToLBraceLoc = importChecked(Err, From: E->getLBraceLoc());
9074 auto ToRBraceLoc = importChecked(Err, From: E->getRBraceLoc());
9075 auto ToType = importChecked(Err, From: E->getType());
9076 if (Err)
9077 return std::move(Err);
9078
9079 SmallVector<Expr *, 4> ToExprs(E->getNumInits());
9080 if (Error Err = ImportContainerChecked(InContainer: E->inits(), OutContainer&: ToExprs))
9081 return std::move(Err);
9082
9083 ASTContext &ToCtx = Importer.getToContext();
9084 InitListExpr *To = new (ToCtx)
9085 InitListExpr(ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc, E->isExplicit());
9086 To->setType(ToType);
9087
9088 if (E->hasArrayFiller()) {
9089 if (ExpectedExpr ToFillerOrErr = import(From: E->getArrayFiller()))
9090 To->setArrayFiller(*ToFillerOrErr);
9091 else
9092 return ToFillerOrErr.takeError();
9093 }
9094
9095 if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
9096 if (auto ToFDOrErr = import(From: FromFD))
9097 To->setInitializedFieldInUnion(*ToFDOrErr);
9098 else
9099 return ToFDOrErr.takeError();
9100 }
9101
9102 if (InitListExpr *SyntForm = E->getSyntacticForm()) {
9103 if (auto ToSyntFormOrErr = import(From: SyntForm))
9104 To->setSyntacticForm(*ToSyntFormOrErr);
9105 else
9106 return ToSyntFormOrErr.takeError();
9107 }
9108
9109 // Copy InitListExprBitfields, which are not handled in the ctor of
9110 // InitListExpr.
9111 To->sawArrayRangeDesignator(ARD: E->hadArrayRangeDesignator());
9112
9113 return To;
9114}
9115
9116ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
9117 CXXStdInitializerListExpr *E) {
9118 ExpectedType ToTypeOrErr = import(From: E->getType());
9119 if (!ToTypeOrErr)
9120 return ToTypeOrErr.takeError();
9121
9122 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
9123 if (!ToSubExprOrErr)
9124 return ToSubExprOrErr.takeError();
9125
9126 return new (Importer.getToContext()) CXXStdInitializerListExpr(
9127 *ToTypeOrErr, *ToSubExprOrErr);
9128}
9129
9130ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
9131 CXXInheritedCtorInitExpr *E) {
9132 Error Err = Error::success();
9133 auto ToLocation = importChecked(Err, From: E->getLocation());
9134 auto ToType = importChecked(Err, From: E->getType());
9135 auto ToConstructor = importChecked(Err, From: E->getConstructor());
9136 if (Err)
9137 return std::move(Err);
9138
9139 return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
9140 ToLocation, ToType, ToConstructor, E->constructsVBase(),
9141 E->inheritedFromVBase());
9142}
9143
9144ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
9145 Error Err = Error::success();
9146 auto ToType = importChecked(Err, From: E->getType());
9147 auto ToCommonExpr = importChecked(Err, From: E->getCommonExpr());
9148 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
9149 if (Err)
9150 return std::move(Err);
9151
9152 return new (Importer.getToContext()) ArrayInitLoopExpr(
9153 ToType, ToCommonExpr, ToSubExpr);
9154}
9155
9156ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
9157 ExpectedType ToTypeOrErr = import(From: E->getType());
9158 if (!ToTypeOrErr)
9159 return ToTypeOrErr.takeError();
9160 return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
9161}
9162
9163ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9164 ExpectedSLoc ToBeginLocOrErr = import(From: E->getBeginLoc());
9165 if (!ToBeginLocOrErr)
9166 return ToBeginLocOrErr.takeError();
9167
9168 auto ToFieldOrErr = import(From: E->getField());
9169 if (!ToFieldOrErr)
9170 return ToFieldOrErr.takeError();
9171
9172 auto UsedContextOrErr = Importer.ImportContext(FromDC: E->getUsedContext());
9173 if (!UsedContextOrErr)
9174 return UsedContextOrErr.takeError();
9175
9176 FieldDecl *ToField = *ToFieldOrErr;
9177 assert(ToField->hasInClassInitializer() &&
9178 "Field should have in-class initializer if there is a default init "
9179 "expression that uses it.");
9180 if (!ToField->getInClassInitializer()) {
9181 // The in-class initializer may be not yet set in "To" AST even if the
9182 // field is already there. This must be set here to make construction of
9183 // CXXDefaultInitExpr work.
9184 auto ToInClassInitializerOrErr =
9185 import(From: E->getField()->getInClassInitializer());
9186 if (!ToInClassInitializerOrErr)
9187 return ToInClassInitializerOrErr.takeError();
9188 ToField->setInClassInitializer(*ToInClassInitializerOrErr);
9189 }
9190
9191 Expr *RewrittenInit = nullptr;
9192 if (E->hasRewrittenInit()) {
9193 ExpectedExpr ExprOrErr = import(From: E->getRewrittenExpr());
9194 if (!ExprOrErr)
9195 return ExprOrErr.takeError();
9196 RewrittenInit = ExprOrErr.get();
9197 }
9198
9199 return CXXDefaultInitExpr::Create(Ctx: Importer.getToContext(), Loc: *ToBeginLocOrErr,
9200 Field: ToField, UsedContext: *UsedContextOrErr, RewrittenInitExpr: RewrittenInit);
9201}
9202
9203ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
9204 Error Err = Error::success();
9205 auto ToType = importChecked(Err, From: E->getType());
9206 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
9207 auto ToTypeInfoAsWritten = importChecked(Err, From: E->getTypeInfoAsWritten());
9208 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
9209 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9210 auto ToAngleBrackets = importChecked(Err, From: E->getAngleBrackets());
9211 if (Err)
9212 return std::move(Err);
9213
9214 ExprValueKind VK = E->getValueKind();
9215 CastKind CK = E->getCastKind();
9216 auto ToBasePathOrErr = ImportCastPath(CE: E);
9217 if (!ToBasePathOrErr)
9218 return ToBasePathOrErr.takeError();
9219
9220 if (auto CCE = dyn_cast<CXXStaticCastExpr>(Val: E)) {
9221 return CXXStaticCastExpr::Create(
9222 Context: Importer.getToContext(), T: ToType, VK, K: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9223 Written: ToTypeInfoAsWritten, FPO: CCE->getFPFeatures(), L: ToOperatorLoc, RParenLoc: ToRParenLoc,
9224 AngleBrackets: ToAngleBrackets);
9225 } else if (isa<CXXDynamicCastExpr>(Val: E)) {
9226 return CXXDynamicCastExpr::Create(
9227 Context: Importer.getToContext(), T: ToType, VK, Kind: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9228 Written: ToTypeInfoAsWritten, L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9229 } else if (isa<CXXReinterpretCastExpr>(Val: E)) {
9230 return CXXReinterpretCastExpr::Create(
9231 Context: Importer.getToContext(), T: ToType, VK, Kind: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9232 WrittenTy: ToTypeInfoAsWritten, L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9233 } else if (isa<CXXConstCastExpr>(Val: E)) {
9234 return CXXConstCastExpr::Create(
9235 Context: Importer.getToContext(), T: ToType, VK, Op: ToSubExpr, WrittenTy: ToTypeInfoAsWritten,
9236 L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9237 } else {
9238 llvm_unreachable("Unknown cast type");
9239 return make_error<ASTImportError>();
9240 }
9241}
9242
9243ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
9244 SubstNonTypeTemplateParmExpr *E) {
9245 Error Err = Error::success();
9246 auto ToType = importChecked(Err, From: E->getType());
9247 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
9248 auto ToAssociatedDecl = importChecked(Err, From: E->getAssociatedDecl());
9249 auto ToParamType = importChecked(Err, From: E->getParameterType());
9250 auto ToReplacement = importChecked(Err, From: E->getReplacement());
9251 if (Err)
9252 return std::move(Err);
9253
9254 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
9255 ToType, E->getValueKind(), ToNameLoc, ToReplacement, ToAssociatedDecl,
9256 ToParamType, E->getIndex(), E->getPackIndex(), E->getFinal());
9257}
9258
9259ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
9260 Error Err = Error::success();
9261 auto ToType = importChecked(Err, From: E->getType());
9262 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
9263 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9264 if (Err)
9265 return std::move(Err);
9266
9267 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
9268 if (Error Err = ImportContainerChecked(InContainer: E->getArgs(), OutContainer&: ToArgs))
9269 return std::move(Err);
9270
9271 if (E->isStoredAsBoolean()) {
9272 // According to Sema::BuildTypeTrait(), if E is value-dependent,
9273 // Value is always false.
9274 bool ToValue = (E->isValueDependent() ? false : E->getBoolValue());
9275 return TypeTraitExpr::Create(C: Importer.getToContext(), T: ToType, Loc: ToBeginLoc,
9276 Kind: E->getTrait(), Args: ToArgs, RParenLoc: ToEndLoc, Value: ToValue);
9277 }
9278 return TypeTraitExpr::Create(C: Importer.getToContext(), T: ToType, Loc: ToBeginLoc,
9279 Kind: E->getTrait(), Args: ToArgs, RParenLoc: ToEndLoc,
9280 Value: E->getAPValue());
9281}
9282
9283ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
9284 ExpectedType ToTypeOrErr = import(From: E->getType());
9285 if (!ToTypeOrErr)
9286 return ToTypeOrErr.takeError();
9287
9288 auto ToSourceRangeOrErr = import(From: E->getSourceRange());
9289 if (!ToSourceRangeOrErr)
9290 return ToSourceRangeOrErr.takeError();
9291
9292 if (E->isTypeOperand()) {
9293 if (auto ToTSIOrErr = import(From: E->getTypeOperandSourceInfo()))
9294 return new (Importer.getToContext()) CXXTypeidExpr(
9295 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
9296 else
9297 return ToTSIOrErr.takeError();
9298 }
9299
9300 ExpectedExpr ToExprOperandOrErr = import(From: E->getExprOperand());
9301 if (!ToExprOperandOrErr)
9302 return ToExprOperandOrErr.takeError();
9303
9304 return new (Importer.getToContext()) CXXTypeidExpr(
9305 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
9306}
9307
9308ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
9309 Error Err = Error::success();
9310
9311 QualType ToType = importChecked(Err, From: E->getType());
9312 UnresolvedLookupExpr *ToCallee = importChecked(Err, From: E->getCallee());
9313 SourceLocation ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
9314 Expr *ToLHS = importChecked(Err, From: E->getLHS());
9315 SourceLocation ToEllipsisLoc = importChecked(Err, From: E->getEllipsisLoc());
9316 Expr *ToRHS = importChecked(Err, From: E->getRHS());
9317 SourceLocation ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9318
9319 if (Err)
9320 return std::move(Err);
9321
9322 return new (Importer.getToContext())
9323 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
9324 ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
9325}
9326
9327ExpectedStmt ASTNodeImporter::VisitRequiresExpr(RequiresExpr *E) {
9328 Error Err = Error::success();
9329 auto RequiresKWLoc = importChecked(Err, From: E->getRequiresKWLoc());
9330 auto RParenLoc = importChecked(Err, From: E->getRParenLoc());
9331 auto RBraceLoc = importChecked(Err, From: E->getRBraceLoc());
9332
9333 auto Body = importChecked(Err, From: E->getBody());
9334 auto LParenLoc = importChecked(Err, From: E->getLParenLoc());
9335 if (Err)
9336 return std::move(Err);
9337 SmallVector<ParmVarDecl *, 4> LocalParameters(E->getLocalParameters().size());
9338 if (Error Err =
9339 ImportArrayChecked(InContainer: E->getLocalParameters(), Obegin: LocalParameters.begin()))
9340 return std::move(Err);
9341 SmallVector<concepts::Requirement *, 4> Requirements(
9342 E->getRequirements().size());
9343 if (Error Err =
9344 ImportArrayChecked(InContainer: E->getRequirements(), Obegin: Requirements.begin()))
9345 return std::move(Err);
9346 return RequiresExpr::Create(C&: Importer.getToContext(), RequiresKWLoc, Body,
9347 LParenLoc, LocalParameters, RParenLoc,
9348 Requirements, RBraceLoc);
9349}
9350
9351ExpectedStmt
9352ASTNodeImporter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
9353 Error Err = Error::success();
9354 auto CL = importChecked(Err, From: E->getConceptReference());
9355 auto CSD = importChecked(Err, From: E->getSpecializationDecl());
9356 if (Err)
9357 return std::move(Err);
9358 if (E->isValueDependent())
9359 return ConceptSpecializationExpr::Create(
9360 C: Importer.getToContext(), ConceptRef: CL,
9361 SpecDecl: const_cast<ImplicitConceptSpecializationDecl *>(CSD), Satisfaction: nullptr);
9362 ConstraintSatisfaction Satisfaction;
9363 if (Error Err =
9364 ImportConstraintSatisfaction(FromSat: E->getSatisfaction(), ToSat&: Satisfaction))
9365 return std::move(Err);
9366 return ConceptSpecializationExpr::Create(
9367 C: Importer.getToContext(), ConceptRef: CL,
9368 SpecDecl: const_cast<ImplicitConceptSpecializationDecl *>(CSD), Satisfaction: &Satisfaction);
9369}
9370
9371ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmPackExpr(
9372 SubstNonTypeTemplateParmPackExpr *E) {
9373 Error Err = Error::success();
9374 auto ToType = importChecked(Err, From: E->getType());
9375 auto ToPackLoc = importChecked(Err, From: E->getParameterPackLocation());
9376 auto ToArgPack = importChecked(Err, From: E->getArgumentPack());
9377 auto ToAssociatedDecl = importChecked(Err, From: E->getAssociatedDecl());
9378 if (Err)
9379 return std::move(Err);
9380
9381 return new (Importer.getToContext()) SubstNonTypeTemplateParmPackExpr(
9382 ToType, E->getValueKind(), ToPackLoc, ToArgPack, ToAssociatedDecl,
9383 E->getIndex(), E->getFinal());
9384}
9385
9386ExpectedStmt ASTNodeImporter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
9387 SmallVector<Expr *, 4> ToSemantics(E->getNumSemanticExprs());
9388 if (Error Err = ImportContainerChecked(InContainer: E->semantics(), OutContainer&: ToSemantics))
9389 return std::move(Err);
9390 auto ToSyntOrErr = import(From: E->getSyntacticForm());
9391 if (!ToSyntOrErr)
9392 return ToSyntOrErr.takeError();
9393 return PseudoObjectExpr::Create(Context: Importer.getToContext(), syntactic: *ToSyntOrErr,
9394 semantic: ToSemantics, resultIndex: E->getResultExprIndex());
9395}
9396
9397ExpectedStmt
9398ASTNodeImporter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
9399 Error Err = Error::success();
9400 auto ToType = importChecked(Err, From: E->getType());
9401 auto ToInitLoc = importChecked(Err, From: E->getInitLoc());
9402 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
9403 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9404 if (Err)
9405 return std::move(Err);
9406
9407 SmallVector<Expr *, 4> ToArgs(E->getInitExprs().size());
9408 if (Error Err = ImportContainerChecked(InContainer: E->getInitExprs(), OutContainer&: ToArgs))
9409 return std::move(Err);
9410 return CXXParenListInitExpr::Create(C&: Importer.getToContext(), Args: ToArgs, T: ToType,
9411 NumUserSpecifiedExprs: E->getUserSpecifiedInitExprs().size(),
9412 InitLoc: ToInitLoc, LParenLoc: ToBeginLoc, RParenLoc: ToEndLoc);
9413}
9414
9415ExpectedStmt
9416ASTNodeImporter::VisitCXXExpansionSelectExpr(CXXExpansionSelectExpr *E) {
9417 Error Err = Error::success();
9418 auto ToRange = importChecked(Err, From: E->getRangeExpr());
9419 auto ToIndex = importChecked(Err, From: E->getIndexExpr());
9420 if (Err)
9421 return std::move(Err);
9422
9423 return new (Importer.getToContext())
9424 CXXExpansionSelectExpr(Importer.getToContext(), ToRange, ToIndex);
9425}
9426
9427Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
9428 CXXMethodDecl *FromMethod) {
9429 Error ImportErrors = Error::success();
9430 for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
9431 if (auto ImportedOrErr = import(From: FromOverriddenMethod))
9432 ToMethod->getCanonicalDecl()->addOverriddenMethod(MD: cast<CXXMethodDecl>(
9433 Val: (*ImportedOrErr)->getCanonicalDecl()));
9434 else
9435 ImportErrors =
9436 joinErrors(E1: std::move(ImportErrors), E2: ImportedOrErr.takeError());
9437 }
9438 return ImportErrors;
9439}
9440
9441ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
9442 ASTContext &FromContext, FileManager &FromFileManager,
9443 bool MinimalImport,
9444 std::shared_ptr<ASTImporterSharedState> SharedState)
9445 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
9446 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
9447 Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {
9448
9449 // Create a default state without the lookup table: LLDB case.
9450 if (!SharedState) {
9451 this->SharedState = std::make_shared<ASTImporterSharedState>();
9452 }
9453
9454 ImportedDecls[FromContext.getTranslationUnitDecl()] =
9455 ToContext.getTranslationUnitDecl();
9456}
9457
9458ASTImporter::~ASTImporter() = default;
9459
9460UnsignedOrNone ASTImporter::getFieldIndex(Decl *F) {
9461 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
9462 "Try to get field index for non-field.");
9463
9464 auto *Owner = dyn_cast<RecordDecl>(Val: F->getDeclContext());
9465 if (!Owner)
9466 return std::nullopt;
9467
9468 unsigned Index = 0;
9469 for (const auto *D : Owner->decls()) {
9470 if (D == F)
9471 return Index;
9472
9473 if (isa<FieldDecl>(Val: *D) || isa<IndirectFieldDecl>(Val: *D))
9474 ++Index;
9475 }
9476
9477 llvm_unreachable("Field was not found in its parent context.");
9478
9479 return std::nullopt;
9480}
9481
9482ASTImporter::FoundDeclsTy
9483ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
9484 // We search in the redecl context because of transparent contexts.
9485 // E.g. a simple C language enum is a transparent context:
9486 // enum E { A, B };
9487 // Now if we had a global variable in the TU
9488 // int A;
9489 // then the enum constant 'A' and the variable 'A' violates ODR.
9490 // We can diagnose this only if we search in the redecl context.
9491 DeclContext *ReDC = DC->getRedeclContext();
9492 if (SharedState->getLookupTable()) {
9493 if (ReDC->isNamespace()) {
9494 // Namespaces can be reopened.
9495 // Lookup table does not handle this, we must search here in all linked
9496 // namespaces.
9497 FoundDeclsTy Result;
9498 SmallVector<Decl *, 2> NSChain =
9499 getCanonicalForwardRedeclChain<NamespaceDecl>(
9500 D: dyn_cast<NamespaceDecl>(Val: ReDC));
9501 for (auto *D : NSChain) {
9502 ASTImporterLookupTable::LookupResult LookupResult =
9503 SharedState->getLookupTable()->lookup(DC: dyn_cast<NamespaceDecl>(Val: D),
9504 Name);
9505 Result.append(in_start: LookupResult.begin(), in_end: LookupResult.end());
9506 }
9507 return Result;
9508 } else {
9509 ASTImporterLookupTable::LookupResult LookupResult =
9510 SharedState->getLookupTable()->lookup(DC: ReDC, Name);
9511 return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
9512 }
9513 } else {
9514 DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
9515 FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
9516 // We must search by the slow case of localUncachedLookup because that is
9517 // working even if there is no LookupPtr for the DC. We could use
9518 // DC::buildLookup() to create the LookupPtr, but that would load external
9519 // decls again, we must avoid that case.
9520 // Also, even if we had the LookupPtr, we must find Decls which are not
9521 // in the LookupPtr, so we need the slow case.
9522 // These cases are handled in ASTImporterLookupTable, but we cannot use
9523 // that with LLDB since that traverses through the AST which initiates the
9524 // load of external decls again via DC::decls(). And again, we must avoid
9525 // loading external decls during the import.
9526 if (Result.empty())
9527 ReDC->localUncachedLookup(Name, Results&: Result);
9528 return Result;
9529 }
9530}
9531
9532void ASTImporter::AddToLookupTable(Decl *ToD) {
9533 SharedState->addDeclToLookup(D: ToD);
9534}
9535
9536Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
9537 // Import the decl using ASTNodeImporter.
9538 ASTNodeImporter Importer(*this);
9539 return Importer.Visit(D: FromD);
9540}
9541
9542void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
9543 MapImported(From: FromD, To: ToD);
9544}
9545
9546llvm::Expected<ExprWithCleanups::CleanupObject>
9547ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
9548 if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
9549 if (Expected<Expr *> R = Import(FromE: CLE))
9550 return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(Val: *R));
9551 }
9552
9553 // FIXME: Handle BlockDecl when we implement importing BlockExpr in
9554 // ASTNodeImporter.
9555 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
9556}
9557
9558ExpectedTypePtr ASTImporter::Import(const Type *FromT) {
9559 if (!FromT)
9560 return FromT;
9561
9562 // Check whether we've already imported this type.
9563 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9564 ImportedTypes.find(Val: FromT);
9565 if (Pos != ImportedTypes.end())
9566 return Pos->second;
9567
9568 // Import the type.
9569 ASTNodeImporter Importer(*this);
9570 ExpectedType ToTOrErr = Importer.Visit(T: FromT);
9571 if (!ToTOrErr)
9572 return ToTOrErr.takeError();
9573
9574 // Record the imported type.
9575 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9576
9577 return ToTOrErr->getTypePtr();
9578}
9579
9580Expected<QualType> ASTImporter::Import(QualType FromT) {
9581 if (FromT.isNull())
9582 return QualType{};
9583
9584 ExpectedTypePtr ToTyOrErr = Import(FromT: FromT.getTypePtr());
9585 if (!ToTyOrErr)
9586 return ToTyOrErr.takeError();
9587
9588 return ToContext.getQualifiedType(T: *ToTyOrErr, Qs: FromT.getLocalQualifiers());
9589}
9590
9591Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
9592 if (!FromTSI)
9593 return FromTSI;
9594
9595 // FIXME: For now we just create a "trivial" type source info based
9596 // on the type and a single location. Implement a real version of this.
9597 ExpectedType TOrErr = Import(FromT: FromTSI->getType());
9598 if (!TOrErr)
9599 return TOrErr.takeError();
9600 ExpectedSLoc BeginLocOrErr = Import(FromLoc: FromTSI->getTypeLoc().getBeginLoc());
9601 if (!BeginLocOrErr)
9602 return BeginLocOrErr.takeError();
9603
9604 return ToContext.getTrivialTypeSourceInfo(T: *TOrErr, Loc: *BeginLocOrErr);
9605}
9606
9607namespace {
9608// To use this object, it should be created before the new attribute is created,
9609// and destructed after it is created. The construction already performs the
9610// import of the data.
9611template <typename T> struct AttrArgImporter {
9612 AttrArgImporter(const AttrArgImporter<T> &) = delete;
9613 AttrArgImporter(AttrArgImporter<T> &&) = default;
9614 AttrArgImporter<T> &operator=(const AttrArgImporter<T> &) = delete;
9615 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) = default;
9616
9617 AttrArgImporter(ASTNodeImporter &I, Error &Err, const T &From)
9618 : To(I.importChecked(Err, From)) {}
9619
9620 const T &value() { return To; }
9621
9622private:
9623 T To;
9624};
9625
9626// To use this object, it should be created before the new attribute is created,
9627// and destructed after it is created. The construction already performs the
9628// import of the data. The array data is accessible in a pointer form, this form
9629// is used by the attribute classes. This object should be created once for the
9630// array data to be imported (the array size is not imported, just copied).
9631template <typename T> struct AttrArgArrayImporter {
9632 AttrArgArrayImporter(const AttrArgArrayImporter<T> &) = delete;
9633 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) = default;
9634 AttrArgArrayImporter<T> &operator=(const AttrArgArrayImporter<T> &) = delete;
9635 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) = default;
9636
9637 AttrArgArrayImporter(ASTNodeImporter &I, Error &Err,
9638 const llvm::iterator_range<T *> &From,
9639 unsigned ArraySize) {
9640 if (Err)
9641 return;
9642 To.reserve(ArraySize);
9643 Err = I.ImportContainerChecked(From, To);
9644 }
9645
9646 T *value() { return To.data(); }
9647
9648private:
9649 llvm::SmallVector<T, 2> To;
9650};
9651
9652class AttrImporter {
9653 Error Err{Error::success()};
9654 Attr *ToAttr = nullptr;
9655 ASTImporter &Importer;
9656 ASTNodeImporter NImporter;
9657
9658public:
9659 AttrImporter(ASTImporter &I) : Importer(I), NImporter(I) {}
9660
9661 // Create an "importer" for an attribute parameter.
9662 // Result of the 'value()' of that object is to be passed to the function
9663 // 'importAttr', in the order that is expected by the attribute class.
9664 template <class T> AttrArgImporter<T> importArg(const T &From) {
9665 return AttrArgImporter<T>(NImporter, Err, From);
9666 }
9667
9668 // Create an "importer" for an attribute parameter that has array type.
9669 // Result of the 'value()' of that object is to be passed to the function
9670 // 'importAttr', then the size of the array as next argument.
9671 template <typename T>
9672 AttrArgArrayImporter<T> importArrayArg(const llvm::iterator_range<T *> &From,
9673 unsigned ArraySize) {
9674 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9675 }
9676
9677 // Create an attribute object with the specified arguments.
9678 // The 'FromAttr' is the original (not imported) attribute, the 'ImportedArg'
9679 // should be values that are passed to the 'Create' function of the attribute.
9680 // (The 'Create' with 'ASTContext' first and 'AttributeCommonInfo' last is
9681 // used here.) As much data is copied or imported from the old attribute
9682 // as possible. The passed arguments should be already imported.
9683 // If an import error happens, the internal error is set to it, and any
9684 // further import attempt is ignored.
9685 template <typename T, typename... Arg>
9686 void importAttr(const T *FromAttr, Arg &&...ImportedArg) {
9687 static_assert(std::is_base_of<Attr, T>::value,
9688 "T should be subclass of Attr.");
9689 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9690
9691 const IdentifierInfo *ToAttrName = Importer.Import(FromAttr->getAttrName());
9692 const IdentifierInfo *ToScopeName =
9693 Importer.Import(FromAttr->getScopeName());
9694 SourceRange ToAttrRange =
9695 NImporter.importChecked(Err, FromAttr->getRange());
9696 SourceLocation ToScopeLoc =
9697 NImporter.importChecked(Err, FromAttr->getScopeLoc());
9698
9699 if (Err)
9700 return;
9701
9702 AttributeCommonInfo ToI(
9703 ToAttrName, AttributeScopeInfo(ToScopeName, ToScopeLoc), ToAttrRange,
9704 FromAttr->getParsedKind(), FromAttr->getForm());
9705 // The "SemanticSpelling" is not needed to be passed to the constructor.
9706 // That value is recalculated from the SpellingListIndex if needed.
9707 ToAttr = T::Create(Importer.getToContext(),
9708 std::forward<Arg>(ImportedArg)..., ToI);
9709
9710 ToAttr->setImplicit(FromAttr->isImplicit());
9711 ToAttr->setPackExpansion(FromAttr->isPackExpansion());
9712 if (auto *ToInheritableAttr = dyn_cast<InheritableAttr>(Val: ToAttr))
9713 ToInheritableAttr->setInherited(FromAttr->isInherited());
9714 }
9715
9716 // Create a clone of the 'FromAttr' and import its source range only.
9717 // This causes objects with invalid references to be created if the 'FromAttr'
9718 // contains other data that should be imported.
9719 void cloneAttr(const Attr *FromAttr) {
9720 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9721
9722 SourceRange ToRange = NImporter.importChecked(Err, From: FromAttr->getRange());
9723 if (Err)
9724 return;
9725
9726 ToAttr = FromAttr->clone(C&: Importer.getToContext());
9727 ToAttr->setRange(ToRange);
9728 ToAttr->setAttrName(Importer.Import(FromId: FromAttr->getAttrName()));
9729 }
9730
9731 // Get the result of the previous import attempt (can be used only once).
9732 llvm::Expected<Attr *> getResult() && {
9733 if (Err)
9734 return std::move(Err);
9735 assert(ToAttr && "Attribute should be created.");
9736 return ToAttr;
9737 }
9738};
9739} // namespace
9740
9741Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
9742 AttrImporter AI(*this);
9743
9744 // FIXME: Is there some kind of AttrVisitor to use here?
9745 switch (FromAttr->getKind()) {
9746 case attr::Aligned: {
9747 auto *From = cast<AlignedAttr>(Val: FromAttr);
9748 if (From->isAlignmentExpr())
9749 AI.importAttr(FromAttr: From, ImportedArg: true, ImportedArg: AI.importArg(From: From->getAlignmentExpr()).value());
9750 else
9751 AI.importAttr(FromAttr: From, ImportedArg: false,
9752 ImportedArg: AI.importArg(From: From->getAlignmentType()).value());
9753 break;
9754 }
9755
9756 case attr::AlignValue: {
9757 auto *From = cast<AlignValueAttr>(Val: FromAttr);
9758 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getAlignment()).value());
9759 break;
9760 }
9761
9762 case attr::Format: {
9763 const auto *From = cast<FormatAttr>(Val: FromAttr);
9764 AI.importAttr(FromAttr: From, ImportedArg: Import(FromId: From->getType()), ImportedArg: From->getFormatIdx(),
9765 ImportedArg: From->getFirstArg());
9766 break;
9767 }
9768
9769 case attr::EnableIf: {
9770 const auto *From = cast<EnableIfAttr>(Val: FromAttr);
9771 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getCond()).value(),
9772 ImportedArg: From->getMessage());
9773 break;
9774 }
9775
9776 case attr::AssertCapability: {
9777 const auto *From = cast<AssertCapabilityAttr>(Val: FromAttr);
9778 AI.importAttr(FromAttr: From,
9779 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9780 ImportedArg: From->args_size());
9781 break;
9782 }
9783 case attr::AcquireCapability: {
9784 const auto *From = cast<AcquireCapabilityAttr>(Val: FromAttr);
9785 AI.importAttr(FromAttr: From,
9786 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9787 ImportedArg: From->args_size());
9788 break;
9789 }
9790 case attr::TryAcquireCapability: {
9791 const auto *From = cast<TryAcquireCapabilityAttr>(Val: FromAttr);
9792 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getSuccessValue()).value(),
9793 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9794 ImportedArg: From->args_size());
9795 break;
9796 }
9797 case attr::ReleaseCapability: {
9798 const auto *From = cast<ReleaseCapabilityAttr>(Val: FromAttr);
9799 AI.importAttr(FromAttr: From,
9800 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9801 ImportedArg: From->args_size());
9802 break;
9803 }
9804 case attr::RequiresCapability: {
9805 const auto *From = cast<RequiresCapabilityAttr>(Val: FromAttr);
9806 AI.importAttr(FromAttr: From,
9807 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9808 ImportedArg: From->args_size());
9809 break;
9810 }
9811 case attr::GuardedBy: {
9812 const auto *From = cast<GuardedByAttr>(Val: FromAttr);
9813 AI.importAttr(FromAttr: From,
9814 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9815 ImportedArg: From->args_size());
9816 break;
9817 }
9818 case attr::PtGuardedBy: {
9819 const auto *From = cast<PtGuardedByAttr>(Val: FromAttr);
9820 AI.importAttr(FromAttr: From,
9821 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9822 ImportedArg: From->args_size());
9823 break;
9824 }
9825 case attr::AcquiredAfter: {
9826 const auto *From = cast<AcquiredAfterAttr>(Val: FromAttr);
9827 AI.importAttr(FromAttr: From,
9828 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9829 ImportedArg: From->args_size());
9830 break;
9831 }
9832 case attr::AcquiredBefore: {
9833 const auto *From = cast<AcquiredBeforeAttr>(Val: FromAttr);
9834 AI.importAttr(FromAttr: From,
9835 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9836 ImportedArg: From->args_size());
9837 break;
9838 }
9839 case attr::LockReturned: {
9840 const auto *From = cast<LockReturnedAttr>(Val: FromAttr);
9841 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getArg()).value());
9842 break;
9843 }
9844 case attr::LocksExcluded: {
9845 const auto *From = cast<LocksExcludedAttr>(Val: FromAttr);
9846 AI.importAttr(FromAttr: From,
9847 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9848 ImportedArg: From->args_size());
9849 break;
9850 }
9851 default: {
9852 // The default branch works for attributes that have no arguments to import.
9853 // FIXME: Handle every attribute type that has arguments of type to import
9854 // (most often Expr* or Decl* or type) in the switch above.
9855 AI.cloneAttr(FromAttr);
9856 break;
9857 }
9858 }
9859
9860 return std::move(AI).getResult();
9861}
9862
9863Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
9864 return ImportedDecls.lookup(Val: FromD);
9865}
9866
9867TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
9868 auto FromDPos = ImportedFromDecls.find(Val: ToD);
9869 if (FromDPos == ImportedFromDecls.end())
9870 return nullptr;
9871 return FromDPos->second->getTranslationUnitDecl();
9872}
9873
9874Expected<Decl *> ASTImporter::Import(Decl *FromD) {
9875 if (!FromD)
9876 return nullptr;
9877
9878 // Push FromD to the stack, and remove that when we return.
9879 ImportPath.push(D: FromD);
9880 llvm::scope_exit ImportPathBuilder([this]() { ImportPath.pop(); });
9881
9882 // Check whether there was a previous failed import.
9883 // If yes return the existing error.
9884 if (auto Error = getImportDeclErrorIfAny(FromD))
9885 return make_error<ASTImportError>(Args&: *Error);
9886
9887 // Check whether we've already imported this declaration.
9888 Decl *ToD = GetAlreadyImportedOrNull(FromD);
9889 if (ToD) {
9890 // Already imported (possibly from another TU) and with an error.
9891 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9892 setImportDeclError(From: FromD, Error: *Error);
9893 return make_error<ASTImportError>(Args&: *Error);
9894 }
9895
9896 // If FromD has some updated flags after last import, apply it.
9897 updateFlags(From: FromD, To: ToD);
9898 // If we encounter a cycle during an import then we save the relevant part
9899 // of the import path associated to the Decl.
9900 if (ImportPath.hasCycleAtBack())
9901 SavedImportPaths[FromD].push_back(Elt: ImportPath.copyCycleAtBack());
9902 return ToD;
9903 }
9904
9905 // Import the declaration.
9906 ExpectedDecl ToDOrErr = ImportImpl(FromD);
9907 if (!ToDOrErr) {
9908 // Failed to import.
9909
9910 auto Pos = ImportedDecls.find(Val: FromD);
9911 bool ToDWasCreated = Pos != ImportedDecls.end();
9912 // Capture the mapped decl before erasing: the iterator is invalidated by
9913 // the erase below under backward-shift deletion, but it is still needed
9914 // further down to record the import error.
9915 Decl *CreatedToD = ToDWasCreated ? Pos->second : nullptr;
9916 if (ToDWasCreated) {
9917 // Import failed after the object was created.
9918 // Remove all references to it.
9919 auto *ToD = CreatedToD;
9920 ImportedDecls.erase(I: Pos);
9921
9922 // Remove the imported type mapping as well.
9923 // The imported type can point to a declaration that failed to import
9924 // later.
9925 if (const auto *FromTD = dyn_cast<TagDecl>(Val: FromD)) {
9926 if (const Type *FromTy =
9927 getFromContext().getCanonicalTagType(TD: FromTD).getTypePtr()) {
9928 ImportedTypes.erase(Val: FromTy);
9929 }
9930 }
9931
9932 // ImportedDecls and ImportedFromDecls are not symmetric. It may happen
9933 // (e.g. with namespaces) that several decls from the 'from' context are
9934 // mapped to the same decl in the 'to' context. If we removed entries
9935 // from the LookupTable here then we may end up removing them multiple
9936 // times.
9937
9938 // The Lookuptable contains decls only which are in the 'to' context.
9939 // Remove from the Lookuptable only if it is *imported* into the 'to'
9940 // context (and do not remove it if it was added during the initial
9941 // traverse of the 'to' context).
9942 auto PosF = ImportedFromDecls.find(Val: ToD);
9943 if (PosF != ImportedFromDecls.end()) {
9944 // In the case of TypedefNameDecl we create the Decl first and only
9945 // then we import and set its DeclContext. So, the DC might not be set
9946 // when we reach here.
9947 if (ToD->getDeclContext())
9948 SharedState->removeDeclFromLookup(D: ToD);
9949 ImportedFromDecls.erase(I: PosF);
9950 }
9951
9952 // FIXME: AST may contain remaining references to the failed object.
9953 // However, the ImportDeclErrors in the shared state contains all the
9954 // failed objects together with their error.
9955 }
9956
9957 // Error encountered for the first time.
9958 // After takeError the error is not usable any more in ToDOrErr.
9959 // Get a copy of the error object (any more simple solution for this?).
9960 ASTImportError ErrOut;
9961 handleAllErrors(E: ToDOrErr.takeError(),
9962 Handlers: [&ErrOut](const ASTImportError &E) { ErrOut = E; });
9963 setImportDeclError(From: FromD, Error: ErrOut);
9964 // Set the error for the mapped to Decl, which is in the "to" context.
9965 if (ToDWasCreated)
9966 SharedState->setImportDeclError(To: CreatedToD, Error: ErrOut);
9967
9968 // Set the error for all nodes which have been created before we
9969 // recognized the error.
9970 for (const auto &Path : SavedImportPaths[FromD]) {
9971 // The import path contains import-dependency nodes first.
9972 // Save the node that was imported as dependency of the current node.
9973 Decl *PrevFromDi = FromD;
9974 for (Decl *FromDi : Path) {
9975 // Begin and end of the path equals 'FromD', skip it.
9976 if (FromDi == FromD)
9977 continue;
9978 // We should not set import error on a node and all following nodes in
9979 // the path if child import errors are ignored.
9980 if (ChildErrorHandlingStrategy(FromDi).ignoreChildErrorOnParent(
9981 FromChildD: PrevFromDi))
9982 break;
9983 PrevFromDi = FromDi;
9984 setImportDeclError(From: FromDi, Error: ErrOut);
9985
9986 if (const auto *FromTDi = dyn_cast<TagDecl>(Val: FromDi)) {
9987 if (const Type *FromTyi =
9988 getFromContext().getCanonicalTagType(TD: FromTDi).getTypePtr()) {
9989 ImportedTypes.erase(Val: FromTyi);
9990 }
9991 }
9992
9993 //FIXME Should we remove these Decls from ImportedDecls?
9994 // Set the error for the mapped to Decl, which is in the "to" context.
9995 auto Ii = ImportedDecls.find(Val: FromDi);
9996 if (Ii != ImportedDecls.end())
9997 SharedState->setImportDeclError(To: Ii->second, Error: ErrOut);
9998 // FIXME Should we remove these Decls from the LookupTable,
9999 // and from ImportedFromDecls?
10000 }
10001 }
10002 SavedImportPaths.erase(Val: FromD);
10003
10004 // Do not return ToDOrErr, error was taken out of it.
10005 return make_error<ASTImportError>(Args&: ErrOut);
10006 }
10007
10008 ToD = *ToDOrErr;
10009
10010 // FIXME: Handle the "already imported with error" case. We can get here
10011 // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
10012 // previously failed create was requested).
10013 // Later GetImportedOrCreateDecl can be updated to return the error.
10014 if (!ToD) {
10015 auto Err = getImportDeclErrorIfAny(FromD);
10016 assert(Err);
10017 return make_error<ASTImportError>(Args&: *Err);
10018 }
10019
10020 // We could import from the current TU without error. But previously we
10021 // already had imported a Decl as `ToD` from another TU (with another
10022 // ASTImporter object) and with an error.
10023 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
10024 setImportDeclError(From: FromD, Error: *Error);
10025 return make_error<ASTImportError>(Args&: *Error);
10026 }
10027 // Make sure that ImportImpl registered the imported decl.
10028 assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
10029
10030 if (FromD->hasAttrs())
10031 for (const Attr *FromAttr : FromD->getAttrs()) {
10032 auto ToAttrOrErr = Import(FromAttr);
10033 if (ToAttrOrErr)
10034 ToD->addAttr(A: *ToAttrOrErr);
10035 else
10036 return ToAttrOrErr.takeError();
10037 }
10038
10039 // Notify subclasses.
10040 Imported(From: FromD, To: ToD);
10041
10042 updateFlags(From: FromD, To: ToD);
10043 SavedImportPaths.erase(Val: FromD);
10044 return ToDOrErr;
10045}
10046
10047llvm::Expected<InheritedConstructor>
10048ASTImporter::Import(const InheritedConstructor &From) {
10049 return ASTNodeImporter(*this).ImportInheritedConstructor(From);
10050}
10051
10052Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
10053 if (!FromDC)
10054 return FromDC;
10055
10056 ExpectedDecl ToDCOrErr = Import(FromD: cast<Decl>(Val: FromDC));
10057 if (!ToDCOrErr)
10058 return ToDCOrErr.takeError();
10059 auto *ToDC = cast<DeclContext>(Val: *ToDCOrErr);
10060
10061 // When we're using a record/enum/Objective-C class/protocol as a context, we
10062 // need it to have a definition.
10063 if (auto *ToRecord = dyn_cast<RecordDecl>(Val: ToDC)) {
10064 auto *FromRecord = cast<RecordDecl>(Val: FromDC);
10065 if (ToRecord->isCompleteDefinition())
10066 return ToDC;
10067
10068 // If FromRecord is not defined we need to force it to be.
10069 // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
10070 // it will start the definition but we never finish it.
10071 // If there are base classes they won't be imported and we will
10072 // be missing anything that we inherit from those bases.
10073 if (FromRecord->getASTContext().getExternalSource() &&
10074 !FromRecord->isCompleteDefinition())
10075 FromRecord->getASTContext().getExternalSource()->CompleteType(Tag: FromRecord);
10076
10077 if (FromRecord->isCompleteDefinition())
10078 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10079 From: FromRecord, To: ToRecord, Kind: ASTNodeImporter::IDK_Basic))
10080 return std::move(Err);
10081 } else if (auto *ToEnum = dyn_cast<EnumDecl>(Val: ToDC)) {
10082 auto *FromEnum = cast<EnumDecl>(Val: FromDC);
10083 if (ToEnum->isCompleteDefinition()) {
10084 // Do nothing.
10085 } else if (FromEnum->isCompleteDefinition()) {
10086 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10087 From: FromEnum, To: ToEnum, Kind: ASTNodeImporter::IDK_Basic))
10088 return std::move(Err);
10089 } else {
10090 CompleteDecl(D: ToEnum);
10091 }
10092 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(Val: ToDC)) {
10093 auto *FromClass = cast<ObjCInterfaceDecl>(Val: FromDC);
10094 if (ToClass->getDefinition()) {
10095 // Do nothing.
10096 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
10097 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10098 From: FromDef, To: ToClass, Kind: ASTNodeImporter::IDK_Basic))
10099 return std::move(Err);
10100 } else {
10101 CompleteDecl(D: ToClass);
10102 }
10103 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(Val: ToDC)) {
10104 auto *FromProto = cast<ObjCProtocolDecl>(Val: FromDC);
10105 if (ToProto->getDefinition()) {
10106 // Do nothing.
10107 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
10108 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10109 From: FromDef, To: ToProto, Kind: ASTNodeImporter::IDK_Basic))
10110 return std::move(Err);
10111 } else {
10112 CompleteDecl(D: ToProto);
10113 }
10114 }
10115
10116 return ToDC;
10117}
10118
10119Expected<Expr *> ASTImporter::Import(Expr *FromE) {
10120 if (ExpectedStmt ToSOrErr = Import(FromS: cast_or_null<Stmt>(Val: FromE)))
10121 return cast_or_null<Expr>(Val: *ToSOrErr);
10122 else
10123 return ToSOrErr.takeError();
10124}
10125
10126Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
10127 if (!FromS)
10128 return nullptr;
10129
10130 // Check whether we've already imported this statement.
10131 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(Val: FromS);
10132 if (Pos != ImportedStmts.end())
10133 return Pos->second;
10134
10135 // Import the statement.
10136 ASTNodeImporter Importer(*this);
10137 ExpectedStmt ToSOrErr = Importer.Visit(S: FromS);
10138 if (!ToSOrErr)
10139 return ToSOrErr;
10140
10141 if (auto *ToE = dyn_cast<Expr>(Val: *ToSOrErr)) {
10142 auto *FromE = cast<Expr>(Val: FromS);
10143 // Copy ExprBitfields, which may not be handled in Expr subclasses
10144 // constructors.
10145 ToE->setValueKind(FromE->getValueKind());
10146 ToE->setObjectKind(FromE->getObjectKind());
10147 ToE->setDependence(FromE->getDependence());
10148 }
10149
10150 // Record the imported statement object.
10151 ImportedStmts[FromS] = *ToSOrErr;
10152 return ToSOrErr;
10153}
10154
10155Expected<NestedNameSpecifier> ASTImporter::Import(NestedNameSpecifier FromNNS) {
10156 switch (FromNNS.getKind()) {
10157 case NestedNameSpecifier::Kind::Null:
10158 case NestedNameSpecifier::Kind::Global:
10159 return FromNNS;
10160 case NestedNameSpecifier::Kind::Namespace: {
10161 auto [Namespace, Prefix] = FromNNS.getAsNamespaceAndPrefix();
10162 auto NSOrErr = Import(FromD: Namespace);
10163 if (!NSOrErr)
10164 return NSOrErr.takeError();
10165 auto PrefixOrErr = Import(FromNNS: Prefix);
10166 if (!PrefixOrErr)
10167 return PrefixOrErr.takeError();
10168 return NestedNameSpecifier(ToContext, cast<NamespaceBaseDecl>(Val: *NSOrErr),
10169 *PrefixOrErr);
10170 }
10171 case NestedNameSpecifier::Kind::MicrosoftSuper:
10172 if (ExpectedDecl RDOrErr = Import(FromD: FromNNS.getAsMicrosoftSuper()))
10173 return NestedNameSpecifier(cast<CXXRecordDecl>(Val: *RDOrErr));
10174 else
10175 return RDOrErr.takeError();
10176 case NestedNameSpecifier::Kind::Type:
10177 if (ExpectedTypePtr TyOrErr = Import(FromT: FromNNS.getAsType())) {
10178 return NestedNameSpecifier(*TyOrErr);
10179 } else {
10180 return TyOrErr.takeError();
10181 }
10182 }
10183 llvm_unreachable("Invalid nested name specifier kind");
10184}
10185
10186Expected<NestedNameSpecifierLoc>
10187ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
10188 // Copied from NestedNameSpecifier mostly.
10189 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
10190 NestedNameSpecifierLoc NNS = FromNNS;
10191
10192 // Push each of the nested-name-specifiers's onto a stack for
10193 // serialization in reverse order.
10194 while (NNS) {
10195 NestedNames.push_back(Elt: NNS);
10196 NNS = NNS.getAsNamespaceAndPrefix().Prefix;
10197 }
10198
10199 NestedNameSpecifierLocBuilder Builder;
10200
10201 while (!NestedNames.empty()) {
10202 NNS = NestedNames.pop_back_val();
10203 NestedNameSpecifier Spec = std::nullopt;
10204 if (Error Err = importInto(To&: Spec, From: NNS.getNestedNameSpecifier()))
10205 return std::move(Err);
10206
10207 NestedNameSpecifier::Kind Kind = Spec.getKind();
10208
10209 SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
10210 if (Kind != NestedNameSpecifier::Kind::MicrosoftSuper) {
10211 if (Error Err = importInto(To&: ToLocalBeginLoc, From: NNS.getLocalBeginLoc()))
10212 return std::move(Err);
10213
10214 if (Kind != NestedNameSpecifier::Kind::Global)
10215 if (Error Err = importInto(To&: ToLocalEndLoc, From: NNS.getLocalEndLoc()))
10216 return std::move(Err);
10217 }
10218
10219 switch (Kind) {
10220 case NestedNameSpecifier::Kind::Namespace:
10221 Builder.Extend(Context&: getToContext(), Namespace: Spec.getAsNamespaceAndPrefix().Namespace,
10222 NamespaceLoc: ToLocalBeginLoc, ColonColonLoc: ToLocalEndLoc);
10223 break;
10224
10225 case NestedNameSpecifier::Kind::Type: {
10226 SourceLocation ToTLoc;
10227 if (Error Err = importInto(To&: ToTLoc, From: NNS.castAsTypeLoc().getBeginLoc()))
10228 return std::move(Err);
10229 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
10230 T: QualType(Spec.getAsType(), 0), Loc: ToTLoc);
10231 Builder.Make(Context&: getToContext(), TL: TSI->getTypeLoc(), ColonColonLoc: ToLocalEndLoc);
10232 break;
10233 }
10234
10235 case NestedNameSpecifier::Kind::Global:
10236 Builder.MakeGlobal(Context&: getToContext(), ColonColonLoc: ToLocalBeginLoc);
10237 break;
10238
10239 case NestedNameSpecifier::Kind::MicrosoftSuper: {
10240 auto ToSourceRangeOrErr = Import(FromRange: NNS.getSourceRange());
10241 if (!ToSourceRangeOrErr)
10242 return ToSourceRangeOrErr.takeError();
10243
10244 Builder.MakeMicrosoftSuper(Context&: getToContext(), RD: Spec.getAsMicrosoftSuper(),
10245 SuperLoc: ToSourceRangeOrErr->getBegin(),
10246 ColonColonLoc: ToSourceRangeOrErr->getEnd());
10247 break;
10248 }
10249 case NestedNameSpecifier::Kind::Null:
10250 llvm_unreachable("unexpected null nested name specifier");
10251 }
10252 }
10253
10254 return Builder.getWithLocInContext(Context&: getToContext());
10255}
10256
10257Expected<TemplateName> ASTImporter::Import(TemplateName From) {
10258 switch (From.getKind()) {
10259 case TemplateName::Template:
10260 if (ExpectedDecl ToTemplateOrErr = Import(FromD: From.getAsTemplateDecl()))
10261 return TemplateName(cast<TemplateDecl>(Val: (*ToTemplateOrErr)->getCanonicalDecl()));
10262 else
10263 return ToTemplateOrErr.takeError();
10264
10265 case TemplateName::OverloadedTemplate: {
10266 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
10267 UnresolvedSet<2> ToTemplates;
10268 for (auto *I : *FromStorage) {
10269 if (auto ToOrErr = Import(FromD: I))
10270 ToTemplates.addDecl(D: cast<NamedDecl>(Val: *ToOrErr));
10271 else
10272 return ToOrErr.takeError();
10273 }
10274 return ToContext.getOverloadedTemplateName(Begin: ToTemplates.begin(),
10275 End: ToTemplates.end());
10276 }
10277
10278 case TemplateName::AssumedTemplate: {
10279 AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
10280 auto DeclNameOrErr = Import(FromName: FromStorage->getDeclName());
10281 if (!DeclNameOrErr)
10282 return DeclNameOrErr.takeError();
10283 return ToContext.getAssumedTemplateName(Name: *DeclNameOrErr);
10284 }
10285
10286 case TemplateName::QualifiedTemplate: {
10287 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
10288 auto QualifierOrErr = Import(FromNNS: QTN->getQualifier());
10289 if (!QualifierOrErr)
10290 return QualifierOrErr.takeError();
10291 auto TNOrErr = Import(From: QTN->getUnderlyingTemplate());
10292 if (!TNOrErr)
10293 return TNOrErr.takeError();
10294 return ToContext.getQualifiedTemplateName(
10295 Qualifier: *QualifierOrErr, TemplateKeyword: QTN->hasTemplateKeyword(), Template: *TNOrErr);
10296 }
10297
10298 case TemplateName::DependentTemplate: {
10299 DependentTemplateName *DTN = From.getAsDependentTemplateName();
10300 auto QualifierOrErr = Import(FromNNS: DTN->getQualifier());
10301 if (!QualifierOrErr)
10302 return QualifierOrErr.takeError();
10303 return ToContext.getDependentTemplateName(
10304 Name: {*QualifierOrErr, Import(FromIO: DTN->getName()), DTN->hasTemplateKeyword()});
10305 }
10306
10307 case TemplateName::SubstTemplateTemplateParm: {
10308 SubstTemplateTemplateParmStorage *Subst =
10309 From.getAsSubstTemplateTemplateParm();
10310 auto ReplacementOrErr = Import(From: Subst->getReplacement());
10311 if (!ReplacementOrErr)
10312 return ReplacementOrErr.takeError();
10313
10314 auto AssociatedDeclOrErr = Import(FromD: Subst->getAssociatedDecl());
10315 if (!AssociatedDeclOrErr)
10316 return AssociatedDeclOrErr.takeError();
10317
10318 return ToContext.getSubstTemplateTemplateParm(
10319 replacement: *ReplacementOrErr, AssociatedDecl: *AssociatedDeclOrErr, Index: Subst->getIndex(),
10320 PackIndex: Subst->getPackIndex(), Final: Subst->getFinal());
10321 }
10322
10323 case TemplateName::SubstTemplateTemplateParmPack: {
10324 SubstTemplateTemplateParmPackStorage *SubstPack =
10325 From.getAsSubstTemplateTemplateParmPack();
10326 ASTNodeImporter Importer(*this);
10327 auto ArgPackOrErr =
10328 Importer.ImportTemplateArgument(From: SubstPack->getArgumentPack());
10329 if (!ArgPackOrErr)
10330 return ArgPackOrErr.takeError();
10331
10332 auto AssociatedDeclOrErr = Import(FromD: SubstPack->getAssociatedDecl());
10333 if (!AssociatedDeclOrErr)
10334 return AssociatedDeclOrErr.takeError();
10335
10336 return ToContext.getSubstTemplateTemplateParmPack(
10337 ArgPack: *ArgPackOrErr, AssociatedDecl: *AssociatedDeclOrErr, Index: SubstPack->getIndex(),
10338 Final: SubstPack->getFinal());
10339 }
10340 case TemplateName::PackIndexingTemplate: {
10341 PackIndexingTemplateStorage *PI = From.getAsPackIndexingTemplate();
10342 auto PatternOrErr = Import(From: PI->getPattern());
10343 if (!PatternOrErr)
10344 return PatternOrErr.takeError();
10345
10346 auto IndexExprOrErr = Import(FromE: PI->getIndexExpr());
10347 if (!IndexExprOrErr)
10348 return IndexExprOrErr.takeError();
10349
10350 SmallVector<TemplateName, 4> Expansions;
10351 for (TemplateName T : PI->getExpansions()) {
10352 auto ExpansionOrErr = Import(From: T);
10353 if (!ExpansionOrErr)
10354 return ExpansionOrErr.takeError();
10355 Expansions.push_back(Elt: *ExpansionOrErr);
10356 }
10357
10358 return ToContext.getPackIndexingTemplateName(
10359 Pattern: *PatternOrErr, IndexExpr: *IndexExprOrErr, FullySubstituted: PI->isFullySubstituted(), Expansions);
10360 }
10361 case TemplateName::UsingTemplate: {
10362 auto UsingOrError = Import(FromD: From.getAsUsingShadowDecl());
10363 if (!UsingOrError)
10364 return UsingOrError.takeError();
10365 return TemplateName(cast<UsingShadowDecl>(Val: *UsingOrError));
10366 }
10367 case TemplateName::DeducedTemplate:
10368 llvm_unreachable("Unexpected DeducedTemplate");
10369 }
10370
10371 llvm_unreachable("Invalid template name kind");
10372}
10373
10374Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
10375 if (FromLoc.isInvalid())
10376 return SourceLocation{};
10377
10378 SourceManager &FromSM = FromContext.getSourceManager();
10379 bool IsBuiltin = FromSM.isWrittenInBuiltinFile(Loc: FromLoc);
10380
10381 FileIDAndOffset Decomposed = FromSM.getDecomposedLoc(Loc: FromLoc);
10382 Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
10383 if (!ToFileIDOrErr)
10384 return ToFileIDOrErr.takeError();
10385 SourceManager &ToSM = ToContext.getSourceManager();
10386 return ToSM.getComposedLoc(FID: *ToFileIDOrErr, Offset: Decomposed.second);
10387}
10388
10389Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
10390 SourceLocation ToBegin, ToEnd;
10391 if (Error Err = importInto(To&: ToBegin, From: FromRange.getBegin()))
10392 return std::move(Err);
10393 if (Error Err = importInto(To&: ToEnd, From: FromRange.getEnd()))
10394 return std::move(Err);
10395
10396 return SourceRange(ToBegin, ToEnd);
10397}
10398
10399Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
10400 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(Val: FromID);
10401 if (Pos != ImportedFileIDs.end())
10402 return Pos->second;
10403
10404 SourceManager &FromSM = FromContext.getSourceManager();
10405 SourceManager &ToSM = ToContext.getSourceManager();
10406 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FID: FromID);
10407
10408 // Map the FromID to the "to" source manager.
10409 FileID ToID;
10410 if (FromSLoc.isExpansion()) {
10411 const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
10412 ExpectedSLoc ToSpLoc = Import(FromLoc: FromEx.getSpellingLoc());
10413 if (!ToSpLoc)
10414 return ToSpLoc.takeError();
10415 ExpectedSLoc ToExLocS = Import(FromLoc: FromEx.getExpansionLocStart());
10416 if (!ToExLocS)
10417 return ToExLocS.takeError();
10418 unsigned ExLength = FromSM.getFileIDSize(FID: FromID);
10419 SourceLocation MLoc;
10420 if (FromEx.isMacroArgExpansion()) {
10421 MLoc = ToSM.createMacroArgExpansionLoc(SpellingLoc: *ToSpLoc, ExpansionLoc: *ToExLocS, Length: ExLength);
10422 } else {
10423 if (ExpectedSLoc ToExLocE = Import(FromLoc: FromEx.getExpansionLocEnd()))
10424 MLoc = ToSM.createExpansionLoc(SpellingLoc: *ToSpLoc, ExpansionLocStart: *ToExLocS, ExpansionLocEnd: *ToExLocE, Length: ExLength,
10425 ExpansionIsTokenRange: FromEx.isExpansionTokenRange());
10426 else
10427 return ToExLocE.takeError();
10428 }
10429 ToID = ToSM.getFileID(SpellingLoc: MLoc);
10430 } else {
10431 const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
10432
10433 if (!IsBuiltin && !Cache->BufferOverridden) {
10434 // Include location of this file.
10435 ExpectedSLoc ToIncludeLoc = Import(FromLoc: FromSLoc.getFile().getIncludeLoc());
10436 if (!ToIncludeLoc)
10437 return ToIncludeLoc.takeError();
10438
10439 // Every FileID that is not the main FileID needs to have a valid include
10440 // location so that the include chain points to the main FileID. When
10441 // importing the main FileID (which has no include location), we need to
10442 // create a fake include location in the main file to keep this property
10443 // intact.
10444 SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
10445 if (FromID == FromSM.getMainFileID())
10446 ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(FID: ToSM.getMainFileID());
10447
10448 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
10449 // FIXME: We probably want to use getVirtualFileRef(), so we don't hit
10450 // the disk again
10451 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
10452 // than mmap the files several times.
10453 auto Entry =
10454 ToFileManager.getOptionalFileRef(Filename: Cache->OrigEntry->getName());
10455 // FIXME: The filename may be a virtual name that does probably not
10456 // point to a valid file and we get no Entry here. In this case try with
10457 // the memory buffer below.
10458 if (Entry)
10459 ToID = ToSM.createFileID(SourceFile: *Entry, IncludePos: ToIncludeLocOrFakeLoc,
10460 FileCharacter: FromSLoc.getFile().getFileCharacteristic());
10461 }
10462 }
10463
10464 if (ToID.isInvalid() || IsBuiltin) {
10465 // FIXME: We want to re-use the existing MemoryBuffer!
10466 std::optional<llvm::MemoryBufferRef> FromBuf =
10467 Cache->getBufferOrNone(Diag&: FromContext.getDiagnostics(),
10468 FM&: FromSM.getFileManager(), Loc: SourceLocation{});
10469 if (!FromBuf)
10470 return llvm::make_error<ASTImportError>(Args: ASTImportError::Unknown);
10471
10472 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
10473 llvm::MemoryBuffer::getMemBufferCopy(InputData: FromBuf->getBuffer(),
10474 BufferName: FromBuf->getBufferIdentifier());
10475 ToID = ToSM.createFileID(Buffer: std::move(ToBuf),
10476 FileCharacter: FromSLoc.getFile().getFileCharacteristic());
10477 }
10478 }
10479
10480 assert(ToID.isValid() && "Unexpected invalid fileID was created.");
10481
10482 ImportedFileIDs[FromID] = ToID;
10483 return ToID;
10484}
10485
10486Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
10487 ExpectedExpr ToExprOrErr = Import(FromE: From->getInit());
10488 if (!ToExprOrErr)
10489 return ToExprOrErr.takeError();
10490
10491 auto LParenLocOrErr = Import(FromLoc: From->getLParenLoc());
10492 if (!LParenLocOrErr)
10493 return LParenLocOrErr.takeError();
10494
10495 auto RParenLocOrErr = Import(FromLoc: From->getRParenLoc());
10496 if (!RParenLocOrErr)
10497 return RParenLocOrErr.takeError();
10498
10499 if (From->isBaseInitializer()) {
10500 auto ToTInfoOrErr = Import(FromTSI: From->getTypeSourceInfo());
10501 if (!ToTInfoOrErr)
10502 return ToTInfoOrErr.takeError();
10503
10504 SourceLocation EllipsisLoc;
10505 if (From->isPackExpansion())
10506 if (Error Err = importInto(To&: EllipsisLoc, From: From->getEllipsisLoc()))
10507 return std::move(Err);
10508
10509 return new (ToContext) CXXCtorInitializer(
10510 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
10511 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
10512 } else if (From->isMemberInitializer()) {
10513 ExpectedDecl ToFieldOrErr = Import(FromD: From->getMember());
10514 if (!ToFieldOrErr)
10515 return ToFieldOrErr.takeError();
10516
10517 auto MemberLocOrErr = Import(FromLoc: From->getMemberLocation());
10518 if (!MemberLocOrErr)
10519 return MemberLocOrErr.takeError();
10520
10521 return new (ToContext) CXXCtorInitializer(
10522 ToContext, cast_or_null<FieldDecl>(Val: *ToFieldOrErr), *MemberLocOrErr,
10523 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10524 } else if (From->isIndirectMemberInitializer()) {
10525 ExpectedDecl ToIFieldOrErr = Import(FromD: From->getIndirectMember());
10526 if (!ToIFieldOrErr)
10527 return ToIFieldOrErr.takeError();
10528
10529 auto MemberLocOrErr = Import(FromLoc: From->getMemberLocation());
10530 if (!MemberLocOrErr)
10531 return MemberLocOrErr.takeError();
10532
10533 return new (ToContext) CXXCtorInitializer(
10534 ToContext, cast_or_null<IndirectFieldDecl>(Val: *ToIFieldOrErr),
10535 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10536 } else if (From->isDelegatingInitializer()) {
10537 auto ToTInfoOrErr = Import(FromTSI: From->getTypeSourceInfo());
10538 if (!ToTInfoOrErr)
10539 return ToTInfoOrErr.takeError();
10540
10541 return new (ToContext)
10542 CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
10543 *ToExprOrErr, *RParenLocOrErr);
10544 } else {
10545 // FIXME: assert?
10546 return make_error<ASTImportError>();
10547 }
10548}
10549
10550Expected<CXXBaseSpecifier *>
10551ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
10552 auto Pos = ImportedCXXBaseSpecifiers.find(Val: BaseSpec);
10553 if (Pos != ImportedCXXBaseSpecifiers.end())
10554 return Pos->second;
10555
10556 Expected<SourceRange> ToSourceRange = Import(FromRange: BaseSpec->getSourceRange());
10557 if (!ToSourceRange)
10558 return ToSourceRange.takeError();
10559 Expected<TypeSourceInfo *> ToTSI = Import(FromTSI: BaseSpec->getTypeSourceInfo());
10560 if (!ToTSI)
10561 return ToTSI.takeError();
10562 ExpectedSLoc ToEllipsisLoc = Import(FromLoc: BaseSpec->getEllipsisLoc());
10563 if (!ToEllipsisLoc)
10564 return ToEllipsisLoc.takeError();
10565 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
10566 *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
10567 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
10568 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
10569 return Imported;
10570}
10571
10572llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
10573 ASTNodeImporter Importer(*this);
10574 return Importer.ImportAPValue(FromValue);
10575}
10576
10577Error ASTImporter::ImportDefinition(Decl *From) {
10578 ExpectedDecl ToOrErr = Import(FromD: From);
10579 if (!ToOrErr)
10580 return ToOrErr.takeError();
10581 Decl *To = *ToOrErr;
10582
10583 auto *FromDC = cast<DeclContext>(Val: From);
10584 ASTNodeImporter Importer(*this);
10585
10586 if (auto *ToRecord = dyn_cast<RecordDecl>(Val: To)) {
10587 if (!ToRecord->getDefinition()) {
10588 return Importer.ImportDefinition(
10589 From: cast<RecordDecl>(Val: FromDC), To: ToRecord,
10590 Kind: ASTNodeImporter::IDK_Everything);
10591 }
10592 }
10593
10594 if (auto *ToEnum = dyn_cast<EnumDecl>(Val: To)) {
10595 if (!ToEnum->getDefinition()) {
10596 return Importer.ImportDefinition(
10597 From: cast<EnumDecl>(Val: FromDC), To: ToEnum, Kind: ASTNodeImporter::IDK_Everything);
10598 }
10599 }
10600
10601 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(Val: To)) {
10602 if (!ToIFace->getDefinition()) {
10603 return Importer.ImportDefinition(
10604 From: cast<ObjCInterfaceDecl>(Val: FromDC), To: ToIFace,
10605 Kind: ASTNodeImporter::IDK_Everything);
10606 }
10607 }
10608
10609 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(Val: To)) {
10610 if (!ToProto->getDefinition()) {
10611 return Importer.ImportDefinition(
10612 From: cast<ObjCProtocolDecl>(Val: FromDC), To: ToProto,
10613 Kind: ASTNodeImporter::IDK_Everything);
10614 }
10615 }
10616
10617 return Importer.ImportDeclContext(FromDC, ForceImport: true);
10618}
10619
10620Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
10621 if (!FromName)
10622 return DeclarationName{};
10623
10624 switch (FromName.getNameKind()) {
10625 case DeclarationName::Identifier:
10626 return DeclarationName(Import(FromId: FromName.getAsIdentifierInfo()));
10627
10628 case DeclarationName::ObjCZeroArgSelector:
10629 case DeclarationName::ObjCOneArgSelector:
10630 case DeclarationName::ObjCMultiArgSelector:
10631 if (auto ToSelOrErr = Import(FromSel: FromName.getObjCSelector()))
10632 return DeclarationName(*ToSelOrErr);
10633 else
10634 return ToSelOrErr.takeError();
10635
10636 case DeclarationName::CXXConstructorName: {
10637 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10638 return ToContext.DeclarationNames.getCXXConstructorName(
10639 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10640 else
10641 return ToTyOrErr.takeError();
10642 }
10643
10644 case DeclarationName::CXXDestructorName: {
10645 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10646 return ToContext.DeclarationNames.getCXXDestructorName(
10647 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10648 else
10649 return ToTyOrErr.takeError();
10650 }
10651
10652 case DeclarationName::CXXDeductionGuideName: {
10653 if (auto ToTemplateOrErr = Import(FromD: FromName.getCXXDeductionGuideTemplate()))
10654 return ToContext.DeclarationNames.getCXXDeductionGuideName(
10655 TD: cast<TemplateDecl>(Val: *ToTemplateOrErr));
10656 else
10657 return ToTemplateOrErr.takeError();
10658 }
10659
10660 case DeclarationName::CXXConversionFunctionName: {
10661 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10662 return ToContext.DeclarationNames.getCXXConversionFunctionName(
10663 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10664 else
10665 return ToTyOrErr.takeError();
10666 }
10667
10668 case DeclarationName::CXXOperatorName:
10669 return ToContext.DeclarationNames.getCXXOperatorName(
10670 Op: FromName.getCXXOverloadedOperator());
10671
10672 case DeclarationName::CXXLiteralOperatorName:
10673 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
10674 II: Import(FromId: FromName.getCXXLiteralIdentifier()));
10675
10676 case DeclarationName::CXXUsingDirective:
10677 // FIXME: STATICS!
10678 return DeclarationName::getUsingDirectiveName();
10679 }
10680
10681 llvm_unreachable("Invalid DeclarationName Kind!");
10682}
10683
10684IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
10685 if (!FromId)
10686 return nullptr;
10687
10688 IdentifierInfo *ToId = &ToContext.Idents.get(Name: FromId->getName());
10689
10690 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
10691 ToId->setBuiltinID(FromId->getBuiltinID());
10692
10693 return ToId;
10694}
10695
10696IdentifierOrOverloadedOperator
10697ASTImporter::Import(IdentifierOrOverloadedOperator FromIO) {
10698 if (const IdentifierInfo *FromII = FromIO.getIdentifier())
10699 return Import(FromId: FromII);
10700 return FromIO.getOperator();
10701}
10702
10703Expected<Selector> ASTImporter::Import(Selector FromSel) {
10704 if (FromSel.isNull())
10705 return Selector{};
10706
10707 SmallVector<const IdentifierInfo *, 4> Idents;
10708 Idents.push_back(Elt: Import(FromId: FromSel.getIdentifierInfoForSlot(argIndex: 0)));
10709 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
10710 Idents.push_back(Elt: Import(FromId: FromSel.getIdentifierInfoForSlot(argIndex: I)));
10711 return ToContext.Selectors.getSelector(NumArgs: FromSel.getNumArgs(), IIV: Idents.data());
10712}
10713
10714llvm::Expected<APValue>
10715ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
10716 APValue Result;
10717 llvm::Error Err = llvm::Error::success();
10718 auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
10719 for (unsigned Idx = 0; Idx < Size; Idx++) {
10720 APValue Tmp = importChecked(Err, From: From[Idx]);
10721 To[Idx] = Tmp;
10722 }
10723 };
10724 switch (FromValue.getKind()) {
10725 case APValue::None:
10726 case APValue::Indeterminate:
10727 case APValue::Int:
10728 case APValue::Float:
10729 case APValue::FixedPoint:
10730 case APValue::ComplexInt:
10731 case APValue::ComplexFloat:
10732 Result = FromValue;
10733 break;
10734 case APValue::Vector: {
10735 Result.MakeVector();
10736 MutableArrayRef<APValue> Elts =
10737 Result.setVectorUninit(FromValue.getVectorLength());
10738 ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
10739 Elts.data(), FromValue.getVectorLength());
10740 break;
10741 }
10742 case APValue::Matrix:
10743 // Matrix values cannot currently arise in APValue import contexts.
10744 llvm_unreachable("Matrix APValue import not yet supported");
10745 case APValue::Array:
10746 Result.MakeArray(InitElts: FromValue.getArrayInitializedElts(),
10747 Size: FromValue.getArraySize());
10748 ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
10749 ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
10750 FromValue.getArrayInitializedElts());
10751 break;
10752 case APValue::Struct:
10753 Result.MakeStruct(B: FromValue.getStructNumBases(),
10754 M: FromValue.getStructNumFields(),
10755 V: FromValue.getStructNumVirtualBases());
10756 ImportLoop(
10757 ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
10758 ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
10759 FromValue.getStructNumBases() + FromValue.getStructNumFields() +
10760 FromValue.getStructNumVirtualBases());
10761 break;
10762 case APValue::Union: {
10763 Result.MakeUnion();
10764 const Decl *ImpFDecl = importChecked(Err, From: FromValue.getUnionField());
10765 APValue ImpValue = importChecked(Err, From: FromValue.getUnionValue());
10766 if (Err)
10767 return std::move(Err);
10768 Result.setUnion(Field: cast<FieldDecl>(Val: ImpFDecl), Value: ImpValue);
10769 break;
10770 }
10771 case APValue::AddrLabelDiff: {
10772 Result.MakeAddrLabelDiff();
10773 const Expr *ImpLHS = importChecked(Err, From: FromValue.getAddrLabelDiffLHS());
10774 const Expr *ImpRHS = importChecked(Err, From: FromValue.getAddrLabelDiffRHS());
10775 if (Err)
10776 return std::move(Err);
10777 Result.setAddrLabelDiff(LHSExpr: cast<AddrLabelExpr>(Val: ImpLHS),
10778 RHSExpr: cast<AddrLabelExpr>(Val: ImpRHS));
10779 break;
10780 }
10781 case APValue::MemberPointer: {
10782 const Decl *ImpMemPtrDecl =
10783 importChecked(Err, From: FromValue.getMemberPointerDecl());
10784 if (Err)
10785 return std::move(Err);
10786 MutableArrayRef<const CXXRecordDecl *> ToPath =
10787 Result.setMemberPointerUninit(
10788 Member: cast<const ValueDecl>(Val: ImpMemPtrDecl),
10789 IsDerivedMember: FromValue.isMemberPointerToDerivedMember(),
10790 Size: FromValue.getMemberPointerPath().size());
10791 ArrayRef<const CXXRecordDecl *> FromPath = Result.getMemberPointerPath();
10792 for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
10793 Idx++) {
10794 const Decl *ImpDecl = importChecked(Err, From: FromPath[Idx]);
10795 if (Err)
10796 return std::move(Err);
10797 ToPath[Idx] = cast<const CXXRecordDecl>(Val: ImpDecl->getCanonicalDecl());
10798 }
10799 break;
10800 }
10801 case APValue::LValue:
10802 APValue::LValueBase Base;
10803 QualType FromElemTy;
10804 if (FromValue.getLValueBase()) {
10805 assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&
10806 "in C++20 dynamic allocation are transient so they shouldn't "
10807 "appear in the AST");
10808 if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
10809 if (const auto *E =
10810 FromValue.getLValueBase().dyn_cast<const Expr *>()) {
10811 FromElemTy = E->getType();
10812 const Expr *ImpExpr = importChecked(Err, From: E);
10813 if (Err)
10814 return std::move(Err);
10815 Base = APValue::LValueBase(ImpExpr,
10816 FromValue.getLValueBase().getCallIndex(),
10817 FromValue.getLValueBase().getVersion());
10818 } else {
10819 FromElemTy =
10820 FromValue.getLValueBase().get<const ValueDecl *>()->getType();
10821 const Decl *ImpDecl = importChecked(
10822 Err, From: FromValue.getLValueBase().get<const ValueDecl *>());
10823 if (Err)
10824 return std::move(Err);
10825 Base = APValue::LValueBase(cast<ValueDecl>(Val: ImpDecl),
10826 FromValue.getLValueBase().getCallIndex(),
10827 FromValue.getLValueBase().getVersion());
10828 }
10829 } else {
10830 FromElemTy = FromValue.getLValueBase().getTypeInfoType();
10831 const Type *ImpTypeInfo = importChecked(
10832 Err, From: FromValue.getLValueBase().get<TypeInfoLValue>().getType());
10833 QualType ImpType =
10834 importChecked(Err, From: FromValue.getLValueBase().getTypeInfoType());
10835 if (Err)
10836 return std::move(Err);
10837 Base = APValue::LValueBase::getTypeInfo(LV: TypeInfoLValue(ImpTypeInfo),
10838 TypeInfo: ImpType);
10839 }
10840 }
10841 CharUnits Offset = FromValue.getLValueOffset();
10842 unsigned PathLength = FromValue.getLValuePath().size();
10843 Result.MakeLValue();
10844 if (FromValue.hasLValuePath()) {
10845 MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
10846 B: Base, O: Offset, Size: PathLength, OnePastTheEnd: FromValue.isLValueOnePastTheEnd(),
10847 IsNullPtr: FromValue.isNullPointer());
10848 ArrayRef<APValue::LValuePathEntry> FromPath = FromValue.getLValuePath();
10849 for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10850 if (FromElemTy->isRecordType()) {
10851 const Decl *FromDecl =
10852 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10853 const Decl *ImpDecl = importChecked(Err, From: FromDecl);
10854 if (Err)
10855 return std::move(Err);
10856 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: FromDecl))
10857 FromElemTy = Importer.FromContext.getCanonicalTagType(TD: RD);
10858 else
10859 FromElemTy = cast<ValueDecl>(Val: FromDecl)->getType();
10860 ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
10861 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10862 } else {
10863 FromElemTy =
10864 Importer.FromContext.getAsArrayType(T: FromElemTy)->getElementType();
10865 ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
10866 Index: FromPath[LoopIdx].getAsArrayIndex());
10867 }
10868 }
10869 } else
10870 Result.setLValue(B: Base, O: Offset, APValue::NoLValuePath{},
10871 IsNullPtr: FromValue.isNullPointer());
10872 }
10873 if (Err)
10874 return std::move(Err);
10875 return Result;
10876}
10877
10878Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
10879 DeclContext *DC,
10880 unsigned IDNS,
10881 NamedDecl **Decls,
10882 unsigned NumDecls) {
10883 if (ODRHandling == ODRHandlingType::Conservative)
10884 // Report error at any name conflict.
10885 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
10886 else
10887 // Allow to create the new Decl with the same name.
10888 return Name;
10889}
10890
10891DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
10892 if (LastDiagFromFrom)
10893 ToContext.getDiagnostics().notePriorDiagnosticFrom(
10894 Other: FromContext.getDiagnostics());
10895 LastDiagFromFrom = false;
10896 return ToContext.getDiagnostics().Report(Loc, DiagID);
10897}
10898
10899DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
10900 if (!LastDiagFromFrom)
10901 FromContext.getDiagnostics().notePriorDiagnosticFrom(
10902 Other: ToContext.getDiagnostics());
10903 LastDiagFromFrom = true;
10904 return FromContext.getDiagnostics().Report(Loc, DiagID);
10905}
10906
10907void ASTImporter::CompleteDecl (Decl *D) {
10908 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(Val: D)) {
10909 if (!ID->getDefinition())
10910 ID->startDefinition();
10911 }
10912 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(Val: D)) {
10913 if (!PD->getDefinition())
10914 PD->startDefinition();
10915 }
10916 else if (auto *TD = dyn_cast<TagDecl>(Val: D)) {
10917 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10918 TD->startDefinition();
10919 TD->setCompleteDefinition(true);
10920 }
10921 }
10922 else {
10923 assert(0 && "CompleteDecl called on a Decl that can't be completed");
10924 }
10925}
10926
10927Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
10928 auto [Pos, Inserted] = ImportedDecls.try_emplace(Key: From, Args&: To);
10929 assert((Inserted || Pos->second == To) &&
10930 "Try to import an already imported Decl");
10931 if (!Inserted)
10932 return Pos->second;
10933 // This mapping should be maintained only in this function. Therefore do not
10934 // check for additional consistency.
10935 ImportedFromDecls[To] = From;
10936 // In the case of TypedefNameDecl we create the Decl first and only then we
10937 // import and set its DeclContext. So, the DC is still not set when we reach
10938 // here from GetImportedOrCreateDecl.
10939 if (To->getDeclContext())
10940 AddToLookupTable(ToD: To);
10941 return To;
10942}
10943
10944std::optional<ASTImportError>
10945ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
10946 auto Pos = ImportDeclErrors.find(Val: FromD);
10947 if (Pos != ImportDeclErrors.end())
10948 return Pos->second;
10949 else
10950 return std::nullopt;
10951}
10952
10953void ASTImporter::setImportDeclError(Decl *From, ASTImportError Error) {
10954 auto InsertRes = ImportDeclErrors.insert(KV: {From, Error});
10955 (void)InsertRes;
10956 // Either we set the error for the first time, or we already had set one and
10957 // now we want to set the same error.
10958 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10959}
10960
10961bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
10962 bool Complain) {
10963 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10964 ImportedTypes.find(Val: From.getTypePtr());
10965 if (Pos != ImportedTypes.end()) {
10966 if (ExpectedType ToFromOrErr = Import(FromT: From)) {
10967 if (ToContext.hasSameType(T1: *ToFromOrErr, T2: To))
10968 return true;
10969 } else {
10970 llvm::consumeError(Err: ToFromOrErr.takeError());
10971 }
10972 }
10973
10974 StructuralEquivalenceContext Ctx(
10975 getToContext().getLangOpts(), FromContext, ToContext, NonEquivalentDecls,
10976 getStructuralEquivalenceKind(Importer: *this), false, Complain);
10977 return Ctx.IsEquivalent(T1: From, T2: To);
10978}
10979