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