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