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