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 Error Err = Error::success();
1642 auto ToQualifier = importChecked(Err, From: T->getQualifier());
1643 auto *ToD = importChecked(Err, From: T->getDecl());
1644 if (Err)
1645 return std::move(Err);
1646
1647 if (T->isCanonicalUnqualified())
1648 return Importer.getToContext().getCanonicalUnresolvedUsingType(D: ToD);
1649 return Importer.getToContext().getUnresolvedUsingType(Keyword: T->getKeyword(),
1650 Qualifier: ToQualifier, D: ToD);
1651}
1652
1653ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
1654 ExpectedType ToInnerTypeOrErr = import(From: T->getInnerType());
1655 if (!ToInnerTypeOrErr)
1656 return ToInnerTypeOrErr.takeError();
1657
1658 return Importer.getToContext().getParenType(NamedType: *ToInnerTypeOrErr);
1659}
1660
1661ExpectedType
1662ASTNodeImporter::VisitPackIndexingType(clang::PackIndexingType const *T) {
1663
1664 ExpectedType Pattern = import(From: T->getPattern());
1665 if (!Pattern)
1666 return Pattern.takeError();
1667 ExpectedExpr Index = import(From: T->getIndexExpr());
1668 if (!Index)
1669 return Index.takeError();
1670 return Importer.getToContext().getPackIndexingType(Pattern: *Pattern, IndexExpr: *Index);
1671}
1672
1673ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1674 Expected<TypedefNameDecl *> ToDeclOrErr = import(From: T->getDecl());
1675 if (!ToDeclOrErr)
1676 return ToDeclOrErr.takeError();
1677
1678 auto ToQualifierOrErr = import(From: T->getQualifier());
1679 if (!ToQualifierOrErr)
1680 return ToQualifierOrErr.takeError();
1681
1682 ExpectedType ToUnderlyingTypeOrErr =
1683 T->typeMatchesDecl() ? QualType() : import(From: T->desugar());
1684 if (!ToUnderlyingTypeOrErr)
1685 return ToUnderlyingTypeOrErr.takeError();
1686
1687 return Importer.getToContext().getTypedefType(
1688 Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr, Decl: *ToDeclOrErr, UnderlyingType: *ToUnderlyingTypeOrErr);
1689}
1690
1691ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1692 ExpectedExpr ToExprOrErr = import(From: T->getUnderlyingExpr());
1693 if (!ToExprOrErr)
1694 return ToExprOrErr.takeError();
1695 return Importer.getToContext().getTypeOfExprType(E: *ToExprOrErr, Kind: T->getKind());
1696}
1697
1698ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1699 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnmodifiedType());
1700 if (!ToUnderlyingTypeOrErr)
1701 return ToUnderlyingTypeOrErr.takeError();
1702 return Importer.getToContext().getTypeOfType(QT: *ToUnderlyingTypeOrErr,
1703 Kind: T->getKind());
1704}
1705
1706ExpectedType ASTNodeImporter::VisitUsingType(const UsingType *T) {
1707 Error Err = Error::success();
1708 auto ToQualifier = importChecked(Err, From: T->getQualifier());
1709 auto *ToD = importChecked(Err, From: T->getDecl());
1710 QualType ToT = importChecked(Err, From: T->desugar());
1711 if (Err)
1712 return std::move(Err);
1713 return Importer.getToContext().getUsingType(Keyword: T->getKeyword(), Qualifier: ToQualifier, D: ToD,
1714 UnderlyingType: ToT);
1715}
1716
1717ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1718 // FIXME: Make sure that the "to" context supports C++0x!
1719 ExpectedExpr ToExprOrErr = import(From: T->getUnderlyingExpr());
1720 if (!ToExprOrErr)
1721 return ToExprOrErr.takeError();
1722
1723 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
1724 if (!ToUnderlyingTypeOrErr)
1725 return ToUnderlyingTypeOrErr.takeError();
1726
1727 return Importer.getToContext().getDecltypeType(
1728 e: *ToExprOrErr, UnderlyingType: *ToUnderlyingTypeOrErr);
1729}
1730
1731ExpectedType
1732ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1733 ExpectedType ToBaseTypeOrErr = import(From: T->getBaseType());
1734 if (!ToBaseTypeOrErr)
1735 return ToBaseTypeOrErr.takeError();
1736
1737 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
1738 if (!ToUnderlyingTypeOrErr)
1739 return ToUnderlyingTypeOrErr.takeError();
1740
1741 return Importer.getToContext().getUnaryTransformType(
1742 BaseType: *ToBaseTypeOrErr, UnderlyingType: *ToUnderlyingTypeOrErr, UKind: T->getUTTKind());
1743}
1744
1745ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1746 // FIXME: Make sure that the "to" context supports C++11!
1747 ExpectedType ToDeducedTypeOrErr = import(From: T->getDeducedType());
1748 if (!ToDeducedTypeOrErr)
1749 return ToDeducedTypeOrErr.takeError();
1750
1751 TemplateName ToTypeConstraint;
1752 if (TemplateName FromTypeConstraint = T->getTypeConstraintConcept();
1753 !FromTypeConstraint.isNull()) {
1754 Expected<TemplateName> ToTypeConstraintOrErr = import(From: FromTypeConstraint);
1755 if (!ToTypeConstraintOrErr)
1756 return ToTypeConstraintOrErr.takeError();
1757 ToTypeConstraint = *ToTypeConstraintOrErr;
1758 }
1759
1760 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1761 if (Error Err = ImportTemplateArguments(FromArgs: T->getTypeConstraintArguments(),
1762 ToArgs&: ToTemplateArgs))
1763 return std::move(Err);
1764
1765 return Importer.getToContext().getAutoType(
1766 DK: T->getDeducedKind(), DeducedAsType: *ToDeducedTypeOrErr, Keyword: T->getKeyword(),
1767 TypeConstraintConcept: ToTypeConstraint, TypeConstraintArgs: ToTemplateArgs);
1768}
1769
1770ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
1771 const DeducedTemplateSpecializationType *T) {
1772 // FIXME: Make sure that the "to" context supports C++17!
1773 Expected<TemplateName> ToTemplateNameOrErr = import(From: T->getTemplateName());
1774 if (!ToTemplateNameOrErr)
1775 return ToTemplateNameOrErr.takeError();
1776 ExpectedType ToDeducedTypeOrErr = import(From: T->getDeducedType());
1777 if (!ToDeducedTypeOrErr)
1778 return ToDeducedTypeOrErr.takeError();
1779
1780 return Importer.getToContext().getDeducedTemplateSpecializationType(
1781 DK: T->getDeducedKind(), DeducedAsType: *ToDeducedTypeOrErr, Keyword: T->getKeyword(),
1782 Template: *ToTemplateNameOrErr);
1783}
1784
1785ExpectedType ASTNodeImporter::VisitTagType(const TagType *T) {
1786 TagDecl *DeclForType = T->getDecl();
1787 Expected<TagDecl *> ToDeclOrErr = import(From: DeclForType);
1788 if (!ToDeclOrErr)
1789 return ToDeclOrErr.takeError();
1790
1791 // If there is a definition of the 'OriginalDecl', it should be imported to
1792 // have all information for the type in the "To" AST. (In some cases no
1793 // other reference may exist to the definition decl and it would not be
1794 // imported otherwise.)
1795 Expected<TagDecl *> ToDefDeclOrErr = import(From: DeclForType->getDefinition());
1796 if (!ToDefDeclOrErr)
1797 return ToDefDeclOrErr.takeError();
1798
1799 if (T->isCanonicalUnqualified())
1800 return Importer.getToContext().getCanonicalTagType(TD: *ToDeclOrErr);
1801
1802 auto ToQualifierOrErr = import(From: T->getQualifier());
1803 if (!ToQualifierOrErr)
1804 return ToQualifierOrErr.takeError();
1805
1806 return Importer.getToContext().getTagType(Keyword: T->getKeyword(), Qualifier: *ToQualifierOrErr,
1807 TD: *ToDeclOrErr, OwnsTag: T->isTagOwned());
1808}
1809
1810ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1811 return VisitTagType(T);
1812}
1813
1814ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1815 return VisitTagType(T);
1816}
1817
1818ExpectedType
1819ASTNodeImporter::VisitInjectedClassNameType(const InjectedClassNameType *T) {
1820 return VisitTagType(T);
1821}
1822
1823ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1824 ExpectedType ToModifiedTypeOrErr = import(From: T->getModifiedType());
1825 if (!ToModifiedTypeOrErr)
1826 return ToModifiedTypeOrErr.takeError();
1827 ExpectedType ToEquivalentTypeOrErr = import(From: T->getEquivalentType());
1828 if (!ToEquivalentTypeOrErr)
1829 return ToEquivalentTypeOrErr.takeError();
1830
1831 return Importer.getToContext().getAttributedType(
1832 attrKind: T->getAttrKind(), modifiedType: *ToModifiedTypeOrErr, equivalentType: *ToEquivalentTypeOrErr,
1833 attr: T->getAttr());
1834}
1835
1836ExpectedType
1837ASTNodeImporter::VisitCountAttributedType(const CountAttributedType *T) {
1838 ExpectedType ToWrappedTypeOrErr = import(From: T->desugar());
1839 if (!ToWrappedTypeOrErr)
1840 return ToWrappedTypeOrErr.takeError();
1841
1842 Error Err = Error::success();
1843 Expr *CountExpr = importChecked(Err, From: T->getCountExpr());
1844
1845 SmallVector<TypeCoupledDeclRefInfo, 1> CoupledDecls;
1846 for (const TypeCoupledDeclRefInfo &TI : T->dependent_decls()) {
1847 Expected<ValueDecl *> ToDeclOrErr = import(From: TI.getDecl());
1848 if (!ToDeclOrErr)
1849 return ToDeclOrErr.takeError();
1850 CoupledDecls.emplace_back(Args&: *ToDeclOrErr, Args: TI.isDeref());
1851 }
1852
1853 return Importer.getToContext().getCountAttributedType(
1854 T: *ToWrappedTypeOrErr, CountExpr, CountInBytes: T->isCountInBytes(), OrNull: T->isOrNull(),
1855 DependentDecls: ArrayRef(CoupledDecls));
1856}
1857
1858ExpectedType
1859ASTNodeImporter::VisitLateParsedAttrType(const LateParsedAttrType *T) {
1860 llvm_unreachable("should be replaced with a concrete type before AST import");
1861}
1862
1863ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1864 const TemplateTypeParmType *T) {
1865 Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(From: T->getDecl());
1866 if (!ToDeclOrErr)
1867 return ToDeclOrErr.takeError();
1868
1869 return Importer.getToContext().getTemplateTypeParmType(
1870 Depth: T->getDepth(), Index: T->getIndex(), ParameterPack: T->isParameterPack(), ParmDecl: *ToDeclOrErr);
1871}
1872
1873ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1874 const SubstTemplateTypeParmType *T) {
1875 Expected<Decl *> ReplacedOrErr = import(From: T->getAssociatedDecl());
1876 if (!ReplacedOrErr)
1877 return ReplacedOrErr.takeError();
1878
1879 ExpectedType ToReplacementTypeOrErr = import(From: T->getReplacementType());
1880 if (!ToReplacementTypeOrErr)
1881 return ToReplacementTypeOrErr.takeError();
1882
1883 return Importer.getToContext().getSubstTemplateTypeParmType(
1884 Replacement: *ToReplacementTypeOrErr, AssociatedDecl: *ReplacedOrErr, Index: T->getIndex(), PackIndex: T->getPackIndex(),
1885 Final: T->getFinal());
1886}
1887
1888ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
1889 const SubstTemplateTypeParmPackType *T) {
1890 Expected<Decl *> ReplacedOrErr = import(From: T->getAssociatedDecl());
1891 if (!ReplacedOrErr)
1892 return ReplacedOrErr.takeError();
1893
1894 Expected<TemplateArgument> ToArgumentPack = import(From: T->getArgumentPack());
1895 if (!ToArgumentPack)
1896 return ToArgumentPack.takeError();
1897
1898 return Importer.getToContext().getSubstTemplateTypeParmPackType(
1899 AssociatedDecl: *ReplacedOrErr, Index: T->getIndex(), Final: T->getFinal(), ArgPack: *ToArgumentPack);
1900}
1901
1902ExpectedType ASTNodeImporter::VisitSubstBuiltinTemplatePackType(
1903 const SubstBuiltinTemplatePackType *T) {
1904 Expected<TemplateArgument> ToArgumentPack = import(From: T->getArgumentPack());
1905 if (!ToArgumentPack)
1906 return ToArgumentPack.takeError();
1907 return Importer.getToContext().getSubstBuiltinTemplatePack(ArgPack: *ToArgumentPack);
1908}
1909
1910ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1911 const TemplateSpecializationType *T) {
1912 auto ToTemplateOrErr = import(From: T->getTemplateName());
1913 if (!ToTemplateOrErr)
1914 return ToTemplateOrErr.takeError();
1915
1916 SmallVector<TemplateArgument, 2> ToTemplateArgs;
1917 if (Error Err =
1918 ImportTemplateArguments(FromArgs: T->template_arguments(), ToArgs&: ToTemplateArgs))
1919 return std::move(Err);
1920
1921 ExpectedType ToUnderlyingOrErr =
1922 T->isCanonicalUnqualified() ? QualType() : import(From: T->desugar());
1923 if (!ToUnderlyingOrErr)
1924 return ToUnderlyingOrErr.takeError();
1925 return Importer.getToContext().getTemplateSpecializationType(
1926 Keyword: T->getKeyword(), T: *ToTemplateOrErr, SpecifiedArgs: ToTemplateArgs, CanonicalArgs: {},
1927 Underlying: *ToUnderlyingOrErr);
1928}
1929
1930ExpectedType
1931ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1932 ExpectedType ToPatternOrErr = import(From: T->getPattern());
1933 if (!ToPatternOrErr)
1934 return ToPatternOrErr.takeError();
1935
1936 return Importer.getToContext().getPackExpansionType(Pattern: *ToPatternOrErr,
1937 NumExpansions: T->getNumExpansions(),
1938 /*ExpactPack=*/ExpectPackInType: false);
1939}
1940
1941ExpectedType
1942ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1943 auto ToQualifierOrErr = import(From: T->getQualifier());
1944 if (!ToQualifierOrErr)
1945 return ToQualifierOrErr.takeError();
1946
1947 IdentifierInfo *Name = Importer.Import(FromId: T->getIdentifier());
1948 return Importer.getToContext().getDependentNameType(Keyword: T->getKeyword(),
1949 NNS: *ToQualifierOrErr, Name);
1950}
1951
1952ExpectedType
1953ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1954 Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(From: T->getDecl());
1955 if (!ToDeclOrErr)
1956 return ToDeclOrErr.takeError();
1957
1958 return Importer.getToContext().getObjCInterfaceType(Decl: *ToDeclOrErr);
1959}
1960
1961ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1962 ExpectedType ToBaseTypeOrErr = import(From: T->getBaseType());
1963 if (!ToBaseTypeOrErr)
1964 return ToBaseTypeOrErr.takeError();
1965
1966 SmallVector<QualType, 4> TypeArgs;
1967 for (auto TypeArg : T->getTypeArgsAsWritten()) {
1968 if (ExpectedType TyOrErr = import(From: TypeArg))
1969 TypeArgs.push_back(Elt: *TyOrErr);
1970 else
1971 return TyOrErr.takeError();
1972 }
1973
1974 SmallVector<ObjCProtocolDecl *, 4> Protocols;
1975 for (auto *P : T->quals()) {
1976 if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(From: P))
1977 Protocols.push_back(Elt: *ProtocolOrErr);
1978 else
1979 return ProtocolOrErr.takeError();
1980
1981 }
1982
1983 return Importer.getToContext().getObjCObjectType(Base: *ToBaseTypeOrErr, typeArgs: TypeArgs,
1984 protocols: Protocols,
1985 isKindOf: T->isKindOfTypeAsWritten());
1986}
1987
1988ExpectedType
1989ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1990 ExpectedType ToPointeeTypeOrErr = import(From: T->getPointeeType());
1991 if (!ToPointeeTypeOrErr)
1992 return ToPointeeTypeOrErr.takeError();
1993
1994 return Importer.getToContext().getObjCObjectPointerType(OIT: *ToPointeeTypeOrErr);
1995}
1996
1997ExpectedType
1998ASTNodeImporter::VisitMacroQualifiedType(const MacroQualifiedType *T) {
1999 ExpectedType ToUnderlyingTypeOrErr = import(From: T->getUnderlyingType());
2000 if (!ToUnderlyingTypeOrErr)
2001 return ToUnderlyingTypeOrErr.takeError();
2002
2003 IdentifierInfo *ToIdentifier = Importer.Import(FromId: T->getMacroIdentifier());
2004 return Importer.getToContext().getMacroQualifiedType(UnderlyingTy: *ToUnderlyingTypeOrErr,
2005 MacroII: ToIdentifier);
2006}
2007
2008ExpectedType clang::ASTNodeImporter::VisitAdjustedType(const AdjustedType *T) {
2009 Error Err = Error::success();
2010 QualType ToOriginalType = importChecked(Err, From: T->getOriginalType());
2011 QualType ToAdjustedType = importChecked(Err, From: T->getAdjustedType());
2012 if (Err)
2013 return std::move(Err);
2014
2015 return Importer.getToContext().getAdjustedType(Orig: ToOriginalType,
2016 New: ToAdjustedType);
2017}
2018
2019ExpectedType clang::ASTNodeImporter::VisitBitIntType(const BitIntType *T) {
2020 return Importer.getToContext().getBitIntType(Unsigned: T->isUnsigned(),
2021 NumBits: T->getNumBits());
2022}
2023
2024ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType(
2025 const clang::BTFTagAttributedType *T) {
2026 Error Err = Error::success();
2027 const BTFTypeTagAttr *ToBTFAttr = importChecked(Err, From: T->getAttr());
2028 QualType ToWrappedType = importChecked(Err, From: T->getWrappedType());
2029 if (Err)
2030 return std::move(Err);
2031
2032 return Importer.getToContext().getBTFTagAttributedType(BTFAttr: ToBTFAttr,
2033 Wrapped: ToWrappedType);
2034}
2035
2036ExpectedType clang::ASTNodeImporter::VisitOverflowBehaviorType(
2037 const clang::OverflowBehaviorType *T) {
2038 Error Err = Error::success();
2039 OverflowBehaviorType::OverflowBehaviorKind ToKind = T->getBehaviorKind();
2040 QualType ToUnderlyingType = importChecked(Err, From: T->getUnderlyingType());
2041 if (Err)
2042 return std::move(Err);
2043
2044 return Importer.getToContext().getOverflowBehaviorType(Kind: ToKind,
2045 Wrapped: ToUnderlyingType);
2046}
2047
2048ExpectedType clang::ASTNodeImporter::VisitHLSLAttributedResourceType(
2049 const clang::HLSLAttributedResourceType *T) {
2050 Error Err = Error::success();
2051 HLSLAttributedResourceType::Attributes ToAttrs = T->getAttrs();
2052 QualType ToWrappedType = importChecked(Err, From: T->getWrappedType());
2053 QualType ToContainedType = importChecked(Err, From: T->getContainedType());
2054 ToAttrs.SampleCountExpr = importChecked(Err, From: T->getSampleCountExpr());
2055 if (Err)
2056 return std::move(Err);
2057
2058 return Importer.getToContext().getHLSLAttributedResourceType(
2059 Wrapped: ToWrappedType, Contained: ToContainedType, Attrs: ToAttrs);
2060}
2061
2062ExpectedType clang::ASTNodeImporter::VisitHLSLInlineSpirvType(
2063 const clang::HLSLInlineSpirvType *T) {
2064 Error Err = Error::success();
2065
2066 uint32_t ToOpcode = T->getOpcode();
2067 uint32_t ToSize = T->getSize();
2068 uint32_t ToAlignment = T->getAlignment();
2069
2070 llvm::SmallVector<SpirvOperand> ToOperands;
2071
2072 for (auto &Operand : T->getOperands()) {
2073 using SpirvOperandKind = SpirvOperand::SpirvOperandKind;
2074
2075 switch (Operand.getKind()) {
2076 case SpirvOperandKind::ConstantId:
2077 ToOperands.push_back(Elt: SpirvOperand::createConstant(
2078 ResultType: importChecked(Err, From: Operand.getResultType()), Val: Operand.getValue()));
2079 break;
2080 case SpirvOperandKind::Literal:
2081 ToOperands.push_back(Elt: SpirvOperand::createLiteral(Val: Operand.getValue()));
2082 break;
2083 case SpirvOperandKind::TypeId:
2084 ToOperands.push_back(Elt: SpirvOperand::createType(
2085 T: importChecked(Err, From: Operand.getResultType())));
2086 break;
2087 default:
2088 llvm_unreachable("Invalid SpirvOperand kind");
2089 }
2090
2091 if (Err)
2092 return std::move(Err);
2093 }
2094
2095 return Importer.getToContext().getHLSLInlineSpirvType(
2096 Opcode: ToOpcode, Size: ToSize, Alignment: ToAlignment, Operands: ToOperands);
2097}
2098
2099ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType(
2100 const clang::ConstantMatrixType *T) {
2101 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
2102 if (!ToElementTypeOrErr)
2103 return ToElementTypeOrErr.takeError();
2104
2105 return Importer.getToContext().getConstantMatrixType(
2106 ElementType: *ToElementTypeOrErr, NumRows: T->getNumRows(), NumColumns: T->getNumColumns());
2107}
2108
2109ExpectedType clang::ASTNodeImporter::VisitDependentAddressSpaceType(
2110 const clang::DependentAddressSpaceType *T) {
2111 Error Err = Error::success();
2112 QualType ToPointeeType = importChecked(Err, From: T->getPointeeType());
2113 Expr *ToAddrSpaceExpr = importChecked(Err, From: T->getAddrSpaceExpr());
2114 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2115 if (Err)
2116 return std::move(Err);
2117
2118 return Importer.getToContext().getDependentAddressSpaceType(
2119 PointeeType: ToPointeeType, AddrSpaceExpr: ToAddrSpaceExpr, AttrLoc: ToAttrLoc);
2120}
2121
2122ExpectedType clang::ASTNodeImporter::VisitDependentBitIntType(
2123 const clang::DependentBitIntType *T) {
2124 ExpectedExpr ToNumBitsExprOrErr = import(From: T->getNumBitsExpr());
2125 if (!ToNumBitsExprOrErr)
2126 return ToNumBitsExprOrErr.takeError();
2127 return Importer.getToContext().getDependentBitIntType(Unsigned: T->isUnsigned(),
2128 BitsExpr: *ToNumBitsExprOrErr);
2129}
2130
2131ExpectedType clang::ASTNodeImporter::VisitPredefinedSugarType(
2132 const clang::PredefinedSugarType *T) {
2133 return Importer.getToContext().getPredefinedSugarType(KD: T->getKind());
2134}
2135
2136ExpectedType clang::ASTNodeImporter::VisitDependentSizedMatrixType(
2137 const clang::DependentSizedMatrixType *T) {
2138 Error Err = Error::success();
2139 QualType ToElementType = importChecked(Err, From: T->getElementType());
2140 Expr *ToRowExpr = importChecked(Err, From: T->getRowExpr());
2141 Expr *ToColumnExpr = importChecked(Err, From: T->getColumnExpr());
2142 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2143 if (Err)
2144 return std::move(Err);
2145
2146 return Importer.getToContext().getDependentSizedMatrixType(
2147 ElementType: ToElementType, RowExpr: ToRowExpr, ColumnExpr: ToColumnExpr, AttrLoc: ToAttrLoc);
2148}
2149
2150ExpectedType clang::ASTNodeImporter::VisitDependentVectorType(
2151 const clang::DependentVectorType *T) {
2152 Error Err = Error::success();
2153 QualType ToElementType = importChecked(Err, From: T->getElementType());
2154 Expr *ToSizeExpr = importChecked(Err, From: T->getSizeExpr());
2155 SourceLocation ToAttrLoc = importChecked(Err, From: T->getAttributeLoc());
2156 if (Err)
2157 return std::move(Err);
2158
2159 return Importer.getToContext().getDependentVectorType(
2160 VectorType: ToElementType, SizeExpr: ToSizeExpr, AttrLoc: ToAttrLoc, VecKind: T->getVectorKind());
2161}
2162
2163ExpectedType clang::ASTNodeImporter::VisitObjCTypeParamType(
2164 const clang::ObjCTypeParamType *T) {
2165 Expected<ObjCTypeParamDecl *> ToDeclOrErr = import(From: T->getDecl());
2166 if (!ToDeclOrErr)
2167 return ToDeclOrErr.takeError();
2168
2169 SmallVector<ObjCProtocolDecl *, 4> ToProtocols;
2170 for (ObjCProtocolDecl *FromProtocol : T->getProtocols()) {
2171 Expected<ObjCProtocolDecl *> ToProtocolOrErr = import(From: FromProtocol);
2172 if (!ToProtocolOrErr)
2173 return ToProtocolOrErr.takeError();
2174 ToProtocols.push_back(Elt: *ToProtocolOrErr);
2175 }
2176
2177 return Importer.getToContext().getObjCTypeParamType(Decl: *ToDeclOrErr,
2178 protocols: ToProtocols);
2179}
2180
2181ExpectedType clang::ASTNodeImporter::VisitPipeType(const clang::PipeType *T) {
2182 ExpectedType ToElementTypeOrErr = import(From: T->getElementType());
2183 if (!ToElementTypeOrErr)
2184 return ToElementTypeOrErr.takeError();
2185
2186 ASTContext &ToCtx = Importer.getToContext();
2187 if (T->isReadOnly())
2188 return ToCtx.getReadPipeType(T: *ToElementTypeOrErr);
2189 else
2190 return ToCtx.getWritePipeType(T: *ToElementTypeOrErr);
2191}
2192
2193//----------------------------------------------------------------------------
2194// Import Declarations
2195//----------------------------------------------------------------------------
2196Error ASTNodeImporter::ImportDeclParts(
2197 NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
2198 DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
2199 // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
2200 // example: int struct_in_proto(struct data_t{int a;int b;} *d);
2201 // FIXME: We could support these constructs by importing a different type of
2202 // this parameter and by importing the original type of the parameter only
2203 // after the FunctionDecl is created. See
2204 // VisitFunctionDecl::UsedDifferentProtoType.
2205 DeclContext *OrigDC = D->getDeclContext();
2206 FunctionDecl *FunDecl;
2207 if (isa<RecordDecl>(Val: D) && (FunDecl = dyn_cast<FunctionDecl>(Val: OrigDC)) &&
2208 FunDecl->hasBody()) {
2209 auto getLeafPointeeType = [](const Type *T) {
2210 while (T->isPointerType() || T->isArrayType()) {
2211 T = T->getPointeeOrArrayElementType();
2212 }
2213 return T;
2214 };
2215 for (const ParmVarDecl *P : FunDecl->parameters()) {
2216 const Type *LeafT =
2217 getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
2218 auto *RT = dyn_cast<RecordType>(Val: LeafT);
2219 if (RT && RT->getDecl() == D) {
2220 Importer.FromDiag(Loc: D->getLocation(), DiagID: diag::err_unsupported_ast_node)
2221 << D->getDeclKindName();
2222 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
2223 }
2224 }
2225 }
2226
2227 // Import the context of this declaration.
2228 if (Error Err = ImportDeclContext(From: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
2229 return Err;
2230
2231 // Import the name of this declaration.
2232 if (Error Err = importInto(To&: Name, From: D->getDeclName()))
2233 return Err;
2234
2235 // Import the location of this declaration.
2236 if (Error Err = importInto(To&: Loc, From: D->getLocation()))
2237 return Err;
2238
2239 ToD = cast_or_null<NamedDecl>(Val: Importer.GetAlreadyImportedOrNull(FromD: D));
2240 if (ToD)
2241 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD: D, ToD))
2242 return Err;
2243
2244 return Error::success();
2245}
2246
2247Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
2248 NamedDecl *&ToD, SourceLocation &Loc) {
2249
2250 // Import the name of this declaration.
2251 if (Error Err = importInto(To&: Name, From: D->getDeclName()))
2252 return Err;
2253
2254 // Import the location of this declaration.
2255 if (Error Err = importInto(To&: Loc, From: D->getLocation()))
2256 return Err;
2257
2258 ToD = cast_or_null<NamedDecl>(Val: Importer.GetAlreadyImportedOrNull(FromD: D));
2259 if (ToD)
2260 if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD: D, ToD))
2261 return Err;
2262
2263 return Error::success();
2264}
2265
2266Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
2267 if (!FromD)
2268 return Error::success();
2269
2270 if (!ToD)
2271 if (Error Err = importInto(To&: ToD, From: FromD))
2272 return Err;
2273
2274 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(Val: FromD)) {
2275 if (RecordDecl *ToRecord = cast<RecordDecl>(Val: ToD)) {
2276 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
2277 !ToRecord->getDefinition()) {
2278 if (Error Err = ImportDefinition(From: FromRecord, To: ToRecord))
2279 return Err;
2280 }
2281 }
2282 return Error::success();
2283 }
2284
2285 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(Val: FromD)) {
2286 if (EnumDecl *ToEnum = cast<EnumDecl>(Val: ToD)) {
2287 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
2288 if (Error Err = ImportDefinition(From: FromEnum, To: ToEnum))
2289 return Err;
2290 }
2291 }
2292 return Error::success();
2293 }
2294
2295 return Error::success();
2296}
2297
2298Error
2299ASTNodeImporter::ImportDeclarationNameLoc(
2300 const DeclarationNameInfo &From, DeclarationNameInfo& To) {
2301 // NOTE: To.Name and To.Loc are already imported.
2302 // We only have to import To.LocInfo.
2303 switch (To.getName().getNameKind()) {
2304 case DeclarationName::Identifier:
2305 case DeclarationName::ObjCZeroArgSelector:
2306 case DeclarationName::ObjCOneArgSelector:
2307 case DeclarationName::ObjCMultiArgSelector:
2308 case DeclarationName::CXXUsingDirective:
2309 case DeclarationName::CXXDeductionGuideName:
2310 return Error::success();
2311
2312 case DeclarationName::CXXOperatorName: {
2313 if (auto ToRangeOrErr = import(From: From.getCXXOperatorNameRange()))
2314 To.setCXXOperatorNameRange(*ToRangeOrErr);
2315 else
2316 return ToRangeOrErr.takeError();
2317 return Error::success();
2318 }
2319 case DeclarationName::CXXLiteralOperatorName: {
2320 if (ExpectedSLoc LocOrErr = import(From: From.getCXXLiteralOperatorNameLoc()))
2321 To.setCXXLiteralOperatorNameLoc(*LocOrErr);
2322 else
2323 return LocOrErr.takeError();
2324 return Error::success();
2325 }
2326 case DeclarationName::CXXConstructorName:
2327 case DeclarationName::CXXDestructorName:
2328 case DeclarationName::CXXConversionFunctionName: {
2329 if (auto ToTInfoOrErr = import(From: From.getNamedTypeInfo()))
2330 To.setNamedTypeInfo(*ToTInfoOrErr);
2331 else
2332 return ToTInfoOrErr.takeError();
2333 return Error::success();
2334 }
2335 }
2336 llvm_unreachable("Unknown name kind.");
2337}
2338
2339Error
2340ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
2341 if (Importer.isMinimalImport() && !ForceImport) {
2342 auto ToDCOrErr = Importer.ImportContext(FromDC);
2343 return ToDCOrErr.takeError();
2344 }
2345
2346 // We use strict error handling in case of records and enums, but not
2347 // with e.g. namespaces.
2348 //
2349 // FIXME Clients of the ASTImporter should be able to choose an
2350 // appropriate error handling strategy for their needs. For instance,
2351 // they may not want to mark an entire namespace as erroneous merely
2352 // because there is an ODR error with two typedefs. As another example,
2353 // the client may allow EnumConstantDecls with same names but with
2354 // different values in two distinct translation units.
2355 ChildErrorHandlingStrategy HandleChildErrors(FromDC);
2356
2357 auto MightNeedReordering = [](const Decl *D) {
2358 return isa<FieldDecl>(Val: D) || isa<IndirectFieldDecl>(Val: D) || isa<FriendDecl>(Val: D);
2359 };
2360
2361 // Import everything that might need reordering first.
2362 Error ChildErrors = Error::success();
2363 for (auto *From : FromDC->decls()) {
2364 if (!MightNeedReordering(From))
2365 continue;
2366
2367 ExpectedDecl ImportedOrErr = import(From);
2368
2369 // If we are in the process of ImportDefinition(...) for a RecordDecl we
2370 // want to make sure that we are also completing each FieldDecl. There
2371 // are currently cases where this does not happen and this is correctness
2372 // fix since operations such as code generation will expect this to be so.
2373 if (!ImportedOrErr) {
2374 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors,
2375 ChildErr: ImportedOrErr.takeError());
2376 continue;
2377 }
2378 FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(Val: From);
2379 Decl *ImportedDecl = *ImportedOrErr;
2380 FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(Val: ImportedDecl);
2381 if (FieldFrom && FieldTo) {
2382 Error Err = ImportFieldDeclDefinition(From: FieldFrom, To: FieldTo);
2383 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors, ChildErr: std::move(Err));
2384 }
2385 }
2386
2387 // We reorder declarations in RecordDecls because they may have another order
2388 // in the "to" context than they have in the "from" context. This may happen
2389 // e.g when we import a class like this:
2390 // struct declToImport {
2391 // int a = c + b;
2392 // int b = 1;
2393 // int c = 2;
2394 // };
2395 // During the import of `a` we import first the dependencies in sequence,
2396 // thus the order would be `c`, `b`, `a`. We will get the normal order by
2397 // first removing the already imported members and then adding them in the
2398 // order as they appear in the "from" context.
2399 //
2400 // Keeping field order is vital because it determines structure layout.
2401 //
2402 // Here and below, we cannot call field_begin() method and its callers on
2403 // ToDC if it has an external storage. Calling field_begin() will
2404 // automatically load all the fields by calling
2405 // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
2406 // call ASTImporter::Import(). This is because the ExternalASTSource
2407 // interface in LLDB is implemented by the means of the ASTImporter. However,
2408 // calling an import at this point would result in an uncontrolled import, we
2409 // must avoid that.
2410
2411 auto ToDCOrErr = Importer.ImportContext(FromDC);
2412 if (!ToDCOrErr) {
2413 consumeError(Err: std::move(ChildErrors));
2414 return ToDCOrErr.takeError();
2415 }
2416
2417 if (const auto *FromRD = dyn_cast<RecordDecl>(Val: FromDC)) {
2418 DeclContext *ToDC = *ToDCOrErr;
2419 // Remove all declarations, which may be in wrong order in the
2420 // lexical DeclContext and then add them in the proper order.
2421 for (auto *D : FromRD->decls()) {
2422 if (!MightNeedReordering(D))
2423 continue;
2424
2425 assert(D && "DC contains a null decl");
2426 if (Decl *ToD = Importer.GetAlreadyImportedOrNull(FromD: D)) {
2427 // Remove only the decls which we successfully imported.
2428 assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
2429 // Remove the decl from its wrong place in the linked list.
2430 ToDC->removeDecl(D: ToD);
2431 // Add the decl to the end of the linked list.
2432 // This time it will be at the proper place because the enclosing for
2433 // loop iterates in the original (good) order of the decls.
2434 ToDC->addDeclInternal(D: ToD);
2435 }
2436 }
2437 }
2438
2439 // Import everything else.
2440 for (auto *From : FromDC->decls()) {
2441 if (MightNeedReordering(From))
2442 continue;
2443
2444 ExpectedDecl ImportedOrErr = import(From);
2445 if (!ImportedOrErr)
2446 HandleChildErrors.handleChildImportResult(ResultErr&: ChildErrors,
2447 ChildErr: ImportedOrErr.takeError());
2448 }
2449
2450 return ChildErrors;
2451}
2452
2453Error ASTNodeImporter::ImportFieldDeclDefinition(const FieldDecl *From,
2454 const FieldDecl *To) {
2455 RecordDecl *FromRecordDecl = nullptr;
2456 RecordDecl *ToRecordDecl = nullptr;
2457 // If we have a field that is an ArrayType we need to check if the array
2458 // element is a RecordDecl and if so we need to import the definition.
2459 QualType FromType = From->getType();
2460 QualType ToType = To->getType();
2461 if (FromType->isArrayType()) {
2462 // getBaseElementTypeUnsafe(...) handles multi-dimensional arrays for us.
2463 FromRecordDecl = FromType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2464 ToRecordDecl = ToType->getBaseElementTypeUnsafe()->getAsRecordDecl();
2465 }
2466
2467 if (!FromRecordDecl || !ToRecordDecl) {
2468 const RecordType *RecordFrom = FromType->getAs<RecordType>();
2469 const RecordType *RecordTo = ToType->getAs<RecordType>();
2470
2471 if (RecordFrom && RecordTo) {
2472 FromRecordDecl = RecordFrom->getDecl();
2473 ToRecordDecl = RecordTo->getDecl();
2474 }
2475 }
2476
2477 if (FromRecordDecl && ToRecordDecl) {
2478 if (FromRecordDecl->isCompleteDefinition() &&
2479 !ToRecordDecl->isCompleteDefinition())
2480 return ImportDefinition(From: FromRecordDecl, To: ToRecordDecl);
2481 }
2482
2483 return Error::success();
2484}
2485
2486Error ASTNodeImporter::ImportDeclContext(
2487 Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
2488 auto ToDCOrErr = Importer.ImportContext(FromDC: FromD->getDeclContext());
2489 if (!ToDCOrErr)
2490 return ToDCOrErr.takeError();
2491 ToDC = *ToDCOrErr;
2492
2493 if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
2494 auto ToLexicalDCOrErr = Importer.ImportContext(
2495 FromDC: FromD->getLexicalDeclContext());
2496 if (!ToLexicalDCOrErr)
2497 return ToLexicalDCOrErr.takeError();
2498 ToLexicalDC = *ToLexicalDCOrErr;
2499 } else
2500 ToLexicalDC = ToDC;
2501
2502 return Error::success();
2503}
2504
2505Error ASTNodeImporter::ImportImplicitMethods(
2506 const CXXRecordDecl *From, CXXRecordDecl *To) {
2507 assert(From->isCompleteDefinition() && To->getDefinition() == To &&
2508 "Import implicit methods to or from non-definition");
2509
2510 for (CXXMethodDecl *FromM : From->methods())
2511 if (FromM->isImplicit()) {
2512 Expected<CXXMethodDecl *> ToMOrErr = import(From: FromM);
2513 if (!ToMOrErr)
2514 return ToMOrErr.takeError();
2515 }
2516
2517 return Error::success();
2518}
2519
2520static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
2521 ASTImporter &Importer) {
2522 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
2523 if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromD: FromTypedef))
2524 To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(Val: *ToTypedefOrErr));
2525 else
2526 return ToTypedefOrErr.takeError();
2527 }
2528 return Error::success();
2529}
2530
2531Error ASTNodeImporter::ImportDefinition(
2532 RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
2533 auto DefinitionCompleter = [To]() {
2534 // There are cases in LLDB when we first import a class without its
2535 // members. The class will have DefinitionData, but no members. Then,
2536 // importDefinition is called from LLDB, which tries to get the members, so
2537 // when we get here, the class already has the DefinitionData set, so we
2538 // must unset the CompleteDefinition here to be able to complete again the
2539 // definition.
2540 To->setCompleteDefinition(false);
2541 To->completeDefinition();
2542 };
2543
2544 if (To->getDefinition() || To->isBeingDefined()) {
2545 if (Kind == IDK_Everything ||
2546 // In case of lambdas, the class already has a definition ptr set, but
2547 // the contained decls are not imported yet. Also, isBeingDefined was
2548 // set in CXXRecordDecl::CreateLambda. We must import the contained
2549 // decls here and finish the definition.
2550 (To->isLambda() && shouldForceImportDeclContext(IDK: Kind))) {
2551 if (To->isLambda()) {
2552 auto *FromCXXRD = cast<CXXRecordDecl>(Val: From);
2553 SmallVector<LambdaCapture, 8> ToCaptures;
2554 ToCaptures.reserve(N: FromCXXRD->capture_size());
2555 for (const auto &FromCapture : FromCXXRD->captures()) {
2556 if (auto ToCaptureOrErr = import(From: FromCapture))
2557 ToCaptures.push_back(Elt: *ToCaptureOrErr);
2558 else
2559 return ToCaptureOrErr.takeError();
2560 }
2561 cast<CXXRecordDecl>(Val: To)->setCaptures(Context&: Importer.getToContext(),
2562 Captures: ToCaptures);
2563 }
2564
2565 Error Result = ImportDeclContext(FromDC: From, /*ForceImport=*/true);
2566 // Finish the definition of the lambda, set isBeingDefined to false.
2567 if (To->isLambda())
2568 DefinitionCompleter();
2569 return Result;
2570 }
2571
2572 return Error::success();
2573 }
2574
2575 To->startDefinition();
2576 // Set the definition to complete even if it is really not complete during
2577 // import. Some AST constructs (expressions) require the record layout
2578 // to be calculated (see 'clang::computeDependence') at the time they are
2579 // constructed. Import of such AST node is possible during import of the
2580 // same record, there is no way to have a completely defined record (all
2581 // fields imported) at that time without multiple AST import passes.
2582 if (!Importer.isMinimalImport())
2583 To->setCompleteDefinition(true);
2584 // Complete the definition even if error is returned.
2585 // The RecordDecl may be already part of the AST so it is better to
2586 // have it in complete state even if something is wrong with it.
2587 llvm::scope_exit DefinitionCompleterScopeExit(DefinitionCompleter);
2588
2589 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2590 return Err;
2591
2592 // Add base classes.
2593 auto *ToCXX = dyn_cast<CXXRecordDecl>(Val: To);
2594 auto *FromCXX = dyn_cast<CXXRecordDecl>(Val: From);
2595 if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
2596
2597 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
2598 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
2599
2600 #define FIELD(Name, Width, Merge) \
2601 ToData.Name = FromData.Name;
2602 #include "clang/AST/CXXRecordDeclDefinitionBits.def"
2603
2604 // Copy over the data stored in RecordDeclBits
2605 ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
2606
2607 SmallVector<CXXBaseSpecifier *, 4> Bases;
2608 for (const auto &Base1 : FromCXX->bases()) {
2609 ExpectedType TyOrErr = import(From: Base1.getType());
2610 if (!TyOrErr)
2611 return TyOrErr.takeError();
2612
2613 SourceLocation EllipsisLoc;
2614 if (Base1.isPackExpansion()) {
2615 if (ExpectedSLoc LocOrErr = import(From: Base1.getEllipsisLoc()))
2616 EllipsisLoc = *LocOrErr;
2617 else
2618 return LocOrErr.takeError();
2619 }
2620
2621 // Ensure that we have a definition for the base.
2622 if (Error Err =
2623 ImportDefinitionIfNeeded(FromD: Base1.getType()->getAsCXXRecordDecl()))
2624 return Err;
2625
2626 auto RangeOrErr = import(From: Base1.getSourceRange());
2627 if (!RangeOrErr)
2628 return RangeOrErr.takeError();
2629
2630 auto TSIOrErr = import(From: Base1.getTypeSourceInfo());
2631 if (!TSIOrErr)
2632 return TSIOrErr.takeError();
2633
2634 Bases.push_back(
2635 Elt: new (Importer.getToContext()) CXXBaseSpecifier(
2636 *RangeOrErr,
2637 Base1.isVirtual(),
2638 Base1.isBaseOfClass(),
2639 Base1.getAccessSpecifierAsWritten(),
2640 *TSIOrErr,
2641 EllipsisLoc));
2642 }
2643 if (!Bases.empty())
2644 ToCXX->setBases(Bases: Bases.data(), NumBases: Bases.size());
2645 }
2646
2647 if (shouldForceImportDeclContext(IDK: Kind)) {
2648 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
2649 return Err;
2650 }
2651
2652 return Error::success();
2653}
2654
2655Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
2656 if (To->getAnyInitializer())
2657 return Error::success();
2658
2659 Expr *FromInit = From->getInit();
2660 if (!FromInit)
2661 return Error::success();
2662
2663 ExpectedExpr ToInitOrErr = import(From: FromInit);
2664 if (!ToInitOrErr)
2665 return ToInitOrErr.takeError();
2666
2667 To->setInit(*ToInitOrErr);
2668 if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2669 EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2670 ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2671 ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2672 // FIXME: Also import the initializer value.
2673 }
2674
2675 // FIXME: Other bits to merge?
2676 return Error::success();
2677}
2678
2679Error ASTNodeImporter::ImportDefinition(
2680 EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
2681 if (To->getDefinition() || To->isBeingDefined()) {
2682 if (Kind == IDK_Everything)
2683 return ImportDeclContext(FromDC: From, /*ForceImport=*/true);
2684 return Error::success();
2685 }
2686
2687 To->startDefinition();
2688
2689 if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2690 return Err;
2691
2692 ExpectedType ToTypeOrErr =
2693 import(From: QualType(Importer.getFromContext().getCanonicalTagType(TD: From)));
2694 if (!ToTypeOrErr)
2695 return ToTypeOrErr.takeError();
2696
2697 ExpectedType ToPromotionTypeOrErr = import(From: From->getPromotionType());
2698 if (!ToPromotionTypeOrErr)
2699 return ToPromotionTypeOrErr.takeError();
2700
2701 if (shouldForceImportDeclContext(IDK: Kind))
2702 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
2703 return Err;
2704
2705 // FIXME: we might need to merge the number of positive or negative bits
2706 // if the enumerator lists don't match.
2707 To->completeDefinition(NewType: *ToTypeOrErr, PromotionType: *ToPromotionTypeOrErr,
2708 NumPositiveBits: From->getNumPositiveBits(),
2709 NumNegativeBits: From->getNumNegativeBits());
2710 return Error::success();
2711}
2712
2713Error ASTNodeImporter::ImportTemplateArguments(
2714 ArrayRef<TemplateArgument> FromArgs,
2715 SmallVectorImpl<TemplateArgument> &ToArgs) {
2716 for (const auto &Arg : FromArgs) {
2717 if (auto ToOrErr = import(From: Arg))
2718 ToArgs.push_back(Elt: *ToOrErr);
2719 else
2720 return ToOrErr.takeError();
2721 }
2722
2723 return Error::success();
2724}
2725
2726// FIXME: Do not forget to remove this and use only 'import'.
2727Expected<TemplateArgument>
2728ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2729 return import(From);
2730}
2731
2732template <typename InContainerTy>
2733Error ASTNodeImporter::ImportTemplateArgumentListInfo(
2734 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
2735 for (const auto &FromLoc : Container) {
2736 if (auto ToLocOrErr = import(FromLoc))
2737 ToTAInfo.addArgument(Loc: *ToLocOrErr);
2738 else
2739 return ToLocOrErr.takeError();
2740 }
2741 return Error::success();
2742}
2743
2744static StructuralEquivalenceKind
2745getStructuralEquivalenceKind(const ASTImporter &Importer) {
2746 return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
2747 : StructuralEquivalenceKind::Default;
2748}
2749
2750bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain,
2751 bool IgnoreTemplateParmDepth) {
2752 // Eliminate a potential failure point where we attempt to re-import
2753 // something we're trying to import while completing ToRecord.
2754 Decl *ToOrigin = Importer.GetOriginalDecl(To);
2755 if (ToOrigin) {
2756 To = ToOrigin;
2757 }
2758
2759 StructuralEquivalenceContext Ctx(
2760 Importer.getToContext().getLangOpts(), Importer.getFromContext(),
2761 Importer.getToContext(), Importer.getNonEquivalentDecls(),
2762 getStructuralEquivalenceKind(Importer),
2763 /*StrictTypeSpelling=*/false, Complain, /*ErrorOnTagTypeMismatch=*/false,
2764 IgnoreTemplateParmDepth);
2765 return Ctx.IsEquivalent(D1: From, D2: To);
2766}
2767
2768ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
2769 Importer.FromDiag(Loc: D->getLocation(), DiagID: diag::err_unsupported_ast_node)
2770 << D->getDeclKindName();
2771 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
2772}
2773
2774ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *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::VisitEmptyDecl(EmptyDecl *D) {
2781 // Import the context of this declaration.
2782 DeclContext *DC, *LexicalDC;
2783 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
2784 return std::move(Err);
2785
2786 // Import the location of this declaration.
2787 ExpectedSLoc LocOrErr = import(From: D->getLocation());
2788 if (!LocOrErr)
2789 return LocOrErr.takeError();
2790
2791 EmptyDecl *ToD;
2792 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: *LocOrErr))
2793 return ToD;
2794
2795 ToD->setLexicalDeclContext(LexicalDC);
2796 LexicalDC->addDeclInternal(D: ToD);
2797 return ToD;
2798}
2799
2800ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2801 TranslationUnitDecl *ToD =
2802 Importer.getToContext().getTranslationUnitDecl();
2803
2804 Importer.MapImported(From: D, To: ToD);
2805
2806 return ToD;
2807}
2808
2809ExpectedDecl ASTNodeImporter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
2810 Error Err = Error::success();
2811 Expr *ToAsmString = importChecked(Err, From: D->getAsmStringExpr());
2812 SourceLocation ToAsmLoc = importChecked(Err, From: D->getAsmLoc());
2813 SourceLocation ToRParenLoc = importChecked(Err, From: D->getRParenLoc());
2814 if (Err)
2815 return std::move(Err);
2816
2817 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2818 if (!DCOrErr)
2819 return DCOrErr.takeError();
2820 DeclContext *DC = *DCOrErr;
2821
2822 FileScopeAsmDecl *ToD;
2823 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToAsmString,
2824 args&: ToAsmLoc, args&: ToRParenLoc))
2825 return ToD;
2826
2827 ToD->setLexicalDeclContext(DC);
2828 DC->addDeclInternal(D: ToD);
2829
2830 return ToD;
2831}
2832
2833ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
2834 DeclContext *DC, *LexicalDC;
2835 DeclarationName Name;
2836 SourceLocation Loc;
2837 NamedDecl *ToND;
2838 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: ToND, Loc))
2839 return std::move(Err);
2840 if (ToND)
2841 return ToND;
2842
2843 BindingDecl *ToD;
2844 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
2845 args: Name.getAsIdentifierInfo(), args: D->getType()))
2846 return ToD;
2847
2848 Error Err = Error::success();
2849 QualType ToType = importChecked(Err, From: D->getType());
2850 Expr *ToBinding = importChecked(Err, From: D->getBinding());
2851 DecompositionDecl *ToDecomposedDecl =
2852 importChecked(Err, From: D->getDecomposedDecl());
2853 if (Err)
2854 return std::move(Err);
2855
2856 ToD->setBinding(DeclaredType: ToType, Binding: ToBinding);
2857 ToD->setDecomposedDecl(ToDecomposedDecl);
2858 addDeclToContexts(FromD: D, ToD);
2859
2860 return ToD;
2861}
2862
2863ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2864 ExpectedSLoc LocOrErr = import(From: D->getLocation());
2865 if (!LocOrErr)
2866 return LocOrErr.takeError();
2867 auto ColonLocOrErr = import(From: D->getColonLoc());
2868 if (!ColonLocOrErr)
2869 return ColonLocOrErr.takeError();
2870
2871 // Import the context of this declaration.
2872 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2873 if (!DCOrErr)
2874 return DCOrErr.takeError();
2875 DeclContext *DC = *DCOrErr;
2876
2877 AccessSpecDecl *ToD;
2878 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args: D->getAccess(),
2879 args&: DC, args&: *LocOrErr, args&: *ColonLocOrErr))
2880 return ToD;
2881
2882 // Lexical DeclContext and Semantic DeclContext
2883 // is always the same for the accessSpec.
2884 ToD->setLexicalDeclContext(DC);
2885 DC->addDeclInternal(D: ToD);
2886
2887 return ToD;
2888}
2889
2890ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2891 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2892 if (!DCOrErr)
2893 return DCOrErr.takeError();
2894 DeclContext *DC = *DCOrErr;
2895 DeclContext *LexicalDC = DC;
2896
2897 Error Err = Error::success();
2898 auto ToLocation = importChecked(Err, From: D->getLocation());
2899 auto ToRParenLoc = importChecked(Err, From: D->getRParenLoc());
2900 auto ToAssertExpr = importChecked(Err, From: D->getAssertExpr());
2901 auto ToMessage = importChecked(Err, From: D->getMessage());
2902 if (Err)
2903 return std::move(Err);
2904
2905 StaticAssertDecl *ToD;
2906 if (GetImportedOrCreateDecl(
2907 ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToLocation, args&: ToAssertExpr, args&: ToMessage,
2908 args&: ToRParenLoc, args: D->isFailed()))
2909 return ToD;
2910
2911 ToD->setLexicalDeclContext(LexicalDC);
2912 LexicalDC->addDeclInternal(D: ToD);
2913 return ToD;
2914}
2915
2916ExpectedDecl
2917ASTNodeImporter::VisitCXXExpansionStmtDecl(CXXExpansionStmtDecl *D) {
2918 auto DCOrErr = Importer.ImportContext(FromDC: D->getDeclContext());
2919 if (!DCOrErr)
2920 return DCOrErr.takeError();
2921 DeclContext *DC = *DCOrErr;
2922 DeclContext *LexicalDC = DC;
2923
2924 Error Err = Error::success();
2925 auto ToLocation = importChecked(Err, From: D->getLocation());
2926 auto ToExpansion = importChecked(Err, From: D->getExpansionPattern());
2927 auto ToIndex = importChecked(Err, From: D->getIndexTemplateParm());
2928 auto ToInstantiations = importChecked(Err, From: D->getInstantiations());
2929 if (Err)
2930 return std::move(Err);
2931
2932 CXXExpansionStmtDecl *ToD;
2933 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToLocation,
2934 args&: ToIndex))
2935 return ToD;
2936
2937 ToD->setExpansionPattern(ToExpansion);
2938 ToD->setInstantiations(ToInstantiations);
2939 ToD->setLexicalDeclContext(LexicalDC);
2940 LexicalDC->addDeclInternal(D: ToD);
2941 return ToD;
2942}
2943
2944ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2945 // Import the major distinguishing characteristics of this namespace.
2946 DeclContext *DC, *LexicalDC;
2947 DeclarationName Name;
2948 SourceLocation Loc;
2949 NamedDecl *ToD;
2950 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2951 return std::move(Err);
2952 if (ToD)
2953 return ToD;
2954
2955 NamespaceDecl *MergeWithNamespace = nullptr;
2956 if (!Name) {
2957 // This is an anonymous namespace. Adopt an existing anonymous
2958 // namespace if we can.
2959 DeclContext *EnclosingDC = DC->getEnclosingNamespaceContext();
2960 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: EnclosingDC))
2961 MergeWithNamespace = TU->getAnonymousNamespace();
2962 else
2963 MergeWithNamespace =
2964 cast<NamespaceDecl>(Val: EnclosingDC)->getAnonymousNamespace();
2965 } else {
2966 SmallVector<NamedDecl *, 4> ConflictingDecls;
2967 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2968 for (auto *FoundDecl : FoundDecls) {
2969 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Namespace))
2970 continue;
2971
2972 if (auto *FoundNS = dyn_cast<NamespaceDecl>(Val: FoundDecl)) {
2973 MergeWithNamespace = FoundNS;
2974 ConflictingDecls.clear();
2975 break;
2976 }
2977
2978 ConflictingDecls.push_back(Elt: FoundDecl);
2979 }
2980
2981 if (!ConflictingDecls.empty()) {
2982 ExpectedName NameOrErr = Importer.HandleNameConflict(
2983 Name, DC, IDNS: Decl::IDNS_Namespace, Decls: ConflictingDecls.data(),
2984 NumDecls: ConflictingDecls.size());
2985 if (NameOrErr)
2986 Name = NameOrErr.get();
2987 else
2988 return NameOrErr.takeError();
2989 }
2990 }
2991
2992 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
2993 if (!BeginLocOrErr)
2994 return BeginLocOrErr.takeError();
2995 ExpectedSLoc RBraceLocOrErr = import(From: D->getRBraceLoc());
2996 if (!RBraceLocOrErr)
2997 return RBraceLocOrErr.takeError();
2998
2999 // Create the "to" namespace, if needed.
3000 NamespaceDecl *ToNamespace = MergeWithNamespace;
3001 if (!ToNamespace) {
3002 if (GetImportedOrCreateDecl(ToD&: ToNamespace, FromD: D, args&: Importer.getToContext(), args&: DC,
3003 args: D->isInline(), args&: *BeginLocOrErr, args&: Loc,
3004 args: Name.getAsIdentifierInfo(),
3005 /*PrevDecl=*/args: nullptr, args: D->isNested()))
3006 return ToNamespace;
3007 ToNamespace->setRBraceLoc(*RBraceLocOrErr);
3008 ToNamespace->setLexicalDeclContext(LexicalDC);
3009 LexicalDC->addDeclInternal(D: ToNamespace);
3010
3011 // If this is an anonymous namespace, register it as the anonymous
3012 // namespace within its context.
3013 if (!Name) {
3014 if (auto *TU = dyn_cast<TranslationUnitDecl>(Val: DC))
3015 TU->setAnonymousNamespace(ToNamespace);
3016 else
3017 cast<NamespaceDecl>(Val: DC)->setAnonymousNamespace(ToNamespace);
3018 }
3019 }
3020 Importer.MapImported(From: D, To: ToNamespace);
3021
3022 if (Error Err = ImportDeclContext(FromDC: D))
3023 return std::move(Err);
3024
3025 return ToNamespace;
3026}
3027
3028ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
3029 // Import the major distinguishing characteristics of this namespace.
3030 DeclContext *DC, *LexicalDC;
3031 DeclarationName Name;
3032 SourceLocation Loc;
3033 NamedDecl *LookupD;
3034 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: LookupD, Loc))
3035 return std::move(Err);
3036 if (LookupD)
3037 return LookupD;
3038
3039 // NOTE: No conflict resolution is done for namespace aliases now.
3040
3041 Error Err = Error::success();
3042 auto ToNamespaceLoc = importChecked(Err, From: D->getNamespaceLoc());
3043 auto ToAliasLoc = importChecked(Err, From: D->getAliasLoc());
3044 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3045 auto ToTargetNameLoc = importChecked(Err, From: D->getTargetNameLoc());
3046 auto ToNamespace = importChecked(Err, From: D->getNamespace());
3047 if (Err)
3048 return std::move(Err);
3049
3050 IdentifierInfo *ToIdentifier = Importer.Import(FromId: D->getIdentifier());
3051
3052 NamespaceAliasDecl *ToD;
3053 if (GetImportedOrCreateDecl(
3054 ToD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToNamespaceLoc, args&: ToAliasLoc,
3055 args&: ToIdentifier, args&: ToQualifierLoc, args&: ToTargetNameLoc, args&: ToNamespace))
3056 return ToD;
3057
3058 ToD->setLexicalDeclContext(LexicalDC);
3059 LexicalDC->addDeclInternal(D: ToD);
3060
3061 return ToD;
3062}
3063
3064ExpectedDecl
3065ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
3066 // Import the major distinguishing characteristics of this typedef.
3067 DeclarationName Name;
3068 SourceLocation Loc;
3069 NamedDecl *ToD;
3070 // Do not import the DeclContext, we will import it once the TypedefNameDecl
3071 // is created.
3072 if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
3073 return std::move(Err);
3074 if (ToD)
3075 return ToD;
3076
3077 DeclContext *DC = cast_or_null<DeclContext>(
3078 Val: Importer.GetAlreadyImportedOrNull(FromD: cast<Decl>(Val: D->getDeclContext())));
3079 DeclContext *LexicalDC =
3080 cast_or_null<DeclContext>(Val: Importer.GetAlreadyImportedOrNull(
3081 FromD: cast<Decl>(Val: D->getLexicalDeclContext())));
3082
3083 // If this typedef is not in block scope, determine whether we've
3084 // seen a typedef with the same name (that we can merge with) or any
3085 // other entity by that name (which name lookup could conflict with).
3086 // Note: Repeated typedefs are not valid in C99:
3087 // 'typedef int T; typedef int T;' is invalid
3088 // We do not care about this now.
3089 if (DC && !DC->isFunctionOrMethod()) {
3090 SmallVector<NamedDecl *, 4> ConflictingDecls;
3091 unsigned IDNS = Decl::IDNS_Ordinary;
3092 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3093 for (auto *FoundDecl : FoundDecls) {
3094 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3095 continue;
3096 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(Val: FoundDecl)) {
3097 if (!hasSameVisibilityContextAndLinkage(Found: FoundTypedef, From: D))
3098 continue;
3099
3100 QualType FromUT = D->getUnderlyingType();
3101 QualType FoundUT = FoundTypedef->getUnderlyingType();
3102 if (Importer.IsStructurallyEquivalent(From: FromUT, To: FoundUT)) {
3103 // If the underlying declarations are unnamed records these can be
3104 // imported as different types. We should create a distinct typedef
3105 // node in this case.
3106 // If we found an existing underlying type with a record in a
3107 // different context (than the imported), this is already reason for
3108 // having distinct typedef nodes for these.
3109 // Again this can create situation like
3110 // 'typedef int T; typedef int T;' but this is hard to avoid without
3111 // a rename strategy at import.
3112 if (!FromUT.isNull() && !FoundUT.isNull()) {
3113 RecordDecl *FromR = FromUT->getAsRecordDecl();
3114 RecordDecl *FoundR = FoundUT->getAsRecordDecl();
3115 if (FromR && FoundR &&
3116 !hasSameVisibilityContextAndLinkage(Found: FoundR, From: FromR))
3117 continue;
3118 }
3119 // If the "From" context has a complete underlying type but we
3120 // already have a complete underlying type then return with that.
3121 if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
3122 return Importer.MapImported(From: D, To: FoundTypedef);
3123 // FIXME Handle redecl chain. When you do that make consistent changes
3124 // in ASTImporterLookupTable too.
3125 } else {
3126 ConflictingDecls.push_back(Elt: FoundDecl);
3127 }
3128 }
3129 }
3130
3131 if (!ConflictingDecls.empty()) {
3132 ExpectedName NameOrErr = Importer.HandleNameConflict(
3133 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3134 if (NameOrErr)
3135 Name = NameOrErr.get();
3136 else
3137 return NameOrErr.takeError();
3138 }
3139 }
3140
3141 Error Err = Error::success();
3142 auto ToUnderlyingType = importChecked(Err, From: D->getUnderlyingType());
3143 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
3144 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
3145 if (Err)
3146 return std::move(Err);
3147
3148 // Create the new typedef node.
3149 // FIXME: ToUnderlyingType is not used.
3150 (void)ToUnderlyingType;
3151 TypedefNameDecl *ToTypedef;
3152 if (IsAlias) {
3153 if (GetImportedOrCreateDecl<TypeAliasDecl>(
3154 ToD&: ToTypedef, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc, args&: Loc,
3155 args: Name.getAsIdentifierInfo(), args&: ToTypeSourceInfo))
3156 return ToTypedef;
3157 } else if (GetImportedOrCreateDecl<TypedefDecl>(
3158 ToD&: ToTypedef, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc, args&: Loc,
3159 args: Name.getAsIdentifierInfo(), args&: ToTypeSourceInfo))
3160 return ToTypedef;
3161
3162 // Import the DeclContext and set it to the Typedef.
3163 if ((Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC)))
3164 return std::move(Err);
3165 ToTypedef->setDeclContext(DC);
3166 ToTypedef->setLexicalDeclContext(LexicalDC);
3167 // Add to the lookupTable because we could not do that in MapImported.
3168 Importer.AddToLookupTable(ToD: ToTypedef);
3169
3170 ToTypedef->setAccess(D->getAccess());
3171
3172 // Templated declarations should not appear in DeclContext.
3173 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(Val: D) : nullptr;
3174 if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
3175 LexicalDC->addDeclInternal(D: ToTypedef);
3176
3177 return ToTypedef;
3178}
3179
3180ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
3181 return VisitTypedefNameDecl(D, /*IsAlias=*/false);
3182}
3183
3184ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
3185 return VisitTypedefNameDecl(D, /*IsAlias=*/true);
3186}
3187
3188ExpectedDecl
3189ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
3190 // Import the major distinguishing characteristics of this typedef.
3191 DeclContext *DC, *LexicalDC;
3192 DeclarationName Name;
3193 SourceLocation Loc;
3194 NamedDecl *FoundD;
3195 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD&: FoundD, Loc))
3196 return std::move(Err);
3197 if (FoundD)
3198 return FoundD;
3199
3200 // If this typedef is not in block scope, determine whether we've
3201 // seen a typedef with the same name (that we can merge with) or any
3202 // other entity by that name (which name lookup could conflict with).
3203 if (!DC->isFunctionOrMethod()) {
3204 SmallVector<NamedDecl *, 4> ConflictingDecls;
3205 unsigned IDNS = Decl::IDNS_Ordinary;
3206 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3207 for (auto *FoundDecl : FoundDecls) {
3208 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3209 continue;
3210 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(Val: FoundDecl)) {
3211 if (IsStructuralMatch(From: D, To: FoundAlias))
3212 return Importer.MapImported(From: D, To: FoundAlias);
3213 ConflictingDecls.push_back(Elt: FoundDecl);
3214 }
3215 }
3216
3217 if (!ConflictingDecls.empty()) {
3218 ExpectedName NameOrErr = Importer.HandleNameConflict(
3219 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3220 if (NameOrErr)
3221 Name = NameOrErr.get();
3222 else
3223 return NameOrErr.takeError();
3224 }
3225 }
3226
3227 Error Err = Error::success();
3228 auto ToTemplateParameters = importChecked(Err, From: D->getTemplateParameters());
3229 auto ToTemplatedDecl = importChecked(Err, From: D->getTemplatedDecl());
3230 if (Err)
3231 return std::move(Err);
3232
3233 TypeAliasTemplateDecl *ToAlias;
3234 if (GetImportedOrCreateDecl(ToD&: ToAlias, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3235 args&: Name, args&: ToTemplateParameters, args&: ToTemplatedDecl))
3236 return ToAlias;
3237
3238 ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
3239
3240 ToAlias->setAccess(D->getAccess());
3241 ToAlias->setLexicalDeclContext(LexicalDC);
3242 LexicalDC->addDeclInternal(D: ToAlias);
3243 if (DC != Importer.getToContext().getTranslationUnitDecl())
3244 updateLookupTableForTemplateParameters(Params&: *ToTemplateParameters);
3245 return ToAlias;
3246}
3247
3248ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
3249 // Import the major distinguishing characteristics of this label.
3250 DeclContext *DC, *LexicalDC;
3251 DeclarationName Name;
3252 SourceLocation Loc;
3253 NamedDecl *ToD;
3254 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3255 return std::move(Err);
3256 if (ToD)
3257 return ToD;
3258
3259 assert(LexicalDC->isFunctionOrMethod());
3260
3261 LabelDecl *ToLabel;
3262 if (D->isGnuLocal()) {
3263 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
3264 if (!BeginLocOrErr)
3265 return BeginLocOrErr.takeError();
3266 if (GetImportedOrCreateDecl(ToD&: ToLabel, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3267 args: Name.getAsIdentifierInfo(), args&: *BeginLocOrErr))
3268 return ToLabel;
3269
3270 } else {
3271 if (GetImportedOrCreateDecl(ToD&: ToLabel, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
3272 args: Name.getAsIdentifierInfo()))
3273 return ToLabel;
3274
3275 }
3276
3277 Expected<LabelStmt *> ToStmtOrErr = import(From: D->getStmt());
3278 if (!ToStmtOrErr)
3279 return ToStmtOrErr.takeError();
3280
3281 ToLabel->setStmt(*ToStmtOrErr);
3282 ToLabel->setLexicalDeclContext(LexicalDC);
3283 LexicalDC->addDeclInternal(D: ToLabel);
3284 return ToLabel;
3285}
3286
3287ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
3288 // Import the major distinguishing characteristics of this enum.
3289 DeclContext *DC, *LexicalDC;
3290 DeclarationName Name;
3291 SourceLocation Loc;
3292 NamedDecl *ToD;
3293 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3294 return std::move(Err);
3295 if (ToD)
3296 return ToD;
3297
3298 // Figure out what enum name we're looking for.
3299 unsigned IDNS = Decl::IDNS_Tag;
3300 DeclarationName SearchName = Name;
3301 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3302 if (Error Err = importInto(
3303 To&: SearchName, From: D->getTypedefNameForAnonDecl()->getDeclName()))
3304 return std::move(Err);
3305 IDNS = Decl::IDNS_Ordinary;
3306 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3307 IDNS |= Decl::IDNS_Ordinary;
3308
3309 // We may already have an enum of the same name; try to find and match it.
3310 EnumDecl *PrevDecl = nullptr;
3311 if (!DC->isFunctionOrMethod()) {
3312 SmallVector<NamedDecl *, 4> ConflictingDecls;
3313 auto FoundDecls =
3314 Importer.findDeclsInToCtx(DC, Name: SearchName);
3315 for (auto *FoundDecl : FoundDecls) {
3316 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3317 continue;
3318
3319 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Val: FoundDecl)) {
3320 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3321 FoundDecl = Tag->getDecl();
3322 }
3323
3324 if (auto *FoundEnum = dyn_cast<EnumDecl>(Val: FoundDecl)) {
3325 if (!hasSameVisibilityContextAndLinkage(Found: FoundEnum, From: D))
3326 continue;
3327 if (IsStructuralMatch(From: D, To: FoundEnum, Complain: !SearchName.isEmpty())) {
3328 EnumDecl *FoundDef = FoundEnum->getDefinition();
3329 if (D->isThisDeclarationADefinition() && FoundDef)
3330 return Importer.MapImported(From: D, To: FoundDef);
3331 PrevDecl = FoundEnum->getMostRecentDecl();
3332 break;
3333 }
3334 ConflictingDecls.push_back(Elt: FoundDecl);
3335 }
3336 }
3337
3338 // In case of unnamed enums, we try to find an existing similar one, if none
3339 // was found, perform the import always.
3340 // Structural in-equivalence is not detected in this way here, but it may
3341 // be found when the parent decl is imported (if the enum is part of a
3342 // class). To make this totally exact a more difficult solution is needed.
3343 if (SearchName && !ConflictingDecls.empty()) {
3344 ExpectedName NameOrErr = Importer.HandleNameConflict(
3345 Name: SearchName, DC, IDNS, Decls: ConflictingDecls.data(),
3346 NumDecls: ConflictingDecls.size());
3347 if (NameOrErr)
3348 Name = NameOrErr.get();
3349 else
3350 return NameOrErr.takeError();
3351 }
3352 }
3353
3354 Error Err = Error::success();
3355 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
3356 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3357 auto ToIntegerType = importChecked(Err, From: D->getIntegerType());
3358 auto ToBraceRange = importChecked(Err, From: D->getBraceRange());
3359 if (Err)
3360 return std::move(Err);
3361
3362 // Create the enum declaration.
3363 EnumDecl *D2;
3364 if (GetImportedOrCreateDecl(
3365 ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToBeginLoc,
3366 args&: Loc, args: Name.getAsIdentifierInfo(), args&: PrevDecl, args: D->isScoped(),
3367 args: D->isScopedUsingClassTag(), args: D->isFixed()))
3368 return D2;
3369
3370 D2->setQualifierInfo(ToQualifierLoc);
3371 D2->setIntegerType(ToIntegerType);
3372 D2->setBraceRange(ToBraceRange);
3373 D2->setAccess(D->getAccess());
3374 D2->setLexicalDeclContext(LexicalDC);
3375 addDeclToContexts(FromD: D, ToD: D2);
3376
3377 if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
3378 TemplateSpecializationKind SK = MemberInfo->getTemplateSpecializationKind();
3379 EnumDecl *FromInst = D->getInstantiatedFromMemberEnum();
3380 if (Expected<EnumDecl *> ToInstOrErr = import(From: FromInst))
3381 D2->setInstantiationOfMemberEnum(ED: *ToInstOrErr, TSK: SK);
3382 else
3383 return ToInstOrErr.takeError();
3384 if (ExpectedSLoc POIOrErr = import(From: MemberInfo->getPointOfInstantiation()))
3385 D2->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3386 else
3387 return POIOrErr.takeError();
3388 }
3389
3390 // Import the definition
3391 if (D->isCompleteDefinition())
3392 if (Error Err = ImportDefinition(From: D, To: D2))
3393 return std::move(Err);
3394
3395 return D2;
3396}
3397
3398ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
3399 bool IsFriendTemplate = false;
3400 if (auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3401 IsFriendTemplate =
3402 DCXX->getDescribedClassTemplate() &&
3403 DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
3404 Decl::FOK_None;
3405 }
3406
3407 // Import the major distinguishing characteristics of this record.
3408 DeclContext *DC = nullptr, *LexicalDC = nullptr;
3409 DeclarationName Name;
3410 SourceLocation Loc;
3411 NamedDecl *ToD = nullptr;
3412 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3413 return std::move(Err);
3414 if (ToD)
3415 return ToD;
3416
3417 // Figure out what structure name we're looking for.
3418 unsigned IDNS = Decl::IDNS_Tag;
3419 DeclarationName SearchName = Name;
3420 if (!SearchName && D->getTypedefNameForAnonDecl()) {
3421 if (Error Err = importInto(
3422 To&: SearchName, From: D->getTypedefNameForAnonDecl()->getDeclName()))
3423 return std::move(Err);
3424 IDNS = Decl::IDNS_Ordinary;
3425 } else if (Importer.getToContext().getLangOpts().CPlusPlus)
3426 IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
3427
3428 bool IsDependentContext = DC != LexicalDC ? LexicalDC->isDependentContext()
3429 : DC->isDependentContext();
3430 bool DependentFriend = IsFriendTemplate && IsDependentContext;
3431
3432 // We may already have a record of the same name; try to find and match it.
3433 RecordDecl *PrevDecl = nullptr;
3434 if (!DependentFriend && !DC->isFunctionOrMethod() && !D->isLambda()) {
3435 SmallVector<NamedDecl *, 4> ConflictingDecls;
3436 auto FoundDecls =
3437 Importer.findDeclsInToCtx(DC, Name: SearchName);
3438 if (!FoundDecls.empty()) {
3439 // We're going to have to compare D against potentially conflicting Decls,
3440 // so complete it.
3441 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
3442 D->getASTContext().getExternalSource()->CompleteType(Tag: D);
3443 }
3444
3445 for (auto *FoundDecl : FoundDecls) {
3446 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3447 continue;
3448
3449 Decl *Found = FoundDecl;
3450 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Val: Found)) {
3451 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
3452 Found = Tag->getDecl();
3453 }
3454
3455 if (auto *FoundRecord = dyn_cast<RecordDecl>(Val: Found)) {
3456 // Do not emit false positive diagnostic in case of unnamed
3457 // struct/union and in case of anonymous structs. Would be false
3458 // because there may be several anonymous/unnamed structs in a class.
3459 // E.g. these are both valid:
3460 // struct A { // unnamed structs
3461 // struct { struct A *next; } entry0;
3462 // struct { struct A *next; } entry1;
3463 // };
3464 // struct X { struct { int a; }; struct { int b; }; }; // anon structs
3465 if (!SearchName)
3466 if (!IsStructuralMatch(From: D, To: FoundRecord, Complain: false))
3467 continue;
3468
3469 if (!hasSameVisibilityContextAndLinkage(Found: FoundRecord, From: D))
3470 continue;
3471
3472 if (IsStructuralMatch(From: D, To: FoundRecord)) {
3473 RecordDecl *FoundDef = FoundRecord->getDefinition();
3474 if (D->isThisDeclarationADefinition() && FoundDef) {
3475 // FIXME: Structural equivalence check should check for same
3476 // user-defined methods.
3477 Importer.MapImported(From: D, To: FoundDef);
3478 if (const auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3479 auto *FoundCXX = dyn_cast<CXXRecordDecl>(Val: FoundDef);
3480 assert(FoundCXX && "Record type mismatch");
3481
3482 if (!Importer.isMinimalImport())
3483 // FoundDef may not have every implicit method that D has
3484 // because implicit methods are created only if they are used.
3485 if (Error Err = ImportImplicitMethods(From: DCXX, To: FoundCXX))
3486 return std::move(Err);
3487 }
3488 // FIXME: We can return FoundDef here.
3489 }
3490 PrevDecl = FoundRecord->getMostRecentDecl();
3491 break;
3492 }
3493 ConflictingDecls.push_back(Elt: FoundDecl);
3494 } // kind is RecordDecl
3495 } // for
3496
3497 if (!ConflictingDecls.empty() && SearchName) {
3498 ExpectedName NameOrErr = Importer.HandleNameConflict(
3499 Name: SearchName, DC, IDNS, Decls: ConflictingDecls.data(),
3500 NumDecls: ConflictingDecls.size());
3501 if (NameOrErr)
3502 Name = NameOrErr.get();
3503 else
3504 return NameOrErr.takeError();
3505 }
3506 }
3507
3508 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
3509 if (!BeginLocOrErr)
3510 return BeginLocOrErr.takeError();
3511
3512 // Create the record declaration.
3513 RecordDecl *D2 = nullptr;
3514 CXXRecordDecl *D2CXX = nullptr;
3515 if (auto *DCXX = dyn_cast<CXXRecordDecl>(Val: D)) {
3516 if (DCXX->isLambda()) {
3517 auto TInfoOrErr = import(From: DCXX->getLambdaTypeInfo());
3518 if (!TInfoOrErr)
3519 return TInfoOrErr.takeError();
3520 if (GetImportedOrCreateSpecialDecl(
3521 ToD&: D2CXX, CreateFun: CXXRecordDecl::CreateLambda, FromD: D, args&: Importer.getToContext(),
3522 args&: DC, args&: *TInfoOrErr, args&: Loc, args: DCXX->getLambdaDependencyKind(),
3523 args: DCXX->isGenericLambda(), args: DCXX->getLambdaCaptureDefault()))
3524 return D2CXX;
3525 Decl *ContextDecl = DCXX->getLambdaContextDecl();
3526 ExpectedDecl CDeclOrErr = import(From: ContextDecl);
3527 if (!CDeclOrErr)
3528 return CDeclOrErr.takeError();
3529 if (ContextDecl != nullptr) {
3530 D2CXX->setLambdaContextDecl(*CDeclOrErr);
3531 }
3532 D2CXX->setLambdaNumbering(DCXX->getLambdaNumbering());
3533 } else {
3534 if (GetImportedOrCreateDecl(ToD&: D2CXX, FromD: D, args&: Importer.getToContext(),
3535 args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr, args&: Loc,
3536 args: Name.getAsIdentifierInfo(),
3537 args: cast_or_null<CXXRecordDecl>(Val: PrevDecl)))
3538 return D2CXX;
3539 }
3540
3541 D2 = D2CXX;
3542 D2->setAccess(D->getAccess());
3543 D2->setLexicalDeclContext(LexicalDC);
3544 addDeclToContexts(FromD: D, ToD: D2);
3545
3546 if (ClassTemplateDecl *FromDescribed =
3547 DCXX->getDescribedClassTemplate()) {
3548 ClassTemplateDecl *ToDescribed;
3549 if (Error Err = importInto(To&: ToDescribed, From: FromDescribed))
3550 return std::move(Err);
3551 D2CXX->setDescribedClassTemplate(ToDescribed);
3552 } else if (MemberSpecializationInfo *MemberInfo =
3553 DCXX->getMemberSpecializationInfo()) {
3554 TemplateSpecializationKind SK =
3555 MemberInfo->getTemplateSpecializationKind();
3556 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
3557
3558 if (Expected<CXXRecordDecl *> ToInstOrErr = import(From: FromInst))
3559 D2CXX->setInstantiationOfMemberClass(RD: *ToInstOrErr, TSK: SK);
3560 else
3561 return ToInstOrErr.takeError();
3562
3563 if (ExpectedSLoc POIOrErr =
3564 import(From: MemberInfo->getPointOfInstantiation()))
3565 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
3566 *POIOrErr);
3567 else
3568 return POIOrErr.takeError();
3569 }
3570
3571 } else {
3572 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(),
3573 args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr, args&: Loc,
3574 args: Name.getAsIdentifierInfo(), args&: PrevDecl))
3575 return D2;
3576 D2->setLexicalDeclContext(LexicalDC);
3577 addDeclToContexts(FromD: D, ToD: D2);
3578 }
3579
3580 if (auto BraceRangeOrErr = import(From: D->getBraceRange()))
3581 D2->setBraceRange(*BraceRangeOrErr);
3582 else
3583 return BraceRangeOrErr.takeError();
3584 if (auto QualifierLocOrErr = import(From: D->getQualifierLoc()))
3585 D2->setQualifierInfo(*QualifierLocOrErr);
3586 else
3587 return QualifierLocOrErr.takeError();
3588
3589 if (D->isAnonymousStructOrUnion())
3590 D2->setAnonymousStructOrUnion(true);
3591
3592 if (D->isCompleteDefinition())
3593 if (Error Err = ImportDefinition(From: D, To: D2, Kind: IDK_Default))
3594 return std::move(Err);
3595
3596 return D2;
3597}
3598
3599ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
3600 // Import the major distinguishing characteristics of this enumerator.
3601 DeclContext *DC, *LexicalDC;
3602 DeclarationName Name;
3603 SourceLocation Loc;
3604 NamedDecl *ToD;
3605 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3606 return std::move(Err);
3607 if (ToD)
3608 return ToD;
3609
3610 // Determine whether there are any other declarations with the same name and
3611 // in the same context.
3612 if (!LexicalDC->isFunctionOrMethod()) {
3613 SmallVector<NamedDecl *, 4> ConflictingDecls;
3614 unsigned IDNS = Decl::IDNS_Ordinary;
3615 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3616 for (auto *FoundDecl : FoundDecls) {
3617 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3618 continue;
3619
3620 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(Val: FoundDecl)) {
3621 if (IsStructuralMatch(From: D, To: FoundEnumConstant))
3622 return Importer.MapImported(From: D, To: FoundEnumConstant);
3623 ConflictingDecls.push_back(Elt: FoundDecl);
3624 }
3625 }
3626
3627 if (!ConflictingDecls.empty()) {
3628 ExpectedName NameOrErr = Importer.HandleNameConflict(
3629 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3630 if (NameOrErr)
3631 Name = NameOrErr.get();
3632 else
3633 return NameOrErr.takeError();
3634 }
3635 }
3636
3637 ExpectedType TypeOrErr = import(From: D->getType());
3638 if (!TypeOrErr)
3639 return TypeOrErr.takeError();
3640
3641 ExpectedExpr InitOrErr = import(From: D->getInitExpr());
3642 if (!InitOrErr)
3643 return InitOrErr.takeError();
3644
3645 EnumConstantDecl *ToEnumerator;
3646 if (GetImportedOrCreateDecl(
3647 ToD&: ToEnumerator, FromD: D, args&: Importer.getToContext(), args: cast<EnumDecl>(Val: DC), args&: Loc,
3648 args: Name.getAsIdentifierInfo(), args&: *TypeOrErr, args&: *InitOrErr, args: D->getInitVal()))
3649 return ToEnumerator;
3650
3651 ToEnumerator->setAccess(D->getAccess());
3652 ToEnumerator->setLexicalDeclContext(LexicalDC);
3653 LexicalDC->addDeclInternal(D: ToEnumerator);
3654 return ToEnumerator;
3655}
3656
3657template <typename DeclTy>
3658Error ASTNodeImporter::ImportTemplateParameterLists(const DeclTy *FromD,
3659 DeclTy *ToD) {
3660 ArrayRef<TemplateParameterList *> FromTPLs =
3661 FromD->getTemplateParameterLists();
3662 if (FromTPLs.empty())
3663 return Error::success();
3664 SmallVector<TemplateParameterList *, 2> ToTPLists(FromTPLs.size());
3665 for (unsigned int I = 0; I < FromTPLs.size(); ++I)
3666 if (Expected<TemplateParameterList *> ToTPListOrErr = import(From: FromTPLs[I]))
3667 ToTPLists[I] = *ToTPListOrErr;
3668 else
3669 return ToTPListOrErr.takeError();
3670 ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3671 return Error::success();
3672}
3673
3674Error ASTNodeImporter::ImportTemplateInformation(
3675 FunctionDecl *FromFD, FunctionDecl *ToFD) {
3676 switch (FromFD->getTemplatedKind()) {
3677 case FunctionDecl::TK_NonTemplate:
3678 case FunctionDecl::TK_FunctionTemplate:
3679 return Error::success();
3680
3681 case FunctionDecl::TK_DependentNonTemplate:
3682 if (Expected<FunctionDecl *> InstFDOrErr =
3683 import(From: FromFD->getInstantiatedFromDecl()))
3684 ToFD->setInstantiatedFromDecl(*InstFDOrErr);
3685 return Error::success();
3686 case FunctionDecl::TK_MemberSpecialization: {
3687 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3688
3689 if (Expected<FunctionDecl *> InstFDOrErr =
3690 import(From: FromFD->getInstantiatedFromMemberFunction()))
3691 ToFD->setInstantiationOfMemberFunction(FD: *InstFDOrErr, TSK);
3692 else
3693 return InstFDOrErr.takeError();
3694
3695 if (ExpectedSLoc POIOrErr = import(
3696 From: FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3697 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3698 else
3699 return POIOrErr.takeError();
3700
3701 return Error::success();
3702 }
3703
3704 case FunctionDecl::TK_FunctionTemplateSpecialization: {
3705 auto FunctionAndArgsOrErr =
3706 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3707 if (!FunctionAndArgsOrErr)
3708 return FunctionAndArgsOrErr.takeError();
3709
3710 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
3711 Context&: Importer.getToContext(), Args: std::get<1>(t&: *FunctionAndArgsOrErr));
3712
3713 auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3714 TemplateArgumentListInfo ToTAInfo;
3715 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3716 if (FromTAArgsAsWritten)
3717 if (Error Err = ImportTemplateArgumentListInfo(
3718 From: *FromTAArgsAsWritten, Result&: ToTAInfo))
3719 return Err;
3720
3721 ExpectedSLoc POIOrErr = import(From: FTSInfo->getPointOfInstantiation());
3722 if (!POIOrErr)
3723 return POIOrErr.takeError();
3724
3725 if (Error Err = ImportTemplateParameterLists(FromD: FromFD, ToD: ToFD))
3726 return Err;
3727
3728 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3729 ToFD->setFunctionTemplateSpecialization(
3730 Template: std::get<0>(t&: *FunctionAndArgsOrErr), TemplateArgs: ToTAList, /* InsertPos= */ nullptr,
3731 TSK, TemplateArgsAsWritten: FromTAArgsAsWritten ? &ToTAInfo : nullptr, PointOfInstantiation: *POIOrErr);
3732 return Error::success();
3733 }
3734
3735 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
3736 auto *FromInfo = FromFD->getDependentSpecializationInfo();
3737 UnresolvedSet<8> Candidates;
3738 for (FunctionTemplateDecl *FTD : FromInfo->getCandidates()) {
3739 if (Expected<FunctionTemplateDecl *> ToFTDOrErr = import(From: FTD))
3740 Candidates.addDecl(D: *ToFTDOrErr);
3741 else
3742 return ToFTDOrErr.takeError();
3743 }
3744
3745 // Import TemplateArgumentListInfo.
3746 TemplateArgumentListInfo ToTAInfo;
3747 const auto *FromTAArgsAsWritten = FromInfo->TemplateArgumentsAsWritten;
3748 if (FromTAArgsAsWritten)
3749 if (Error Err =
3750 ImportTemplateArgumentListInfo(From: *FromTAArgsAsWritten, Result&: ToTAInfo))
3751 return Err;
3752
3753 ToFD->setDependentTemplateSpecialization(
3754 Context&: Importer.getToContext(), Templates: Candidates,
3755 TemplateArgs: FromTAArgsAsWritten ? &ToTAInfo : nullptr);
3756 return Error::success();
3757 }
3758 }
3759 llvm_unreachable("All cases should be covered!");
3760}
3761
3762Expected<FunctionDecl *>
3763ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
3764 auto FunctionAndArgsOrErr =
3765 ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3766 if (!FunctionAndArgsOrErr)
3767 return FunctionAndArgsOrErr.takeError();
3768
3769 FunctionTemplateDecl *Template;
3770 TemplateArgsTy ToTemplArgs;
3771 std::tie(args&: Template, args&: ToTemplArgs) = *FunctionAndArgsOrErr;
3772 void *InsertPos = nullptr;
3773 auto *FoundSpec = Template->findSpecialization(Args: ToTemplArgs, InsertPos);
3774 return FoundSpec;
3775}
3776
3777Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
3778 FunctionDecl *ToFD) {
3779 if (Stmt *FromBody = FromFD->getBody()) {
3780 if (ExpectedStmt ToBodyOrErr = import(From: FromBody))
3781 ToFD->setBody(*ToBodyOrErr);
3782 else
3783 return ToBodyOrErr.takeError();
3784 }
3785 return Error::success();
3786}
3787
3788ExplicitSpecifier
3789ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
3790 Expr *ExplicitExpr = ESpec.getExpr();
3791 if (ExplicitExpr)
3792 ExplicitExpr = importChecked(Err, From: ESpec.getExpr());
3793 return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3794}
3795
3796ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3797
3798 SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
3799 auto RedeclIt = Redecls.begin();
3800 // Import the first part of the decl chain. I.e. import all previous
3801 // declarations starting from the canonical decl.
3802 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3803 ExpectedDecl ToRedeclOrErr = import(From: *RedeclIt);
3804 if (!ToRedeclOrErr)
3805 return ToRedeclOrErr.takeError();
3806 }
3807 assert(*RedeclIt == D);
3808
3809 // Import the major distinguishing characteristics of this function.
3810 DeclContext *DC, *LexicalDC;
3811 DeclarationName Name;
3812 SourceLocation Loc;
3813 NamedDecl *ToD;
3814 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3815 return std::move(Err);
3816 if (ToD)
3817 return ToD;
3818
3819 FunctionDecl *FoundByLookup = nullptr;
3820 FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3821
3822 // If this is a function template specialization, then try to find the same
3823 // existing specialization in the "to" context. The lookup below will not
3824 // find any specialization, but would find the primary template; thus, we
3825 // have to skip normal lookup in case of specializations.
3826 // FIXME handle member function templates (TK_MemberSpecialization) similarly?
3827 if (D->getTemplatedKind() ==
3828 FunctionDecl::TK_FunctionTemplateSpecialization) {
3829 auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(FromFD: D);
3830 if (!FoundFunctionOrErr)
3831 return FoundFunctionOrErr.takeError();
3832 if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3833 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3834 return Def;
3835 FoundByLookup = FoundFunction;
3836 }
3837 }
3838 // Try to find a function in our own ("to") context with the same name, same
3839 // type, and in the same context as the function we're importing.
3840 else if (!LexicalDC->isFunctionOrMethod()) {
3841 SmallVector<NamedDecl *, 4> ConflictingDecls;
3842 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
3843 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3844 for (auto *FoundDecl : FoundDecls) {
3845 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
3846 continue;
3847
3848 if (auto *FoundFunction = dyn_cast<FunctionDecl>(Val: FoundDecl)) {
3849 if (!hasSameVisibilityContextAndLinkage(Found: FoundFunction, From: D))
3850 continue;
3851
3852 if (IsStructuralMatch(From: D, To: FoundFunction)) {
3853 if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3854 return Def;
3855 FoundByLookup = FoundFunction;
3856 break;
3857 }
3858 // FIXME: Check for overloading more carefully, e.g., by boosting
3859 // Sema::IsOverload out to the AST library.
3860
3861 // Function overloading is okay in C++.
3862 if (Importer.getToContext().getLangOpts().CPlusPlus)
3863 continue;
3864
3865 // Complain about inconsistent function types.
3866 Importer.ToDiag(Loc, DiagID: diag::warn_odr_function_type_inconsistent)
3867 << Name << D->getType() << FoundFunction->getType();
3868 Importer.ToDiag(Loc: FoundFunction->getLocation(), DiagID: diag::note_odr_value_here)
3869 << FoundFunction->getType();
3870 ConflictingDecls.push_back(Elt: FoundDecl);
3871 }
3872 }
3873
3874 if (!ConflictingDecls.empty()) {
3875 ExpectedName NameOrErr = Importer.HandleNameConflict(
3876 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
3877 if (NameOrErr)
3878 Name = NameOrErr.get();
3879 else
3880 return NameOrErr.takeError();
3881 }
3882 }
3883
3884 // We do not allow more than one in-class declaration of a function. This is
3885 // because AST clients like VTableBuilder asserts on this. VTableBuilder
3886 // assumes there is only one in-class declaration. Building a redecl
3887 // chain would result in more than one in-class declaration for
3888 // overrides (even if they are part of the same redecl chain inside the
3889 // derived class.)
3890 if (FoundByLookup) {
3891 if (isa<CXXMethodDecl>(Val: FoundByLookup)) {
3892 if (D->getLexicalDeclContext() == D->getDeclContext()) {
3893 if (!D->doesThisDeclarationHaveABody()) {
3894 if (FunctionTemplateDecl *DescribedD =
3895 D->getDescribedFunctionTemplate()) {
3896 // Handle a "templated" function together with its described
3897 // template. This avoids need for a similar check at import of the
3898 // described template.
3899 assert(FoundByLookup->getDescribedFunctionTemplate() &&
3900 "Templated function mapped to non-templated?");
3901 Importer.MapImported(From: DescribedD,
3902 To: FoundByLookup->getDescribedFunctionTemplate());
3903 }
3904 return Importer.MapImported(From: D, To: FoundByLookup);
3905 } else {
3906 // Let's continue and build up the redecl chain in this case.
3907 // FIXME Merge the functions into one decl.
3908 }
3909 }
3910 }
3911 }
3912
3913 DeclarationNameInfo NameInfo(Name, Loc);
3914 // Import additional name location/type info.
3915 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
3916 return std::move(Err);
3917
3918 QualType FromTy = D->getType();
3919 TypeSourceInfo *FromTSI = D->getTypeSourceInfo();
3920 // Set to true if we do not import the type of the function as is. There are
3921 // cases when the original type would result in an infinite recursion during
3922 // the import. To avoid an infinite recursion when importing, we create the
3923 // FunctionDecl with a simplified function type and update it only after the
3924 // relevant AST nodes are already imported.
3925 // The type is related to TypeSourceInfo (it references the type), so we must
3926 // do the same with TypeSourceInfo.
3927 bool UsedDifferentProtoType = false;
3928 if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3929 QualType FromReturnTy = FromFPT->getReturnType();
3930 // Functions with auto return type may define a struct inside their body
3931 // and the return type could refer to that struct.
3932 // E.g.: auto foo() { struct X{}; return X(); }
3933 // There are many more cases when types inside the function declaration
3934 // can appear in the return type, like types declared as typenames from
3935 // template params.
3936 // All such cases are tracked in FindFunctionDeclImportCycle.
3937 if (Importer.FindFunctionDeclImportCycle.isCycle(D)) {
3938 FromReturnTy = Importer.getFromContext().VoidTy;
3939 UsedDifferentProtoType = true;
3940 }
3941 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3942 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3943 // FunctionDecl that we are importing the FunctionProtoType for.
3944 // To avoid an infinite recursion when importing, create the FunctionDecl
3945 // with a simplified function type.
3946 if (FromEPI.ExceptionSpec.SourceDecl ||
3947 FromEPI.ExceptionSpec.SourceTemplate ||
3948 FromEPI.ExceptionSpec.NoexceptExpr) {
3949 FunctionProtoType::ExtProtoInfo DefaultEPI;
3950 FromEPI = DefaultEPI;
3951 UsedDifferentProtoType = true;
3952 }
3953 FromTy = Importer.getFromContext().getFunctionType(
3954 ResultTy: FromReturnTy, Args: FromFPT->getParamTypes(), EPI: FromEPI);
3955 FromTSI = Importer.getFromContext().getTrivialTypeSourceInfo(
3956 T: FromTy, Loc: D->getBeginLoc());
3957 }
3958
3959 Error Err = Error::success();
3960 auto ScopedReturnTypeDeclCycleDetector =
3961 Importer.FindFunctionDeclImportCycle.makeScopedCycleDetection(D);
3962 auto T = importChecked(Err, From: FromTy);
3963 auto TInfo = importChecked(Err, From: FromTSI);
3964 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
3965 auto ToEndLoc = importChecked(Err, From: D->getEndLoc());
3966 auto ToDefaultLoc = importChecked(Err, From: D->getDefaultLoc());
3967 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
3968 AssociatedConstraint TrailingRequiresClause = D->getTrailingRequiresClause();
3969 TrailingRequiresClause.ConstraintExpr =
3970 importChecked(Err, From: TrailingRequiresClause.ConstraintExpr);
3971 if (Err)
3972 return std::move(Err);
3973
3974 // Import the function parameters.
3975 SmallVector<ParmVarDecl *, 8> Parameters;
3976 for (auto *P : D->parameters()) {
3977 if (Expected<ParmVarDecl *> ToPOrErr = import(From: P))
3978 Parameters.push_back(Elt: *ToPOrErr);
3979 else
3980 return ToPOrErr.takeError();
3981 }
3982
3983 // Create the imported function.
3984 FunctionDecl *ToFunction = nullptr;
3985 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(Val: D)) {
3986 ExplicitSpecifier ESpec =
3987 importExplicitSpecifier(Err, ESpec: FromConstructor->getExplicitSpecifier());
3988 if (Err)
3989 return std::move(Err);
3990 auto ToInheritedConstructor = InheritedConstructor();
3991 if (FromConstructor->isInheritingConstructor()) {
3992 Expected<InheritedConstructor> ImportedInheritedCtor =
3993 import(From: FromConstructor->getInheritedConstructor());
3994 if (!ImportedInheritedCtor)
3995 return ImportedInheritedCtor.takeError();
3996 ToInheritedConstructor = *ImportedInheritedCtor;
3997 }
3998 if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3999 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4000 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args&: ESpec, args: D->UsesFPIntrin(),
4001 args: D->isInlineSpecified(), args: D->isImplicit(), args: D->getConstexprKind(),
4002 args&: ToInheritedConstructor, args&: TrailingRequiresClause))
4003 return ToFunction;
4004 } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(Val: D)) {
4005
4006 Error Err = Error::success();
4007 auto ToOperatorDelete = importChecked(
4008 Err, From: const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
4009 auto ToThisArg = importChecked(Err, From: FromDtor->getOperatorDeleteThisArg());
4010 if (Err)
4011 return std::move(Err);
4012
4013 if (GetImportedOrCreateDecl<CXXDestructorDecl>(
4014 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4015 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: D->UsesFPIntrin(),
4016 args: D->isInlineSpecified(), args: D->isImplicit(), args: D->getConstexprKind(),
4017 args&: TrailingRequiresClause))
4018 return ToFunction;
4019
4020 CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(Val: ToFunction);
4021
4022 ToDtor->setOperatorDelete(OD: ToOperatorDelete, ThisArg: ToThisArg);
4023 } else if (CXXConversionDecl *FromConversion =
4024 dyn_cast<CXXConversionDecl>(Val: D)) {
4025 ExplicitSpecifier ESpec =
4026 importExplicitSpecifier(Err, ESpec: FromConversion->getExplicitSpecifier());
4027 if (Err)
4028 return std::move(Err);
4029 if (GetImportedOrCreateDecl<CXXConversionDecl>(
4030 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4031 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: D->UsesFPIntrin(),
4032 args: D->isInlineSpecified(), args&: ESpec, args: D->getConstexprKind(),
4033 args: SourceLocation(), args&: TrailingRequiresClause))
4034 return ToFunction;
4035 } else if (auto *Method = dyn_cast<CXXMethodDecl>(Val: D)) {
4036 if (GetImportedOrCreateDecl<CXXMethodDecl>(
4037 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args: cast<CXXRecordDecl>(Val: DC),
4038 args&: ToInnerLocStart, args&: NameInfo, args&: T, args&: TInfo, args: Method->getStorageClass(),
4039 args: Method->UsesFPIntrin(), args: Method->isInlineSpecified(),
4040 args: D->getConstexprKind(), args: SourceLocation(), args&: TrailingRequiresClause))
4041 return ToFunction;
4042 } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(Val: D)) {
4043 ExplicitSpecifier ESpec =
4044 importExplicitSpecifier(Err, ESpec: Guide->getExplicitSpecifier());
4045 CXXConstructorDecl *Ctor =
4046 importChecked(Err, From: Guide->getCorrespondingConstructor());
4047 const CXXDeductionGuideDecl *SourceDG =
4048 importChecked(Err, From: Guide->getSourceDeductionGuide());
4049 if (Err)
4050 return std::move(Err);
4051 if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
4052 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart, args&: ESpec,
4053 args&: NameInfo, args&: T, args&: TInfo, args&: ToEndLoc, args&: Ctor,
4054 args: Guide->getDeductionCandidateKind(), args&: TrailingRequiresClause,
4055 args&: SourceDG, args: Guide->getSourceDeductionGuideKind()))
4056 return ToFunction;
4057 } else {
4058 if (GetImportedOrCreateDecl(
4059 ToD&: ToFunction, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart,
4060 args&: NameInfo, args&: T, args&: TInfo, args: D->getStorageClass(), args: D->UsesFPIntrin(),
4061 args: D->isInlineSpecified(), args: D->hasWrittenPrototype(),
4062 args: D->getConstexprKind(), args&: TrailingRequiresClause))
4063 return ToFunction;
4064 }
4065
4066 // Connect the redecl chain.
4067 if (FoundByLookup) {
4068 auto *Recent = const_cast<FunctionDecl *>(
4069 FoundByLookup->getMostRecentDecl());
4070 ToFunction->setPreviousDecl(Recent);
4071 // FIXME Probably we should merge exception specifications. E.g. In the
4072 // "To" context the existing function may have exception specification with
4073 // noexcept-unevaluated, while the newly imported function may have an
4074 // evaluated noexcept. A call to adjustExceptionSpec() on the imported
4075 // decl and its redeclarations may be required.
4076 }
4077
4078 // We will import DefaultedOrDeletedInfo later.
4079
4080 ToFunction->setQualifierInfo(ToQualifierLoc);
4081 ToFunction->setAccess(D->getAccess());
4082 ToFunction->setLexicalDeclContext(LexicalDC);
4083 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
4084 ToFunction->setTrivial(D->isTrivial());
4085 ToFunction->setIsPureVirtual(D->isPureVirtual());
4086 ToFunction->setDefaulted(D->isDefaulted());
4087 ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
4088 ToFunction->setDeletedAsWritten(D: D->isDeletedAsWritten());
4089 ToFunction->setFriendConstraintRefersToEnclosingTemplate(
4090 D->FriendConstraintRefersToEnclosingTemplate());
4091 ToFunction->setIsDestroyingOperatorDelete(D->isDestroyingOperatorDelete());
4092 ToFunction->setIsTypeAwareOperatorNewOrDelete(
4093 D->isTypeAwareOperatorNewOrDelete());
4094 ToFunction->setRangeEnd(ToEndLoc);
4095 ToFunction->setDefaultLoc(ToDefaultLoc);
4096
4097 if (auto *Info = D->getDefaultedOrDeletedInfo()) {
4098 StringLiteral *Msg = nullptr;
4099 if (StringLiteral *M = Info->getDeletedMessage()) {
4100 auto Imported = import(From: M);
4101 if (!Imported)
4102 return Imported.takeError();
4103 Msg = *Imported;
4104 }
4105
4106 SmallVector<DeclAccessPair, 4> Lookups;
4107 for (DeclAccessPair P : Info->getUnqualifiedLookups()) {
4108 auto Imported = import(From: P.getDecl());
4109 if (!Imported)
4110 return Imported.takeError();
4111 Lookups.push_back(
4112 Elt: DeclAccessPair::make(D: cast<NamedDecl>(Val: *Imported), AS: P.getAccess()));
4113 }
4114
4115 ToFunction->setDefaultedOrDeletedInfo(
4116 FunctionDecl::DefaultedOrDeletedFunctionInfo::Create(
4117 Context&: Importer.getToContext(), Lookups, FPFeatures: Info->getFPFeatures(), DeletedMessage: Msg));
4118 }
4119
4120 // Set the parameters.
4121 for (auto *Param : Parameters) {
4122 Param->setOwningFunction(ToFunction);
4123 ToFunction->addDeclInternal(D: Param);
4124 if (ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable())
4125 LT->update(ND: Param, OldDC: Importer.getToContext().getTranslationUnitDecl());
4126 }
4127 ToFunction->setParams(Parameters);
4128
4129 // We need to complete creation of FunctionProtoTypeLoc manually with setting
4130 // params it refers to.
4131 if (TInfo) {
4132 if (auto ProtoLoc =
4133 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
4134 for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
4135 ProtoLoc.setParam(i: I, VD: Parameters[I]);
4136 }
4137 }
4138
4139 // Import the describing template function, if any.
4140 if (FromFT) {
4141 auto ToFTOrErr = import(From: FromFT);
4142 if (!ToFTOrErr)
4143 return ToFTOrErr.takeError();
4144 }
4145
4146 // Import Ctor initializers.
4147 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(Val: D)) {
4148 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
4149 SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
4150 // Import first, then allocate memory and copy if there was no error.
4151 if (Error Err = ImportContainerChecked(
4152 InContainer: FromConstructor->inits(), OutContainer&: CtorInitializers))
4153 return std::move(Err);
4154 auto **Memory =
4155 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
4156 llvm::copy(Range&: CtorInitializers, Out: Memory);
4157 auto *ToCtor = cast<CXXConstructorDecl>(Val: ToFunction);
4158 ToCtor->setCtorInitializers(Memory);
4159 ToCtor->setNumCtorInitializers(NumInitializers);
4160 }
4161 }
4162
4163 // If it is a template, import all related things.
4164 if (Error Err = ImportTemplateInformation(FromFD: D, ToFD: ToFunction))
4165 return std::move(Err);
4166
4167 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(Val: D))
4168 if (Error Err = ImportOverriddenMethods(ToMethod: cast<CXXMethodDecl>(Val: ToFunction),
4169 FromMethod: FromCXXMethod))
4170 return std::move(Err);
4171
4172 if (D->doesThisDeclarationHaveABody()) {
4173 Error Err = ImportFunctionDeclBody(FromFD: D, ToFD: ToFunction);
4174
4175 if (Err)
4176 return std::move(Err);
4177 }
4178
4179 // Import and set the original type in case we used another type.
4180 if (UsedDifferentProtoType) {
4181 if (ExpectedType TyOrErr = import(From: D->getType()))
4182 ToFunction->setType(*TyOrErr);
4183 else
4184 return TyOrErr.takeError();
4185 if (Expected<TypeSourceInfo *> TSIOrErr = import(From: D->getTypeSourceInfo()))
4186 ToFunction->setTypeSourceInfo(*TSIOrErr);
4187 else
4188 return TSIOrErr.takeError();
4189 }
4190
4191 // FIXME: Other bits to merge?
4192
4193 addDeclToContexts(FromD: D, ToD: ToFunction);
4194
4195 // Import the rest of the chain. I.e. import all subsequent declarations.
4196 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4197 ExpectedDecl ToRedeclOrErr = import(From: *RedeclIt);
4198 if (!ToRedeclOrErr)
4199 return ToRedeclOrErr.takeError();
4200 }
4201
4202 return ToFunction;
4203}
4204
4205ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
4206 return VisitFunctionDecl(D);
4207}
4208
4209ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
4210 return VisitCXXMethodDecl(D);
4211}
4212
4213ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
4214 return VisitCXXMethodDecl(D);
4215}
4216
4217ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
4218 return VisitCXXMethodDecl(D);
4219}
4220
4221ExpectedDecl
4222ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
4223 return VisitFunctionDecl(D);
4224}
4225
4226ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
4227 // Import the major distinguishing characteristics of a variable.
4228 DeclContext *DC, *LexicalDC;
4229 DeclarationName Name;
4230 SourceLocation Loc;
4231 NamedDecl *ToD;
4232 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4233 return std::move(Err);
4234 if (ToD)
4235 return ToD;
4236
4237 // Determine whether we've already imported this field.
4238 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4239 for (auto *FoundDecl : FoundDecls) {
4240 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(Val: FoundDecl)) {
4241 // For anonymous fields, match up by index.
4242 if (!Name &&
4243 ASTImporter::getFieldIndex(F: D) !=
4244 ASTImporter::getFieldIndex(F: FoundField))
4245 continue;
4246
4247 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4248 To: FoundField->getType())) {
4249 Importer.MapImported(From: D, To: FoundField);
4250 // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
4251 // initializer of a FieldDecl might not had been instantiated in the
4252 // "To" context. However, the "From" context might instantiated that,
4253 // thus we have to merge that.
4254 // Note: `hasInClassInitializer()` is not the same as non-null
4255 // `getInClassInitializer()` value.
4256 if (Expr *FromInitializer = D->getInClassInitializer()) {
4257 if (ExpectedExpr ToInitializerOrErr = import(From: FromInitializer)) {
4258 // Import of the FromInitializer may result in the setting of
4259 // InClassInitializer. If not, set it here.
4260 assert(FoundField->hasInClassInitializer() &&
4261 "Field should have an in-class initializer if it has an "
4262 "expression for it.");
4263 if (!FoundField->getInClassInitializer())
4264 FoundField->setInClassInitializer(*ToInitializerOrErr);
4265 } else {
4266 return ToInitializerOrErr.takeError();
4267 }
4268 }
4269 return FoundField;
4270 }
4271
4272 // FIXME: Why is this case not handled with calling HandleNameConflict?
4273 Importer.ToDiag(Loc, DiagID: diag::warn_odr_field_type_inconsistent)
4274 << Name << D->getType() << FoundField->getType();
4275 Importer.ToDiag(Loc: FoundField->getLocation(), DiagID: diag::note_odr_value_here)
4276 << FoundField->getType();
4277
4278 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4279 }
4280 }
4281
4282 Error Err = Error::success();
4283 auto ToType = importChecked(Err, From: D->getType());
4284 auto ToTInfo = importChecked(Err, From: D->getTypeSourceInfo());
4285 auto ToBitWidth = importChecked(Err, From: D->getBitWidth());
4286 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4287 if (Err)
4288 return std::move(Err);
4289 const Type *ToCapturedVLAType = nullptr;
4290 if (Error Err = Importer.importInto(
4291 To&: ToCapturedVLAType, From: cast_or_null<Type>(Val: D->getCapturedVLAType())))
4292 return std::move(Err);
4293
4294 FieldDecl *ToField;
4295 if (GetImportedOrCreateDecl(ToD&: ToField, FromD: D, args&: Importer.getToContext(), args&: DC,
4296 args&: ToInnerLocStart, args&: Loc, args: Name.getAsIdentifierInfo(),
4297 args&: ToType, args&: ToTInfo, args&: ToBitWidth, args: D->isMutable(),
4298 args: D->getInClassInitStyle()))
4299 return ToField;
4300
4301 ToField->setAccess(D->getAccess());
4302 ToField->setLexicalDeclContext(LexicalDC);
4303 ToField->setImplicit(D->isImplicit());
4304 if (ToCapturedVLAType)
4305 ToField->setCapturedVLAType(cast<VariableArrayType>(Val: ToCapturedVLAType));
4306 LexicalDC->addDeclInternal(D: ToField);
4307 // Import initializer only after the field was created, it may have recursive
4308 // reference to the field.
4309 auto ToInitializer = importChecked(Err, From: D->getInClassInitializer());
4310 if (Err)
4311 return std::move(Err);
4312 if (ToInitializer) {
4313 auto *AlreadyImported = ToField->getInClassInitializer();
4314 if (AlreadyImported)
4315 assert(ToInitializer == AlreadyImported &&
4316 "Duplicate import of in-class initializer.");
4317 else
4318 ToField->setInClassInitializer(ToInitializer);
4319 }
4320
4321 return ToField;
4322}
4323
4324ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
4325 // Import the major distinguishing characteristics of a variable.
4326 DeclContext *DC, *LexicalDC;
4327 DeclarationName Name;
4328 SourceLocation Loc;
4329 NamedDecl *ToD;
4330 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4331 return std::move(Err);
4332 if (ToD)
4333 return ToD;
4334
4335 // Determine whether we've already imported this field.
4336 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4337 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
4338 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(Val: FoundDecls[I])) {
4339 // For anonymous indirect fields, match up by index.
4340 if (!Name &&
4341 ASTImporter::getFieldIndex(F: D) !=
4342 ASTImporter::getFieldIndex(F: FoundField))
4343 continue;
4344
4345 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4346 To: FoundField->getType(),
4347 Complain: !Name.isEmpty())) {
4348 Importer.MapImported(From: D, To: FoundField);
4349 return FoundField;
4350 }
4351
4352 // If there are more anonymous fields to check, continue.
4353 if (!Name && I < N-1)
4354 continue;
4355
4356 // FIXME: Why is this case not handled with calling HandleNameConflict?
4357 Importer.ToDiag(Loc, DiagID: diag::warn_odr_field_type_inconsistent)
4358 << Name << D->getType() << FoundField->getType();
4359 Importer.ToDiag(Loc: FoundField->getLocation(), DiagID: diag::note_odr_value_here)
4360 << FoundField->getType();
4361
4362 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4363 }
4364 }
4365
4366 // Import the type.
4367 auto TypeOrErr = import(From: D->getType());
4368 if (!TypeOrErr)
4369 return TypeOrErr.takeError();
4370
4371 auto **NamedChain =
4372 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
4373
4374 unsigned i = 0;
4375 for (auto *PI : D->chain())
4376 if (Expected<NamedDecl *> ToD = import(From: PI))
4377 NamedChain[i++] = *ToD;
4378 else
4379 return ToD.takeError();
4380
4381 MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
4382 IndirectFieldDecl *ToIndirectField;
4383 if (GetImportedOrCreateDecl(ToD&: ToIndirectField, FromD: D, args&: Importer.getToContext(), args&: DC,
4384 args&: Loc, args: Name.getAsIdentifierInfo(), args&: *TypeOrErr, args&: CH))
4385 // FIXME here we leak `NamedChain` which is allocated before
4386 return ToIndirectField;
4387
4388 ToIndirectField->setAccess(D->getAccess());
4389 ToIndirectField->setLexicalDeclContext(LexicalDC);
4390 LexicalDC->addDeclInternal(D: ToIndirectField);
4391 return ToIndirectField;
4392}
4393
4394/// Used as return type of getFriendCountAndPosition.
4395struct FriendCountAndPosition {
4396 /// Number of similar looking friends.
4397 unsigned int TotalCount;
4398 /// Index of the specific FriendDecl.
4399 unsigned int IndexOfDecl;
4400};
4401
4402static bool IsEquivalentFriend(ASTImporter &Importer, FriendDecl *FD1,
4403 FriendDecl *FD2) {
4404 if (FD1->getKind() != FD2->getKind())
4405 return false;
4406
4407 ASTImporter::NonEquivalentDeclSet NonEquivalentDecls;
4408 StructuralEquivalenceContext Ctx(
4409 Importer.getToContext().getLangOpts(), FD1->getASTContext(),
4410 FD2->getASTContext(), NonEquivalentDecls,
4411 StructuralEquivalenceKind::Default,
4412 /*StrictTypeSpelling=*/false, /*Complain=*/false);
4413 return Ctx.IsEquivalent(D1: FD1, D2: FD2);
4414}
4415
4416static FriendCountAndPosition getFriendCountAndPosition(ASTImporter &Importer,
4417 FriendDecl *FD) {
4418 unsigned int FriendCount = 0;
4419 UnsignedOrNone FriendPosition = std::nullopt;
4420 const auto *RD = cast<CXXRecordDecl>(Val: FD->getLexicalDeclContext());
4421
4422 for (FriendDecl *FoundFriend : RD->friends()) {
4423 if (FoundFriend == FD) {
4424 FriendPosition = FriendCount;
4425 ++FriendCount;
4426 } else if (IsEquivalentFriend(Importer, FD1: FD, FD2: FoundFriend)) {
4427 ++FriendCount;
4428 }
4429 }
4430
4431 assert(FriendPosition && "Friend decl not found in own parent.");
4432 return {.TotalCount: FriendCount, .IndexOfDecl: *FriendPosition};
4433}
4434
4435Expected<FriendDecl::FriendUnion>
4436ASTNodeImporter::importFriendUnion(FriendDecl *D) {
4437 if (NamedDecl *FriendD = D->getFriendDecl()) {
4438 NamedDecl *ToFriendD;
4439 if (Error Err = importInto(To&: ToFriendD, From: FriendD))
4440 return std::move(Err);
4441
4442 if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
4443 !FriendD->isInIdentifierNamespace(NS: Decl::IDNS_NonMemberOperator))
4444 ToFriendD->setObjectOfFriendDecl(false);
4445
4446 return ToFriendD;
4447 }
4448
4449 // The friend is a type, not a decl.
4450 auto TSIOrErr = import(From: D->getFriendType());
4451 if (TSIOrErr)
4452 return *TSIOrErr;
4453 return TSIOrErr.takeError();
4454}
4455
4456ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
4457 // Import the major distinguishing characteristics of a declaration.
4458 DeclContext *DC, *LexicalDC;
4459 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
4460 return std::move(Err);
4461
4462 // Determine whether we've already imported this decl.
4463 // FriendDecl is not a NamedDecl so we cannot use lookup.
4464 // We try to maintain order and count of redundant friend declarations.
4465 const auto *RD = cast<CXXRecordDecl>(Val: DC);
4466 SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
4467 for (FriendDecl *ImportedFriend : RD->friends())
4468 if (IsEquivalentFriend(Importer, FD1: D, FD2: ImportedFriend))
4469 ImportedEquivalentFriends.push_back(Elt: ImportedFriend);
4470
4471 FriendCountAndPosition CountAndPosition =
4472 getFriendCountAndPosition(Importer, FD: D);
4473
4474 assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
4475 "Class with non-matching friends is imported, ODR check wrong?");
4476 if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
4477 return Importer.MapImported(
4478 From: D, To: ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
4479
4480 // Not found. Create it.
4481 // The declarations will be put into order later by ImportDeclContext.
4482 auto ToFUOrErr = importFriendUnion(D);
4483 if (!ToFUOrErr)
4484 return ToFUOrErr.takeError();
4485 FriendDecl::FriendUnion ToFU = *ToFUOrErr;
4486
4487 auto LocationOrErr = import(From: D->getLocation());
4488 if (!LocationOrErr)
4489 return LocationOrErr.takeError();
4490 auto FriendLocOrErr = import(From: D->getFriendLoc());
4491 if (!FriendLocOrErr)
4492 return FriendLocOrErr.takeError();
4493 auto EllipsisLocOrErr = import(From: D->getEllipsisLoc());
4494 if (!EllipsisLocOrErr)
4495 return EllipsisLocOrErr.takeError();
4496
4497 FriendDecl *FrD;
4498 if (GetImportedOrCreateDecl(ToD&: FrD, FromD: D, args&: Importer.getToContext(), args&: DC,
4499 args&: *LocationOrErr, args&: ToFU, args&: *FriendLocOrErr,
4500 args&: *EllipsisLocOrErr))
4501 return FrD;
4502
4503 FrD->setAccess(D->getAccess());
4504 FrD->setLexicalDeclContext(LexicalDC);
4505 LexicalDC->addDeclInternal(D: FrD);
4506 return FrD;
4507}
4508
4509ExpectedDecl ASTNodeImporter::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
4510 DeclContext *DC, *LexicalDC;
4511 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
4512 return std::move(Err);
4513
4514 const auto *RD = cast<CXXRecordDecl>(Val: DC);
4515 SmallVector<FriendTemplateDecl *, 2> ImportedEquivalentFriends;
4516 for (FriendDecl *ImportedFriend : RD->friends()) {
4517 auto *ImportedFriendTemplate = dyn_cast<FriendTemplateDecl>(Val: ImportedFriend);
4518 if (ImportedFriendTemplate &&
4519 IsEquivalentFriend(Importer, FD1: D, FD2: ImportedFriendTemplate))
4520 ImportedEquivalentFriends.push_back(Elt: ImportedFriendTemplate);
4521 }
4522
4523 FriendCountAndPosition CountAndPosition =
4524 getFriendCountAndPosition(Importer, FD: D);
4525 assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
4526 "Class with non-matching friends is imported, ODR check wrong?");
4527
4528 if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
4529 return Importer.MapImported(
4530 From: D, To: ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
4531
4532 FriendTemplateDecl::FriendUnion ToFU;
4533 if (D->getFriendKind() !=
4534 FriendTemplateDecl::FriendTemplateEntityKind::Template) {
4535 auto ToFUOrErr = importFriendUnion(D);
4536 if (!ToFUOrErr)
4537 return ToFUOrErr.takeError();
4538 ToFU = *ToFUOrErr;
4539 }
4540
4541 TemplateName ToTemplate;
4542 const TemplateName FromTemplate = D->getFriendTemplateName();
4543 if (!FromTemplate.isNull()) {
4544 if (Error Err = importInto(To&: ToTemplate, From: FromTemplate))
4545 return std::move(Err);
4546 }
4547
4548 ArrayRef<TemplateParameterList *> FromTPLs = D->getTemplateParameterLists();
4549 SmallVector<TemplateParameterList *, 1> ToTPLs(FromTPLs.size());
4550 if (Error Err = ImportContainerChecked(InContainer: FromTPLs, OutContainer&: ToTPLs))
4551 return std::move(Err);
4552
4553 auto LocationOrErr = import(From: D->getLocation());
4554 if (!LocationOrErr)
4555 return LocationOrErr.takeError();
4556
4557 auto FriendLocOrErr = import(From: D->getFriendLoc());
4558 if (!FriendLocOrErr)
4559 return FriendLocOrErr.takeError();
4560
4561 auto EllipsisLocOrErr = import(From: D->getEllipsisLoc());
4562 if (!EllipsisLocOrErr)
4563 return EllipsisLocOrErr.takeError();
4564
4565 FriendTemplateDecl *FTD;
4566 if (GetImportedOrCreateDecl(ToD&: FTD, FromD: D, args&: Importer.getToContext(), args&: DC,
4567 args&: *LocationOrErr, args&: ToFU, args&: *FriendLocOrErr, args&: ToTPLs,
4568 args&: *EllipsisLocOrErr, args&: ToTemplate))
4569 return FTD;
4570
4571 FTD->setAccess(D->getAccess());
4572 FTD->setLexicalDeclContext(LexicalDC);
4573 LexicalDC->addDeclInternal(D: FTD);
4574 return FTD;
4575}
4576
4577ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
4578 // Import the major distinguishing characteristics of an ivar.
4579 DeclContext *DC, *LexicalDC;
4580 DeclarationName Name;
4581 SourceLocation Loc;
4582 NamedDecl *ToD;
4583 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4584 return std::move(Err);
4585 if (ToD)
4586 return ToD;
4587
4588 // Determine whether we've already imported this ivar
4589 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4590 for (auto *FoundDecl : FoundDecls) {
4591 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(Val: FoundDecl)) {
4592 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4593 To: FoundIvar->getType())) {
4594 Importer.MapImported(From: D, To: FoundIvar);
4595 return FoundIvar;
4596 }
4597
4598 Importer.ToDiag(Loc, DiagID: diag::warn_odr_ivar_type_inconsistent)
4599 << Name << D->getType() << FoundIvar->getType();
4600 Importer.ToDiag(Loc: FoundIvar->getLocation(), DiagID: diag::note_odr_value_here)
4601 << FoundIvar->getType();
4602
4603 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4604 }
4605 }
4606
4607 Error Err = Error::success();
4608 auto ToType = importChecked(Err, From: D->getType());
4609 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4610 auto ToBitWidth = importChecked(Err, From: D->getBitWidth());
4611 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4612 if (Err)
4613 return std::move(Err);
4614
4615 ObjCIvarDecl *ToIvar;
4616 if (GetImportedOrCreateDecl(
4617 ToD&: ToIvar, FromD: D, args&: Importer.getToContext(), args: cast<ObjCContainerDecl>(Val: DC),
4618 args&: ToInnerLocStart, args&: Loc, args: Name.getAsIdentifierInfo(),
4619 args&: ToType, args&: ToTypeSourceInfo,
4620 args: D->getAccessControl(),args&: ToBitWidth, args: D->getSynthesize()))
4621 return ToIvar;
4622
4623 ToIvar->setLexicalDeclContext(LexicalDC);
4624 LexicalDC->addDeclInternal(D: ToIvar);
4625 return ToIvar;
4626}
4627
4628ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
4629
4630 SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
4631 auto RedeclIt = Redecls.begin();
4632 // Import the first part of the decl chain. I.e. import all previous
4633 // declarations starting from the canonical decl.
4634 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
4635 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
4636 if (!RedeclOrErr)
4637 return RedeclOrErr.takeError();
4638 }
4639 assert(*RedeclIt == D);
4640
4641 // Import the major distinguishing characteristics of a variable.
4642 DeclContext *DC, *LexicalDC;
4643 DeclarationName Name;
4644 SourceLocation Loc;
4645 NamedDecl *ToD;
4646 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4647 return std::move(Err);
4648 if (ToD)
4649 return ToD;
4650
4651 // Try to find a variable in our own ("to") context with the same name and
4652 // in the same context as the variable we're importing.
4653 VarDecl *FoundByLookup = nullptr;
4654 if (D->isFileVarDecl()) {
4655 SmallVector<NamedDecl *, 4> ConflictingDecls;
4656 unsigned IDNS = Decl::IDNS_Ordinary;
4657 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4658 for (auto *FoundDecl : FoundDecls) {
4659 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
4660 continue;
4661
4662 if (auto *FoundVar = dyn_cast<VarDecl>(Val: FoundDecl)) {
4663 if (!hasSameVisibilityContextAndLinkage(Found: FoundVar, From: D))
4664 continue;
4665 if (Importer.IsStructurallyEquivalent(From: D->getType(),
4666 To: FoundVar->getType())) {
4667
4668 // The VarDecl in the "From" context has a definition, but in the
4669 // "To" context we already have a definition.
4670 VarDecl *FoundDef = FoundVar->getDefinition();
4671 if (D->isThisDeclarationADefinition() && FoundDef)
4672 // FIXME Check for ODR error if the two definitions have
4673 // different initializers?
4674 return Importer.MapImported(From: D, To: FoundDef);
4675
4676 // The VarDecl in the "From" context has an initializer, but in the
4677 // "To" context we already have an initializer.
4678 const VarDecl *FoundDInit = nullptr;
4679 if (D->getInit() && FoundVar->getAnyInitializer(D&: FoundDInit))
4680 // FIXME Diagnose ODR error if the two initializers are different?
4681 return Importer.MapImported(From: D, To: const_cast<VarDecl*>(FoundDInit));
4682
4683 FoundByLookup = FoundVar;
4684 break;
4685 }
4686
4687 const ArrayType *FoundArray
4688 = Importer.getToContext().getAsArrayType(T: FoundVar->getType());
4689 const ArrayType *TArray
4690 = Importer.getToContext().getAsArrayType(T: D->getType());
4691 if (FoundArray && TArray) {
4692 if (isa<IncompleteArrayType>(Val: FoundArray) &&
4693 isa<ConstantArrayType>(Val: TArray)) {
4694 // Import the type.
4695 if (auto TyOrErr = import(From: D->getType()))
4696 FoundVar->setType(*TyOrErr);
4697 else
4698 return TyOrErr.takeError();
4699
4700 FoundByLookup = FoundVar;
4701 break;
4702 } else if (isa<IncompleteArrayType>(Val: TArray) &&
4703 isa<ConstantArrayType>(Val: FoundArray)) {
4704 FoundByLookup = FoundVar;
4705 break;
4706 }
4707 }
4708
4709 Importer.ToDiag(Loc, DiagID: diag::warn_odr_variable_type_inconsistent)
4710 << Name << D->getType() << FoundVar->getType();
4711 Importer.ToDiag(Loc: FoundVar->getLocation(), DiagID: diag::note_odr_value_here)
4712 << FoundVar->getType();
4713 ConflictingDecls.push_back(Elt: FoundDecl);
4714 }
4715 }
4716
4717 if (!ConflictingDecls.empty()) {
4718 ExpectedName NameOrErr = Importer.HandleNameConflict(
4719 Name, DC, IDNS, Decls: ConflictingDecls.data(), NumDecls: ConflictingDecls.size());
4720 if (NameOrErr)
4721 Name = NameOrErr.get();
4722 else
4723 return NameOrErr.takeError();
4724 }
4725 }
4726
4727 Error Err = Error::success();
4728 auto ToType = importChecked(Err, From: D->getType());
4729 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4730 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4731 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
4732 if (Err)
4733 return std::move(Err);
4734
4735 VarDecl *ToVar;
4736 if (auto *FromDecomp = dyn_cast<DecompositionDecl>(Val: D)) {
4737 SmallVector<BindingDecl *> Bindings(FromDecomp->bindings().size());
4738 if (Error Err =
4739 ImportArrayChecked(InContainer: FromDecomp->bindings(), Obegin: Bindings.begin()))
4740 return std::move(Err);
4741 DecompositionDecl *ToDecomp;
4742 if (GetImportedOrCreateDecl(
4743 ToD&: ToDecomp, FromD: FromDecomp, args&: Importer.getToContext(), args&: DC, args&: ToInnerLocStart,
4744 args&: Loc, args: FromDecomp->getRSquareLoc(), args&: ToType, args&: ToTypeSourceInfo,
4745 args: D->getStorageClass(), args&: Bindings))
4746 return ToDecomp;
4747 ToVar = ToDecomp;
4748 } else {
4749 // Create the imported variable.
4750 if (GetImportedOrCreateDecl(ToD&: ToVar, FromD: D, args&: Importer.getToContext(), args&: DC,
4751 args&: ToInnerLocStart, args&: Loc,
4752 args: Name.getAsIdentifierInfo(), args&: ToType,
4753 args&: ToTypeSourceInfo, args: D->getStorageClass()))
4754 return ToVar;
4755 }
4756
4757 ToVar->setTSCSpec(D->getTSCSpec());
4758 ToVar->setQualifierInfo(ToQualifierLoc);
4759 ToVar->setAccess(D->getAccess());
4760 ToVar->setLexicalDeclContext(LexicalDC);
4761 if (D->isInlineSpecified())
4762 ToVar->setInlineSpecified();
4763 if (D->isInline())
4764 ToVar->setImplicitlyInline();
4765
4766 if (FoundByLookup) {
4767 auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4768 ToVar->setPreviousDecl(Recent);
4769 }
4770
4771 // Import the described template, if any.
4772 if (D->getDescribedVarTemplate()) {
4773 auto ToVTOrErr = import(From: D->getDescribedVarTemplate());
4774 if (!ToVTOrErr)
4775 return ToVTOrErr.takeError();
4776 } else if (MemberSpecializationInfo *MSI = D->getMemberSpecializationInfo()) {
4777 TemplateSpecializationKind SK = MSI->getTemplateSpecializationKind();
4778 VarDecl *FromInst = D->getInstantiatedFromStaticDataMember();
4779 if (Expected<VarDecl *> ToInstOrErr = import(From: FromInst))
4780 ToVar->setInstantiationOfStaticDataMember(VD: *ToInstOrErr, TSK: SK);
4781 else
4782 return ToInstOrErr.takeError();
4783 if (ExpectedSLoc POIOrErr = import(From: MSI->getPointOfInstantiation()))
4784 ToVar->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
4785 else
4786 return POIOrErr.takeError();
4787 }
4788
4789 if (Error Err = ImportInitializer(From: D, To: ToVar))
4790 return std::move(Err);
4791
4792 if (D->isConstexpr())
4793 ToVar->setConstexpr(true);
4794
4795 addDeclToContexts(FromD: D, ToD: ToVar);
4796
4797 // Import the rest of the chain. I.e. import all subsequent declarations.
4798 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4799 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
4800 if (!RedeclOrErr)
4801 return RedeclOrErr.takeError();
4802 }
4803
4804 return ToVar;
4805}
4806
4807ExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
4808 // Parameters are created in the translation unit's context, then moved
4809 // into the function declaration's context afterward.
4810 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4811
4812 Error Err = Error::success();
4813 auto ToDeclName = importChecked(Err, From: D->getDeclName());
4814 auto ToLocation = importChecked(Err, From: D->getLocation());
4815 auto ToType = importChecked(Err, From: D->getType());
4816 if (Err)
4817 return std::move(Err);
4818
4819 // Create the imported parameter.
4820 ImplicitParamDecl *ToParm = nullptr;
4821 if (GetImportedOrCreateDecl(ToD&: ToParm, FromD: D, args&: Importer.getToContext(), args&: DC,
4822 args&: ToLocation, args: ToDeclName.getAsIdentifierInfo(),
4823 args&: ToType, args: D->getParameterKind()))
4824 return ToParm;
4825 return ToParm;
4826}
4827
4828Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
4829 const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
4830
4831 if (auto LocOrErr = import(From: FromParam->getExplicitObjectParamThisLoc()))
4832 ToParam->setExplicitObjectParameterLoc(*LocOrErr);
4833 else
4834 return LocOrErr.takeError();
4835
4836 ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4837 ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4838
4839 if (FromParam->hasUninstantiatedDefaultArg()) {
4840 if (auto ToDefArgOrErr = import(From: FromParam->getUninstantiatedDefaultArg()))
4841 ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4842 else
4843 return ToDefArgOrErr.takeError();
4844 } else if (FromParam->hasUnparsedDefaultArg()) {
4845 ToParam->setUnparsedDefaultArg();
4846 } else if (FromParam->hasDefaultArg()) {
4847 if (auto ToDefArgOrErr = import(From: FromParam->getDefaultArg()))
4848 ToParam->setDefaultArg(*ToDefArgOrErr);
4849 else
4850 return ToDefArgOrErr.takeError();
4851 }
4852
4853 return Error::success();
4854}
4855
4856Expected<InheritedConstructor>
4857ASTNodeImporter::ImportInheritedConstructor(const InheritedConstructor &From) {
4858 Error Err = Error::success();
4859 CXXConstructorDecl *ToBaseCtor = importChecked(Err, From: From.getConstructor());
4860 ConstructorUsingShadowDecl *ToShadow =
4861 importChecked(Err, From: From.getShadowDecl());
4862 if (Err)
4863 return std::move(Err);
4864 return InheritedConstructor(ToShadow, ToBaseCtor);
4865}
4866
4867ExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
4868 // Parameters are created in the translation unit's context, then moved
4869 // into the function declaration's context afterward.
4870 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4871
4872 Error Err = Error::success();
4873 auto ToDeclName = importChecked(Err, From: D->getDeclName());
4874 auto ToLocation = importChecked(Err, From: D->getLocation());
4875 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
4876 auto ToType = importChecked(Err, From: D->getType());
4877 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
4878 if (Err)
4879 return std::move(Err);
4880
4881 ParmVarDecl *ToParm;
4882 if (GetImportedOrCreateDecl(ToD&: ToParm, FromD: D, args&: Importer.getToContext(), args&: DC,
4883 args&: ToInnerLocStart, args&: ToLocation,
4884 args: ToDeclName.getAsIdentifierInfo(), args&: ToType,
4885 args&: ToTypeSourceInfo, args: D->getStorageClass(),
4886 /*DefaultArg*/ args: nullptr))
4887 return ToParm;
4888
4889 // Set the default argument. It should be no problem if it was already done.
4890 // Do not import the default expression before GetImportedOrCreateDecl call
4891 // to avoid possible infinite import loop because circular dependency.
4892 if (Error Err = ImportDefaultArgOfParmVarDecl(FromParam: D, ToParam: ToParm))
4893 return std::move(Err);
4894
4895 if (D->isObjCMethodParameter()) {
4896 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4897 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4898 } else {
4899 ToParm->setScopeInfo(scopeDepth: D->getFunctionScopeDepth(),
4900 parameterIndex: D->getFunctionScopeIndex());
4901 }
4902
4903 return ToParm;
4904}
4905
4906ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
4907 // Import the major distinguishing characteristics of a method.
4908 DeclContext *DC, *LexicalDC;
4909 DeclarationName Name;
4910 SourceLocation Loc;
4911 NamedDecl *ToD;
4912 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4913 return std::move(Err);
4914 if (ToD)
4915 return ToD;
4916
4917 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4918 for (auto *FoundDecl : FoundDecls) {
4919 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(Val: FoundDecl)) {
4920 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4921 continue;
4922
4923 // Check return types.
4924 if (!Importer.IsStructurallyEquivalent(From: D->getReturnType(),
4925 To: FoundMethod->getReturnType())) {
4926 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_result_type_inconsistent)
4927 << D->isInstanceMethod() << Name << D->getReturnType()
4928 << FoundMethod->getReturnType();
4929 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4930 DiagID: diag::note_odr_objc_method_here)
4931 << D->isInstanceMethod() << Name;
4932
4933 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4934 }
4935
4936 // Check the number of parameters.
4937 if (D->param_size() != FoundMethod->param_size()) {
4938 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_num_params_inconsistent)
4939 << D->isInstanceMethod() << Name
4940 << D->param_size() << FoundMethod->param_size();
4941 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4942 DiagID: diag::note_odr_objc_method_here)
4943 << D->isInstanceMethod() << Name;
4944
4945 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4946 }
4947
4948 // Check parameter types.
4949 for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4950 PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4951 P != PEnd; ++P, ++FoundP) {
4952 if (!Importer.IsStructurallyEquivalent(From: (*P)->getType(),
4953 To: (*FoundP)->getType())) {
4954 Importer.FromDiag(Loc: (*P)->getLocation(),
4955 DiagID: diag::warn_odr_objc_method_param_type_inconsistent)
4956 << D->isInstanceMethod() << Name
4957 << (*P)->getType() << (*FoundP)->getType();
4958 Importer.ToDiag(Loc: (*FoundP)->getLocation(), DiagID: diag::note_odr_value_here)
4959 << (*FoundP)->getType();
4960
4961 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4962 }
4963 }
4964
4965 // Check variadic/non-variadic.
4966 // Check the number of parameters.
4967 if (D->isVariadic() != FoundMethod->isVariadic()) {
4968 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_method_variadic_inconsistent)
4969 << D->isInstanceMethod() << Name;
4970 Importer.ToDiag(Loc: FoundMethod->getLocation(),
4971 DiagID: diag::note_odr_objc_method_here)
4972 << D->isInstanceMethod() << Name;
4973
4974 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
4975 }
4976
4977 // FIXME: Any other bits we need to merge?
4978 return Importer.MapImported(From: D, To: FoundMethod);
4979 }
4980 }
4981
4982 Error Err = Error::success();
4983 auto ToEndLoc = importChecked(Err, From: D->getEndLoc());
4984 auto ToReturnType = importChecked(Err, From: D->getReturnType());
4985 auto ToReturnTypeSourceInfo =
4986 importChecked(Err, From: D->getReturnTypeSourceInfo());
4987 if (Err)
4988 return std::move(Err);
4989
4990 ObjCMethodDecl *ToMethod;
4991 if (GetImportedOrCreateDecl(
4992 ToD&: ToMethod, FromD: D, args&: Importer.getToContext(), args&: Loc, args&: ToEndLoc,
4993 args: Name.getObjCSelector(), args&: ToReturnType, args&: ToReturnTypeSourceInfo, args&: DC,
4994 args: D->isInstanceMethod(), args: D->isVariadic(), args: D->isPropertyAccessor(),
4995 args: D->isSynthesizedAccessorStub(), args: D->isImplicit(), args: D->isDefined(),
4996 args: D->getImplementationControl(), args: D->hasRelatedResultType()))
4997 return ToMethod;
4998
4999 // FIXME: When we decide to merge method definitions, we'll need to
5000 // deal with implicit parameters.
5001
5002 // Import the parameters
5003 SmallVector<ParmVarDecl *, 5> ToParams;
5004 for (auto *FromP : D->parameters()) {
5005 if (Expected<ParmVarDecl *> ToPOrErr = import(From: FromP))
5006 ToParams.push_back(Elt: *ToPOrErr);
5007 else
5008 return ToPOrErr.takeError();
5009 }
5010
5011 // Set the parameters.
5012 for (auto *ToParam : ToParams) {
5013 ToParam->setOwningFunction(ToMethod);
5014 ToMethod->addDeclInternal(D: ToParam);
5015 }
5016
5017 SmallVector<SourceLocation, 12> FromSelLocs;
5018 D->getSelectorLocs(SelLocs&: FromSelLocs);
5019 SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
5020 if (Error Err = ImportContainerChecked(InContainer: FromSelLocs, OutContainer&: ToSelLocs))
5021 return std::move(Err);
5022
5023 ToMethod->setMethodParams(C&: Importer.getToContext(), Params: ToParams, SelLocs: ToSelLocs);
5024
5025 ToMethod->setLexicalDeclContext(LexicalDC);
5026 LexicalDC->addDeclInternal(D: ToMethod);
5027
5028 // Implicit params are declared when Sema encounters the definition but this
5029 // never happens when the method is imported. Manually declare the implicit
5030 // params now that the MethodDecl knows its class interface.
5031 if (D->getSelfDecl())
5032 ToMethod->createImplicitParams(Context&: Importer.getToContext(),
5033 ID: ToMethod->getClassInterface());
5034
5035 return ToMethod;
5036}
5037
5038ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
5039 // Import the major distinguishing characteristics of a category.
5040 DeclContext *DC, *LexicalDC;
5041 DeclarationName Name;
5042 SourceLocation Loc;
5043 NamedDecl *ToD;
5044 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5045 return std::move(Err);
5046 if (ToD)
5047 return ToD;
5048
5049 Error Err = Error::success();
5050 auto ToVarianceLoc = importChecked(Err, From: D->getVarianceLoc());
5051 auto ToLocation = importChecked(Err, From: D->getLocation());
5052 auto ToColonLoc = importChecked(Err, From: D->getColonLoc());
5053 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
5054 if (Err)
5055 return std::move(Err);
5056
5057 ObjCTypeParamDecl *Result;
5058 if (GetImportedOrCreateDecl(
5059 ToD&: Result, FromD: D, args&: Importer.getToContext(), args&: DC, args: D->getVariance(),
5060 args&: ToVarianceLoc, args: D->getIndex(),
5061 args&: ToLocation, args: Name.getAsIdentifierInfo(),
5062 args&: ToColonLoc, args&: ToTypeSourceInfo))
5063 return Result;
5064
5065 // Only import 'ObjCTypeParamType' after the decl is created.
5066 auto ToTypeForDecl = importChecked(Err, From: D->getTypeForDecl());
5067 if (Err)
5068 return std::move(Err);
5069 Result->setTypeForDecl(ToTypeForDecl);
5070 Result->setLexicalDeclContext(LexicalDC);
5071 return Result;
5072}
5073
5074ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
5075 // Import the major distinguishing characteristics of a category.
5076 DeclContext *DC, *LexicalDC;
5077 DeclarationName Name;
5078 SourceLocation Loc;
5079 NamedDecl *ToD;
5080 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5081 return std::move(Err);
5082 if (ToD)
5083 return ToD;
5084
5085 ObjCInterfaceDecl *ToInterface;
5086 if (Error Err = importInto(To&: ToInterface, From: D->getClassInterface()))
5087 return std::move(Err);
5088
5089 // Determine if we've already encountered this category.
5090 ObjCCategoryDecl *MergeWithCategory
5091 = ToInterface->FindCategoryDeclaration(CategoryId: Name.getAsIdentifierInfo());
5092 ObjCCategoryDecl *ToCategory = MergeWithCategory;
5093 if (!ToCategory) {
5094
5095 Error Err = Error::success();
5096 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5097 auto ToCategoryNameLoc = importChecked(Err, From: D->getCategoryNameLoc());
5098 auto ToIvarLBraceLoc = importChecked(Err, From: D->getIvarLBraceLoc());
5099 auto ToIvarRBraceLoc = importChecked(Err, From: D->getIvarRBraceLoc());
5100 if (Err)
5101 return std::move(Err);
5102
5103 if (GetImportedOrCreateDecl(ToD&: ToCategory, FromD: D, args&: Importer.getToContext(), args&: DC,
5104 args&: ToAtStartLoc, args&: Loc,
5105 args&: ToCategoryNameLoc,
5106 args: Name.getAsIdentifierInfo(), args&: ToInterface,
5107 /*TypeParamList=*/args: nullptr,
5108 args&: ToIvarLBraceLoc,
5109 args&: ToIvarRBraceLoc))
5110 return ToCategory;
5111
5112 ToCategory->setLexicalDeclContext(LexicalDC);
5113 LexicalDC->addDeclInternal(D: ToCategory);
5114 // Import the type parameter list after MapImported, to avoid
5115 // loops when bringing in their DeclContext.
5116 if (auto PListOrErr = ImportObjCTypeParamList(list: D->getTypeParamList()))
5117 ToCategory->setTypeParamList(*PListOrErr);
5118 else
5119 return PListOrErr.takeError();
5120
5121 // Import protocols
5122 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5123 SmallVector<SourceLocation, 4> ProtocolLocs;
5124 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
5125 = D->protocol_loc_begin();
5126 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
5127 FromProtoEnd = D->protocol_end();
5128 FromProto != FromProtoEnd;
5129 ++FromProto, ++FromProtoLoc) {
5130 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5131 Protocols.push_back(Elt: *ToProtoOrErr);
5132 else
5133 return ToProtoOrErr.takeError();
5134
5135 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5136 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5137 else
5138 return ToProtoLocOrErr.takeError();
5139 }
5140
5141 // FIXME: If we're merging, make sure that the protocol list is the same.
5142 ToCategory->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5143 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5144
5145 } else {
5146 Importer.MapImported(From: D, To: ToCategory);
5147 }
5148
5149 // Import all of the members of this category.
5150 if (Error Err = ImportDeclContext(FromDC: D))
5151 return std::move(Err);
5152
5153 // If we have an implementation, import it as well.
5154 if (D->getImplementation()) {
5155 if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
5156 import(From: D->getImplementation()))
5157 ToCategory->setImplementation(*ToImplOrErr);
5158 else
5159 return ToImplOrErr.takeError();
5160 }
5161
5162 return ToCategory;
5163}
5164
5165Error ASTNodeImporter::ImportDefinition(
5166 ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
5167 if (To->getDefinition()) {
5168 if (shouldForceImportDeclContext(IDK: Kind))
5169 if (Error Err = ImportDeclContext(FromDC: From))
5170 return Err;
5171 return Error::success();
5172 }
5173
5174 // Start the protocol definition
5175 To->startDefinition();
5176
5177 // Import protocols
5178 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5179 SmallVector<SourceLocation, 4> ProtocolLocs;
5180 ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
5181 From->protocol_loc_begin();
5182 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
5183 FromProtoEnd = From->protocol_end();
5184 FromProto != FromProtoEnd;
5185 ++FromProto, ++FromProtoLoc) {
5186 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5187 Protocols.push_back(Elt: *ToProtoOrErr);
5188 else
5189 return ToProtoOrErr.takeError();
5190
5191 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5192 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5193 else
5194 return ToProtoLocOrErr.takeError();
5195
5196 }
5197
5198 // FIXME: If we're merging, make sure that the protocol list is the same.
5199 To->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5200 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5201
5202 if (shouldForceImportDeclContext(IDK: Kind)) {
5203 // Import all of the members of this protocol.
5204 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
5205 return Err;
5206 }
5207 return Error::success();
5208}
5209
5210ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
5211 // If this protocol has a definition in the translation unit we're coming
5212 // from, but this particular declaration is not that definition, import the
5213 // definition and map to that.
5214 ObjCProtocolDecl *Definition = D->getDefinition();
5215 if (Definition && Definition != D) {
5216 if (ExpectedDecl ImportedDefOrErr = import(From: Definition))
5217 return Importer.MapImported(From: D, To: *ImportedDefOrErr);
5218 else
5219 return ImportedDefOrErr.takeError();
5220 }
5221
5222 // Import the major distinguishing characteristics of a protocol.
5223 DeclContext *DC, *LexicalDC;
5224 DeclarationName Name;
5225 SourceLocation Loc;
5226 NamedDecl *ToD;
5227 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5228 return std::move(Err);
5229 if (ToD)
5230 return ToD;
5231
5232 ObjCProtocolDecl *MergeWithProtocol = nullptr;
5233 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5234 for (auto *FoundDecl : FoundDecls) {
5235 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_ObjCProtocol))
5236 continue;
5237
5238 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(Val: FoundDecl)))
5239 break;
5240 }
5241
5242 ObjCProtocolDecl *ToProto = MergeWithProtocol;
5243 if (!ToProto) {
5244 auto ToAtBeginLocOrErr = import(From: D->getAtStartLoc());
5245 if (!ToAtBeginLocOrErr)
5246 return ToAtBeginLocOrErr.takeError();
5247
5248 if (GetImportedOrCreateDecl(ToD&: ToProto, FromD: D, args&: Importer.getToContext(), args&: DC,
5249 args: Name.getAsIdentifierInfo(), args&: Loc,
5250 args&: *ToAtBeginLocOrErr,
5251 /*PrevDecl=*/args: nullptr))
5252 return ToProto;
5253 ToProto->setLexicalDeclContext(LexicalDC);
5254 LexicalDC->addDeclInternal(D: ToProto);
5255 }
5256
5257 Importer.MapImported(From: D, To: ToProto);
5258
5259 if (D->isThisDeclarationADefinition())
5260 if (Error Err = ImportDefinition(From: D, To: ToProto))
5261 return std::move(Err);
5262
5263 return ToProto;
5264}
5265
5266ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
5267 DeclContext *DC, *LexicalDC;
5268 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5269 return std::move(Err);
5270
5271 ExpectedSLoc ExternLocOrErr = import(From: D->getExternLoc());
5272 if (!ExternLocOrErr)
5273 return ExternLocOrErr.takeError();
5274
5275 ExpectedSLoc LangLocOrErr = import(From: D->getLocation());
5276 if (!LangLocOrErr)
5277 return LangLocOrErr.takeError();
5278
5279 bool HasBraces = D->hasBraces();
5280
5281 LinkageSpecDecl *ToLinkageSpec;
5282 if (GetImportedOrCreateDecl(ToD&: ToLinkageSpec, FromD: D, args&: Importer.getToContext(), args&: DC,
5283 args&: *ExternLocOrErr, args&: *LangLocOrErr,
5284 args: D->getLanguage(), args&: HasBraces))
5285 return ToLinkageSpec;
5286
5287 if (HasBraces) {
5288 ExpectedSLoc RBraceLocOrErr = import(From: D->getRBraceLoc());
5289 if (!RBraceLocOrErr)
5290 return RBraceLocOrErr.takeError();
5291 ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
5292 }
5293
5294 ToLinkageSpec->setLexicalDeclContext(LexicalDC);
5295 LexicalDC->addDeclInternal(D: ToLinkageSpec);
5296
5297 return ToLinkageSpec;
5298}
5299
5300ExpectedDecl ASTNodeImporter::ImportUsingShadowDecls(BaseUsingDecl *D,
5301 BaseUsingDecl *ToSI) {
5302 for (UsingShadowDecl *FromShadow : D->shadows()) {
5303 if (Expected<UsingShadowDecl *> ToShadowOrErr = import(From: FromShadow))
5304 ToSI->addShadowDecl(S: *ToShadowOrErr);
5305 else
5306 // FIXME: We return error here but the definition is already created
5307 // and available with lookups. How to fix this?..
5308 return ToShadowOrErr.takeError();
5309 }
5310 return ToSI;
5311}
5312
5313ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
5314 DeclContext *DC, *LexicalDC;
5315 DeclarationName Name;
5316 SourceLocation Loc;
5317 NamedDecl *ToD = nullptr;
5318 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5319 return std::move(Err);
5320 if (ToD)
5321 return ToD;
5322
5323 Error Err = Error::success();
5324 auto ToLoc = importChecked(Err, From: D->getNameInfo().getLoc());
5325 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5326 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5327 if (Err)
5328 return std::move(Err);
5329
5330 DeclarationNameInfo NameInfo(Name, ToLoc);
5331 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
5332 return std::move(Err);
5333
5334 UsingDecl *ToUsing;
5335 if (GetImportedOrCreateDecl(ToD&: ToUsing, FromD: D, args&: Importer.getToContext(), args&: DC,
5336 args&: ToUsingLoc, args&: ToQualifierLoc, args&: NameInfo,
5337 args: D->hasTypename()))
5338 return ToUsing;
5339
5340 ToUsing->setLexicalDeclContext(LexicalDC);
5341 LexicalDC->addDeclInternal(D: ToUsing);
5342
5343 if (NamedDecl *FromPattern =
5344 Importer.getFromContext().getInstantiatedFromUsingDecl(Inst: D)) {
5345 if (Expected<NamedDecl *> ToPatternOrErr = import(From: FromPattern))
5346 Importer.getToContext().setInstantiatedFromUsingDecl(
5347 Inst: ToUsing, Pattern: *ToPatternOrErr);
5348 else
5349 return ToPatternOrErr.takeError();
5350 }
5351
5352 return ImportUsingShadowDecls(D, ToSI: ToUsing);
5353}
5354
5355ExpectedDecl ASTNodeImporter::VisitUsingEnumDecl(UsingEnumDecl *D) {
5356 DeclContext *DC, *LexicalDC;
5357 DeclarationName Name;
5358 SourceLocation Loc;
5359 NamedDecl *ToD = nullptr;
5360 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5361 return std::move(Err);
5362 if (ToD)
5363 return ToD;
5364
5365 Error Err = Error::success();
5366 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5367 auto ToEnumLoc = importChecked(Err, From: D->getEnumLoc());
5368 auto ToNameLoc = importChecked(Err, From: D->getLocation());
5369 auto *ToEnumType = importChecked(Err, From: D->getEnumType());
5370 if (Err)
5371 return std::move(Err);
5372
5373 UsingEnumDecl *ToUsingEnum;
5374 if (GetImportedOrCreateDecl(ToD&: ToUsingEnum, FromD: D, args&: Importer.getToContext(), args&: DC,
5375 args&: ToUsingLoc, args&: ToEnumLoc, args&: ToNameLoc, args&: ToEnumType))
5376 return ToUsingEnum;
5377
5378 ToUsingEnum->setLexicalDeclContext(LexicalDC);
5379 LexicalDC->addDeclInternal(D: ToUsingEnum);
5380
5381 if (UsingEnumDecl *FromPattern =
5382 Importer.getFromContext().getInstantiatedFromUsingEnumDecl(Inst: D)) {
5383 if (Expected<UsingEnumDecl *> ToPatternOrErr = import(From: FromPattern))
5384 Importer.getToContext().setInstantiatedFromUsingEnumDecl(Inst: ToUsingEnum,
5385 Pattern: *ToPatternOrErr);
5386 else
5387 return ToPatternOrErr.takeError();
5388 }
5389
5390 return ImportUsingShadowDecls(D, ToSI: ToUsingEnum);
5391}
5392
5393ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
5394 DeclContext *DC, *LexicalDC;
5395 DeclarationName Name;
5396 SourceLocation Loc;
5397 NamedDecl *ToD = nullptr;
5398 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5399 return std::move(Err);
5400 if (ToD)
5401 return ToD;
5402
5403 Expected<BaseUsingDecl *> ToIntroducerOrErr = import(From: D->getIntroducer());
5404 if (!ToIntroducerOrErr)
5405 return ToIntroducerOrErr.takeError();
5406
5407 Expected<NamedDecl *> ToTargetOrErr = import(From: D->getTargetDecl());
5408 if (!ToTargetOrErr)
5409 return ToTargetOrErr.takeError();
5410
5411 UsingShadowDecl *ToShadow;
5412 if (auto *FromConstructorUsingShadow =
5413 dyn_cast<ConstructorUsingShadowDecl>(Val: D)) {
5414 Error Err = Error::success();
5415 ConstructorUsingShadowDecl *Nominated = importChecked(
5416 Err, From: FromConstructorUsingShadow->getNominatedBaseClassShadowDecl());
5417 if (Err)
5418 return std::move(Err);
5419 // The 'Target' parameter of ConstructorUsingShadowDecl constructor
5420 // is really the "NominatedBaseClassShadowDecl" value if it exists
5421 // (see code of ConstructorUsingShadowDecl::ConstructorUsingShadowDecl).
5422 // We should pass the NominatedBaseClassShadowDecl to it (if non-null) to
5423 // get the correct values.
5424 if (GetImportedOrCreateDecl<ConstructorUsingShadowDecl>(
5425 ToD&: ToShadow, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5426 args: cast<UsingDecl>(Val: *ToIntroducerOrErr),
5427 args: Nominated ? Nominated : *ToTargetOrErr,
5428 args: FromConstructorUsingShadow->constructsVirtualBase()))
5429 return ToShadow;
5430 } else {
5431 if (GetImportedOrCreateDecl(ToD&: ToShadow, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5432 args&: Name, args&: *ToIntroducerOrErr, args&: *ToTargetOrErr))
5433 return ToShadow;
5434 }
5435
5436 ToShadow->setLexicalDeclContext(LexicalDC);
5437 ToShadow->setAccess(D->getAccess());
5438
5439 if (UsingShadowDecl *FromPattern =
5440 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(Inst: D)) {
5441 if (Expected<UsingShadowDecl *> ToPatternOrErr = import(From: FromPattern))
5442 Importer.getToContext().setInstantiatedFromUsingShadowDecl(
5443 Inst: ToShadow, Pattern: *ToPatternOrErr);
5444 else
5445 // FIXME: We return error here but the definition is already created
5446 // and available with lookups. How to fix this?..
5447 return ToPatternOrErr.takeError();
5448 }
5449
5450 LexicalDC->addDeclInternal(D: ToShadow);
5451
5452 return ToShadow;
5453}
5454
5455ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
5456 DeclContext *DC, *LexicalDC;
5457 DeclarationName Name;
5458 SourceLocation Loc;
5459 NamedDecl *ToD = nullptr;
5460 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5461 return std::move(Err);
5462 if (ToD)
5463 return ToD;
5464
5465 auto ToComAncestorOrErr = Importer.ImportContext(FromDC: D->getCommonAncestor());
5466 if (!ToComAncestorOrErr)
5467 return ToComAncestorOrErr.takeError();
5468
5469 Error Err = Error::success();
5470 auto ToNominatedNamespace = importChecked(Err, From: D->getNominatedNamespace());
5471 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5472 auto ToNamespaceKeyLocation =
5473 importChecked(Err, From: D->getNamespaceKeyLocation());
5474 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5475 auto ToIdentLocation = importChecked(Err, From: D->getIdentLocation());
5476 if (Err)
5477 return std::move(Err);
5478
5479 UsingDirectiveDecl *ToUsingDir;
5480 if (GetImportedOrCreateDecl(ToD&: ToUsingDir, FromD: D, args&: Importer.getToContext(), args&: DC,
5481 args&: ToUsingLoc,
5482 args&: ToNamespaceKeyLocation,
5483 args&: ToQualifierLoc,
5484 args&: ToIdentLocation,
5485 args&: ToNominatedNamespace, args&: *ToComAncestorOrErr))
5486 return ToUsingDir;
5487
5488 ToUsingDir->setLexicalDeclContext(LexicalDC);
5489 LexicalDC->addDeclInternal(D: ToUsingDir);
5490
5491 return ToUsingDir;
5492}
5493
5494ExpectedDecl ASTNodeImporter::VisitUsingPackDecl(UsingPackDecl *D) {
5495 DeclContext *DC, *LexicalDC;
5496 DeclarationName Name;
5497 SourceLocation Loc;
5498 NamedDecl *ToD = nullptr;
5499 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5500 return std::move(Err);
5501 if (ToD)
5502 return ToD;
5503
5504 auto ToInstantiatedFromUsingOrErr =
5505 Importer.Import(FromD: D->getInstantiatedFromUsingDecl());
5506 if (!ToInstantiatedFromUsingOrErr)
5507 return ToInstantiatedFromUsingOrErr.takeError();
5508 SmallVector<NamedDecl *, 4> Expansions(D->expansions().size());
5509 if (Error Err = ImportArrayChecked(InContainer: D->expansions(), Obegin: Expansions.begin()))
5510 return std::move(Err);
5511
5512 UsingPackDecl *ToUsingPack;
5513 if (GetImportedOrCreateDecl(ToD&: ToUsingPack, FromD: D, args&: Importer.getToContext(), args&: DC,
5514 args: cast<NamedDecl>(Val: *ToInstantiatedFromUsingOrErr),
5515 args&: Expansions))
5516 return ToUsingPack;
5517
5518 addDeclToContexts(FromD: D, ToD: ToUsingPack);
5519
5520 return ToUsingPack;
5521}
5522
5523ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
5524 UnresolvedUsingValueDecl *D) {
5525 DeclContext *DC, *LexicalDC;
5526 DeclarationName Name;
5527 SourceLocation Loc;
5528 NamedDecl *ToD = nullptr;
5529 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5530 return std::move(Err);
5531 if (ToD)
5532 return ToD;
5533
5534 Error Err = Error::success();
5535 auto ToLoc = importChecked(Err, From: D->getNameInfo().getLoc());
5536 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5537 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5538 auto ToEllipsisLoc = importChecked(Err, From: D->getEllipsisLoc());
5539 if (Err)
5540 return std::move(Err);
5541
5542 DeclarationNameInfo NameInfo(Name, ToLoc);
5543 if (Error Err = ImportDeclarationNameLoc(From: D->getNameInfo(), To&: NameInfo))
5544 return std::move(Err);
5545
5546 UnresolvedUsingValueDecl *ToUsingValue;
5547 if (GetImportedOrCreateDecl(ToD&: ToUsingValue, FromD: D, args&: Importer.getToContext(), args&: DC,
5548 args&: ToUsingLoc, args&: ToQualifierLoc, args&: NameInfo,
5549 args&: ToEllipsisLoc))
5550 return ToUsingValue;
5551
5552 ToUsingValue->setAccess(D->getAccess());
5553 ToUsingValue->setLexicalDeclContext(LexicalDC);
5554 LexicalDC->addDeclInternal(D: ToUsingValue);
5555
5556 return ToUsingValue;
5557}
5558
5559ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
5560 UnresolvedUsingTypenameDecl *D) {
5561 DeclContext *DC, *LexicalDC;
5562 DeclarationName Name;
5563 SourceLocation Loc;
5564 NamedDecl *ToD = nullptr;
5565 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5566 return std::move(Err);
5567 if (ToD)
5568 return ToD;
5569
5570 Error Err = Error::success();
5571 auto ToUsingLoc = importChecked(Err, From: D->getUsingLoc());
5572 auto ToTypenameLoc = importChecked(Err, From: D->getTypenameLoc());
5573 auto ToQualifierLoc = importChecked(Err, From: D->getQualifierLoc());
5574 auto ToEllipsisLoc = importChecked(Err, From: D->getEllipsisLoc());
5575 if (Err)
5576 return std::move(Err);
5577
5578 UnresolvedUsingTypenameDecl *ToUsing;
5579 if (GetImportedOrCreateDecl(ToD&: ToUsing, FromD: D, args&: Importer.getToContext(), args&: DC,
5580 args&: ToUsingLoc, args&: ToTypenameLoc,
5581 args&: ToQualifierLoc, args&: Loc, args&: Name, args&: ToEllipsisLoc))
5582 return ToUsing;
5583
5584 ToUsing->setAccess(D->getAccess());
5585 ToUsing->setLexicalDeclContext(LexicalDC);
5586 LexicalDC->addDeclInternal(D: ToUsing);
5587
5588 return ToUsing;
5589}
5590
5591ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
5592 Decl* ToD = nullptr;
5593 switch (D->getBuiltinTemplateKind()) {
5594#define BuiltinTemplate(BTName) \
5595 case BuiltinTemplateKind::BTK##BTName: \
5596 ToD = Importer.getToContext().get##BTName##Decl(); \
5597 break;
5598#include "clang/Basic/BuiltinTemplates.inc"
5599 }
5600 assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
5601 Importer.MapImported(From: D, To: ToD);
5602 return ToD;
5603}
5604
5605Error ASTNodeImporter::ImportDefinition(
5606 ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
5607 if (To->getDefinition()) {
5608 // Check consistency of superclass.
5609 ObjCInterfaceDecl *FromSuper = From->getSuperClass();
5610 if (FromSuper) {
5611 if (auto FromSuperOrErr = import(From: FromSuper))
5612 FromSuper = *FromSuperOrErr;
5613 else
5614 return FromSuperOrErr.takeError();
5615 }
5616
5617 ObjCInterfaceDecl *ToSuper = To->getSuperClass();
5618 if ((bool)FromSuper != (bool)ToSuper ||
5619 (FromSuper && !declaresSameEntity(D1: FromSuper, D2: ToSuper))) {
5620 Importer.ToDiag(Loc: To->getLocation(),
5621 DiagID: diag::warn_odr_objc_superclass_inconsistent)
5622 << To->getDeclName();
5623 if (ToSuper)
5624 Importer.ToDiag(Loc: To->getSuperClassLoc(), DiagID: diag::note_odr_objc_superclass)
5625 << To->getSuperClass()->getDeclName();
5626 else
5627 Importer.ToDiag(Loc: To->getLocation(),
5628 DiagID: diag::note_odr_objc_missing_superclass);
5629 if (From->getSuperClass())
5630 Importer.FromDiag(Loc: From->getSuperClassLoc(),
5631 DiagID: diag::note_odr_objc_superclass)
5632 << From->getSuperClass()->getDeclName();
5633 else
5634 Importer.FromDiag(Loc: From->getLocation(),
5635 DiagID: diag::note_odr_objc_missing_superclass);
5636 }
5637
5638 if (shouldForceImportDeclContext(IDK: Kind))
5639 if (Error Err = ImportDeclContext(FromDC: From))
5640 return Err;
5641 return Error::success();
5642 }
5643
5644 // Start the definition.
5645 To->startDefinition();
5646
5647 // If this class has a superclass, import it.
5648 if (From->getSuperClass()) {
5649 if (auto SuperTInfoOrErr = import(From: From->getSuperClassTInfo()))
5650 To->setSuperClass(*SuperTInfoOrErr);
5651 else
5652 return SuperTInfoOrErr.takeError();
5653 }
5654
5655 // Import protocols
5656 SmallVector<ObjCProtocolDecl *, 4> Protocols;
5657 SmallVector<SourceLocation, 4> ProtocolLocs;
5658 ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc =
5659 From->protocol_loc_begin();
5660
5661 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
5662 FromProtoEnd = From->protocol_end();
5663 FromProto != FromProtoEnd;
5664 ++FromProto, ++FromProtoLoc) {
5665 if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(From: *FromProto))
5666 Protocols.push_back(Elt: *ToProtoOrErr);
5667 else
5668 return ToProtoOrErr.takeError();
5669
5670 if (ExpectedSLoc ToProtoLocOrErr = import(From: *FromProtoLoc))
5671 ProtocolLocs.push_back(Elt: *ToProtoLocOrErr);
5672 else
5673 return ToProtoLocOrErr.takeError();
5674
5675 }
5676
5677 // FIXME: If we're merging, make sure that the protocol list is the same.
5678 To->setProtocolList(List: Protocols.data(), Num: Protocols.size(),
5679 Locs: ProtocolLocs.data(), C&: Importer.getToContext());
5680
5681 // Import categories. When the categories themselves are imported, they'll
5682 // hook themselves into this interface.
5683 for (auto *Cat : From->known_categories()) {
5684 auto ToCatOrErr = import(From: Cat);
5685 if (!ToCatOrErr)
5686 return ToCatOrErr.takeError();
5687 }
5688
5689 // If we have an @implementation, import it as well.
5690 if (From->getImplementation()) {
5691 if (Expected<ObjCImplementationDecl *> ToImplOrErr =
5692 import(From: From->getImplementation()))
5693 To->setImplementation(*ToImplOrErr);
5694 else
5695 return ToImplOrErr.takeError();
5696 }
5697
5698 // Import all of the members of this class.
5699 if (Error Err = ImportDeclContext(FromDC: From, /*ForceImport=*/true))
5700 return Err;
5701
5702 return Error::success();
5703}
5704
5705Expected<ObjCTypeParamList *>
5706ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
5707 if (!list)
5708 return nullptr;
5709
5710 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
5711 for (auto *fromTypeParam : *list) {
5712 if (auto toTypeParamOrErr = import(From: fromTypeParam))
5713 toTypeParams.push_back(Elt: *toTypeParamOrErr);
5714 else
5715 return toTypeParamOrErr.takeError();
5716 }
5717
5718 auto LAngleLocOrErr = import(From: list->getLAngleLoc());
5719 if (!LAngleLocOrErr)
5720 return LAngleLocOrErr.takeError();
5721
5722 auto RAngleLocOrErr = import(From: list->getRAngleLoc());
5723 if (!RAngleLocOrErr)
5724 return RAngleLocOrErr.takeError();
5725
5726 return ObjCTypeParamList::create(ctx&: Importer.getToContext(),
5727 lAngleLoc: *LAngleLocOrErr,
5728 typeParams: toTypeParams,
5729 rAngleLoc: *RAngleLocOrErr);
5730}
5731
5732ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
5733 // If this class has a definition in the translation unit we're coming from,
5734 // but this particular declaration is not that definition, import the
5735 // definition and map to that.
5736 ObjCInterfaceDecl *Definition = D->getDefinition();
5737 if (Definition && Definition != D) {
5738 if (ExpectedDecl ImportedDefOrErr = import(From: Definition))
5739 return Importer.MapImported(From: D, To: *ImportedDefOrErr);
5740 else
5741 return ImportedDefOrErr.takeError();
5742 }
5743
5744 // Import the major distinguishing characteristics of an @interface.
5745 DeclContext *DC, *LexicalDC;
5746 DeclarationName Name;
5747 SourceLocation Loc;
5748 NamedDecl *ToD;
5749 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5750 return std::move(Err);
5751 if (ToD)
5752 return ToD;
5753
5754 // Look for an existing interface with the same name.
5755 ObjCInterfaceDecl *MergeWithIface = nullptr;
5756 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5757 for (auto *FoundDecl : FoundDecls) {
5758 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary))
5759 continue;
5760
5761 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(Val: FoundDecl)))
5762 break;
5763 }
5764
5765 // Create an interface declaration, if one does not already exist.
5766 ObjCInterfaceDecl *ToIface = MergeWithIface;
5767 if (!ToIface) {
5768 ExpectedSLoc AtBeginLocOrErr = import(From: D->getAtStartLoc());
5769 if (!AtBeginLocOrErr)
5770 return AtBeginLocOrErr.takeError();
5771
5772 if (GetImportedOrCreateDecl(
5773 ToD&: ToIface, FromD: D, args&: Importer.getToContext(), args&: DC,
5774 args&: *AtBeginLocOrErr, args: Name.getAsIdentifierInfo(),
5775 /*TypeParamList=*/args: nullptr,
5776 /*PrevDecl=*/args: nullptr, args&: Loc, args: D->isImplicitInterfaceDecl()))
5777 return ToIface;
5778 ToIface->setLexicalDeclContext(LexicalDC);
5779 LexicalDC->addDeclInternal(D: ToIface);
5780 }
5781 Importer.MapImported(From: D, To: ToIface);
5782 // Import the type parameter list after MapImported, to avoid
5783 // loops when bringing in their DeclContext.
5784 if (auto ToPListOrErr =
5785 ImportObjCTypeParamList(list: D->getTypeParamListAsWritten()))
5786 ToIface->setTypeParamList(*ToPListOrErr);
5787 else
5788 return ToPListOrErr.takeError();
5789
5790 if (D->isThisDeclarationADefinition())
5791 if (Error Err = ImportDefinition(From: D, To: ToIface))
5792 return std::move(Err);
5793
5794 return ToIface;
5795}
5796
5797ExpectedDecl
5798ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
5799 ObjCCategoryDecl *Category;
5800 if (Error Err = importInto(To&: Category, From: D->getCategoryDecl()))
5801 return std::move(Err);
5802
5803 ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
5804 if (!ToImpl) {
5805 DeclContext *DC, *LexicalDC;
5806 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5807 return std::move(Err);
5808
5809 Error Err = Error::success();
5810 auto ToLocation = importChecked(Err, From: D->getLocation());
5811 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5812 auto ToCategoryNameLoc = importChecked(Err, From: D->getCategoryNameLoc());
5813 if (Err)
5814 return std::move(Err);
5815
5816 if (GetImportedOrCreateDecl(
5817 ToD&: ToImpl, FromD: D, args&: Importer.getToContext(), args&: DC,
5818 args: Importer.Import(FromId: D->getIdentifier()), args: Category->getClassInterface(),
5819 args&: ToLocation, args&: ToAtStartLoc, args&: ToCategoryNameLoc))
5820 return ToImpl;
5821
5822 ToImpl->setLexicalDeclContext(LexicalDC);
5823 LexicalDC->addDeclInternal(D: ToImpl);
5824 Category->setImplementation(ToImpl);
5825 }
5826
5827 Importer.MapImported(From: D, To: ToImpl);
5828 if (Error Err = ImportDeclContext(FromDC: D))
5829 return std::move(Err);
5830
5831 return ToImpl;
5832}
5833
5834ExpectedDecl
5835ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
5836 // Find the corresponding interface.
5837 ObjCInterfaceDecl *Iface;
5838 if (Error Err = importInto(To&: Iface, From: D->getClassInterface()))
5839 return std::move(Err);
5840
5841 // Import the superclass, if any.
5842 ObjCInterfaceDecl *Super;
5843 if (Error Err = importInto(To&: Super, From: D->getSuperClass()))
5844 return std::move(Err);
5845
5846 ObjCImplementationDecl *Impl = Iface->getImplementation();
5847 if (!Impl) {
5848 // We haven't imported an implementation yet. Create a new @implementation
5849 // now.
5850 DeclContext *DC, *LexicalDC;
5851 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
5852 return std::move(Err);
5853
5854 Error Err = Error::success();
5855 auto ToLocation = importChecked(Err, From: D->getLocation());
5856 auto ToAtStartLoc = importChecked(Err, From: D->getAtStartLoc());
5857 auto ToSuperClassLoc = importChecked(Err, From: D->getSuperClassLoc());
5858 auto ToIvarLBraceLoc = importChecked(Err, From: D->getIvarLBraceLoc());
5859 auto ToIvarRBraceLoc = importChecked(Err, From: D->getIvarRBraceLoc());
5860 if (Err)
5861 return std::move(Err);
5862
5863 if (GetImportedOrCreateDecl(ToD&: Impl, FromD: D, args&: Importer.getToContext(),
5864 args&: DC, args&: Iface, args&: Super,
5865 args&: ToLocation,
5866 args&: ToAtStartLoc,
5867 args&: ToSuperClassLoc,
5868 args&: ToIvarLBraceLoc,
5869 args&: ToIvarRBraceLoc))
5870 return Impl;
5871
5872 Impl->setLexicalDeclContext(LexicalDC);
5873
5874 // Associate the implementation with the class it implements.
5875 Iface->setImplementation(Impl);
5876 Importer.MapImported(From: D, To: Iface->getImplementation());
5877 } else {
5878 Importer.MapImported(From: D, To: Iface->getImplementation());
5879
5880 // Verify that the existing @implementation has the same superclass.
5881 if ((Super && !Impl->getSuperClass()) ||
5882 (!Super && Impl->getSuperClass()) ||
5883 (Super && Impl->getSuperClass() &&
5884 !declaresSameEntity(D1: Super->getCanonicalDecl(),
5885 D2: Impl->getSuperClass()))) {
5886 Importer.ToDiag(Loc: Impl->getLocation(),
5887 DiagID: diag::warn_odr_objc_superclass_inconsistent)
5888 << Iface->getDeclName();
5889 // FIXME: It would be nice to have the location of the superclass
5890 // below.
5891 if (Impl->getSuperClass())
5892 Importer.ToDiag(Loc: Impl->getLocation(),
5893 DiagID: diag::note_odr_objc_superclass)
5894 << Impl->getSuperClass()->getDeclName();
5895 else
5896 Importer.ToDiag(Loc: Impl->getLocation(),
5897 DiagID: diag::note_odr_objc_missing_superclass);
5898 if (D->getSuperClass())
5899 Importer.FromDiag(Loc: D->getLocation(),
5900 DiagID: diag::note_odr_objc_superclass)
5901 << D->getSuperClass()->getDeclName();
5902 else
5903 Importer.FromDiag(Loc: D->getLocation(),
5904 DiagID: diag::note_odr_objc_missing_superclass);
5905
5906 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
5907 }
5908 }
5909
5910 // Import all of the members of this @implementation.
5911 if (Error Err = ImportDeclContext(FromDC: D))
5912 return std::move(Err);
5913
5914 return Impl;
5915}
5916
5917ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
5918 // Import the major distinguishing characteristics of an @property.
5919 DeclContext *DC, *LexicalDC;
5920 DeclarationName Name;
5921 SourceLocation Loc;
5922 NamedDecl *ToD;
5923 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5924 return std::move(Err);
5925 if (ToD)
5926 return ToD;
5927
5928 // Check whether we have already imported this property.
5929 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5930 for (auto *FoundDecl : FoundDecls) {
5931 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(Val: FoundDecl)) {
5932 // Instance and class properties can share the same name but are different
5933 // declarations.
5934 if (FoundProp->isInstanceProperty() != D->isInstanceProperty())
5935 continue;
5936
5937 // Check property types.
5938 if (!Importer.IsStructurallyEquivalent(From: D->getType(),
5939 To: FoundProp->getType())) {
5940 Importer.ToDiag(Loc, DiagID: diag::warn_odr_objc_property_type_inconsistent)
5941 << Name << D->getType() << FoundProp->getType();
5942 Importer.ToDiag(Loc: FoundProp->getLocation(), DiagID: diag::note_odr_value_here)
5943 << FoundProp->getType();
5944
5945 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
5946 }
5947
5948 // FIXME: Check property attributes, getters, setters, etc.?
5949
5950 // Consider these properties to be equivalent.
5951 Importer.MapImported(From: D, To: FoundProp);
5952 return FoundProp;
5953 }
5954 }
5955
5956 Error Err = Error::success();
5957 auto ToType = importChecked(Err, From: D->getType());
5958 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
5959 auto ToAtLoc = importChecked(Err, From: D->getAtLoc());
5960 auto ToLParenLoc = importChecked(Err, From: D->getLParenLoc());
5961 if (Err)
5962 return std::move(Err);
5963
5964 // Create the new property.
5965 ObjCPropertyDecl *ToProperty;
5966 if (GetImportedOrCreateDecl(
5967 ToD&: ToProperty, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
5968 args: Name.getAsIdentifierInfo(), args&: ToAtLoc,
5969 args&: ToLParenLoc, args&: ToType,
5970 args&: ToTypeSourceInfo, args: D->getPropertyImplementation()))
5971 return ToProperty;
5972
5973 auto ToGetterName = importChecked(Err, From: D->getGetterName());
5974 auto ToSetterName = importChecked(Err, From: D->getSetterName());
5975 auto ToGetterNameLoc = importChecked(Err, From: D->getGetterNameLoc());
5976 auto ToSetterNameLoc = importChecked(Err, From: D->getSetterNameLoc());
5977 auto ToGetterMethodDecl = importChecked(Err, From: D->getGetterMethodDecl());
5978 auto ToSetterMethodDecl = importChecked(Err, From: D->getSetterMethodDecl());
5979 auto ToPropertyIvarDecl = importChecked(Err, From: D->getPropertyIvarDecl());
5980 if (Err)
5981 return std::move(Err);
5982
5983 ToProperty->setLexicalDeclContext(LexicalDC);
5984 LexicalDC->addDeclInternal(D: ToProperty);
5985
5986 ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5987 ToProperty->setPropertyAttributesAsWritten(
5988 D->getPropertyAttributesAsWritten());
5989 ToProperty->setGetterName(Sel: ToGetterName, Loc: ToGetterNameLoc);
5990 ToProperty->setSetterName(Sel: ToSetterName, Loc: ToSetterNameLoc);
5991 ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5992 ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5993 ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
5994 return ToProperty;
5995}
5996
5997ExpectedDecl
5998ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
5999 ObjCPropertyDecl *Property;
6000 if (Error Err = importInto(To&: Property, From: D->getPropertyDecl()))
6001 return std::move(Err);
6002
6003 DeclContext *DC, *LexicalDC;
6004 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6005 return std::move(Err);
6006
6007 auto *InImpl = cast<ObjCImplDecl>(Val: LexicalDC);
6008
6009 // Import the ivar (for an @synthesize).
6010 ObjCIvarDecl *Ivar = nullptr;
6011 if (Error Err = importInto(To&: Ivar, From: D->getPropertyIvarDecl()))
6012 return std::move(Err);
6013
6014 ObjCPropertyImplDecl *ToImpl
6015 = InImpl->FindPropertyImplDecl(propertyId: Property->getIdentifier(),
6016 queryKind: Property->getQueryKind());
6017 if (!ToImpl) {
6018
6019 Error Err = Error::success();
6020 auto ToBeginLoc = importChecked(Err, From: D->getBeginLoc());
6021 auto ToLocation = importChecked(Err, From: D->getLocation());
6022 auto ToPropertyIvarDeclLoc =
6023 importChecked(Err, From: D->getPropertyIvarDeclLoc());
6024 if (Err)
6025 return std::move(Err);
6026
6027 if (GetImportedOrCreateDecl(ToD&: ToImpl, FromD: D, args&: Importer.getToContext(), args&: DC,
6028 args&: ToBeginLoc,
6029 args&: ToLocation, args&: Property,
6030 args: D->getPropertyImplementation(), args&: Ivar,
6031 args&: ToPropertyIvarDeclLoc))
6032 return ToImpl;
6033
6034 ToImpl->setLexicalDeclContext(LexicalDC);
6035 LexicalDC->addDeclInternal(D: ToImpl);
6036 } else {
6037 // Check that we have the same kind of property implementation (@synthesize
6038 // vs. @dynamic).
6039 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
6040 Importer.ToDiag(Loc: ToImpl->getLocation(),
6041 DiagID: diag::warn_odr_objc_property_impl_kind_inconsistent)
6042 << Property->getDeclName()
6043 << (ToImpl->getPropertyImplementation()
6044 == ObjCPropertyImplDecl::Dynamic);
6045 Importer.FromDiag(Loc: D->getLocation(),
6046 DiagID: diag::note_odr_objc_property_impl_kind)
6047 << D->getPropertyDecl()->getDeclName()
6048 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
6049
6050 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6051 }
6052
6053 // For @synthesize, check that we have the same
6054 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
6055 Ivar != ToImpl->getPropertyIvarDecl()) {
6056 Importer.ToDiag(Loc: ToImpl->getPropertyIvarDeclLoc(),
6057 DiagID: diag::warn_odr_objc_synthesize_ivar_inconsistent)
6058 << Property->getDeclName()
6059 << ToImpl->getPropertyIvarDecl()->getDeclName()
6060 << Ivar->getDeclName();
6061 Importer.FromDiag(Loc: D->getPropertyIvarDeclLoc(),
6062 DiagID: diag::note_odr_objc_synthesize_ivar_here)
6063 << D->getPropertyIvarDecl()->getDeclName();
6064
6065 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6066 }
6067
6068 // Merge the existing implementation with the new implementation.
6069 Importer.MapImported(From: D, To: ToImpl);
6070 }
6071
6072 return ToImpl;
6073}
6074
6075ExpectedDecl
6076ASTNodeImporter::VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D) {
6077 Error Err = Error::success();
6078 auto ToType = importChecked(Err, From: D->getType());
6079 auto ToValue = importChecked(Err, From: D->getValue());
6080 if (Err)
6081 return std::move(Err);
6082
6083 TemplateParamObjectDecl *ToD;
6084 auto Create = [this](QualType T, const APValue &V) {
6085 return Importer.ToContext.getTemplateParamObjectDecl(T, V);
6086 };
6087 (void)GetImportedOrCreateSpecialDecl(ToD, CreateFun: Create, FromD: D, args&: ToType, args&: ToValue);
6088 return ToD;
6089}
6090
6091ExpectedDecl
6092ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
6093 // For template arguments, we adopt the translation unit as our declaration
6094 // context. This context will be fixed when (during) the actual template
6095 // declaration is created.
6096
6097 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6098 if (!BeginLocOrErr)
6099 return BeginLocOrErr.takeError();
6100
6101 ExpectedSLoc LocationOrErr = import(From: D->getLocation());
6102 if (!LocationOrErr)
6103 return LocationOrErr.takeError();
6104
6105 TemplateTypeParmDecl *ToD = nullptr;
6106 if (GetImportedOrCreateDecl(
6107 ToD, FromD: D, args&: Importer.getToContext(),
6108 args: Importer.getToContext().getTranslationUnitDecl(),
6109 args&: *BeginLocOrErr, args&: *LocationOrErr,
6110 args: D->getDepth(), args: D->getIndex(), args: Importer.Import(FromId: D->getIdentifier()),
6111 args: D->wasDeclaredWithTypename(), args: D->isParameterPack(),
6112 args: D->hasTypeConstraint()))
6113 return ToD;
6114
6115 // Import the type-constraint
6116 if (const TypeConstraint *TC = D->getTypeConstraint()) {
6117
6118 Error Err = Error::success();
6119 auto ToConceptRef = importChecked(Err, From: TC->getConceptReference());
6120 auto ToIDC = importChecked(Err, From: TC->getImmediatelyDeclaredConstraint());
6121 if (Err)
6122 return std::move(Err);
6123
6124 ToD->setTypeConstraint(CR: ToConceptRef, ImmediatelyDeclaredConstraint: ToIDC, ArgPackSubstIndex: TC->getArgPackSubstIndex());
6125 }
6126
6127 if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
6128 return Err;
6129
6130 return ToD;
6131}
6132
6133ExpectedDecl
6134ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
6135
6136 Error Err = Error::success();
6137 auto ToDeclName = importChecked(Err, From: D->getDeclName());
6138 auto ToLocation = importChecked(Err, From: D->getLocation());
6139 auto ToType = importChecked(Err, From: D->getType());
6140 auto ToTypeSourceInfo = importChecked(Err, From: D->getTypeSourceInfo());
6141 auto ToInnerLocStart = importChecked(Err, From: D->getInnerLocStart());
6142 if (Err)
6143 return std::move(Err);
6144
6145 NonTypeTemplateParmDecl *ToD = nullptr;
6146 if (GetImportedOrCreateDecl(ToD, FromD: D, args&: Importer.getToContext(),
6147 args: Importer.getToContext().getTranslationUnitDecl(),
6148 args&: ToInnerLocStart, args&: ToLocation, args: D->getDepth(),
6149 args: D->getPosition(),
6150 args: ToDeclName.getAsIdentifierInfo(), args&: ToType,
6151 args: D->isParameterPack(), args&: ToTypeSourceInfo))
6152 return ToD;
6153
6154 Err = importTemplateParameterDefaultArgument(D, ToD);
6155 if (Err)
6156 return Err;
6157
6158 return ToD;
6159}
6160
6161ExpectedDecl
6162ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
6163 bool IsCanonical = false;
6164 if (auto *CanonD = Importer.getFromContext()
6165 .findCanonicalTemplateTemplateParmDeclInternal(TTP: D);
6166 CanonD == D)
6167 IsCanonical = true;
6168
6169 // Import the name of this declaration.
6170 auto NameOrErr = import(From: D->getDeclName());
6171 if (!NameOrErr)
6172 return NameOrErr.takeError();
6173
6174 // Import the location of this declaration.
6175 ExpectedSLoc LocationOrErr = import(From: D->getLocation());
6176 if (!LocationOrErr)
6177 return LocationOrErr.takeError();
6178
6179 // Import template parameters.
6180 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6181 if (!TemplateParamsOrErr)
6182 return TemplateParamsOrErr.takeError();
6183
6184 TemplateTemplateParmDecl *ToD = nullptr;
6185 if (GetImportedOrCreateDecl(
6186 ToD, FromD: D, args&: Importer.getToContext(),
6187 args: Importer.getToContext().getTranslationUnitDecl(), args&: *LocationOrErr,
6188 args: D->getDepth(), args: D->getPosition(), args: D->isParameterPack(),
6189 args: (*NameOrErr).getAsIdentifierInfo(), args: D->templateParameterKind(),
6190 args: D->wasDeclaredWithTypename(), args&: *TemplateParamsOrErr))
6191 return ToD;
6192
6193 if (Error Err = importTemplateParameterDefaultArgument(D, ToD))
6194 return Err;
6195
6196 if (IsCanonical)
6197 return Importer.getToContext()
6198 .insertCanonicalTemplateTemplateParmDeclInternal(CanonTTP: ToD);
6199
6200 return ToD;
6201}
6202
6203// Returns the definition for a (forward) declaration of a TemplateDecl, if
6204// it has any definition in the redecl chain.
6205template <typename T> static auto getTemplateDefinition(T *D) -> T * {
6206 assert(D->getTemplatedDecl() && "Should be called on templates only");
6207 auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
6208 if (!ToTemplatedDef)
6209 return nullptr;
6210 auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
6211 return cast_or_null<T>(TemplateWithDef);
6212}
6213
6214ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
6215
6216 // Import the major distinguishing characteristics of this class template.
6217 DeclContext *DC, *LexicalDC;
6218 DeclarationName Name;
6219 SourceLocation Loc;
6220 NamedDecl *ToD;
6221 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6222 return std::move(Err);
6223 if (ToD)
6224 return ToD;
6225
6226 // Should check if a declaration is friend in a dependent context.
6227 // Such templates are not linked together in a declaration chain.
6228 // The ASTImporter strategy is to map existing forward declarations to
6229 // imported ones only if strictly necessary, otherwise import these as new
6230 // forward declarations. In case of the "dependent friend" declarations, new
6231 // declarations are created, but not linked in a declaration chain.
6232 auto IsDependentFriend = [](ClassTemplateDecl *TD) {
6233 return TD->getFriendObjectKind() != Decl::FOK_None &&
6234 TD->getLexicalDeclContext()->isDependentContext();
6235 };
6236 bool DependentFriend = IsDependentFriend(D);
6237
6238 ClassTemplateDecl *FoundByLookup = nullptr;
6239
6240 // We may already have a template of the same name; try to find and match it.
6241 if (!DC->isFunctionOrMethod()) {
6242 SmallVector<NamedDecl *, 4> ConflictingDecls;
6243 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6244 for (auto *FoundDecl : FoundDecls) {
6245 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary |
6246 Decl::IDNS_TagFriend))
6247 continue;
6248
6249 auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Val: FoundDecl);
6250 if (FoundTemplate) {
6251 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate, From: D))
6252 continue;
6253
6254 // FIXME: sufficient condition for 'IgnoreTemplateParmDepth'?
6255 bool IgnoreTemplateParmDepth =
6256 (FoundTemplate->getFriendObjectKind() != Decl::FOK_None) !=
6257 (D->getFriendObjectKind() != Decl::FOK_None);
6258 if (IsStructuralMatch(From: D, To: FoundTemplate, /*Complain=*/true,
6259 IgnoreTemplateParmDepth)) {
6260 if (DependentFriend || IsDependentFriend(FoundTemplate))
6261 continue;
6262
6263 ClassTemplateDecl *TemplateWithDef =
6264 getTemplateDefinition(D: FoundTemplate);
6265 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6266 return Importer.MapImported(From: D, To: TemplateWithDef);
6267 if (!FoundByLookup)
6268 FoundByLookup = FoundTemplate;
6269 // Search in all matches because there may be multiple decl chains,
6270 // see ASTTests test ImportExistingFriendClassTemplateDef.
6271 continue;
6272 }
6273 // When importing a friend, it is possible that multiple declarations
6274 // with same name can co-exist in specific cases (if a template contains
6275 // a friend template and has a specialization). For this case the
6276 // declarations should match, except that the "template depth" is
6277 // different. No linking of previous declaration is needed in this case.
6278 // FIXME: This condition may need refinement.
6279 if (D->getFriendObjectKind() != Decl::FOK_None &&
6280 FoundTemplate->getFriendObjectKind() != Decl::FOK_None &&
6281 D->getFriendObjectKind() != FoundTemplate->getFriendObjectKind() &&
6282 IsStructuralMatch(From: D, To: FoundTemplate, /*Complain=*/false,
6283 /*IgnoreTemplateParmDepth=*/true))
6284 continue;
6285
6286 ConflictingDecls.push_back(Elt: FoundDecl);
6287 }
6288 }
6289
6290 if (!ConflictingDecls.empty()) {
6291 ExpectedName NameOrErr = Importer.HandleNameConflict(
6292 Name, DC, IDNS: Decl::IDNS_Ordinary, Decls: ConflictingDecls.data(),
6293 NumDecls: ConflictingDecls.size());
6294 if (NameOrErr)
6295 Name = NameOrErr.get();
6296 else
6297 return NameOrErr.takeError();
6298 }
6299 }
6300
6301 CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
6302
6303 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6304 if (!TemplateParamsOrErr)
6305 return TemplateParamsOrErr.takeError();
6306
6307 // Create the declaration that is being templated.
6308 CXXRecordDecl *ToTemplated;
6309 if (Error Err = importInto(To&: ToTemplated, From: FromTemplated))
6310 return std::move(Err);
6311
6312 // Create the class template declaration itself.
6313 ClassTemplateDecl *D2;
6314 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc, args&: Name,
6315 args&: *TemplateParamsOrErr, args&: ToTemplated))
6316 return D2;
6317
6318 ToTemplated->setDescribedClassTemplate(D2);
6319
6320 D2->setAccess(D->getAccess());
6321 D2->setLexicalDeclContext(LexicalDC);
6322
6323 addDeclToContexts(FromD: D, ToD: D2);
6324 updateLookupTableForTemplateParameters(Params&: **TemplateParamsOrErr);
6325
6326 if (FoundByLookup) {
6327 auto *Recent =
6328 const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6329
6330 // It is possible that during the import of the class template definition
6331 // we start the import of a fwd friend decl of the very same class template
6332 // and we add the fwd friend decl to the lookup table. But the ToTemplated
6333 // had been created earlier and by that time the lookup could not find
6334 // anything existing, so it has no previous decl. Later, (still during the
6335 // import of the fwd friend decl) we start to import the definition again
6336 // and this time the lookup finds the previous fwd friend class template.
6337 // In this case we must set up the previous decl for the templated decl.
6338 if (!ToTemplated->getPreviousDecl()) {
6339 assert(FoundByLookup->getTemplatedDecl() &&
6340 "Found decl must have its templated decl set");
6341 CXXRecordDecl *PrevTemplated =
6342 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6343 if (ToTemplated != PrevTemplated)
6344 ToTemplated->setPreviousDecl(PrevTemplated);
6345 }
6346
6347 D2->setPreviousDecl(Recent);
6348 }
6349
6350 return D2;
6351}
6352
6353ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
6354 ClassTemplateSpecializationDecl *D) {
6355 ClassTemplateDecl *ClassTemplate;
6356 if (Error Err = importInto(To&: ClassTemplate, From: D->getSpecializedTemplate()))
6357 return std::move(Err);
6358
6359 // Import the context of this declaration.
6360 DeclContext *DC, *LexicalDC;
6361 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6362 return std::move(Err);
6363
6364 // Import template arguments.
6365 SmallVector<TemplateArgument, 2> TemplateArgs;
6366 if (Error Err =
6367 ImportTemplateArguments(FromArgs: D->getTemplateArgs().asArray(), ToArgs&: TemplateArgs))
6368 return std::move(Err);
6369 // Try to find an existing specialization with these template arguments and
6370 // template parameter list.
6371 void *InsertPos = nullptr;
6372 ClassTemplateSpecializationDecl *PrevDecl = nullptr;
6373 ClassTemplatePartialSpecializationDecl *PartialSpec =
6374 dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: D);
6375
6376 // Import template parameters.
6377 TemplateParameterList *ToTPList = nullptr;
6378
6379 if (PartialSpec) {
6380 auto ToTPListOrErr = import(From: PartialSpec->getTemplateParameters());
6381 if (!ToTPListOrErr)
6382 return ToTPListOrErr.takeError();
6383 ToTPList = *ToTPListOrErr;
6384 PrevDecl = ClassTemplate->findPartialSpecialization(Args: TemplateArgs,
6385 TPL: *ToTPListOrErr,
6386 InsertPos);
6387 } else
6388 PrevDecl = ClassTemplate->findSpecialization(Args: TemplateArgs, InsertPos);
6389
6390 if (PrevDecl) {
6391 if (IsStructuralMatch(From: D, To: PrevDecl)) {
6392 CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
6393 if (D->isThisDeclarationADefinition() && PrevDefinition) {
6394 Importer.MapImported(From: D, To: PrevDefinition);
6395 // Import those default field initializers which have been
6396 // instantiated in the "From" context, but not in the "To" context.
6397 for (auto *FromField : D->fields()) {
6398 auto ToOrErr = import(From: FromField);
6399 if (!ToOrErr)
6400 return ToOrErr.takeError();
6401 }
6402
6403 // Import those methods which have been instantiated in the
6404 // "From" context, but not in the "To" context.
6405 for (CXXMethodDecl *FromM : D->methods()) {
6406 auto ToOrErr = import(From: FromM);
6407 if (!ToOrErr)
6408 return ToOrErr.takeError();
6409 }
6410
6411 // TODO Import instantiated default arguments.
6412 // TODO Import instantiated exception specifications.
6413 //
6414 // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
6415 // what else could be fused during an AST merge.
6416 return PrevDefinition;
6417 }
6418 } else { // ODR violation.
6419 // FIXME HandleNameConflict
6420 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6421 }
6422 }
6423
6424 // Import the location of this declaration.
6425 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6426 if (!BeginLocOrErr)
6427 return BeginLocOrErr.takeError();
6428 ExpectedSLoc IdLocOrErr = import(From: D->getLocation());
6429 if (!IdLocOrErr)
6430 return IdLocOrErr.takeError();
6431
6432 // Import TemplateArgumentListInfo.
6433 TemplateArgumentListInfo ToTAInfo;
6434 if (const auto *ASTTemplateArgs = D->getTemplateArgsAsWritten()) {
6435 if (Error Err = ImportTemplateArgumentListInfo(From: *ASTTemplateArgs, Result&: ToTAInfo))
6436 return std::move(Err);
6437 }
6438
6439 // Create the specialization.
6440 ClassTemplateSpecializationDecl *D2 = nullptr;
6441 if (PartialSpec) {
6442 if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
6443 ToD&: D2, FromD: D, args&: Importer.getToContext(), args: D->getTagKind(), args&: DC, args&: *BeginLocOrErr,
6444 args&: *IdLocOrErr, args&: ToTPList, args&: ClassTemplate, args: ArrayRef(TemplateArgs),
6445 /*CanonInjectedTST=*/args: CanQualType(),
6446 args: cast_or_null<ClassTemplatePartialSpecializationDecl>(Val: PrevDecl)))
6447 return D2;
6448
6449 // Update InsertPos, because preceding import calls may have invalidated
6450 // it by adding new specializations.
6451 auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(Val: D2);
6452 if (!ClassTemplate->findPartialSpecialization(Args: TemplateArgs, TPL: ToTPList,
6453 InsertPos))
6454 // Add this partial specialization to the class template.
6455 ClassTemplate->AddPartialSpecialization(D: PartSpec2, InsertPos);
6456 if (Expected<ClassTemplatePartialSpecializationDecl *> ToInstOrErr =
6457 import(From: PartialSpec->getInstantiatedFromMember()))
6458 PartSpec2->setInstantiatedFromMember(*ToInstOrErr);
6459 else
6460 return ToInstOrErr.takeError();
6461
6462 updateLookupTableForTemplateParameters(Params&: *ToTPList);
6463 } else { // Not a partial specialization.
6464 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args: D->getTagKind(),
6465 args&: DC, args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: ClassTemplate,
6466 args&: TemplateArgs, args: D->hasStrictPackMatch(),
6467 args&: PrevDecl))
6468 return D2;
6469
6470 // Update InsertPos, because preceding import calls may have invalidated
6471 // it by adding new specializations.
6472 if (!ClassTemplate->findSpecialization(Args: TemplateArgs, InsertPos))
6473 // Add this specialization to the class template.
6474 ClassTemplate->AddSpecialization(D: D2, InsertPos);
6475 }
6476
6477 D2->setSpecializationKind(D->getSpecializationKind());
6478
6479 // Set the context of this specialization/instantiation.
6480 D2->setLexicalDeclContext(LexicalDC);
6481
6482 // Add to the DC only if it was an explicit specialization/instantiation.
6483 if (D2->isExplicitInstantiationOrSpecialization()) {
6484 LexicalDC->addDeclInternal(D: D2);
6485 }
6486
6487 if (auto BraceRangeOrErr = import(From: D->getBraceRange()))
6488 D2->setBraceRange(*BraceRangeOrErr);
6489 else
6490 return BraceRangeOrErr.takeError();
6491
6492 if (Error Err = ImportTemplateParameterLists(FromD: D, ToD: D2))
6493 return std::move(Err);
6494
6495 // Import the qualifier, if any.
6496 if (auto LocOrErr = import(From: D->getQualifierLoc()))
6497 D2->setQualifierInfo(*LocOrErr);
6498 else
6499 return LocOrErr.takeError();
6500
6501 if (D->getTemplateArgsAsWritten())
6502 D2->setTemplateArgsAsWritten(ToTAInfo);
6503
6504 if (auto LocOrErr = import(From: D->getTemplateKeywordLoc()))
6505 D2->setTemplateKeywordLoc(*LocOrErr);
6506 else
6507 return LocOrErr.takeError();
6508
6509 if (auto LocOrErr = import(From: D->getExternKeywordLoc()))
6510 D2->setExternKeywordLoc(*LocOrErr);
6511 else
6512 return LocOrErr.takeError();
6513
6514 if (D->getPointOfInstantiation().isValid()) {
6515 if (auto POIOrErr = import(From: D->getPointOfInstantiation()))
6516 D2->setPointOfInstantiation(*POIOrErr);
6517 else
6518 return POIOrErr.takeError();
6519 }
6520
6521 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
6522
6523 if (auto P = D->getInstantiatedFrom()) {
6524 if (auto *CTD = dyn_cast<ClassTemplateDecl *>(Val&: P)) {
6525 if (auto CTDorErr = import(From: CTD))
6526 D2->setInstantiationOf(*CTDorErr);
6527 } else {
6528 auto *CTPSD = cast<ClassTemplatePartialSpecializationDecl *>(Val&: P);
6529 auto CTPSDOrErr = import(From: CTPSD);
6530 if (!CTPSDOrErr)
6531 return CTPSDOrErr.takeError();
6532 const TemplateArgumentList &DArgs = D->getTemplateInstantiationArgs();
6533 SmallVector<TemplateArgument, 2> D2ArgsVec(DArgs.size());
6534 for (unsigned I = 0; I < DArgs.size(); ++I) {
6535 const TemplateArgument &DArg = DArgs[I];
6536 if (auto ArgOrErr = import(From: DArg))
6537 D2ArgsVec[I] = *ArgOrErr;
6538 else
6539 return ArgOrErr.takeError();
6540 }
6541 D2->setInstantiationOf(
6542 PartialSpec: *CTPSDOrErr,
6543 TemplateArgs: TemplateArgumentList::CreateCopy(Context&: Importer.getToContext(), Args: D2ArgsVec));
6544 }
6545 }
6546
6547 if (D->isCompleteDefinition())
6548 if (Error Err = ImportDefinition(From: D, To: D2))
6549 return std::move(Err);
6550
6551 return D2;
6552}
6553
6554ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
6555 // Import the major distinguishing characteristics of this variable template.
6556 DeclContext *DC, *LexicalDC;
6557 DeclarationName Name;
6558 SourceLocation Loc;
6559 NamedDecl *ToD;
6560 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6561 return std::move(Err);
6562 if (ToD)
6563 return ToD;
6564
6565 // We may already have a template of the same name; try to find and match it.
6566 assert(!DC->isFunctionOrMethod() &&
6567 "Variable templates cannot be declared at function scope");
6568
6569 SmallVector<NamedDecl *, 4> ConflictingDecls;
6570 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6571 VarTemplateDecl *FoundByLookup = nullptr;
6572 for (auto *FoundDecl : FoundDecls) {
6573 if (!FoundDecl->isInIdentifierNamespace(NS: Decl::IDNS_Ordinary))
6574 continue;
6575
6576 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Val: FoundDecl)) {
6577 // Use the templated decl, some linkage flags are set only there.
6578 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate->getTemplatedDecl(),
6579 From: D->getTemplatedDecl()))
6580 continue;
6581 if (IsStructuralMatch(From: D, To: FoundTemplate)) {
6582 // FIXME Check for ODR error if the two definitions have
6583 // different initializers?
6584 VarTemplateDecl *FoundDef = getTemplateDefinition(D: FoundTemplate);
6585 if (D->getDeclContext()->isRecord()) {
6586 assert(FoundTemplate->getDeclContext()->isRecord() &&
6587 "Member variable template imported as non-member, "
6588 "inconsistent imported AST?");
6589 if (FoundDef)
6590 return Importer.MapImported(From: D, To: FoundDef);
6591 if (!D->isThisDeclarationADefinition())
6592 return Importer.MapImported(From: D, To: FoundTemplate);
6593 } else {
6594 if (FoundDef && D->isThisDeclarationADefinition())
6595 return Importer.MapImported(From: D, To: FoundDef);
6596 }
6597 FoundByLookup = FoundTemplate;
6598 break;
6599 }
6600 ConflictingDecls.push_back(Elt: FoundDecl);
6601 }
6602 }
6603
6604 if (!ConflictingDecls.empty()) {
6605 ExpectedName NameOrErr = Importer.HandleNameConflict(
6606 Name, DC, IDNS: Decl::IDNS_Ordinary, Decls: ConflictingDecls.data(),
6607 NumDecls: ConflictingDecls.size());
6608 if (NameOrErr)
6609 Name = NameOrErr.get();
6610 else
6611 return NameOrErr.takeError();
6612 }
6613
6614 VarDecl *DTemplated = D->getTemplatedDecl();
6615
6616 // Import the type.
6617 // FIXME: Value not used?
6618 ExpectedType TypeOrErr = import(From: DTemplated->getType());
6619 if (!TypeOrErr)
6620 return TypeOrErr.takeError();
6621
6622 // Create the declaration that is being templated.
6623 VarDecl *ToTemplated;
6624 if (Error Err = importInto(To&: ToTemplated, From: DTemplated))
6625 return std::move(Err);
6626
6627 // Create the variable template declaration itself.
6628 auto TemplateParamsOrErr = import(From: D->getTemplateParameters());
6629 if (!TemplateParamsOrErr)
6630 return TemplateParamsOrErr.takeError();
6631
6632 VarTemplateDecl *ToVarTD;
6633 if (GetImportedOrCreateDecl(ToD&: ToVarTD, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc,
6634 args&: Name, args&: *TemplateParamsOrErr, args&: ToTemplated))
6635 return ToVarTD;
6636
6637 ToTemplated->setDescribedVarTemplate(ToVarTD);
6638
6639 ToVarTD->setAccess(D->getAccess());
6640 ToVarTD->setLexicalDeclContext(LexicalDC);
6641 LexicalDC->addDeclInternal(D: ToVarTD);
6642 if (DC != Importer.getToContext().getTranslationUnitDecl())
6643 updateLookupTableForTemplateParameters(Params&: **TemplateParamsOrErr);
6644
6645 if (FoundByLookup) {
6646 auto *Recent =
6647 const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6648 if (!ToTemplated->getPreviousDecl()) {
6649 auto *PrevTemplated =
6650 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6651 if (ToTemplated != PrevTemplated)
6652 ToTemplated->setPreviousDecl(PrevTemplated);
6653 }
6654 ToVarTD->setPreviousDecl(Recent);
6655 }
6656
6657 return ToVarTD;
6658}
6659
6660ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
6661 VarTemplateSpecializationDecl *D) {
6662 // A VarTemplateSpecializationDecl inherits from VarDecl, the import is done
6663 // in an analog way (but specialized for this case).
6664
6665 SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
6666 auto RedeclIt = Redecls.begin();
6667 // Import the first part of the decl chain. I.e. import all previous
6668 // declarations starting from the canonical decl.
6669 for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
6670 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
6671 if (!RedeclOrErr)
6672 return RedeclOrErr.takeError();
6673 }
6674 assert(*RedeclIt == D);
6675
6676 VarTemplateDecl *VarTemplate = nullptr;
6677 if (Error Err = importInto(To&: VarTemplate, From: D->getSpecializedTemplate()))
6678 return std::move(Err);
6679
6680 // Import the context of this declaration.
6681 DeclContext *DC, *LexicalDC;
6682 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
6683 return std::move(Err);
6684
6685 // Import the location of this declaration.
6686 ExpectedSLoc BeginLocOrErr = import(From: D->getBeginLoc());
6687 if (!BeginLocOrErr)
6688 return BeginLocOrErr.takeError();
6689
6690 auto IdLocOrErr = import(From: D->getLocation());
6691 if (!IdLocOrErr)
6692 return IdLocOrErr.takeError();
6693
6694 // Import template arguments.
6695 SmallVector<TemplateArgument, 2> TemplateArgs;
6696 if (Error Err =
6697 ImportTemplateArguments(FromArgs: D->getTemplateArgs().asArray(), ToArgs&: TemplateArgs))
6698 return std::move(Err);
6699
6700 // Try to find an existing specialization with these template arguments.
6701 void *InsertPos = nullptr;
6702 VarTemplateSpecializationDecl *FoundSpecialization =
6703 VarTemplate->findSpecialization(Args: TemplateArgs, InsertPos);
6704 if (FoundSpecialization) {
6705 if (IsStructuralMatch(From: D, To: FoundSpecialization)) {
6706 VarDecl *FoundDef = FoundSpecialization->getDefinition();
6707 if (D->getDeclContext()->isRecord()) {
6708 // In a record, it is allowed only to have one optional declaration and
6709 // one definition of the (static or constexpr) variable template.
6710 assert(
6711 FoundSpecialization->getDeclContext()->isRecord() &&
6712 "Member variable template specialization imported as non-member, "
6713 "inconsistent imported AST?");
6714 if (FoundDef)
6715 return Importer.MapImported(From: D, To: FoundDef);
6716 if (!D->isThisDeclarationADefinition())
6717 return Importer.MapImported(From: D, To: FoundSpecialization);
6718 } else {
6719 // If definition is imported and there is already one, map to it.
6720 // Otherwise create a new variable and link it to the existing.
6721 if (FoundDef && D->isThisDeclarationADefinition())
6722 return Importer.MapImported(From: D, To: FoundDef);
6723 }
6724 } else {
6725 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6726 }
6727 }
6728
6729 VarTemplateSpecializationDecl *D2 = nullptr;
6730
6731 TemplateArgumentListInfo ToTAInfo;
6732 if (const auto *Args = D->getTemplateArgsAsWritten()) {
6733 if (Error Err = ImportTemplateArgumentListInfo(From: *Args, Result&: ToTAInfo))
6734 return std::move(Err);
6735 }
6736
6737 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
6738 // Create a new specialization.
6739 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(Val: D)) {
6740 auto ToTPListOrErr = import(From: FromPartial->getTemplateParameters());
6741 if (!ToTPListOrErr)
6742 return ToTPListOrErr.takeError();
6743
6744 PartVarSpecDecl *ToPartial;
6745 if (GetImportedOrCreateDecl(ToD&: ToPartial, FromD: D, args&: Importer.getToContext(), args&: DC,
6746 args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: *ToTPListOrErr,
6747 args&: VarTemplate, args: QualType(), args: nullptr,
6748 args: D->getStorageClass(), args&: TemplateArgs))
6749 return ToPartial;
6750
6751 if (Expected<PartVarSpecDecl *> ToInstOrErr =
6752 import(From: FromPartial->getInstantiatedFromMember()))
6753 ToPartial->setInstantiatedFromMember(*ToInstOrErr);
6754 else
6755 return ToInstOrErr.takeError();
6756
6757 if (FromPartial->isMemberSpecialization())
6758 ToPartial->setMemberSpecialization();
6759
6760 D2 = ToPartial;
6761
6762 // FIXME: Use this update if VarTemplatePartialSpecializationDecl is fixed
6763 // to adopt template parameters.
6764 // updateLookupTableForTemplateParameters(**ToTPListOrErr);
6765 } else { // Full specialization
6766 if (GetImportedOrCreateDecl(ToD&: D2, FromD: D, args&: Importer.getToContext(), args&: DC,
6767 args&: *BeginLocOrErr, args&: *IdLocOrErr, args&: VarTemplate,
6768 args: QualType(), args: nullptr, args: D->getStorageClass(),
6769 args&: TemplateArgs))
6770 return D2;
6771 }
6772
6773 // Update InsertPos, because preceding import calls may have invalidated
6774 // it by adding new specializations.
6775 if (!VarTemplate->findSpecialization(Args: TemplateArgs, InsertPos))
6776 VarTemplate->AddSpecialization(D: D2, InsertPos);
6777
6778 QualType T;
6779 if (Error Err = importInto(To&: T, From: D->getType()))
6780 return std::move(Err);
6781 D2->setType(T);
6782
6783 auto TInfoOrErr = import(From: D->getTypeSourceInfo());
6784 if (!TInfoOrErr)
6785 return TInfoOrErr.takeError();
6786 D2->setTypeSourceInfo(*TInfoOrErr);
6787
6788 if (D->getPointOfInstantiation().isValid()) {
6789 if (ExpectedSLoc POIOrErr = import(From: D->getPointOfInstantiation()))
6790 D2->setPointOfInstantiation(*POIOrErr);
6791 else
6792 return POIOrErr.takeError();
6793 }
6794
6795 D2->setSpecializationKind(D->getSpecializationKind());
6796
6797 if (D->getTemplateArgsAsWritten())
6798 D2->setTemplateArgsAsWritten(ToTAInfo);
6799
6800 if (auto LocOrErr = import(From: D->getQualifierLoc()))
6801 D2->setQualifierInfo(*LocOrErr);
6802 else
6803 return LocOrErr.takeError();
6804
6805 if (D->isConstexpr())
6806 D2->setConstexpr(true);
6807
6808 D2->setAccess(D->getAccess());
6809
6810 if (Error Err = ImportInitializer(From: D, To: D2))
6811 return std::move(Err);
6812
6813 if (FoundSpecialization)
6814 D2->setPreviousDecl(FoundSpecialization->getMostRecentDecl());
6815
6816 addDeclToContexts(FromD: D, ToD: D2);
6817
6818 // Import the rest of the chain. I.e. import all subsequent declarations.
6819 for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
6820 ExpectedDecl RedeclOrErr = import(From: *RedeclIt);
6821 if (!RedeclOrErr)
6822 return RedeclOrErr.takeError();
6823 }
6824
6825 return D2;
6826}
6827
6828ExpectedDecl
6829ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
6830 DeclContext *DC, *LexicalDC;
6831 DeclarationName Name;
6832 SourceLocation Loc;
6833 NamedDecl *ToD;
6834
6835 if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
6836 return std::move(Err);
6837
6838 if (ToD)
6839 return ToD;
6840
6841 const FunctionTemplateDecl *FoundByLookup = nullptr;
6842
6843 // Try to find a function in our own ("to") context with the same name, same
6844 // type, and in the same context as the function we're importing.
6845 // FIXME Split this into a separate function.
6846 if (!LexicalDC->isFunctionOrMethod()) {
6847 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
6848 auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
6849 for (auto *FoundDecl : FoundDecls) {
6850 if (!FoundDecl->isInIdentifierNamespace(NS: IDNS))
6851 continue;
6852
6853 if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(Val: FoundDecl)) {
6854 if (!hasSameVisibilityContextAndLinkage(Found: FoundTemplate, From: D))
6855 continue;
6856 if (IsStructuralMatch(From: D, To: FoundTemplate)) {
6857 FunctionTemplateDecl *TemplateWithDef =
6858 getTemplateDefinition(D: FoundTemplate);
6859 if (D->isThisDeclarationADefinition() && TemplateWithDef)
6860 return Importer.MapImported(From: D, To: TemplateWithDef);
6861
6862 FoundByLookup = FoundTemplate;
6863 break;
6864 // TODO: handle conflicting names
6865 }
6866 }
6867 }
6868 }
6869
6870 auto ParamsOrErr = import(From: D->getTemplateParameters());
6871 if (!ParamsOrErr)
6872 return ParamsOrErr.takeError();
6873 TemplateParameterList *Params = *ParamsOrErr;
6874
6875 FunctionDecl *TemplatedFD;
6876 if (Error Err = importInto(To&: TemplatedFD, From: D->getTemplatedDecl()))
6877 return std::move(Err);
6878
6879 // At creation of the template the template parameters are "adopted"
6880 // (DeclContext is changed). After this possible change the lookup table
6881 // must be updated.
6882 // At deduction guides the DeclContext of the template parameters may be
6883 // different from what we would expect, it may be the class template, or a
6884 // probably different CXXDeductionGuideDecl. This may come from the fact that
6885 // the template parameter objects may be shared between deduction guides or
6886 // the class template, and at creation of multiple FunctionTemplateDecl
6887 // objects (for deduction guides) the same parameters are re-used. The
6888 // "adoption" happens multiple times with different parent, even recursively
6889 // for TemplateTemplateParmDecl. The same happens at import when the
6890 // FunctionTemplateDecl objects are created, but in different order.
6891 // In this way the DeclContext of these template parameters is not necessarily
6892 // the same as in the "from" context.
6893 SmallVector<DeclContext *, 2> OldParamDC;
6894 OldParamDC.reserve(N: Params->size());
6895 llvm::transform(Range&: *Params, d_first: std::back_inserter(x&: OldParamDC),
6896 F: [](NamedDecl *ND) { return ND->getDeclContext(); });
6897
6898 FunctionTemplateDecl *ToFunc;
6899 if (GetImportedOrCreateDecl(ToD&: ToFunc, FromD: D, args&: Importer.getToContext(), args&: DC, args&: Loc, args&: Name,
6900 args&: Params, args&: TemplatedFD))
6901 return ToFunc;
6902
6903 // Fail if TemplatedFD is already part of a template.
6904 // The template should have been found by structural equivalence check before,
6905 // or ToFunc should be already imported.
6906 // If not, there is AST incompatibility that can be caused by previous import
6907 // errors. (NameConflict is not exact here.)
6908 if (TemplatedFD->getDescribedTemplate())
6909 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
6910
6911 TemplatedFD->setDescribedFunctionTemplate(ToFunc);
6912
6913 ToFunc->setAccess(D->getAccess());
6914 ToFunc->setLexicalDeclContext(LexicalDC);
6915 addDeclToContexts(FromD: D, ToD: ToFunc);
6916
6917 ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
6918 if (LT && !OldParamDC.empty()) {
6919 for (unsigned int I = 0; I < OldParamDC.size(); ++I)
6920 LT->updateForced(ND: Params->getParam(Idx: I), OldDC: OldParamDC[I]);
6921 }
6922
6923 if (FoundByLookup) {
6924 auto *Recent =
6925 const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
6926 if (!TemplatedFD->getPreviousDecl()) {
6927 assert(FoundByLookup->getTemplatedDecl() &&
6928 "Found decl must have its templated decl set");
6929 auto *PrevTemplated =
6930 FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
6931 if (TemplatedFD != PrevTemplated)
6932 TemplatedFD->setPreviousDecl(PrevTemplated);
6933 }
6934 ToFunc->setPreviousDecl(Recent);
6935 }
6936
6937 return ToFunc;
6938}
6939
6940ExpectedDecl ASTNodeImporter::VisitConceptDecl(ConceptDecl *D) {
6941 DeclContext *DC, *LexicalDC;
6942 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6943 auto LocationOrErr = importChecked(Err, From: D->getLocation());
6944 auto NameDeclOrErr = importChecked(Err, From: D->getDeclName());
6945 auto ToTemplateParameters = importChecked(Err, From: D->getTemplateParameters());
6946 auto ConstraintExpr = importChecked(Err, From: D->getConstraintExpr());
6947 if (Err)
6948 return std::move(Err);
6949
6950 ConceptDecl *To;
6951 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: LocationOrErr,
6952 args&: NameDeclOrErr, args&: ToTemplateParameters,
6953 args&: ConstraintExpr))
6954 return To;
6955 To->setLexicalDeclContext(LexicalDC);
6956 LexicalDC->addDeclInternal(D: To);
6957 return To;
6958}
6959
6960ExpectedDecl
6961ASTNodeImporter::VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D) {
6962 DeclContext *DC, *LexicalDC;
6963 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6964 auto RequiresLoc = importChecked(Err, From: D->getLocation());
6965 if (Err)
6966 return std::move(Err);
6967
6968 RequiresExprBodyDecl *To;
6969 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: RequiresLoc))
6970 return To;
6971 To->setLexicalDeclContext(LexicalDC);
6972 LexicalDC->addDeclInternal(D: To);
6973 return To;
6974}
6975
6976ExpectedDecl ASTNodeImporter::VisitImplicitConceptSpecializationDecl(
6977 ImplicitConceptSpecializationDecl *D) {
6978 DeclContext *DC, *LexicalDC;
6979 Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC);
6980 auto ToSL = importChecked(Err, From: D->getLocation());
6981 if (Err)
6982 return std::move(Err);
6983
6984 SmallVector<TemplateArgument, 2> ToArgs(D->getTemplateArguments().size());
6985 if (Error Err = ImportTemplateArguments(FromArgs: D->getTemplateArguments(), ToArgs))
6986 return std::move(Err);
6987
6988 ImplicitConceptSpecializationDecl *To;
6989 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Importer.getToContext(), args&: DC, args&: ToSL, args&: ToArgs))
6990 return To;
6991 To->setLexicalDeclContext(LexicalDC);
6992 LexicalDC->addDeclInternal(D: To);
6993 return To;
6994}
6995
6996//----------------------------------------------------------------------------
6997// Import Statements
6998//----------------------------------------------------------------------------
6999
7000ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
7001 Importer.FromDiag(Loc: S->getBeginLoc(), DiagID: diag::err_unsupported_ast_node)
7002 << S->getStmtClassName();
7003 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7004}
7005
7006
7007ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
7008 if (Importer.returnWithErrorInTest())
7009 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7010 SmallVector<IdentifierInfo *, 4> Names;
7011 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
7012 IdentifierInfo *ToII = Importer.Import(FromId: S->getOutputIdentifier(i: I));
7013 // ToII is nullptr when no symbolic name is given for output operand
7014 // see ParseStmtAsm::ParseAsmOperandsOpt
7015 Names.push_back(Elt: ToII);
7016 }
7017
7018 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
7019 IdentifierInfo *ToII = Importer.Import(FromId: S->getInputIdentifier(i: I));
7020 // ToII is nullptr when no symbolic name is given for input operand
7021 // see ParseStmtAsm::ParseAsmOperandsOpt
7022 Names.push_back(Elt: ToII);
7023 }
7024
7025 SmallVector<Expr *, 4> Clobbers;
7026 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
7027 if (auto ClobberOrErr = import(From: S->getClobberExpr(i: I)))
7028 Clobbers.push_back(Elt: *ClobberOrErr);
7029 else
7030 return ClobberOrErr.takeError();
7031
7032 }
7033
7034 SmallVector<Expr *, 4> Constraints;
7035 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
7036 if (auto OutputOrErr = import(From: S->getOutputConstraintExpr(i: I)))
7037 Constraints.push_back(Elt: *OutputOrErr);
7038 else
7039 return OutputOrErr.takeError();
7040 }
7041
7042 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
7043 if (auto InputOrErr = import(From: S->getInputConstraintExpr(i: I)))
7044 Constraints.push_back(Elt: *InputOrErr);
7045 else
7046 return InputOrErr.takeError();
7047 }
7048
7049 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
7050 S->getNumLabels());
7051 if (Error Err = ImportContainerChecked(InContainer: S->outputs(), OutContainer&: Exprs))
7052 return std::move(Err);
7053
7054 if (Error Err =
7055 ImportArrayChecked(InContainer: S->inputs(), Obegin: Exprs.begin() + S->getNumOutputs()))
7056 return std::move(Err);
7057
7058 if (Error Err = ImportArrayChecked(
7059 InContainer: S->labels(), Obegin: Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
7060 return std::move(Err);
7061
7062 ExpectedSLoc AsmLocOrErr = import(From: S->getAsmLoc());
7063 if (!AsmLocOrErr)
7064 return AsmLocOrErr.takeError();
7065 auto AsmStrOrErr = import(From: S->getAsmStringExpr());
7066 if (!AsmStrOrErr)
7067 return AsmStrOrErr.takeError();
7068 ExpectedSLoc RParenLocOrErr = import(From: S->getRParenLoc());
7069 if (!RParenLocOrErr)
7070 return RParenLocOrErr.takeError();
7071
7072 return new (Importer.getToContext()) GCCAsmStmt(
7073 Importer.getToContext(),
7074 *AsmLocOrErr,
7075 S->isSimple(),
7076 S->isVolatile(),
7077 S->getNumOutputs(),
7078 S->getNumInputs(),
7079 Names.data(),
7080 Constraints.data(),
7081 Exprs.data(),
7082 *AsmStrOrErr,
7083 S->getNumClobbers(),
7084 Clobbers.data(),
7085 S->getNumLabels(),
7086 *RParenLocOrErr);
7087}
7088
7089ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
7090
7091 Error Err = Error::success();
7092 auto ToDG = importChecked(Err, From: S->getDeclGroup());
7093 auto ToBeginLoc = importChecked(Err, From: S->getBeginLoc());
7094 auto ToEndLoc = importChecked(Err, From: S->getEndLoc());
7095 if (Err)
7096 return std::move(Err);
7097 return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
7098}
7099
7100ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
7101 ExpectedSLoc ToSemiLocOrErr = import(From: S->getSemiLoc());
7102 if (!ToSemiLocOrErr)
7103 return ToSemiLocOrErr.takeError();
7104 return new (Importer.getToContext()) NullStmt(
7105 *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
7106}
7107
7108ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
7109 SmallVector<Stmt *, 8> ToStmts(S->size());
7110
7111 if (Error Err = ImportContainerChecked(InContainer: S->body(), OutContainer&: ToStmts))
7112 return std::move(Err);
7113
7114 ExpectedSLoc ToLBracLocOrErr = import(From: S->getLBracLoc());
7115 if (!ToLBracLocOrErr)
7116 return ToLBracLocOrErr.takeError();
7117
7118 ExpectedSLoc ToRBracLocOrErr = import(From: S->getRBracLoc());
7119 if (!ToRBracLocOrErr)
7120 return ToRBracLocOrErr.takeError();
7121
7122 FPOptionsOverride FPO =
7123 S->hasStoredFPFeatures() ? S->getStoredFPFeatures() : FPOptionsOverride();
7124 return CompoundStmt::Create(C: Importer.getToContext(), Stmts: ToStmts, FPFeatures: FPO,
7125 LB: *ToLBracLocOrErr, RB: *ToRBracLocOrErr);
7126}
7127
7128ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
7129
7130 Error Err = Error::success();
7131 auto ToLHS = importChecked(Err, From: S->getLHS());
7132 auto ToRHS = importChecked(Err, From: S->getRHS());
7133 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7134 auto ToCaseLoc = importChecked(Err, From: S->getCaseLoc());
7135 auto ToEllipsisLoc = importChecked(Err, From: S->getEllipsisLoc());
7136 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7137 if (Err)
7138 return std::move(Err);
7139
7140 auto *ToStmt = CaseStmt::Create(Ctx: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS,
7141 caseLoc: ToCaseLoc, ellipsisLoc: ToEllipsisLoc, colonLoc: ToColonLoc);
7142 ToStmt->setSubStmt(ToSubStmt);
7143
7144 return ToStmt;
7145}
7146
7147ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
7148
7149 Error Err = Error::success();
7150 auto ToDefaultLoc = importChecked(Err, From: S->getDefaultLoc());
7151 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7152 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7153 if (Err)
7154 return std::move(Err);
7155
7156 return new (Importer.getToContext()) DefaultStmt(
7157 ToDefaultLoc, ToColonLoc, ToSubStmt);
7158}
7159
7160ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
7161
7162 Error Err = Error::success();
7163 auto ToIdentLoc = importChecked(Err, From: S->getIdentLoc());
7164 auto ToLabelDecl = importChecked(Err, From: S->getDecl());
7165 auto ToSubStmt = importChecked(Err, From: S->getSubStmt());
7166 if (Err)
7167 return std::move(Err);
7168
7169 return new (Importer.getToContext()) LabelStmt(
7170 ToIdentLoc, ToLabelDecl, ToSubStmt);
7171}
7172
7173ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
7174 ExpectedSLoc ToAttrLocOrErr = import(From: S->getAttrLoc());
7175 if (!ToAttrLocOrErr)
7176 return ToAttrLocOrErr.takeError();
7177 ArrayRef<const Attr*> FromAttrs(S->getAttrs());
7178 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
7179 if (Error Err = ImportContainerChecked(InContainer: FromAttrs, OutContainer&: ToAttrs))
7180 return std::move(Err);
7181 ExpectedStmt ToSubStmtOrErr = import(From: S->getSubStmt());
7182 if (!ToSubStmtOrErr)
7183 return ToSubStmtOrErr.takeError();
7184
7185 return AttributedStmt::Create(
7186 C: Importer.getToContext(), Loc: *ToAttrLocOrErr, Attrs: ToAttrs, SubStmt: *ToSubStmtOrErr);
7187}
7188
7189ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
7190
7191 Error Err = Error::success();
7192 auto ToIfLoc = importChecked(Err, From: S->getIfLoc());
7193 auto ToInit = importChecked(Err, From: S->getInit());
7194 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7195 auto ToCond = importChecked(Err, From: S->getCond());
7196 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7197 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7198 auto ToThen = importChecked(Err, From: S->getThen());
7199 auto ToElseLoc = importChecked(Err, From: S->getElseLoc());
7200 auto ToElse = importChecked(Err, From: S->getElse());
7201 if (Err)
7202 return std::move(Err);
7203
7204 return IfStmt::Create(Ctx: Importer.getToContext(), IL: ToIfLoc, Kind: S->getStatementKind(),
7205 Init: ToInit, Var: ToConditionVariable, Cond: ToCond, LPL: ToLParenLoc,
7206 RPL: ToRParenLoc, Then: ToThen, EL: ToElseLoc, Else: ToElse);
7207}
7208
7209ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
7210
7211 Error Err = Error::success();
7212 auto ToInit = importChecked(Err, From: S->getInit());
7213 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7214 auto ToCond = importChecked(Err, From: S->getCond());
7215 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7216 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7217 auto ToBody = importChecked(Err, From: S->getBody());
7218 auto ToSwitchLoc = importChecked(Err, From: S->getSwitchLoc());
7219 if (Err)
7220 return std::move(Err);
7221
7222 auto *ToStmt =
7223 SwitchStmt::Create(Ctx: Importer.getToContext(), Init: ToInit, Var: ToConditionVariable,
7224 Cond: ToCond, LParenLoc: ToLParenLoc, RParenLoc: ToRParenLoc);
7225 ToStmt->setBody(ToBody);
7226 ToStmt->setSwitchLoc(ToSwitchLoc);
7227
7228 // Now we have to re-chain the cases.
7229 SwitchCase *LastChainedSwitchCase = nullptr;
7230 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
7231 SC = SC->getNextSwitchCase()) {
7232 Expected<SwitchCase *> ToSCOrErr = import(From: SC);
7233 if (!ToSCOrErr)
7234 return ToSCOrErr.takeError();
7235 if (LastChainedSwitchCase)
7236 LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
7237 else
7238 ToStmt->setSwitchCaseList(*ToSCOrErr);
7239 LastChainedSwitchCase = *ToSCOrErr;
7240 }
7241
7242 return ToStmt;
7243}
7244
7245ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
7246
7247 Error Err = Error::success();
7248 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7249 auto ToCond = importChecked(Err, From: S->getCond());
7250 auto ToBody = importChecked(Err, From: S->getBody());
7251 auto ToWhileLoc = importChecked(Err, From: S->getWhileLoc());
7252 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7253 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7254 if (Err)
7255 return std::move(Err);
7256
7257 return WhileStmt::Create(Ctx: Importer.getToContext(), Var: ToConditionVariable, Cond: ToCond,
7258 Body: ToBody, WL: ToWhileLoc, LParenLoc: ToLParenLoc, RParenLoc: ToRParenLoc);
7259}
7260
7261ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
7262
7263 Error Err = Error::success();
7264 auto ToBody = importChecked(Err, From: S->getBody());
7265 auto ToCond = importChecked(Err, From: S->getCond());
7266 auto ToDoLoc = importChecked(Err, From: S->getDoLoc());
7267 auto ToWhileLoc = importChecked(Err, From: S->getWhileLoc());
7268 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7269 if (Err)
7270 return std::move(Err);
7271
7272 return new (Importer.getToContext()) DoStmt(
7273 ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
7274}
7275
7276ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
7277
7278 Error Err = Error::success();
7279 auto ToInit = importChecked(Err, From: S->getInit());
7280 auto ToCond = importChecked(Err, From: S->getCond());
7281 auto ToConditionVariable = importChecked(Err, From: S->getConditionVariable());
7282 auto ToInc = importChecked(Err, From: S->getInc());
7283 auto ToBody = importChecked(Err, From: S->getBody());
7284 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7285 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7286 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7287 if (Err)
7288 return std::move(Err);
7289
7290 return new (Importer.getToContext()) ForStmt(
7291 Importer.getToContext(),
7292 ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
7293 ToRParenLoc);
7294}
7295
7296ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
7297
7298 Error Err = Error::success();
7299 auto ToLabel = importChecked(Err, From: S->getLabel());
7300 auto ToGotoLoc = importChecked(Err, From: S->getGotoLoc());
7301 auto ToLabelLoc = importChecked(Err, From: S->getLabelLoc());
7302 if (Err)
7303 return std::move(Err);
7304
7305 return new (Importer.getToContext()) GotoStmt(
7306 ToLabel, ToGotoLoc, ToLabelLoc);
7307}
7308
7309ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
7310
7311 Error Err = Error::success();
7312 auto ToGotoLoc = importChecked(Err, From: S->getGotoLoc());
7313 auto ToStarLoc = importChecked(Err, From: S->getStarLoc());
7314 auto ToTarget = importChecked(Err, From: S->getTarget());
7315 if (Err)
7316 return std::move(Err);
7317
7318 return new (Importer.getToContext()) IndirectGotoStmt(
7319 ToGotoLoc, ToStarLoc, ToTarget);
7320}
7321
7322template <typename StmtClass>
7323static ExpectedStmt ImportLoopControlStmt(ASTNodeImporter &NodeImporter,
7324 ASTImporter &Importer, StmtClass *S) {
7325 Error Err = Error::success();
7326 auto ToLoc = NodeImporter.importChecked(Err, S->getKwLoc());
7327 auto ToLabelLoc = S->hasLabelTarget()
7328 ? NodeImporter.importChecked(Err, S->getLabelLoc())
7329 : SourceLocation();
7330 auto ToDecl = S->hasLabelTarget()
7331 ? NodeImporter.importChecked(Err, S->getLabelDecl())
7332 : nullptr;
7333 if (Err)
7334 return std::move(Err);
7335 return new (Importer.getToContext()) StmtClass(ToLoc, ToLabelLoc, ToDecl);
7336}
7337
7338ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
7339 return ImportLoopControlStmt(NodeImporter&: *this, Importer, S);
7340}
7341
7342ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
7343 return ImportLoopControlStmt(NodeImporter&: *this, Importer, S);
7344}
7345
7346ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
7347
7348 Error Err = Error::success();
7349 auto ToReturnLoc = importChecked(Err, From: S->getReturnLoc());
7350 auto ToRetValue = importChecked(Err, From: S->getRetValue());
7351 auto ToNRVOCandidate = importChecked(Err, From: S->getNRVOCandidate());
7352 if (Err)
7353 return std::move(Err);
7354
7355 return ReturnStmt::Create(Ctx: Importer.getToContext(), RL: ToReturnLoc, E: ToRetValue,
7356 NRVOCandidate: ToNRVOCandidate);
7357}
7358
7359ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
7360
7361 Error Err = Error::success();
7362 auto ToCatchLoc = importChecked(Err, From: S->getCatchLoc());
7363 auto ToExceptionDecl = importChecked(Err, From: S->getExceptionDecl());
7364 auto ToHandlerBlock = importChecked(Err, From: S->getHandlerBlock());
7365 if (Err)
7366 return std::move(Err);
7367
7368 return new (Importer.getToContext()) CXXCatchStmt (
7369 ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
7370}
7371
7372ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
7373 ExpectedSLoc ToTryLocOrErr = import(From: S->getTryLoc());
7374 if (!ToTryLocOrErr)
7375 return ToTryLocOrErr.takeError();
7376
7377 ExpectedStmt ToTryBlockOrErr = import(From: S->getTryBlock());
7378 if (!ToTryBlockOrErr)
7379 return ToTryBlockOrErr.takeError();
7380
7381 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
7382 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
7383 CXXCatchStmt *FromHandler = S->getHandler(i: HI);
7384 if (auto ToHandlerOrErr = import(From: FromHandler))
7385 ToHandlers[HI] = *ToHandlerOrErr;
7386 else
7387 return ToHandlerOrErr.takeError();
7388 }
7389
7390 return CXXTryStmt::Create(C: Importer.getToContext(), tryLoc: *ToTryLocOrErr,
7391 tryBlock: cast<CompoundStmt>(Val: *ToTryBlockOrErr), handlers: ToHandlers);
7392}
7393
7394ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
7395
7396 Error Err = Error::success();
7397 auto ToInit = importChecked(Err, From: S->getInit());
7398 auto ToRangeStmt = importChecked(Err, From: S->getRangeStmt());
7399 auto ToBeginStmt = importChecked(Err, From: S->getBeginStmt());
7400 auto ToEndStmt = importChecked(Err, From: S->getEndStmt());
7401 auto ToCond = importChecked(Err, From: S->getCond());
7402 auto ToInc = importChecked(Err, From: S->getInc());
7403 auto ToLoopVarStmt = importChecked(Err, From: S->getLoopVarStmt());
7404 auto ToBody = importChecked(Err, From: S->getBody());
7405 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7406 auto ToCoawaitLoc = importChecked(Err, From: S->getCoawaitLoc());
7407 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7408 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7409 if (Err)
7410 return std::move(Err);
7411
7412 return new (Importer.getToContext()) CXXForRangeStmt(
7413 ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
7414 ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
7415}
7416
7417ExpectedStmt
7418ASTNodeImporter::VisitCXXExpansionStmtPattern(CXXExpansionStmtPattern *S) {
7419 Error Err = Error::success();
7420 auto ToESD = importChecked(Err, From: S->getDecl());
7421 auto ToInit = importChecked(Err, From: S->getInit());
7422 auto ToExpansionVar = importChecked(Err, From: S->getExpansionVarStmt());
7423 auto ToLParenLoc = importChecked(Err, From: S->getLParenLoc());
7424 auto ToColonLoc = importChecked(Err, From: S->getColonLoc());
7425 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7426 if (Err)
7427 return std::move(Err);
7428
7429 switch (S->getKind()) {
7430 case CXXExpansionStmtPattern::ExpansionStmtKind::Enumerating:
7431 return CXXExpansionStmtPattern::CreateEnumerating(
7432 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar, LParenLoc: ToLParenLoc,
7433 ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7434
7435 case CXXExpansionStmtPattern::ExpansionStmtKind::Iterating: {
7436 auto ToRange = importChecked(Err, From: S->getRangeVarStmt());
7437 auto ToBegin = importChecked(Err, From: S->getBeginVarStmt());
7438 auto ToIter = importChecked(Err, From: S->getIterVarStmt());
7439 if (Err)
7440 return std::move(Err);
7441
7442 return CXXExpansionStmtPattern::CreateIterating(
7443 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar, Range: ToRange,
7444 Begin: ToBegin, Iter: ToIter, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7445 }
7446
7447 case CXXExpansionStmtPattern::ExpansionStmtKind::Destructuring: {
7448 auto ToDecompositionDeclStmt =
7449 importChecked(Err, From: S->getDecompositionDeclStmt());
7450 if (Err)
7451 return std::move(Err);
7452
7453 return CXXExpansionStmtPattern::CreateDestructuring(
7454 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar,
7455 DecompositionDeclStmt: ToDecompositionDeclStmt, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7456 }
7457
7458 case CXXExpansionStmtPattern::ExpansionStmtKind::Dependent: {
7459 auto ToExpansionInitializer =
7460 importChecked(Err, From: S->getExpansionInitializer());
7461 if (Err)
7462 return std::move(Err);
7463 return CXXExpansionStmtPattern::CreateDependent(
7464 Context&: Importer.getToContext(), ESD: ToESD, Init: ToInit, ExpansionVar: ToExpansionVar,
7465 ExpansionInitializer: ToExpansionInitializer, LParenLoc: ToLParenLoc, ColonLoc: ToColonLoc, RParenLoc: ToRParenLoc);
7466 }
7467 }
7468
7469 llvm_unreachable("invalid pattern kind");
7470}
7471
7472ExpectedStmt ASTNodeImporter::VisitCXXExpansionStmtInstantiation(
7473 CXXExpansionStmtInstantiation *S) {
7474 Error Err = Error::success();
7475 SmallVector<Stmt *> ToInstantiations;
7476 SmallVector<Stmt *> ToSharedStmts;
7477 auto ToParent = importChecked(Err, From: S->getParent());
7478 for (Stmt *FromInst : S->getInstantiations())
7479 ToInstantiations.push_back(Elt: importChecked(Err, From: FromInst));
7480 for (Stmt *FromShared : S->getPreambleStmts())
7481 ToSharedStmts.push_back(Elt: importChecked(Err, From: FromShared));
7482
7483 if (Err)
7484 return std::move(Err);
7485
7486 return CXXExpansionStmtInstantiation::Create(
7487 C&: Importer.getToContext(), Parent: ToParent, Instantiations: ToInstantiations, PreambleStmts: ToSharedStmts,
7488 ShouldApplyLifetimeExtensionToPreamble: S->shouldApplyLifetimeExtensionToPreamble());
7489}
7490
7491ExpectedStmt
7492ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
7493 Error Err = Error::success();
7494 auto ToElement = importChecked(Err, From: S->getElement());
7495 auto ToCollection = importChecked(Err, From: S->getCollection());
7496 auto ToBody = importChecked(Err, From: S->getBody());
7497 auto ToForLoc = importChecked(Err, From: S->getForLoc());
7498 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7499 if (Err)
7500 return std::move(Err);
7501
7502 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
7503 ToCollection,
7504 ToBody,
7505 ToForLoc,
7506 ToRParenLoc);
7507}
7508
7509ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
7510
7511 Error Err = Error::success();
7512 auto ToAtCatchLoc = importChecked(Err, From: S->getAtCatchLoc());
7513 auto ToRParenLoc = importChecked(Err, From: S->getRParenLoc());
7514 auto ToCatchParamDecl = importChecked(Err, From: S->getCatchParamDecl());
7515 auto ToCatchBody = importChecked(Err, From: S->getCatchBody());
7516 if (Err)
7517 return std::move(Err);
7518
7519 return new (Importer.getToContext()) ObjCAtCatchStmt (
7520 ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
7521}
7522
7523ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
7524 ExpectedSLoc ToAtFinallyLocOrErr = import(From: S->getAtFinallyLoc());
7525 if (!ToAtFinallyLocOrErr)
7526 return ToAtFinallyLocOrErr.takeError();
7527 ExpectedStmt ToAtFinallyStmtOrErr = import(From: S->getFinallyBody());
7528 if (!ToAtFinallyStmtOrErr)
7529 return ToAtFinallyStmtOrErr.takeError();
7530 return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
7531 *ToAtFinallyStmtOrErr);
7532}
7533
7534ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
7535
7536 Error Err = Error::success();
7537 auto ToAtTryLoc = importChecked(Err, From: S->getAtTryLoc());
7538 auto ToTryBody = importChecked(Err, From: S->getTryBody());
7539 auto ToFinallyStmt = importChecked(Err, From: S->getFinallyStmt());
7540 if (Err)
7541 return std::move(Err);
7542
7543 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
7544 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
7545 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(I: CI);
7546 if (ExpectedStmt ToCatchStmtOrErr = import(From: FromCatchStmt))
7547 ToCatchStmts[CI] = *ToCatchStmtOrErr;
7548 else
7549 return ToCatchStmtOrErr.takeError();
7550 }
7551
7552 return ObjCAtTryStmt::Create(Context: Importer.getToContext(),
7553 atTryLoc: ToAtTryLoc, atTryStmt: ToTryBody,
7554 CatchStmts: ToCatchStmts.begin(), NumCatchStmts: ToCatchStmts.size(),
7555 atFinallyStmt: ToFinallyStmt);
7556}
7557
7558ExpectedStmt
7559ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
7560
7561 Error Err = Error::success();
7562 auto ToAtSynchronizedLoc = importChecked(Err, From: S->getAtSynchronizedLoc());
7563 auto ToSynchExpr = importChecked(Err, From: S->getSynchExpr());
7564 auto ToSynchBody = importChecked(Err, From: S->getSynchBody());
7565 if (Err)
7566 return std::move(Err);
7567
7568 return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
7569 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
7570}
7571
7572ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
7573 ExpectedSLoc ToThrowLocOrErr = import(From: S->getThrowLoc());
7574 if (!ToThrowLocOrErr)
7575 return ToThrowLocOrErr.takeError();
7576 ExpectedExpr ToThrowExprOrErr = import(From: S->getThrowExpr());
7577 if (!ToThrowExprOrErr)
7578 return ToThrowExprOrErr.takeError();
7579 return new (Importer.getToContext()) ObjCAtThrowStmt(
7580 *ToThrowLocOrErr, *ToThrowExprOrErr);
7581}
7582
7583ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
7584 ObjCAutoreleasePoolStmt *S) {
7585 ExpectedSLoc ToAtLocOrErr = import(From: S->getAtLoc());
7586 if (!ToAtLocOrErr)
7587 return ToAtLocOrErr.takeError();
7588 ExpectedStmt ToSubStmtOrErr = import(From: S->getSubStmt());
7589 if (!ToSubStmtOrErr)
7590 return ToSubStmtOrErr.takeError();
7591 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
7592 *ToSubStmtOrErr);
7593}
7594
7595//----------------------------------------------------------------------------
7596// Import Expressions
7597//----------------------------------------------------------------------------
7598ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
7599 Importer.FromDiag(Loc: E->getBeginLoc(), DiagID: diag::err_unsupported_ast_node)
7600 << E->getStmtClassName();
7601 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
7602}
7603
7604ExpectedStmt ASTNodeImporter::VisitSourceLocExpr(SourceLocExpr *E) {
7605 Error Err = Error::success();
7606 auto ToType = importChecked(Err, From: E->getType());
7607 auto BLoc = importChecked(Err, From: E->getBeginLoc());
7608 auto RParenLoc = importChecked(Err, From: E->getEndLoc());
7609 if (Err)
7610 return std::move(Err);
7611 auto ParentContextOrErr = Importer.ImportContext(FromDC: E->getParentContext());
7612 if (!ParentContextOrErr)
7613 return ParentContextOrErr.takeError();
7614
7615 return new (Importer.getToContext())
7616 SourceLocExpr(Importer.getToContext(), E->getIdentKind(), ToType, BLoc,
7617 RParenLoc, *ParentContextOrErr);
7618}
7619
7620ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
7621
7622 Error Err = Error::success();
7623 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7624 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
7625 auto ToWrittenTypeInfo = importChecked(Err, From: E->getWrittenTypeInfo());
7626 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7627 auto ToType = importChecked(Err, From: E->getType());
7628 if (Err)
7629 return std::move(Err);
7630
7631 return new (Importer.getToContext())
7632 VAArgExpr(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
7633 E->getVarargABI());
7634}
7635
7636ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
7637
7638 Error Err = Error::success();
7639 auto ToCond = importChecked(Err, From: E->getCond());
7640 auto ToLHS = importChecked(Err, From: E->getLHS());
7641 auto ToRHS = importChecked(Err, From: E->getRHS());
7642 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7643 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7644 auto ToType = importChecked(Err, From: E->getType());
7645 if (Err)
7646 return std::move(Err);
7647
7648 ExprValueKind VK = E->getValueKind();
7649 ExprObjectKind OK = E->getObjectKind();
7650
7651 // The value of CondIsTrue only matters if the value is not
7652 // condition-dependent.
7653 bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
7654
7655 return new (Importer.getToContext())
7656 ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
7657 ToRParenLoc, CondIsTrue);
7658}
7659
7660ExpectedStmt ASTNodeImporter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
7661 Error Err = Error::success();
7662 auto *ToSrcExpr = importChecked(Err, From: E->getSrcExpr());
7663 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7664 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7665 auto ToType = importChecked(Err, From: E->getType());
7666 auto *ToTSI = importChecked(Err, From: E->getTypeSourceInfo());
7667 if (Err)
7668 return std::move(Err);
7669
7670 return ConvertVectorExpr::Create(
7671 C: Importer.getToContext(), SrcExpr: ToSrcExpr, TI: ToTSI, DstType: ToType, VK: E->getValueKind(),
7672 OK: E->getObjectKind(), BuiltinLoc: ToBuiltinLoc, RParenLoc: ToRParenLoc,
7673 FPFeatures: E->getStoredFPFeaturesOrDefault());
7674}
7675
7676ExpectedStmt ASTNodeImporter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
7677 Error Err = Error::success();
7678 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7679 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
7680 auto ToType = importChecked(Err, From: E->getType());
7681 const unsigned NumSubExprs = E->getNumSubExprs();
7682
7683 llvm::SmallVector<Expr *, 8> ToSubExprs;
7684 ArrayRef<Expr *> FromSubExprs(E->getSubExprs(), NumSubExprs);
7685 ToSubExprs.resize(N: NumSubExprs);
7686
7687 if ((Err = ImportContainerChecked(InContainer: FromSubExprs, OutContainer&: ToSubExprs)))
7688 return std::move(Err);
7689
7690 return new (Importer.getToContext()) ShuffleVectorExpr(
7691 Importer.getToContext(), ToSubExprs, ToType, ToBeginLoc, ToRParenLoc);
7692}
7693
7694ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
7695 ExpectedType TypeOrErr = import(From: E->getType());
7696 if (!TypeOrErr)
7697 return TypeOrErr.takeError();
7698
7699 ExpectedSLoc BeginLocOrErr = import(From: E->getBeginLoc());
7700 if (!BeginLocOrErr)
7701 return BeginLocOrErr.takeError();
7702
7703 return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
7704}
7705
7706ExpectedStmt
7707ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
7708 Error Err = Error::success();
7709 auto ToGenericLoc = importChecked(Err, From: E->getGenericLoc());
7710 Expr *ToControllingExpr = nullptr;
7711 TypeSourceInfo *ToControllingType = nullptr;
7712 if (E->isExprPredicate())
7713 ToControllingExpr = importChecked(Err, From: E->getControllingExpr());
7714 else
7715 ToControllingType = importChecked(Err, From: E->getControllingType());
7716 assert((ToControllingExpr || ToControllingType) &&
7717 "Either the controlling expr or type must be nonnull");
7718 auto ToDefaultLoc = importChecked(Err, From: E->getDefaultLoc());
7719 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7720 if (Err)
7721 return std::move(Err);
7722
7723 ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
7724 SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
7725 if (Error Err = ImportContainerChecked(InContainer: FromAssocTypes, OutContainer&: ToAssocTypes))
7726 return std::move(Err);
7727
7728 ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
7729 SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
7730 if (Error Err = ImportContainerChecked(InContainer: FromAssocExprs, OutContainer&: ToAssocExprs))
7731 return std::move(Err);
7732
7733 const ASTContext &ToCtx = Importer.getToContext();
7734 if (E->isResultDependent()) {
7735 if (ToControllingExpr) {
7736 return GenericSelectionExpr::Create(
7737 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingExpr: ToControllingExpr, AssocTypes: ArrayRef(ToAssocTypes),
7738 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7739 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
7740 }
7741 return GenericSelectionExpr::Create(
7742 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingType: ToControllingType, AssocTypes: ArrayRef(ToAssocTypes),
7743 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7744 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
7745 }
7746
7747 if (ToControllingExpr) {
7748 return GenericSelectionExpr::Create(
7749 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingExpr: ToControllingExpr, AssocTypes: ArrayRef(ToAssocTypes),
7750 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7751 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack(), ResultIndex: E->getResultIndex());
7752 }
7753 return GenericSelectionExpr::Create(
7754 Context: ToCtx, GenericLoc: ToGenericLoc, ControllingType: ToControllingType, AssocTypes: ArrayRef(ToAssocTypes),
7755 AssocExprs: ArrayRef(ToAssocExprs), DefaultLoc: ToDefaultLoc, RParenLoc: ToRParenLoc,
7756 ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack(), ResultIndex: E->getResultIndex());
7757}
7758
7759ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
7760
7761 Error Err = Error::success();
7762 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
7763 auto ToType = importChecked(Err, From: E->getType());
7764 auto ToFunctionName = importChecked(Err, From: E->getFunctionName());
7765 if (Err)
7766 return std::move(Err);
7767
7768 return PredefinedExpr::Create(Ctx: Importer.getToContext(), L: ToBeginLoc, FNTy: ToType,
7769 IK: E->getIdentKind(), IsTransparent: E->isTransparent(),
7770 SL: ToFunctionName);
7771}
7772
7773ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
7774
7775 Error Err = Error::success();
7776 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
7777 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
7778 auto ToDecl = importChecked(Err, From: E->getDecl());
7779 auto ToLocation = importChecked(Err, From: E->getLocation());
7780 auto ToType = importChecked(Err, From: E->getType());
7781 if (Err)
7782 return std::move(Err);
7783
7784 NamedDecl *ToFoundD = nullptr;
7785 if (E->getDecl() != E->getFoundDecl()) {
7786 auto FoundDOrErr = import(From: E->getFoundDecl());
7787 if (!FoundDOrErr)
7788 return FoundDOrErr.takeError();
7789 ToFoundD = *FoundDOrErr;
7790 }
7791
7792 TemplateArgumentListInfo ToTAInfo;
7793 TemplateArgumentListInfo *ToResInfo = nullptr;
7794 if (E->hasExplicitTemplateArgs()) {
7795 if (Error Err =
7796 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
7797 Container: E->template_arguments(), Result&: ToTAInfo))
7798 return std::move(Err);
7799 ToResInfo = &ToTAInfo;
7800 }
7801
7802 auto *ToE = DeclRefExpr::Create(
7803 Context: Importer.getToContext(), QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc, D: ToDecl,
7804 RefersToEnclosingVariableOrCapture: E->refersToEnclosingVariableOrCapture(), NameLoc: ToLocation, T: ToType,
7805 VK: E->getValueKind(), FoundD: ToFoundD, TemplateArgs: ToResInfo, NOUR: E->isNonOdrUse());
7806 if (E->hadMultipleCandidates())
7807 ToE->setHadMultipleCandidates(true);
7808 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
7809 return ToE;
7810}
7811
7812ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
7813 ExpectedType TypeOrErr = import(From: E->getType());
7814 if (!TypeOrErr)
7815 return TypeOrErr.takeError();
7816
7817 return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
7818}
7819
7820ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
7821 ExpectedExpr ToInitOrErr = import(From: E->getInit());
7822 if (!ToInitOrErr)
7823 return ToInitOrErr.takeError();
7824
7825 ExpectedSLoc ToEqualOrColonLocOrErr = import(From: E->getEqualOrColonLoc());
7826 if (!ToEqualOrColonLocOrErr)
7827 return ToEqualOrColonLocOrErr.takeError();
7828
7829 SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
7830 // List elements from the second, the first is Init itself
7831 for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
7832 if (ExpectedExpr ToArgOrErr = import(From: E->getSubExpr(Idx: I)))
7833 ToIndexExprs[I - 1] = *ToArgOrErr;
7834 else
7835 return ToArgOrErr.takeError();
7836 }
7837
7838 SmallVector<Designator, 4> ToDesignators(E->size());
7839 if (Error Err = ImportContainerChecked(InContainer: E->designators(), OutContainer&: ToDesignators))
7840 return std::move(Err);
7841
7842 return DesignatedInitExpr::Create(
7843 C: Importer.getToContext(), Designators: ToDesignators,
7844 IndexExprs: ToIndexExprs, EqualOrColonLoc: *ToEqualOrColonLocOrErr,
7845 GNUSyntax: E->usesGNUSyntax(), Init: *ToInitOrErr);
7846}
7847
7848ExpectedStmt
7849ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
7850 ExpectedType ToTypeOrErr = import(From: E->getType());
7851 if (!ToTypeOrErr)
7852 return ToTypeOrErr.takeError();
7853
7854 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7855 if (!ToLocationOrErr)
7856 return ToLocationOrErr.takeError();
7857
7858 return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
7859 *ToTypeOrErr, *ToLocationOrErr);
7860}
7861
7862ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
7863 ExpectedType ToTypeOrErr = import(From: E->getType());
7864 if (!ToTypeOrErr)
7865 return ToTypeOrErr.takeError();
7866
7867 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7868 if (!ToLocationOrErr)
7869 return ToLocationOrErr.takeError();
7870
7871 return IntegerLiteral::Create(
7872 C: Importer.getToContext(), V: E->getValue(), type: *ToTypeOrErr, l: *ToLocationOrErr);
7873}
7874
7875
7876ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
7877 ExpectedType ToTypeOrErr = import(From: E->getType());
7878 if (!ToTypeOrErr)
7879 return ToTypeOrErr.takeError();
7880
7881 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7882 if (!ToLocationOrErr)
7883 return ToLocationOrErr.takeError();
7884
7885 return FloatingLiteral::Create(
7886 C: Importer.getToContext(), V: E->getValue(), isexact: E->isExact(),
7887 Type: *ToTypeOrErr, L: *ToLocationOrErr);
7888}
7889
7890ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
7891 auto ToTypeOrErr = import(From: E->getType());
7892 if (!ToTypeOrErr)
7893 return ToTypeOrErr.takeError();
7894
7895 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
7896 if (!ToSubExprOrErr)
7897 return ToSubExprOrErr.takeError();
7898
7899 return new (Importer.getToContext()) ImaginaryLiteral(
7900 *ToSubExprOrErr, *ToTypeOrErr);
7901}
7902
7903ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
7904 auto ToTypeOrErr = import(From: E->getType());
7905 if (!ToTypeOrErr)
7906 return ToTypeOrErr.takeError();
7907
7908 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7909 if (!ToLocationOrErr)
7910 return ToLocationOrErr.takeError();
7911
7912 return new (Importer.getToContext()) FixedPointLiteral(
7913 Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
7914 Importer.getToContext().getFixedPointScale(Ty: *ToTypeOrErr));
7915}
7916
7917ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
7918 ExpectedType ToTypeOrErr = import(From: E->getType());
7919 if (!ToTypeOrErr)
7920 return ToTypeOrErr.takeError();
7921
7922 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
7923 if (!ToLocationOrErr)
7924 return ToLocationOrErr.takeError();
7925
7926 return new (Importer.getToContext()) CharacterLiteral(
7927 E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
7928}
7929
7930ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
7931 ExpectedType ToTypeOrErr = import(From: E->getType());
7932 if (!ToTypeOrErr)
7933 return ToTypeOrErr.takeError();
7934
7935 SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
7936 if (Error Err = ImportArrayChecked(
7937 Ibegin: E->tokloc_begin(), Iend: E->tokloc_end(), Obegin: ToLocations.begin()))
7938 return std::move(Err);
7939
7940 return StringLiteral::Create(Ctx: Importer.getToContext(), Str: E->getBytes(),
7941 Kind: E->getKind(), Pascal: E->isPascal(), Ty: *ToTypeOrErr,
7942 Locs: ToLocations);
7943}
7944
7945ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
7946
7947 Error Err = Error::success();
7948 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
7949 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
7950 auto ToType = importChecked(Err, From: E->getType());
7951 auto ToInitializer = importChecked(Err, From: E->getInitializer());
7952 if (Err)
7953 return std::move(Err);
7954
7955 return new (Importer.getToContext()) CompoundLiteralExpr(
7956 ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
7957 ToInitializer, E->isFileScope());
7958}
7959
7960ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
7961
7962 Error Err = Error::success();
7963 auto ToBuiltinLoc = importChecked(Err, From: E->getBuiltinLoc());
7964 auto ToType = importChecked(Err, From: E->getType());
7965 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
7966 if (Err)
7967 return std::move(Err);
7968
7969 SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
7970 if (Error Err = ImportArrayChecked(
7971 Ibegin: E->getSubExprs(), Iend: E->getSubExprs() + E->getNumSubExprs(),
7972 Obegin: ToExprs.begin()))
7973 return std::move(Err);
7974
7975 return new (Importer.getToContext()) AtomicExpr(
7976
7977 ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
7978}
7979
7980ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
7981 Error Err = Error::success();
7982 auto ToAmpAmpLoc = importChecked(Err, From: E->getAmpAmpLoc());
7983 auto ToLabelLoc = importChecked(Err, From: E->getLabelLoc());
7984 auto ToLabel = importChecked(Err, From: E->getLabel());
7985 auto ToType = importChecked(Err, From: E->getType());
7986 if (Err)
7987 return std::move(Err);
7988
7989 return new (Importer.getToContext()) AddrLabelExpr(
7990 ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
7991}
7992ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
7993 Error Err = Error::success();
7994 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
7995 auto ToResult = importChecked(Err, From: E->getAPValueResult());
7996 if (Err)
7997 return std::move(Err);
7998
7999 return ConstantExpr::Create(Context: Importer.getToContext(), E: ToSubExpr, Result: ToResult);
8000}
8001ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
8002 Error Err = Error::success();
8003 auto ToLParen = importChecked(Err, From: E->getLParen());
8004 auto ToRParen = importChecked(Err, From: E->getRParen());
8005 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8006 if (Err)
8007 return std::move(Err);
8008
8009 return new (Importer.getToContext())
8010 ParenExpr(ToLParen, ToRParen, ToSubExpr);
8011}
8012
8013ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
8014 SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
8015 if (Error Err = ImportContainerChecked(InContainer: E->exprs(), OutContainer&: ToExprs))
8016 return std::move(Err);
8017
8018 ExpectedSLoc ToLParenLocOrErr = import(From: E->getLParenLoc());
8019 if (!ToLParenLocOrErr)
8020 return ToLParenLocOrErr.takeError();
8021
8022 ExpectedSLoc ToRParenLocOrErr = import(From: E->getRParenLoc());
8023 if (!ToRParenLocOrErr)
8024 return ToRParenLocOrErr.takeError();
8025
8026 return ParenListExpr::Create(Ctx: Importer.getToContext(), LParenLoc: *ToLParenLocOrErr,
8027 Exprs: ToExprs, RParenLoc: *ToRParenLocOrErr);
8028}
8029
8030ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
8031 Error Err = Error::success();
8032 auto ToSubStmt = importChecked(Err, From: E->getSubStmt());
8033 auto ToType = importChecked(Err, From: E->getType());
8034 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
8035 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8036 if (Err)
8037 return std::move(Err);
8038
8039 return new (Importer.getToContext())
8040 StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
8041 E->getTemplateDepth());
8042}
8043
8044ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
8045 Error Err = Error::success();
8046 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8047 auto ToType = importChecked(Err, From: E->getType());
8048 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8049 if (Err)
8050 return std::move(Err);
8051
8052 auto *UO = UnaryOperator::CreateEmpty(C: Importer.getToContext(),
8053 hasFPFeatures: E->hasStoredFPFeatures());
8054 UO->setType(ToType);
8055 UO->setSubExpr(ToSubExpr);
8056 UO->setOpcode(E->getOpcode());
8057 UO->setOperatorLoc(ToOperatorLoc);
8058 UO->setCanOverflow(E->canOverflow());
8059 if (E->hasStoredFPFeatures())
8060 UO->setStoredFPFeatures(E->getStoredFPFeatures());
8061
8062 return UO;
8063}
8064
8065ExpectedStmt
8066
8067ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
8068 Error Err = Error::success();
8069 auto ToType = importChecked(Err, From: E->getType());
8070 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8071 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8072 if (Err)
8073 return std::move(Err);
8074
8075 if (E->isArgumentType()) {
8076 Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
8077 import(From: E->getArgumentTypeInfo());
8078 if (!ToArgumentTypeInfoOrErr)
8079 return ToArgumentTypeInfoOrErr.takeError();
8080
8081 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
8082 E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
8083 ToRParenLoc);
8084 }
8085
8086 ExpectedExpr ToArgumentExprOrErr = import(From: E->getArgumentExpr());
8087 if (!ToArgumentExprOrErr)
8088 return ToArgumentExprOrErr.takeError();
8089
8090 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
8091 E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
8092}
8093
8094ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
8095 Error Err = Error::success();
8096 auto ToLHS = importChecked(Err, From: E->getLHS());
8097 auto ToRHS = importChecked(Err, From: E->getRHS());
8098 auto ToType = importChecked(Err, From: E->getType());
8099 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8100 if (Err)
8101 return std::move(Err);
8102
8103 return BinaryOperator::Create(
8104 C: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS, opc: E->getOpcode(), ResTy: ToType,
8105 VK: E->getValueKind(), OK: E->getObjectKind(), opLoc: ToOperatorLoc,
8106 FPFeatures: E->getFPFeatures());
8107}
8108
8109ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
8110 Error Err = Error::success();
8111 auto ToCond = importChecked(Err, From: E->getCond());
8112 auto ToQuestionLoc = importChecked(Err, From: E->getQuestionLoc());
8113 auto ToLHS = importChecked(Err, From: E->getLHS());
8114 auto ToColonLoc = importChecked(Err, From: E->getColonLoc());
8115 auto ToRHS = importChecked(Err, From: E->getRHS());
8116 auto ToType = importChecked(Err, From: E->getType());
8117 if (Err)
8118 return std::move(Err);
8119
8120 return new (Importer.getToContext()) ConditionalOperator(
8121 ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
8122 E->getValueKind(), E->getObjectKind());
8123}
8124
8125ExpectedStmt
8126ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
8127 Error Err = Error::success();
8128 auto ToCommon = importChecked(Err, From: E->getCommon());
8129 auto ToOpaqueValue = importChecked(Err, From: E->getOpaqueValue());
8130 auto ToCond = importChecked(Err, From: E->getCond());
8131 auto ToTrueExpr = importChecked(Err, From: E->getTrueExpr());
8132 auto ToFalseExpr = importChecked(Err, From: E->getFalseExpr());
8133 auto ToQuestionLoc = importChecked(Err, From: E->getQuestionLoc());
8134 auto ToColonLoc = importChecked(Err, From: E->getColonLoc());
8135 auto ToType = importChecked(Err, From: E->getType());
8136 if (Err)
8137 return std::move(Err);
8138
8139 return new (Importer.getToContext()) BinaryConditionalOperator(
8140 ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
8141 ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
8142 E->getObjectKind());
8143}
8144
8145ExpectedStmt ASTNodeImporter::VisitCXXRewrittenBinaryOperator(
8146 CXXRewrittenBinaryOperator *E) {
8147 Error Err = Error::success();
8148 auto ToSemanticForm = importChecked(Err, From: E->getSemanticForm());
8149 if (Err)
8150 return std::move(Err);
8151
8152 return new (Importer.getToContext())
8153 CXXRewrittenBinaryOperator(ToSemanticForm, E->isReversed());
8154}
8155
8156ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
8157 Error Err = Error::success();
8158 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8159 auto ToQueriedTypeSourceInfo =
8160 importChecked(Err, From: E->getQueriedTypeSourceInfo());
8161 auto ToDimensionExpression = importChecked(Err, From: E->getDimensionExpression());
8162 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8163 auto ToType = importChecked(Err, From: E->getType());
8164 if (Err)
8165 return std::move(Err);
8166
8167 return new (Importer.getToContext()) ArrayTypeTraitExpr(
8168 ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
8169 ToDimensionExpression, ToEndLoc, ToType);
8170}
8171
8172ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
8173 Error Err = Error::success();
8174 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8175 auto ToQueriedExpression = importChecked(Err, From: E->getQueriedExpression());
8176 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8177 auto ToType = importChecked(Err, From: E->getType());
8178 if (Err)
8179 return std::move(Err);
8180
8181 return new (Importer.getToContext()) ExpressionTraitExpr(
8182 ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
8183 ToEndLoc, ToType);
8184}
8185
8186ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
8187 Error Err = Error::success();
8188 auto ToLocation = importChecked(Err, From: E->getLocation());
8189 auto ToType = importChecked(Err, From: E->getType());
8190 auto ToSourceExpr = importChecked(Err, From: E->getSourceExpr());
8191 if (Err)
8192 return std::move(Err);
8193
8194 return new (Importer.getToContext()) OpaqueValueExpr(
8195 ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
8196}
8197
8198ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
8199 Error Err = Error::success();
8200 auto ToLHS = importChecked(Err, From: E->getLHS());
8201 auto ToRHS = importChecked(Err, From: E->getRHS());
8202 auto ToType = importChecked(Err, From: E->getType());
8203 auto ToRBracketLoc = importChecked(Err, From: E->getRBracketLoc());
8204 if (Err)
8205 return std::move(Err);
8206
8207 return new (Importer.getToContext()) ArraySubscriptExpr(
8208 ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
8209 ToRBracketLoc);
8210}
8211
8212ExpectedStmt
8213ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
8214 Error Err = Error::success();
8215 auto ToLHS = importChecked(Err, From: E->getLHS());
8216 auto ToRHS = importChecked(Err, From: E->getRHS());
8217 auto ToType = importChecked(Err, From: E->getType());
8218 auto ToComputationLHSType = importChecked(Err, From: E->getComputationLHSType());
8219 auto ToComputationResultType =
8220 importChecked(Err, From: E->getComputationResultType());
8221 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8222 if (Err)
8223 return std::move(Err);
8224
8225 return CompoundAssignOperator::Create(
8226 C: Importer.getToContext(), lhs: ToLHS, rhs: ToRHS, opc: E->getOpcode(), ResTy: ToType,
8227 VK: E->getValueKind(), OK: E->getObjectKind(), opLoc: ToOperatorLoc,
8228 FPFeatures: E->getFPFeatures(),
8229 CompLHSType: ToComputationLHSType, CompResultType: ToComputationResultType);
8230}
8231
8232Expected<CXXCastPath>
8233ASTNodeImporter::ImportCastPath(CastExpr *CE) {
8234 CXXCastPath Path;
8235 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
8236 if (auto SpecOrErr = import(From: *I))
8237 Path.push_back(Elt: *SpecOrErr);
8238 else
8239 return SpecOrErr.takeError();
8240 }
8241 return Path;
8242}
8243
8244ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
8245 ExpectedType ToTypeOrErr = import(From: E->getType());
8246 if (!ToTypeOrErr)
8247 return ToTypeOrErr.takeError();
8248
8249 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8250 if (!ToSubExprOrErr)
8251 return ToSubExprOrErr.takeError();
8252
8253 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(CE: E);
8254 if (!ToBasePathOrErr)
8255 return ToBasePathOrErr.takeError();
8256
8257 return ImplicitCastExpr::Create(
8258 Context: Importer.getToContext(), T: *ToTypeOrErr, Kind: E->getCastKind(), Operand: *ToSubExprOrErr,
8259 BasePath: &(*ToBasePathOrErr), Cat: E->getValueKind(), FPO: E->getFPFeatures());
8260}
8261
8262ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
8263 Error Err = Error::success();
8264 auto ToType = importChecked(Err, From: E->getType());
8265 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8266 auto ToTypeInfoAsWritten = importChecked(Err, From: E->getTypeInfoAsWritten());
8267 if (Err)
8268 return std::move(Err);
8269
8270 Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(CE: E);
8271 if (!ToBasePathOrErr)
8272 return ToBasePathOrErr.takeError();
8273 CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
8274
8275 switch (E->getStmtClass()) {
8276 case Stmt::CStyleCastExprClass: {
8277 auto *CCE = cast<CStyleCastExpr>(Val: E);
8278 ExpectedSLoc ToLParenLocOrErr = import(From: CCE->getLParenLoc());
8279 if (!ToLParenLocOrErr)
8280 return ToLParenLocOrErr.takeError();
8281 ExpectedSLoc ToRParenLocOrErr = import(From: CCE->getRParenLoc());
8282 if (!ToRParenLocOrErr)
8283 return ToRParenLocOrErr.takeError();
8284 return CStyleCastExpr::Create(
8285 Context: Importer.getToContext(), T: ToType, VK: E->getValueKind(), K: E->getCastKind(),
8286 Op: ToSubExpr, BasePath: ToBasePath, FPO: CCE->getFPFeatures(), WrittenTy: ToTypeInfoAsWritten,
8287 L: *ToLParenLocOrErr, R: *ToRParenLocOrErr);
8288 }
8289
8290 case Stmt::CXXFunctionalCastExprClass: {
8291 auto *FCE = cast<CXXFunctionalCastExpr>(Val: E);
8292 ExpectedSLoc ToLParenLocOrErr = import(From: FCE->getLParenLoc());
8293 if (!ToLParenLocOrErr)
8294 return ToLParenLocOrErr.takeError();
8295 ExpectedSLoc ToRParenLocOrErr = import(From: FCE->getRParenLoc());
8296 if (!ToRParenLocOrErr)
8297 return ToRParenLocOrErr.takeError();
8298 return CXXFunctionalCastExpr::Create(
8299 Context: Importer.getToContext(), T: ToType, VK: E->getValueKind(), Written: ToTypeInfoAsWritten,
8300 Kind: E->getCastKind(), Op: ToSubExpr, Path: ToBasePath, FPO: FCE->getFPFeatures(),
8301 LPLoc: *ToLParenLocOrErr, RPLoc: *ToRParenLocOrErr);
8302 }
8303
8304 case Stmt::ObjCBridgedCastExprClass: {
8305 auto *OCE = cast<ObjCBridgedCastExpr>(Val: E);
8306 ExpectedSLoc ToLParenLocOrErr = import(From: OCE->getLParenLoc());
8307 if (!ToLParenLocOrErr)
8308 return ToLParenLocOrErr.takeError();
8309 ExpectedSLoc ToBridgeKeywordLocOrErr = import(From: OCE->getBridgeKeywordLoc());
8310 if (!ToBridgeKeywordLocOrErr)
8311 return ToBridgeKeywordLocOrErr.takeError();
8312 return new (Importer.getToContext()) ObjCBridgedCastExpr(
8313 *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
8314 *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
8315 }
8316 case Stmt::BuiltinBitCastExprClass: {
8317 auto *BBC = cast<BuiltinBitCastExpr>(Val: E);
8318 ExpectedSLoc ToKWLocOrErr = import(From: BBC->getBeginLoc());
8319 if (!ToKWLocOrErr)
8320 return ToKWLocOrErr.takeError();
8321 ExpectedSLoc ToRParenLocOrErr = import(From: BBC->getEndLoc());
8322 if (!ToRParenLocOrErr)
8323 return ToRParenLocOrErr.takeError();
8324 return new (Importer.getToContext()) BuiltinBitCastExpr(
8325 ToType, E->getValueKind(), E->getCastKind(), ToSubExpr,
8326 ToTypeInfoAsWritten, *ToKWLocOrErr, *ToRParenLocOrErr);
8327 }
8328 default:
8329 llvm_unreachable("Cast expression of unsupported type!");
8330 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
8331 }
8332}
8333
8334ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
8335 SmallVector<OffsetOfNode, 4> ToNodes;
8336 for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
8337 const OffsetOfNode &FromNode = E->getComponent(Idx: I);
8338
8339 SourceLocation ToBeginLoc, ToEndLoc;
8340
8341 if (FromNode.getKind() != OffsetOfNode::Base) {
8342 Error Err = Error::success();
8343 ToBeginLoc = importChecked(Err, From: FromNode.getBeginLoc());
8344 ToEndLoc = importChecked(Err, From: FromNode.getEndLoc());
8345 if (Err)
8346 return std::move(Err);
8347 }
8348
8349 switch (FromNode.getKind()) {
8350 case OffsetOfNode::Array:
8351 ToNodes.push_back(
8352 Elt: OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
8353 break;
8354 case OffsetOfNode::Base: {
8355 auto ToBSOrErr = import(From: FromNode.getBase());
8356 if (!ToBSOrErr)
8357 return ToBSOrErr.takeError();
8358 ToNodes.push_back(Elt: OffsetOfNode(*ToBSOrErr));
8359 break;
8360 }
8361 case OffsetOfNode::Field: {
8362 auto ToFieldOrErr = import(From: FromNode.getField());
8363 if (!ToFieldOrErr)
8364 return ToFieldOrErr.takeError();
8365 ToNodes.push_back(Elt: OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
8366 break;
8367 }
8368 case OffsetOfNode::Identifier: {
8369 IdentifierInfo *ToII = Importer.Import(FromId: FromNode.getFieldName());
8370 ToNodes.push_back(Elt: OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
8371 break;
8372 }
8373 }
8374 }
8375
8376 SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
8377 for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
8378 ExpectedExpr ToIndexExprOrErr = import(From: E->getIndexExpr(Idx: I));
8379 if (!ToIndexExprOrErr)
8380 return ToIndexExprOrErr.takeError();
8381 ToExprs[I] = *ToIndexExprOrErr;
8382 }
8383
8384 Error Err = Error::success();
8385 auto ToType = importChecked(Err, From: E->getType());
8386 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8387 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8388 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8389 if (Err)
8390 return std::move(Err);
8391
8392 return OffsetOfExpr::Create(
8393 C: Importer.getToContext(), type: ToType, OperatorLoc: ToOperatorLoc, tsi: ToTypeSourceInfo, comps: ToNodes,
8394 exprs: ToExprs, RParenLoc: ToRParenLoc);
8395}
8396
8397ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
8398 Error Err = Error::success();
8399 auto ToType = importChecked(Err, From: E->getType());
8400 auto ToOperand = importChecked(Err, From: E->getOperand());
8401 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8402 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
8403 if (Err)
8404 return std::move(Err);
8405
8406 CanThrowResult ToCanThrow;
8407 if (E->isValueDependent())
8408 ToCanThrow = CT_Dependent;
8409 else
8410 ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
8411
8412 return new (Importer.getToContext()) CXXNoexceptExpr(
8413 ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
8414}
8415
8416ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
8417 Error Err = Error::success();
8418 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
8419 auto ToType = importChecked(Err, From: E->getType());
8420 auto ToThrowLoc = importChecked(Err, From: E->getThrowLoc());
8421 if (Err)
8422 return std::move(Err);
8423
8424 return new (Importer.getToContext()) CXXThrowExpr(
8425 ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
8426}
8427
8428ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
8429 ExpectedSLoc ToUsedLocOrErr = import(From: E->getUsedLocation());
8430 if (!ToUsedLocOrErr)
8431 return ToUsedLocOrErr.takeError();
8432
8433 auto ToParamOrErr = import(From: E->getParam());
8434 if (!ToParamOrErr)
8435 return ToParamOrErr.takeError();
8436
8437 auto UsedContextOrErr = Importer.ImportContext(FromDC: E->getUsedContext());
8438 if (!UsedContextOrErr)
8439 return UsedContextOrErr.takeError();
8440
8441 // Import the default arg if it was not imported yet.
8442 // This is needed because it can happen that during the import of the
8443 // default expression (from VisitParmVarDecl) the same ParmVarDecl is
8444 // encountered here. The default argument for a ParmVarDecl is set in the
8445 // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
8446 // see VisitParmVarDecl).
8447 ParmVarDecl *ToParam = *ToParamOrErr;
8448 if (!ToParam->getDefaultArg()) {
8449 std::optional<ParmVarDecl *> FromParam =
8450 Importer.getImportedFromDecl(ToD: ToParam);
8451 assert(FromParam && "ParmVarDecl was not imported?");
8452
8453 if (Error Err = ImportDefaultArgOfParmVarDecl(FromParam: *FromParam, ToParam))
8454 return std::move(Err);
8455 }
8456 Expr *RewrittenInit = nullptr;
8457 if (E->hasRewrittenInit()) {
8458 ExpectedExpr ExprOrErr = import(From: E->getRewrittenExpr());
8459 if (!ExprOrErr)
8460 return ExprOrErr.takeError();
8461 RewrittenInit = ExprOrErr.get();
8462 }
8463 return CXXDefaultArgExpr::Create(C: Importer.getToContext(), Loc: *ToUsedLocOrErr,
8464 Param: *ToParamOrErr, RewrittenExpr: RewrittenInit,
8465 UsedContext: *UsedContextOrErr);
8466}
8467
8468ExpectedStmt
8469ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
8470 Error Err = Error::success();
8471 auto ToType = importChecked(Err, From: E->getType());
8472 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8473 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8474 if (Err)
8475 return std::move(Err);
8476
8477 return new (Importer.getToContext()) CXXScalarValueInitExpr(
8478 ToType, ToTypeSourceInfo, ToRParenLoc);
8479}
8480
8481ExpectedStmt
8482ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
8483 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8484 if (!ToSubExprOrErr)
8485 return ToSubExprOrErr.takeError();
8486
8487 auto ToDtorOrErr = import(From: E->getTemporary()->getDestructor());
8488 if (!ToDtorOrErr)
8489 return ToDtorOrErr.takeError();
8490
8491 ASTContext &ToCtx = Importer.getToContext();
8492 CXXTemporary *Temp = CXXTemporary::Create(C: ToCtx, Destructor: *ToDtorOrErr);
8493 return CXXBindTemporaryExpr::Create(C: ToCtx, Temp, SubExpr: *ToSubExprOrErr);
8494}
8495
8496ExpectedStmt
8497
8498ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
8499 Error Err = Error::success();
8500 auto ToConstructor = importChecked(Err, From: E->getConstructor());
8501 auto ToType = importChecked(Err, From: E->getType());
8502 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8503 auto ToParenOrBraceRange = importChecked(Err, From: E->getParenOrBraceRange());
8504 if (Err)
8505 return std::move(Err);
8506
8507 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8508 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8509 return std::move(Err);
8510
8511 return CXXTemporaryObjectExpr::Create(
8512 Ctx: Importer.getToContext(), Cons: ToConstructor, Ty: ToType, TSI: ToTypeSourceInfo, Args: ToArgs,
8513 ParenOrBraceRange: ToParenOrBraceRange, HadMultipleCandidates: E->hadMultipleCandidates(),
8514 ListInitialization: E->isListInitialization(), StdInitListInitialization: E->isStdInitListInitialization(),
8515 ZeroInitialization: E->requiresZeroInitialization());
8516}
8517
8518ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
8519 LifetimeExtendedTemporaryDecl *D) {
8520 DeclContext *DC, *LexicalDC;
8521 if (Error Err = ImportDeclContext(FromD: D, ToDC&: DC, ToLexicalDC&: LexicalDC))
8522 return std::move(Err);
8523
8524 Error Err = Error::success();
8525 auto Temporary = importChecked(Err, From: D->getTemporaryExpr());
8526 auto ExtendingDecl = importChecked(Err, From: D->getExtendingDecl());
8527 if (Err)
8528 return std::move(Err);
8529 // FIXME: Should ManglingNumber get numbers associated with 'to' context?
8530
8531 LifetimeExtendedTemporaryDecl *To;
8532 if (GetImportedOrCreateDecl(ToD&: To, FromD: D, args&: Temporary, args&: ExtendingDecl,
8533 args: D->getManglingNumber()))
8534 return To;
8535
8536 To->setLexicalDeclContext(LexicalDC);
8537 LexicalDC->addDeclInternal(D: To);
8538 return To;
8539}
8540
8541ExpectedStmt
8542ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
8543 Error Err = Error::success();
8544 auto ToType = importChecked(Err, From: E->getType());
8545 Expr *ToTemporaryExpr = importChecked(
8546 Err, From: E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
8547 auto ToMaterializedDecl =
8548 importChecked(Err, From: E->getLifetimeExtendedTemporaryDecl());
8549 if (Err)
8550 return std::move(Err);
8551
8552 if (!ToTemporaryExpr)
8553 ToTemporaryExpr = cast<Expr>(Val: ToMaterializedDecl->getTemporaryExpr());
8554
8555 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
8556 ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
8557 ToMaterializedDecl);
8558
8559 return ToMTE;
8560}
8561
8562ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
8563 Error Err = Error::success();
8564 auto *ToPattern = importChecked(Err, From: E->getPattern());
8565 auto ToEllipsisLoc = importChecked(Err, From: E->getEllipsisLoc());
8566 if (Err)
8567 return std::move(Err);
8568
8569 return new (Importer.getToContext())
8570 PackExpansionExpr(ToPattern, ToEllipsisLoc, E->getNumExpansions());
8571}
8572
8573ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
8574 Error Err = Error::success();
8575 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8576 auto ToPack = importChecked(Err, From: E->getPack());
8577 auto ToPackLoc = importChecked(Err, From: E->getPackLoc());
8578 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8579 if (Err)
8580 return std::move(Err);
8581
8582 UnsignedOrNone Length = std::nullopt;
8583 if (!E->isValueDependent())
8584 Length = E->getPackLength();
8585
8586 SmallVector<TemplateArgument, 8> ToPartialArguments;
8587 if (E->isPartiallySubstituted()) {
8588 if (Error Err = ImportTemplateArguments(FromArgs: E->getPartialArguments(),
8589 ToArgs&: ToPartialArguments))
8590 return std::move(Err);
8591 }
8592
8593 return SizeOfPackExpr::Create(
8594 Context&: Importer.getToContext(), OperatorLoc: ToOperatorLoc, Pack: ToPack, PackLoc: ToPackLoc, RParenLoc: ToRParenLoc,
8595 Length, PartialArgs: ToPartialArguments);
8596}
8597
8598
8599ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
8600 Error Err = Error::success();
8601 auto ToOperatorNew = importChecked(Err, From: E->getOperatorNew());
8602 auto ToOperatorDelete = importChecked(Err, From: E->getOperatorDelete());
8603 auto ToTypeIdParens = importChecked(Err, From: E->getTypeIdParens());
8604 auto ToArraySize = importChecked(Err, From: E->getArraySize());
8605 auto ToInitializer = importChecked(Err, From: E->getInitializer());
8606 auto ToType = importChecked(Err, From: E->getType());
8607 auto ToAllocatedTypeSourceInfo =
8608 importChecked(Err, From: E->getAllocatedTypeSourceInfo());
8609 auto ToSourceRange = importChecked(Err, From: E->getSourceRange());
8610 auto ToDirectInitRange = importChecked(Err, From: E->getDirectInitRange());
8611 if (Err)
8612 return std::move(Err);
8613
8614 SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
8615 if (Error Err =
8616 ImportContainerChecked(InContainer: E->placement_arguments(), OutContainer&: ToPlacementArgs))
8617 return std::move(Err);
8618
8619 return CXXNewExpr::Create(
8620 Ctx: Importer.getToContext(), IsGlobalNew: E->isGlobalNew(), OperatorNew: ToOperatorNew,
8621 OperatorDelete: ToOperatorDelete, IAP: E->implicitAllocationParameters(),
8622 UsualArrayDeleteWantsSize: E->doesUsualArrayDeleteWantSize(), PlacementArgs: ToPlacementArgs, TypeIdParens: ToTypeIdParens,
8623 ArraySize: ToArraySize, InitializationStyle: E->getInitializationStyle(), Initializer: ToInitializer, Ty: ToType,
8624 AllocatedTypeInfo: ToAllocatedTypeSourceInfo, Range: ToSourceRange, DirectInitRange: ToDirectInitRange);
8625}
8626
8627ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
8628 Error Err = Error::success();
8629 auto ToType = importChecked(Err, From: E->getType());
8630 auto ToOperatorDelete = importChecked(Err, From: E->getOperatorDelete());
8631 auto ToArgument = importChecked(Err, From: E->getArgument());
8632 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
8633 if (Err)
8634 return std::move(Err);
8635
8636 return new (Importer.getToContext()) CXXDeleteExpr(
8637 ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
8638 E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
8639 ToBeginLoc);
8640}
8641
8642ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
8643 Error Err = Error::success();
8644 auto ToType = importChecked(Err, From: E->getType());
8645 auto ToLocation = importChecked(Err, From: E->getLocation());
8646 auto ToConstructor = importChecked(Err, From: E->getConstructor());
8647 auto ToParenOrBraceRange = importChecked(Err, From: E->getParenOrBraceRange());
8648 if (Err)
8649 return std::move(Err);
8650
8651 SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
8652 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8653 return std::move(Err);
8654
8655 CXXConstructExpr *ToE = CXXConstructExpr::Create(
8656 Ctx: Importer.getToContext(), Ty: ToType, Loc: ToLocation, Ctor: ToConstructor,
8657 Elidable: E->isElidable(), Args: ToArgs, HadMultipleCandidates: E->hadMultipleCandidates(),
8658 ListInitialization: E->isListInitialization(), StdInitListInitialization: E->isStdInitListInitialization(),
8659 ZeroInitialization: E->requiresZeroInitialization(), ConstructKind: E->getConstructionKind(),
8660 ParenOrBraceRange: ToParenOrBraceRange);
8661 ToE->setIsImmediateEscalating(E->isImmediateEscalating());
8662 return ToE;
8663}
8664
8665ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
8666 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
8667 if (!ToSubExprOrErr)
8668 return ToSubExprOrErr.takeError();
8669
8670 SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
8671 if (Error Err = ImportContainerChecked(InContainer: E->getObjects(), OutContainer&: ToObjects))
8672 return std::move(Err);
8673
8674 return ExprWithCleanups::Create(
8675 C: Importer.getToContext(), subexpr: *ToSubExprOrErr, CleanupsHaveSideEffects: E->cleanupsHaveSideEffects(),
8676 objects: ToObjects);
8677}
8678
8679ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
8680 Error Err = Error::success();
8681 auto ToCallee = importChecked(Err, From: E->getCallee());
8682 auto ToType = importChecked(Err, From: E->getType());
8683 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8684 if (Err)
8685 return std::move(Err);
8686
8687 SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
8688 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
8689 return std::move(Err);
8690
8691 return CXXMemberCallExpr::Create(Ctx: Importer.getToContext(), Fn: ToCallee, Args: ToArgs,
8692 Ty: ToType, VK: E->getValueKind(), RP: ToRParenLoc,
8693 FPFeatures: E->getFPFeatures());
8694}
8695
8696ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
8697 ExpectedType ToTypeOrErr = import(From: E->getType());
8698 if (!ToTypeOrErr)
8699 return ToTypeOrErr.takeError();
8700
8701 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
8702 if (!ToLocationOrErr)
8703 return ToLocationOrErr.takeError();
8704
8705 return CXXThisExpr::Create(Ctx: Importer.getToContext(), L: *ToLocationOrErr,
8706 Ty: *ToTypeOrErr, IsImplicit: E->isImplicit());
8707}
8708
8709ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
8710 ExpectedType ToTypeOrErr = import(From: E->getType());
8711 if (!ToTypeOrErr)
8712 return ToTypeOrErr.takeError();
8713
8714 ExpectedSLoc ToLocationOrErr = import(From: E->getLocation());
8715 if (!ToLocationOrErr)
8716 return ToLocationOrErr.takeError();
8717
8718 return CXXBoolLiteralExpr::Create(C: Importer.getToContext(), Val: E->getValue(),
8719 Ty: *ToTypeOrErr, Loc: *ToLocationOrErr);
8720}
8721
8722ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
8723 Error Err = Error::success();
8724 auto ToBase = importChecked(Err, From: E->getBase());
8725 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8726 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8727 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8728 auto ToMemberDecl = importChecked(Err, From: E->getMemberDecl());
8729 auto ToType = importChecked(Err, From: E->getType());
8730 auto ToDecl = importChecked(Err, From: E->getFoundDecl().getDecl());
8731 auto ToName = importChecked(Err, From: E->getMemberNameInfo().getName());
8732 auto ToLoc = importChecked(Err, From: E->getMemberNameInfo().getLoc());
8733 if (Err)
8734 return std::move(Err);
8735
8736 DeclAccessPair ToFoundDecl =
8737 DeclAccessPair::make(D: ToDecl, AS: E->getFoundDecl().getAccess());
8738
8739 DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
8740
8741 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
8742 if (E->hasExplicitTemplateArgs()) {
8743 if (Error Err =
8744 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8745 Container: E->template_arguments(), Result&: ToTAInfo))
8746 return std::move(Err);
8747 ResInfo = &ToTAInfo;
8748 }
8749
8750 return MemberExpr::Create(C: Importer.getToContext(), Base: ToBase, IsArrow: E->isArrow(),
8751 OperatorLoc: ToOperatorLoc, QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
8752 MemberDecl: ToMemberDecl, FoundDecl: ToFoundDecl, MemberNameInfo: ToMemberNameInfo,
8753 TemplateArgs: ResInfo, T: ToType, VK: E->getValueKind(),
8754 OK: E->getObjectKind(), NOUR: E->isNonOdrUse());
8755}
8756
8757ExpectedStmt
8758ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
8759 Error Err = Error::success();
8760 auto ToBase = importChecked(Err, From: E->getBase());
8761 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8762 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8763 auto ToScopeTypeInfo = importChecked(Err, From: E->getScopeTypeInfo());
8764 auto ToColonColonLoc = importChecked(Err, From: E->getColonColonLoc());
8765 auto ToTildeLoc = importChecked(Err, From: E->getTildeLoc());
8766 if (Err)
8767 return std::move(Err);
8768
8769 PseudoDestructorTypeStorage Storage;
8770 if (const IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
8771 const IdentifierInfo *ToII = Importer.Import(FromId: FromII);
8772 ExpectedSLoc ToDestroyedTypeLocOrErr = import(From: E->getDestroyedTypeLoc());
8773 if (!ToDestroyedTypeLocOrErr)
8774 return ToDestroyedTypeLocOrErr.takeError();
8775 Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
8776 } else {
8777 if (auto ToTIOrErr = import(From: E->getDestroyedTypeInfo()))
8778 Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
8779 else
8780 return ToTIOrErr.takeError();
8781 }
8782
8783 return new (Importer.getToContext()) CXXPseudoDestructorExpr(
8784 Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
8785 ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
8786}
8787
8788ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
8789 CXXDependentScopeMemberExpr *E) {
8790 Error Err = Error::success();
8791 auto ToType = importChecked(Err, From: E->getType());
8792 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8793 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8794 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8795 auto ToFirstQualifierFoundInScope =
8796 importChecked(Err, From: E->getFirstQualifierFoundInScope());
8797 if (Err)
8798 return std::move(Err);
8799
8800 Expr *ToBase = nullptr;
8801 if (!E->isImplicitAccess()) {
8802 if (ExpectedExpr ToBaseOrErr = import(From: E->getBase()))
8803 ToBase = *ToBaseOrErr;
8804 else
8805 return ToBaseOrErr.takeError();
8806 }
8807
8808 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
8809
8810 if (E->hasExplicitTemplateArgs()) {
8811 if (Error Err =
8812 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8813 Container: E->template_arguments(), Result&: ToTAInfo))
8814 return std::move(Err);
8815 ResInfo = &ToTAInfo;
8816 }
8817 auto ToMember = importChecked(Err, From: E->getMember());
8818 auto ToMemberLoc = importChecked(Err, From: E->getMemberLoc());
8819 if (Err)
8820 return std::move(Err);
8821 DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);
8822
8823 // Import additional name location/type info.
8824 if (Error Err =
8825 ImportDeclarationNameLoc(From: E->getMemberNameInfo(), To&: ToMemberNameInfo))
8826 return std::move(Err);
8827
8828 return CXXDependentScopeMemberExpr::Create(
8829 Ctx: Importer.getToContext(), Base: ToBase, BaseType: ToType, IsArrow: E->isArrow(), OperatorLoc: ToOperatorLoc,
8830 QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc, FirstQualifierFoundInScope: ToFirstQualifierFoundInScope,
8831 MemberNameInfo: ToMemberNameInfo, TemplateArgs: ResInfo);
8832}
8833
8834ExpectedStmt
8835ASTNodeImporter::VisitDependentTemplateIdExpr(DependentTemplateIdExpr *E) {
8836 Error Err = Error::success();
8837 auto ToName = importChecked(Err, From: E->getTemplateName());
8838 auto ToDeclName = importChecked(Err, From: E->getName());
8839 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8840 if (Err)
8841 return std::move(Err);
8842
8843 DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
8844 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8845 return std::move(Err);
8846
8847 TemplateArgumentListInfo ToTAInfo;
8848 if (Error Err =
8849 ImportTemplateArgumentListInfo(FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(),
8850 Container: E->template_arguments(), Result&: ToTAInfo))
8851 return std::move(Err);
8852
8853 return DependentTemplateIdExpr::Create(Context: Importer.getToContext(), NameInfo: ToNameInfo,
8854 Name: ToName, TemplateArgs: ToTAInfo);
8855}
8856
8857ExpectedStmt
8858ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
8859 Error Err = Error::success();
8860 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8861 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8862 auto ToDeclName = importChecked(Err, From: E->getDeclName());
8863 auto ToNameLoc = importChecked(Err, From: E->getNameInfo().getLoc());
8864 auto ToLAngleLoc = importChecked(Err, From: E->getLAngleLoc());
8865 auto ToRAngleLoc = importChecked(Err, From: E->getRAngleLoc());
8866 if (Err)
8867 return std::move(Err);
8868
8869 DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
8870 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8871 return std::move(Err);
8872
8873 TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
8874 TemplateArgumentListInfo *ResInfo = nullptr;
8875 if (E->hasExplicitTemplateArgs()) {
8876 if (Error Err =
8877 ImportTemplateArgumentListInfo(Container: E->template_arguments(), ToTAInfo))
8878 return std::move(Err);
8879 ResInfo = &ToTAInfo;
8880 }
8881
8882 return DependentScopeDeclRefExpr::Create(
8883 Context: Importer.getToContext(), QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
8884 NameInfo: ToNameInfo, TemplateArgs: ResInfo);
8885}
8886
8887ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
8888 CXXUnresolvedConstructExpr *E) {
8889 Error Err = Error::success();
8890 auto ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
8891 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
8892 auto ToType = importChecked(Err, From: E->getType());
8893 auto ToTypeSourceInfo = importChecked(Err, From: E->getTypeSourceInfo());
8894 if (Err)
8895 return std::move(Err);
8896
8897 SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
8898 if (Error Err =
8899 ImportArrayChecked(Ibegin: E->arg_begin(), Iend: E->arg_end(), Obegin: ToArgs.begin()))
8900 return std::move(Err);
8901
8902 return CXXUnresolvedConstructExpr::Create(
8903 Context: Importer.getToContext(), T: ToType, TSI: ToTypeSourceInfo, LParenLoc: ToLParenLoc,
8904 Args: ArrayRef(ToArgs), RParenLoc: ToRParenLoc, IsListInit: E->isListInitialization());
8905}
8906
8907ExpectedStmt
8908ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
8909 Expected<CXXRecordDecl *> ToNamingClassOrErr = import(From: E->getNamingClass());
8910 if (!ToNamingClassOrErr)
8911 return ToNamingClassOrErr.takeError();
8912
8913 auto ToQualifierLocOrErr = import(From: E->getQualifierLoc());
8914 if (!ToQualifierLocOrErr)
8915 return ToQualifierLocOrErr.takeError();
8916
8917 Error Err = Error::success();
8918 auto ToName = importChecked(Err, From: E->getName());
8919 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8920 if (Err)
8921 return std::move(Err);
8922 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
8923
8924 // Import additional name location/type info.
8925 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8926 return std::move(Err);
8927
8928 UnresolvedSet<8> ToDecls;
8929 for (auto *D : E->decls())
8930 if (auto ToDOrErr = import(From: D))
8931 ToDecls.addDecl(D: cast<NamedDecl>(Val: *ToDOrErr));
8932 else
8933 return ToDOrErr.takeError();
8934
8935 if (E->hasExplicitTemplateArgs()) {
8936 TemplateArgumentListInfo ToTAInfo;
8937 if (Error Err = ImportTemplateArgumentListInfo(
8938 FromLAngleLoc: E->getLAngleLoc(), FromRAngleLoc: E->getRAngleLoc(), Container: E->template_arguments(),
8939 Result&: ToTAInfo))
8940 return std::move(Err);
8941
8942 ExpectedSLoc ToTemplateKeywordLocOrErr = import(From: E->getTemplateKeywordLoc());
8943 if (!ToTemplateKeywordLocOrErr)
8944 return ToTemplateKeywordLocOrErr.takeError();
8945
8946 const bool KnownDependent =
8947 (E->getDependence() & ExprDependence::TypeValue) ==
8948 ExprDependence::TypeValue;
8949 return UnresolvedLookupExpr::Create(
8950 Context: Importer.getToContext(), NamingClass: *ToNamingClassOrErr, QualifierLoc: *ToQualifierLocOrErr,
8951 TemplateKWLoc: *ToTemplateKeywordLocOrErr, NameInfo: ToNameInfo, RequiresADL: E->requiresADL(), Args: &ToTAInfo,
8952 Begin: ToDecls.begin(), End: ToDecls.end(), KnownDependent,
8953 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8954 }
8955
8956 return UnresolvedLookupExpr::Create(
8957 Context: Importer.getToContext(), NamingClass: *ToNamingClassOrErr, QualifierLoc: *ToQualifierLocOrErr,
8958 NameInfo: ToNameInfo, RequiresADL: E->requiresADL(), Begin: ToDecls.begin(), End: ToDecls.end(),
8959 /*KnownDependent=*/E->isTypeDependent(),
8960 /*KnownInstantiationDependent=*/E->isInstantiationDependent());
8961}
8962
8963ExpectedStmt
8964ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
8965 Error Err = Error::success();
8966 auto ToType = importChecked(Err, From: E->getType());
8967 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
8968 auto ToQualifierLoc = importChecked(Err, From: E->getQualifierLoc());
8969 auto ToTemplateKeywordLoc = importChecked(Err, From: E->getTemplateKeywordLoc());
8970 auto ToName = importChecked(Err, From: E->getName());
8971 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
8972 if (Err)
8973 return std::move(Err);
8974
8975 DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
8976 // Import additional name location/type info.
8977 if (Error Err = ImportDeclarationNameLoc(From: E->getNameInfo(), To&: ToNameInfo))
8978 return std::move(Err);
8979
8980 UnresolvedSet<8> ToDecls;
8981 for (Decl *D : E->decls())
8982 if (auto ToDOrErr = import(From: D))
8983 ToDecls.addDecl(D: cast<NamedDecl>(Val: *ToDOrErr));
8984 else
8985 return ToDOrErr.takeError();
8986
8987 TemplateArgumentListInfo ToTAInfo;
8988 TemplateArgumentListInfo *ResInfo = nullptr;
8989 if (E->hasExplicitTemplateArgs()) {
8990 TemplateArgumentListInfo FromTAInfo;
8991 E->copyTemplateArgumentsInto(List&: FromTAInfo);
8992 if (Error Err = ImportTemplateArgumentListInfo(From: FromTAInfo, Result&: ToTAInfo))
8993 return std::move(Err);
8994 ResInfo = &ToTAInfo;
8995 }
8996
8997 Expr *ToBase = nullptr;
8998 if (!E->isImplicitAccess()) {
8999 if (ExpectedExpr ToBaseOrErr = import(From: E->getBase()))
9000 ToBase = *ToBaseOrErr;
9001 else
9002 return ToBaseOrErr.takeError();
9003 }
9004
9005 return UnresolvedMemberExpr::Create(
9006 Context: Importer.getToContext(), HasUnresolvedUsing: E->hasUnresolvedUsing(), Base: ToBase, BaseType: ToType,
9007 IsArrow: E->isArrow(), OperatorLoc: ToOperatorLoc, QualifierLoc: ToQualifierLoc, TemplateKWLoc: ToTemplateKeywordLoc,
9008 MemberNameInfo: ToNameInfo, TemplateArgs: ResInfo, Begin: ToDecls.begin(), End: ToDecls.end());
9009}
9010
9011ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
9012 Error Err = Error::success();
9013 auto ToCallee = importChecked(Err, From: E->getCallee());
9014 auto ToType = importChecked(Err, From: E->getType());
9015 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9016 if (Err)
9017 return std::move(Err);
9018
9019 unsigned NumArgs = E->getNumArgs();
9020 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
9021 if (Error Err = ImportContainerChecked(InContainer: E->arguments(), OutContainer&: ToArgs))
9022 return std::move(Err);
9023
9024 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(Val: E)) {
9025 return CXXOperatorCallExpr::Create(
9026 Ctx: Importer.getToContext(), OpKind: OCE->getOperator(), Fn: ToCallee, Args: ToArgs, Ty: ToType,
9027 VK: OCE->getValueKind(), OperatorLoc: ToRParenLoc, FPFeatures: OCE->getFPFeatures(),
9028 UsesADL: OCE->getADLCallKind());
9029 }
9030
9031 return CallExpr::Create(Ctx: Importer.getToContext(), Fn: ToCallee, Args: ToArgs, Ty: ToType,
9032 VK: E->getValueKind(), RParenLoc: ToRParenLoc, FPFeatures: E->getFPFeatures(),
9033 /*MinNumArgs=*/0, UsesADL: E->getADLCallKind());
9034}
9035
9036ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
9037 CXXRecordDecl *FromClass = E->getLambdaClass();
9038 auto ToClassOrErr = import(From: FromClass);
9039 if (!ToClassOrErr)
9040 return ToClassOrErr.takeError();
9041 CXXRecordDecl *ToClass = *ToClassOrErr;
9042
9043 auto ToCallOpOrErr = import(From: E->getCallOperator());
9044 if (!ToCallOpOrErr)
9045 return ToCallOpOrErr.takeError();
9046
9047 SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
9048 if (Error Err = ImportContainerChecked(InContainer: E->capture_inits(), OutContainer&: ToCaptureInits))
9049 return std::move(Err);
9050
9051 Error Err = Error::success();
9052 auto ToIntroducerRange = importChecked(Err, From: E->getIntroducerRange());
9053 auto ToCaptureDefaultLoc = importChecked(Err, From: E->getCaptureDefaultLoc());
9054 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9055 if (Err)
9056 return std::move(Err);
9057
9058 return LambdaExpr::Create(C: Importer.getToContext(), Class: ToClass, IntroducerRange: ToIntroducerRange,
9059 CaptureDefault: E->getCaptureDefault(), CaptureDefaultLoc: ToCaptureDefaultLoc,
9060 ExplicitParams: E->hasExplicitParameters(),
9061 ExplicitResultType: E->hasExplicitResultType(), CaptureInits: ToCaptureInits,
9062 ClosingBrace: ToEndLoc, ContainsUnexpandedParameterPack: E->containsUnexpandedParameterPack());
9063}
9064
9065
9066ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
9067 Error Err = Error::success();
9068 auto ToLBraceLoc = importChecked(Err, From: E->getLBraceLoc());
9069 auto ToRBraceLoc = importChecked(Err, From: E->getRBraceLoc());
9070 auto ToType = importChecked(Err, From: E->getType());
9071 if (Err)
9072 return std::move(Err);
9073
9074 SmallVector<Expr *, 4> ToExprs(E->getNumInits());
9075 if (Error Err = ImportContainerChecked(InContainer: E->inits(), OutContainer&: ToExprs))
9076 return std::move(Err);
9077
9078 ASTContext &ToCtx = Importer.getToContext();
9079 InitListExpr *To = new (ToCtx)
9080 InitListExpr(ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc, E->isExplicit());
9081 To->setType(ToType);
9082
9083 if (E->hasArrayFiller()) {
9084 if (ExpectedExpr ToFillerOrErr = import(From: E->getArrayFiller()))
9085 To->setArrayFiller(*ToFillerOrErr);
9086 else
9087 return ToFillerOrErr.takeError();
9088 }
9089
9090 if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
9091 if (auto ToFDOrErr = import(From: FromFD))
9092 To->setInitializedFieldInUnion(*ToFDOrErr);
9093 else
9094 return ToFDOrErr.takeError();
9095 }
9096
9097 if (InitListExpr *SyntForm = E->getSyntacticForm()) {
9098 if (auto ToSyntFormOrErr = import(From: SyntForm))
9099 To->setSyntacticForm(*ToSyntFormOrErr);
9100 else
9101 return ToSyntFormOrErr.takeError();
9102 }
9103
9104 // Copy InitListExprBitfields, which are not handled in the ctor of
9105 // InitListExpr.
9106 To->sawArrayRangeDesignator(ARD: E->hadArrayRangeDesignator());
9107
9108 return To;
9109}
9110
9111ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
9112 CXXStdInitializerListExpr *E) {
9113 ExpectedType ToTypeOrErr = import(From: E->getType());
9114 if (!ToTypeOrErr)
9115 return ToTypeOrErr.takeError();
9116
9117 ExpectedExpr ToSubExprOrErr = import(From: E->getSubExpr());
9118 if (!ToSubExprOrErr)
9119 return ToSubExprOrErr.takeError();
9120
9121 return new (Importer.getToContext()) CXXStdInitializerListExpr(
9122 *ToTypeOrErr, *ToSubExprOrErr);
9123}
9124
9125ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
9126 CXXInheritedCtorInitExpr *E) {
9127 Error Err = Error::success();
9128 auto ToLocation = importChecked(Err, From: E->getLocation());
9129 auto ToType = importChecked(Err, From: E->getType());
9130 auto ToConstructor = importChecked(Err, From: E->getConstructor());
9131 if (Err)
9132 return std::move(Err);
9133
9134 return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
9135 ToLocation, ToType, ToConstructor, E->constructsVBase(),
9136 E->inheritedFromVBase());
9137}
9138
9139ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
9140 Error Err = Error::success();
9141 auto ToType = importChecked(Err, From: E->getType());
9142 auto ToCommonExpr = importChecked(Err, From: E->getCommonExpr());
9143 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
9144 if (Err)
9145 return std::move(Err);
9146
9147 return new (Importer.getToContext()) ArrayInitLoopExpr(
9148 ToType, ToCommonExpr, ToSubExpr);
9149}
9150
9151ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
9152 ExpectedType ToTypeOrErr = import(From: E->getType());
9153 if (!ToTypeOrErr)
9154 return ToTypeOrErr.takeError();
9155 return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
9156}
9157
9158ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
9159 ExpectedSLoc ToBeginLocOrErr = import(From: E->getBeginLoc());
9160 if (!ToBeginLocOrErr)
9161 return ToBeginLocOrErr.takeError();
9162
9163 auto ToFieldOrErr = import(From: E->getField());
9164 if (!ToFieldOrErr)
9165 return ToFieldOrErr.takeError();
9166
9167 auto UsedContextOrErr = Importer.ImportContext(FromDC: E->getUsedContext());
9168 if (!UsedContextOrErr)
9169 return UsedContextOrErr.takeError();
9170
9171 FieldDecl *ToField = *ToFieldOrErr;
9172 assert(ToField->hasInClassInitializer() &&
9173 "Field should have in-class initializer if there is a default init "
9174 "expression that uses it.");
9175 if (!ToField->getInClassInitializer()) {
9176 // The in-class initializer may be not yet set in "To" AST even if the
9177 // field is already there. This must be set here to make construction of
9178 // CXXDefaultInitExpr work.
9179 auto ToInClassInitializerOrErr =
9180 import(From: E->getField()->getInClassInitializer());
9181 if (!ToInClassInitializerOrErr)
9182 return ToInClassInitializerOrErr.takeError();
9183 ToField->setInClassInitializer(*ToInClassInitializerOrErr);
9184 }
9185
9186 Expr *RewrittenInit = nullptr;
9187 if (E->hasRewrittenInit()) {
9188 ExpectedExpr ExprOrErr = import(From: E->getRewrittenExpr());
9189 if (!ExprOrErr)
9190 return ExprOrErr.takeError();
9191 RewrittenInit = ExprOrErr.get();
9192 }
9193
9194 return CXXDefaultInitExpr::Create(Ctx: Importer.getToContext(), Loc: *ToBeginLocOrErr,
9195 Field: ToField, UsedContext: *UsedContextOrErr, RewrittenInitExpr: RewrittenInit);
9196}
9197
9198ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
9199 Error Err = Error::success();
9200 auto ToType = importChecked(Err, From: E->getType());
9201 auto ToSubExpr = importChecked(Err, From: E->getSubExpr());
9202 auto ToTypeInfoAsWritten = importChecked(Err, From: E->getTypeInfoAsWritten());
9203 auto ToOperatorLoc = importChecked(Err, From: E->getOperatorLoc());
9204 auto ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9205 auto ToAngleBrackets = importChecked(Err, From: E->getAngleBrackets());
9206 if (Err)
9207 return std::move(Err);
9208
9209 ExprValueKind VK = E->getValueKind();
9210 CastKind CK = E->getCastKind();
9211 auto ToBasePathOrErr = ImportCastPath(CE: E);
9212 if (!ToBasePathOrErr)
9213 return ToBasePathOrErr.takeError();
9214
9215 if (auto CCE = dyn_cast<CXXStaticCastExpr>(Val: E)) {
9216 return CXXStaticCastExpr::Create(
9217 Context: Importer.getToContext(), T: ToType, VK, K: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9218 Written: ToTypeInfoAsWritten, FPO: CCE->getFPFeatures(), L: ToOperatorLoc, RParenLoc: ToRParenLoc,
9219 AngleBrackets: ToAngleBrackets);
9220 } else if (isa<CXXDynamicCastExpr>(Val: E)) {
9221 return CXXDynamicCastExpr::Create(
9222 Context: Importer.getToContext(), T: ToType, VK, Kind: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9223 Written: ToTypeInfoAsWritten, L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9224 } else if (isa<CXXReinterpretCastExpr>(Val: E)) {
9225 return CXXReinterpretCastExpr::Create(
9226 Context: Importer.getToContext(), T: ToType, VK, Kind: CK, Op: ToSubExpr, Path: &(*ToBasePathOrErr),
9227 WrittenTy: ToTypeInfoAsWritten, L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9228 } else if (isa<CXXConstCastExpr>(Val: E)) {
9229 return CXXConstCastExpr::Create(
9230 Context: Importer.getToContext(), T: ToType, VK, Op: ToSubExpr, WrittenTy: ToTypeInfoAsWritten,
9231 L: ToOperatorLoc, RParenLoc: ToRParenLoc, AngleBrackets: ToAngleBrackets);
9232 } else {
9233 llvm_unreachable("Unknown cast type");
9234 return make_error<ASTImportError>();
9235 }
9236}
9237
9238ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
9239 SubstNonTypeTemplateParmExpr *E) {
9240 Error Err = Error::success();
9241 auto ToType = importChecked(Err, From: E->getType());
9242 auto ToNameLoc = importChecked(Err, From: E->getNameLoc());
9243 auto ToAssociatedDecl = importChecked(Err, From: E->getAssociatedDecl());
9244 auto ToParamType = importChecked(Err, From: E->getParameterType());
9245 auto ToReplacement = importChecked(Err, From: E->getReplacement());
9246 if (Err)
9247 return std::move(Err);
9248
9249 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
9250 ToType, E->getValueKind(), ToNameLoc, ToReplacement, ToAssociatedDecl,
9251 ToParamType, E->getIndex(), E->getPackIndex(), E->getFinal());
9252}
9253
9254ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
9255 Error Err = Error::success();
9256 auto ToType = importChecked(Err, From: E->getType());
9257 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
9258 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9259 if (Err)
9260 return std::move(Err);
9261
9262 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
9263 if (Error Err = ImportContainerChecked(InContainer: E->getArgs(), OutContainer&: ToArgs))
9264 return std::move(Err);
9265
9266 if (E->isStoredAsBoolean()) {
9267 // According to Sema::BuildTypeTrait(), if E is value-dependent,
9268 // Value is always false.
9269 bool ToValue = (E->isValueDependent() ? false : E->getBoolValue());
9270 return TypeTraitExpr::Create(C: Importer.getToContext(), T: ToType, Loc: ToBeginLoc,
9271 Kind: E->getTrait(), Args: ToArgs, RParenLoc: ToEndLoc, Value: ToValue);
9272 }
9273 return TypeTraitExpr::Create(C: Importer.getToContext(), T: ToType, Loc: ToBeginLoc,
9274 Kind: E->getTrait(), Args: ToArgs, RParenLoc: ToEndLoc,
9275 Value: E->getAPValue());
9276}
9277
9278ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
9279 ExpectedType ToTypeOrErr = import(From: E->getType());
9280 if (!ToTypeOrErr)
9281 return ToTypeOrErr.takeError();
9282
9283 auto ToSourceRangeOrErr = import(From: E->getSourceRange());
9284 if (!ToSourceRangeOrErr)
9285 return ToSourceRangeOrErr.takeError();
9286
9287 if (E->isTypeOperand()) {
9288 if (auto ToTSIOrErr = import(From: E->getTypeOperandSourceInfo()))
9289 return new (Importer.getToContext()) CXXTypeidExpr(
9290 *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
9291 else
9292 return ToTSIOrErr.takeError();
9293 }
9294
9295 ExpectedExpr ToExprOperandOrErr = import(From: E->getExprOperand());
9296 if (!ToExprOperandOrErr)
9297 return ToExprOperandOrErr.takeError();
9298
9299 return new (Importer.getToContext()) CXXTypeidExpr(
9300 *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
9301}
9302
9303ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
9304 Error Err = Error::success();
9305
9306 QualType ToType = importChecked(Err, From: E->getType());
9307 UnresolvedLookupExpr *ToCallee = importChecked(Err, From: E->getCallee());
9308 SourceLocation ToLParenLoc = importChecked(Err, From: E->getLParenLoc());
9309 Expr *ToLHS = importChecked(Err, From: E->getLHS());
9310 SourceLocation ToEllipsisLoc = importChecked(Err, From: E->getEllipsisLoc());
9311 Expr *ToRHS = importChecked(Err, From: E->getRHS());
9312 SourceLocation ToRParenLoc = importChecked(Err, From: E->getRParenLoc());
9313
9314 if (Err)
9315 return std::move(Err);
9316
9317 return new (Importer.getToContext())
9318 CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
9319 ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
9320}
9321
9322ExpectedStmt ASTNodeImporter::VisitRequiresExpr(RequiresExpr *E) {
9323 Error Err = Error::success();
9324 auto RequiresKWLoc = importChecked(Err, From: E->getRequiresKWLoc());
9325 auto RParenLoc = importChecked(Err, From: E->getRParenLoc());
9326 auto RBraceLoc = importChecked(Err, From: E->getRBraceLoc());
9327
9328 auto Body = importChecked(Err, From: E->getBody());
9329 auto LParenLoc = importChecked(Err, From: E->getLParenLoc());
9330 if (Err)
9331 return std::move(Err);
9332 SmallVector<ParmVarDecl *, 4> LocalParameters(E->getLocalParameters().size());
9333 if (Error Err =
9334 ImportArrayChecked(InContainer: E->getLocalParameters(), Obegin: LocalParameters.begin()))
9335 return std::move(Err);
9336 SmallVector<concepts::Requirement *, 4> Requirements(
9337 E->getRequirements().size());
9338 if (Error Err =
9339 ImportArrayChecked(InContainer: E->getRequirements(), Obegin: Requirements.begin()))
9340 return std::move(Err);
9341 return RequiresExpr::Create(C&: Importer.getToContext(), RequiresKWLoc, Body,
9342 LParenLoc, LocalParameters, RParenLoc,
9343 Requirements, RBraceLoc);
9344}
9345
9346ExpectedStmt
9347ASTNodeImporter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
9348 Error Err = Error::success();
9349 auto CL = importChecked(Err, From: E->getConceptReference());
9350 auto CSD = importChecked(Err, From: E->getSpecializationDecl());
9351 if (Err)
9352 return std::move(Err);
9353 if (E->isValueDependent())
9354 return ConceptSpecializationExpr::Create(
9355 C: Importer.getToContext(), ConceptRef: CL,
9356 SpecDecl: const_cast<ImplicitConceptSpecializationDecl *>(CSD), Satisfaction: nullptr);
9357 ConstraintSatisfaction Satisfaction;
9358 if (Error Err =
9359 ImportConstraintSatisfaction(FromSat: E->getSatisfaction(), ToSat&: Satisfaction))
9360 return std::move(Err);
9361 return ConceptSpecializationExpr::Create(
9362 C: Importer.getToContext(), ConceptRef: CL,
9363 SpecDecl: const_cast<ImplicitConceptSpecializationDecl *>(CSD), Satisfaction: &Satisfaction);
9364}
9365
9366ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmPackExpr(
9367 SubstNonTypeTemplateParmPackExpr *E) {
9368 Error Err = Error::success();
9369 auto ToType = importChecked(Err, From: E->getType());
9370 auto ToPackLoc = importChecked(Err, From: E->getParameterPackLocation());
9371 auto ToArgPack = importChecked(Err, From: E->getArgumentPack());
9372 auto ToAssociatedDecl = importChecked(Err, From: E->getAssociatedDecl());
9373 if (Err)
9374 return std::move(Err);
9375
9376 return new (Importer.getToContext()) SubstNonTypeTemplateParmPackExpr(
9377 ToType, E->getValueKind(), ToPackLoc, ToArgPack, ToAssociatedDecl,
9378 E->getIndex(), E->getFinal());
9379}
9380
9381ExpectedStmt ASTNodeImporter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
9382 SmallVector<Expr *, 4> ToSemantics(E->getNumSemanticExprs());
9383 if (Error Err = ImportContainerChecked(InContainer: E->semantics(), OutContainer&: ToSemantics))
9384 return std::move(Err);
9385 auto ToSyntOrErr = import(From: E->getSyntacticForm());
9386 if (!ToSyntOrErr)
9387 return ToSyntOrErr.takeError();
9388 return PseudoObjectExpr::Create(Context: Importer.getToContext(), syntactic: *ToSyntOrErr,
9389 semantic: ToSemantics, resultIndex: E->getResultExprIndex());
9390}
9391
9392ExpectedStmt
9393ASTNodeImporter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
9394 Error Err = Error::success();
9395 auto ToType = importChecked(Err, From: E->getType());
9396 auto ToInitLoc = importChecked(Err, From: E->getInitLoc());
9397 auto ToBeginLoc = importChecked(Err, From: E->getBeginLoc());
9398 auto ToEndLoc = importChecked(Err, From: E->getEndLoc());
9399 if (Err)
9400 return std::move(Err);
9401
9402 SmallVector<Expr *, 4> ToArgs(E->getInitExprs().size());
9403 if (Error Err = ImportContainerChecked(InContainer: E->getInitExprs(), OutContainer&: ToArgs))
9404 return std::move(Err);
9405 return CXXParenListInitExpr::Create(C&: Importer.getToContext(), Args: ToArgs, T: ToType,
9406 NumUserSpecifiedExprs: E->getUserSpecifiedInitExprs().size(),
9407 InitLoc: ToInitLoc, LParenLoc: ToBeginLoc, RParenLoc: ToEndLoc);
9408}
9409
9410ExpectedStmt
9411ASTNodeImporter::VisitCXXExpansionSelectExpr(CXXExpansionSelectExpr *E) {
9412 Error Err = Error::success();
9413 auto ToRange = importChecked(Err, From: E->getRangeExpr());
9414 auto ToIndex = importChecked(Err, From: E->getIndexExpr());
9415 if (Err)
9416 return std::move(Err);
9417
9418 return new (Importer.getToContext())
9419 CXXExpansionSelectExpr(Importer.getToContext(), ToRange, ToIndex);
9420}
9421
9422Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
9423 CXXMethodDecl *FromMethod) {
9424 Error ImportErrors = Error::success();
9425 for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
9426 if (auto ImportedOrErr = import(From: FromOverriddenMethod))
9427 ToMethod->getCanonicalDecl()->addOverriddenMethod(MD: cast<CXXMethodDecl>(
9428 Val: (*ImportedOrErr)->getCanonicalDecl()));
9429 else
9430 ImportErrors =
9431 joinErrors(E1: std::move(ImportErrors), E2: ImportedOrErr.takeError());
9432 }
9433 return ImportErrors;
9434}
9435
9436ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
9437 ASTContext &FromContext, FileManager &FromFileManager,
9438 bool MinimalImport,
9439 std::shared_ptr<ASTImporterSharedState> SharedState)
9440 : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
9441 ToFileManager(ToFileManager), FromFileManager(FromFileManager),
9442 Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {
9443
9444 // Create a default state without the lookup table: LLDB case.
9445 if (!SharedState) {
9446 this->SharedState = std::make_shared<ASTImporterSharedState>();
9447 }
9448
9449 ImportedDecls[FromContext.getTranslationUnitDecl()] =
9450 ToContext.getTranslationUnitDecl();
9451}
9452
9453ASTImporter::~ASTImporter() = default;
9454
9455UnsignedOrNone ASTImporter::getFieldIndex(Decl *F) {
9456 assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
9457 "Try to get field index for non-field.");
9458
9459 auto *Owner = dyn_cast<RecordDecl>(Val: F->getDeclContext());
9460 if (!Owner)
9461 return std::nullopt;
9462
9463 unsigned Index = 0;
9464 for (const auto *D : Owner->decls()) {
9465 if (D == F)
9466 return Index;
9467
9468 if (isa<FieldDecl>(Val: *D) || isa<IndirectFieldDecl>(Val: *D))
9469 ++Index;
9470 }
9471
9472 llvm_unreachable("Field was not found in its parent context.");
9473
9474 return std::nullopt;
9475}
9476
9477ASTImporter::FoundDeclsTy
9478ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
9479 // We search in the redecl context because of transparent contexts.
9480 // E.g. a simple C language enum is a transparent context:
9481 // enum E { A, B };
9482 // Now if we had a global variable in the TU
9483 // int A;
9484 // then the enum constant 'A' and the variable 'A' violates ODR.
9485 // We can diagnose this only if we search in the redecl context.
9486 DeclContext *ReDC = DC->getRedeclContext();
9487 if (SharedState->getLookupTable()) {
9488 if (ReDC->isNamespace()) {
9489 // Namespaces can be reopened.
9490 // Lookup table does not handle this, we must search here in all linked
9491 // namespaces.
9492 FoundDeclsTy Result;
9493 SmallVector<Decl *, 2> NSChain =
9494 getCanonicalForwardRedeclChain<NamespaceDecl>(
9495 D: dyn_cast<NamespaceDecl>(Val: ReDC));
9496 for (auto *D : NSChain) {
9497 ASTImporterLookupTable::LookupResult LookupResult =
9498 SharedState->getLookupTable()->lookup(DC: dyn_cast<NamespaceDecl>(Val: D),
9499 Name);
9500 Result.append(in_start: LookupResult.begin(), in_end: LookupResult.end());
9501 }
9502 return Result;
9503 } else {
9504 ASTImporterLookupTable::LookupResult LookupResult =
9505 SharedState->getLookupTable()->lookup(DC: ReDC, Name);
9506 return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
9507 }
9508 } else {
9509 DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
9510 FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
9511 // We must search by the slow case of localUncachedLookup because that is
9512 // working even if there is no LookupPtr for the DC. We could use
9513 // DC::buildLookup() to create the LookupPtr, but that would load external
9514 // decls again, we must avoid that case.
9515 // Also, even if we had the LookupPtr, we must find Decls which are not
9516 // in the LookupPtr, so we need the slow case.
9517 // These cases are handled in ASTImporterLookupTable, but we cannot use
9518 // that with LLDB since that traverses through the AST which initiates the
9519 // load of external decls again via DC::decls(). And again, we must avoid
9520 // loading external decls during the import.
9521 if (Result.empty())
9522 ReDC->localUncachedLookup(Name, Results&: Result);
9523 return Result;
9524 }
9525}
9526
9527void ASTImporter::AddToLookupTable(Decl *ToD) {
9528 SharedState->addDeclToLookup(D: ToD);
9529}
9530
9531Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
9532 // Import the decl using ASTNodeImporter.
9533 ASTNodeImporter Importer(*this);
9534 return Importer.Visit(D: FromD);
9535}
9536
9537void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
9538 MapImported(From: FromD, To: ToD);
9539}
9540
9541llvm::Expected<ExprWithCleanups::CleanupObject>
9542ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
9543 if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
9544 if (Expected<Expr *> R = Import(FromE: CLE))
9545 return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(Val: *R));
9546 }
9547
9548 // FIXME: Handle BlockDecl when we implement importing BlockExpr in
9549 // ASTNodeImporter.
9550 return make_error<ASTImportError>(Args: ASTImportError::UnsupportedConstruct);
9551}
9552
9553ExpectedTypePtr ASTImporter::Import(const Type *FromT) {
9554 if (!FromT)
9555 return FromT;
9556
9557 // Check whether we've already imported this type.
9558 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9559 ImportedTypes.find(Val: FromT);
9560 if (Pos != ImportedTypes.end())
9561 return Pos->second;
9562
9563 // Import the type.
9564 ASTNodeImporter Importer(*this);
9565 ExpectedType ToTOrErr = Importer.Visit(T: FromT);
9566 if (!ToTOrErr)
9567 return ToTOrErr.takeError();
9568
9569 // Record the imported type.
9570 ImportedTypes[FromT] = ToTOrErr->getTypePtr();
9571
9572 return ToTOrErr->getTypePtr();
9573}
9574
9575Expected<QualType> ASTImporter::Import(QualType FromT) {
9576 if (FromT.isNull())
9577 return QualType{};
9578
9579 ExpectedTypePtr ToTyOrErr = Import(FromT: FromT.getTypePtr());
9580 if (!ToTyOrErr)
9581 return ToTyOrErr.takeError();
9582
9583 return ToContext.getQualifiedType(T: *ToTyOrErr, Qs: FromT.getLocalQualifiers());
9584}
9585
9586Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
9587 if (!FromTSI)
9588 return FromTSI;
9589
9590 // FIXME: For now we just create a "trivial" type source info based
9591 // on the type and a single location. Implement a real version of this.
9592 ExpectedType TOrErr = Import(FromT: FromTSI->getType());
9593 if (!TOrErr)
9594 return TOrErr.takeError();
9595 ExpectedSLoc BeginLocOrErr = Import(FromLoc: FromTSI->getTypeLoc().getBeginLoc());
9596 if (!BeginLocOrErr)
9597 return BeginLocOrErr.takeError();
9598
9599 return ToContext.getTrivialTypeSourceInfo(T: *TOrErr, Loc: *BeginLocOrErr);
9600}
9601
9602namespace {
9603// To use this object, it should be created before the new attribute is created,
9604// and destructed after it is created. The construction already performs the
9605// import of the data.
9606template <typename T> struct AttrArgImporter {
9607 AttrArgImporter(const AttrArgImporter<T> &) = delete;
9608 AttrArgImporter(AttrArgImporter<T> &&) = default;
9609 AttrArgImporter<T> &operator=(const AttrArgImporter<T> &) = delete;
9610 AttrArgImporter<T> &operator=(AttrArgImporter<T> &&) = default;
9611
9612 AttrArgImporter(ASTNodeImporter &I, Error &Err, const T &From)
9613 : To(I.importChecked(Err, From)) {}
9614
9615 const T &value() { return To; }
9616
9617private:
9618 T To;
9619};
9620
9621// To use this object, it should be created before the new attribute is created,
9622// and destructed after it is created. The construction already performs the
9623// import of the data. The array data is accessible in a pointer form, this form
9624// is used by the attribute classes. This object should be created once for the
9625// array data to be imported (the array size is not imported, just copied).
9626template <typename T> struct AttrArgArrayImporter {
9627 AttrArgArrayImporter(const AttrArgArrayImporter<T> &) = delete;
9628 AttrArgArrayImporter(AttrArgArrayImporter<T> &&) = default;
9629 AttrArgArrayImporter<T> &operator=(const AttrArgArrayImporter<T> &) = delete;
9630 AttrArgArrayImporter<T> &operator=(AttrArgArrayImporter<T> &&) = default;
9631
9632 AttrArgArrayImporter(ASTNodeImporter &I, Error &Err,
9633 const llvm::iterator_range<T *> &From,
9634 unsigned ArraySize) {
9635 if (Err)
9636 return;
9637 To.reserve(ArraySize);
9638 Err = I.ImportContainerChecked(From, To);
9639 }
9640
9641 T *value() { return To.data(); }
9642
9643private:
9644 llvm::SmallVector<T, 2> To;
9645};
9646
9647class AttrImporter {
9648 Error Err{Error::success()};
9649 Attr *ToAttr = nullptr;
9650 ASTImporter &Importer;
9651 ASTNodeImporter NImporter;
9652
9653public:
9654 AttrImporter(ASTImporter &I) : Importer(I), NImporter(I) {}
9655
9656 // Create an "importer" for an attribute parameter.
9657 // Result of the 'value()' of that object is to be passed to the function
9658 // 'importAttr', in the order that is expected by the attribute class.
9659 template <class T> AttrArgImporter<T> importArg(const T &From) {
9660 return AttrArgImporter<T>(NImporter, Err, From);
9661 }
9662
9663 // Create an "importer" for an attribute parameter that has array type.
9664 // Result of the 'value()' of that object is to be passed to the function
9665 // 'importAttr', then the size of the array as next argument.
9666 template <typename T>
9667 AttrArgArrayImporter<T> importArrayArg(const llvm::iterator_range<T *> &From,
9668 unsigned ArraySize) {
9669 return AttrArgArrayImporter<T>(NImporter, Err, From, ArraySize);
9670 }
9671
9672 // Create an attribute object with the specified arguments.
9673 // The 'FromAttr' is the original (not imported) attribute, the 'ImportedArg'
9674 // should be values that are passed to the 'Create' function of the attribute.
9675 // (The 'Create' with 'ASTContext' first and 'AttributeCommonInfo' last is
9676 // used here.) As much data is copied or imported from the old attribute
9677 // as possible. The passed arguments should be already imported.
9678 // If an import error happens, the internal error is set to it, and any
9679 // further import attempt is ignored.
9680 template <typename T, typename... Arg>
9681 void importAttr(const T *FromAttr, Arg &&...ImportedArg) {
9682 static_assert(std::is_base_of<Attr, T>::value,
9683 "T should be subclass of Attr.");
9684 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9685
9686 const IdentifierInfo *ToAttrName = Importer.Import(FromAttr->getAttrName());
9687 const IdentifierInfo *ToScopeName =
9688 Importer.Import(FromAttr->getScopeName());
9689 SourceRange ToAttrRange =
9690 NImporter.importChecked(Err, FromAttr->getRange());
9691 SourceLocation ToScopeLoc =
9692 NImporter.importChecked(Err, FromAttr->getScopeLoc());
9693
9694 if (Err)
9695 return;
9696
9697 AttributeCommonInfo ToI(
9698 ToAttrName, AttributeScopeInfo(ToScopeName, ToScopeLoc), ToAttrRange,
9699 FromAttr->getParsedKind(), FromAttr->getForm());
9700 // The "SemanticSpelling" is not needed to be passed to the constructor.
9701 // That value is recalculated from the SpellingListIndex if needed.
9702 ToAttr = T::Create(Importer.getToContext(),
9703 std::forward<Arg>(ImportedArg)..., ToI);
9704
9705 ToAttr->setImplicit(FromAttr->isImplicit());
9706 ToAttr->setPackExpansion(FromAttr->isPackExpansion());
9707 if (auto *ToInheritableAttr = dyn_cast<InheritableAttr>(Val: ToAttr))
9708 ToInheritableAttr->setInherited(FromAttr->isInherited());
9709 }
9710
9711 // Create a clone of the 'FromAttr' and import its source range only.
9712 // This causes objects with invalid references to be created if the 'FromAttr'
9713 // contains other data that should be imported.
9714 void cloneAttr(const Attr *FromAttr) {
9715 assert(!ToAttr && "Use one AttrImporter to import one Attribute object.");
9716
9717 SourceRange ToRange = NImporter.importChecked(Err, From: FromAttr->getRange());
9718 if (Err)
9719 return;
9720
9721 ToAttr = FromAttr->clone(C&: Importer.getToContext());
9722 ToAttr->setRange(ToRange);
9723 ToAttr->setAttrName(Importer.Import(FromId: FromAttr->getAttrName()));
9724 }
9725
9726 // Get the result of the previous import attempt (can be used only once).
9727 llvm::Expected<Attr *> getResult() && {
9728 if (Err)
9729 return std::move(Err);
9730 assert(ToAttr && "Attribute should be created.");
9731 return ToAttr;
9732 }
9733};
9734} // namespace
9735
9736Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
9737 AttrImporter AI(*this);
9738
9739 // FIXME: Is there some kind of AttrVisitor to use here?
9740 switch (FromAttr->getKind()) {
9741 case attr::Aligned: {
9742 auto *From = cast<AlignedAttr>(Val: FromAttr);
9743 if (From->isAlignmentExpr())
9744 AI.importAttr(FromAttr: From, ImportedArg: true, ImportedArg: AI.importArg(From: From->getAlignmentExpr()).value());
9745 else
9746 AI.importAttr(FromAttr: From, ImportedArg: false,
9747 ImportedArg: AI.importArg(From: From->getAlignmentType()).value());
9748 break;
9749 }
9750
9751 case attr::AlignValue: {
9752 auto *From = cast<AlignValueAttr>(Val: FromAttr);
9753 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getAlignment()).value());
9754 break;
9755 }
9756
9757 case attr::Format: {
9758 const auto *From = cast<FormatAttr>(Val: FromAttr);
9759 AI.importAttr(FromAttr: From, ImportedArg: Import(FromId: From->getType()), ImportedArg: From->getFormatIdx(),
9760 ImportedArg: From->getFirstArg());
9761 break;
9762 }
9763
9764 case attr::EnableIf: {
9765 const auto *From = cast<EnableIfAttr>(Val: FromAttr);
9766 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getCond()).value(),
9767 ImportedArg: From->getMessage());
9768 break;
9769 }
9770
9771 case attr::AssertCapability: {
9772 const auto *From = cast<AssertCapabilityAttr>(Val: FromAttr);
9773 AI.importAttr(FromAttr: From,
9774 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9775 ImportedArg: From->args_size());
9776 break;
9777 }
9778 case attr::AcquireCapability: {
9779 const auto *From = cast<AcquireCapabilityAttr>(Val: FromAttr);
9780 AI.importAttr(FromAttr: From,
9781 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9782 ImportedArg: From->args_size());
9783 break;
9784 }
9785 case attr::TryAcquireCapability: {
9786 const auto *From = cast<TryAcquireCapabilityAttr>(Val: FromAttr);
9787 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getSuccessValue()).value(),
9788 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9789 ImportedArg: From->args_size());
9790 break;
9791 }
9792 case attr::ReleaseCapability: {
9793 const auto *From = cast<ReleaseCapabilityAttr>(Val: FromAttr);
9794 AI.importAttr(FromAttr: From,
9795 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9796 ImportedArg: From->args_size());
9797 break;
9798 }
9799 case attr::RequiresCapability: {
9800 const auto *From = cast<RequiresCapabilityAttr>(Val: FromAttr);
9801 AI.importAttr(FromAttr: From,
9802 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9803 ImportedArg: From->args_size());
9804 break;
9805 }
9806 case attr::GuardedBy: {
9807 const auto *From = cast<GuardedByAttr>(Val: FromAttr);
9808 AI.importAttr(FromAttr: From,
9809 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9810 ImportedArg: From->args_size());
9811 break;
9812 }
9813 case attr::PtGuardedBy: {
9814 const auto *From = cast<PtGuardedByAttr>(Val: FromAttr);
9815 AI.importAttr(FromAttr: From,
9816 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9817 ImportedArg: From->args_size());
9818 break;
9819 }
9820 case attr::AcquiredAfter: {
9821 const auto *From = cast<AcquiredAfterAttr>(Val: FromAttr);
9822 AI.importAttr(FromAttr: From,
9823 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9824 ImportedArg: From->args_size());
9825 break;
9826 }
9827 case attr::AcquiredBefore: {
9828 const auto *From = cast<AcquiredBeforeAttr>(Val: FromAttr);
9829 AI.importAttr(FromAttr: From,
9830 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9831 ImportedArg: From->args_size());
9832 break;
9833 }
9834 case attr::LockReturned: {
9835 const auto *From = cast<LockReturnedAttr>(Val: FromAttr);
9836 AI.importAttr(FromAttr: From, ImportedArg: AI.importArg(From: From->getArg()).value());
9837 break;
9838 }
9839 case attr::LocksExcluded: {
9840 const auto *From = cast<LocksExcludedAttr>(Val: FromAttr);
9841 AI.importAttr(FromAttr: From,
9842 ImportedArg: AI.importArrayArg(From: From->args(), ArraySize: From->args_size()).value(),
9843 ImportedArg: From->args_size());
9844 break;
9845 }
9846 default: {
9847 // The default branch works for attributes that have no arguments to import.
9848 // FIXME: Handle every attribute type that has arguments of type to import
9849 // (most often Expr* or Decl* or type) in the switch above.
9850 AI.cloneAttr(FromAttr);
9851 break;
9852 }
9853 }
9854
9855 return std::move(AI).getResult();
9856}
9857
9858Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
9859 return ImportedDecls.lookup(Val: FromD);
9860}
9861
9862TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
9863 auto FromDPos = ImportedFromDecls.find(Val: ToD);
9864 if (FromDPos == ImportedFromDecls.end())
9865 return nullptr;
9866 return FromDPos->second->getTranslationUnitDecl();
9867}
9868
9869Expected<Decl *> ASTImporter::Import(Decl *FromD) {
9870 if (!FromD)
9871 return nullptr;
9872
9873 // Push FromD to the stack, and remove that when we return.
9874 ImportPath.push(D: FromD);
9875 llvm::scope_exit ImportPathBuilder([this]() { ImportPath.pop(); });
9876
9877 // Check whether there was a previous failed import.
9878 // If yes return the existing error.
9879 if (auto Error = getImportDeclErrorIfAny(FromD))
9880 return make_error<ASTImportError>(Args&: *Error);
9881
9882 // Check whether we've already imported this declaration.
9883 Decl *ToD = GetAlreadyImportedOrNull(FromD);
9884 if (ToD) {
9885 // Already imported (possibly from another TU) and with an error.
9886 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
9887 setImportDeclError(From: FromD, Error: *Error);
9888 return make_error<ASTImportError>(Args&: *Error);
9889 }
9890
9891 // If FromD has some updated flags after last import, apply it.
9892 updateFlags(From: FromD, To: ToD);
9893 // If we encounter a cycle during an import then we save the relevant part
9894 // of the import path associated to the Decl.
9895 if (ImportPath.hasCycleAtBack())
9896 SavedImportPaths[FromD].push_back(Elt: ImportPath.copyCycleAtBack());
9897 return ToD;
9898 }
9899
9900 // Import the declaration.
9901 ExpectedDecl ToDOrErr = ImportImpl(FromD);
9902 if (!ToDOrErr) {
9903 // Failed to import.
9904
9905 auto Pos = ImportedDecls.find(Val: FromD);
9906 bool ToDWasCreated = Pos != ImportedDecls.end();
9907 // Capture the mapped decl before erasing: the iterator is invalidated by
9908 // the erase below under backward-shift deletion, but it is still needed
9909 // further down to record the import error.
9910 Decl *CreatedToD = ToDWasCreated ? Pos->second : nullptr;
9911 if (ToDWasCreated) {
9912 // Import failed after the object was created.
9913 // Remove all references to it.
9914 auto *ToD = CreatedToD;
9915 ImportedDecls.erase(I: Pos);
9916
9917 // Remove the imported type mapping as well.
9918 // The imported type can point to a declaration that failed to import
9919 // later.
9920 if (const auto *FromTD = dyn_cast<TagDecl>(Val: FromD)) {
9921 if (const Type *FromTy =
9922 getFromContext().getCanonicalTagType(TD: FromTD).getTypePtr()) {
9923 ImportedTypes.erase(Val: FromTy);
9924 }
9925 }
9926
9927 // ImportedDecls and ImportedFromDecls are not symmetric. It may happen
9928 // (e.g. with namespaces) that several decls from the 'from' context are
9929 // mapped to the same decl in the 'to' context. If we removed entries
9930 // from the LookupTable here then we may end up removing them multiple
9931 // times.
9932
9933 // The Lookuptable contains decls only which are in the 'to' context.
9934 // Remove from the Lookuptable only if it is *imported* into the 'to'
9935 // context (and do not remove it if it was added during the initial
9936 // traverse of the 'to' context).
9937 auto PosF = ImportedFromDecls.find(Val: ToD);
9938 if (PosF != ImportedFromDecls.end()) {
9939 // In the case of TypedefNameDecl we create the Decl first and only
9940 // then we import and set its DeclContext. So, the DC might not be set
9941 // when we reach here.
9942 if (ToD->getDeclContext())
9943 SharedState->removeDeclFromLookup(D: ToD);
9944 ImportedFromDecls.erase(I: PosF);
9945 }
9946
9947 // FIXME: AST may contain remaining references to the failed object.
9948 // However, the ImportDeclErrors in the shared state contains all the
9949 // failed objects together with their error.
9950 }
9951
9952 // Error encountered for the first time.
9953 // After takeError the error is not usable any more in ToDOrErr.
9954 // Get a copy of the error object (any more simple solution for this?).
9955 ASTImportError ErrOut;
9956 handleAllErrors(E: ToDOrErr.takeError(),
9957 Handlers: [&ErrOut](const ASTImportError &E) { ErrOut = E; });
9958 setImportDeclError(From: FromD, Error: ErrOut);
9959 // Set the error for the mapped to Decl, which is in the "to" context.
9960 if (ToDWasCreated)
9961 SharedState->setImportDeclError(To: CreatedToD, Error: ErrOut);
9962
9963 // Set the error for all nodes which have been created before we
9964 // recognized the error.
9965 for (const auto &Path : SavedImportPaths[FromD]) {
9966 // The import path contains import-dependency nodes first.
9967 // Save the node that was imported as dependency of the current node.
9968 Decl *PrevFromDi = FromD;
9969 for (Decl *FromDi : Path) {
9970 // Begin and end of the path equals 'FromD', skip it.
9971 if (FromDi == FromD)
9972 continue;
9973 // We should not set import error on a node and all following nodes in
9974 // the path if child import errors are ignored.
9975 if (ChildErrorHandlingStrategy(FromDi).ignoreChildErrorOnParent(
9976 FromChildD: PrevFromDi))
9977 break;
9978 PrevFromDi = FromDi;
9979 setImportDeclError(From: FromDi, Error: ErrOut);
9980
9981 if (const auto *FromTDi = dyn_cast<TagDecl>(Val: FromDi)) {
9982 if (const Type *FromTyi =
9983 getFromContext().getCanonicalTagType(TD: FromTDi).getTypePtr()) {
9984 ImportedTypes.erase(Val: FromTyi);
9985 }
9986 }
9987
9988 //FIXME Should we remove these Decls from ImportedDecls?
9989 // Set the error for the mapped to Decl, which is in the "to" context.
9990 auto Ii = ImportedDecls.find(Val: FromDi);
9991 if (Ii != ImportedDecls.end())
9992 SharedState->setImportDeclError(To: Ii->second, Error: ErrOut);
9993 // FIXME Should we remove these Decls from the LookupTable,
9994 // and from ImportedFromDecls?
9995 }
9996 }
9997 SavedImportPaths.erase(Val: FromD);
9998
9999 // Do not return ToDOrErr, error was taken out of it.
10000 return make_error<ASTImportError>(Args&: ErrOut);
10001 }
10002
10003 ToD = *ToDOrErr;
10004
10005 // FIXME: Handle the "already imported with error" case. We can get here
10006 // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
10007 // previously failed create was requested).
10008 // Later GetImportedOrCreateDecl can be updated to return the error.
10009 if (!ToD) {
10010 auto Err = getImportDeclErrorIfAny(FromD);
10011 assert(Err);
10012 return make_error<ASTImportError>(Args&: *Err);
10013 }
10014
10015 // We could import from the current TU without error. But previously we
10016 // already had imported a Decl as `ToD` from another TU (with another
10017 // ASTImporter object) and with an error.
10018 if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
10019 setImportDeclError(From: FromD, Error: *Error);
10020 return make_error<ASTImportError>(Args&: *Error);
10021 }
10022 // Make sure that ImportImpl registered the imported decl.
10023 assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
10024
10025 if (FromD->hasAttrs())
10026 for (const Attr *FromAttr : FromD->getAttrs()) {
10027 auto ToAttrOrErr = Import(FromAttr);
10028 if (ToAttrOrErr)
10029 ToD->addAttr(A: *ToAttrOrErr);
10030 else
10031 return ToAttrOrErr.takeError();
10032 }
10033
10034 // Notify subclasses.
10035 Imported(From: FromD, To: ToD);
10036
10037 updateFlags(From: FromD, To: ToD);
10038 SavedImportPaths.erase(Val: FromD);
10039 return ToDOrErr;
10040}
10041
10042llvm::Expected<InheritedConstructor>
10043ASTImporter::Import(const InheritedConstructor &From) {
10044 return ASTNodeImporter(*this).ImportInheritedConstructor(From);
10045}
10046
10047Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
10048 if (!FromDC)
10049 return FromDC;
10050
10051 ExpectedDecl ToDCOrErr = Import(FromD: cast<Decl>(Val: FromDC));
10052 if (!ToDCOrErr)
10053 return ToDCOrErr.takeError();
10054 auto *ToDC = cast<DeclContext>(Val: *ToDCOrErr);
10055
10056 // When we're using a record/enum/Objective-C class/protocol as a context, we
10057 // need it to have a definition.
10058 if (auto *ToRecord = dyn_cast<RecordDecl>(Val: ToDC)) {
10059 auto *FromRecord = cast<RecordDecl>(Val: FromDC);
10060 if (ToRecord->isCompleteDefinition())
10061 return ToDC;
10062
10063 // If FromRecord is not defined we need to force it to be.
10064 // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
10065 // it will start the definition but we never finish it.
10066 // If there are base classes they won't be imported and we will
10067 // be missing anything that we inherit from those bases.
10068 if (FromRecord->getASTContext().getExternalSource() &&
10069 !FromRecord->isCompleteDefinition())
10070 FromRecord->getASTContext().getExternalSource()->CompleteType(Tag: FromRecord);
10071
10072 if (FromRecord->isCompleteDefinition())
10073 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10074 From: FromRecord, To: ToRecord, Kind: ASTNodeImporter::IDK_Basic))
10075 return std::move(Err);
10076 } else if (auto *ToEnum = dyn_cast<EnumDecl>(Val: ToDC)) {
10077 auto *FromEnum = cast<EnumDecl>(Val: FromDC);
10078 if (ToEnum->isCompleteDefinition()) {
10079 // Do nothing.
10080 } else if (FromEnum->isCompleteDefinition()) {
10081 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10082 From: FromEnum, To: ToEnum, Kind: ASTNodeImporter::IDK_Basic))
10083 return std::move(Err);
10084 } else {
10085 CompleteDecl(D: ToEnum);
10086 }
10087 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(Val: ToDC)) {
10088 auto *FromClass = cast<ObjCInterfaceDecl>(Val: FromDC);
10089 if (ToClass->getDefinition()) {
10090 // Do nothing.
10091 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
10092 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10093 From: FromDef, To: ToClass, Kind: ASTNodeImporter::IDK_Basic))
10094 return std::move(Err);
10095 } else {
10096 CompleteDecl(D: ToClass);
10097 }
10098 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(Val: ToDC)) {
10099 auto *FromProto = cast<ObjCProtocolDecl>(Val: FromDC);
10100 if (ToProto->getDefinition()) {
10101 // Do nothing.
10102 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
10103 if (Error Err = ASTNodeImporter(*this).ImportDefinition(
10104 From: FromDef, To: ToProto, Kind: ASTNodeImporter::IDK_Basic))
10105 return std::move(Err);
10106 } else {
10107 CompleteDecl(D: ToProto);
10108 }
10109 }
10110
10111 return ToDC;
10112}
10113
10114Expected<Expr *> ASTImporter::Import(Expr *FromE) {
10115 if (ExpectedStmt ToSOrErr = Import(FromS: cast_or_null<Stmt>(Val: FromE)))
10116 return cast_or_null<Expr>(Val: *ToSOrErr);
10117 else
10118 return ToSOrErr.takeError();
10119}
10120
10121Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
10122 if (!FromS)
10123 return nullptr;
10124
10125 // Check whether we've already imported this statement.
10126 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(Val: FromS);
10127 if (Pos != ImportedStmts.end())
10128 return Pos->second;
10129
10130 // Import the statement.
10131 ASTNodeImporter Importer(*this);
10132 ExpectedStmt ToSOrErr = Importer.Visit(S: FromS);
10133 if (!ToSOrErr)
10134 return ToSOrErr;
10135
10136 if (auto *ToE = dyn_cast<Expr>(Val: *ToSOrErr)) {
10137 auto *FromE = cast<Expr>(Val: FromS);
10138 // Copy ExprBitfields, which may not be handled in Expr subclasses
10139 // constructors.
10140 ToE->setValueKind(FromE->getValueKind());
10141 ToE->setObjectKind(FromE->getObjectKind());
10142 ToE->setDependence(FromE->getDependence());
10143 }
10144
10145 // Record the imported statement object.
10146 ImportedStmts[FromS] = *ToSOrErr;
10147 return ToSOrErr;
10148}
10149
10150Expected<NestedNameSpecifier> ASTImporter::Import(NestedNameSpecifier FromNNS) {
10151 switch (FromNNS.getKind()) {
10152 case NestedNameSpecifier::Kind::Null:
10153 case NestedNameSpecifier::Kind::Global:
10154 return FromNNS;
10155 case NestedNameSpecifier::Kind::Namespace: {
10156 auto [Namespace, Prefix] = FromNNS.getAsNamespaceAndPrefix();
10157 auto NSOrErr = Import(FromD: Namespace);
10158 if (!NSOrErr)
10159 return NSOrErr.takeError();
10160 auto PrefixOrErr = Import(FromNNS: Prefix);
10161 if (!PrefixOrErr)
10162 return PrefixOrErr.takeError();
10163 return NestedNameSpecifier(ToContext, cast<NamespaceBaseDecl>(Val: *NSOrErr),
10164 *PrefixOrErr);
10165 }
10166 case NestedNameSpecifier::Kind::MicrosoftSuper:
10167 if (ExpectedDecl RDOrErr = Import(FromD: FromNNS.getAsMicrosoftSuper()))
10168 return NestedNameSpecifier(cast<CXXRecordDecl>(Val: *RDOrErr));
10169 else
10170 return RDOrErr.takeError();
10171 case NestedNameSpecifier::Kind::Type:
10172 if (ExpectedTypePtr TyOrErr = Import(FromT: FromNNS.getAsType())) {
10173 return NestedNameSpecifier(*TyOrErr);
10174 } else {
10175 return TyOrErr.takeError();
10176 }
10177 }
10178 llvm_unreachable("Invalid nested name specifier kind");
10179}
10180
10181Expected<NestedNameSpecifierLoc>
10182ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
10183 // Copied from NestedNameSpecifier mostly.
10184 SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
10185 NestedNameSpecifierLoc NNS = FromNNS;
10186
10187 // Push each of the nested-name-specifiers's onto a stack for
10188 // serialization in reverse order.
10189 while (NNS) {
10190 NestedNames.push_back(Elt: NNS);
10191 NNS = NNS.getAsNamespaceAndPrefix().Prefix;
10192 }
10193
10194 NestedNameSpecifierLocBuilder Builder;
10195
10196 while (!NestedNames.empty()) {
10197 NNS = NestedNames.pop_back_val();
10198 NestedNameSpecifier Spec = std::nullopt;
10199 if (Error Err = importInto(To&: Spec, From: NNS.getNestedNameSpecifier()))
10200 return std::move(Err);
10201
10202 NestedNameSpecifier::Kind Kind = Spec.getKind();
10203
10204 SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
10205 if (Kind != NestedNameSpecifier::Kind::MicrosoftSuper) {
10206 if (Error Err = importInto(To&: ToLocalBeginLoc, From: NNS.getLocalBeginLoc()))
10207 return std::move(Err);
10208
10209 if (Kind != NestedNameSpecifier::Kind::Global)
10210 if (Error Err = importInto(To&: ToLocalEndLoc, From: NNS.getLocalEndLoc()))
10211 return std::move(Err);
10212 }
10213
10214 switch (Kind) {
10215 case NestedNameSpecifier::Kind::Namespace:
10216 Builder.Extend(Context&: getToContext(), Namespace: Spec.getAsNamespaceAndPrefix().Namespace,
10217 NamespaceLoc: ToLocalBeginLoc, ColonColonLoc: ToLocalEndLoc);
10218 break;
10219
10220 case NestedNameSpecifier::Kind::Type: {
10221 SourceLocation ToTLoc;
10222 if (Error Err = importInto(To&: ToTLoc, From: NNS.castAsTypeLoc().getBeginLoc()))
10223 return std::move(Err);
10224 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
10225 T: QualType(Spec.getAsType(), 0), Loc: ToTLoc);
10226 Builder.Make(Context&: getToContext(), TL: TSI->getTypeLoc(), ColonColonLoc: ToLocalEndLoc);
10227 break;
10228 }
10229
10230 case NestedNameSpecifier::Kind::Global:
10231 Builder.MakeGlobal(Context&: getToContext(), ColonColonLoc: ToLocalBeginLoc);
10232 break;
10233
10234 case NestedNameSpecifier::Kind::MicrosoftSuper: {
10235 auto ToSourceRangeOrErr = Import(FromRange: NNS.getSourceRange());
10236 if (!ToSourceRangeOrErr)
10237 return ToSourceRangeOrErr.takeError();
10238
10239 Builder.MakeMicrosoftSuper(Context&: getToContext(), RD: Spec.getAsMicrosoftSuper(),
10240 SuperLoc: ToSourceRangeOrErr->getBegin(),
10241 ColonColonLoc: ToSourceRangeOrErr->getEnd());
10242 break;
10243 }
10244 case NestedNameSpecifier::Kind::Null:
10245 llvm_unreachable("unexpected null nested name specifier");
10246 }
10247 }
10248
10249 return Builder.getWithLocInContext(Context&: getToContext());
10250}
10251
10252Expected<TemplateName> ASTImporter::Import(TemplateName From) {
10253 switch (From.getKind()) {
10254 case TemplateName::Template:
10255 if (ExpectedDecl ToTemplateOrErr = Import(FromD: From.getAsTemplateDecl()))
10256 return TemplateName(cast<TemplateDecl>(Val: (*ToTemplateOrErr)->getCanonicalDecl()));
10257 else
10258 return ToTemplateOrErr.takeError();
10259
10260 case TemplateName::OverloadedTemplate: {
10261 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
10262 UnresolvedSet<2> ToTemplates;
10263 for (auto *I : *FromStorage) {
10264 if (auto ToOrErr = Import(FromD: I))
10265 ToTemplates.addDecl(D: cast<NamedDecl>(Val: *ToOrErr));
10266 else
10267 return ToOrErr.takeError();
10268 }
10269 return ToContext.getOverloadedTemplateName(Begin: ToTemplates.begin(),
10270 End: ToTemplates.end());
10271 }
10272
10273 case TemplateName::AssumedTemplate: {
10274 AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
10275 auto DeclNameOrErr = Import(FromName: FromStorage->getDeclName());
10276 if (!DeclNameOrErr)
10277 return DeclNameOrErr.takeError();
10278 return ToContext.getAssumedTemplateName(Name: *DeclNameOrErr);
10279 }
10280
10281 case TemplateName::QualifiedTemplate: {
10282 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
10283 auto QualifierOrErr = Import(FromNNS: QTN->getQualifier());
10284 if (!QualifierOrErr)
10285 return QualifierOrErr.takeError();
10286 auto TNOrErr = Import(From: QTN->getUnderlyingTemplate());
10287 if (!TNOrErr)
10288 return TNOrErr.takeError();
10289 return ToContext.getQualifiedTemplateName(
10290 Qualifier: *QualifierOrErr, TemplateKeyword: QTN->hasTemplateKeyword(), Template: *TNOrErr);
10291 }
10292
10293 case TemplateName::DependentTemplate: {
10294 DependentTemplateName *DTN = From.getAsDependentTemplateName();
10295 auto QualifierOrErr = Import(FromNNS: DTN->getQualifier());
10296 if (!QualifierOrErr)
10297 return QualifierOrErr.takeError();
10298 return ToContext.getDependentTemplateName(
10299 Name: {*QualifierOrErr, Import(FromIO: DTN->getName()), DTN->hasTemplateKeyword()});
10300 }
10301
10302 case TemplateName::SubstTemplateTemplateParm: {
10303 SubstTemplateTemplateParmStorage *Subst =
10304 From.getAsSubstTemplateTemplateParm();
10305 auto ReplacementOrErr = Import(From: Subst->getReplacement());
10306 if (!ReplacementOrErr)
10307 return ReplacementOrErr.takeError();
10308
10309 auto AssociatedDeclOrErr = Import(FromD: Subst->getAssociatedDecl());
10310 if (!AssociatedDeclOrErr)
10311 return AssociatedDeclOrErr.takeError();
10312
10313 return ToContext.getSubstTemplateTemplateParm(
10314 replacement: *ReplacementOrErr, AssociatedDecl: *AssociatedDeclOrErr, Index: Subst->getIndex(),
10315 PackIndex: Subst->getPackIndex(), Final: Subst->getFinal());
10316 }
10317
10318 case TemplateName::SubstTemplateTemplateParmPack: {
10319 SubstTemplateTemplateParmPackStorage *SubstPack =
10320 From.getAsSubstTemplateTemplateParmPack();
10321 ASTNodeImporter Importer(*this);
10322 auto ArgPackOrErr =
10323 Importer.ImportTemplateArgument(From: SubstPack->getArgumentPack());
10324 if (!ArgPackOrErr)
10325 return ArgPackOrErr.takeError();
10326
10327 auto AssociatedDeclOrErr = Import(FromD: SubstPack->getAssociatedDecl());
10328 if (!AssociatedDeclOrErr)
10329 return AssociatedDeclOrErr.takeError();
10330
10331 return ToContext.getSubstTemplateTemplateParmPack(
10332 ArgPack: *ArgPackOrErr, AssociatedDecl: *AssociatedDeclOrErr, Index: SubstPack->getIndex(),
10333 Final: SubstPack->getFinal());
10334 }
10335 case TemplateName::PackIndexingTemplate: {
10336 PackIndexingTemplateStorage *PI = From.getAsPackIndexingTemplate();
10337 auto PatternOrErr = Import(From: PI->getPattern());
10338 if (!PatternOrErr)
10339 return PatternOrErr.takeError();
10340
10341 auto IndexExprOrErr = Import(FromE: PI->getIndexExpr());
10342 if (!IndexExprOrErr)
10343 return IndexExprOrErr.takeError();
10344
10345 SmallVector<TemplateName, 4> Expansions;
10346 for (TemplateName T : PI->getExpansions()) {
10347 auto ExpansionOrErr = Import(From: T);
10348 if (!ExpansionOrErr)
10349 return ExpansionOrErr.takeError();
10350 Expansions.push_back(Elt: *ExpansionOrErr);
10351 }
10352
10353 return ToContext.getPackIndexingTemplateName(
10354 Pattern: *PatternOrErr, IndexExpr: *IndexExprOrErr, FullySubstituted: PI->isFullySubstituted(), Expansions);
10355 }
10356 case TemplateName::UsingTemplate: {
10357 auto UsingOrError = Import(FromD: From.getAsUsingShadowDecl());
10358 if (!UsingOrError)
10359 return UsingOrError.takeError();
10360 return TemplateName(cast<UsingShadowDecl>(Val: *UsingOrError));
10361 }
10362 case TemplateName::DeducedTemplate:
10363 llvm_unreachable("Unexpected DeducedTemplate");
10364 }
10365
10366 llvm_unreachable("Invalid template name kind");
10367}
10368
10369Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
10370 if (FromLoc.isInvalid())
10371 return SourceLocation{};
10372
10373 SourceManager &FromSM = FromContext.getSourceManager();
10374 bool IsBuiltin = FromSM.isWrittenInBuiltinFile(Loc: FromLoc);
10375
10376 FileIDAndOffset Decomposed = FromSM.getDecomposedLoc(Loc: FromLoc);
10377 Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
10378 if (!ToFileIDOrErr)
10379 return ToFileIDOrErr.takeError();
10380 SourceManager &ToSM = ToContext.getSourceManager();
10381 return ToSM.getComposedLoc(FID: *ToFileIDOrErr, Offset: Decomposed.second);
10382}
10383
10384Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
10385 SourceLocation ToBegin, ToEnd;
10386 if (Error Err = importInto(To&: ToBegin, From: FromRange.getBegin()))
10387 return std::move(Err);
10388 if (Error Err = importInto(To&: ToEnd, From: FromRange.getEnd()))
10389 return std::move(Err);
10390
10391 return SourceRange(ToBegin, ToEnd);
10392}
10393
10394Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
10395 llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(Val: FromID);
10396 if (Pos != ImportedFileIDs.end())
10397 return Pos->second;
10398
10399 SourceManager &FromSM = FromContext.getSourceManager();
10400 SourceManager &ToSM = ToContext.getSourceManager();
10401 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FID: FromID);
10402
10403 // Map the FromID to the "to" source manager.
10404 FileID ToID;
10405 if (FromSLoc.isExpansion()) {
10406 const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
10407 ExpectedSLoc ToSpLoc = Import(FromLoc: FromEx.getSpellingLoc());
10408 if (!ToSpLoc)
10409 return ToSpLoc.takeError();
10410 ExpectedSLoc ToExLocS = Import(FromLoc: FromEx.getExpansionLocStart());
10411 if (!ToExLocS)
10412 return ToExLocS.takeError();
10413 unsigned ExLength = FromSM.getFileIDSize(FID: FromID);
10414 SourceLocation MLoc;
10415 if (FromEx.isMacroArgExpansion()) {
10416 MLoc = ToSM.createMacroArgExpansionLoc(SpellingLoc: *ToSpLoc, ExpansionLoc: *ToExLocS, Length: ExLength);
10417 } else {
10418 if (ExpectedSLoc ToExLocE = Import(FromLoc: FromEx.getExpansionLocEnd()))
10419 MLoc = ToSM.createExpansionLoc(SpellingLoc: *ToSpLoc, ExpansionLocStart: *ToExLocS, ExpansionLocEnd: *ToExLocE, Length: ExLength,
10420 ExpansionIsTokenRange: FromEx.isExpansionTokenRange());
10421 else
10422 return ToExLocE.takeError();
10423 }
10424 ToID = ToSM.getFileID(SpellingLoc: MLoc);
10425 } else {
10426 const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
10427
10428 if (!IsBuiltin && !Cache->BufferOverridden) {
10429 // Include location of this file.
10430 ExpectedSLoc ToIncludeLoc = Import(FromLoc: FromSLoc.getFile().getIncludeLoc());
10431 if (!ToIncludeLoc)
10432 return ToIncludeLoc.takeError();
10433
10434 // Every FileID that is not the main FileID needs to have a valid include
10435 // location so that the include chain points to the main FileID. When
10436 // importing the main FileID (which has no include location), we need to
10437 // create a fake include location in the main file to keep this property
10438 // intact.
10439 SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
10440 if (FromID == FromSM.getMainFileID())
10441 ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(FID: ToSM.getMainFileID());
10442
10443 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
10444 // FIXME: We probably want to use getVirtualFileRef(), so we don't hit
10445 // the disk again
10446 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
10447 // than mmap the files several times.
10448 auto Entry =
10449 ToFileManager.getOptionalFileRef(Filename: Cache->OrigEntry->getName());
10450 // FIXME: The filename may be a virtual name that does probably not
10451 // point to a valid file and we get no Entry here. In this case try with
10452 // the memory buffer below.
10453 if (Entry)
10454 ToID = ToSM.createFileID(SourceFile: *Entry, IncludePos: ToIncludeLocOrFakeLoc,
10455 FileCharacter: FromSLoc.getFile().getFileCharacteristic());
10456 }
10457 }
10458
10459 if (ToID.isInvalid() || IsBuiltin) {
10460 // FIXME: We want to re-use the existing MemoryBuffer!
10461 std::optional<llvm::MemoryBufferRef> FromBuf =
10462 Cache->getBufferOrNone(Diag&: FromContext.getDiagnostics(),
10463 FM&: FromSM.getFileManager(), Loc: SourceLocation{});
10464 if (!FromBuf)
10465 return llvm::make_error<ASTImportError>(Args: ASTImportError::Unknown);
10466
10467 std::unique_ptr<llvm::MemoryBuffer> ToBuf =
10468 llvm::MemoryBuffer::getMemBufferCopy(InputData: FromBuf->getBuffer(),
10469 BufferName: FromBuf->getBufferIdentifier());
10470 ToID = ToSM.createFileID(Buffer: std::move(ToBuf),
10471 FileCharacter: FromSLoc.getFile().getFileCharacteristic());
10472 }
10473 }
10474
10475 assert(ToID.isValid() && "Unexpected invalid fileID was created.");
10476
10477 ImportedFileIDs[FromID] = ToID;
10478 return ToID;
10479}
10480
10481Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
10482 ExpectedExpr ToExprOrErr = Import(FromE: From->getInit());
10483 if (!ToExprOrErr)
10484 return ToExprOrErr.takeError();
10485
10486 auto LParenLocOrErr = Import(FromLoc: From->getLParenLoc());
10487 if (!LParenLocOrErr)
10488 return LParenLocOrErr.takeError();
10489
10490 auto RParenLocOrErr = Import(FromLoc: From->getRParenLoc());
10491 if (!RParenLocOrErr)
10492 return RParenLocOrErr.takeError();
10493
10494 if (From->isBaseInitializer()) {
10495 auto ToTInfoOrErr = Import(FromTSI: From->getTypeSourceInfo());
10496 if (!ToTInfoOrErr)
10497 return ToTInfoOrErr.takeError();
10498
10499 SourceLocation EllipsisLoc;
10500 if (From->isPackExpansion())
10501 if (Error Err = importInto(To&: EllipsisLoc, From: From->getEllipsisLoc()))
10502 return std::move(Err);
10503
10504 return new (ToContext) CXXCtorInitializer(
10505 ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
10506 *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
10507 } else if (From->isMemberInitializer()) {
10508 ExpectedDecl ToFieldOrErr = Import(FromD: From->getMember());
10509 if (!ToFieldOrErr)
10510 return ToFieldOrErr.takeError();
10511
10512 auto MemberLocOrErr = Import(FromLoc: From->getMemberLocation());
10513 if (!MemberLocOrErr)
10514 return MemberLocOrErr.takeError();
10515
10516 return new (ToContext) CXXCtorInitializer(
10517 ToContext, cast_or_null<FieldDecl>(Val: *ToFieldOrErr), *MemberLocOrErr,
10518 *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10519 } else if (From->isIndirectMemberInitializer()) {
10520 ExpectedDecl ToIFieldOrErr = Import(FromD: From->getIndirectMember());
10521 if (!ToIFieldOrErr)
10522 return ToIFieldOrErr.takeError();
10523
10524 auto MemberLocOrErr = Import(FromLoc: From->getMemberLocation());
10525 if (!MemberLocOrErr)
10526 return MemberLocOrErr.takeError();
10527
10528 return new (ToContext) CXXCtorInitializer(
10529 ToContext, cast_or_null<IndirectFieldDecl>(Val: *ToIFieldOrErr),
10530 *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
10531 } else if (From->isDelegatingInitializer()) {
10532 auto ToTInfoOrErr = Import(FromTSI: From->getTypeSourceInfo());
10533 if (!ToTInfoOrErr)
10534 return ToTInfoOrErr.takeError();
10535
10536 return new (ToContext)
10537 CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
10538 *ToExprOrErr, *RParenLocOrErr);
10539 } else {
10540 // FIXME: assert?
10541 return make_error<ASTImportError>();
10542 }
10543}
10544
10545Expected<CXXBaseSpecifier *>
10546ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
10547 auto Pos = ImportedCXXBaseSpecifiers.find(Val: BaseSpec);
10548 if (Pos != ImportedCXXBaseSpecifiers.end())
10549 return Pos->second;
10550
10551 Expected<SourceRange> ToSourceRange = Import(FromRange: BaseSpec->getSourceRange());
10552 if (!ToSourceRange)
10553 return ToSourceRange.takeError();
10554 Expected<TypeSourceInfo *> ToTSI = Import(FromTSI: BaseSpec->getTypeSourceInfo());
10555 if (!ToTSI)
10556 return ToTSI.takeError();
10557 ExpectedSLoc ToEllipsisLoc = Import(FromLoc: BaseSpec->getEllipsisLoc());
10558 if (!ToEllipsisLoc)
10559 return ToEllipsisLoc.takeError();
10560 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
10561 *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
10562 BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
10563 ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
10564 return Imported;
10565}
10566
10567llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
10568 ASTNodeImporter Importer(*this);
10569 return Importer.ImportAPValue(FromValue);
10570}
10571
10572Error ASTImporter::ImportDefinition(Decl *From) {
10573 ExpectedDecl ToOrErr = Import(FromD: From);
10574 if (!ToOrErr)
10575 return ToOrErr.takeError();
10576 Decl *To = *ToOrErr;
10577
10578 auto *FromDC = cast<DeclContext>(Val: From);
10579 ASTNodeImporter Importer(*this);
10580
10581 if (auto *ToRecord = dyn_cast<RecordDecl>(Val: To)) {
10582 if (!ToRecord->getDefinition()) {
10583 return Importer.ImportDefinition(
10584 From: cast<RecordDecl>(Val: FromDC), To: ToRecord,
10585 Kind: ASTNodeImporter::IDK_Everything);
10586 }
10587 }
10588
10589 if (auto *ToEnum = dyn_cast<EnumDecl>(Val: To)) {
10590 if (!ToEnum->getDefinition()) {
10591 return Importer.ImportDefinition(
10592 From: cast<EnumDecl>(Val: FromDC), To: ToEnum, Kind: ASTNodeImporter::IDK_Everything);
10593 }
10594 }
10595
10596 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(Val: To)) {
10597 if (!ToIFace->getDefinition()) {
10598 return Importer.ImportDefinition(
10599 From: cast<ObjCInterfaceDecl>(Val: FromDC), To: ToIFace,
10600 Kind: ASTNodeImporter::IDK_Everything);
10601 }
10602 }
10603
10604 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(Val: To)) {
10605 if (!ToProto->getDefinition()) {
10606 return Importer.ImportDefinition(
10607 From: cast<ObjCProtocolDecl>(Val: FromDC), To: ToProto,
10608 Kind: ASTNodeImporter::IDK_Everything);
10609 }
10610 }
10611
10612 return Importer.ImportDeclContext(FromDC, ForceImport: true);
10613}
10614
10615Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
10616 if (!FromName)
10617 return DeclarationName{};
10618
10619 switch (FromName.getNameKind()) {
10620 case DeclarationName::Identifier:
10621 return DeclarationName(Import(FromId: FromName.getAsIdentifierInfo()));
10622
10623 case DeclarationName::ObjCZeroArgSelector:
10624 case DeclarationName::ObjCOneArgSelector:
10625 case DeclarationName::ObjCMultiArgSelector:
10626 if (auto ToSelOrErr = Import(FromSel: FromName.getObjCSelector()))
10627 return DeclarationName(*ToSelOrErr);
10628 else
10629 return ToSelOrErr.takeError();
10630
10631 case DeclarationName::CXXConstructorName: {
10632 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10633 return ToContext.DeclarationNames.getCXXConstructorName(
10634 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10635 else
10636 return ToTyOrErr.takeError();
10637 }
10638
10639 case DeclarationName::CXXDestructorName: {
10640 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10641 return ToContext.DeclarationNames.getCXXDestructorName(
10642 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10643 else
10644 return ToTyOrErr.takeError();
10645 }
10646
10647 case DeclarationName::CXXDeductionGuideName: {
10648 if (auto ToTemplateOrErr = Import(FromD: FromName.getCXXDeductionGuideTemplate()))
10649 return ToContext.DeclarationNames.getCXXDeductionGuideName(
10650 TD: cast<TemplateDecl>(Val: *ToTemplateOrErr));
10651 else
10652 return ToTemplateOrErr.takeError();
10653 }
10654
10655 case DeclarationName::CXXConversionFunctionName: {
10656 if (auto ToTyOrErr = Import(FromT: FromName.getCXXNameType()))
10657 return ToContext.DeclarationNames.getCXXConversionFunctionName(
10658 Ty: ToContext.getCanonicalType(T: *ToTyOrErr));
10659 else
10660 return ToTyOrErr.takeError();
10661 }
10662
10663 case DeclarationName::CXXOperatorName:
10664 return ToContext.DeclarationNames.getCXXOperatorName(
10665 Op: FromName.getCXXOverloadedOperator());
10666
10667 case DeclarationName::CXXLiteralOperatorName:
10668 return ToContext.DeclarationNames.getCXXLiteralOperatorName(
10669 II: Import(FromId: FromName.getCXXLiteralIdentifier()));
10670
10671 case DeclarationName::CXXUsingDirective:
10672 // FIXME: STATICS!
10673 return DeclarationName::getUsingDirectiveName();
10674 }
10675
10676 llvm_unreachable("Invalid DeclarationName Kind!");
10677}
10678
10679IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
10680 if (!FromId)
10681 return nullptr;
10682
10683 IdentifierInfo *ToId = &ToContext.Idents.get(Name: FromId->getName());
10684
10685 if (!ToId->getBuiltinID() && FromId->getBuiltinID())
10686 ToId->setBuiltinID(FromId->getBuiltinID());
10687
10688 return ToId;
10689}
10690
10691IdentifierOrOverloadedOperator
10692ASTImporter::Import(IdentifierOrOverloadedOperator FromIO) {
10693 if (const IdentifierInfo *FromII = FromIO.getIdentifier())
10694 return Import(FromId: FromII);
10695 return FromIO.getOperator();
10696}
10697
10698Expected<Selector> ASTImporter::Import(Selector FromSel) {
10699 if (FromSel.isNull())
10700 return Selector{};
10701
10702 SmallVector<const IdentifierInfo *, 4> Idents;
10703 Idents.push_back(Elt: Import(FromId: FromSel.getIdentifierInfoForSlot(argIndex: 0)));
10704 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
10705 Idents.push_back(Elt: Import(FromId: FromSel.getIdentifierInfoForSlot(argIndex: I)));
10706 return ToContext.Selectors.getSelector(NumArgs: FromSel.getNumArgs(), IIV: Idents.data());
10707}
10708
10709llvm::Expected<APValue>
10710ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
10711 APValue Result;
10712 llvm::Error Err = llvm::Error::success();
10713 auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
10714 for (unsigned Idx = 0; Idx < Size; Idx++) {
10715 APValue Tmp = importChecked(Err, From: From[Idx]);
10716 To[Idx] = Tmp;
10717 }
10718 };
10719 switch (FromValue.getKind()) {
10720 case APValue::None:
10721 case APValue::Indeterminate:
10722 case APValue::Int:
10723 case APValue::Float:
10724 case APValue::FixedPoint:
10725 case APValue::ComplexInt:
10726 case APValue::ComplexFloat:
10727 Result = FromValue;
10728 break;
10729 case APValue::Vector: {
10730 Result.MakeVector();
10731 MutableArrayRef<APValue> Elts =
10732 Result.setVectorUninit(FromValue.getVectorLength());
10733 ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
10734 Elts.data(), FromValue.getVectorLength());
10735 break;
10736 }
10737 case APValue::Matrix:
10738 // Matrix values cannot currently arise in APValue import contexts.
10739 llvm_unreachable("Matrix APValue import not yet supported");
10740 case APValue::Array:
10741 Result.MakeArray(InitElts: FromValue.getArrayInitializedElts(),
10742 Size: FromValue.getArraySize());
10743 ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
10744 ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
10745 FromValue.getArrayInitializedElts());
10746 break;
10747 case APValue::Struct:
10748 Result.MakeStruct(B: FromValue.getStructNumBases(),
10749 M: FromValue.getStructNumFields(),
10750 V: FromValue.getStructNumVirtualBases());
10751 ImportLoop(
10752 ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
10753 ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
10754 FromValue.getStructNumBases() + FromValue.getStructNumFields() +
10755 FromValue.getStructNumVirtualBases());
10756 break;
10757 case APValue::Union: {
10758 Result.MakeUnion();
10759 const Decl *ImpFDecl = importChecked(Err, From: FromValue.getUnionField());
10760 APValue ImpValue = importChecked(Err, From: FromValue.getUnionValue());
10761 if (Err)
10762 return std::move(Err);
10763 Result.setUnion(Field: cast<FieldDecl>(Val: ImpFDecl), Value: ImpValue);
10764 break;
10765 }
10766 case APValue::AddrLabelDiff: {
10767 Result.MakeAddrLabelDiff();
10768 const Expr *ImpLHS = importChecked(Err, From: FromValue.getAddrLabelDiffLHS());
10769 const Expr *ImpRHS = importChecked(Err, From: FromValue.getAddrLabelDiffRHS());
10770 if (Err)
10771 return std::move(Err);
10772 Result.setAddrLabelDiff(LHSExpr: cast<AddrLabelExpr>(Val: ImpLHS),
10773 RHSExpr: cast<AddrLabelExpr>(Val: ImpRHS));
10774 break;
10775 }
10776 case APValue::MemberPointer: {
10777 const Decl *ImpMemPtrDecl =
10778 importChecked(Err, From: FromValue.getMemberPointerDecl());
10779 if (Err)
10780 return std::move(Err);
10781 MutableArrayRef<const CXXRecordDecl *> ToPath =
10782 Result.setMemberPointerUninit(
10783 Member: cast<const ValueDecl>(Val: ImpMemPtrDecl),
10784 IsDerivedMember: FromValue.isMemberPointerToDerivedMember(),
10785 Size: FromValue.getMemberPointerPath().size());
10786 ArrayRef<const CXXRecordDecl *> FromPath = Result.getMemberPointerPath();
10787 for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
10788 Idx++) {
10789 const Decl *ImpDecl = importChecked(Err, From: FromPath[Idx]);
10790 if (Err)
10791 return std::move(Err);
10792 ToPath[Idx] = cast<const CXXRecordDecl>(Val: ImpDecl->getCanonicalDecl());
10793 }
10794 break;
10795 }
10796 case APValue::LValue:
10797 APValue::LValueBase Base;
10798 QualType FromElemTy;
10799 if (FromValue.getLValueBase()) {
10800 assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&
10801 "in C++20 dynamic allocation are transient so they shouldn't "
10802 "appear in the AST");
10803 if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
10804 if (const auto *E =
10805 FromValue.getLValueBase().dyn_cast<const Expr *>()) {
10806 FromElemTy = E->getType();
10807 const Expr *ImpExpr = importChecked(Err, From: E);
10808 if (Err)
10809 return std::move(Err);
10810 Base = APValue::LValueBase(ImpExpr,
10811 FromValue.getLValueBase().getCallIndex(),
10812 FromValue.getLValueBase().getVersion());
10813 } else {
10814 FromElemTy =
10815 FromValue.getLValueBase().get<const ValueDecl *>()->getType();
10816 const Decl *ImpDecl = importChecked(
10817 Err, From: FromValue.getLValueBase().get<const ValueDecl *>());
10818 if (Err)
10819 return std::move(Err);
10820 Base = APValue::LValueBase(cast<ValueDecl>(Val: ImpDecl),
10821 FromValue.getLValueBase().getCallIndex(),
10822 FromValue.getLValueBase().getVersion());
10823 }
10824 } else {
10825 FromElemTy = FromValue.getLValueBase().getTypeInfoType();
10826 const Type *ImpTypeInfo = importChecked(
10827 Err, From: FromValue.getLValueBase().get<TypeInfoLValue>().getType());
10828 QualType ImpType =
10829 importChecked(Err, From: FromValue.getLValueBase().getTypeInfoType());
10830 if (Err)
10831 return std::move(Err);
10832 Base = APValue::LValueBase::getTypeInfo(LV: TypeInfoLValue(ImpTypeInfo),
10833 TypeInfo: ImpType);
10834 }
10835 }
10836 CharUnits Offset = FromValue.getLValueOffset();
10837 unsigned PathLength = FromValue.getLValuePath().size();
10838 Result.MakeLValue();
10839 if (FromValue.hasLValuePath()) {
10840 MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
10841 B: Base, O: Offset, Size: PathLength, OnePastTheEnd: FromValue.isLValueOnePastTheEnd(),
10842 IsNullPtr: FromValue.isNullPointer());
10843 ArrayRef<APValue::LValuePathEntry> FromPath = FromValue.getLValuePath();
10844 for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
10845 if (FromElemTy->isRecordType()) {
10846 const Decl *FromDecl =
10847 FromPath[LoopIdx].getAsBaseOrMember().getPointer();
10848 const Decl *ImpDecl = importChecked(Err, From: FromDecl);
10849 if (Err)
10850 return std::move(Err);
10851 if (auto *RD = dyn_cast<CXXRecordDecl>(Val: FromDecl))
10852 FromElemTy = Importer.FromContext.getCanonicalTagType(TD: RD);
10853 else
10854 FromElemTy = cast<ValueDecl>(Val: FromDecl)->getType();
10855 ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
10856 ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
10857 } else {
10858 FromElemTy =
10859 Importer.FromContext.getAsArrayType(T: FromElemTy)->getElementType();
10860 ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
10861 Index: FromPath[LoopIdx].getAsArrayIndex());
10862 }
10863 }
10864 } else
10865 Result.setLValue(B: Base, O: Offset, APValue::NoLValuePath{},
10866 IsNullPtr: FromValue.isNullPointer());
10867 }
10868 if (Err)
10869 return std::move(Err);
10870 return Result;
10871}
10872
10873Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
10874 DeclContext *DC,
10875 unsigned IDNS,
10876 NamedDecl **Decls,
10877 unsigned NumDecls) {
10878 if (ODRHandling == ODRHandlingType::Conservative)
10879 // Report error at any name conflict.
10880 return make_error<ASTImportError>(Args: ASTImportError::NameConflict);
10881 else
10882 // Allow to create the new Decl with the same name.
10883 return Name;
10884}
10885
10886DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
10887 if (LastDiagFromFrom)
10888 ToContext.getDiagnostics().notePriorDiagnosticFrom(
10889 Other: FromContext.getDiagnostics());
10890 LastDiagFromFrom = false;
10891 return ToContext.getDiagnostics().Report(Loc, DiagID);
10892}
10893
10894DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
10895 if (!LastDiagFromFrom)
10896 FromContext.getDiagnostics().notePriorDiagnosticFrom(
10897 Other: ToContext.getDiagnostics());
10898 LastDiagFromFrom = true;
10899 return FromContext.getDiagnostics().Report(Loc, DiagID);
10900}
10901
10902void ASTImporter::CompleteDecl (Decl *D) {
10903 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(Val: D)) {
10904 if (!ID->getDefinition())
10905 ID->startDefinition();
10906 }
10907 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(Val: D)) {
10908 if (!PD->getDefinition())
10909 PD->startDefinition();
10910 }
10911 else if (auto *TD = dyn_cast<TagDecl>(Val: D)) {
10912 if (!TD->getDefinition() && !TD->isBeingDefined()) {
10913 TD->startDefinition();
10914 TD->setCompleteDefinition(true);
10915 }
10916 }
10917 else {
10918 assert(0 && "CompleteDecl called on a Decl that can't be completed");
10919 }
10920}
10921
10922Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
10923 auto [Pos, Inserted] = ImportedDecls.try_emplace(Key: From, Args&: To);
10924 assert((Inserted || Pos->second == To) &&
10925 "Try to import an already imported Decl");
10926 if (!Inserted)
10927 return Pos->second;
10928 // This mapping should be maintained only in this function. Therefore do not
10929 // check for additional consistency.
10930 ImportedFromDecls[To] = From;
10931 // In the case of TypedefNameDecl we create the Decl first and only then we
10932 // import and set its DeclContext. So, the DC is still not set when we reach
10933 // here from GetImportedOrCreateDecl.
10934 if (To->getDeclContext())
10935 AddToLookupTable(ToD: To);
10936 return To;
10937}
10938
10939std::optional<ASTImportError>
10940ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
10941 auto Pos = ImportDeclErrors.find(Val: FromD);
10942 if (Pos != ImportDeclErrors.end())
10943 return Pos->second;
10944 else
10945 return std::nullopt;
10946}
10947
10948void ASTImporter::setImportDeclError(Decl *From, ASTImportError Error) {
10949 auto InsertRes = ImportDeclErrors.insert(KV: {From, Error});
10950 (void)InsertRes;
10951 // Either we set the error for the first time, or we already had set one and
10952 // now we want to set the same error.
10953 assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
10954}
10955
10956bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
10957 bool Complain) {
10958 llvm::DenseMap<const Type *, const Type *>::iterator Pos =
10959 ImportedTypes.find(Val: From.getTypePtr());
10960 if (Pos != ImportedTypes.end()) {
10961 if (ExpectedType ToFromOrErr = Import(FromT: From)) {
10962 if (ToContext.hasSameType(T1: *ToFromOrErr, T2: To))
10963 return true;
10964 } else {
10965 llvm::consumeError(Err: ToFromOrErr.takeError());
10966 }
10967 }
10968
10969 StructuralEquivalenceContext Ctx(
10970 getToContext().getLangOpts(), FromContext, ToContext, NonEquivalentDecls,
10971 getStructuralEquivalenceKind(Importer: *this), false, Complain);
10972 return Ctx.IsEquivalent(T1: From, T2: To);
10973}
10974