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