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/ASTImporterSharedState.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTDiagnostic.h"
18 #include "clang/AST/ASTStructuralEquivalence.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclAccessPair.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
28 #include "clang/AST/DeclVisitor.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExprObjC.h"
33 #include "clang/AST/ExternalASTSource.h"
34 #include "clang/AST/LambdaCapture.h"
35 #include "clang/AST/NestedNameSpecifier.h"
36 #include "clang/AST/OperationKinds.h"
37 #include "clang/AST/Stmt.h"
38 #include "clang/AST/StmtCXX.h"
39 #include "clang/AST/StmtObjC.h"
40 #include "clang/AST/StmtVisitor.h"
41 #include "clang/AST/TemplateBase.h"
42 #include "clang/AST/TemplateName.h"
43 #include "clang/AST/Type.h"
44 #include "clang/AST/TypeLoc.h"
45 #include "clang/AST/TypeVisitor.h"
46 #include "clang/AST/UnresolvedSet.h"
47 #include "clang/Basic/Builtins.h"
48 #include "clang/Basic/ExceptionSpecificationType.h"
49 #include "clang/Basic/FileManager.h"
50 #include "clang/Basic/IdentifierTable.h"
51 #include "clang/Basic/LLVM.h"
52 #include "clang/Basic/LangOptions.h"
53 #include "clang/Basic/SourceLocation.h"
54 #include "clang/Basic/SourceManager.h"
55 #include "clang/Basic/Specifiers.h"
56 #include "llvm/ADT/APSInt.h"
57 #include "llvm/ADT/ArrayRef.h"
58 #include "llvm/ADT/DenseMap.h"
59 #include "llvm/ADT/None.h"
60 #include "llvm/ADT/Optional.h"
61 #include "llvm/ADT/ScopeExit.h"
62 #include "llvm/ADT/STLExtras.h"
63 #include "llvm/ADT/SmallVector.h"
64 #include "llvm/Support/Casting.h"
65 #include "llvm/Support/ErrorHandling.h"
66 #include "llvm/Support/MemoryBuffer.h"
67 #include <algorithm>
68 #include <cassert>
69 #include <cstddef>
70 #include <memory>
71 #include <type_traits>
72 #include <utility>
73 
74 namespace clang {
75 
76   using llvm::make_error;
77   using llvm::Error;
78   using llvm::Expected;
79   using ExpectedType = llvm::Expected<QualType>;
80   using ExpectedStmt = llvm::Expected<Stmt *>;
81   using ExpectedExpr = llvm::Expected<Expr *>;
82   using ExpectedDecl = llvm::Expected<Decl *>;
83   using ExpectedSLoc = llvm::Expected<SourceLocation>;
84   using ExpectedName = llvm::Expected<DeclarationName>;
85 
toString() const86   std::string ImportError::toString() const {
87     // FIXME: Improve error texts.
88     switch (Error) {
89     case NameConflict:
90       return "NameConflict";
91     case UnsupportedConstruct:
92       return "UnsupportedConstruct";
93     case Unknown:
94       return "Unknown error";
95     }
96     llvm_unreachable("Invalid error code.");
97     return "Invalid error code.";
98   }
99 
log(raw_ostream & OS) const100   void ImportError::log(raw_ostream &OS) const {
101     OS << toString();
102   }
103 
convertToErrorCode() const104   std::error_code ImportError::convertToErrorCode() const {
105     llvm_unreachable("Function not implemented.");
106   }
107 
108   char ImportError::ID;
109 
110   template <class T>
111   SmallVector<Decl *, 2>
getCanonicalForwardRedeclChain(Redeclarable<T> * D)112   getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
113     SmallVector<Decl *, 2> Redecls;
114     for (auto *R : D->getFirstDecl()->redecls()) {
115       if (R != D->getFirstDecl())
116         Redecls.push_back(R);
117     }
118     Redecls.push_back(D->getFirstDecl());
119     std::reverse(Redecls.begin(), Redecls.end());
120     return Redecls;
121   }
122 
getCanonicalForwardRedeclChain(Decl * D)123   SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
124     if (auto *FD = dyn_cast<FunctionDecl>(D))
125       return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
126     if (auto *VD = dyn_cast<VarDecl>(D))
127       return getCanonicalForwardRedeclChain<VarDecl>(VD);
128     if (auto *TD = dyn_cast<TagDecl>(D))
129       return getCanonicalForwardRedeclChain<TagDecl>(TD);
130     llvm_unreachable("Bad declaration kind");
131   }
132 
updateFlags(const Decl * From,Decl * To)133   void updateFlags(const Decl *From, Decl *To) {
134     // Check if some flags or attrs are new in 'From' and copy into 'To'.
135     // FIXME: Other flags or attrs?
136     if (From->isUsed(false) && !To->isUsed(false))
137       To->setIsUsed();
138   }
139 
140   class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
141                           public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
142                           public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
143     ASTImporter &Importer;
144 
145     // Use this instead of Importer.importInto .
146     template <typename ImportT>
importInto(ImportT & To,const ImportT & From)147     LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
148       return Importer.importInto(To, From);
149     }
150 
151     // Use this to import pointers of specific type.
152     template <typename ImportT>
importInto(ImportT * & To,ImportT * From)153     LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
154       auto ToOrErr = Importer.Import(From);
155       if (ToOrErr)
156         To = cast_or_null<ImportT>(*ToOrErr);
157       return ToOrErr.takeError();
158     }
159 
160     // Call the import function of ASTImporter for a baseclass of type `T` and
161     // cast the return value to `T`.
162     template <typename T>
import(T * From)163     Expected<T *> import(T *From) {
164       auto ToOrErr = Importer.Import(From);
165       if (!ToOrErr)
166         return ToOrErr.takeError();
167       return cast_or_null<T>(*ToOrErr);
168     }
169 
170     template <typename T>
import(const T * From)171     Expected<T *> import(const T *From) {
172       return import(const_cast<T *>(From));
173     }
174 
175     // Call the import function of ASTImporter for type `T`.
176     template <typename T>
import(const T & From)177     Expected<T> import(const T &From) {
178       return Importer.Import(From);
179     }
180 
181     // Import an Optional<T> by importing the contained T, if any.
182     template<typename T>
import(Optional<T> From)183     Expected<Optional<T>> import(Optional<T> From) {
184       if (!From)
185         return Optional<T>();
186       return import(*From);
187     }
188 
189     // Helper for chaining together multiple imports. If an error is detected,
190     // subsequent imports will return default constructed nodes, so that failure
191     // can be detected with a single conditional branch after a sequence of
192     // imports.
importChecked(Error & Err,const T & From)193     template <typename T> T importChecked(Error &Err, const T &From) {
194       // Don't attempt to import nodes if we hit an error earlier.
195       if (Err)
196         return T{};
197       Expected<T> MaybeVal = import(From);
198       if (!MaybeVal) {
199         Err = MaybeVal.takeError();
200         return T{};
201       }
202       return *MaybeVal;
203     }
204 
205     ExplicitSpecifier importExplicitSpecifier(Error &Err,
206                                               ExplicitSpecifier ESpec);
207 
208     // Wrapper for an overload set.
209     template <typename ToDeclT> struct CallOverloadedCreateFun {
operator ()clang::ASTNodeImporter::CallOverloadedCreateFun210       template <typename... Args> decltype(auto) operator()(Args &&... args) {
211         return ToDeclT::Create(std::forward<Args>(args)...);
212       }
213     };
214 
215     // Always use these functions to create a Decl during import. There are
216     // certain tasks which must be done after the Decl was created, e.g. we
217     // must immediately register that as an imported Decl.  The parameter `ToD`
218     // will be set to the newly created Decl or if had been imported before
219     // then to the already imported Decl.  Returns a bool value set to true if
220     // the `FromD` had been imported before.
221     template <typename ToDeclT, typename FromDeclT, typename... Args>
GetImportedOrCreateDecl(ToDeclT * & ToD,FromDeclT * FromD,Args &&...args)222     LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
223                                                 Args &&... args) {
224       // There may be several overloads of ToDeclT::Create. We must make sure
225       // to call the one which would be chosen by the arguments, thus we use a
226       // wrapper for the overload set.
227       CallOverloadedCreateFun<ToDeclT> OC;
228       return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
229                                             std::forward<Args>(args)...);
230     }
231     // Use this overload if a special Type is needed to be created.  E.g if we
232     // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
233     // then:
234     // TypedefNameDecl *ToTypedef;
235     // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
236     template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
237               typename... Args>
GetImportedOrCreateDecl(ToDeclT * & ToD,FromDeclT * FromD,Args &&...args)238     LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
239                                                 Args &&... args) {
240       CallOverloadedCreateFun<NewDeclT> OC;
241       return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
242                                             std::forward<Args>(args)...);
243     }
244     // Use this version if a special create function must be
245     // used, e.g. CXXRecordDecl::CreateLambda .
246     template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
247               typename... Args>
248     LLVM_NODISCARD bool
GetImportedOrCreateSpecialDecl(ToDeclT * & ToD,CreateFunT CreateFun,FromDeclT * FromD,Args &&...args)249     GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
250                                    FromDeclT *FromD, Args &&... args) {
251       if (Importer.getImportDeclErrorIfAny(FromD)) {
252         ToD = nullptr;
253         return true; // Already imported but with error.
254       }
255       ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
256       if (ToD)
257         return true; // Already imported.
258       ToD = CreateFun(std::forward<Args>(args)...);
259       // Keep track of imported Decls.
260       Importer.RegisterImportedDecl(FromD, ToD);
261       InitializeImportedDecl(FromD, ToD);
262       return false; // A new Decl is created.
263     }
264 
InitializeImportedDecl(Decl * FromD,Decl * ToD)265     void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
266       ToD->IdentifierNamespace = FromD->IdentifierNamespace;
267       if (FromD->isUsed())
268         ToD->setIsUsed();
269       if (FromD->isImplicit())
270         ToD->setImplicit();
271     }
272 
273     // Check if we have found an existing definition.  Returns with that
274     // definition if yes, otherwise returns null.
FindAndMapDefinition(FunctionDecl * D,FunctionDecl * FoundFunction)275     Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
276       const FunctionDecl *Definition = nullptr;
277       if (D->doesThisDeclarationHaveABody() &&
278           FoundFunction->hasBody(Definition))
279         return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
280       return nullptr;
281     }
282 
addDeclToContexts(Decl * FromD,Decl * ToD)283     void addDeclToContexts(Decl *FromD, Decl *ToD) {
284       if (Importer.isMinimalImport()) {
285         // In minimal import case the decl must be added even if it is not
286         // contained in original context, for LLDB compatibility.
287         // FIXME: Check if a better solution is possible.
288         if (!FromD->getDescribedTemplate() &&
289             FromD->getFriendObjectKind() == Decl::FOK_None)
290           ToD->getLexicalDeclContext()->addDeclInternal(ToD);
291         return;
292       }
293 
294       DeclContext *FromDC = FromD->getDeclContext();
295       DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
296       DeclContext *ToDC = ToD->getDeclContext();
297       DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
298 
299       bool Visible = false;
300       if (FromDC->containsDeclAndLoad(FromD)) {
301         ToDC->addDeclInternal(ToD);
302         Visible = true;
303       }
304       if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
305         ToLexicalDC->addDeclInternal(ToD);
306         Visible = true;
307       }
308 
309       // If the Decl was added to any context, it was made already visible.
310       // Otherwise it is still possible that it should be visible.
311       if (!Visible) {
312         if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
313           auto *ToNamed = cast<NamedDecl>(ToD);
314           DeclContextLookupResult FromLookup =
315               FromDC->lookup(FromNamed->getDeclName());
316           for (NamedDecl *ND : FromLookup)
317             if (ND == FromNamed) {
318               ToDC->makeDeclVisibleInContext(ToNamed);
319               break;
320             }
321         }
322       }
323     }
324 
325   public:
ASTNodeImporter(ASTImporter & Importer)326     explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
327 
328     using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
329     using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
330     using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
331 
332     // Importing types
333     ExpectedType VisitType(const Type *T);
334     ExpectedType VisitAtomicType(const AtomicType *T);
335     ExpectedType VisitBuiltinType(const BuiltinType *T);
336     ExpectedType VisitDecayedType(const DecayedType *T);
337     ExpectedType VisitComplexType(const ComplexType *T);
338     ExpectedType VisitPointerType(const PointerType *T);
339     ExpectedType VisitBlockPointerType(const BlockPointerType *T);
340     ExpectedType VisitLValueReferenceType(const LValueReferenceType *T);
341     ExpectedType VisitRValueReferenceType(const RValueReferenceType *T);
342     ExpectedType VisitMemberPointerType(const MemberPointerType *T);
343     ExpectedType VisitConstantArrayType(const ConstantArrayType *T);
344     ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T);
345     ExpectedType VisitVariableArrayType(const VariableArrayType *T);
346     ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
347     // FIXME: DependentSizedExtVectorType
348     ExpectedType VisitVectorType(const VectorType *T);
349     ExpectedType VisitExtVectorType(const ExtVectorType *T);
350     ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
351     ExpectedType VisitFunctionProtoType(const FunctionProtoType *T);
352     ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
353     ExpectedType VisitParenType(const ParenType *T);
354     ExpectedType VisitTypedefType(const TypedefType *T);
355     ExpectedType VisitTypeOfExprType(const TypeOfExprType *T);
356     // FIXME: DependentTypeOfExprType
357     ExpectedType VisitTypeOfType(const TypeOfType *T);
358     ExpectedType VisitDecltypeType(const DecltypeType *T);
359     ExpectedType VisitUnaryTransformType(const UnaryTransformType *T);
360     ExpectedType VisitAutoType(const AutoType *T);
361     ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T);
362     // FIXME: DependentDecltypeType
363     ExpectedType VisitRecordType(const RecordType *T);
364     ExpectedType VisitEnumType(const EnumType *T);
365     ExpectedType VisitAttributedType(const AttributedType *T);
366     ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
367     ExpectedType VisitSubstTemplateTypeParmType(
368         const SubstTemplateTypeParmType *T);
369     ExpectedType VisitTemplateSpecializationType(
370         const TemplateSpecializationType *T);
371     ExpectedType VisitElaboratedType(const ElaboratedType *T);
372     ExpectedType VisitDependentNameType(const DependentNameType *T);
373     ExpectedType VisitPackExpansionType(const PackExpansionType *T);
374     ExpectedType VisitDependentTemplateSpecializationType(
375         const DependentTemplateSpecializationType *T);
376     ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T);
377     ExpectedType VisitObjCObjectType(const ObjCObjectType *T);
378     ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
379 
380     // Importing declarations
381     Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
382                           SourceLocation &Loc);
383     Error ImportDeclParts(
384         NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
385         DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc);
386     Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
387     Error ImportDeclarationNameLoc(
388         const DeclarationNameInfo &From, DeclarationNameInfo &To);
389     Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
390     Error ImportDeclContext(
391         Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
392     Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
393 
394     Expected<CXXCastPath> ImportCastPath(CastExpr *E);
395     Expected<APValue> ImportAPValue(const APValue &FromValue);
396 
397     using Designator = DesignatedInitExpr::Designator;
398 
399     /// What we should import from the definition.
400     enum ImportDefinitionKind {
401       /// Import the default subset of the definition, which might be
402       /// nothing (if minimal import is set) or might be everything (if minimal
403       /// import is not set).
404       IDK_Default,
405       /// Import everything.
406       IDK_Everything,
407       /// Import only the bare bones needed to establish a valid
408       /// DeclContext.
409       IDK_Basic
410     };
411 
shouldForceImportDeclContext(ImportDefinitionKind IDK)412     bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
413       return IDK == IDK_Everything ||
414              (IDK == IDK_Default && !Importer.isMinimalImport());
415     }
416 
417     Error ImportInitializer(VarDecl *From, VarDecl *To);
418     Error ImportDefinition(
419         RecordDecl *From, RecordDecl *To,
420         ImportDefinitionKind Kind = IDK_Default);
421     Error ImportDefinition(
422         EnumDecl *From, EnumDecl *To,
423         ImportDefinitionKind Kind = IDK_Default);
424     Error ImportDefinition(
425         ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
426         ImportDefinitionKind Kind = IDK_Default);
427     Error ImportDefinition(
428         ObjCProtocolDecl *From, ObjCProtocolDecl *To,
429         ImportDefinitionKind Kind = IDK_Default);
430     Error ImportTemplateArguments(
431         const TemplateArgument *FromArgs, unsigned NumFromArgs,
432         SmallVectorImpl<TemplateArgument> &ToArgs);
433     Expected<TemplateArgument>
434     ImportTemplateArgument(const TemplateArgument &From);
435 
436     template <typename InContainerTy>
437     Error ImportTemplateArgumentListInfo(
438         const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
439 
440     template<typename InContainerTy>
441     Error ImportTemplateArgumentListInfo(
442       SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
443       const InContainerTy &Container, TemplateArgumentListInfo &Result);
444 
445     using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
446     using FunctionTemplateAndArgsTy =
447         std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
448     Expected<FunctionTemplateAndArgsTy>
449     ImportFunctionTemplateWithTemplateArgsFromSpecialization(
450         FunctionDecl *FromFD);
451     Error ImportTemplateParameterLists(const DeclaratorDecl *FromD,
452                                        DeclaratorDecl *ToD);
453 
454     Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
455 
456     Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
457 
458     Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
459                                         ParmVarDecl *ToParam);
460 
461     template <typename T>
462     bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
463 
464     bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
465     bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
466                            bool Complain = true);
467     bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
468                            bool Complain = true);
469     bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
470     bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
471     bool IsStructuralMatch(FunctionTemplateDecl *From,
472                            FunctionTemplateDecl *To);
473     bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
474     bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
475     bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
476     ExpectedDecl VisitDecl(Decl *D);
477     ExpectedDecl VisitImportDecl(ImportDecl *D);
478     ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
479     ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
480     ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
481     ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
482     ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
483     ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
484     ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
485     ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
486     ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
487     ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
488     ExpectedDecl VisitLabelDecl(LabelDecl *D);
489     ExpectedDecl VisitEnumDecl(EnumDecl *D);
490     ExpectedDecl VisitRecordDecl(RecordDecl *D);
491     ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
492     ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
493     ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
494     ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
495     ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
496     ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
497     ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
498     ExpectedDecl VisitFieldDecl(FieldDecl *D);
499     ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
500     ExpectedDecl VisitFriendDecl(FriendDecl *D);
501     ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
502     ExpectedDecl VisitVarDecl(VarDecl *D);
503     ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
504     ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
505     ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
506     ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
507     ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
508     ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
509     ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
510     ExpectedDecl VisitUsingDecl(UsingDecl *D);
511     ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
512     ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
513     ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
514     ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
515     ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
516     ExpectedDecl
517     VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
518 
519     Expected<ObjCTypeParamList *>
520     ImportObjCTypeParamList(ObjCTypeParamList *list);
521 
522     ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
523     ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
524     ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
525     ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
526     ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
527     ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
528     ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
529     ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
530     ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
531     ExpectedDecl VisitClassTemplateSpecializationDecl(
532                                             ClassTemplateSpecializationDecl *D);
533     ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
534     ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
535     ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
536 
537     // Importing statements
538     ExpectedStmt VisitStmt(Stmt *S);
539     ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
540     ExpectedStmt VisitDeclStmt(DeclStmt *S);
541     ExpectedStmt VisitNullStmt(NullStmt *S);
542     ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
543     ExpectedStmt VisitCaseStmt(CaseStmt *S);
544     ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
545     ExpectedStmt VisitLabelStmt(LabelStmt *S);
546     ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
547     ExpectedStmt VisitIfStmt(IfStmt *S);
548     ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
549     ExpectedStmt VisitWhileStmt(WhileStmt *S);
550     ExpectedStmt VisitDoStmt(DoStmt *S);
551     ExpectedStmt VisitForStmt(ForStmt *S);
552     ExpectedStmt VisitGotoStmt(GotoStmt *S);
553     ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
554     ExpectedStmt VisitContinueStmt(ContinueStmt *S);
555     ExpectedStmt VisitBreakStmt(BreakStmt *S);
556     ExpectedStmt VisitReturnStmt(ReturnStmt *S);
557     // FIXME: MSAsmStmt
558     // FIXME: SEHExceptStmt
559     // FIXME: SEHFinallyStmt
560     // FIXME: SEHTryStmt
561     // FIXME: SEHLeaveStmt
562     // FIXME: CapturedStmt
563     ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
564     ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
565     ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
566     // FIXME: MSDependentExistsStmt
567     ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
568     ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
569     ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
570     ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
571     ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
572     ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
573     ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
574 
575     // Importing expressions
576     ExpectedStmt VisitExpr(Expr *E);
577     ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
578     ExpectedStmt VisitChooseExpr(ChooseExpr *E);
579     ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
580     ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
581     ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
582     ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
583     ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
584     ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
585     ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
586     ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
587     ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
588     ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
589     ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
590     ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
591     ExpectedStmt VisitStringLiteral(StringLiteral *E);
592     ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
593     ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
594     ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
595     ExpectedStmt VisitConstantExpr(ConstantExpr *E);
596     ExpectedStmt VisitParenExpr(ParenExpr *E);
597     ExpectedStmt VisitParenListExpr(ParenListExpr *E);
598     ExpectedStmt VisitStmtExpr(StmtExpr *E);
599     ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
600     ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
601     ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
602     ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
603     ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
604     ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
605     ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
606     ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
607     ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
608     ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
609     ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
610     ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
611     ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
612     ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
613     ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
614     ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
615     ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
616     ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
617     ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
618     ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
619     ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
620     ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
621     ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
622     ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
623     ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
624     ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
625     ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
626     ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
627     ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
628     ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
629     ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
630     ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
631     ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
632     ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
633     ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
634     ExpectedStmt VisitMemberExpr(MemberExpr *E);
635     ExpectedStmt VisitCallExpr(CallExpr *E);
636     ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
637     ExpectedStmt VisitInitListExpr(InitListExpr *E);
638     ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
639     ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
640     ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
641     ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
642     ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
643     ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
644     ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
645     ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
646     ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
647     ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
648 
649     template<typename IIter, typename OIter>
ImportArrayChecked(IIter Ibegin,IIter Iend,OIter Obegin)650     Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
651       using ItemT = std::remove_reference_t<decltype(*Obegin)>;
652       for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
653         Expected<ItemT> ToOrErr = import(*Ibegin);
654         if (!ToOrErr)
655           return ToOrErr.takeError();
656         *Obegin = *ToOrErr;
657       }
658       return Error::success();
659     }
660 
661     // Import every item from a container structure into an output container.
662     // If error occurs, stops at first error and returns the error.
663     // The output container should have space for all needed elements (it is not
664     // expanded, new items are put into from the beginning).
665     template<typename InContainerTy, typename OutContainerTy>
ImportContainerChecked(const InContainerTy & InContainer,OutContainerTy & OutContainer)666     Error ImportContainerChecked(
667         const InContainerTy &InContainer, OutContainerTy &OutContainer) {
668       return ImportArrayChecked(
669           InContainer.begin(), InContainer.end(), OutContainer.begin());
670     }
671 
672     template<typename InContainerTy, typename OIter>
ImportArrayChecked(const InContainerTy & InContainer,OIter Obegin)673     Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
674       return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
675     }
676 
677     Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
678                                   CXXMethodDecl *FromMethod);
679 
680     Expected<FunctionDecl *> FindFunctionTemplateSpecialization(
681         FunctionDecl *FromFD);
682 
683     // Returns true if the given function has a placeholder return type and
684     // that type is declared inside the body of the function.
685     // E.g. auto f() { struct X{}; return X(); }
686     bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
687   };
688 
689 template <typename InContainerTy>
ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,SourceLocation FromRAngleLoc,const InContainerTy & Container,TemplateArgumentListInfo & Result)690 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
691     SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
692     const InContainerTy &Container, TemplateArgumentListInfo &Result) {
693   auto ToLAngleLocOrErr = import(FromLAngleLoc);
694   if (!ToLAngleLocOrErr)
695     return ToLAngleLocOrErr.takeError();
696   auto ToRAngleLocOrErr = import(FromRAngleLoc);
697   if (!ToRAngleLocOrErr)
698     return ToRAngleLocOrErr.takeError();
699 
700   TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr);
701   if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo))
702     return Err;
703   Result = ToTAInfo;
704   return Error::success();
705 }
706 
707 template <>
ImportTemplateArgumentListInfo(const TemplateArgumentListInfo & From,TemplateArgumentListInfo & Result)708 Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
709     const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
710   return ImportTemplateArgumentListInfo(
711       From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
712 }
713 
714 template <>
ImportTemplateArgumentListInfo(const ASTTemplateArgumentListInfo & From,TemplateArgumentListInfo & Result)715 Error ASTNodeImporter::ImportTemplateArgumentListInfo<
716     ASTTemplateArgumentListInfo>(
717         const ASTTemplateArgumentListInfo &From,
718         TemplateArgumentListInfo &Result) {
719   return ImportTemplateArgumentListInfo(
720       From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
721 }
722 
723 Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
ImportFunctionTemplateWithTemplateArgsFromSpecialization(FunctionDecl * FromFD)724 ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
725     FunctionDecl *FromFD) {
726   assert(FromFD->getTemplatedKind() ==
727       FunctionDecl::TK_FunctionTemplateSpecialization);
728 
729   FunctionTemplateAndArgsTy Result;
730 
731   auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
732   if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate()))
733     return std::move(Err);
734 
735   // Import template arguments.
736   auto TemplArgs = FTSInfo->TemplateArguments->asArray();
737   if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
738       std::get<1>(Result)))
739     return std::move(Err);
740 
741   return Result;
742 }
743 
744 template <>
745 Expected<TemplateParameterList *>
import(TemplateParameterList * From)746 ASTNodeImporter::import(TemplateParameterList *From) {
747   SmallVector<NamedDecl *, 4> To(From->size());
748   if (Error Err = ImportContainerChecked(*From, To))
749     return std::move(Err);
750 
751   ExpectedExpr ToRequiresClause = import(From->getRequiresClause());
752   if (!ToRequiresClause)
753     return ToRequiresClause.takeError();
754 
755   auto ToTemplateLocOrErr = import(From->getTemplateLoc());
756   if (!ToTemplateLocOrErr)
757     return ToTemplateLocOrErr.takeError();
758   auto ToLAngleLocOrErr = import(From->getLAngleLoc());
759   if (!ToLAngleLocOrErr)
760     return ToLAngleLocOrErr.takeError();
761   auto ToRAngleLocOrErr = import(From->getRAngleLoc());
762   if (!ToRAngleLocOrErr)
763     return ToRAngleLocOrErr.takeError();
764 
765   return TemplateParameterList::Create(
766       Importer.getToContext(),
767       *ToTemplateLocOrErr,
768       *ToLAngleLocOrErr,
769       To,
770       *ToRAngleLocOrErr,
771       *ToRequiresClause);
772 }
773 
774 template <>
775 Expected<TemplateArgument>
import(const TemplateArgument & From)776 ASTNodeImporter::import(const TemplateArgument &From) {
777   switch (From.getKind()) {
778   case TemplateArgument::Null:
779     return TemplateArgument();
780 
781   case TemplateArgument::Type: {
782     ExpectedType ToTypeOrErr = import(From.getAsType());
783     if (!ToTypeOrErr)
784       return ToTypeOrErr.takeError();
785     return TemplateArgument(*ToTypeOrErr);
786   }
787 
788   case TemplateArgument::Integral: {
789     ExpectedType ToTypeOrErr = import(From.getIntegralType());
790     if (!ToTypeOrErr)
791       return ToTypeOrErr.takeError();
792     return TemplateArgument(From, *ToTypeOrErr);
793   }
794 
795   case TemplateArgument::Declaration: {
796     Expected<ValueDecl *> ToOrErr = import(From.getAsDecl());
797     if (!ToOrErr)
798       return ToOrErr.takeError();
799     ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl());
800     if (!ToTypeOrErr)
801       return ToTypeOrErr.takeError();
802     return TemplateArgument(*ToOrErr, *ToTypeOrErr);
803   }
804 
805   case TemplateArgument::NullPtr: {
806     ExpectedType ToTypeOrErr = import(From.getNullPtrType());
807     if (!ToTypeOrErr)
808       return ToTypeOrErr.takeError();
809     return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true);
810   }
811 
812   case TemplateArgument::Template: {
813     Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate());
814     if (!ToTemplateOrErr)
815       return ToTemplateOrErr.takeError();
816 
817     return TemplateArgument(*ToTemplateOrErr);
818   }
819 
820   case TemplateArgument::TemplateExpansion: {
821     Expected<TemplateName> ToTemplateOrErr =
822         import(From.getAsTemplateOrTemplatePattern());
823     if (!ToTemplateOrErr)
824       return ToTemplateOrErr.takeError();
825 
826     return TemplateArgument(
827         *ToTemplateOrErr, From.getNumTemplateExpansions());
828   }
829 
830   case TemplateArgument::Expression:
831     if (ExpectedExpr ToExpr = import(From.getAsExpr()))
832       return TemplateArgument(*ToExpr);
833     else
834       return ToExpr.takeError();
835 
836   case TemplateArgument::Pack: {
837     SmallVector<TemplateArgument, 2> ToPack;
838     ToPack.reserve(From.pack_size());
839     if (Error Err = ImportTemplateArguments(
840         From.pack_begin(), From.pack_size(), ToPack))
841       return std::move(Err);
842 
843     return TemplateArgument(
844         llvm::makeArrayRef(ToPack).copy(Importer.getToContext()));
845   }
846   }
847 
848   llvm_unreachable("Invalid template argument kind");
849 }
850 
851 template <>
852 Expected<TemplateArgumentLoc>
import(const TemplateArgumentLoc & TALoc)853 ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
854   Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
855   if (!ArgOrErr)
856     return ArgOrErr.takeError();
857   TemplateArgument Arg = *ArgOrErr;
858 
859   TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo();
860 
861   TemplateArgumentLocInfo ToInfo;
862   if (Arg.getKind() == TemplateArgument::Expression) {
863     ExpectedExpr E = import(FromInfo.getAsExpr());
864     if (!E)
865       return E.takeError();
866     ToInfo = TemplateArgumentLocInfo(*E);
867   } else if (Arg.getKind() == TemplateArgument::Type) {
868     if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo()))
869       ToInfo = TemplateArgumentLocInfo(*TSIOrErr);
870     else
871       return TSIOrErr.takeError();
872   } else {
873     auto ToTemplateQualifierLocOrErr =
874         import(FromInfo.getTemplateQualifierLoc());
875     if (!ToTemplateQualifierLocOrErr)
876       return ToTemplateQualifierLocOrErr.takeError();
877     auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
878     if (!ToTemplateNameLocOrErr)
879       return ToTemplateNameLocOrErr.takeError();
880     auto ToTemplateEllipsisLocOrErr =
881         import(FromInfo.getTemplateEllipsisLoc());
882     if (!ToTemplateEllipsisLocOrErr)
883       return ToTemplateEllipsisLocOrErr.takeError();
884     ToInfo = TemplateArgumentLocInfo(
885         Importer.getToContext(), *ToTemplateQualifierLocOrErr,
886         *ToTemplateNameLocOrErr, *ToTemplateEllipsisLocOrErr);
887   }
888 
889   return TemplateArgumentLoc(Arg, ToInfo);
890 }
891 
892 template <>
import(const DeclGroupRef & DG)893 Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
894   if (DG.isNull())
895     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
896   size_t NumDecls = DG.end() - DG.begin();
897   SmallVector<Decl *, 1> ToDecls;
898   ToDecls.reserve(NumDecls);
899   for (Decl *FromD : DG) {
900     if (auto ToDOrErr = import(FromD))
901       ToDecls.push_back(*ToDOrErr);
902     else
903       return ToDOrErr.takeError();
904   }
905   return DeclGroupRef::Create(Importer.getToContext(),
906                               ToDecls.begin(),
907                               NumDecls);
908 }
909 
910 template <>
911 Expected<ASTNodeImporter::Designator>
import(const Designator & D)912 ASTNodeImporter::import(const Designator &D) {
913   if (D.isFieldDesignator()) {
914     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
915 
916     ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc());
917     if (!ToDotLocOrErr)
918       return ToDotLocOrErr.takeError();
919 
920     ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc());
921     if (!ToFieldLocOrErr)
922       return ToFieldLocOrErr.takeError();
923 
924     return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr);
925   }
926 
927   ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc());
928   if (!ToLBracketLocOrErr)
929     return ToLBracketLocOrErr.takeError();
930 
931   ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc());
932   if (!ToRBracketLocOrErr)
933     return ToRBracketLocOrErr.takeError();
934 
935   if (D.isArrayDesignator())
936     return Designator(D.getFirstExprIndex(),
937                       *ToLBracketLocOrErr, *ToRBracketLocOrErr);
938 
939   ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
940   if (!ToEllipsisLocOrErr)
941     return ToEllipsisLocOrErr.takeError();
942 
943   assert(D.isArrayRangeDesignator());
944   return Designator(
945       D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
946       *ToRBracketLocOrErr);
947 }
948 
949 template <>
import(const LambdaCapture & From)950 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
951   VarDecl *Var = nullptr;
952   if (From.capturesVariable()) {
953     if (auto VarOrErr = import(From.getCapturedVar()))
954       Var = *VarOrErr;
955     else
956       return VarOrErr.takeError();
957   }
958 
959   auto LocationOrErr = import(From.getLocation());
960   if (!LocationOrErr)
961     return LocationOrErr.takeError();
962 
963   SourceLocation EllipsisLoc;
964   if (From.isPackExpansion())
965     if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
966       return std::move(Err);
967 
968   return LambdaCapture(
969       *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
970       EllipsisLoc);
971 }
972 
973 template <typename T>
hasSameVisibilityContextAndLinkage(T * Found,T * From)974 bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(T *Found, T *From) {
975   if (Found->getLinkageInternal() != From->getLinkageInternal())
976     return false;
977 
978   if (From->hasExternalFormalLinkage())
979     return Found->hasExternalFormalLinkage();
980   if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl())
981     return false;
982   if (From->isInAnonymousNamespace())
983     return Found->isInAnonymousNamespace();
984   else
985     return !Found->isInAnonymousNamespace() &&
986            !Found->hasExternalFormalLinkage();
987 }
988 
989 template <>
hasSameVisibilityContextAndLinkage(TypedefNameDecl * Found,TypedefNameDecl * From)990 bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
991                                                TypedefNameDecl *From) {
992   if (Found->getLinkageInternal() != From->getLinkageInternal())
993     return false;
994 
995   if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace())
996     return Importer.GetFromTU(Found) == From->getTranslationUnitDecl();
997   return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace();
998 }
999 
1000 } // namespace clang
1001 
1002 //----------------------------------------------------------------------------
1003 // Import Types
1004 //----------------------------------------------------------------------------
1005 
1006 using namespace clang;
1007 
VisitType(const Type * T)1008 ExpectedType ASTNodeImporter::VisitType(const Type *T) {
1009   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
1010     << T->getTypeClassName();
1011   return make_error<ImportError>(ImportError::UnsupportedConstruct);
1012 }
1013 
VisitAtomicType(const AtomicType * T)1014 ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
1015   ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
1016   if (!UnderlyingTypeOrErr)
1017     return UnderlyingTypeOrErr.takeError();
1018 
1019   return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
1020 }
1021 
VisitBuiltinType(const BuiltinType * T)1022 ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
1023   switch (T->getKind()) {
1024 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1025   case BuiltinType::Id: \
1026     return Importer.getToContext().SingletonId;
1027 #include "clang/Basic/OpenCLImageTypes.def"
1028 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1029   case BuiltinType::Id: \
1030     return Importer.getToContext().Id##Ty;
1031 #include "clang/Basic/OpenCLExtensionTypes.def"
1032 #define SVE_TYPE(Name, Id, SingletonId) \
1033   case BuiltinType::Id: \
1034     return Importer.getToContext().SingletonId;
1035 #include "clang/Basic/AArch64SVEACLETypes.def"
1036 #define PPC_VECTOR_TYPE(Name, Id, Size) \
1037   case BuiltinType::Id: \
1038     return Importer.getToContext().Id##Ty;
1039 #include "clang/Basic/PPCTypes.def"
1040 #define SHARED_SINGLETON_TYPE(Expansion)
1041 #define BUILTIN_TYPE(Id, SingletonId) \
1042   case BuiltinType::Id: return Importer.getToContext().SingletonId;
1043 #include "clang/AST/BuiltinTypes.def"
1044 
1045   // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
1046   // context supports C++.
1047 
1048   // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
1049   // context supports ObjC.
1050 
1051   case BuiltinType::Char_U:
1052     // The context we're importing from has an unsigned 'char'. If we're
1053     // importing into a context with a signed 'char', translate to
1054     // 'unsigned char' instead.
1055     if (Importer.getToContext().getLangOpts().CharIsSigned)
1056       return Importer.getToContext().UnsignedCharTy;
1057 
1058     return Importer.getToContext().CharTy;
1059 
1060   case BuiltinType::Char_S:
1061     // The context we're importing from has an unsigned 'char'. If we're
1062     // importing into a context with a signed 'char', translate to
1063     // 'unsigned char' instead.
1064     if (!Importer.getToContext().getLangOpts().CharIsSigned)
1065       return Importer.getToContext().SignedCharTy;
1066 
1067     return Importer.getToContext().CharTy;
1068 
1069   case BuiltinType::WChar_S:
1070   case BuiltinType::WChar_U:
1071     // FIXME: If not in C++, shall we translate to the C equivalent of
1072     // wchar_t?
1073     return Importer.getToContext().WCharTy;
1074   }
1075 
1076   llvm_unreachable("Invalid BuiltinType Kind!");
1077 }
1078 
VisitDecayedType(const DecayedType * T)1079 ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
1080   ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
1081   if (!ToOriginalTypeOrErr)
1082     return ToOriginalTypeOrErr.takeError();
1083 
1084   return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
1085 }
1086 
VisitComplexType(const ComplexType * T)1087 ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
1088   ExpectedType ToElementTypeOrErr = import(T->getElementType());
1089   if (!ToElementTypeOrErr)
1090     return ToElementTypeOrErr.takeError();
1091 
1092   return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
1093 }
1094 
VisitPointerType(const PointerType * T)1095 ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
1096   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1097   if (!ToPointeeTypeOrErr)
1098     return ToPointeeTypeOrErr.takeError();
1099 
1100   return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
1101 }
1102 
VisitBlockPointerType(const BlockPointerType * T)1103 ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
1104   // FIXME: Check for blocks support in "to" context.
1105   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1106   if (!ToPointeeTypeOrErr)
1107     return ToPointeeTypeOrErr.takeError();
1108 
1109   return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr);
1110 }
1111 
1112 ExpectedType
VisitLValueReferenceType(const LValueReferenceType * T)1113 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
1114   // FIXME: Check for C++ support in "to" context.
1115   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1116   if (!ToPointeeTypeOrErr)
1117     return ToPointeeTypeOrErr.takeError();
1118 
1119   return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr);
1120 }
1121 
1122 ExpectedType
VisitRValueReferenceType(const RValueReferenceType * T)1123 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
1124   // FIXME: Check for C++0x support in "to" context.
1125   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
1126   if (!ToPointeeTypeOrErr)
1127     return ToPointeeTypeOrErr.takeError();
1128 
1129   return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr);
1130 }
1131 
1132 ExpectedType
VisitMemberPointerType(const MemberPointerType * T)1133 ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
1134   // FIXME: Check for C++ support in "to" context.
1135   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1136   if (!ToPointeeTypeOrErr)
1137     return ToPointeeTypeOrErr.takeError();
1138 
1139   ExpectedType ClassTypeOrErr = import(QualType(T->getClass(), 0));
1140   if (!ClassTypeOrErr)
1141     return ClassTypeOrErr.takeError();
1142 
1143   return Importer.getToContext().getMemberPointerType(
1144       *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr());
1145 }
1146 
1147 ExpectedType
VisitConstantArrayType(const ConstantArrayType * T)1148 ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
1149   Error Err = Error::success();
1150   auto ToElementType = importChecked(Err, T->getElementType());
1151   auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
1152   if (Err)
1153     return std::move(Err);
1154 
1155   return Importer.getToContext().getConstantArrayType(
1156       ToElementType, T->getSize(), ToSizeExpr, T->getSizeModifier(),
1157       T->getIndexTypeCVRQualifiers());
1158 }
1159 
1160 ExpectedType
VisitIncompleteArrayType(const IncompleteArrayType * T)1161 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
1162   ExpectedType ToElementTypeOrErr = import(T->getElementType());
1163   if (!ToElementTypeOrErr)
1164     return ToElementTypeOrErr.takeError();
1165 
1166   return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
1167                                                         T->getSizeModifier(),
1168                                                 T->getIndexTypeCVRQualifiers());
1169 }
1170 
1171 ExpectedType
VisitVariableArrayType(const VariableArrayType * T)1172 ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
1173   Error Err = Error::success();
1174   QualType ToElementType = importChecked(Err, T->getElementType());
1175   Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1176   SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1177   if (Err)
1178     return std::move(Err);
1179   return Importer.getToContext().getVariableArrayType(
1180       ToElementType, ToSizeExpr, T->getSizeModifier(),
1181       T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1182 }
1183 
VisitDependentSizedArrayType(const DependentSizedArrayType * T)1184 ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
1185     const DependentSizedArrayType *T) {
1186   Error Err = Error::success();
1187   QualType ToElementType = importChecked(Err, T->getElementType());
1188   Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
1189   SourceRange ToBracketsRange = importChecked(Err, T->getBracketsRange());
1190   if (Err)
1191     return std::move(Err);
1192   // SizeExpr may be null if size is not specified directly.
1193   // For example, 'int a[]'.
1194 
1195   return Importer.getToContext().getDependentSizedArrayType(
1196       ToElementType, ToSizeExpr, T->getSizeModifier(),
1197       T->getIndexTypeCVRQualifiers(), ToBracketsRange);
1198 }
1199 
VisitVectorType(const VectorType * T)1200 ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
1201   ExpectedType ToElementTypeOrErr = import(T->getElementType());
1202   if (!ToElementTypeOrErr)
1203     return ToElementTypeOrErr.takeError();
1204 
1205   return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
1206                                                T->getNumElements(),
1207                                                T->getVectorKind());
1208 }
1209 
VisitExtVectorType(const ExtVectorType * T)1210 ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
1211   ExpectedType ToElementTypeOrErr = import(T->getElementType());
1212   if (!ToElementTypeOrErr)
1213     return ToElementTypeOrErr.takeError();
1214 
1215   return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr,
1216                                                   T->getNumElements());
1217 }
1218 
1219 ExpectedType
VisitFunctionNoProtoType(const FunctionNoProtoType * T)1220 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
1221   // FIXME: What happens if we're importing a function without a prototype
1222   // into C++? Should we make it variadic?
1223   ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1224   if (!ToReturnTypeOrErr)
1225     return ToReturnTypeOrErr.takeError();
1226 
1227   return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr,
1228                                                         T->getExtInfo());
1229 }
1230 
1231 ExpectedType
VisitFunctionProtoType(const FunctionProtoType * T)1232 ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
1233   ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
1234   if (!ToReturnTypeOrErr)
1235     return ToReturnTypeOrErr.takeError();
1236 
1237   // Import argument types
1238   SmallVector<QualType, 4> ArgTypes;
1239   for (const auto &A : T->param_types()) {
1240     ExpectedType TyOrErr = import(A);
1241     if (!TyOrErr)
1242       return TyOrErr.takeError();
1243     ArgTypes.push_back(*TyOrErr);
1244   }
1245 
1246   // Import exception types
1247   SmallVector<QualType, 4> ExceptionTypes;
1248   for (const auto &E : T->exceptions()) {
1249     ExpectedType TyOrErr = import(E);
1250     if (!TyOrErr)
1251       return TyOrErr.takeError();
1252     ExceptionTypes.push_back(*TyOrErr);
1253   }
1254 
1255   FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo();
1256   Error Err = Error::success();
1257   FunctionProtoType::ExtProtoInfo ToEPI;
1258   ToEPI.ExtInfo = FromEPI.ExtInfo;
1259   ToEPI.Variadic = FromEPI.Variadic;
1260   ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn;
1261   ToEPI.TypeQuals = FromEPI.TypeQuals;
1262   ToEPI.RefQualifier = FromEPI.RefQualifier;
1263   ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type;
1264   ToEPI.ExceptionSpec.NoexceptExpr =
1265       importChecked(Err, FromEPI.ExceptionSpec.NoexceptExpr);
1266   ToEPI.ExceptionSpec.SourceDecl =
1267       importChecked(Err, FromEPI.ExceptionSpec.SourceDecl);
1268   ToEPI.ExceptionSpec.SourceTemplate =
1269       importChecked(Err, FromEPI.ExceptionSpec.SourceTemplate);
1270   ToEPI.ExceptionSpec.Exceptions = ExceptionTypes;
1271 
1272   if (Err)
1273     return std::move(Err);
1274 
1275   return Importer.getToContext().getFunctionType(
1276       *ToReturnTypeOrErr, ArgTypes, ToEPI);
1277 }
1278 
VisitUnresolvedUsingType(const UnresolvedUsingType * T)1279 ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
1280     const UnresolvedUsingType *T) {
1281   Error Err = Error::success();
1282   auto ToD = importChecked(Err, T->getDecl());
1283   auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
1284   if (Err)
1285     return std::move(Err);
1286 
1287   return Importer.getToContext().getTypeDeclType(
1288       ToD, cast_or_null<TypeDecl>(ToPrevD));
1289 }
1290 
VisitParenType(const ParenType * T)1291 ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
1292   ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
1293   if (!ToInnerTypeOrErr)
1294     return ToInnerTypeOrErr.takeError();
1295 
1296   return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
1297 }
1298 
VisitTypedefType(const TypedefType * T)1299 ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
1300   Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
1301   if (!ToDeclOrErr)
1302     return ToDeclOrErr.takeError();
1303 
1304   return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
1305 }
1306 
VisitTypeOfExprType(const TypeOfExprType * T)1307 ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
1308   ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1309   if (!ToExprOrErr)
1310     return ToExprOrErr.takeError();
1311 
1312   return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
1313 }
1314 
VisitTypeOfType(const TypeOfType * T)1315 ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
1316   ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1317   if (!ToUnderlyingTypeOrErr)
1318     return ToUnderlyingTypeOrErr.takeError();
1319 
1320   return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
1321 }
1322 
VisitDecltypeType(const DecltypeType * T)1323 ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
1324   // FIXME: Make sure that the "to" context supports C++0x!
1325   ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
1326   if (!ToExprOrErr)
1327     return ToExprOrErr.takeError();
1328 
1329   ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1330   if (!ToUnderlyingTypeOrErr)
1331     return ToUnderlyingTypeOrErr.takeError();
1332 
1333   return Importer.getToContext().getDecltypeType(
1334       *ToExprOrErr, *ToUnderlyingTypeOrErr);
1335 }
1336 
1337 ExpectedType
VisitUnaryTransformType(const UnaryTransformType * T)1338 ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
1339   ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1340   if (!ToBaseTypeOrErr)
1341     return ToBaseTypeOrErr.takeError();
1342 
1343   ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
1344   if (!ToUnderlyingTypeOrErr)
1345     return ToUnderlyingTypeOrErr.takeError();
1346 
1347   return Importer.getToContext().getUnaryTransformType(
1348       *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
1349 }
1350 
VisitAutoType(const AutoType * T)1351 ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
1352   // FIXME: Make sure that the "to" context supports C++11!
1353   ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
1354   if (!ToDeducedTypeOrErr)
1355     return ToDeducedTypeOrErr.takeError();
1356 
1357   ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
1358   if (!ToTypeConstraintConcept)
1359     return ToTypeConstraintConcept.takeError();
1360 
1361   SmallVector<TemplateArgument, 2> ToTemplateArgs;
1362   ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
1363   if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
1364                                           FromTemplateArgs.size(),
1365                                           ToTemplateArgs))
1366     return std::move(Err);
1367 
1368   return Importer.getToContext().getAutoType(
1369       *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
1370       /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
1371       ToTemplateArgs);
1372 }
1373 
VisitInjectedClassNameType(const InjectedClassNameType * T)1374 ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
1375     const InjectedClassNameType *T) {
1376   Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
1377   if (!ToDeclOrErr)
1378     return ToDeclOrErr.takeError();
1379 
1380   ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType());
1381   if (!ToInjTypeOrErr)
1382     return ToInjTypeOrErr.takeError();
1383 
1384   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
1385   // See comments in InjectedClassNameType definition for details
1386   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
1387   enum {
1388     TypeAlignmentInBits = 4,
1389     TypeAlignment = 1 << TypeAlignmentInBits
1390   };
1391 
1392   return QualType(new (Importer.getToContext(), TypeAlignment)
1393                   InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
1394 }
1395 
VisitRecordType(const RecordType * T)1396 ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
1397   Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
1398   if (!ToDeclOrErr)
1399     return ToDeclOrErr.takeError();
1400 
1401   return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1402 }
1403 
VisitEnumType(const EnumType * T)1404 ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
1405   Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
1406   if (!ToDeclOrErr)
1407     return ToDeclOrErr.takeError();
1408 
1409   return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
1410 }
1411 
VisitAttributedType(const AttributedType * T)1412 ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
1413   ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
1414   if (!ToModifiedTypeOrErr)
1415     return ToModifiedTypeOrErr.takeError();
1416   ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType());
1417   if (!ToEquivalentTypeOrErr)
1418     return ToEquivalentTypeOrErr.takeError();
1419 
1420   return Importer.getToContext().getAttributedType(T->getAttrKind(),
1421       *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
1422 }
1423 
VisitTemplateTypeParmType(const TemplateTypeParmType * T)1424 ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
1425     const TemplateTypeParmType *T) {
1426   Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
1427   if (!ToDeclOrErr)
1428     return ToDeclOrErr.takeError();
1429 
1430   return Importer.getToContext().getTemplateTypeParmType(
1431       T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr);
1432 }
1433 
VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType * T)1434 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
1435     const SubstTemplateTypeParmType *T) {
1436   ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0));
1437   if (!ReplacedOrErr)
1438     return ReplacedOrErr.takeError();
1439   const TemplateTypeParmType *Replaced =
1440       cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr());
1441 
1442   ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
1443   if (!ToReplacementTypeOrErr)
1444     return ToReplacementTypeOrErr.takeError();
1445 
1446   return Importer.getToContext().getSubstTemplateTypeParmType(
1447         Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
1448 }
1449 
VisitTemplateSpecializationType(const TemplateSpecializationType * T)1450 ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
1451                                        const TemplateSpecializationType *T) {
1452   auto ToTemplateOrErr = import(T->getTemplateName());
1453   if (!ToTemplateOrErr)
1454     return ToTemplateOrErr.takeError();
1455 
1456   SmallVector<TemplateArgument, 2> ToTemplateArgs;
1457   if (Error Err = ImportTemplateArguments(
1458       T->getArgs(), T->getNumArgs(), ToTemplateArgs))
1459     return std::move(Err);
1460 
1461   QualType ToCanonType;
1462   if (!QualType(T, 0).isCanonical()) {
1463     QualType FromCanonType
1464       = Importer.getFromContext().getCanonicalType(QualType(T, 0));
1465     if (ExpectedType TyOrErr = import(FromCanonType))
1466       ToCanonType = *TyOrErr;
1467     else
1468       return TyOrErr.takeError();
1469   }
1470   return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
1471                                                                ToTemplateArgs,
1472                                                                ToCanonType);
1473 }
1474 
VisitElaboratedType(const ElaboratedType * T)1475 ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
1476   // Note: the qualifier in an ElaboratedType is optional.
1477   auto ToQualifierOrErr = import(T->getQualifier());
1478   if (!ToQualifierOrErr)
1479     return ToQualifierOrErr.takeError();
1480 
1481   ExpectedType ToNamedTypeOrErr = import(T->getNamedType());
1482   if (!ToNamedTypeOrErr)
1483     return ToNamedTypeOrErr.takeError();
1484 
1485   Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl());
1486   if (!ToOwnedTagDeclOrErr)
1487     return ToOwnedTagDeclOrErr.takeError();
1488 
1489   return Importer.getToContext().getElaboratedType(T->getKeyword(),
1490                                                    *ToQualifierOrErr,
1491                                                    *ToNamedTypeOrErr,
1492                                                    *ToOwnedTagDeclOrErr);
1493 }
1494 
1495 ExpectedType
VisitPackExpansionType(const PackExpansionType * T)1496 ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
1497   ExpectedType ToPatternOrErr = import(T->getPattern());
1498   if (!ToPatternOrErr)
1499     return ToPatternOrErr.takeError();
1500 
1501   return Importer.getToContext().getPackExpansionType(*ToPatternOrErr,
1502                                                       T->getNumExpansions(),
1503                                                       /*ExpactPack=*/false);
1504 }
1505 
VisitDependentTemplateSpecializationType(const DependentTemplateSpecializationType * T)1506 ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
1507     const DependentTemplateSpecializationType *T) {
1508   auto ToQualifierOrErr = import(T->getQualifier());
1509   if (!ToQualifierOrErr)
1510     return ToQualifierOrErr.takeError();
1511 
1512   IdentifierInfo *ToName = Importer.Import(T->getIdentifier());
1513 
1514   SmallVector<TemplateArgument, 2> ToPack;
1515   ToPack.reserve(T->getNumArgs());
1516   if (Error Err = ImportTemplateArguments(
1517       T->getArgs(), T->getNumArgs(), ToPack))
1518     return std::move(Err);
1519 
1520   return Importer.getToContext().getDependentTemplateSpecializationType(
1521       T->getKeyword(), *ToQualifierOrErr, ToName, ToPack);
1522 }
1523 
1524 ExpectedType
VisitDependentNameType(const DependentNameType * T)1525 ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
1526   auto ToQualifierOrErr = import(T->getQualifier());
1527   if (!ToQualifierOrErr)
1528     return ToQualifierOrErr.takeError();
1529 
1530   IdentifierInfo *Name = Importer.Import(T->getIdentifier());
1531 
1532   QualType Canon;
1533   if (T != T->getCanonicalTypeInternal().getTypePtr()) {
1534     if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal()))
1535       Canon = (*TyOrErr).getCanonicalType();
1536     else
1537       return TyOrErr.takeError();
1538   }
1539 
1540   return Importer.getToContext().getDependentNameType(T->getKeyword(),
1541                                                       *ToQualifierOrErr,
1542                                                       Name, Canon);
1543 }
1544 
1545 ExpectedType
VisitObjCInterfaceType(const ObjCInterfaceType * T)1546 ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
1547   Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
1548   if (!ToDeclOrErr)
1549     return ToDeclOrErr.takeError();
1550 
1551   return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
1552 }
1553 
VisitObjCObjectType(const ObjCObjectType * T)1554 ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
1555   ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
1556   if (!ToBaseTypeOrErr)
1557     return ToBaseTypeOrErr.takeError();
1558 
1559   SmallVector<QualType, 4> TypeArgs;
1560   for (auto TypeArg : T->getTypeArgsAsWritten()) {
1561     if (ExpectedType TyOrErr = import(TypeArg))
1562       TypeArgs.push_back(*TyOrErr);
1563     else
1564       return TyOrErr.takeError();
1565   }
1566 
1567   SmallVector<ObjCProtocolDecl *, 4> Protocols;
1568   for (auto *P : T->quals()) {
1569     if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P))
1570       Protocols.push_back(*ProtocolOrErr);
1571     else
1572       return ProtocolOrErr.takeError();
1573 
1574   }
1575 
1576   return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
1577                                                    Protocols,
1578                                                    T->isKindOfTypeAsWritten());
1579 }
1580 
1581 ExpectedType
VisitObjCObjectPointerType(const ObjCObjectPointerType * T)1582 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
1583   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
1584   if (!ToPointeeTypeOrErr)
1585     return ToPointeeTypeOrErr.takeError();
1586 
1587   return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr);
1588 }
1589 
1590 //----------------------------------------------------------------------------
1591 // Import Declarations
1592 //----------------------------------------------------------------------------
ImportDeclParts(NamedDecl * D,DeclContext * & DC,DeclContext * & LexicalDC,DeclarationName & Name,NamedDecl * & ToD,SourceLocation & Loc)1593 Error ASTNodeImporter::ImportDeclParts(
1594     NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
1595     DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
1596   // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
1597   // example: int struct_in_proto(struct data_t{int a;int b;} *d);
1598   // FIXME: We could support these constructs by importing a different type of
1599   // this parameter and by importing the original type of the parameter only
1600   // after the FunctionDecl is created. See
1601   // VisitFunctionDecl::UsedDifferentProtoType.
1602   DeclContext *OrigDC = D->getDeclContext();
1603   FunctionDecl *FunDecl;
1604   if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
1605       FunDecl->hasBody()) {
1606     auto getLeafPointeeType = [](const Type *T) {
1607       while (T->isPointerType() || T->isArrayType()) {
1608         T = T->getPointeeOrArrayElementType();
1609       }
1610       return T;
1611     };
1612     for (const ParmVarDecl *P : FunDecl->parameters()) {
1613       const Type *LeafT =
1614           getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
1615       auto *RT = dyn_cast<RecordType>(LeafT);
1616       if (RT && RT->getDecl() == D) {
1617         Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
1618             << D->getDeclKindName();
1619         return make_error<ImportError>(ImportError::UnsupportedConstruct);
1620       }
1621     }
1622   }
1623 
1624   // Import the context of this declaration.
1625   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
1626     return Err;
1627 
1628   // Import the name of this declaration.
1629   if (Error Err = importInto(Name, D->getDeclName()))
1630     return Err;
1631 
1632   // Import the location of this declaration.
1633   if (Error Err = importInto(Loc, D->getLocation()))
1634     return Err;
1635 
1636   ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1637   if (ToD)
1638     if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1639       return Err;
1640 
1641   return Error::success();
1642 }
1643 
ImportDeclParts(NamedDecl * D,DeclarationName & Name,NamedDecl * & ToD,SourceLocation & Loc)1644 Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclarationName &Name,
1645                                        NamedDecl *&ToD, SourceLocation &Loc) {
1646 
1647   // Import the name of this declaration.
1648   if (Error Err = importInto(Name, D->getDeclName()))
1649     return Err;
1650 
1651   // Import the location of this declaration.
1652   if (Error Err = importInto(Loc, D->getLocation()))
1653     return Err;
1654 
1655   ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D));
1656   if (ToD)
1657     if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD))
1658       return Err;
1659 
1660   return Error::success();
1661 }
1662 
ImportDefinitionIfNeeded(Decl * FromD,Decl * ToD)1663 Error ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) {
1664   if (!FromD)
1665     return Error::success();
1666 
1667   if (!ToD)
1668     if (Error Err = importInto(ToD, FromD))
1669       return Err;
1670 
1671   if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) {
1672     if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) {
1673       if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() &&
1674           !ToRecord->getDefinition()) {
1675         if (Error Err = ImportDefinition(FromRecord, ToRecord))
1676           return Err;
1677       }
1678     }
1679     return Error::success();
1680   }
1681 
1682   if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) {
1683     if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) {
1684       if (FromEnum->getDefinition() && !ToEnum->getDefinition()) {
1685         if (Error Err = ImportDefinition(FromEnum, ToEnum))
1686           return Err;
1687       }
1688     }
1689     return Error::success();
1690   }
1691 
1692   return Error::success();
1693 }
1694 
1695 Error
ImportDeclarationNameLoc(const DeclarationNameInfo & From,DeclarationNameInfo & To)1696 ASTNodeImporter::ImportDeclarationNameLoc(
1697     const DeclarationNameInfo &From, DeclarationNameInfo& To) {
1698   // NOTE: To.Name and To.Loc are already imported.
1699   // We only have to import To.LocInfo.
1700   switch (To.getName().getNameKind()) {
1701   case DeclarationName::Identifier:
1702   case DeclarationName::ObjCZeroArgSelector:
1703   case DeclarationName::ObjCOneArgSelector:
1704   case DeclarationName::ObjCMultiArgSelector:
1705   case DeclarationName::CXXUsingDirective:
1706   case DeclarationName::CXXDeductionGuideName:
1707     return Error::success();
1708 
1709   case DeclarationName::CXXOperatorName: {
1710     if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange()))
1711       To.setCXXOperatorNameRange(*ToRangeOrErr);
1712     else
1713       return ToRangeOrErr.takeError();
1714     return Error::success();
1715   }
1716   case DeclarationName::CXXLiteralOperatorName: {
1717     if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc()))
1718       To.setCXXLiteralOperatorNameLoc(*LocOrErr);
1719     else
1720       return LocOrErr.takeError();
1721     return Error::success();
1722   }
1723   case DeclarationName::CXXConstructorName:
1724   case DeclarationName::CXXDestructorName:
1725   case DeclarationName::CXXConversionFunctionName: {
1726     if (auto ToTInfoOrErr = import(From.getNamedTypeInfo()))
1727       To.setNamedTypeInfo(*ToTInfoOrErr);
1728     else
1729       return ToTInfoOrErr.takeError();
1730     return Error::success();
1731   }
1732   }
1733   llvm_unreachable("Unknown name kind.");
1734 }
1735 
1736 Error
ImportDeclContext(DeclContext * FromDC,bool ForceImport)1737 ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
1738   if (Importer.isMinimalImport() && !ForceImport) {
1739     auto ToDCOrErr = Importer.ImportContext(FromDC);
1740     return ToDCOrErr.takeError();
1741   }
1742 
1743   // We use strict error handling in case of records and enums, but not
1744   // with e.g. namespaces.
1745   //
1746   // FIXME Clients of the ASTImporter should be able to choose an
1747   // appropriate error handling strategy for their needs.  For instance,
1748   // they may not want to mark an entire namespace as erroneous merely
1749   // because there is an ODR error with two typedefs.  As another example,
1750   // the client may allow EnumConstantDecls with same names but with
1751   // different values in two distinct translation units.
1752   bool AccumulateChildErrors = isa<TagDecl>(FromDC);
1753 
1754   Error ChildErrors = Error::success();
1755   for (auto *From : FromDC->decls()) {
1756     ExpectedDecl ImportedOrErr = import(From);
1757 
1758     // If we are in the process of ImportDefinition(...) for a RecordDecl we
1759     // want to make sure that we are also completing each FieldDecl. There
1760     // are currently cases where this does not happen and this is correctness
1761     // fix since operations such as code generation will expect this to be so.
1762     if (ImportedOrErr) {
1763       FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From);
1764       Decl *ImportedDecl = *ImportedOrErr;
1765       FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl);
1766       if (FieldFrom && FieldTo) {
1767         RecordDecl *FromRecordDecl = nullptr;
1768         RecordDecl *ToRecordDecl = nullptr;
1769         // If we have a field that is an ArrayType we need to check if the array
1770         // element is a RecordDecl and if so we need to import the defintion.
1771         if (FieldFrom->getType()->isArrayType()) {
1772           // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
1773           FromRecordDecl = FieldFrom->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1774           ToRecordDecl = FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
1775         }
1776 
1777         if (!FromRecordDecl || !ToRecordDecl) {
1778           const RecordType *RecordFrom =
1779               FieldFrom->getType()->getAs<RecordType>();
1780           const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>();
1781 
1782           if (RecordFrom && RecordTo) {
1783             FromRecordDecl = RecordFrom->getDecl();
1784             ToRecordDecl = RecordTo->getDecl();
1785           }
1786         }
1787 
1788         if (FromRecordDecl && ToRecordDecl) {
1789           if (FromRecordDecl->isCompleteDefinition() &&
1790               !ToRecordDecl->isCompleteDefinition()) {
1791             Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl);
1792 
1793             if (Err && AccumulateChildErrors)
1794               ChildErrors =  joinErrors(std::move(ChildErrors), std::move(Err));
1795             else
1796               consumeError(std::move(Err));
1797           }
1798         }
1799       }
1800     } else {
1801       if (AccumulateChildErrors)
1802         ChildErrors =
1803             joinErrors(std::move(ChildErrors), ImportedOrErr.takeError());
1804       else
1805         consumeError(ImportedOrErr.takeError());
1806     }
1807   }
1808 
1809   // We reorder declarations in RecordDecls because they may have another order
1810   // in the "to" context than they have in the "from" context. This may happen
1811   // e.g when we import a class like this:
1812   //    struct declToImport {
1813   //        int a = c + b;
1814   //        int b = 1;
1815   //        int c = 2;
1816   //    };
1817   // During the import of `a` we import first the dependencies in sequence,
1818   // thus the order would be `c`, `b`, `a`. We will get the normal order by
1819   // first removing the already imported members and then adding them in the
1820   // order as they apper in the "from" context.
1821   //
1822   // Keeping field order is vital because it determines structure layout.
1823   //
1824   // Here and below, we cannot call field_begin() method and its callers on
1825   // ToDC if it has an external storage. Calling field_begin() will
1826   // automatically load all the fields by calling
1827   // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would
1828   // call ASTImporter::Import(). This is because the ExternalASTSource
1829   // interface in LLDB is implemented by the means of the ASTImporter. However,
1830   // calling an import at this point would result in an uncontrolled import, we
1831   // must avoid that.
1832   const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
1833   if (!FromRD)
1834     return ChildErrors;
1835 
1836   auto ToDCOrErr = Importer.ImportContext(FromDC);
1837   if (!ToDCOrErr) {
1838     consumeError(std::move(ChildErrors));
1839     return ToDCOrErr.takeError();
1840   }
1841 
1842   DeclContext *ToDC = *ToDCOrErr;
1843   // Remove all declarations, which may be in wrong order in the
1844   // lexical DeclContext and then add them in the proper order.
1845   for (auto *D : FromRD->decls()) {
1846     if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) {
1847       assert(D && "DC contains a null decl");
1848       Decl *ToD = Importer.GetAlreadyImportedOrNull(D);
1849       // Remove only the decls which we successfully imported.
1850       if (ToD) {
1851         assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD));
1852         // Remove the decl from its wrong place in the linked list.
1853         ToDC->removeDecl(ToD);
1854         // Add the decl to the end of the linked list.
1855         // This time it will be at the proper place because the enclosing for
1856         // loop iterates in the original (good) order of the decls.
1857         ToDC->addDeclInternal(ToD);
1858       }
1859     }
1860   }
1861 
1862   return ChildErrors;
1863 }
1864 
ImportDeclContext(Decl * FromD,DeclContext * & ToDC,DeclContext * & ToLexicalDC)1865 Error ASTNodeImporter::ImportDeclContext(
1866     Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
1867   auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
1868   if (!ToDCOrErr)
1869     return ToDCOrErr.takeError();
1870   ToDC = *ToDCOrErr;
1871 
1872   if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
1873     auto ToLexicalDCOrErr = Importer.ImportContext(
1874         FromD->getLexicalDeclContext());
1875     if (!ToLexicalDCOrErr)
1876       return ToLexicalDCOrErr.takeError();
1877     ToLexicalDC = *ToLexicalDCOrErr;
1878   } else
1879     ToLexicalDC = ToDC;
1880 
1881   return Error::success();
1882 }
1883 
ImportImplicitMethods(const CXXRecordDecl * From,CXXRecordDecl * To)1884 Error ASTNodeImporter::ImportImplicitMethods(
1885     const CXXRecordDecl *From, CXXRecordDecl *To) {
1886   assert(From->isCompleteDefinition() && To->getDefinition() == To &&
1887       "Import implicit methods to or from non-definition");
1888 
1889   for (CXXMethodDecl *FromM : From->methods())
1890     if (FromM->isImplicit()) {
1891       Expected<CXXMethodDecl *> ToMOrErr = import(FromM);
1892       if (!ToMOrErr)
1893         return ToMOrErr.takeError();
1894     }
1895 
1896   return Error::success();
1897 }
1898 
setTypedefNameForAnonDecl(TagDecl * From,TagDecl * To,ASTImporter & Importer)1899 static Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To,
1900                                        ASTImporter &Importer) {
1901   if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) {
1902     if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef))
1903       To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr));
1904     else
1905       return ToTypedefOrErr.takeError();
1906   }
1907   return Error::success();
1908 }
1909 
ImportDefinition(RecordDecl * From,RecordDecl * To,ImportDefinitionKind Kind)1910 Error ASTNodeImporter::ImportDefinition(
1911     RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
1912   auto DefinitionCompleter = [To]() {
1913     // There are cases in LLDB when we first import a class without its
1914     // members. The class will have DefinitionData, but no members. Then,
1915     // importDefinition is called from LLDB, which tries to get the members, so
1916     // when we get here, the class already has the DefinitionData set, so we
1917     // must unset the CompleteDefinition here to be able to complete again the
1918     // definition.
1919     To->setCompleteDefinition(false);
1920     To->completeDefinition();
1921   };
1922 
1923   if (To->getDefinition() || To->isBeingDefined()) {
1924     if (Kind == IDK_Everything ||
1925         // In case of lambdas, the class already has a definition ptr set, but
1926         // the contained decls are not imported yet. Also, isBeingDefined was
1927         // set in CXXRecordDecl::CreateLambda.  We must import the contained
1928         // decls here and finish the definition.
1929         (To->isLambda() && shouldForceImportDeclContext(Kind))) {
1930       if (To->isLambda()) {
1931         auto *FromCXXRD = cast<CXXRecordDecl>(From);
1932         SmallVector<LambdaCapture, 8> ToCaptures;
1933         ToCaptures.reserve(FromCXXRD->capture_size());
1934         for (const auto &FromCapture : FromCXXRD->captures()) {
1935           if (auto ToCaptureOrErr = import(FromCapture))
1936             ToCaptures.push_back(*ToCaptureOrErr);
1937           else
1938             return ToCaptureOrErr.takeError();
1939         }
1940         cast<CXXRecordDecl>(To)->setCaptures(Importer.getToContext(),
1941                                              ToCaptures);
1942       }
1943 
1944       Error Result = ImportDeclContext(From, /*ForceImport=*/true);
1945       // Finish the definition of the lambda, set isBeingDefined to false.
1946       if (To->isLambda())
1947         DefinitionCompleter();
1948       return Result;
1949     }
1950 
1951     return Error::success();
1952   }
1953 
1954   To->startDefinition();
1955   // Complete the definition even if error is returned.
1956   // The RecordDecl may be already part of the AST so it is better to
1957   // have it in complete state even if something is wrong with it.
1958   auto DefinitionCompleterScopeExit =
1959       llvm::make_scope_exit(DefinitionCompleter);
1960 
1961   if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
1962     return Err;
1963 
1964   // Add base classes.
1965   auto *ToCXX = dyn_cast<CXXRecordDecl>(To);
1966   auto *FromCXX = dyn_cast<CXXRecordDecl>(From);
1967   if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) {
1968 
1969     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
1970     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
1971 
1972     #define FIELD(Name, Width, Merge) \
1973     ToData.Name = FromData.Name;
1974     #include "clang/AST/CXXRecordDeclDefinitionBits.def"
1975 
1976     // Copy over the data stored in RecordDeclBits
1977     ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
1978 
1979     SmallVector<CXXBaseSpecifier *, 4> Bases;
1980     for (const auto &Base1 : FromCXX->bases()) {
1981       ExpectedType TyOrErr = import(Base1.getType());
1982       if (!TyOrErr)
1983         return TyOrErr.takeError();
1984 
1985       SourceLocation EllipsisLoc;
1986       if (Base1.isPackExpansion()) {
1987         if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc()))
1988           EllipsisLoc = *LocOrErr;
1989         else
1990           return LocOrErr.takeError();
1991       }
1992 
1993       // Ensure that we have a definition for the base.
1994       if (Error Err =
1995           ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
1996         return Err;
1997 
1998       auto RangeOrErr = import(Base1.getSourceRange());
1999       if (!RangeOrErr)
2000         return RangeOrErr.takeError();
2001 
2002       auto TSIOrErr = import(Base1.getTypeSourceInfo());
2003       if (!TSIOrErr)
2004         return TSIOrErr.takeError();
2005 
2006       Bases.push_back(
2007           new (Importer.getToContext()) CXXBaseSpecifier(
2008               *RangeOrErr,
2009               Base1.isVirtual(),
2010               Base1.isBaseOfClass(),
2011               Base1.getAccessSpecifierAsWritten(),
2012               *TSIOrErr,
2013               EllipsisLoc));
2014     }
2015     if (!Bases.empty())
2016       ToCXX->setBases(Bases.data(), Bases.size());
2017   }
2018 
2019   if (shouldForceImportDeclContext(Kind))
2020     if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2021       return Err;
2022 
2023   return Error::success();
2024 }
2025 
ImportInitializer(VarDecl * From,VarDecl * To)2026 Error ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) {
2027   if (To->getAnyInitializer())
2028     return Error::success();
2029 
2030   Expr *FromInit = From->getInit();
2031   if (!FromInit)
2032     return Error::success();
2033 
2034   ExpectedExpr ToInitOrErr = import(FromInit);
2035   if (!ToInitOrErr)
2036     return ToInitOrErr.takeError();
2037 
2038   To->setInit(*ToInitOrErr);
2039   if (EvaluatedStmt *FromEval = From->getEvaluatedStmt()) {
2040     EvaluatedStmt *ToEval = To->ensureEvaluatedStmt();
2041     ToEval->HasConstantInitialization = FromEval->HasConstantInitialization;
2042     ToEval->HasConstantDestruction = FromEval->HasConstantDestruction;
2043     // FIXME: Also import the initializer value.
2044   }
2045 
2046   // FIXME: Other bits to merge?
2047   return Error::success();
2048 }
2049 
ImportDefinition(EnumDecl * From,EnumDecl * To,ImportDefinitionKind Kind)2050 Error ASTNodeImporter::ImportDefinition(
2051     EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
2052   if (To->getDefinition() || To->isBeingDefined()) {
2053     if (Kind == IDK_Everything)
2054       return ImportDeclContext(From, /*ForceImport=*/true);
2055     return Error::success();
2056   }
2057 
2058   To->startDefinition();
2059 
2060   if (Error Err = setTypedefNameForAnonDecl(From, To, Importer))
2061     return Err;
2062 
2063   ExpectedType ToTypeOrErr =
2064       import(Importer.getFromContext().getTypeDeclType(From));
2065   if (!ToTypeOrErr)
2066     return ToTypeOrErr.takeError();
2067 
2068   ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType());
2069   if (!ToPromotionTypeOrErr)
2070     return ToPromotionTypeOrErr.takeError();
2071 
2072   if (shouldForceImportDeclContext(Kind))
2073     if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
2074       return Err;
2075 
2076   // FIXME: we might need to merge the number of positive or negative bits
2077   // if the enumerator lists don't match.
2078   To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr,
2079                          From->getNumPositiveBits(),
2080                          From->getNumNegativeBits());
2081   return Error::success();
2082 }
2083 
ImportTemplateArguments(const TemplateArgument * FromArgs,unsigned NumFromArgs,SmallVectorImpl<TemplateArgument> & ToArgs)2084 Error ASTNodeImporter::ImportTemplateArguments(
2085     const TemplateArgument *FromArgs, unsigned NumFromArgs,
2086     SmallVectorImpl<TemplateArgument> &ToArgs) {
2087   for (unsigned I = 0; I != NumFromArgs; ++I) {
2088     if (auto ToOrErr = import(FromArgs[I]))
2089       ToArgs.push_back(*ToOrErr);
2090     else
2091       return ToOrErr.takeError();
2092   }
2093 
2094   return Error::success();
2095 }
2096 
2097 // FIXME: Do not forget to remove this and use only 'import'.
2098 Expected<TemplateArgument>
ImportTemplateArgument(const TemplateArgument & From)2099 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
2100   return import(From);
2101 }
2102 
2103 template <typename InContainerTy>
ImportTemplateArgumentListInfo(const InContainerTy & Container,TemplateArgumentListInfo & ToTAInfo)2104 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
2105     const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
2106   for (const auto &FromLoc : Container) {
2107     if (auto ToLocOrErr = import(FromLoc))
2108       ToTAInfo.addArgument(*ToLocOrErr);
2109     else
2110       return ToLocOrErr.takeError();
2111   }
2112   return Error::success();
2113 }
2114 
2115 static StructuralEquivalenceKind
getStructuralEquivalenceKind(const ASTImporter & Importer)2116 getStructuralEquivalenceKind(const ASTImporter &Importer) {
2117   return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
2118                                     : StructuralEquivalenceKind::Default;
2119 }
2120 
IsStructuralMatch(Decl * From,Decl * To,bool Complain)2121 bool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) {
2122   StructuralEquivalenceContext Ctx(
2123       Importer.getFromContext(), Importer.getToContext(),
2124       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2125       false, Complain);
2126   return Ctx.IsEquivalent(From, To);
2127 }
2128 
IsStructuralMatch(RecordDecl * FromRecord,RecordDecl * ToRecord,bool Complain)2129 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord,
2130                                         RecordDecl *ToRecord, bool Complain) {
2131   // Eliminate a potential failure point where we attempt to re-import
2132   // something we're trying to import while completing ToRecord.
2133   Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord);
2134   if (ToOrigin) {
2135     auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin);
2136     if (ToOriginRecord)
2137       ToRecord = ToOriginRecord;
2138   }
2139 
2140   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2141                                    ToRecord->getASTContext(),
2142                                    Importer.getNonEquivalentDecls(),
2143                                    getStructuralEquivalenceKind(Importer),
2144                                    false, Complain);
2145   return Ctx.IsEquivalent(FromRecord, ToRecord);
2146 }
2147 
IsStructuralMatch(VarDecl * FromVar,VarDecl * ToVar,bool Complain)2148 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
2149                                         bool Complain) {
2150   StructuralEquivalenceContext Ctx(
2151       Importer.getFromContext(), Importer.getToContext(),
2152       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2153       false, Complain);
2154   return Ctx.IsEquivalent(FromVar, ToVar);
2155 }
2156 
IsStructuralMatch(EnumDecl * FromEnum,EnumDecl * ToEnum)2157 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) {
2158   // Eliminate a potential failure point where we attempt to re-import
2159   // something we're trying to import while completing ToEnum.
2160   if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum))
2161     if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin))
2162         ToEnum = ToOriginEnum;
2163 
2164   StructuralEquivalenceContext Ctx(
2165       Importer.getFromContext(), Importer.getToContext(),
2166       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
2167   return Ctx.IsEquivalent(FromEnum, ToEnum);
2168 }
2169 
IsStructuralMatch(FunctionTemplateDecl * From,FunctionTemplateDecl * To)2170 bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From,
2171                                         FunctionTemplateDecl *To) {
2172   StructuralEquivalenceContext Ctx(
2173       Importer.getFromContext(), Importer.getToContext(),
2174       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2175       false, false);
2176   return Ctx.IsEquivalent(From, To);
2177 }
2178 
IsStructuralMatch(FunctionDecl * From,FunctionDecl * To)2179 bool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) {
2180   StructuralEquivalenceContext Ctx(
2181       Importer.getFromContext(), Importer.getToContext(),
2182       Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
2183       false, false);
2184   return Ctx.IsEquivalent(From, To);
2185 }
2186 
IsStructuralMatch(EnumConstantDecl * FromEC,EnumConstantDecl * ToEC)2187 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
2188                                         EnumConstantDecl *ToEC) {
2189   const llvm::APSInt &FromVal = FromEC->getInitVal();
2190   const llvm::APSInt &ToVal = ToEC->getInitVal();
2191 
2192   return FromVal.isSigned() == ToVal.isSigned() &&
2193          FromVal.getBitWidth() == ToVal.getBitWidth() &&
2194          FromVal == ToVal;
2195 }
2196 
IsStructuralMatch(ClassTemplateDecl * From,ClassTemplateDecl * To)2197 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
2198                                         ClassTemplateDecl *To) {
2199   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2200                                    Importer.getToContext(),
2201                                    Importer.getNonEquivalentDecls(),
2202                                    getStructuralEquivalenceKind(Importer));
2203   return Ctx.IsEquivalent(From, To);
2204 }
2205 
IsStructuralMatch(VarTemplateDecl * From,VarTemplateDecl * To)2206 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
2207                                         VarTemplateDecl *To) {
2208   StructuralEquivalenceContext Ctx(Importer.getFromContext(),
2209                                    Importer.getToContext(),
2210                                    Importer.getNonEquivalentDecls(),
2211                                    getStructuralEquivalenceKind(Importer));
2212   return Ctx.IsEquivalent(From, To);
2213 }
2214 
VisitDecl(Decl * D)2215 ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
2216   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2217     << D->getDeclKindName();
2218   return make_error<ImportError>(ImportError::UnsupportedConstruct);
2219 }
2220 
VisitImportDecl(ImportDecl * D)2221 ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {
2222   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
2223       << D->getDeclKindName();
2224   return make_error<ImportError>(ImportError::UnsupportedConstruct);
2225 }
2226 
VisitEmptyDecl(EmptyDecl * D)2227 ExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) {
2228   // Import the context of this declaration.
2229   DeclContext *DC, *LexicalDC;
2230   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
2231     return std::move(Err);
2232 
2233   // Import the location of this declaration.
2234   ExpectedSLoc LocOrErr = import(D->getLocation());
2235   if (!LocOrErr)
2236     return LocOrErr.takeError();
2237 
2238   EmptyDecl *ToD;
2239   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr))
2240     return ToD;
2241 
2242   ToD->setLexicalDeclContext(LexicalDC);
2243   LexicalDC->addDeclInternal(ToD);
2244   return ToD;
2245 }
2246 
VisitTranslationUnitDecl(TranslationUnitDecl * D)2247 ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
2248   TranslationUnitDecl *ToD =
2249     Importer.getToContext().getTranslationUnitDecl();
2250 
2251   Importer.MapImported(D, ToD);
2252 
2253   return ToD;
2254 }
2255 
VisitAccessSpecDecl(AccessSpecDecl * D)2256 ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
2257   ExpectedSLoc LocOrErr = import(D->getLocation());
2258   if (!LocOrErr)
2259     return LocOrErr.takeError();
2260   auto ColonLocOrErr = import(D->getColonLoc());
2261   if (!ColonLocOrErr)
2262     return ColonLocOrErr.takeError();
2263 
2264   // Import the context of this declaration.
2265   auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2266   if (!DCOrErr)
2267     return DCOrErr.takeError();
2268   DeclContext *DC = *DCOrErr;
2269 
2270   AccessSpecDecl *ToD;
2271   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(),
2272                               DC, *LocOrErr, *ColonLocOrErr))
2273     return ToD;
2274 
2275   // Lexical DeclContext and Semantic DeclContext
2276   // is always the same for the accessSpec.
2277   ToD->setLexicalDeclContext(DC);
2278   DC->addDeclInternal(ToD);
2279 
2280   return ToD;
2281 }
2282 
VisitStaticAssertDecl(StaticAssertDecl * D)2283 ExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) {
2284   auto DCOrErr = Importer.ImportContext(D->getDeclContext());
2285   if (!DCOrErr)
2286     return DCOrErr.takeError();
2287   DeclContext *DC = *DCOrErr;
2288   DeclContext *LexicalDC = DC;
2289 
2290   Error Err = Error::success();
2291   auto ToLocation = importChecked(Err, D->getLocation());
2292   auto ToRParenLoc = importChecked(Err, D->getRParenLoc());
2293   auto ToAssertExpr = importChecked(Err, D->getAssertExpr());
2294   auto ToMessage = importChecked(Err, D->getMessage());
2295   if (Err)
2296     return std::move(Err);
2297 
2298   StaticAssertDecl *ToD;
2299   if (GetImportedOrCreateDecl(
2300       ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
2301       ToRParenLoc, D->isFailed()))
2302     return ToD;
2303 
2304   ToD->setLexicalDeclContext(LexicalDC);
2305   LexicalDC->addDeclInternal(ToD);
2306   return ToD;
2307 }
2308 
VisitNamespaceDecl(NamespaceDecl * D)2309 ExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) {
2310   // Import the major distinguishing characteristics of this namespace.
2311   DeclContext *DC, *LexicalDC;
2312   DeclarationName Name;
2313   SourceLocation Loc;
2314   NamedDecl *ToD;
2315   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2316     return std::move(Err);
2317   if (ToD)
2318     return ToD;
2319 
2320   NamespaceDecl *MergeWithNamespace = nullptr;
2321   if (!Name) {
2322     // This is an anonymous namespace. Adopt an existing anonymous
2323     // namespace if we can.
2324     // FIXME: Not testable.
2325     if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2326       MergeWithNamespace = TU->getAnonymousNamespace();
2327     else
2328       MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace();
2329   } else {
2330     SmallVector<NamedDecl *, 4> ConflictingDecls;
2331     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2332     for (auto *FoundDecl : FoundDecls) {
2333       if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace))
2334         continue;
2335 
2336       if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) {
2337         MergeWithNamespace = FoundNS;
2338         ConflictingDecls.clear();
2339         break;
2340       }
2341 
2342       ConflictingDecls.push_back(FoundDecl);
2343     }
2344 
2345     if (!ConflictingDecls.empty()) {
2346       ExpectedName NameOrErr = Importer.HandleNameConflict(
2347           Name, DC, Decl::IDNS_Namespace, ConflictingDecls.data(),
2348           ConflictingDecls.size());
2349       if (NameOrErr)
2350         Name = NameOrErr.get();
2351       else
2352         return NameOrErr.takeError();
2353     }
2354   }
2355 
2356   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2357   if (!BeginLocOrErr)
2358     return BeginLocOrErr.takeError();
2359   ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
2360   if (!RBraceLocOrErr)
2361     return RBraceLocOrErr.takeError();
2362 
2363   // Create the "to" namespace, if needed.
2364   NamespaceDecl *ToNamespace = MergeWithNamespace;
2365   if (!ToNamespace) {
2366     if (GetImportedOrCreateDecl(
2367             ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
2368             *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2369             /*PrevDecl=*/nullptr))
2370       return ToNamespace;
2371     ToNamespace->setRBraceLoc(*RBraceLocOrErr);
2372     ToNamespace->setLexicalDeclContext(LexicalDC);
2373     LexicalDC->addDeclInternal(ToNamespace);
2374 
2375     // If this is an anonymous namespace, register it as the anonymous
2376     // namespace within its context.
2377     if (!Name) {
2378       if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2379         TU->setAnonymousNamespace(ToNamespace);
2380       else
2381         cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace);
2382     }
2383   }
2384   Importer.MapImported(D, ToNamespace);
2385 
2386   if (Error Err = ImportDeclContext(D))
2387     return std::move(Err);
2388 
2389   return ToNamespace;
2390 }
2391 
VisitNamespaceAliasDecl(NamespaceAliasDecl * D)2392 ExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
2393   // Import the major distinguishing characteristics of this namespace.
2394   DeclContext *DC, *LexicalDC;
2395   DeclarationName Name;
2396   SourceLocation Loc;
2397   NamedDecl *LookupD;
2398   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc))
2399     return std::move(Err);
2400   if (LookupD)
2401     return LookupD;
2402 
2403   // NOTE: No conflict resolution is done for namespace aliases now.
2404 
2405   Error Err = Error::success();
2406   auto ToNamespaceLoc = importChecked(Err, D->getNamespaceLoc());
2407   auto ToAliasLoc = importChecked(Err, D->getAliasLoc());
2408   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2409   auto ToTargetNameLoc = importChecked(Err, D->getTargetNameLoc());
2410   auto ToNamespace = importChecked(Err, D->getNamespace());
2411   if (Err)
2412     return std::move(Err);
2413 
2414   IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());
2415 
2416   NamespaceAliasDecl *ToD;
2417   if (GetImportedOrCreateDecl(
2418       ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
2419       ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
2420     return ToD;
2421 
2422   ToD->setLexicalDeclContext(LexicalDC);
2423   LexicalDC->addDeclInternal(ToD);
2424 
2425   return ToD;
2426 }
2427 
2428 ExpectedDecl
VisitTypedefNameDecl(TypedefNameDecl * D,bool IsAlias)2429 ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
2430   // Import the major distinguishing characteristics of this typedef.
2431   DeclarationName Name;
2432   SourceLocation Loc;
2433   NamedDecl *ToD;
2434   // Do not import the DeclContext, we will import it once the TypedefNameDecl
2435   // is created.
2436   if (Error Err = ImportDeclParts(D, Name, ToD, Loc))
2437     return std::move(Err);
2438   if (ToD)
2439     return ToD;
2440 
2441   DeclContext *DC = cast_or_null<DeclContext>(
2442       Importer.GetAlreadyImportedOrNull(cast<Decl>(D->getDeclContext())));
2443   DeclContext *LexicalDC =
2444       cast_or_null<DeclContext>(Importer.GetAlreadyImportedOrNull(
2445           cast<Decl>(D->getLexicalDeclContext())));
2446 
2447   // If this typedef is not in block scope, determine whether we've
2448   // seen a typedef with the same name (that we can merge with) or any
2449   // other entity by that name (which name lookup could conflict with).
2450   // Note: Repeated typedefs are not valid in C99:
2451   // 'typedef int T; typedef int T;' is invalid
2452   // We do not care about this now.
2453   if (DC && !DC->isFunctionOrMethod()) {
2454     SmallVector<NamedDecl *, 4> ConflictingDecls;
2455     unsigned IDNS = Decl::IDNS_Ordinary;
2456     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2457     for (auto *FoundDecl : FoundDecls) {
2458       if (!FoundDecl->isInIdentifierNamespace(IDNS))
2459         continue;
2460       if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2461         if (!hasSameVisibilityContextAndLinkage(FoundTypedef, D))
2462           continue;
2463 
2464         QualType FromUT = D->getUnderlyingType();
2465         QualType FoundUT = FoundTypedef->getUnderlyingType();
2466         if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) {
2467           // If the "From" context has a complete underlying type but we
2468           // already have a complete underlying type then return with that.
2469           if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType())
2470             return Importer.MapImported(D, FoundTypedef);
2471           // FIXME Handle redecl chain. When you do that make consistent changes
2472           // in ASTImporterLookupTable too.
2473         } else {
2474           ConflictingDecls.push_back(FoundDecl);
2475         }
2476       }
2477     }
2478 
2479     if (!ConflictingDecls.empty()) {
2480       ExpectedName NameOrErr = Importer.HandleNameConflict(
2481           Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2482       if (NameOrErr)
2483         Name = NameOrErr.get();
2484       else
2485         return NameOrErr.takeError();
2486     }
2487   }
2488 
2489   Error Err = Error::success();
2490   auto ToUnderlyingType = importChecked(Err, D->getUnderlyingType());
2491   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
2492   auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2493   if (Err)
2494     return std::move(Err);
2495 
2496   // Create the new typedef node.
2497   // FIXME: ToUnderlyingType is not used.
2498   (void)ToUnderlyingType;
2499   TypedefNameDecl *ToTypedef;
2500   if (IsAlias) {
2501     if (GetImportedOrCreateDecl<TypeAliasDecl>(
2502         ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2503         Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2504       return ToTypedef;
2505   } else if (GetImportedOrCreateDecl<TypedefDecl>(
2506       ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
2507       Name.getAsIdentifierInfo(), ToTypeSourceInfo))
2508     return ToTypedef;
2509 
2510   // Import the DeclContext and set it to the Typedef.
2511   if ((Err = ImportDeclContext(D, DC, LexicalDC)))
2512     return std::move(Err);
2513   ToTypedef->setDeclContext(DC);
2514   ToTypedef->setLexicalDeclContext(LexicalDC);
2515   // Add to the lookupTable because we could not do that in MapImported.
2516   Importer.AddToLookupTable(ToTypedef);
2517 
2518   ToTypedef->setAccess(D->getAccess());
2519 
2520   // Templated declarations should not appear in DeclContext.
2521   TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr;
2522   if (!FromAlias || !FromAlias->getDescribedAliasTemplate())
2523     LexicalDC->addDeclInternal(ToTypedef);
2524 
2525   return ToTypedef;
2526 }
2527 
VisitTypedefDecl(TypedefDecl * D)2528 ExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) {
2529   return VisitTypedefNameDecl(D, /*IsAlias=*/false);
2530 }
2531 
VisitTypeAliasDecl(TypeAliasDecl * D)2532 ExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) {
2533   return VisitTypedefNameDecl(D, /*IsAlias=*/true);
2534 }
2535 
2536 ExpectedDecl
VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl * D)2537 ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
2538   // Import the major distinguishing characteristics of this typedef.
2539   DeclContext *DC, *LexicalDC;
2540   DeclarationName Name;
2541   SourceLocation Loc;
2542   NamedDecl *FoundD;
2543   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc))
2544     return std::move(Err);
2545   if (FoundD)
2546     return FoundD;
2547 
2548   // If this typedef is not in block scope, determine whether we've
2549   // seen a typedef with the same name (that we can merge with) or any
2550   // other entity by that name (which name lookup could conflict with).
2551   if (!DC->isFunctionOrMethod()) {
2552     SmallVector<NamedDecl *, 4> ConflictingDecls;
2553     unsigned IDNS = Decl::IDNS_Ordinary;
2554     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2555     for (auto *FoundDecl : FoundDecls) {
2556       if (!FoundDecl->isInIdentifierNamespace(IDNS))
2557         continue;
2558       if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl))
2559         return Importer.MapImported(D, FoundAlias);
2560       ConflictingDecls.push_back(FoundDecl);
2561     }
2562 
2563     if (!ConflictingDecls.empty()) {
2564       ExpectedName NameOrErr = Importer.HandleNameConflict(
2565           Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2566       if (NameOrErr)
2567         Name = NameOrErr.get();
2568       else
2569         return NameOrErr.takeError();
2570     }
2571   }
2572 
2573   Error Err = Error::success();
2574   auto ToTemplateParameters = importChecked(Err, D->getTemplateParameters());
2575   auto ToTemplatedDecl = importChecked(Err, D->getTemplatedDecl());
2576   if (Err)
2577     return std::move(Err);
2578 
2579   TypeAliasTemplateDecl *ToAlias;
2580   if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc,
2581                               Name, ToTemplateParameters, ToTemplatedDecl))
2582     return ToAlias;
2583 
2584   ToTemplatedDecl->setDescribedAliasTemplate(ToAlias);
2585 
2586   ToAlias->setAccess(D->getAccess());
2587   ToAlias->setLexicalDeclContext(LexicalDC);
2588   LexicalDC->addDeclInternal(ToAlias);
2589   return ToAlias;
2590 }
2591 
VisitLabelDecl(LabelDecl * D)2592 ExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) {
2593   // Import the major distinguishing characteristics of this label.
2594   DeclContext *DC, *LexicalDC;
2595   DeclarationName Name;
2596   SourceLocation Loc;
2597   NamedDecl *ToD;
2598   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2599     return std::move(Err);
2600   if (ToD)
2601     return ToD;
2602 
2603   assert(LexicalDC->isFunctionOrMethod());
2604 
2605   LabelDecl *ToLabel;
2606   if (D->isGnuLocal()) {
2607     ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2608     if (!BeginLocOrErr)
2609       return BeginLocOrErr.takeError();
2610     if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2611                                 Name.getAsIdentifierInfo(), *BeginLocOrErr))
2612       return ToLabel;
2613 
2614   } else {
2615     if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
2616                                 Name.getAsIdentifierInfo()))
2617       return ToLabel;
2618 
2619   }
2620 
2621   Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
2622   if (!ToStmtOrErr)
2623     return ToStmtOrErr.takeError();
2624 
2625   ToLabel->setStmt(*ToStmtOrErr);
2626   ToLabel->setLexicalDeclContext(LexicalDC);
2627   LexicalDC->addDeclInternal(ToLabel);
2628   return ToLabel;
2629 }
2630 
VisitEnumDecl(EnumDecl * D)2631 ExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) {
2632   // Import the major distinguishing characteristics of this enum.
2633   DeclContext *DC, *LexicalDC;
2634   DeclarationName Name;
2635   SourceLocation Loc;
2636   NamedDecl *ToD;
2637   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2638     return std::move(Err);
2639   if (ToD)
2640     return ToD;
2641 
2642   // Figure out what enum name we're looking for.
2643   unsigned IDNS = Decl::IDNS_Tag;
2644   DeclarationName SearchName = Name;
2645   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2646     if (Error Err = importInto(
2647         SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2648       return std::move(Err);
2649     IDNS = Decl::IDNS_Ordinary;
2650   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2651     IDNS |= Decl::IDNS_Ordinary;
2652 
2653   // We may already have an enum of the same name; try to find and match it.
2654   EnumDecl *PrevDecl = nullptr;
2655   if (!DC->isFunctionOrMethod() && SearchName) {
2656     SmallVector<NamedDecl *, 4> ConflictingDecls;
2657     auto FoundDecls =
2658         Importer.findDeclsInToCtx(DC, SearchName);
2659     for (auto *FoundDecl : FoundDecls) {
2660       if (!FoundDecl->isInIdentifierNamespace(IDNS))
2661         continue;
2662 
2663       if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
2664         if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2665           FoundDecl = Tag->getDecl();
2666       }
2667 
2668       if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) {
2669         if (!hasSameVisibilityContextAndLinkage(FoundEnum, D))
2670           continue;
2671         if (IsStructuralMatch(D, FoundEnum)) {
2672           EnumDecl *FoundDef = FoundEnum->getDefinition();
2673           if (D->isThisDeclarationADefinition() && FoundDef)
2674             return Importer.MapImported(D, FoundDef);
2675           PrevDecl = FoundEnum->getMostRecentDecl();
2676           break;
2677         }
2678         ConflictingDecls.push_back(FoundDecl);
2679       }
2680     }
2681 
2682     if (!ConflictingDecls.empty()) {
2683       ExpectedName NameOrErr = Importer.HandleNameConflict(
2684           SearchName, DC, IDNS, ConflictingDecls.data(),
2685           ConflictingDecls.size());
2686       if (NameOrErr)
2687         Name = NameOrErr.get();
2688       else
2689         return NameOrErr.takeError();
2690     }
2691   }
2692 
2693   Error Err = Error::success();
2694   auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
2695   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
2696   auto ToIntegerType = importChecked(Err, D->getIntegerType());
2697   auto ToBraceRange = importChecked(Err, D->getBraceRange());
2698   if (Err)
2699     return std::move(Err);
2700 
2701   // Create the enum declaration.
2702   EnumDecl *D2;
2703   if (GetImportedOrCreateDecl(
2704           D2, D, Importer.getToContext(), DC, ToBeginLoc,
2705           Loc, Name.getAsIdentifierInfo(), PrevDecl, D->isScoped(),
2706           D->isScopedUsingClassTag(), D->isFixed()))
2707     return D2;
2708 
2709   D2->setQualifierInfo(ToQualifierLoc);
2710   D2->setIntegerType(ToIntegerType);
2711   D2->setBraceRange(ToBraceRange);
2712   D2->setAccess(D->getAccess());
2713   D2->setLexicalDeclContext(LexicalDC);
2714   LexicalDC->addDeclInternal(D2);
2715 
2716   // Import the definition
2717   if (D->isCompleteDefinition())
2718     if (Error Err = ImportDefinition(D, D2))
2719       return std::move(Err);
2720 
2721   return D2;
2722 }
2723 
VisitRecordDecl(RecordDecl * D)2724 ExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) {
2725   bool IsFriendTemplate = false;
2726   if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2727     IsFriendTemplate =
2728         DCXX->getDescribedClassTemplate() &&
2729         DCXX->getDescribedClassTemplate()->getFriendObjectKind() !=
2730             Decl::FOK_None;
2731   }
2732 
2733   // Import the major distinguishing characteristics of this record.
2734   DeclContext *DC = nullptr, *LexicalDC = nullptr;
2735   DeclarationName Name;
2736   SourceLocation Loc;
2737   NamedDecl *ToD = nullptr;
2738   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2739     return std::move(Err);
2740   if (ToD)
2741     return ToD;
2742 
2743   // Figure out what structure name we're looking for.
2744   unsigned IDNS = Decl::IDNS_Tag;
2745   DeclarationName SearchName = Name;
2746   if (!SearchName && D->getTypedefNameForAnonDecl()) {
2747     if (Error Err = importInto(
2748         SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
2749       return std::move(Err);
2750     IDNS = Decl::IDNS_Ordinary;
2751   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
2752     IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend;
2753 
2754   // We may already have a record of the same name; try to find and match it.
2755   RecordDecl *PrevDecl = nullptr;
2756   if (!DC->isFunctionOrMethod() && !D->isLambda()) {
2757     SmallVector<NamedDecl *, 4> ConflictingDecls;
2758     auto FoundDecls =
2759         Importer.findDeclsInToCtx(DC, SearchName);
2760     if (!FoundDecls.empty()) {
2761       // We're going to have to compare D against potentially conflicting Decls,
2762       // so complete it.
2763       if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition())
2764         D->getASTContext().getExternalSource()->CompleteType(D);
2765     }
2766 
2767     for (auto *FoundDecl : FoundDecls) {
2768       if (!FoundDecl->isInIdentifierNamespace(IDNS))
2769         continue;
2770 
2771       Decl *Found = FoundDecl;
2772       if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
2773         if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
2774           Found = Tag->getDecl();
2775       }
2776 
2777       if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) {
2778         // Do not emit false positive diagnostic in case of unnamed
2779         // struct/union and in case of anonymous structs.  Would be false
2780         // because there may be several anonymous/unnamed structs in a class.
2781         // E.g. these are both valid:
2782         //  struct A { // unnamed structs
2783         //    struct { struct A *next; } entry0;
2784         //    struct { struct A *next; } entry1;
2785         //  };
2786         //  struct X { struct { int a; }; struct { int b; }; }; // anon structs
2787         if (!SearchName)
2788           if (!IsStructuralMatch(D, FoundRecord, false))
2789             continue;
2790 
2791         if (!hasSameVisibilityContextAndLinkage(FoundRecord, D))
2792           continue;
2793 
2794         if (IsStructuralMatch(D, FoundRecord)) {
2795           RecordDecl *FoundDef = FoundRecord->getDefinition();
2796           if (D->isThisDeclarationADefinition() && FoundDef) {
2797             // FIXME: Structural equivalence check should check for same
2798             // user-defined methods.
2799             Importer.MapImported(D, FoundDef);
2800             if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2801               auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
2802               assert(FoundCXX && "Record type mismatch");
2803 
2804               if (!Importer.isMinimalImport())
2805                 // FoundDef may not have every implicit method that D has
2806                 // because implicit methods are created only if they are used.
2807                 if (Error Err = ImportImplicitMethods(DCXX, FoundCXX))
2808                   return std::move(Err);
2809             }
2810           }
2811           PrevDecl = FoundRecord->getMostRecentDecl();
2812           break;
2813         }
2814         ConflictingDecls.push_back(FoundDecl);
2815       } // kind is RecordDecl
2816     } // for
2817 
2818     if (!ConflictingDecls.empty() && SearchName) {
2819       ExpectedName NameOrErr = Importer.HandleNameConflict(
2820           SearchName, DC, IDNS, ConflictingDecls.data(),
2821           ConflictingDecls.size());
2822       if (NameOrErr)
2823         Name = NameOrErr.get();
2824       else
2825         return NameOrErr.takeError();
2826     }
2827   }
2828 
2829   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
2830   if (!BeginLocOrErr)
2831     return BeginLocOrErr.takeError();
2832 
2833   // Create the record declaration.
2834   RecordDecl *D2 = nullptr;
2835   CXXRecordDecl *D2CXX = nullptr;
2836   if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
2837     if (DCXX->isLambda()) {
2838       auto TInfoOrErr = import(DCXX->getLambdaTypeInfo());
2839       if (!TInfoOrErr)
2840         return TInfoOrErr.takeError();
2841       if (GetImportedOrCreateSpecialDecl(
2842               D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(),
2843               DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(),
2844               DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault()))
2845         return D2CXX;
2846       ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl());
2847       if (!CDeclOrErr)
2848         return CDeclOrErr.takeError();
2849       D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr,
2850                                DCXX->hasKnownLambdaInternalLinkage());
2851       D2CXX->setDeviceLambdaManglingNumber(
2852           DCXX->getDeviceLambdaManglingNumber());
2853    } else if (DCXX->isInjectedClassName()) {
2854       // We have to be careful to do a similar dance to the one in
2855       // Sema::ActOnStartCXXMemberDeclarations
2856       const bool DelayTypeCreation = true;
2857       if (GetImportedOrCreateDecl(
2858               D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
2859               *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
2860               cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
2861         return D2CXX;
2862       Importer.getToContext().getTypeDeclType(
2863           D2CXX, dyn_cast<CXXRecordDecl>(DC));
2864     } else {
2865       if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
2866                                   D->getTagKind(), DC, *BeginLocOrErr, Loc,
2867                                   Name.getAsIdentifierInfo(),
2868                                   cast_or_null<CXXRecordDecl>(PrevDecl)))
2869         return D2CXX;
2870     }
2871 
2872     D2 = D2CXX;
2873     D2->setAccess(D->getAccess());
2874     D2->setLexicalDeclContext(LexicalDC);
2875     addDeclToContexts(D, D2);
2876 
2877     if (ClassTemplateDecl *FromDescribed =
2878         DCXX->getDescribedClassTemplate()) {
2879       ClassTemplateDecl *ToDescribed;
2880       if (Error Err = importInto(ToDescribed, FromDescribed))
2881         return std::move(Err);
2882       D2CXX->setDescribedClassTemplate(ToDescribed);
2883       if (!DCXX->isInjectedClassName() && !IsFriendTemplate) {
2884         // In a record describing a template the type should be an
2885         // InjectedClassNameType (see Sema::CheckClassTemplate). Update the
2886         // previously set type to the correct value here (ToDescribed is not
2887         // available at record create).
2888         // FIXME: The previous type is cleared but not removed from
2889         // ASTContext's internal storage.
2890         CXXRecordDecl *Injected = nullptr;
2891         for (NamedDecl *Found : D2CXX->noload_lookup(Name)) {
2892           auto *Record = dyn_cast<CXXRecordDecl>(Found);
2893           if (Record && Record->isInjectedClassName()) {
2894             Injected = Record;
2895             break;
2896           }
2897         }
2898         // Create an injected type for the whole redecl chain.
2899         SmallVector<Decl *, 2> Redecls =
2900             getCanonicalForwardRedeclChain(D2CXX);
2901         for (auto *R : Redecls) {
2902           auto *RI = cast<CXXRecordDecl>(R);
2903           RI->setTypeForDecl(nullptr);
2904           // Below we create a new injected type and assign that to the
2905           // canonical decl, subsequent declarations in the chain will reuse
2906           // that type.
2907           Importer.getToContext().getInjectedClassNameType(
2908               RI, ToDescribed->getInjectedClassNameSpecialization());
2909         }
2910         // Set the new type for the previous injected decl too.
2911         if (Injected) {
2912           Injected->setTypeForDecl(nullptr);
2913           Importer.getToContext().getTypeDeclType(Injected, D2CXX);
2914         }
2915       }
2916     } else if (MemberSpecializationInfo *MemberInfo =
2917                    DCXX->getMemberSpecializationInfo()) {
2918         TemplateSpecializationKind SK =
2919             MemberInfo->getTemplateSpecializationKind();
2920         CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
2921 
2922         if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
2923           D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
2924         else
2925           return ToInstOrErr.takeError();
2926 
2927         if (ExpectedSLoc POIOrErr =
2928             import(MemberInfo->getPointOfInstantiation()))
2929           D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
2930             *POIOrErr);
2931         else
2932           return POIOrErr.takeError();
2933     }
2934 
2935   } else {
2936     if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
2937                                 D->getTagKind(), DC, *BeginLocOrErr, Loc,
2938                                 Name.getAsIdentifierInfo(), PrevDecl))
2939       return D2;
2940     D2->setLexicalDeclContext(LexicalDC);
2941     addDeclToContexts(D, D2);
2942   }
2943 
2944   if (auto BraceRangeOrErr = import(D->getBraceRange()))
2945     D2->setBraceRange(*BraceRangeOrErr);
2946   else
2947     return BraceRangeOrErr.takeError();
2948   if (auto QualifierLocOrErr = import(D->getQualifierLoc()))
2949     D2->setQualifierInfo(*QualifierLocOrErr);
2950   else
2951     return QualifierLocOrErr.takeError();
2952 
2953   if (D->isAnonymousStructOrUnion())
2954     D2->setAnonymousStructOrUnion(true);
2955 
2956   if (D->isCompleteDefinition())
2957     if (Error Err = ImportDefinition(D, D2, IDK_Default))
2958       return std::move(Err);
2959 
2960   return D2;
2961 }
2962 
VisitEnumConstantDecl(EnumConstantDecl * D)2963 ExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) {
2964   // Import the major distinguishing characteristics of this enumerator.
2965   DeclContext *DC, *LexicalDC;
2966   DeclarationName Name;
2967   SourceLocation Loc;
2968   NamedDecl *ToD;
2969   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
2970     return std::move(Err);
2971   if (ToD)
2972     return ToD;
2973 
2974   // Determine whether there are any other declarations with the same name and
2975   // in the same context.
2976   if (!LexicalDC->isFunctionOrMethod()) {
2977     SmallVector<NamedDecl *, 4> ConflictingDecls;
2978     unsigned IDNS = Decl::IDNS_Ordinary;
2979     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
2980     for (auto *FoundDecl : FoundDecls) {
2981       if (!FoundDecl->isInIdentifierNamespace(IDNS))
2982         continue;
2983 
2984       if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) {
2985         if (IsStructuralMatch(D, FoundEnumConstant))
2986           return Importer.MapImported(D, FoundEnumConstant);
2987         ConflictingDecls.push_back(FoundDecl);
2988       }
2989     }
2990 
2991     if (!ConflictingDecls.empty()) {
2992       ExpectedName NameOrErr = Importer.HandleNameConflict(
2993           Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
2994       if (NameOrErr)
2995         Name = NameOrErr.get();
2996       else
2997         return NameOrErr.takeError();
2998     }
2999   }
3000 
3001   ExpectedType TypeOrErr = import(D->getType());
3002   if (!TypeOrErr)
3003     return TypeOrErr.takeError();
3004 
3005   ExpectedExpr InitOrErr = import(D->getInitExpr());
3006   if (!InitOrErr)
3007     return InitOrErr.takeError();
3008 
3009   EnumConstantDecl *ToEnumerator;
3010   if (GetImportedOrCreateDecl(
3011           ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc,
3012           Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal()))
3013     return ToEnumerator;
3014 
3015   ToEnumerator->setAccess(D->getAccess());
3016   ToEnumerator->setLexicalDeclContext(LexicalDC);
3017   LexicalDC->addDeclInternal(ToEnumerator);
3018   return ToEnumerator;
3019 }
3020 
ImportTemplateParameterLists(const DeclaratorDecl * FromD,DeclaratorDecl * ToD)3021 Error ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD,
3022                                                     DeclaratorDecl *ToD) {
3023   unsigned int Num = FromD->getNumTemplateParameterLists();
3024   if (Num == 0)
3025     return Error::success();
3026   SmallVector<TemplateParameterList *, 2> ToTPLists(Num);
3027   for (unsigned int I = 0; I < Num; ++I)
3028     if (Expected<TemplateParameterList *> ToTPListOrErr =
3029             import(FromD->getTemplateParameterList(I)))
3030       ToTPLists[I] = *ToTPListOrErr;
3031     else
3032       return ToTPListOrErr.takeError();
3033   ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists);
3034   return Error::success();
3035 }
3036 
ImportTemplateInformation(FunctionDecl * FromFD,FunctionDecl * ToFD)3037 Error ASTNodeImporter::ImportTemplateInformation(
3038     FunctionDecl *FromFD, FunctionDecl *ToFD) {
3039   switch (FromFD->getTemplatedKind()) {
3040   case FunctionDecl::TK_NonTemplate:
3041   case FunctionDecl::TK_FunctionTemplate:
3042     return Error::success();
3043 
3044   case FunctionDecl::TK_MemberSpecialization: {
3045     TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
3046 
3047     if (Expected<FunctionDecl *> InstFDOrErr =
3048         import(FromFD->getInstantiatedFromMemberFunction()))
3049       ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
3050     else
3051       return InstFDOrErr.takeError();
3052 
3053     if (ExpectedSLoc POIOrErr = import(
3054         FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
3055       ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
3056     else
3057       return POIOrErr.takeError();
3058 
3059     return Error::success();
3060   }
3061 
3062   case FunctionDecl::TK_FunctionTemplateSpecialization: {
3063     auto FunctionAndArgsOrErr =
3064         ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3065     if (!FunctionAndArgsOrErr)
3066       return FunctionAndArgsOrErr.takeError();
3067 
3068     TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
3069           Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
3070 
3071     auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
3072     TemplateArgumentListInfo ToTAInfo;
3073     const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
3074     if (FromTAArgsAsWritten)
3075       if (Error Err = ImportTemplateArgumentListInfo(
3076           *FromTAArgsAsWritten, ToTAInfo))
3077         return Err;
3078 
3079     ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
3080     if (!POIOrErr)
3081       return POIOrErr.takeError();
3082 
3083     if (Error Err = ImportTemplateParameterLists(FromFD, ToFD))
3084       return Err;
3085 
3086     TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind();
3087     ToFD->setFunctionTemplateSpecialization(
3088         std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr,
3089         TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr);
3090     return Error::success();
3091   }
3092 
3093   case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
3094     auto *FromInfo = FromFD->getDependentSpecializationInfo();
3095     UnresolvedSet<8> TemplDecls;
3096     unsigned NumTemplates = FromInfo->getNumTemplates();
3097     for (unsigned I = 0; I < NumTemplates; I++) {
3098       if (Expected<FunctionTemplateDecl *> ToFTDOrErr =
3099           import(FromInfo->getTemplate(I)))
3100         TemplDecls.addDecl(*ToFTDOrErr);
3101       else
3102         return ToFTDOrErr.takeError();
3103     }
3104 
3105     // Import TemplateArgumentListInfo.
3106     TemplateArgumentListInfo ToTAInfo;
3107     if (Error Err = ImportTemplateArgumentListInfo(
3108         FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
3109         llvm::makeArrayRef(
3110             FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()),
3111         ToTAInfo))
3112       return Err;
3113 
3114     ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
3115                                              TemplDecls, ToTAInfo);
3116     return Error::success();
3117   }
3118   }
3119   llvm_unreachable("All cases should be covered!");
3120 }
3121 
3122 Expected<FunctionDecl *>
FindFunctionTemplateSpecialization(FunctionDecl * FromFD)3123 ASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) {
3124   auto FunctionAndArgsOrErr =
3125       ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD);
3126   if (!FunctionAndArgsOrErr)
3127     return FunctionAndArgsOrErr.takeError();
3128 
3129   FunctionTemplateDecl *Template;
3130   TemplateArgsTy ToTemplArgs;
3131   std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr;
3132   void *InsertPos = nullptr;
3133   auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos);
3134   return FoundSpec;
3135 }
3136 
ImportFunctionDeclBody(FunctionDecl * FromFD,FunctionDecl * ToFD)3137 Error ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD,
3138                                               FunctionDecl *ToFD) {
3139   if (Stmt *FromBody = FromFD->getBody()) {
3140     if (ExpectedStmt ToBodyOrErr = import(FromBody))
3141       ToFD->setBody(*ToBodyOrErr);
3142     else
3143       return ToBodyOrErr.takeError();
3144   }
3145   return Error::success();
3146 }
3147 
3148 // Returns true if the given D has a DeclContext up to the TranslationUnitDecl
3149 // which is equal to the given DC.
isAncestorDeclContextOf(const DeclContext * DC,const Decl * D)3150 static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
3151   const DeclContext *DCi = D->getDeclContext();
3152   while (DCi != D->getTranslationUnitDecl()) {
3153     if (DCi == DC)
3154       return true;
3155     DCi = DCi->getParent();
3156   }
3157   return false;
3158 }
3159 
hasAutoReturnTypeDeclaredInside(FunctionDecl * D)3160 bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
3161   QualType FromTy = D->getType();
3162   const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>();
3163   assert(FromFPT && "Must be called on FunctionProtoType");
3164   if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
3165     QualType DeducedT = AutoT->getDeducedType();
3166     if (const RecordType *RecordT =
3167             DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
3168       RecordDecl *RD = RecordT->getDecl();
3169       assert(RD);
3170       if (isAncestorDeclContextOf(D, RD)) {
3171         assert(RD->getLexicalDeclContext() == RD->getDeclContext());
3172         return true;
3173       }
3174     }
3175   }
3176   if (const TypedefType *TypedefT =
3177           dyn_cast<TypedefType>(FromFPT->getReturnType())) {
3178     TypedefNameDecl *TD = TypedefT->getDecl();
3179     assert(TD);
3180     if (isAncestorDeclContextOf(D, TD)) {
3181       assert(TD->getLexicalDeclContext() == TD->getDeclContext());
3182       return true;
3183     }
3184   }
3185   return false;
3186 }
3187 
3188 ExplicitSpecifier
importExplicitSpecifier(Error & Err,ExplicitSpecifier ESpec)3189 ASTNodeImporter::importExplicitSpecifier(Error &Err, ExplicitSpecifier ESpec) {
3190   Expr *ExplicitExpr = ESpec.getExpr();
3191   if (ExplicitExpr)
3192     ExplicitExpr = importChecked(Err, ESpec.getExpr());
3193   return ExplicitSpecifier(ExplicitExpr, ESpec.getKind());
3194 }
3195 
VisitFunctionDecl(FunctionDecl * D)3196 ExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
3197 
3198   SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
3199   auto RedeclIt = Redecls.begin();
3200   // Import the first part of the decl chain. I.e. import all previous
3201   // declarations starting from the canonical decl.
3202   for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3203     ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3204     if (!ToRedeclOrErr)
3205       return ToRedeclOrErr.takeError();
3206   }
3207   assert(*RedeclIt == D);
3208 
3209   // Import the major distinguishing characteristics of this function.
3210   DeclContext *DC, *LexicalDC;
3211   DeclarationName Name;
3212   SourceLocation Loc;
3213   NamedDecl *ToD;
3214   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3215     return std::move(Err);
3216   if (ToD)
3217     return ToD;
3218 
3219   FunctionDecl *FoundByLookup = nullptr;
3220   FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate();
3221 
3222   // If this is a function template specialization, then try to find the same
3223   // existing specialization in the "to" context. The lookup below will not
3224   // find any specialization, but would find the primary template; thus, we
3225   // have to skip normal lookup in case of specializations.
3226   // FIXME handle member function templates (TK_MemberSpecialization) similarly?
3227   if (D->getTemplatedKind() ==
3228       FunctionDecl::TK_FunctionTemplateSpecialization) {
3229     auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D);
3230     if (!FoundFunctionOrErr)
3231       return FoundFunctionOrErr.takeError();
3232     if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) {
3233       if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3234         return Def;
3235       FoundByLookup = FoundFunction;
3236     }
3237   }
3238   // Try to find a function in our own ("to") context with the same name, same
3239   // type, and in the same context as the function we're importing.
3240   else if (!LexicalDC->isFunctionOrMethod()) {
3241     SmallVector<NamedDecl *, 4> ConflictingDecls;
3242     unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
3243     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3244     for (auto *FoundDecl : FoundDecls) {
3245       if (!FoundDecl->isInIdentifierNamespace(IDNS))
3246         continue;
3247 
3248       if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) {
3249         if (!hasSameVisibilityContextAndLinkage(FoundFunction, D))
3250           continue;
3251 
3252         if (IsStructuralMatch(D, FoundFunction)) {
3253           if (Decl *Def = FindAndMapDefinition(D, FoundFunction))
3254             return Def;
3255           FoundByLookup = FoundFunction;
3256           break;
3257         }
3258         // FIXME: Check for overloading more carefully, e.g., by boosting
3259         // Sema::IsOverload out to the AST library.
3260 
3261         // Function overloading is okay in C++.
3262         if (Importer.getToContext().getLangOpts().CPlusPlus)
3263           continue;
3264 
3265         // Complain about inconsistent function types.
3266         Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent)
3267             << Name << D->getType() << FoundFunction->getType();
3268         Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here)
3269             << FoundFunction->getType();
3270         ConflictingDecls.push_back(FoundDecl);
3271       }
3272     }
3273 
3274     if (!ConflictingDecls.empty()) {
3275       ExpectedName NameOrErr = Importer.HandleNameConflict(
3276           Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3277       if (NameOrErr)
3278         Name = NameOrErr.get();
3279       else
3280         return NameOrErr.takeError();
3281     }
3282   }
3283 
3284   // We do not allow more than one in-class declaration of a function. This is
3285   // because AST clients like VTableBuilder asserts on this. VTableBuilder
3286   // assumes there is only one in-class declaration. Building a redecl
3287   // chain would result in more than one in-class declaration for
3288   // overrides (even if they are part of the same redecl chain inside the
3289   // derived class.)
3290   if (FoundByLookup) {
3291     if (isa<CXXMethodDecl>(FoundByLookup)) {
3292       if (D->getLexicalDeclContext() == D->getDeclContext()) {
3293         if (!D->doesThisDeclarationHaveABody()) {
3294           if (FunctionTemplateDecl *DescribedD =
3295                   D->getDescribedFunctionTemplate()) {
3296             // Handle a "templated" function together with its described
3297             // template. This avoids need for a similar check at import of the
3298             // described template.
3299             assert(FoundByLookup->getDescribedFunctionTemplate() &&
3300                    "Templated function mapped to non-templated?");
3301             Importer.MapImported(DescribedD,
3302                                  FoundByLookup->getDescribedFunctionTemplate());
3303           }
3304           return Importer.MapImported(D, FoundByLookup);
3305         } else {
3306           // Let's continue and build up the redecl chain in this case.
3307           // FIXME Merge the functions into one decl.
3308         }
3309       }
3310     }
3311   }
3312 
3313   DeclarationNameInfo NameInfo(Name, Loc);
3314   // Import additional name location/type info.
3315   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
3316     return std::move(Err);
3317 
3318   QualType FromTy = D->getType();
3319   // Set to true if we do not import the type of the function as is. There are
3320   // cases when the original type would result in an infinite recursion during
3321   // the import. To avoid an infinite recursion when importing, we create the
3322   // FunctionDecl with a simplified function type and update it only after the
3323   // relevant AST nodes are already imported.
3324   bool UsedDifferentProtoType = false;
3325   if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
3326     QualType FromReturnTy = FromFPT->getReturnType();
3327     // Functions with auto return type may define a struct inside their body
3328     // and the return type could refer to that struct.
3329     // E.g.: auto foo() { struct X{}; return X(); }
3330     // To avoid an infinite recursion when importing, create the FunctionDecl
3331     // with a simplified return type.
3332     if (hasAutoReturnTypeDeclaredInside(D)) {
3333       FromReturnTy = Importer.getFromContext().VoidTy;
3334       UsedDifferentProtoType = true;
3335     }
3336     FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo();
3337     // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the
3338     // FunctionDecl that we are importing the FunctionProtoType for.
3339     // To avoid an infinite recursion when importing, create the FunctionDecl
3340     // with a simplified function type.
3341     if (FromEPI.ExceptionSpec.SourceDecl ||
3342         FromEPI.ExceptionSpec.SourceTemplate ||
3343         FromEPI.ExceptionSpec.NoexceptExpr) {
3344       FunctionProtoType::ExtProtoInfo DefaultEPI;
3345       FromEPI = DefaultEPI;
3346       UsedDifferentProtoType = true;
3347     }
3348     FromTy = Importer.getFromContext().getFunctionType(
3349         FromReturnTy, FromFPT->getParamTypes(), FromEPI);
3350   }
3351 
3352   Error Err = Error::success();
3353   auto T = importChecked(Err, FromTy);
3354   auto TInfo = importChecked(Err, D->getTypeSourceInfo());
3355   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3356   auto ToEndLoc = importChecked(Err, D->getEndLoc());
3357   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
3358   auto TrailingRequiresClause =
3359       importChecked(Err, D->getTrailingRequiresClause());
3360   if (Err)
3361     return std::move(Err);
3362 
3363   // Import the function parameters.
3364   SmallVector<ParmVarDecl *, 8> Parameters;
3365   for (auto P : D->parameters()) {
3366     if (Expected<ParmVarDecl *> ToPOrErr = import(P))
3367       Parameters.push_back(*ToPOrErr);
3368     else
3369       return ToPOrErr.takeError();
3370   }
3371 
3372   // Create the imported function.
3373   FunctionDecl *ToFunction = nullptr;
3374   if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3375     ExplicitSpecifier ESpec =
3376         importExplicitSpecifier(Err, FromConstructor->getExplicitSpecifier());
3377     if (Err)
3378       return std::move(Err);
3379     if (GetImportedOrCreateDecl<CXXConstructorDecl>(
3380             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3381             ToInnerLocStart, NameInfo, T, TInfo, ESpec, D->isInlineSpecified(),
3382             D->isImplicit(), D->getConstexprKind(),
3383             InheritedConstructor(), // FIXME: Properly import inherited
3384                                     // constructor info
3385             TrailingRequiresClause))
3386       return ToFunction;
3387   } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {
3388 
3389     Error Err = Error::success();
3390     auto ToOperatorDelete = importChecked(
3391         Err, const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()));
3392     auto ToThisArg = importChecked(Err, FromDtor->getOperatorDeleteThisArg());
3393     if (Err)
3394       return std::move(Err);
3395 
3396     if (GetImportedOrCreateDecl<CXXDestructorDecl>(
3397         ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3398         ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
3399         D->isImplicit(), D->getConstexprKind(), TrailingRequiresClause))
3400       return ToFunction;
3401 
3402     CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction);
3403 
3404     ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
3405   } else if (CXXConversionDecl *FromConversion =
3406                  dyn_cast<CXXConversionDecl>(D)) {
3407     ExplicitSpecifier ESpec =
3408         importExplicitSpecifier(Err, FromConversion->getExplicitSpecifier());
3409     if (Err)
3410       return std::move(Err);
3411     if (GetImportedOrCreateDecl<CXXConversionDecl>(
3412             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3413             ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), ESpec,
3414             D->getConstexprKind(), SourceLocation(), TrailingRequiresClause))
3415       return ToFunction;
3416   } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
3417     if (GetImportedOrCreateDecl<CXXMethodDecl>(
3418             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
3419             ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
3420             Method->isInlineSpecified(), D->getConstexprKind(),
3421             SourceLocation(), TrailingRequiresClause))
3422       return ToFunction;
3423   } else if (auto *Guide = dyn_cast<CXXDeductionGuideDecl>(D)) {
3424     ExplicitSpecifier ESpec =
3425         importExplicitSpecifier(Err, Guide->getExplicitSpecifier());
3426     if (Err)
3427       return std::move(Err);
3428     if (GetImportedOrCreateDecl<CXXDeductionGuideDecl>(
3429             ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, ESpec,
3430             NameInfo, T, TInfo, ToEndLoc))
3431       return ToFunction;
3432     cast<CXXDeductionGuideDecl>(ToFunction)
3433         ->setIsCopyDeductionCandidate(Guide->isCopyDeductionCandidate());
3434   } else {
3435     if (GetImportedOrCreateDecl(
3436             ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart,
3437             NameInfo, T, TInfo, D->getStorageClass(), D->isInlineSpecified(),
3438             D->hasWrittenPrototype(), D->getConstexprKind(),
3439             TrailingRequiresClause))
3440       return ToFunction;
3441   }
3442 
3443   // Connect the redecl chain.
3444   if (FoundByLookup) {
3445     auto *Recent = const_cast<FunctionDecl *>(
3446           FoundByLookup->getMostRecentDecl());
3447     ToFunction->setPreviousDecl(Recent);
3448     // FIXME Probably we should merge exception specifications.  E.g. In the
3449     // "To" context the existing function may have exception specification with
3450     // noexcept-unevaluated, while the newly imported function may have an
3451     // evaluated noexcept.  A call to adjustExceptionSpec() on the imported
3452     // decl and its redeclarations may be required.
3453   }
3454 
3455   ToFunction->setQualifierInfo(ToQualifierLoc);
3456   ToFunction->setAccess(D->getAccess());
3457   ToFunction->setLexicalDeclContext(LexicalDC);
3458   ToFunction->setVirtualAsWritten(D->isVirtualAsWritten());
3459   ToFunction->setTrivial(D->isTrivial());
3460   ToFunction->setPure(D->isPure());
3461   ToFunction->setDefaulted(D->isDefaulted());
3462   ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted());
3463   ToFunction->setDeletedAsWritten(D->isDeletedAsWritten());
3464   ToFunction->setRangeEnd(ToEndLoc);
3465 
3466   // Set the parameters.
3467   for (auto *Param : Parameters) {
3468     Param->setOwningFunction(ToFunction);
3469     ToFunction->addDeclInternal(Param);
3470   }
3471   ToFunction->setParams(Parameters);
3472 
3473   // We need to complete creation of FunctionProtoTypeLoc manually with setting
3474   // params it refers to.
3475   if (TInfo) {
3476     if (auto ProtoLoc =
3477         TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
3478       for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
3479         ProtoLoc.setParam(I, Parameters[I]);
3480     }
3481   }
3482 
3483   // Import the describing template function, if any.
3484   if (FromFT) {
3485     auto ToFTOrErr = import(FromFT);
3486     if (!ToFTOrErr)
3487       return ToFTOrErr.takeError();
3488   }
3489 
3490   // Import Ctor initializers.
3491   if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
3492     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
3493       SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
3494       // Import first, then allocate memory and copy if there was no error.
3495       if (Error Err = ImportContainerChecked(
3496           FromConstructor->inits(), CtorInitializers))
3497         return std::move(Err);
3498       auto **Memory =
3499           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
3500       std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory);
3501       auto *ToCtor = cast<CXXConstructorDecl>(ToFunction);
3502       ToCtor->setCtorInitializers(Memory);
3503       ToCtor->setNumCtorInitializers(NumInitializers);
3504     }
3505   }
3506 
3507   if (D->doesThisDeclarationHaveABody()) {
3508     Error Err = ImportFunctionDeclBody(D, ToFunction);
3509 
3510     if (Err)
3511       return std::move(Err);
3512   }
3513 
3514   // Import and set the original type in case we used another type.
3515   if (UsedDifferentProtoType) {
3516     if (ExpectedType TyOrErr = import(D->getType()))
3517       ToFunction->setType(*TyOrErr);
3518     else
3519       return TyOrErr.takeError();
3520   }
3521 
3522   // FIXME: Other bits to merge?
3523 
3524   // If it is a template, import all related things.
3525   if (Error Err = ImportTemplateInformation(D, ToFunction))
3526     return std::move(Err);
3527 
3528   addDeclToContexts(D, ToFunction);
3529 
3530   if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D))
3531     if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction),
3532                                             FromCXXMethod))
3533       return std::move(Err);
3534 
3535   // Import the rest of the chain. I.e. import all subsequent declarations.
3536   for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
3537     ExpectedDecl ToRedeclOrErr = import(*RedeclIt);
3538     if (!ToRedeclOrErr)
3539       return ToRedeclOrErr.takeError();
3540   }
3541 
3542   return ToFunction;
3543 }
3544 
VisitCXXMethodDecl(CXXMethodDecl * D)3545 ExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) {
3546   return VisitFunctionDecl(D);
3547 }
3548 
VisitCXXConstructorDecl(CXXConstructorDecl * D)3549 ExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
3550   return VisitCXXMethodDecl(D);
3551 }
3552 
VisitCXXDestructorDecl(CXXDestructorDecl * D)3553 ExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
3554   return VisitCXXMethodDecl(D);
3555 }
3556 
VisitCXXConversionDecl(CXXConversionDecl * D)3557 ExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) {
3558   return VisitCXXMethodDecl(D);
3559 }
3560 
3561 ExpectedDecl
VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl * D)3562 ASTNodeImporter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
3563   return VisitFunctionDecl(D);
3564 }
3565 
VisitFieldDecl(FieldDecl * D)3566 ExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) {
3567   // Import the major distinguishing characteristics of a variable.
3568   DeclContext *DC, *LexicalDC;
3569   DeclarationName Name;
3570   SourceLocation Loc;
3571   NamedDecl *ToD;
3572   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3573     return std::move(Err);
3574   if (ToD)
3575     return ToD;
3576 
3577   // Determine whether we've already imported this field.
3578   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3579   for (auto *FoundDecl : FoundDecls) {
3580     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
3581       // For anonymous fields, match up by index.
3582       if (!Name &&
3583           ASTImporter::getFieldIndex(D) !=
3584           ASTImporter::getFieldIndex(FoundField))
3585         continue;
3586 
3587       if (Importer.IsStructurallyEquivalent(D->getType(),
3588                                             FoundField->getType())) {
3589         Importer.MapImported(D, FoundField);
3590         // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the
3591         // initializer of a FieldDecl might not had been instantiated in the
3592         // "To" context.  However, the "From" context might instantiated that,
3593         // thus we have to merge that.
3594         if (Expr *FromInitializer = D->getInClassInitializer()) {
3595           // We don't have yet the initializer set.
3596           if (FoundField->hasInClassInitializer() &&
3597               !FoundField->getInClassInitializer()) {
3598             if (ExpectedExpr ToInitializerOrErr = import(FromInitializer))
3599               FoundField->setInClassInitializer(*ToInitializerOrErr);
3600             else {
3601               // We can't return error here,
3602               // since we already mapped D as imported.
3603               // FIXME: warning message?
3604               consumeError(ToInitializerOrErr.takeError());
3605               return FoundField;
3606             }
3607           }
3608         }
3609         return FoundField;
3610       }
3611 
3612       // FIXME: Why is this case not handled with calling HandleNameConflict?
3613       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3614         << Name << D->getType() << FoundField->getType();
3615       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3616         << FoundField->getType();
3617 
3618       return make_error<ImportError>(ImportError::NameConflict);
3619     }
3620   }
3621 
3622   Error Err = Error::success();
3623   auto ToType = importChecked(Err, D->getType());
3624   auto ToTInfo = importChecked(Err, D->getTypeSourceInfo());
3625   auto ToBitWidth = importChecked(Err, D->getBitWidth());
3626   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3627   auto ToInitializer = importChecked(Err, D->getInClassInitializer());
3628   if (Err)
3629     return std::move(Err);
3630 
3631   FieldDecl *ToField;
3632   if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC,
3633                               ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3634                               ToType, ToTInfo, ToBitWidth, D->isMutable(),
3635                               D->getInClassInitStyle()))
3636     return ToField;
3637 
3638   ToField->setAccess(D->getAccess());
3639   ToField->setLexicalDeclContext(LexicalDC);
3640   if (ToInitializer)
3641     ToField->setInClassInitializer(ToInitializer);
3642   ToField->setImplicit(D->isImplicit());
3643   LexicalDC->addDeclInternal(ToField);
3644   return ToField;
3645 }
3646 
VisitIndirectFieldDecl(IndirectFieldDecl * D)3647 ExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
3648   // Import the major distinguishing characteristics of a variable.
3649   DeclContext *DC, *LexicalDC;
3650   DeclarationName Name;
3651   SourceLocation Loc;
3652   NamedDecl *ToD;
3653   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3654     return std::move(Err);
3655   if (ToD)
3656     return ToD;
3657 
3658   // Determine whether we've already imported this field.
3659   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3660   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
3661     if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
3662       // For anonymous indirect fields, match up by index.
3663       if (!Name &&
3664           ASTImporter::getFieldIndex(D) !=
3665           ASTImporter::getFieldIndex(FoundField))
3666         continue;
3667 
3668       if (Importer.IsStructurallyEquivalent(D->getType(),
3669                                             FoundField->getType(),
3670                                             !Name.isEmpty())) {
3671         Importer.MapImported(D, FoundField);
3672         return FoundField;
3673       }
3674 
3675       // If there are more anonymous fields to check, continue.
3676       if (!Name && I < N-1)
3677         continue;
3678 
3679       // FIXME: Why is this case not handled with calling HandleNameConflict?
3680       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
3681         << Name << D->getType() << FoundField->getType();
3682       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
3683         << FoundField->getType();
3684 
3685       return make_error<ImportError>(ImportError::NameConflict);
3686     }
3687   }
3688 
3689   // Import the type.
3690   auto TypeOrErr = import(D->getType());
3691   if (!TypeOrErr)
3692     return TypeOrErr.takeError();
3693 
3694   auto **NamedChain =
3695     new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
3696 
3697   unsigned i = 0;
3698   for (auto *PI : D->chain())
3699     if (Expected<NamedDecl *> ToD = import(PI))
3700       NamedChain[i++] = *ToD;
3701     else
3702       return ToD.takeError();
3703 
3704   llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()};
3705   IndirectFieldDecl *ToIndirectField;
3706   if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC,
3707                               Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH))
3708     // FIXME here we leak `NamedChain` which is allocated before
3709     return ToIndirectField;
3710 
3711   ToIndirectField->setAccess(D->getAccess());
3712   ToIndirectField->setLexicalDeclContext(LexicalDC);
3713   LexicalDC->addDeclInternal(ToIndirectField);
3714   return ToIndirectField;
3715 }
3716 
3717 /// Used as return type of getFriendCountAndPosition.
3718 struct FriendCountAndPosition {
3719   /// Number of similar looking friends.
3720   unsigned int TotalCount;
3721   /// Index of the specific FriendDecl.
3722   unsigned int IndexOfDecl;
3723 };
3724 
3725 template <class T>
getFriendCountAndPosition(const FriendDecl * FD,llvm::function_ref<T (const FriendDecl *)> GetCanTypeOrDecl)3726 static FriendCountAndPosition getFriendCountAndPosition(
3727     const FriendDecl *FD,
3728     llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
3729   unsigned int FriendCount = 0;
3730   llvm::Optional<unsigned int> FriendPosition;
3731   const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
3732 
3733   T TypeOrDecl = GetCanTypeOrDecl(FD);
3734 
3735   for (const FriendDecl *FoundFriend : RD->friends()) {
3736     if (FoundFriend == FD) {
3737       FriendPosition = FriendCount;
3738       ++FriendCount;
3739     } else if (!FoundFriend->getFriendDecl() == !FD->getFriendDecl() &&
3740                GetCanTypeOrDecl(FoundFriend) == TypeOrDecl) {
3741       ++FriendCount;
3742     }
3743   }
3744 
3745   assert(FriendPosition && "Friend decl not found in own parent.");
3746 
3747   return {FriendCount, *FriendPosition};
3748 }
3749 
getFriendCountAndPosition(const FriendDecl * FD)3750 static FriendCountAndPosition getFriendCountAndPosition(const FriendDecl *FD) {
3751   if (FD->getFriendType())
3752     return getFriendCountAndPosition<QualType>(FD, [](const FriendDecl *F) {
3753       if (TypeSourceInfo *TSI = F->getFriendType())
3754         return TSI->getType().getCanonicalType();
3755       llvm_unreachable("Wrong friend object type.");
3756     });
3757   else
3758     return getFriendCountAndPosition<Decl *>(FD, [](const FriendDecl *F) {
3759       if (Decl *D = F->getFriendDecl())
3760         return D->getCanonicalDecl();
3761       llvm_unreachable("Wrong friend object type.");
3762     });
3763 }
3764 
VisitFriendDecl(FriendDecl * D)3765 ExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) {
3766   // Import the major distinguishing characteristics of a declaration.
3767   DeclContext *DC, *LexicalDC;
3768   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
3769     return std::move(Err);
3770 
3771   // Determine whether we've already imported this decl.
3772   // FriendDecl is not a NamedDecl so we cannot use lookup.
3773   // We try to maintain order and count of redundant friend declarations.
3774   const auto *RD = cast<CXXRecordDecl>(DC);
3775   FriendDecl *ImportedFriend = RD->getFirstFriend();
3776   SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
3777 
3778   while (ImportedFriend) {
3779     bool Match = false;
3780     if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) {
3781       Match =
3782           IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(),
3783                             /*Complain=*/false);
3784     } else if (D->getFriendType() && ImportedFriend->getFriendType()) {
3785       Match = Importer.IsStructurallyEquivalent(
3786           D->getFriendType()->getType(),
3787           ImportedFriend->getFriendType()->getType(), /*Complain=*/false);
3788     }
3789     if (Match)
3790       ImportedEquivalentFriends.push_back(ImportedFriend);
3791 
3792     ImportedFriend = ImportedFriend->getNextFriend();
3793   }
3794   FriendCountAndPosition CountAndPosition = getFriendCountAndPosition(D);
3795 
3796   assert(ImportedEquivalentFriends.size() <= CountAndPosition.TotalCount &&
3797          "Class with non-matching friends is imported, ODR check wrong?");
3798   if (ImportedEquivalentFriends.size() == CountAndPosition.TotalCount)
3799     return Importer.MapImported(
3800         D, ImportedEquivalentFriends[CountAndPosition.IndexOfDecl]);
3801 
3802   // Not found. Create it.
3803   // The declarations will be put into order later by ImportDeclContext.
3804   FriendDecl::FriendUnion ToFU;
3805   if (NamedDecl *FriendD = D->getFriendDecl()) {
3806     NamedDecl *ToFriendD;
3807     if (Error Err = importInto(ToFriendD, FriendD))
3808       return std::move(Err);
3809 
3810     if (FriendD->getFriendObjectKind() != Decl::FOK_None &&
3811         !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator)))
3812       ToFriendD->setObjectOfFriendDecl(false);
3813 
3814     ToFU = ToFriendD;
3815   } else { // The friend is a type, not a decl.
3816     if (auto TSIOrErr = import(D->getFriendType()))
3817       ToFU = *TSIOrErr;
3818     else
3819       return TSIOrErr.takeError();
3820   }
3821 
3822   SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists);
3823   auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>();
3824   for (unsigned I = 0; I < D->NumTPLists; I++) {
3825     if (auto ListOrErr = import(FromTPLists[I]))
3826       ToTPLists[I] = *ListOrErr;
3827     else
3828       return ListOrErr.takeError();
3829   }
3830 
3831   auto LocationOrErr = import(D->getLocation());
3832   if (!LocationOrErr)
3833     return LocationOrErr.takeError();
3834   auto FriendLocOrErr = import(D->getFriendLoc());
3835   if (!FriendLocOrErr)
3836     return FriendLocOrErr.takeError();
3837 
3838   FriendDecl *FrD;
3839   if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
3840                               *LocationOrErr, ToFU,
3841                               *FriendLocOrErr, ToTPLists))
3842     return FrD;
3843 
3844   FrD->setAccess(D->getAccess());
3845   FrD->setLexicalDeclContext(LexicalDC);
3846   LexicalDC->addDeclInternal(FrD);
3847   return FrD;
3848 }
3849 
VisitObjCIvarDecl(ObjCIvarDecl * D)3850 ExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) {
3851   // Import the major distinguishing characteristics of an ivar.
3852   DeclContext *DC, *LexicalDC;
3853   DeclarationName Name;
3854   SourceLocation Loc;
3855   NamedDecl *ToD;
3856   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3857     return std::move(Err);
3858   if (ToD)
3859     return ToD;
3860 
3861   // Determine whether we've already imported this ivar
3862   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3863   for (auto *FoundDecl : FoundDecls) {
3864     if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) {
3865       if (Importer.IsStructurallyEquivalent(D->getType(),
3866                                             FoundIvar->getType())) {
3867         Importer.MapImported(D, FoundIvar);
3868         return FoundIvar;
3869       }
3870 
3871       Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
3872         << Name << D->getType() << FoundIvar->getType();
3873       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
3874         << FoundIvar->getType();
3875 
3876       return make_error<ImportError>(ImportError::NameConflict);
3877     }
3878   }
3879 
3880   Error Err = Error::success();
3881   auto ToType = importChecked(Err, D->getType());
3882   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
3883   auto ToBitWidth = importChecked(Err, D->getBitWidth());
3884   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
3885   if (Err)
3886     return std::move(Err);
3887 
3888   ObjCIvarDecl *ToIvar;
3889   if (GetImportedOrCreateDecl(
3890           ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
3891           ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
3892           ToType, ToTypeSourceInfo,
3893           D->getAccessControl(),ToBitWidth, D->getSynthesize()))
3894     return ToIvar;
3895 
3896   ToIvar->setLexicalDeclContext(LexicalDC);
3897   LexicalDC->addDeclInternal(ToIvar);
3898   return ToIvar;
3899 }
3900 
VisitVarDecl(VarDecl * D)3901 ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
3902 
3903   SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
3904   auto RedeclIt = Redecls.begin();
3905   // Import the first part of the decl chain. I.e. import all previous
3906   // declarations starting from the canonical decl.
3907   for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) {
3908     ExpectedDecl RedeclOrErr = import(*RedeclIt);
3909     if (!RedeclOrErr)
3910       return RedeclOrErr.takeError();
3911   }
3912   assert(*RedeclIt == D);
3913 
3914   // Import the major distinguishing characteristics of a variable.
3915   DeclContext *DC, *LexicalDC;
3916   DeclarationName Name;
3917   SourceLocation Loc;
3918   NamedDecl *ToD;
3919   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
3920     return std::move(Err);
3921   if (ToD)
3922     return ToD;
3923 
3924   // Try to find a variable in our own ("to") context with the same name and
3925   // in the same context as the variable we're importing.
3926   VarDecl *FoundByLookup = nullptr;
3927   if (D->isFileVarDecl()) {
3928     SmallVector<NamedDecl *, 4> ConflictingDecls;
3929     unsigned IDNS = Decl::IDNS_Ordinary;
3930     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
3931     for (auto *FoundDecl : FoundDecls) {
3932       if (!FoundDecl->isInIdentifierNamespace(IDNS))
3933         continue;
3934 
3935       if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) {
3936         if (!hasSameVisibilityContextAndLinkage(FoundVar, D))
3937           continue;
3938         if (Importer.IsStructurallyEquivalent(D->getType(),
3939                                               FoundVar->getType())) {
3940 
3941           // The VarDecl in the "From" context has a definition, but in the
3942           // "To" context we already have a definition.
3943           VarDecl *FoundDef = FoundVar->getDefinition();
3944           if (D->isThisDeclarationADefinition() && FoundDef)
3945             // FIXME Check for ODR error if the two definitions have
3946             // different initializers?
3947             return Importer.MapImported(D, FoundDef);
3948 
3949           // The VarDecl in the "From" context has an initializer, but in the
3950           // "To" context we already have an initializer.
3951           const VarDecl *FoundDInit = nullptr;
3952           if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
3953             // FIXME Diagnose ODR error if the two initializers are different?
3954             return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit));
3955 
3956           FoundByLookup = FoundVar;
3957           break;
3958         }
3959 
3960         const ArrayType *FoundArray
3961           = Importer.getToContext().getAsArrayType(FoundVar->getType());
3962         const ArrayType *TArray
3963           = Importer.getToContext().getAsArrayType(D->getType());
3964         if (FoundArray && TArray) {
3965           if (isa<IncompleteArrayType>(FoundArray) &&
3966               isa<ConstantArrayType>(TArray)) {
3967             // Import the type.
3968             if (auto TyOrErr = import(D->getType()))
3969               FoundVar->setType(*TyOrErr);
3970             else
3971               return TyOrErr.takeError();
3972 
3973             FoundByLookup = FoundVar;
3974             break;
3975           } else if (isa<IncompleteArrayType>(TArray) &&
3976                      isa<ConstantArrayType>(FoundArray)) {
3977             FoundByLookup = FoundVar;
3978             break;
3979           }
3980         }
3981 
3982         Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
3983           << Name << D->getType() << FoundVar->getType();
3984         Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
3985           << FoundVar->getType();
3986         ConflictingDecls.push_back(FoundDecl);
3987       }
3988     }
3989 
3990     if (!ConflictingDecls.empty()) {
3991       ExpectedName NameOrErr = Importer.HandleNameConflict(
3992           Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size());
3993       if (NameOrErr)
3994         Name = NameOrErr.get();
3995       else
3996         return NameOrErr.takeError();
3997     }
3998   }
3999 
4000   Error Err = Error::success();
4001   auto ToType = importChecked(Err, D->getType());
4002   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4003   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4004   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4005   if (Err)
4006     return std::move(Err);
4007 
4008   // Create the imported variable.
4009   VarDecl *ToVar;
4010   if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC,
4011                               ToInnerLocStart, Loc,
4012                               Name.getAsIdentifierInfo(),
4013                               ToType, ToTypeSourceInfo,
4014                               D->getStorageClass()))
4015     return ToVar;
4016 
4017   ToVar->setQualifierInfo(ToQualifierLoc);
4018   ToVar->setAccess(D->getAccess());
4019   ToVar->setLexicalDeclContext(LexicalDC);
4020 
4021   if (FoundByLookup) {
4022     auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl());
4023     ToVar->setPreviousDecl(Recent);
4024   }
4025 
4026   // Import the described template, if any.
4027   if (D->getDescribedVarTemplate()) {
4028     auto ToVTOrErr = import(D->getDescribedVarTemplate());
4029     if (!ToVTOrErr)
4030       return ToVTOrErr.takeError();
4031   }
4032 
4033   if (Error Err = ImportInitializer(D, ToVar))
4034     return std::move(Err);
4035 
4036   if (D->isConstexpr())
4037     ToVar->setConstexpr(true);
4038 
4039   addDeclToContexts(D, ToVar);
4040 
4041   // Import the rest of the chain. I.e. import all subsequent declarations.
4042   for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) {
4043     ExpectedDecl RedeclOrErr = import(*RedeclIt);
4044     if (!RedeclOrErr)
4045       return RedeclOrErr.takeError();
4046   }
4047 
4048   return ToVar;
4049 }
4050 
VisitImplicitParamDecl(ImplicitParamDecl * D)4051 ExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) {
4052   // Parameters are created in the translation unit's context, then moved
4053   // into the function declaration's context afterward.
4054   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4055 
4056   Error Err = Error::success();
4057   auto ToDeclName = importChecked(Err, D->getDeclName());
4058   auto ToLocation = importChecked(Err, D->getLocation());
4059   auto ToType = importChecked(Err, D->getType());
4060   if (Err)
4061     return std::move(Err);
4062 
4063   // Create the imported parameter.
4064   ImplicitParamDecl *ToParm = nullptr;
4065   if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4066                               ToLocation, ToDeclName.getAsIdentifierInfo(),
4067                               ToType, D->getParameterKind()))
4068     return ToParm;
4069   return ToParm;
4070 }
4071 
ImportDefaultArgOfParmVarDecl(const ParmVarDecl * FromParam,ParmVarDecl * ToParam)4072 Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
4073     const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
4074   ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
4075   ToParam->setKNRPromoted(FromParam->isKNRPromoted());
4076 
4077   if (FromParam->hasUninstantiatedDefaultArg()) {
4078     if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg()))
4079       ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr);
4080     else
4081       return ToDefArgOrErr.takeError();
4082   } else if (FromParam->hasUnparsedDefaultArg()) {
4083     ToParam->setUnparsedDefaultArg();
4084   } else if (FromParam->hasDefaultArg()) {
4085     if (auto ToDefArgOrErr = import(FromParam->getDefaultArg()))
4086       ToParam->setDefaultArg(*ToDefArgOrErr);
4087     else
4088       return ToDefArgOrErr.takeError();
4089   }
4090 
4091   return Error::success();
4092 }
4093 
VisitParmVarDecl(ParmVarDecl * D)4094 ExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
4095   // Parameters are created in the translation unit's context, then moved
4096   // into the function declaration's context afterward.
4097   DeclContext *DC = Importer.getToContext().getTranslationUnitDecl();
4098 
4099   Error Err = Error::success();
4100   auto ToDeclName = importChecked(Err, D->getDeclName());
4101   auto ToLocation = importChecked(Err, D->getLocation());
4102   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
4103   auto ToType = importChecked(Err, D->getType());
4104   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4105   if (Err)
4106     return std::move(Err);
4107 
4108   ParmVarDecl *ToParm;
4109   if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC,
4110                               ToInnerLocStart, ToLocation,
4111                               ToDeclName.getAsIdentifierInfo(), ToType,
4112                               ToTypeSourceInfo, D->getStorageClass(),
4113                               /*DefaultArg*/ nullptr))
4114     return ToParm;
4115 
4116   // Set the default argument. It should be no problem if it was already done.
4117   // Do not import the default expression before GetImportedOrCreateDecl call
4118   // to avoid possible infinite import loop because circular dependency.
4119   if (Error Err = ImportDefaultArgOfParmVarDecl(D, ToParm))
4120     return std::move(Err);
4121 
4122   if (D->isObjCMethodParameter()) {
4123     ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex());
4124     ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier());
4125   } else {
4126     ToParm->setScopeInfo(D->getFunctionScopeDepth(),
4127                          D->getFunctionScopeIndex());
4128   }
4129 
4130   return ToParm;
4131 }
4132 
VisitObjCMethodDecl(ObjCMethodDecl * D)4133 ExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
4134   // Import the major distinguishing characteristics of a method.
4135   DeclContext *DC, *LexicalDC;
4136   DeclarationName Name;
4137   SourceLocation Loc;
4138   NamedDecl *ToD;
4139   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4140     return std::move(Err);
4141   if (ToD)
4142     return ToD;
4143 
4144   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4145   for (auto *FoundDecl : FoundDecls) {
4146     if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) {
4147       if (FoundMethod->isInstanceMethod() != D->isInstanceMethod())
4148         continue;
4149 
4150       // Check return types.
4151       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
4152                                              FoundMethod->getReturnType())) {
4153         Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
4154             << D->isInstanceMethod() << Name << D->getReturnType()
4155             << FoundMethod->getReturnType();
4156         Importer.ToDiag(FoundMethod->getLocation(),
4157                         diag::note_odr_objc_method_here)
4158           << D->isInstanceMethod() << Name;
4159 
4160         return make_error<ImportError>(ImportError::NameConflict);
4161       }
4162 
4163       // Check the number of parameters.
4164       if (D->param_size() != FoundMethod->param_size()) {
4165         Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
4166           << D->isInstanceMethod() << Name
4167           << D->param_size() << FoundMethod->param_size();
4168         Importer.ToDiag(FoundMethod->getLocation(),
4169                         diag::note_odr_objc_method_here)
4170           << D->isInstanceMethod() << Name;
4171 
4172         return make_error<ImportError>(ImportError::NameConflict);
4173       }
4174 
4175       // Check parameter types.
4176       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
4177              PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
4178            P != PEnd; ++P, ++FoundP) {
4179         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
4180                                                (*FoundP)->getType())) {
4181           Importer.FromDiag((*P)->getLocation(),
4182                             diag::warn_odr_objc_method_param_type_inconsistent)
4183             << D->isInstanceMethod() << Name
4184             << (*P)->getType() << (*FoundP)->getType();
4185           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
4186             << (*FoundP)->getType();
4187 
4188           return make_error<ImportError>(ImportError::NameConflict);
4189         }
4190       }
4191 
4192       // Check variadic/non-variadic.
4193       // Check the number of parameters.
4194       if (D->isVariadic() != FoundMethod->isVariadic()) {
4195         Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
4196           << D->isInstanceMethod() << Name;
4197         Importer.ToDiag(FoundMethod->getLocation(),
4198                         diag::note_odr_objc_method_here)
4199           << D->isInstanceMethod() << Name;
4200 
4201         return make_error<ImportError>(ImportError::NameConflict);
4202       }
4203 
4204       // FIXME: Any other bits we need to merge?
4205       return Importer.MapImported(D, FoundMethod);
4206     }
4207   }
4208 
4209   Error Err = Error::success();
4210   auto ToEndLoc = importChecked(Err, D->getEndLoc());
4211   auto ToReturnType = importChecked(Err, D->getReturnType());
4212   auto ToReturnTypeSourceInfo =
4213       importChecked(Err, D->getReturnTypeSourceInfo());
4214   if (Err)
4215     return std::move(Err);
4216 
4217   ObjCMethodDecl *ToMethod;
4218   if (GetImportedOrCreateDecl(
4219           ToMethod, D, Importer.getToContext(), Loc, ToEndLoc,
4220           Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC,
4221           D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(),
4222           D->isSynthesizedAccessorStub(), D->isImplicit(), D->isDefined(),
4223           D->getImplementationControl(), D->hasRelatedResultType()))
4224     return ToMethod;
4225 
4226   // FIXME: When we decide to merge method definitions, we'll need to
4227   // deal with implicit parameters.
4228 
4229   // Import the parameters
4230   SmallVector<ParmVarDecl *, 5> ToParams;
4231   for (auto *FromP : D->parameters()) {
4232     if (Expected<ParmVarDecl *> ToPOrErr = import(FromP))
4233       ToParams.push_back(*ToPOrErr);
4234     else
4235       return ToPOrErr.takeError();
4236   }
4237 
4238   // Set the parameters.
4239   for (auto *ToParam : ToParams) {
4240     ToParam->setOwningFunction(ToMethod);
4241     ToMethod->addDeclInternal(ToParam);
4242   }
4243 
4244   SmallVector<SourceLocation, 12> FromSelLocs;
4245   D->getSelectorLocs(FromSelLocs);
4246   SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size());
4247   if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs))
4248     return std::move(Err);
4249 
4250   ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs);
4251 
4252   ToMethod->setLexicalDeclContext(LexicalDC);
4253   LexicalDC->addDeclInternal(ToMethod);
4254 
4255   // Implicit params are declared when Sema encounters the definition but this
4256   // never happens when the method is imported. Manually declare the implicit
4257   // params now that the MethodDecl knows its class interface.
4258   if (D->getSelfDecl())
4259     ToMethod->createImplicitParams(Importer.getToContext(),
4260                                    ToMethod->getClassInterface());
4261 
4262   return ToMethod;
4263 }
4264 
VisitObjCTypeParamDecl(ObjCTypeParamDecl * D)4265 ExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
4266   // Import the major distinguishing characteristics of a category.
4267   DeclContext *DC, *LexicalDC;
4268   DeclarationName Name;
4269   SourceLocation Loc;
4270   NamedDecl *ToD;
4271   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4272     return std::move(Err);
4273   if (ToD)
4274     return ToD;
4275 
4276   Error Err = Error::success();
4277   auto ToVarianceLoc = importChecked(Err, D->getVarianceLoc());
4278   auto ToLocation = importChecked(Err, D->getLocation());
4279   auto ToColonLoc = importChecked(Err, D->getColonLoc());
4280   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
4281   if (Err)
4282     return std::move(Err);
4283 
4284   ObjCTypeParamDecl *Result;
4285   if (GetImportedOrCreateDecl(
4286           Result, D, Importer.getToContext(), DC, D->getVariance(),
4287           ToVarianceLoc, D->getIndex(),
4288           ToLocation, Name.getAsIdentifierInfo(),
4289           ToColonLoc, ToTypeSourceInfo))
4290     return Result;
4291 
4292   Result->setLexicalDeclContext(LexicalDC);
4293   return Result;
4294 }
4295 
VisitObjCCategoryDecl(ObjCCategoryDecl * D)4296 ExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
4297   // Import the major distinguishing characteristics of a category.
4298   DeclContext *DC, *LexicalDC;
4299   DeclarationName Name;
4300   SourceLocation Loc;
4301   NamedDecl *ToD;
4302   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4303     return std::move(Err);
4304   if (ToD)
4305     return ToD;
4306 
4307   ObjCInterfaceDecl *ToInterface;
4308   if (Error Err = importInto(ToInterface, D->getClassInterface()))
4309     return std::move(Err);
4310 
4311   // Determine if we've already encountered this category.
4312   ObjCCategoryDecl *MergeWithCategory
4313     = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
4314   ObjCCategoryDecl *ToCategory = MergeWithCategory;
4315   if (!ToCategory) {
4316 
4317     Error Err = Error::success();
4318     auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4319     auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4320     auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
4321     auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
4322     if (Err)
4323       return std::move(Err);
4324 
4325     if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
4326                                 ToAtStartLoc, Loc,
4327                                 ToCategoryNameLoc,
4328                                 Name.getAsIdentifierInfo(), ToInterface,
4329                                 /*TypeParamList=*/nullptr,
4330                                 ToIvarLBraceLoc,
4331                                 ToIvarRBraceLoc))
4332       return ToCategory;
4333 
4334     ToCategory->setLexicalDeclContext(LexicalDC);
4335     LexicalDC->addDeclInternal(ToCategory);
4336     // Import the type parameter list after MapImported, to avoid
4337     // loops when bringing in their DeclContext.
4338     if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList()))
4339       ToCategory->setTypeParamList(*PListOrErr);
4340     else
4341       return PListOrErr.takeError();
4342 
4343     // Import protocols
4344     SmallVector<ObjCProtocolDecl *, 4> Protocols;
4345     SmallVector<SourceLocation, 4> ProtocolLocs;
4346     ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
4347       = D->protocol_loc_begin();
4348     for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
4349                                           FromProtoEnd = D->protocol_end();
4350          FromProto != FromProtoEnd;
4351          ++FromProto, ++FromProtoLoc) {
4352       if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4353         Protocols.push_back(*ToProtoOrErr);
4354       else
4355         return ToProtoOrErr.takeError();
4356 
4357       if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4358         ProtocolLocs.push_back(*ToProtoLocOrErr);
4359       else
4360         return ToProtoLocOrErr.takeError();
4361     }
4362 
4363     // FIXME: If we're merging, make sure that the protocol list is the same.
4364     ToCategory->setProtocolList(Protocols.data(), Protocols.size(),
4365                                 ProtocolLocs.data(), Importer.getToContext());
4366 
4367   } else {
4368     Importer.MapImported(D, ToCategory);
4369   }
4370 
4371   // Import all of the members of this category.
4372   if (Error Err = ImportDeclContext(D))
4373     return std::move(Err);
4374 
4375   // If we have an implementation, import it as well.
4376   if (D->getImplementation()) {
4377     if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
4378         import(D->getImplementation()))
4379       ToCategory->setImplementation(*ToImplOrErr);
4380     else
4381       return ToImplOrErr.takeError();
4382   }
4383 
4384   return ToCategory;
4385 }
4386 
ImportDefinition(ObjCProtocolDecl * From,ObjCProtocolDecl * To,ImportDefinitionKind Kind)4387 Error ASTNodeImporter::ImportDefinition(
4388     ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
4389   if (To->getDefinition()) {
4390     if (shouldForceImportDeclContext(Kind))
4391       if (Error Err = ImportDeclContext(From))
4392         return Err;
4393     return Error::success();
4394   }
4395 
4396   // Start the protocol definition
4397   To->startDefinition();
4398 
4399   // Import protocols
4400   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4401   SmallVector<SourceLocation, 4> ProtocolLocs;
4402   ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
4403       From->protocol_loc_begin();
4404   for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
4405                                         FromProtoEnd = From->protocol_end();
4406        FromProto != FromProtoEnd;
4407        ++FromProto, ++FromProtoLoc) {
4408     if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4409       Protocols.push_back(*ToProtoOrErr);
4410     else
4411       return ToProtoOrErr.takeError();
4412 
4413     if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4414       ProtocolLocs.push_back(*ToProtoLocOrErr);
4415     else
4416       return ToProtoLocOrErr.takeError();
4417 
4418   }
4419 
4420   // FIXME: If we're merging, make sure that the protocol list is the same.
4421   To->setProtocolList(Protocols.data(), Protocols.size(),
4422                       ProtocolLocs.data(), Importer.getToContext());
4423 
4424   if (shouldForceImportDeclContext(Kind)) {
4425     // Import all of the members of this protocol.
4426     if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
4427       return Err;
4428   }
4429   return Error::success();
4430 }
4431 
VisitObjCProtocolDecl(ObjCProtocolDecl * D)4432 ExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
4433   // If this protocol has a definition in the translation unit we're coming
4434   // from, but this particular declaration is not that definition, import the
4435   // definition and map to that.
4436   ObjCProtocolDecl *Definition = D->getDefinition();
4437   if (Definition && Definition != D) {
4438     if (ExpectedDecl ImportedDefOrErr = import(Definition))
4439       return Importer.MapImported(D, *ImportedDefOrErr);
4440     else
4441       return ImportedDefOrErr.takeError();
4442   }
4443 
4444   // Import the major distinguishing characteristics of a protocol.
4445   DeclContext *DC, *LexicalDC;
4446   DeclarationName Name;
4447   SourceLocation Loc;
4448   NamedDecl *ToD;
4449   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4450     return std::move(Err);
4451   if (ToD)
4452     return ToD;
4453 
4454   ObjCProtocolDecl *MergeWithProtocol = nullptr;
4455   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4456   for (auto *FoundDecl : FoundDecls) {
4457     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol))
4458       continue;
4459 
4460     if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl)))
4461       break;
4462   }
4463 
4464   ObjCProtocolDecl *ToProto = MergeWithProtocol;
4465   if (!ToProto) {
4466     auto ToAtBeginLocOrErr = import(D->getAtStartLoc());
4467     if (!ToAtBeginLocOrErr)
4468       return ToAtBeginLocOrErr.takeError();
4469 
4470     if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC,
4471                                 Name.getAsIdentifierInfo(), Loc,
4472                                 *ToAtBeginLocOrErr,
4473                                 /*PrevDecl=*/nullptr))
4474       return ToProto;
4475     ToProto->setLexicalDeclContext(LexicalDC);
4476     LexicalDC->addDeclInternal(ToProto);
4477   }
4478 
4479   Importer.MapImported(D, ToProto);
4480 
4481   if (D->isThisDeclarationADefinition())
4482     if (Error Err = ImportDefinition(D, ToProto))
4483       return std::move(Err);
4484 
4485   return ToProto;
4486 }
4487 
VisitLinkageSpecDecl(LinkageSpecDecl * D)4488 ExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
4489   DeclContext *DC, *LexicalDC;
4490   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4491     return std::move(Err);
4492 
4493   ExpectedSLoc ExternLocOrErr = import(D->getExternLoc());
4494   if (!ExternLocOrErr)
4495     return ExternLocOrErr.takeError();
4496 
4497   ExpectedSLoc LangLocOrErr = import(D->getLocation());
4498   if (!LangLocOrErr)
4499     return LangLocOrErr.takeError();
4500 
4501   bool HasBraces = D->hasBraces();
4502 
4503   LinkageSpecDecl *ToLinkageSpec;
4504   if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
4505                               *ExternLocOrErr, *LangLocOrErr,
4506                               D->getLanguage(), HasBraces))
4507     return ToLinkageSpec;
4508 
4509   if (HasBraces) {
4510     ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc());
4511     if (!RBraceLocOrErr)
4512       return RBraceLocOrErr.takeError();
4513     ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr);
4514   }
4515 
4516   ToLinkageSpec->setLexicalDeclContext(LexicalDC);
4517   LexicalDC->addDeclInternal(ToLinkageSpec);
4518 
4519   return ToLinkageSpec;
4520 }
4521 
VisitUsingDecl(UsingDecl * D)4522 ExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) {
4523   DeclContext *DC, *LexicalDC;
4524   DeclarationName Name;
4525   SourceLocation Loc;
4526   NamedDecl *ToD = nullptr;
4527   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4528     return std::move(Err);
4529   if (ToD)
4530     return ToD;
4531 
4532   Error Err = Error::success();
4533   auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4534   auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4535   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4536   if (Err)
4537     return std::move(Err);
4538 
4539   DeclarationNameInfo NameInfo(Name, ToLoc);
4540   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4541     return std::move(Err);
4542 
4543   UsingDecl *ToUsing;
4544   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4545                               ToUsingLoc, ToQualifierLoc, NameInfo,
4546                               D->hasTypename()))
4547     return ToUsing;
4548 
4549   ToUsing->setLexicalDeclContext(LexicalDC);
4550   LexicalDC->addDeclInternal(ToUsing);
4551 
4552   if (NamedDecl *FromPattern =
4553       Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
4554     if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
4555       Importer.getToContext().setInstantiatedFromUsingDecl(
4556           ToUsing, *ToPatternOrErr);
4557     else
4558       return ToPatternOrErr.takeError();
4559   }
4560 
4561   for (UsingShadowDecl *FromShadow : D->shadows()) {
4562     if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow))
4563       ToUsing->addShadowDecl(*ToShadowOrErr);
4564     else
4565       // FIXME: We return error here but the definition is already created
4566       // and available with lookups. How to fix this?..
4567       return ToShadowOrErr.takeError();
4568   }
4569   return ToUsing;
4570 }
4571 
VisitUsingShadowDecl(UsingShadowDecl * D)4572 ExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) {
4573   DeclContext *DC, *LexicalDC;
4574   DeclarationName Name;
4575   SourceLocation Loc;
4576   NamedDecl *ToD = nullptr;
4577   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4578     return std::move(Err);
4579   if (ToD)
4580     return ToD;
4581 
4582   Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl());
4583   if (!ToUsingOrErr)
4584     return ToUsingOrErr.takeError();
4585 
4586   Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl());
4587   if (!ToTargetOrErr)
4588     return ToTargetOrErr.takeError();
4589 
4590   UsingShadowDecl *ToShadow;
4591   if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc,
4592                               *ToUsingOrErr, *ToTargetOrErr))
4593     return ToShadow;
4594 
4595   ToShadow->setLexicalDeclContext(LexicalDC);
4596   ToShadow->setAccess(D->getAccess());
4597 
4598   if (UsingShadowDecl *FromPattern =
4599       Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
4600     if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
4601       Importer.getToContext().setInstantiatedFromUsingShadowDecl(
4602           ToShadow, *ToPatternOrErr);
4603     else
4604       // FIXME: We return error here but the definition is already created
4605       // and available with lookups. How to fix this?..
4606       return ToPatternOrErr.takeError();
4607   }
4608 
4609   LexicalDC->addDeclInternal(ToShadow);
4610 
4611   return ToShadow;
4612 }
4613 
VisitUsingDirectiveDecl(UsingDirectiveDecl * D)4614 ExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
4615   DeclContext *DC, *LexicalDC;
4616   DeclarationName Name;
4617   SourceLocation Loc;
4618   NamedDecl *ToD = nullptr;
4619   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4620     return std::move(Err);
4621   if (ToD)
4622     return ToD;
4623 
4624   auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor());
4625   if (!ToComAncestorOrErr)
4626     return ToComAncestorOrErr.takeError();
4627 
4628   Error Err = Error::success();
4629   auto ToNominatedNamespace = importChecked(Err, D->getNominatedNamespace());
4630   auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4631   auto ToNamespaceKeyLocation =
4632       importChecked(Err, D->getNamespaceKeyLocation());
4633   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4634   auto ToIdentLocation = importChecked(Err, D->getIdentLocation());
4635   if (Err)
4636     return std::move(Err);
4637 
4638   UsingDirectiveDecl *ToUsingDir;
4639   if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
4640                               ToUsingLoc,
4641                               ToNamespaceKeyLocation,
4642                               ToQualifierLoc,
4643                               ToIdentLocation,
4644                               ToNominatedNamespace, *ToComAncestorOrErr))
4645     return ToUsingDir;
4646 
4647   ToUsingDir->setLexicalDeclContext(LexicalDC);
4648   LexicalDC->addDeclInternal(ToUsingDir);
4649 
4650   return ToUsingDir;
4651 }
4652 
VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl * D)4653 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
4654     UnresolvedUsingValueDecl *D) {
4655   DeclContext *DC, *LexicalDC;
4656   DeclarationName Name;
4657   SourceLocation Loc;
4658   NamedDecl *ToD = nullptr;
4659   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4660     return std::move(Err);
4661   if (ToD)
4662     return ToD;
4663 
4664   Error Err = Error::success();
4665   auto ToLoc = importChecked(Err, D->getNameInfo().getLoc());
4666   auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4667   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4668   auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4669   if (Err)
4670     return std::move(Err);
4671 
4672   DeclarationNameInfo NameInfo(Name, ToLoc);
4673   if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo))
4674     return std::move(Err);
4675 
4676   UnresolvedUsingValueDecl *ToUsingValue;
4677   if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC,
4678                               ToUsingLoc, ToQualifierLoc, NameInfo,
4679                               ToEllipsisLoc))
4680     return ToUsingValue;
4681 
4682   ToUsingValue->setAccess(D->getAccess());
4683   ToUsingValue->setLexicalDeclContext(LexicalDC);
4684   LexicalDC->addDeclInternal(ToUsingValue);
4685 
4686   return ToUsingValue;
4687 }
4688 
VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl * D)4689 ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl(
4690     UnresolvedUsingTypenameDecl *D) {
4691   DeclContext *DC, *LexicalDC;
4692   DeclarationName Name;
4693   SourceLocation Loc;
4694   NamedDecl *ToD = nullptr;
4695   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4696     return std::move(Err);
4697   if (ToD)
4698     return ToD;
4699 
4700   Error Err = Error::success();
4701   auto ToUsingLoc = importChecked(Err, D->getUsingLoc());
4702   auto ToTypenameLoc = importChecked(Err, D->getTypenameLoc());
4703   auto ToQualifierLoc = importChecked(Err, D->getQualifierLoc());
4704   auto ToEllipsisLoc = importChecked(Err, D->getEllipsisLoc());
4705   if (Err)
4706     return std::move(Err);
4707 
4708   UnresolvedUsingTypenameDecl *ToUsing;
4709   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
4710                               ToUsingLoc, ToTypenameLoc,
4711                               ToQualifierLoc, Loc, Name, ToEllipsisLoc))
4712     return ToUsing;
4713 
4714   ToUsing->setAccess(D->getAccess());
4715   ToUsing->setLexicalDeclContext(LexicalDC);
4716   LexicalDC->addDeclInternal(ToUsing);
4717 
4718   return ToUsing;
4719 }
4720 
VisitBuiltinTemplateDecl(BuiltinTemplateDecl * D)4721 ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
4722   Decl* ToD = nullptr;
4723   switch (D->getBuiltinTemplateKind()) {
4724   case BuiltinTemplateKind::BTK__make_integer_seq:
4725     ToD = Importer.getToContext().getMakeIntegerSeqDecl();
4726     break;
4727   case BuiltinTemplateKind::BTK__type_pack_element:
4728     ToD = Importer.getToContext().getTypePackElementDecl();
4729     break;
4730   }
4731   assert(ToD && "BuiltinTemplateDecl of unsupported kind!");
4732   Importer.MapImported(D, ToD);
4733   return ToD;
4734 }
4735 
ImportDefinition(ObjCInterfaceDecl * From,ObjCInterfaceDecl * To,ImportDefinitionKind Kind)4736 Error ASTNodeImporter::ImportDefinition(
4737     ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
4738   if (To->getDefinition()) {
4739     // Check consistency of superclass.
4740     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
4741     if (FromSuper) {
4742       if (auto FromSuperOrErr = import(FromSuper))
4743         FromSuper = *FromSuperOrErr;
4744       else
4745         return FromSuperOrErr.takeError();
4746     }
4747 
4748     ObjCInterfaceDecl *ToSuper = To->getSuperClass();
4749     if ((bool)FromSuper != (bool)ToSuper ||
4750         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
4751       Importer.ToDiag(To->getLocation(),
4752                       diag::warn_odr_objc_superclass_inconsistent)
4753         << To->getDeclName();
4754       if (ToSuper)
4755         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
4756           << To->getSuperClass()->getDeclName();
4757       else
4758         Importer.ToDiag(To->getLocation(),
4759                         diag::note_odr_objc_missing_superclass);
4760       if (From->getSuperClass())
4761         Importer.FromDiag(From->getSuperClassLoc(),
4762                           diag::note_odr_objc_superclass)
4763         << From->getSuperClass()->getDeclName();
4764       else
4765         Importer.FromDiag(From->getLocation(),
4766                           diag::note_odr_objc_missing_superclass);
4767     }
4768 
4769     if (shouldForceImportDeclContext(Kind))
4770       if (Error Err = ImportDeclContext(From))
4771         return Err;
4772     return Error::success();
4773   }
4774 
4775   // Start the definition.
4776   To->startDefinition();
4777 
4778   // If this class has a superclass, import it.
4779   if (From->getSuperClass()) {
4780     if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo()))
4781       To->setSuperClass(*SuperTInfoOrErr);
4782     else
4783       return SuperTInfoOrErr.takeError();
4784   }
4785 
4786   // Import protocols
4787   SmallVector<ObjCProtocolDecl *, 4> Protocols;
4788   SmallVector<SourceLocation, 4> ProtocolLocs;
4789   ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc =
4790       From->protocol_loc_begin();
4791 
4792   for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
4793                                          FromProtoEnd = From->protocol_end();
4794        FromProto != FromProtoEnd;
4795        ++FromProto, ++FromProtoLoc) {
4796     if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
4797       Protocols.push_back(*ToProtoOrErr);
4798     else
4799       return ToProtoOrErr.takeError();
4800 
4801     if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc))
4802       ProtocolLocs.push_back(*ToProtoLocOrErr);
4803     else
4804       return ToProtoLocOrErr.takeError();
4805 
4806   }
4807 
4808   // FIXME: If we're merging, make sure that the protocol list is the same.
4809   To->setProtocolList(Protocols.data(), Protocols.size(),
4810                       ProtocolLocs.data(), Importer.getToContext());
4811 
4812   // Import categories. When the categories themselves are imported, they'll
4813   // hook themselves into this interface.
4814   for (auto *Cat : From->known_categories()) {
4815     auto ToCatOrErr = import(Cat);
4816     if (!ToCatOrErr)
4817       return ToCatOrErr.takeError();
4818   }
4819 
4820   // If we have an @implementation, import it as well.
4821   if (From->getImplementation()) {
4822     if (Expected<ObjCImplementationDecl *> ToImplOrErr =
4823         import(From->getImplementation()))
4824       To->setImplementation(*ToImplOrErr);
4825     else
4826       return ToImplOrErr.takeError();
4827   }
4828 
4829   // Import all of the members of this class.
4830   if (Error Err = ImportDeclContext(From, /*ForceImport=*/true))
4831     return Err;
4832 
4833   return Error::success();
4834 }
4835 
4836 Expected<ObjCTypeParamList *>
ImportObjCTypeParamList(ObjCTypeParamList * list)4837 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) {
4838   if (!list)
4839     return nullptr;
4840 
4841   SmallVector<ObjCTypeParamDecl *, 4> toTypeParams;
4842   for (auto *fromTypeParam : *list) {
4843     if (auto toTypeParamOrErr = import(fromTypeParam))
4844       toTypeParams.push_back(*toTypeParamOrErr);
4845     else
4846       return toTypeParamOrErr.takeError();
4847   }
4848 
4849   auto LAngleLocOrErr = import(list->getLAngleLoc());
4850   if (!LAngleLocOrErr)
4851     return LAngleLocOrErr.takeError();
4852 
4853   auto RAngleLocOrErr = import(list->getRAngleLoc());
4854   if (!RAngleLocOrErr)
4855     return RAngleLocOrErr.takeError();
4856 
4857   return ObjCTypeParamList::create(Importer.getToContext(),
4858                                    *LAngleLocOrErr,
4859                                    toTypeParams,
4860                                    *RAngleLocOrErr);
4861 }
4862 
VisitObjCInterfaceDecl(ObjCInterfaceDecl * D)4863 ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
4864   // If this class has a definition in the translation unit we're coming from,
4865   // but this particular declaration is not that definition, import the
4866   // definition and map to that.
4867   ObjCInterfaceDecl *Definition = D->getDefinition();
4868   if (Definition && Definition != D) {
4869     if (ExpectedDecl ImportedDefOrErr = import(Definition))
4870       return Importer.MapImported(D, *ImportedDefOrErr);
4871     else
4872       return ImportedDefOrErr.takeError();
4873   }
4874 
4875   // Import the major distinguishing characteristics of an @interface.
4876   DeclContext *DC, *LexicalDC;
4877   DeclarationName Name;
4878   SourceLocation Loc;
4879   NamedDecl *ToD;
4880   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
4881     return std::move(Err);
4882   if (ToD)
4883     return ToD;
4884 
4885   // Look for an existing interface with the same name.
4886   ObjCInterfaceDecl *MergeWithIface = nullptr;
4887   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
4888   for (auto *FoundDecl : FoundDecls) {
4889     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
4890       continue;
4891 
4892     if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl)))
4893       break;
4894   }
4895 
4896   // Create an interface declaration, if one does not already exist.
4897   ObjCInterfaceDecl *ToIface = MergeWithIface;
4898   if (!ToIface) {
4899     ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc());
4900     if (!AtBeginLocOrErr)
4901       return AtBeginLocOrErr.takeError();
4902 
4903     if (GetImportedOrCreateDecl(
4904             ToIface, D, Importer.getToContext(), DC,
4905             *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
4906             /*TypeParamList=*/nullptr,
4907             /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
4908       return ToIface;
4909     ToIface->setLexicalDeclContext(LexicalDC);
4910     LexicalDC->addDeclInternal(ToIface);
4911   }
4912   Importer.MapImported(D, ToIface);
4913   // Import the type parameter list after MapImported, to avoid
4914   // loops when bringing in their DeclContext.
4915   if (auto ToPListOrErr =
4916       ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
4917     ToIface->setTypeParamList(*ToPListOrErr);
4918   else
4919     return ToPListOrErr.takeError();
4920 
4921   if (D->isThisDeclarationADefinition())
4922     if (Error Err = ImportDefinition(D, ToIface))
4923       return std::move(Err);
4924 
4925   return ToIface;
4926 }
4927 
4928 ExpectedDecl
VisitObjCCategoryImplDecl(ObjCCategoryImplDecl * D)4929 ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
4930   ObjCCategoryDecl *Category;
4931   if (Error Err = importInto(Category, D->getCategoryDecl()))
4932     return std::move(Err);
4933 
4934   ObjCCategoryImplDecl *ToImpl = Category->getImplementation();
4935   if (!ToImpl) {
4936     DeclContext *DC, *LexicalDC;
4937     if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4938       return std::move(Err);
4939 
4940     Error Err = Error::success();
4941     auto ToLocation = importChecked(Err, D->getLocation());
4942     auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4943     auto ToCategoryNameLoc = importChecked(Err, D->getCategoryNameLoc());
4944     if (Err)
4945       return std::move(Err);
4946 
4947     if (GetImportedOrCreateDecl(
4948             ToImpl, D, Importer.getToContext(), DC,
4949             Importer.Import(D->getIdentifier()), Category->getClassInterface(),
4950             ToLocation, ToAtStartLoc, ToCategoryNameLoc))
4951       return ToImpl;
4952 
4953     ToImpl->setLexicalDeclContext(LexicalDC);
4954     LexicalDC->addDeclInternal(ToImpl);
4955     Category->setImplementation(ToImpl);
4956   }
4957 
4958   Importer.MapImported(D, ToImpl);
4959   if (Error Err = ImportDeclContext(D))
4960     return std::move(Err);
4961 
4962   return ToImpl;
4963 }
4964 
4965 ExpectedDecl
VisitObjCImplementationDecl(ObjCImplementationDecl * D)4966 ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
4967   // Find the corresponding interface.
4968   ObjCInterfaceDecl *Iface;
4969   if (Error Err = importInto(Iface, D->getClassInterface()))
4970     return std::move(Err);
4971 
4972   // Import the superclass, if any.
4973   ObjCInterfaceDecl *Super;
4974   if (Error Err = importInto(Super, D->getSuperClass()))
4975     return std::move(Err);
4976 
4977   ObjCImplementationDecl *Impl = Iface->getImplementation();
4978   if (!Impl) {
4979     // We haven't imported an implementation yet. Create a new @implementation
4980     // now.
4981     DeclContext *DC, *LexicalDC;
4982     if (Error Err = ImportDeclContext(D, DC, LexicalDC))
4983       return std::move(Err);
4984 
4985     Error Err = Error::success();
4986     auto ToLocation = importChecked(Err, D->getLocation());
4987     auto ToAtStartLoc = importChecked(Err, D->getAtStartLoc());
4988     auto ToSuperClassLoc = importChecked(Err, D->getSuperClassLoc());
4989     auto ToIvarLBraceLoc = importChecked(Err, D->getIvarLBraceLoc());
4990     auto ToIvarRBraceLoc = importChecked(Err, D->getIvarRBraceLoc());
4991     if (Err)
4992       return std::move(Err);
4993 
4994     if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
4995                                 DC, Iface, Super,
4996                                 ToLocation,
4997                                 ToAtStartLoc,
4998                                 ToSuperClassLoc,
4999                                 ToIvarLBraceLoc,
5000                                 ToIvarRBraceLoc))
5001       return Impl;
5002 
5003     Impl->setLexicalDeclContext(LexicalDC);
5004 
5005     // Associate the implementation with the class it implements.
5006     Iface->setImplementation(Impl);
5007     Importer.MapImported(D, Iface->getImplementation());
5008   } else {
5009     Importer.MapImported(D, Iface->getImplementation());
5010 
5011     // Verify that the existing @implementation has the same superclass.
5012     if ((Super && !Impl->getSuperClass()) ||
5013         (!Super && Impl->getSuperClass()) ||
5014         (Super && Impl->getSuperClass() &&
5015          !declaresSameEntity(Super->getCanonicalDecl(),
5016                              Impl->getSuperClass()))) {
5017       Importer.ToDiag(Impl->getLocation(),
5018                       diag::warn_odr_objc_superclass_inconsistent)
5019         << Iface->getDeclName();
5020       // FIXME: It would be nice to have the location of the superclass
5021       // below.
5022       if (Impl->getSuperClass())
5023         Importer.ToDiag(Impl->getLocation(),
5024                         diag::note_odr_objc_superclass)
5025         << Impl->getSuperClass()->getDeclName();
5026       else
5027         Importer.ToDiag(Impl->getLocation(),
5028                         diag::note_odr_objc_missing_superclass);
5029       if (D->getSuperClass())
5030         Importer.FromDiag(D->getLocation(),
5031                           diag::note_odr_objc_superclass)
5032         << D->getSuperClass()->getDeclName();
5033       else
5034         Importer.FromDiag(D->getLocation(),
5035                           diag::note_odr_objc_missing_superclass);
5036 
5037       return make_error<ImportError>(ImportError::NameConflict);
5038     }
5039   }
5040 
5041   // Import all of the members of this @implementation.
5042   if (Error Err = ImportDeclContext(D))
5043     return std::move(Err);
5044 
5045   return Impl;
5046 }
5047 
VisitObjCPropertyDecl(ObjCPropertyDecl * D)5048 ExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
5049   // Import the major distinguishing characteristics of an @property.
5050   DeclContext *DC, *LexicalDC;
5051   DeclarationName Name;
5052   SourceLocation Loc;
5053   NamedDecl *ToD;
5054   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5055     return std::move(Err);
5056   if (ToD)
5057     return ToD;
5058 
5059   // Check whether we have already imported this property.
5060   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5061   for (auto *FoundDecl : FoundDecls) {
5062     if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) {
5063       // Check property types.
5064       if (!Importer.IsStructurallyEquivalent(D->getType(),
5065                                              FoundProp->getType())) {
5066         Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
5067           << Name << D->getType() << FoundProp->getType();
5068         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
5069           << FoundProp->getType();
5070 
5071         return make_error<ImportError>(ImportError::NameConflict);
5072       }
5073 
5074       // FIXME: Check property attributes, getters, setters, etc.?
5075 
5076       // Consider these properties to be equivalent.
5077       Importer.MapImported(D, FoundProp);
5078       return FoundProp;
5079     }
5080   }
5081 
5082   Error Err = Error::success();
5083   auto ToType = importChecked(Err, D->getType());
5084   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5085   auto ToAtLoc = importChecked(Err, D->getAtLoc());
5086   auto ToLParenLoc = importChecked(Err, D->getLParenLoc());
5087   if (Err)
5088     return std::move(Err);
5089 
5090   // Create the new property.
5091   ObjCPropertyDecl *ToProperty;
5092   if (GetImportedOrCreateDecl(
5093           ToProperty, D, Importer.getToContext(), DC, Loc,
5094           Name.getAsIdentifierInfo(), ToAtLoc,
5095           ToLParenLoc, ToType,
5096           ToTypeSourceInfo, D->getPropertyImplementation()))
5097     return ToProperty;
5098 
5099   auto ToGetterName = importChecked(Err, D->getGetterName());
5100   auto ToSetterName = importChecked(Err, D->getSetterName());
5101   auto ToGetterNameLoc = importChecked(Err, D->getGetterNameLoc());
5102   auto ToSetterNameLoc = importChecked(Err, D->getSetterNameLoc());
5103   auto ToGetterMethodDecl = importChecked(Err, D->getGetterMethodDecl());
5104   auto ToSetterMethodDecl = importChecked(Err, D->getSetterMethodDecl());
5105   auto ToPropertyIvarDecl = importChecked(Err, D->getPropertyIvarDecl());
5106   if (Err)
5107     return std::move(Err);
5108 
5109   ToProperty->setLexicalDeclContext(LexicalDC);
5110   LexicalDC->addDeclInternal(ToProperty);
5111 
5112   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
5113   ToProperty->setPropertyAttributesAsWritten(
5114                                       D->getPropertyAttributesAsWritten());
5115   ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
5116   ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
5117   ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
5118   ToProperty->setSetterMethodDecl(ToSetterMethodDecl);
5119   ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl);
5120   return ToProperty;
5121 }
5122 
5123 ExpectedDecl
VisitObjCPropertyImplDecl(ObjCPropertyImplDecl * D)5124 ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
5125   ObjCPropertyDecl *Property;
5126   if (Error Err = importInto(Property, D->getPropertyDecl()))
5127     return std::move(Err);
5128 
5129   DeclContext *DC, *LexicalDC;
5130   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5131     return std::move(Err);
5132 
5133   auto *InImpl = cast<ObjCImplDecl>(LexicalDC);
5134 
5135   // Import the ivar (for an @synthesize).
5136   ObjCIvarDecl *Ivar = nullptr;
5137   if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
5138     return std::move(Err);
5139 
5140   ObjCPropertyImplDecl *ToImpl
5141     = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
5142                                    Property->getQueryKind());
5143   if (!ToImpl) {
5144 
5145     Error Err = Error::success();
5146     auto ToBeginLoc = importChecked(Err, D->getBeginLoc());
5147     auto ToLocation = importChecked(Err, D->getLocation());
5148     auto ToPropertyIvarDeclLoc =
5149         importChecked(Err, D->getPropertyIvarDeclLoc());
5150     if (Err)
5151       return std::move(Err);
5152 
5153     if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
5154                                 ToBeginLoc,
5155                                 ToLocation, Property,
5156                                 D->getPropertyImplementation(), Ivar,
5157                                 ToPropertyIvarDeclLoc))
5158       return ToImpl;
5159 
5160     ToImpl->setLexicalDeclContext(LexicalDC);
5161     LexicalDC->addDeclInternal(ToImpl);
5162   } else {
5163     // Check that we have the same kind of property implementation (@synthesize
5164     // vs. @dynamic).
5165     if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
5166       Importer.ToDiag(ToImpl->getLocation(),
5167                       diag::warn_odr_objc_property_impl_kind_inconsistent)
5168         << Property->getDeclName()
5169         << (ToImpl->getPropertyImplementation()
5170                                               == ObjCPropertyImplDecl::Dynamic);
5171       Importer.FromDiag(D->getLocation(),
5172                         diag::note_odr_objc_property_impl_kind)
5173         << D->getPropertyDecl()->getDeclName()
5174         << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
5175 
5176       return make_error<ImportError>(ImportError::NameConflict);
5177     }
5178 
5179     // For @synthesize, check that we have the same
5180     if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize &&
5181         Ivar != ToImpl->getPropertyIvarDecl()) {
5182       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
5183                       diag::warn_odr_objc_synthesize_ivar_inconsistent)
5184         << Property->getDeclName()
5185         << ToImpl->getPropertyIvarDecl()->getDeclName()
5186         << Ivar->getDeclName();
5187       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
5188                         diag::note_odr_objc_synthesize_ivar_here)
5189         << D->getPropertyIvarDecl()->getDeclName();
5190 
5191       return make_error<ImportError>(ImportError::NameConflict);
5192     }
5193 
5194     // Merge the existing implementation with the new implementation.
5195     Importer.MapImported(D, ToImpl);
5196   }
5197 
5198   return ToImpl;
5199 }
5200 
5201 ExpectedDecl
VisitTemplateTypeParmDecl(TemplateTypeParmDecl * D)5202 ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
5203   // For template arguments, we adopt the translation unit as our declaration
5204   // context. This context will be fixed when the actual template declaration
5205   // is created.
5206 
5207   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5208   if (!BeginLocOrErr)
5209     return BeginLocOrErr.takeError();
5210 
5211   ExpectedSLoc LocationOrErr = import(D->getLocation());
5212   if (!LocationOrErr)
5213     return LocationOrErr.takeError();
5214 
5215   TemplateTypeParmDecl *ToD = nullptr;
5216   if (GetImportedOrCreateDecl(
5217       ToD, D, Importer.getToContext(),
5218       Importer.getToContext().getTranslationUnitDecl(),
5219       *BeginLocOrErr, *LocationOrErr,
5220       D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
5221       D->wasDeclaredWithTypename(), D->isParameterPack(),
5222       D->hasTypeConstraint()))
5223     return ToD;
5224 
5225   // Import the type-constraint
5226   if (const TypeConstraint *TC = D->getTypeConstraint()) {
5227 
5228     Error Err = Error::success();
5229     auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
5230     auto ToName = importChecked(Err, TC->getConceptNameInfo().getName());
5231     auto ToNameLoc = importChecked(Err, TC->getConceptNameInfo().getLoc());
5232     auto ToFoundDecl = importChecked(Err, TC->getFoundDecl());
5233     auto ToNamedConcept = importChecked(Err, TC->getNamedConcept());
5234     auto ToIDC = importChecked(Err, TC->getImmediatelyDeclaredConstraint());
5235     if (Err)
5236       return std::move(Err);
5237 
5238     TemplateArgumentListInfo ToTAInfo;
5239     const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
5240     if (ASTTemplateArgs)
5241       if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
5242                                                      ToTAInfo))
5243         return std::move(Err);
5244 
5245     ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
5246         ToFoundDecl, ToNamedConcept,
5247         ASTTemplateArgs ?
5248             ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
5249                                                 ToTAInfo) : nullptr,
5250         ToIDC);
5251   }
5252 
5253   if (D->hasDefaultArgument()) {
5254     Expected<TypeSourceInfo *> ToDefaultArgOrErr =
5255         import(D->getDefaultArgumentInfo());
5256     if (!ToDefaultArgOrErr)
5257       return ToDefaultArgOrErr.takeError();
5258     ToD->setDefaultArgument(*ToDefaultArgOrErr);
5259   }
5260 
5261   return ToD;
5262 }
5263 
5264 ExpectedDecl
VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl * D)5265 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
5266 
5267   Error Err = Error::success();
5268   auto ToDeclName = importChecked(Err, D->getDeclName());
5269   auto ToLocation = importChecked(Err, D->getLocation());
5270   auto ToType = importChecked(Err, D->getType());
5271   auto ToTypeSourceInfo = importChecked(Err, D->getTypeSourceInfo());
5272   auto ToInnerLocStart = importChecked(Err, D->getInnerLocStart());
5273   if (Err)
5274     return std::move(Err);
5275 
5276   NonTypeTemplateParmDecl *ToD = nullptr;
5277   if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(),
5278                               Importer.getToContext().getTranslationUnitDecl(),
5279                               ToInnerLocStart, ToLocation, D->getDepth(),
5280                               D->getPosition(),
5281                               ToDeclName.getAsIdentifierInfo(), ToType,
5282                               D->isParameterPack(), ToTypeSourceInfo))
5283     return ToD;
5284 
5285   if (D->hasDefaultArgument()) {
5286     ExpectedExpr ToDefaultArgOrErr = import(D->getDefaultArgument());
5287     if (!ToDefaultArgOrErr)
5288       return ToDefaultArgOrErr.takeError();
5289     ToD->setDefaultArgument(*ToDefaultArgOrErr);
5290   }
5291 
5292   return ToD;
5293 }
5294 
5295 ExpectedDecl
VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl * D)5296 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
5297   // Import the name of this declaration.
5298   auto NameOrErr = import(D->getDeclName());
5299   if (!NameOrErr)
5300     return NameOrErr.takeError();
5301 
5302   // Import the location of this declaration.
5303   ExpectedSLoc LocationOrErr = import(D->getLocation());
5304   if (!LocationOrErr)
5305     return LocationOrErr.takeError();
5306 
5307   // Import template parameters.
5308   auto TemplateParamsOrErr = import(D->getTemplateParameters());
5309   if (!TemplateParamsOrErr)
5310     return TemplateParamsOrErr.takeError();
5311 
5312   TemplateTemplateParmDecl *ToD = nullptr;
5313   if (GetImportedOrCreateDecl(
5314           ToD, D, Importer.getToContext(),
5315           Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr,
5316           D->getDepth(), D->getPosition(), D->isParameterPack(),
5317           (*NameOrErr).getAsIdentifierInfo(), *TemplateParamsOrErr))
5318     return ToD;
5319 
5320   if (D->hasDefaultArgument()) {
5321     Expected<TemplateArgumentLoc> ToDefaultArgOrErr =
5322         import(D->getDefaultArgument());
5323     if (!ToDefaultArgOrErr)
5324       return ToDefaultArgOrErr.takeError();
5325     ToD->setDefaultArgument(Importer.getToContext(), *ToDefaultArgOrErr);
5326   }
5327 
5328   return ToD;
5329 }
5330 
5331 // Returns the definition for a (forward) declaration of a TemplateDecl, if
5332 // it has any definition in the redecl chain.
getTemplateDefinition(T * D)5333 template <typename T> static auto getTemplateDefinition(T *D) -> T * {
5334   assert(D->getTemplatedDecl() && "Should be called on templates only");
5335   auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition();
5336   if (!ToTemplatedDef)
5337     return nullptr;
5338   auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate();
5339   return cast_or_null<T>(TemplateWithDef);
5340 }
5341 
VisitClassTemplateDecl(ClassTemplateDecl * D)5342 ExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
5343 
5344   // Import the major distinguishing characteristics of this class template.
5345   DeclContext *DC, *LexicalDC;
5346   DeclarationName Name;
5347   SourceLocation Loc;
5348   NamedDecl *ToD;
5349   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5350     return std::move(Err);
5351   if (ToD)
5352     return ToD;
5353 
5354   ClassTemplateDecl *FoundByLookup = nullptr;
5355 
5356   // We may already have a template of the same name; try to find and match it.
5357   if (!DC->isFunctionOrMethod()) {
5358     SmallVector<NamedDecl *, 4> ConflictingDecls;
5359     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5360     for (auto *FoundDecl : FoundDecls) {
5361       if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary |
5362                                               Decl::IDNS_TagFriend))
5363         continue;
5364 
5365       Decl *Found = FoundDecl;
5366       auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found);
5367       if (FoundTemplate) {
5368         if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
5369           continue;
5370 
5371         if (IsStructuralMatch(D, FoundTemplate)) {
5372           ClassTemplateDecl *TemplateWithDef =
5373               getTemplateDefinition(FoundTemplate);
5374           if (D->isThisDeclarationADefinition() && TemplateWithDef)
5375             return Importer.MapImported(D, TemplateWithDef);
5376           if (!FoundByLookup)
5377             FoundByLookup = FoundTemplate;
5378           // Search in all matches because there may be multiple decl chains,
5379           // see ASTTests test ImportExistingFriendClassTemplateDef.
5380           continue;
5381         }
5382         ConflictingDecls.push_back(FoundDecl);
5383       }
5384     }
5385 
5386     if (!ConflictingDecls.empty()) {
5387       ExpectedName NameOrErr = Importer.HandleNameConflict(
5388           Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5389           ConflictingDecls.size());
5390       if (NameOrErr)
5391         Name = NameOrErr.get();
5392       else
5393         return NameOrErr.takeError();
5394     }
5395   }
5396 
5397   CXXRecordDecl *FromTemplated = D->getTemplatedDecl();
5398 
5399   auto TemplateParamsOrErr = import(D->getTemplateParameters());
5400   if (!TemplateParamsOrErr)
5401     return TemplateParamsOrErr.takeError();
5402 
5403   // Create the declaration that is being templated.
5404   CXXRecordDecl *ToTemplated;
5405   if (Error Err = importInto(ToTemplated, FromTemplated))
5406     return std::move(Err);
5407 
5408   // Create the class template declaration itself.
5409   ClassTemplateDecl *D2;
5410   if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name,
5411                               *TemplateParamsOrErr, ToTemplated))
5412     return D2;
5413 
5414   ToTemplated->setDescribedClassTemplate(D2);
5415 
5416   D2->setAccess(D->getAccess());
5417   D2->setLexicalDeclContext(LexicalDC);
5418 
5419   addDeclToContexts(D, D2);
5420 
5421   if (FoundByLookup) {
5422     auto *Recent =
5423         const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5424 
5425     // It is possible that during the import of the class template definition
5426     // we start the import of a fwd friend decl of the very same class template
5427     // and we add the fwd friend decl to the lookup table. But the ToTemplated
5428     // had been created earlier and by that time the lookup could not find
5429     // anything existing, so it has no previous decl. Later, (still during the
5430     // import of the fwd friend decl) we start to import the definition again
5431     // and this time the lookup finds the previous fwd friend class template.
5432     // In this case we must set up the previous decl for the templated decl.
5433     if (!ToTemplated->getPreviousDecl()) {
5434       assert(FoundByLookup->getTemplatedDecl() &&
5435              "Found decl must have its templated decl set");
5436       CXXRecordDecl *PrevTemplated =
5437           FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5438       if (ToTemplated != PrevTemplated)
5439         ToTemplated->setPreviousDecl(PrevTemplated);
5440     }
5441 
5442     D2->setPreviousDecl(Recent);
5443   }
5444 
5445   if (FromTemplated->isCompleteDefinition() &&
5446       !ToTemplated->isCompleteDefinition()) {
5447     // FIXME: Import definition!
5448   }
5449 
5450   return D2;
5451 }
5452 
VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl * D)5453 ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
5454                                           ClassTemplateSpecializationDecl *D) {
5455   ClassTemplateDecl *ClassTemplate;
5456   if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
5457     return std::move(Err);
5458 
5459   // Import the context of this declaration.
5460   DeclContext *DC, *LexicalDC;
5461   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5462     return std::move(Err);
5463 
5464   // Import template arguments.
5465   SmallVector<TemplateArgument, 2> TemplateArgs;
5466   if (Error Err = ImportTemplateArguments(
5467       D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5468     return std::move(Err);
5469   // Try to find an existing specialization with these template arguments and
5470   // template parameter list.
5471   void *InsertPos = nullptr;
5472   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
5473   ClassTemplatePartialSpecializationDecl *PartialSpec =
5474             dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
5475 
5476   // Import template parameters.
5477   TemplateParameterList *ToTPList = nullptr;
5478 
5479   if (PartialSpec) {
5480     auto ToTPListOrErr = import(PartialSpec->getTemplateParameters());
5481     if (!ToTPListOrErr)
5482       return ToTPListOrErr.takeError();
5483     ToTPList = *ToTPListOrErr;
5484     PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
5485                                                         *ToTPListOrErr,
5486                                                         InsertPos);
5487   } else
5488     PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
5489 
5490   if (PrevDecl) {
5491     if (IsStructuralMatch(D, PrevDecl)) {
5492       CXXRecordDecl *PrevDefinition = PrevDecl->getDefinition();
5493       if (D->isThisDeclarationADefinition() && PrevDefinition) {
5494         Importer.MapImported(D, PrevDefinition);
5495         // Import those default field initializers which have been
5496         // instantiated in the "From" context, but not in the "To" context.
5497         for (auto *FromField : D->fields()) {
5498           auto ToOrErr = import(FromField);
5499           if (!ToOrErr)
5500             return ToOrErr.takeError();
5501         }
5502 
5503         // Import those methods which have been instantiated in the
5504         // "From" context, but not in the "To" context.
5505         for (CXXMethodDecl *FromM : D->methods()) {
5506           auto ToOrErr = import(FromM);
5507           if (!ToOrErr)
5508             return ToOrErr.takeError();
5509         }
5510 
5511         // TODO Import instantiated default arguments.
5512         // TODO Import instantiated exception specifications.
5513         //
5514         // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint
5515         // what else could be fused during an AST merge.
5516         return PrevDefinition;
5517       }
5518     } else { // ODR violation.
5519       // FIXME HandleNameConflict
5520       return make_error<ImportError>(ImportError::NameConflict);
5521     }
5522   }
5523 
5524   // Import the location of this declaration.
5525   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5526   if (!BeginLocOrErr)
5527     return BeginLocOrErr.takeError();
5528   ExpectedSLoc IdLocOrErr = import(D->getLocation());
5529   if (!IdLocOrErr)
5530     return IdLocOrErr.takeError();
5531 
5532   // Create the specialization.
5533   ClassTemplateSpecializationDecl *D2 = nullptr;
5534   if (PartialSpec) {
5535     // Import TemplateArgumentListInfo.
5536     TemplateArgumentListInfo ToTAInfo;
5537     const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
5538     if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
5539       return std::move(Err);
5540 
5541     QualType CanonInjType;
5542     if (Error Err = importInto(
5543         CanonInjType, PartialSpec->getInjectedSpecializationType()))
5544       return std::move(Err);
5545     CanonInjType = CanonInjType.getCanonicalType();
5546 
5547     if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
5548             D2, D, Importer.getToContext(), D->getTagKind(), DC,
5549             *BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate,
5550             llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
5551             ToTAInfo, CanonInjType,
5552             cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
5553       return D2;
5554 
5555     // Update InsertPos, because preceding import calls may have invalidated
5556     // it by adding new specializations.
5557     auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2);
5558     if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList,
5559                                                   InsertPos))
5560       // Add this partial specialization to the class template.
5561       ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos);
5562 
5563   } else { // Not a partial specialization.
5564     if (GetImportedOrCreateDecl(
5565             D2, D, Importer.getToContext(), D->getTagKind(), DC,
5566             *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
5567             PrevDecl))
5568       return D2;
5569 
5570     // Update InsertPos, because preceding import calls may have invalidated
5571     // it by adding new specializations.
5572     if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos))
5573       // Add this specialization to the class template.
5574       ClassTemplate->AddSpecialization(D2, InsertPos);
5575   }
5576 
5577   D2->setSpecializationKind(D->getSpecializationKind());
5578 
5579   // Set the context of this specialization/instantiation.
5580   D2->setLexicalDeclContext(LexicalDC);
5581 
5582   // Add to the DC only if it was an explicit specialization/instantiation.
5583   if (D2->isExplicitInstantiationOrSpecialization()) {
5584     LexicalDC->addDeclInternal(D2);
5585   }
5586 
5587   if (auto BraceRangeOrErr = import(D->getBraceRange()))
5588     D2->setBraceRange(*BraceRangeOrErr);
5589   else
5590     return BraceRangeOrErr.takeError();
5591 
5592   // Import the qualifier, if any.
5593   if (auto LocOrErr = import(D->getQualifierLoc()))
5594     D2->setQualifierInfo(*LocOrErr);
5595   else
5596     return LocOrErr.takeError();
5597 
5598   if (auto *TSI = D->getTypeAsWritten()) {
5599     if (auto TInfoOrErr = import(TSI))
5600       D2->setTypeAsWritten(*TInfoOrErr);
5601     else
5602       return TInfoOrErr.takeError();
5603 
5604     if (auto LocOrErr = import(D->getTemplateKeywordLoc()))
5605       D2->setTemplateKeywordLoc(*LocOrErr);
5606     else
5607       return LocOrErr.takeError();
5608 
5609     if (auto LocOrErr = import(D->getExternLoc()))
5610       D2->setExternLoc(*LocOrErr);
5611     else
5612       return LocOrErr.takeError();
5613   }
5614 
5615   if (D->getPointOfInstantiation().isValid()) {
5616     if (auto POIOrErr = import(D->getPointOfInstantiation()))
5617       D2->setPointOfInstantiation(*POIOrErr);
5618     else
5619       return POIOrErr.takeError();
5620   }
5621 
5622   D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind());
5623 
5624   if (D->isCompleteDefinition())
5625     if (Error Err = ImportDefinition(D, D2))
5626       return std::move(Err);
5627 
5628   return D2;
5629 }
5630 
VisitVarTemplateDecl(VarTemplateDecl * D)5631 ExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) {
5632   // Import the major distinguishing characteristics of this variable template.
5633   DeclContext *DC, *LexicalDC;
5634   DeclarationName Name;
5635   SourceLocation Loc;
5636   NamedDecl *ToD;
5637   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5638     return std::move(Err);
5639   if (ToD)
5640     return ToD;
5641 
5642   // We may already have a template of the same name; try to find and match it.
5643   assert(!DC->isFunctionOrMethod() &&
5644          "Variable templates cannot be declared at function scope");
5645 
5646   SmallVector<NamedDecl *, 4> ConflictingDecls;
5647   auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5648   VarTemplateDecl *FoundByLookup = nullptr;
5649   for (auto *FoundDecl : FoundDecls) {
5650     if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
5651       continue;
5652 
5653     if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(FoundDecl)) {
5654       // Use the templated decl, some linkage flags are set only there.
5655       if (!hasSameVisibilityContextAndLinkage(FoundTemplate->getTemplatedDecl(),
5656                                               D->getTemplatedDecl()))
5657         continue;
5658       if (IsStructuralMatch(D, FoundTemplate)) {
5659         // The Decl in the "From" context has a definition, but in the
5660         // "To" context we already have a definition.
5661         VarTemplateDecl *FoundDef = getTemplateDefinition(FoundTemplate);
5662         if (D->isThisDeclarationADefinition() && FoundDef)
5663           // FIXME Check for ODR error if the two definitions have
5664           // different initializers?
5665           return Importer.MapImported(D, FoundDef);
5666 
5667         FoundByLookup = FoundTemplate;
5668         break;
5669       }
5670       ConflictingDecls.push_back(FoundDecl);
5671     }
5672   }
5673 
5674   if (!ConflictingDecls.empty()) {
5675     ExpectedName NameOrErr = Importer.HandleNameConflict(
5676         Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(),
5677         ConflictingDecls.size());
5678     if (NameOrErr)
5679       Name = NameOrErr.get();
5680     else
5681       return NameOrErr.takeError();
5682   }
5683 
5684   VarDecl *DTemplated = D->getTemplatedDecl();
5685 
5686   // Import the type.
5687   // FIXME: Value not used?
5688   ExpectedType TypeOrErr = import(DTemplated->getType());
5689   if (!TypeOrErr)
5690     return TypeOrErr.takeError();
5691 
5692   // Create the declaration that is being templated.
5693   VarDecl *ToTemplated;
5694   if (Error Err = importInto(ToTemplated, DTemplated))
5695     return std::move(Err);
5696 
5697   // Create the variable template declaration itself.
5698   auto TemplateParamsOrErr = import(D->getTemplateParameters());
5699   if (!TemplateParamsOrErr)
5700     return TemplateParamsOrErr.takeError();
5701 
5702   VarTemplateDecl *ToVarTD;
5703   if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc,
5704                               Name, *TemplateParamsOrErr, ToTemplated))
5705     return ToVarTD;
5706 
5707   ToTemplated->setDescribedVarTemplate(ToVarTD);
5708 
5709   ToVarTD->setAccess(D->getAccess());
5710   ToVarTD->setLexicalDeclContext(LexicalDC);
5711   LexicalDC->addDeclInternal(ToVarTD);
5712 
5713   if (FoundByLookup) {
5714     auto *Recent =
5715         const_cast<VarTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5716     if (!ToTemplated->getPreviousDecl()) {
5717       auto *PrevTemplated =
5718           FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5719       if (ToTemplated != PrevTemplated)
5720         ToTemplated->setPreviousDecl(PrevTemplated);
5721     }
5722     ToVarTD->setPreviousDecl(Recent);
5723   }
5724 
5725   if (DTemplated->isThisDeclarationADefinition() &&
5726       !ToTemplated->isThisDeclarationADefinition()) {
5727     // FIXME: Import definition!
5728   }
5729 
5730   return ToVarTD;
5731 }
5732 
VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl * D)5733 ExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl(
5734     VarTemplateSpecializationDecl *D) {
5735   // If this record has a definition in the translation unit we're coming from,
5736   // but this particular declaration is not that definition, import the
5737   // definition and map to that.
5738   VarDecl *Definition = D->getDefinition();
5739   if (Definition && Definition != D) {
5740     if (ExpectedDecl ImportedDefOrErr = import(Definition))
5741       return Importer.MapImported(D, *ImportedDefOrErr);
5742     else
5743       return ImportedDefOrErr.takeError();
5744   }
5745 
5746   VarTemplateDecl *VarTemplate = nullptr;
5747   if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate()))
5748     return std::move(Err);
5749 
5750   // Import the context of this declaration.
5751   DeclContext *DC, *LexicalDC;
5752   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
5753     return std::move(Err);
5754 
5755   // Import the location of this declaration.
5756   ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc());
5757   if (!BeginLocOrErr)
5758     return BeginLocOrErr.takeError();
5759 
5760   auto IdLocOrErr = import(D->getLocation());
5761   if (!IdLocOrErr)
5762     return IdLocOrErr.takeError();
5763 
5764   // Import template arguments.
5765   SmallVector<TemplateArgument, 2> TemplateArgs;
5766   if (Error Err = ImportTemplateArguments(
5767       D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
5768     return std::move(Err);
5769 
5770   // Try to find an existing specialization with these template arguments.
5771   void *InsertPos = nullptr;
5772   VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
5773       TemplateArgs, InsertPos);
5774   if (D2) {
5775     // We already have a variable template specialization with these template
5776     // arguments.
5777 
5778     // FIXME: Check for specialization vs. instantiation errors.
5779 
5780     if (VarDecl *FoundDef = D2->getDefinition()) {
5781       if (!D->isThisDeclarationADefinition() ||
5782           IsStructuralMatch(D, FoundDef)) {
5783         // The record types structurally match, or the "from" translation
5784         // unit only had a forward declaration anyway; call it the same
5785         // variable.
5786         return Importer.MapImported(D, FoundDef);
5787       }
5788     }
5789   } else {
5790     // Import the type.
5791     QualType T;
5792     if (Error Err = importInto(T, D->getType()))
5793       return std::move(Err);
5794 
5795     auto TInfoOrErr = import(D->getTypeSourceInfo());
5796     if (!TInfoOrErr)
5797       return TInfoOrErr.takeError();
5798 
5799     TemplateArgumentListInfo ToTAInfo;
5800     if (Error Err = ImportTemplateArgumentListInfo(
5801         D->getTemplateArgsInfo(), ToTAInfo))
5802       return std::move(Err);
5803 
5804     using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
5805     // Create a new specialization.
5806     if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
5807       // Import TemplateArgumentListInfo
5808       TemplateArgumentListInfo ArgInfos;
5809       const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
5810       // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
5811       if (Error Err = ImportTemplateArgumentListInfo(
5812           *FromTAArgsAsWritten, ArgInfos))
5813         return std::move(Err);
5814 
5815       auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
5816       if (!ToTPListOrErr)
5817         return ToTPListOrErr.takeError();
5818 
5819       PartVarSpecDecl *ToPartial;
5820       if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC,
5821                                   *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr,
5822                                   VarTemplate, T, *TInfoOrErr,
5823                                   D->getStorageClass(), TemplateArgs, ArgInfos))
5824         return ToPartial;
5825 
5826       if (Expected<PartVarSpecDecl *> ToInstOrErr = import(
5827           FromPartial->getInstantiatedFromMember()))
5828         ToPartial->setInstantiatedFromMember(*ToInstOrErr);
5829       else
5830         return ToInstOrErr.takeError();
5831 
5832       if (FromPartial->isMemberSpecialization())
5833         ToPartial->setMemberSpecialization();
5834 
5835       D2 = ToPartial;
5836 
5837     } else { // Full specialization
5838       if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC,
5839                                   *BeginLocOrErr, *IdLocOrErr, VarTemplate,
5840                                   T, *TInfoOrErr,
5841                                   D->getStorageClass(), TemplateArgs))
5842         return D2;
5843     }
5844 
5845     if (D->getPointOfInstantiation().isValid()) {
5846       if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation()))
5847         D2->setPointOfInstantiation(*POIOrErr);
5848       else
5849         return POIOrErr.takeError();
5850     }
5851 
5852     D2->setSpecializationKind(D->getSpecializationKind());
5853     D2->setTemplateArgsInfo(ToTAInfo);
5854 
5855     // Add this specialization to the class template.
5856     VarTemplate->AddSpecialization(D2, InsertPos);
5857 
5858     // Import the qualifier, if any.
5859     if (auto LocOrErr = import(D->getQualifierLoc()))
5860       D2->setQualifierInfo(*LocOrErr);
5861     else
5862       return LocOrErr.takeError();
5863 
5864     if (D->isConstexpr())
5865       D2->setConstexpr(true);
5866 
5867     // Add the specialization to this context.
5868     D2->setLexicalDeclContext(LexicalDC);
5869     LexicalDC->addDeclInternal(D2);
5870 
5871     D2->setAccess(D->getAccess());
5872   }
5873 
5874   if (Error Err = ImportInitializer(D, D2))
5875     return std::move(Err);
5876 
5877   return D2;
5878 }
5879 
5880 ExpectedDecl
VisitFunctionTemplateDecl(FunctionTemplateDecl * D)5881 ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
5882   DeclContext *DC, *LexicalDC;
5883   DeclarationName Name;
5884   SourceLocation Loc;
5885   NamedDecl *ToD;
5886 
5887   if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc))
5888     return std::move(Err);
5889 
5890   if (ToD)
5891     return ToD;
5892 
5893   const FunctionTemplateDecl *FoundByLookup = nullptr;
5894 
5895   // Try to find a function in our own ("to") context with the same name, same
5896   // type, and in the same context as the function we're importing.
5897   // FIXME Split this into a separate function.
5898   if (!LexicalDC->isFunctionOrMethod()) {
5899     unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend;
5900     auto FoundDecls = Importer.findDeclsInToCtx(DC, Name);
5901     for (auto *FoundDecl : FoundDecls) {
5902       if (!FoundDecl->isInIdentifierNamespace(IDNS))
5903         continue;
5904 
5905       if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) {
5906         if (!hasSameVisibilityContextAndLinkage(FoundTemplate, D))
5907           continue;
5908         if (IsStructuralMatch(D, FoundTemplate)) {
5909           FunctionTemplateDecl *TemplateWithDef =
5910               getTemplateDefinition(FoundTemplate);
5911           if (D->isThisDeclarationADefinition() && TemplateWithDef)
5912             return Importer.MapImported(D, TemplateWithDef);
5913 
5914           FoundByLookup = FoundTemplate;
5915           break;
5916           // TODO: handle conflicting names
5917         }
5918       }
5919     }
5920   }
5921 
5922   auto ParamsOrErr = import(D->getTemplateParameters());
5923   if (!ParamsOrErr)
5924     return ParamsOrErr.takeError();
5925 
5926   FunctionDecl *TemplatedFD;
5927   if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl()))
5928     return std::move(Err);
5929 
5930   FunctionTemplateDecl *ToFunc;
5931   if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name,
5932                               *ParamsOrErr, TemplatedFD))
5933     return ToFunc;
5934 
5935   TemplatedFD->setDescribedFunctionTemplate(ToFunc);
5936 
5937   ToFunc->setAccess(D->getAccess());
5938   ToFunc->setLexicalDeclContext(LexicalDC);
5939   LexicalDC->addDeclInternal(ToFunc);
5940 
5941   if (FoundByLookup) {
5942     auto *Recent =
5943         const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl());
5944     if (!TemplatedFD->getPreviousDecl()) {
5945       assert(FoundByLookup->getTemplatedDecl() &&
5946              "Found decl must have its templated decl set");
5947       auto *PrevTemplated =
5948           FoundByLookup->getTemplatedDecl()->getMostRecentDecl();
5949       if (TemplatedFD != PrevTemplated)
5950         TemplatedFD->setPreviousDecl(PrevTemplated);
5951     }
5952     ToFunc->setPreviousDecl(Recent);
5953   }
5954 
5955   return ToFunc;
5956 }
5957 
5958 //----------------------------------------------------------------------------
5959 // Import Statements
5960 //----------------------------------------------------------------------------
5961 
VisitStmt(Stmt * S)5962 ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
5963   Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node)
5964       << S->getStmtClassName();
5965   return make_error<ImportError>(ImportError::UnsupportedConstruct);
5966 }
5967 
5968 
VisitGCCAsmStmt(GCCAsmStmt * S)5969 ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
5970   if (Importer.returnWithErrorInTest())
5971     return make_error<ImportError>(ImportError::UnsupportedConstruct);
5972   SmallVector<IdentifierInfo *, 4> Names;
5973   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5974     IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I));
5975     // ToII is nullptr when no symbolic name is given for output operand
5976     // see ParseStmtAsm::ParseAsmOperandsOpt
5977     Names.push_back(ToII);
5978   }
5979 
5980   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
5981     IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I));
5982     // ToII is nullptr when no symbolic name is given for input operand
5983     // see ParseStmtAsm::ParseAsmOperandsOpt
5984     Names.push_back(ToII);
5985   }
5986 
5987   SmallVector<StringLiteral *, 4> Clobbers;
5988   for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) {
5989     if (auto ClobberOrErr = import(S->getClobberStringLiteral(I)))
5990       Clobbers.push_back(*ClobberOrErr);
5991     else
5992       return ClobberOrErr.takeError();
5993 
5994   }
5995 
5996   SmallVector<StringLiteral *, 4> Constraints;
5997   for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) {
5998     if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I)))
5999       Constraints.push_back(*OutputOrErr);
6000     else
6001       return OutputOrErr.takeError();
6002   }
6003 
6004   for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) {
6005     if (auto InputOrErr = import(S->getInputConstraintLiteral(I)))
6006       Constraints.push_back(*InputOrErr);
6007     else
6008       return InputOrErr.takeError();
6009   }
6010 
6011   SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() +
6012                                S->getNumLabels());
6013   if (Error Err = ImportContainerChecked(S->outputs(), Exprs))
6014     return std::move(Err);
6015 
6016   if (Error Err =
6017           ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs()))
6018     return std::move(Err);
6019 
6020   if (Error Err = ImportArrayChecked(
6021           S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs()))
6022     return std::move(Err);
6023 
6024   ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc());
6025   if (!AsmLocOrErr)
6026     return AsmLocOrErr.takeError();
6027   auto AsmStrOrErr = import(S->getAsmString());
6028   if (!AsmStrOrErr)
6029     return AsmStrOrErr.takeError();
6030   ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc());
6031   if (!RParenLocOrErr)
6032     return RParenLocOrErr.takeError();
6033 
6034   return new (Importer.getToContext()) GCCAsmStmt(
6035       Importer.getToContext(),
6036       *AsmLocOrErr,
6037       S->isSimple(),
6038       S->isVolatile(),
6039       S->getNumOutputs(),
6040       S->getNumInputs(),
6041       Names.data(),
6042       Constraints.data(),
6043       Exprs.data(),
6044       *AsmStrOrErr,
6045       S->getNumClobbers(),
6046       Clobbers.data(),
6047       S->getNumLabels(),
6048       *RParenLocOrErr);
6049 }
6050 
VisitDeclStmt(DeclStmt * S)6051 ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
6052 
6053   Error Err = Error::success();
6054   auto ToDG = importChecked(Err, S->getDeclGroup());
6055   auto ToBeginLoc = importChecked(Err, S->getBeginLoc());
6056   auto ToEndLoc = importChecked(Err, S->getEndLoc());
6057   if (Err)
6058     return std::move(Err);
6059   return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc);
6060 }
6061 
VisitNullStmt(NullStmt * S)6062 ExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) {
6063   ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
6064   if (!ToSemiLocOrErr)
6065     return ToSemiLocOrErr.takeError();
6066   return new (Importer.getToContext()) NullStmt(
6067       *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
6068 }
6069 
VisitCompoundStmt(CompoundStmt * S)6070 ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
6071   SmallVector<Stmt *, 8> ToStmts(S->size());
6072 
6073   if (Error Err = ImportContainerChecked(S->body(), ToStmts))
6074     return std::move(Err);
6075 
6076   ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc());
6077   if (!ToLBracLocOrErr)
6078     return ToLBracLocOrErr.takeError();
6079 
6080   ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc());
6081   if (!ToRBracLocOrErr)
6082     return ToRBracLocOrErr.takeError();
6083 
6084   return CompoundStmt::Create(
6085       Importer.getToContext(), ToStmts,
6086       *ToLBracLocOrErr, *ToRBracLocOrErr);
6087 }
6088 
VisitCaseStmt(CaseStmt * S)6089 ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
6090 
6091   Error Err = Error::success();
6092   auto ToLHS = importChecked(Err, S->getLHS());
6093   auto ToRHS = importChecked(Err, S->getRHS());
6094   auto ToSubStmt = importChecked(Err, S->getSubStmt());
6095   auto ToCaseLoc = importChecked(Err, S->getCaseLoc());
6096   auto ToEllipsisLoc = importChecked(Err, S->getEllipsisLoc());
6097   auto ToColonLoc = importChecked(Err, S->getColonLoc());
6098   if (Err)
6099     return std::move(Err);
6100 
6101   auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS,
6102                                   ToCaseLoc, ToEllipsisLoc, ToColonLoc);
6103   ToStmt->setSubStmt(ToSubStmt);
6104 
6105   return ToStmt;
6106 }
6107 
VisitDefaultStmt(DefaultStmt * S)6108 ExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) {
6109 
6110   Error Err = Error::success();
6111   auto ToDefaultLoc = importChecked(Err, S->getDefaultLoc());
6112   auto ToColonLoc = importChecked(Err, S->getColonLoc());
6113   auto ToSubStmt = importChecked(Err, S->getSubStmt());
6114   if (Err)
6115     return std::move(Err);
6116 
6117   return new (Importer.getToContext()) DefaultStmt(
6118     ToDefaultLoc, ToColonLoc, ToSubStmt);
6119 }
6120 
VisitLabelStmt(LabelStmt * S)6121 ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
6122 
6123   Error Err = Error::success();
6124   auto ToIdentLoc = importChecked(Err, S->getIdentLoc());
6125   auto ToLabelDecl = importChecked(Err, S->getDecl());
6126   auto ToSubStmt = importChecked(Err, S->getSubStmt());
6127   if (Err)
6128     return std::move(Err);
6129 
6130   return new (Importer.getToContext()) LabelStmt(
6131       ToIdentLoc, ToLabelDecl, ToSubStmt);
6132 }
6133 
VisitAttributedStmt(AttributedStmt * S)6134 ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
6135   ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
6136   if (!ToAttrLocOrErr)
6137     return ToAttrLocOrErr.takeError();
6138   ArrayRef<const Attr*> FromAttrs(S->getAttrs());
6139   SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
6140   if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
6141     return std::move(Err);
6142   ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6143   if (!ToSubStmtOrErr)
6144     return ToSubStmtOrErr.takeError();
6145 
6146   return AttributedStmt::Create(
6147       Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
6148 }
6149 
VisitIfStmt(IfStmt * S)6150 ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
6151 
6152   Error Err = Error::success();
6153   auto ToIfLoc = importChecked(Err, S->getIfLoc());
6154   auto ToInit = importChecked(Err, S->getInit());
6155   auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6156   auto ToCond = importChecked(Err, S->getCond());
6157   auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6158   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6159   auto ToThen = importChecked(Err, S->getThen());
6160   auto ToElseLoc = importChecked(Err, S->getElseLoc());
6161   auto ToElse = importChecked(Err, S->getElse());
6162   if (Err)
6163     return std::move(Err);
6164 
6165   return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(),
6166                         ToInit, ToConditionVariable, ToCond, ToLParenLoc,
6167                         ToRParenLoc, ToThen, ToElseLoc, ToElse);
6168 }
6169 
VisitSwitchStmt(SwitchStmt * S)6170 ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
6171 
6172   Error Err = Error::success();
6173   auto ToInit = importChecked(Err, S->getInit());
6174   auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6175   auto ToCond = importChecked(Err, S->getCond());
6176   auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6177   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6178   auto ToBody = importChecked(Err, S->getBody());
6179   auto ToSwitchLoc = importChecked(Err, S->getSwitchLoc());
6180   if (Err)
6181     return std::move(Err);
6182 
6183   auto *ToStmt =
6184       SwitchStmt::Create(Importer.getToContext(), ToInit, ToConditionVariable,
6185                          ToCond, ToLParenLoc, ToRParenLoc);
6186   ToStmt->setBody(ToBody);
6187   ToStmt->setSwitchLoc(ToSwitchLoc);
6188 
6189   // Now we have to re-chain the cases.
6190   SwitchCase *LastChainedSwitchCase = nullptr;
6191   for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr;
6192        SC = SC->getNextSwitchCase()) {
6193     Expected<SwitchCase *> ToSCOrErr = import(SC);
6194     if (!ToSCOrErr)
6195       return ToSCOrErr.takeError();
6196     if (LastChainedSwitchCase)
6197       LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr);
6198     else
6199       ToStmt->setSwitchCaseList(*ToSCOrErr);
6200     LastChainedSwitchCase = *ToSCOrErr;
6201   }
6202 
6203   return ToStmt;
6204 }
6205 
VisitWhileStmt(WhileStmt * S)6206 ExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) {
6207 
6208   Error Err = Error::success();
6209   auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6210   auto ToCond = importChecked(Err, S->getCond());
6211   auto ToBody = importChecked(Err, S->getBody());
6212   auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6213   auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6214   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6215   if (Err)
6216     return std::move(Err);
6217 
6218   return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond,
6219                            ToBody, ToWhileLoc, ToLParenLoc, ToRParenLoc);
6220 }
6221 
VisitDoStmt(DoStmt * S)6222 ExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) {
6223 
6224   Error Err = Error::success();
6225   auto ToBody = importChecked(Err, S->getBody());
6226   auto ToCond = importChecked(Err, S->getCond());
6227   auto ToDoLoc = importChecked(Err, S->getDoLoc());
6228   auto ToWhileLoc = importChecked(Err, S->getWhileLoc());
6229   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6230   if (Err)
6231     return std::move(Err);
6232 
6233   return new (Importer.getToContext()) DoStmt(
6234       ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
6235 }
6236 
VisitForStmt(ForStmt * S)6237 ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
6238 
6239   Error Err = Error::success();
6240   auto ToInit = importChecked(Err, S->getInit());
6241   auto ToCond = importChecked(Err, S->getCond());
6242   auto ToConditionVariable = importChecked(Err, S->getConditionVariable());
6243   auto ToInc = importChecked(Err, S->getInc());
6244   auto ToBody = importChecked(Err, S->getBody());
6245   auto ToForLoc = importChecked(Err, S->getForLoc());
6246   auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
6247   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6248   if (Err)
6249     return std::move(Err);
6250 
6251   return new (Importer.getToContext()) ForStmt(
6252       Importer.getToContext(),
6253       ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
6254       ToRParenLoc);
6255 }
6256 
VisitGotoStmt(GotoStmt * S)6257 ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
6258 
6259   Error Err = Error::success();
6260   auto ToLabel = importChecked(Err, S->getLabel());
6261   auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6262   auto ToLabelLoc = importChecked(Err, S->getLabelLoc());
6263   if (Err)
6264     return std::move(Err);
6265 
6266   return new (Importer.getToContext()) GotoStmt(
6267       ToLabel, ToGotoLoc, ToLabelLoc);
6268 }
6269 
VisitIndirectGotoStmt(IndirectGotoStmt * S)6270 ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
6271 
6272   Error Err = Error::success();
6273   auto ToGotoLoc = importChecked(Err, S->getGotoLoc());
6274   auto ToStarLoc = importChecked(Err, S->getStarLoc());
6275   auto ToTarget = importChecked(Err, S->getTarget());
6276   if (Err)
6277     return std::move(Err);
6278 
6279   return new (Importer.getToContext()) IndirectGotoStmt(
6280       ToGotoLoc, ToStarLoc, ToTarget);
6281 }
6282 
VisitContinueStmt(ContinueStmt * S)6283 ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
6284   ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc());
6285   if (!ToContinueLocOrErr)
6286     return ToContinueLocOrErr.takeError();
6287   return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr);
6288 }
6289 
VisitBreakStmt(BreakStmt * S)6290 ExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) {
6291   auto ToBreakLocOrErr = import(S->getBreakLoc());
6292   if (!ToBreakLocOrErr)
6293     return ToBreakLocOrErr.takeError();
6294   return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr);
6295 }
6296 
VisitReturnStmt(ReturnStmt * S)6297 ExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) {
6298 
6299   Error Err = Error::success();
6300   auto ToReturnLoc = importChecked(Err, S->getReturnLoc());
6301   auto ToRetValue = importChecked(Err, S->getRetValue());
6302   auto ToNRVOCandidate = importChecked(Err, S->getNRVOCandidate());
6303   if (Err)
6304     return std::move(Err);
6305 
6306   return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue,
6307                             ToNRVOCandidate);
6308 }
6309 
VisitCXXCatchStmt(CXXCatchStmt * S)6310 ExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) {
6311 
6312   Error Err = Error::success();
6313   auto ToCatchLoc = importChecked(Err, S->getCatchLoc());
6314   auto ToExceptionDecl = importChecked(Err, S->getExceptionDecl());
6315   auto ToHandlerBlock = importChecked(Err, S->getHandlerBlock());
6316   if (Err)
6317     return std::move(Err);
6318 
6319   return new (Importer.getToContext()) CXXCatchStmt (
6320       ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
6321 }
6322 
VisitCXXTryStmt(CXXTryStmt * S)6323 ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
6324   ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc());
6325   if (!ToTryLocOrErr)
6326     return ToTryLocOrErr.takeError();
6327 
6328   ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock());
6329   if (!ToTryBlockOrErr)
6330     return ToTryBlockOrErr.takeError();
6331 
6332   SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
6333   for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) {
6334     CXXCatchStmt *FromHandler = S->getHandler(HI);
6335     if (auto ToHandlerOrErr = import(FromHandler))
6336       ToHandlers[HI] = *ToHandlerOrErr;
6337     else
6338       return ToHandlerOrErr.takeError();
6339   }
6340 
6341   return CXXTryStmt::Create(
6342       Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
6343 }
6344 
VisitCXXForRangeStmt(CXXForRangeStmt * S)6345 ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
6346 
6347   Error Err = Error::success();
6348   auto ToInit = importChecked(Err, S->getInit());
6349   auto ToRangeStmt = importChecked(Err, S->getRangeStmt());
6350   auto ToBeginStmt = importChecked(Err, S->getBeginStmt());
6351   auto ToEndStmt = importChecked(Err, S->getEndStmt());
6352   auto ToCond = importChecked(Err, S->getCond());
6353   auto ToInc = importChecked(Err, S->getInc());
6354   auto ToLoopVarStmt = importChecked(Err, S->getLoopVarStmt());
6355   auto ToBody = importChecked(Err, S->getBody());
6356   auto ToForLoc = importChecked(Err, S->getForLoc());
6357   auto ToCoawaitLoc = importChecked(Err, S->getCoawaitLoc());
6358   auto ToColonLoc = importChecked(Err, S->getColonLoc());
6359   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6360   if (Err)
6361     return std::move(Err);
6362 
6363   return new (Importer.getToContext()) CXXForRangeStmt(
6364       ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt,
6365       ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc);
6366 }
6367 
6368 ExpectedStmt
VisitObjCForCollectionStmt(ObjCForCollectionStmt * S)6369 ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
6370   Error Err = Error::success();
6371   auto ToElement = importChecked(Err, S->getElement());
6372   auto ToCollection = importChecked(Err, S->getCollection());
6373   auto ToBody = importChecked(Err, S->getBody());
6374   auto ToForLoc = importChecked(Err, S->getForLoc());
6375   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6376   if (Err)
6377     return std::move(Err);
6378 
6379   return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
6380                                                              ToCollection,
6381                                                              ToBody,
6382                                                              ToForLoc,
6383                                                              ToRParenLoc);
6384 }
6385 
VisitObjCAtCatchStmt(ObjCAtCatchStmt * S)6386 ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
6387 
6388   Error Err = Error::success();
6389   auto ToAtCatchLoc = importChecked(Err, S->getAtCatchLoc());
6390   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
6391   auto ToCatchParamDecl = importChecked(Err, S->getCatchParamDecl());
6392   auto ToCatchBody = importChecked(Err, S->getCatchBody());
6393   if (Err)
6394     return std::move(Err);
6395 
6396   return new (Importer.getToContext()) ObjCAtCatchStmt (
6397       ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
6398 }
6399 
VisitObjCAtFinallyStmt(ObjCAtFinallyStmt * S)6400 ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
6401   ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc());
6402   if (!ToAtFinallyLocOrErr)
6403     return ToAtFinallyLocOrErr.takeError();
6404   ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
6405   if (!ToAtFinallyStmtOrErr)
6406     return ToAtFinallyStmtOrErr.takeError();
6407   return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
6408                                                          *ToAtFinallyStmtOrErr);
6409 }
6410 
VisitObjCAtTryStmt(ObjCAtTryStmt * S)6411 ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
6412 
6413   Error Err = Error::success();
6414   auto ToAtTryLoc = importChecked(Err, S->getAtTryLoc());
6415   auto ToTryBody = importChecked(Err, S->getTryBody());
6416   auto ToFinallyStmt = importChecked(Err, S->getFinallyStmt());
6417   if (Err)
6418     return std::move(Err);
6419 
6420   SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
6421   for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) {
6422     ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI);
6423     if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt))
6424       ToCatchStmts[CI] = *ToCatchStmtOrErr;
6425     else
6426       return ToCatchStmtOrErr.takeError();
6427   }
6428 
6429   return ObjCAtTryStmt::Create(Importer.getToContext(),
6430                                ToAtTryLoc, ToTryBody,
6431                                ToCatchStmts.begin(), ToCatchStmts.size(),
6432                                ToFinallyStmt);
6433 }
6434 
6435 ExpectedStmt
VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt * S)6436 ASTNodeImporter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
6437 
6438   Error Err = Error::success();
6439   auto ToAtSynchronizedLoc = importChecked(Err, S->getAtSynchronizedLoc());
6440   auto ToSynchExpr = importChecked(Err, S->getSynchExpr());
6441   auto ToSynchBody = importChecked(Err, S->getSynchBody());
6442   if (Err)
6443     return std::move(Err);
6444 
6445   return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
6446     ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
6447 }
6448 
VisitObjCAtThrowStmt(ObjCAtThrowStmt * S)6449 ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
6450   ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc());
6451   if (!ToThrowLocOrErr)
6452     return ToThrowLocOrErr.takeError();
6453   ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
6454   if (!ToThrowExprOrErr)
6455     return ToThrowExprOrErr.takeError();
6456   return new (Importer.getToContext()) ObjCAtThrowStmt(
6457       *ToThrowLocOrErr, *ToThrowExprOrErr);
6458 }
6459 
VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt * S)6460 ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
6461     ObjCAutoreleasePoolStmt *S) {
6462   ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
6463   if (!ToAtLocOrErr)
6464     return ToAtLocOrErr.takeError();
6465   ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
6466   if (!ToSubStmtOrErr)
6467     return ToSubStmtOrErr.takeError();
6468   return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
6469                                                                *ToSubStmtOrErr);
6470 }
6471 
6472 //----------------------------------------------------------------------------
6473 // Import Expressions
6474 //----------------------------------------------------------------------------
VisitExpr(Expr * E)6475 ExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {
6476   Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node)
6477       << E->getStmtClassName();
6478   return make_error<ImportError>(ImportError::UnsupportedConstruct);
6479 }
6480 
VisitVAArgExpr(VAArgExpr * E)6481 ExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) {
6482 
6483   Error Err = Error::success();
6484   auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6485   auto ToSubExpr = importChecked(Err, E->getSubExpr());
6486   auto ToWrittenTypeInfo = importChecked(Err, E->getWrittenTypeInfo());
6487   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6488   auto ToType = importChecked(Err, E->getType());
6489   if (Err)
6490     return std::move(Err);
6491 
6492   return new (Importer.getToContext()) VAArgExpr(
6493       ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
6494       E->isMicrosoftABI());
6495 }
6496 
VisitChooseExpr(ChooseExpr * E)6497 ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
6498 
6499   Error Err = Error::success();
6500   auto ToCond = importChecked(Err, E->getCond());
6501   auto ToLHS = importChecked(Err, E->getLHS());
6502   auto ToRHS = importChecked(Err, E->getRHS());
6503   auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6504   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6505   auto ToType = importChecked(Err, E->getType());
6506   if (Err)
6507     return std::move(Err);
6508 
6509   ExprValueKind VK = E->getValueKind();
6510   ExprObjectKind OK = E->getObjectKind();
6511 
6512   // The value of CondIsTrue only matters if the value is not
6513   // condition-dependent.
6514   bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue();
6515 
6516   return new (Importer.getToContext())
6517       ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK,
6518                  ToRParenLoc, CondIsTrue);
6519 }
6520 
VisitGNUNullExpr(GNUNullExpr * E)6521 ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
6522   ExpectedType TypeOrErr = import(E->getType());
6523   if (!TypeOrErr)
6524     return TypeOrErr.takeError();
6525 
6526   ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
6527   if (!BeginLocOrErr)
6528     return BeginLocOrErr.takeError();
6529 
6530   return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
6531 }
6532 
6533 ExpectedStmt
VisitGenericSelectionExpr(GenericSelectionExpr * E)6534 ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
6535   Error Err = Error::success();
6536   auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
6537   auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
6538   auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
6539   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6540   if (Err)
6541     return std::move(Err);
6542 
6543   ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
6544   SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
6545   if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
6546     return std::move(Err);
6547 
6548   ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
6549   SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
6550   if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
6551     return std::move(Err);
6552 
6553   const ASTContext &ToCtx = Importer.getToContext();
6554   if (E->isResultDependent()) {
6555     return GenericSelectionExpr::Create(
6556         ToCtx, ToGenericLoc, ToControllingExpr,
6557         llvm::makeArrayRef(ToAssocTypes), llvm::makeArrayRef(ToAssocExprs),
6558         ToDefaultLoc, ToRParenLoc, E->containsUnexpandedParameterPack());
6559   }
6560 
6561   return GenericSelectionExpr::Create(
6562       ToCtx, ToGenericLoc, ToControllingExpr, llvm::makeArrayRef(ToAssocTypes),
6563       llvm::makeArrayRef(ToAssocExprs), ToDefaultLoc, ToRParenLoc,
6564       E->containsUnexpandedParameterPack(), E->getResultIndex());
6565 }
6566 
VisitPredefinedExpr(PredefinedExpr * E)6567 ExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) {
6568 
6569   Error Err = Error::success();
6570   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6571   auto ToType = importChecked(Err, E->getType());
6572   auto ToFunctionName = importChecked(Err, E->getFunctionName());
6573   if (Err)
6574     return std::move(Err);
6575 
6576   return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType,
6577                                 E->getIdentKind(), ToFunctionName);
6578 }
6579 
VisitDeclRefExpr(DeclRefExpr * E)6580 ExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) {
6581 
6582   Error Err = Error::success();
6583   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
6584   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
6585   auto ToDecl = importChecked(Err, E->getDecl());
6586   auto ToLocation = importChecked(Err, E->getLocation());
6587   auto ToType = importChecked(Err, E->getType());
6588   if (Err)
6589     return std::move(Err);
6590 
6591   NamedDecl *ToFoundD = nullptr;
6592   if (E->getDecl() != E->getFoundDecl()) {
6593     auto FoundDOrErr = import(E->getFoundDecl());
6594     if (!FoundDOrErr)
6595       return FoundDOrErr.takeError();
6596     ToFoundD = *FoundDOrErr;
6597   }
6598 
6599   TemplateArgumentListInfo ToTAInfo;
6600   TemplateArgumentListInfo *ToResInfo = nullptr;
6601   if (E->hasExplicitTemplateArgs()) {
6602     if (Error Err =
6603             ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
6604                                            E->template_arguments(), ToTAInfo))
6605       return std::move(Err);
6606     ToResInfo = &ToTAInfo;
6607   }
6608 
6609   auto *ToE = DeclRefExpr::Create(
6610       Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl,
6611       E->refersToEnclosingVariableOrCapture(), ToLocation, ToType,
6612       E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse());
6613   if (E->hadMultipleCandidates())
6614     ToE->setHadMultipleCandidates(true);
6615   return ToE;
6616 }
6617 
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)6618 ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
6619   ExpectedType TypeOrErr = import(E->getType());
6620   if (!TypeOrErr)
6621     return TypeOrErr.takeError();
6622 
6623   return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr);
6624 }
6625 
VisitDesignatedInitExpr(DesignatedInitExpr * E)6626 ExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
6627   ExpectedExpr ToInitOrErr = import(E->getInit());
6628   if (!ToInitOrErr)
6629     return ToInitOrErr.takeError();
6630 
6631   ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc());
6632   if (!ToEqualOrColonLocOrErr)
6633     return ToEqualOrColonLocOrErr.takeError();
6634 
6635   SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1);
6636   // List elements from the second, the first is Init itself
6637   for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) {
6638     if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I)))
6639       ToIndexExprs[I - 1] = *ToArgOrErr;
6640     else
6641       return ToArgOrErr.takeError();
6642   }
6643 
6644   SmallVector<Designator, 4> ToDesignators(E->size());
6645   if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
6646     return std::move(Err);
6647 
6648   return DesignatedInitExpr::Create(
6649         Importer.getToContext(), ToDesignators,
6650         ToIndexExprs, *ToEqualOrColonLocOrErr,
6651         E->usesGNUSyntax(), *ToInitOrErr);
6652 }
6653 
6654 ExpectedStmt
VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr * E)6655 ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
6656   ExpectedType ToTypeOrErr = import(E->getType());
6657   if (!ToTypeOrErr)
6658     return ToTypeOrErr.takeError();
6659 
6660   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6661   if (!ToLocationOrErr)
6662     return ToLocationOrErr.takeError();
6663 
6664   return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
6665       *ToTypeOrErr, *ToLocationOrErr);
6666 }
6667 
VisitIntegerLiteral(IntegerLiteral * E)6668 ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
6669   ExpectedType ToTypeOrErr = import(E->getType());
6670   if (!ToTypeOrErr)
6671     return ToTypeOrErr.takeError();
6672 
6673   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6674   if (!ToLocationOrErr)
6675     return ToLocationOrErr.takeError();
6676 
6677   return IntegerLiteral::Create(
6678       Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
6679 }
6680 
6681 
VisitFloatingLiteral(FloatingLiteral * E)6682 ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
6683   ExpectedType ToTypeOrErr = import(E->getType());
6684   if (!ToTypeOrErr)
6685     return ToTypeOrErr.takeError();
6686 
6687   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6688   if (!ToLocationOrErr)
6689     return ToLocationOrErr.takeError();
6690 
6691   return FloatingLiteral::Create(
6692       Importer.getToContext(), E->getValue(), E->isExact(),
6693       *ToTypeOrErr, *ToLocationOrErr);
6694 }
6695 
VisitImaginaryLiteral(ImaginaryLiteral * E)6696 ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
6697   auto ToTypeOrErr = import(E->getType());
6698   if (!ToTypeOrErr)
6699     return ToTypeOrErr.takeError();
6700 
6701   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
6702   if (!ToSubExprOrErr)
6703     return ToSubExprOrErr.takeError();
6704 
6705   return new (Importer.getToContext()) ImaginaryLiteral(
6706       *ToSubExprOrErr, *ToTypeOrErr);
6707 }
6708 
VisitFixedPointLiteral(FixedPointLiteral * E)6709 ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
6710   auto ToTypeOrErr = import(E->getType());
6711   if (!ToTypeOrErr)
6712     return ToTypeOrErr.takeError();
6713 
6714   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6715   if (!ToLocationOrErr)
6716     return ToLocationOrErr.takeError();
6717 
6718   return new (Importer.getToContext()) FixedPointLiteral(
6719       Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr,
6720       Importer.getToContext().getFixedPointScale(*ToTypeOrErr));
6721 }
6722 
VisitCharacterLiteral(CharacterLiteral * E)6723 ExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) {
6724   ExpectedType ToTypeOrErr = import(E->getType());
6725   if (!ToTypeOrErr)
6726     return ToTypeOrErr.takeError();
6727 
6728   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
6729   if (!ToLocationOrErr)
6730     return ToLocationOrErr.takeError();
6731 
6732   return new (Importer.getToContext()) CharacterLiteral(
6733       E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr);
6734 }
6735 
VisitStringLiteral(StringLiteral * E)6736 ExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) {
6737   ExpectedType ToTypeOrErr = import(E->getType());
6738   if (!ToTypeOrErr)
6739     return ToTypeOrErr.takeError();
6740 
6741   SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
6742   if (Error Err = ImportArrayChecked(
6743       E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
6744     return std::move(Err);
6745 
6746   return StringLiteral::Create(
6747       Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
6748       *ToTypeOrErr, ToLocations.data(), ToLocations.size());
6749 }
6750 
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)6751 ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
6752 
6753   Error Err = Error::success();
6754   auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
6755   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
6756   auto ToType = importChecked(Err, E->getType());
6757   auto ToInitializer = importChecked(Err, E->getInitializer());
6758   if (Err)
6759     return std::move(Err);
6760 
6761   return new (Importer.getToContext()) CompoundLiteralExpr(
6762         ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
6763         ToInitializer, E->isFileScope());
6764 }
6765 
VisitAtomicExpr(AtomicExpr * E)6766 ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
6767 
6768   Error Err = Error::success();
6769   auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc());
6770   auto ToType = importChecked(Err, E->getType());
6771   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6772   if (Err)
6773     return std::move(Err);
6774 
6775   SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
6776   if (Error Err = ImportArrayChecked(
6777       E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
6778       ToExprs.begin()))
6779     return std::move(Err);
6780 
6781   return new (Importer.getToContext()) AtomicExpr(
6782 
6783       ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc);
6784 }
6785 
VisitAddrLabelExpr(AddrLabelExpr * E)6786 ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
6787   Error Err = Error::success();
6788   auto ToAmpAmpLoc = importChecked(Err, E->getAmpAmpLoc());
6789   auto ToLabelLoc = importChecked(Err, E->getLabelLoc());
6790   auto ToLabel = importChecked(Err, E->getLabel());
6791   auto ToType = importChecked(Err, E->getType());
6792   if (Err)
6793     return std::move(Err);
6794 
6795   return new (Importer.getToContext()) AddrLabelExpr(
6796       ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
6797 }
VisitConstantExpr(ConstantExpr * E)6798 ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
6799   Error Err = Error::success();
6800   auto ToSubExpr = importChecked(Err, E->getSubExpr());
6801   auto ToResult = importChecked(Err, E->getAPValueResult());
6802   if (Err)
6803     return std::move(Err);
6804 
6805   return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, ToResult);
6806 }
VisitParenExpr(ParenExpr * E)6807 ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
6808   Error Err = Error::success();
6809   auto ToLParen = importChecked(Err, E->getLParen());
6810   auto ToRParen = importChecked(Err, E->getRParen());
6811   auto ToSubExpr = importChecked(Err, E->getSubExpr());
6812   if (Err)
6813     return std::move(Err);
6814 
6815   return new (Importer.getToContext())
6816       ParenExpr(ToLParen, ToRParen, ToSubExpr);
6817 }
6818 
VisitParenListExpr(ParenListExpr * E)6819 ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
6820   SmallVector<Expr *, 4> ToExprs(E->getNumExprs());
6821   if (Error Err = ImportContainerChecked(E->exprs(), ToExprs))
6822     return std::move(Err);
6823 
6824   ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc());
6825   if (!ToLParenLocOrErr)
6826     return ToLParenLocOrErr.takeError();
6827 
6828   ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc());
6829   if (!ToRParenLocOrErr)
6830     return ToRParenLocOrErr.takeError();
6831 
6832   return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr,
6833                                ToExprs, *ToRParenLocOrErr);
6834 }
6835 
VisitStmtExpr(StmtExpr * E)6836 ExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) {
6837   Error Err = Error::success();
6838   auto ToSubStmt = importChecked(Err, E->getSubStmt());
6839   auto ToType = importChecked(Err, E->getType());
6840   auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
6841   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6842   if (Err)
6843     return std::move(Err);
6844 
6845   return new (Importer.getToContext())
6846       StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
6847                E->getTemplateDepth());
6848 }
6849 
VisitUnaryOperator(UnaryOperator * E)6850 ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
6851   Error Err = Error::success();
6852   auto ToSubExpr = importChecked(Err, E->getSubExpr());
6853   auto ToType = importChecked(Err, E->getType());
6854   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6855   if (Err)
6856     return std::move(Err);
6857 
6858   return UnaryOperator::Create(
6859       Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
6860       E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
6861       E->getFPOptionsOverride());
6862 }
6863 
6864 ExpectedStmt
6865 
VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)6866 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
6867   Error Err = Error::success();
6868   auto ToType = importChecked(Err, E->getType());
6869   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6870   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
6871   if (Err)
6872     return std::move(Err);
6873 
6874   if (E->isArgumentType()) {
6875     Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr =
6876         import(E->getArgumentTypeInfo());
6877     if (!ToArgumentTypeInfoOrErr)
6878       return ToArgumentTypeInfoOrErr.takeError();
6879 
6880     return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
6881         E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
6882         ToRParenLoc);
6883   }
6884 
6885   ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
6886   if (!ToArgumentExprOrErr)
6887     return ToArgumentExprOrErr.takeError();
6888 
6889   return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
6890       E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc);
6891 }
6892 
VisitBinaryOperator(BinaryOperator * E)6893 ExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) {
6894   Error Err = Error::success();
6895   auto ToLHS = importChecked(Err, E->getLHS());
6896   auto ToRHS = importChecked(Err, E->getRHS());
6897   auto ToType = importChecked(Err, E->getType());
6898   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
6899   if (Err)
6900     return std::move(Err);
6901 
6902   return BinaryOperator::Create(
6903       Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
6904       E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
6905       E->getFPFeatures(Importer.getFromContext().getLangOpts()));
6906 }
6907 
VisitConditionalOperator(ConditionalOperator * E)6908 ExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) {
6909   Error Err = Error::success();
6910   auto ToCond = importChecked(Err, E->getCond());
6911   auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
6912   auto ToLHS = importChecked(Err, E->getLHS());
6913   auto ToColonLoc = importChecked(Err, E->getColonLoc());
6914   auto ToRHS = importChecked(Err, E->getRHS());
6915   auto ToType = importChecked(Err, E->getType());
6916   if (Err)
6917     return std::move(Err);
6918 
6919   return new (Importer.getToContext()) ConditionalOperator(
6920       ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
6921       E->getValueKind(), E->getObjectKind());
6922 }
6923 
6924 ExpectedStmt
VisitBinaryConditionalOperator(BinaryConditionalOperator * E)6925 ASTNodeImporter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
6926   Error Err = Error::success();
6927   auto ToCommon = importChecked(Err, E->getCommon());
6928   auto ToOpaqueValue = importChecked(Err, E->getOpaqueValue());
6929   auto ToCond = importChecked(Err, E->getCond());
6930   auto ToTrueExpr = importChecked(Err, E->getTrueExpr());
6931   auto ToFalseExpr = importChecked(Err, E->getFalseExpr());
6932   auto ToQuestionLoc = importChecked(Err, E->getQuestionLoc());
6933   auto ToColonLoc = importChecked(Err, E->getColonLoc());
6934   auto ToType = importChecked(Err, E->getType());
6935   if (Err)
6936     return std::move(Err);
6937 
6938   return new (Importer.getToContext()) BinaryConditionalOperator(
6939       ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
6940       ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
6941       E->getObjectKind());
6942 }
6943 
VisitArrayTypeTraitExpr(ArrayTypeTraitExpr * E)6944 ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
6945   Error Err = Error::success();
6946   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6947   auto ToQueriedTypeSourceInfo =
6948       importChecked(Err, E->getQueriedTypeSourceInfo());
6949   auto ToDimensionExpression = importChecked(Err, E->getDimensionExpression());
6950   auto ToEndLoc = importChecked(Err, E->getEndLoc());
6951   auto ToType = importChecked(Err, E->getType());
6952   if (Err)
6953     return std::move(Err);
6954 
6955   return new (Importer.getToContext()) ArrayTypeTraitExpr(
6956       ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(),
6957       ToDimensionExpression, ToEndLoc, ToType);
6958 }
6959 
VisitExpressionTraitExpr(ExpressionTraitExpr * E)6960 ExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
6961   Error Err = Error::success();
6962   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
6963   auto ToQueriedExpression = importChecked(Err, E->getQueriedExpression());
6964   auto ToEndLoc = importChecked(Err, E->getEndLoc());
6965   auto ToType = importChecked(Err, E->getType());
6966   if (Err)
6967     return std::move(Err);
6968 
6969   return new (Importer.getToContext()) ExpressionTraitExpr(
6970       ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
6971       ToEndLoc, ToType);
6972 }
6973 
VisitOpaqueValueExpr(OpaqueValueExpr * E)6974 ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
6975   Error Err = Error::success();
6976   auto ToLocation = importChecked(Err, E->getLocation());
6977   auto ToType = importChecked(Err, E->getType());
6978   auto ToSourceExpr = importChecked(Err, E->getSourceExpr());
6979   if (Err)
6980     return std::move(Err);
6981 
6982   return new (Importer.getToContext()) OpaqueValueExpr(
6983       ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr);
6984 }
6985 
VisitArraySubscriptExpr(ArraySubscriptExpr * E)6986 ExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
6987   Error Err = Error::success();
6988   auto ToLHS = importChecked(Err, E->getLHS());
6989   auto ToRHS = importChecked(Err, E->getRHS());
6990   auto ToType = importChecked(Err, E->getType());
6991   auto ToRBracketLoc = importChecked(Err, E->getRBracketLoc());
6992   if (Err)
6993     return std::move(Err);
6994 
6995   return new (Importer.getToContext()) ArraySubscriptExpr(
6996       ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
6997       ToRBracketLoc);
6998 }
6999 
7000 ExpectedStmt
VisitCompoundAssignOperator(CompoundAssignOperator * E)7001 ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
7002   Error Err = Error::success();
7003   auto ToLHS = importChecked(Err, E->getLHS());
7004   auto ToRHS = importChecked(Err, E->getRHS());
7005   auto ToType = importChecked(Err, E->getType());
7006   auto ToComputationLHSType = importChecked(Err, E->getComputationLHSType());
7007   auto ToComputationResultType =
7008       importChecked(Err, E->getComputationResultType());
7009   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7010   if (Err)
7011     return std::move(Err);
7012 
7013   return CompoundAssignOperator::Create(
7014       Importer.getToContext(), ToLHS, ToRHS, E->getOpcode(), ToType,
7015       E->getValueKind(), E->getObjectKind(), ToOperatorLoc,
7016       E->getFPFeatures(Importer.getFromContext().getLangOpts()),
7017       ToComputationLHSType, ToComputationResultType);
7018 }
7019 
7020 Expected<CXXCastPath>
ImportCastPath(CastExpr * CE)7021 ASTNodeImporter::ImportCastPath(CastExpr *CE) {
7022   CXXCastPath Path;
7023   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
7024     if (auto SpecOrErr = import(*I))
7025       Path.push_back(*SpecOrErr);
7026     else
7027       return SpecOrErr.takeError();
7028   }
7029   return Path;
7030 }
7031 
VisitImplicitCastExpr(ImplicitCastExpr * E)7032 ExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
7033   ExpectedType ToTypeOrErr = import(E->getType());
7034   if (!ToTypeOrErr)
7035     return ToTypeOrErr.takeError();
7036 
7037   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7038   if (!ToSubExprOrErr)
7039     return ToSubExprOrErr.takeError();
7040 
7041   Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7042   if (!ToBasePathOrErr)
7043     return ToBasePathOrErr.takeError();
7044 
7045   return ImplicitCastExpr::Create(
7046       Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr,
7047       &(*ToBasePathOrErr), E->getValueKind(), E->getFPFeatures());
7048 }
7049 
VisitExplicitCastExpr(ExplicitCastExpr * E)7050 ExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
7051   Error Err = Error::success();
7052   auto ToType = importChecked(Err, E->getType());
7053   auto ToSubExpr = importChecked(Err, E->getSubExpr());
7054   auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7055   if (Err)
7056     return std::move(Err);
7057 
7058   Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E);
7059   if (!ToBasePathOrErr)
7060     return ToBasePathOrErr.takeError();
7061   CXXCastPath *ToBasePath = &(*ToBasePathOrErr);
7062 
7063   switch (E->getStmtClass()) {
7064   case Stmt::CStyleCastExprClass: {
7065     auto *CCE = cast<CStyleCastExpr>(E);
7066     ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc());
7067     if (!ToLParenLocOrErr)
7068       return ToLParenLocOrErr.takeError();
7069     ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc());
7070     if (!ToRParenLocOrErr)
7071       return ToRParenLocOrErr.takeError();
7072     return CStyleCastExpr::Create(
7073         Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(),
7074         ToSubExpr, ToBasePath, CCE->getFPFeatures(), ToTypeInfoAsWritten,
7075         *ToLParenLocOrErr, *ToRParenLocOrErr);
7076   }
7077 
7078   case Stmt::CXXFunctionalCastExprClass: {
7079     auto *FCE = cast<CXXFunctionalCastExpr>(E);
7080     ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc());
7081     if (!ToLParenLocOrErr)
7082       return ToLParenLocOrErr.takeError();
7083     ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc());
7084     if (!ToRParenLocOrErr)
7085       return ToRParenLocOrErr.takeError();
7086     return CXXFunctionalCastExpr::Create(
7087         Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten,
7088         E->getCastKind(), ToSubExpr, ToBasePath, FCE->getFPFeatures(),
7089         *ToLParenLocOrErr, *ToRParenLocOrErr);
7090   }
7091 
7092   case Stmt::ObjCBridgedCastExprClass: {
7093     auto *OCE = cast<ObjCBridgedCastExpr>(E);
7094     ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc());
7095     if (!ToLParenLocOrErr)
7096       return ToLParenLocOrErr.takeError();
7097     ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc());
7098     if (!ToBridgeKeywordLocOrErr)
7099       return ToBridgeKeywordLocOrErr.takeError();
7100     return new (Importer.getToContext()) ObjCBridgedCastExpr(
7101         *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(),
7102         *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr);
7103   }
7104   default:
7105     llvm_unreachable("Cast expression of unsupported type!");
7106     return make_error<ImportError>(ImportError::UnsupportedConstruct);
7107   }
7108 }
7109 
VisitOffsetOfExpr(OffsetOfExpr * E)7110 ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
7111   SmallVector<OffsetOfNode, 4> ToNodes;
7112   for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
7113     const OffsetOfNode &FromNode = E->getComponent(I);
7114 
7115     SourceLocation ToBeginLoc, ToEndLoc;
7116 
7117     if (FromNode.getKind() != OffsetOfNode::Base) {
7118       Error Err = Error::success();
7119       ToBeginLoc = importChecked(Err, FromNode.getBeginLoc());
7120       ToEndLoc = importChecked(Err, FromNode.getEndLoc());
7121       if (Err)
7122         return std::move(Err);
7123     }
7124 
7125     switch (FromNode.getKind()) {
7126     case OffsetOfNode::Array:
7127       ToNodes.push_back(
7128           OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc));
7129       break;
7130     case OffsetOfNode::Base: {
7131       auto ToBSOrErr = import(FromNode.getBase());
7132       if (!ToBSOrErr)
7133         return ToBSOrErr.takeError();
7134       ToNodes.push_back(OffsetOfNode(*ToBSOrErr));
7135       break;
7136     }
7137     case OffsetOfNode::Field: {
7138       auto ToFieldOrErr = import(FromNode.getField());
7139       if (!ToFieldOrErr)
7140         return ToFieldOrErr.takeError();
7141       ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc));
7142       break;
7143     }
7144     case OffsetOfNode::Identifier: {
7145       IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName());
7146       ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc));
7147       break;
7148     }
7149     }
7150   }
7151 
7152   SmallVector<Expr *, 4> ToExprs(E->getNumExpressions());
7153   for (int I = 0, N = E->getNumExpressions(); I < N; ++I) {
7154     ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I));
7155     if (!ToIndexExprOrErr)
7156       return ToIndexExprOrErr.takeError();
7157     ToExprs[I] = *ToIndexExprOrErr;
7158   }
7159 
7160   Error Err = Error::success();
7161   auto ToType = importChecked(Err, E->getType());
7162   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7163   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7164   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7165   if (Err)
7166     return std::move(Err);
7167 
7168   return OffsetOfExpr::Create(
7169       Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
7170       ToExprs, ToRParenLoc);
7171 }
7172 
VisitCXXNoexceptExpr(CXXNoexceptExpr * E)7173 ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
7174   Error Err = Error::success();
7175   auto ToType = importChecked(Err, E->getType());
7176   auto ToOperand = importChecked(Err, E->getOperand());
7177   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7178   auto ToEndLoc = importChecked(Err, E->getEndLoc());
7179   if (Err)
7180     return std::move(Err);
7181 
7182   CanThrowResult ToCanThrow;
7183   if (E->isValueDependent())
7184     ToCanThrow = CT_Dependent;
7185   else
7186     ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
7187 
7188   return new (Importer.getToContext()) CXXNoexceptExpr(
7189       ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
7190 }
7191 
VisitCXXThrowExpr(CXXThrowExpr * E)7192 ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
7193   Error Err = Error::success();
7194   auto ToSubExpr = importChecked(Err, E->getSubExpr());
7195   auto ToType = importChecked(Err, E->getType());
7196   auto ToThrowLoc = importChecked(Err, E->getThrowLoc());
7197   if (Err)
7198     return std::move(Err);
7199 
7200   return new (Importer.getToContext()) CXXThrowExpr(
7201       ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
7202 }
7203 
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * E)7204 ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
7205   ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation());
7206   if (!ToUsedLocOrErr)
7207     return ToUsedLocOrErr.takeError();
7208 
7209   auto ToParamOrErr = import(E->getParam());
7210   if (!ToParamOrErr)
7211     return ToParamOrErr.takeError();
7212 
7213   auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
7214   if (!UsedContextOrErr)
7215     return UsedContextOrErr.takeError();
7216 
7217   // Import the default arg if it was not imported yet.
7218   // This is needed because it can happen that during the import of the
7219   // default expression (from VisitParmVarDecl) the same ParmVarDecl is
7220   // encountered here. The default argument for a ParmVarDecl is set in the
7221   // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here,
7222   // see VisitParmVarDecl).
7223   ParmVarDecl *ToParam = *ToParamOrErr;
7224   if (!ToParam->getDefaultArg()) {
7225     Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
7226     assert(FromParam && "ParmVarDecl was not imported?");
7227 
7228     if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam))
7229       return std::move(Err);
7230   }
7231 
7232   return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr,
7233                                    *ToParamOrErr, *UsedContextOrErr);
7234 }
7235 
7236 ExpectedStmt
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)7237 ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
7238   Error Err = Error::success();
7239   auto ToType = importChecked(Err, E->getType());
7240   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7241   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7242   if (Err)
7243     return std::move(Err);
7244 
7245   return new (Importer.getToContext()) CXXScalarValueInitExpr(
7246       ToType, ToTypeSourceInfo, ToRParenLoc);
7247 }
7248 
7249 ExpectedStmt
VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr * E)7250 ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
7251   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7252   if (!ToSubExprOrErr)
7253     return ToSubExprOrErr.takeError();
7254 
7255   auto ToDtorOrErr = import(E->getTemporary()->getDestructor());
7256   if (!ToDtorOrErr)
7257     return ToDtorOrErr.takeError();
7258 
7259   ASTContext &ToCtx = Importer.getToContext();
7260   CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr);
7261   return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr);
7262 }
7263 
7264 ExpectedStmt
7265 
VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr * E)7266 ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
7267   Error Err = Error::success();
7268   auto ToConstructor = importChecked(Err, E->getConstructor());
7269   auto ToType = importChecked(Err, E->getType());
7270   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7271   auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7272   if (Err)
7273     return std::move(Err);
7274 
7275   SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7276   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7277     return std::move(Err);
7278 
7279   return CXXTemporaryObjectExpr::Create(
7280       Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs,
7281       ToParenOrBraceRange, E->hadMultipleCandidates(),
7282       E->isListInitialization(), E->isStdInitListInitialization(),
7283       E->requiresZeroInitialization());
7284 }
7285 
VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl * D)7286 ExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl(
7287     LifetimeExtendedTemporaryDecl *D) {
7288   DeclContext *DC, *LexicalDC;
7289   if (Error Err = ImportDeclContext(D, DC, LexicalDC))
7290     return std::move(Err);
7291 
7292   Error Err = Error::success();
7293   auto Temporary = importChecked(Err, D->getTemporaryExpr());
7294   auto ExtendingDecl = importChecked(Err, D->getExtendingDecl());
7295   if (Err)
7296     return std::move(Err);
7297   // FIXME: Should ManglingNumber get numbers associated with 'to' context?
7298 
7299   LifetimeExtendedTemporaryDecl *To;
7300   if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl,
7301                               D->getManglingNumber()))
7302     return To;
7303 
7304   To->setLexicalDeclContext(LexicalDC);
7305   LexicalDC->addDeclInternal(To);
7306   return To;
7307 }
7308 
7309 ExpectedStmt
VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr * E)7310 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
7311   Error Err = Error::success();
7312   auto ToType = importChecked(Err, E->getType());
7313   Expr *ToTemporaryExpr = importChecked(
7314       Err, E->getLifetimeExtendedTemporaryDecl() ? nullptr : E->getSubExpr());
7315   auto ToMaterializedDecl =
7316       importChecked(Err, E->getLifetimeExtendedTemporaryDecl());
7317   if (Err)
7318     return std::move(Err);
7319 
7320   if (!ToTemporaryExpr)
7321     ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr());
7322 
7323   auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr(
7324       ToType, ToTemporaryExpr, E->isBoundToLvalueReference(),
7325       ToMaterializedDecl);
7326 
7327   return ToMTE;
7328 }
7329 
VisitPackExpansionExpr(PackExpansionExpr * E)7330 ExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) {
7331   Error Err = Error::success();
7332   auto ToType = importChecked(Err, E->getType());
7333   auto ToPattern = importChecked(Err, E->getPattern());
7334   auto ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
7335   if (Err)
7336     return std::move(Err);
7337 
7338   return new (Importer.getToContext()) PackExpansionExpr(
7339       ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions());
7340 }
7341 
VisitSizeOfPackExpr(SizeOfPackExpr * E)7342 ExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
7343   Error Err = Error::success();
7344   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7345   auto ToPack = importChecked(Err, E->getPack());
7346   auto ToPackLoc = importChecked(Err, E->getPackLoc());
7347   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7348   if (Err)
7349     return std::move(Err);
7350 
7351   Optional<unsigned> Length;
7352   if (!E->isValueDependent())
7353     Length = E->getPackLength();
7354 
7355   SmallVector<TemplateArgument, 8> ToPartialArguments;
7356   if (E->isPartiallySubstituted()) {
7357     if (Error Err = ImportTemplateArguments(
7358         E->getPartialArguments().data(),
7359         E->getPartialArguments().size(),
7360         ToPartialArguments))
7361       return std::move(Err);
7362   }
7363 
7364   return SizeOfPackExpr::Create(
7365       Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
7366       Length, ToPartialArguments);
7367 }
7368 
7369 
VisitCXXNewExpr(CXXNewExpr * E)7370 ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
7371   Error Err = Error::success();
7372   auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
7373   auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7374   auto ToTypeIdParens = importChecked(Err, E->getTypeIdParens());
7375   auto ToArraySize = importChecked(Err, E->getArraySize());
7376   auto ToInitializer = importChecked(Err, E->getInitializer());
7377   auto ToType = importChecked(Err, E->getType());
7378   auto ToAllocatedTypeSourceInfo =
7379       importChecked(Err, E->getAllocatedTypeSourceInfo());
7380   auto ToSourceRange = importChecked(Err, E->getSourceRange());
7381   auto ToDirectInitRange = importChecked(Err, E->getDirectInitRange());
7382   if (Err)
7383     return std::move(Err);
7384 
7385   SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
7386   if (Error Err =
7387       ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
7388     return std::move(Err);
7389 
7390   return CXXNewExpr::Create(
7391       Importer.getToContext(), E->isGlobalNew(), ToOperatorNew,
7392       ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(),
7393       ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(),
7394       ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange,
7395       ToDirectInitRange);
7396 }
7397 
VisitCXXDeleteExpr(CXXDeleteExpr * E)7398 ExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
7399   Error Err = Error::success();
7400   auto ToType = importChecked(Err, E->getType());
7401   auto ToOperatorDelete = importChecked(Err, E->getOperatorDelete());
7402   auto ToArgument = importChecked(Err, E->getArgument());
7403   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7404   if (Err)
7405     return std::move(Err);
7406 
7407   return new (Importer.getToContext()) CXXDeleteExpr(
7408       ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(),
7409       E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument,
7410       ToBeginLoc);
7411 }
7412 
VisitCXXConstructExpr(CXXConstructExpr * E)7413 ExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) {
7414   Error Err = Error::success();
7415   auto ToType = importChecked(Err, E->getType());
7416   auto ToLocation = importChecked(Err, E->getLocation());
7417   auto ToConstructor = importChecked(Err, E->getConstructor());
7418   auto ToParenOrBraceRange = importChecked(Err, E->getParenOrBraceRange());
7419   if (Err)
7420     return std::move(Err);
7421 
7422   SmallVector<Expr *, 6> ToArgs(E->getNumArgs());
7423   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7424     return std::move(Err);
7425 
7426   return CXXConstructExpr::Create(
7427       Importer.getToContext(), ToType, ToLocation, ToConstructor,
7428       E->isElidable(), ToArgs, E->hadMultipleCandidates(),
7429       E->isListInitialization(), E->isStdInitListInitialization(),
7430       E->requiresZeroInitialization(), E->getConstructionKind(),
7431       ToParenOrBraceRange);
7432 }
7433 
VisitExprWithCleanups(ExprWithCleanups * E)7434 ExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) {
7435   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7436   if (!ToSubExprOrErr)
7437     return ToSubExprOrErr.takeError();
7438 
7439   SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects());
7440   if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
7441     return std::move(Err);
7442 
7443   return ExprWithCleanups::Create(
7444       Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
7445       ToObjects);
7446 }
7447 
VisitCXXMemberCallExpr(CXXMemberCallExpr * E)7448 ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
7449   Error Err = Error::success();
7450   auto ToCallee = importChecked(Err, E->getCallee());
7451   auto ToType = importChecked(Err, E->getType());
7452   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7453   if (Err)
7454     return std::move(Err);
7455 
7456   SmallVector<Expr *, 4> ToArgs(E->getNumArgs());
7457   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7458     return std::move(Err);
7459 
7460   return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs,
7461                                    ToType, E->getValueKind(), ToRParenLoc,
7462                                    E->getFPFeatures());
7463 }
7464 
VisitCXXThisExpr(CXXThisExpr * E)7465 ExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) {
7466   ExpectedType ToTypeOrErr = import(E->getType());
7467   if (!ToTypeOrErr)
7468     return ToTypeOrErr.takeError();
7469 
7470   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7471   if (!ToLocationOrErr)
7472     return ToLocationOrErr.takeError();
7473 
7474   return new (Importer.getToContext()) CXXThisExpr(
7475       *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
7476 }
7477 
VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr * E)7478 ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
7479   ExpectedType ToTypeOrErr = import(E->getType());
7480   if (!ToTypeOrErr)
7481     return ToTypeOrErr.takeError();
7482 
7483   ExpectedSLoc ToLocationOrErr = import(E->getLocation());
7484   if (!ToLocationOrErr)
7485     return ToLocationOrErr.takeError();
7486 
7487   return new (Importer.getToContext()) CXXBoolLiteralExpr(
7488       E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
7489 }
7490 
VisitMemberExpr(MemberExpr * E)7491 ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
7492   Error Err = Error::success();
7493   auto ToBase = importChecked(Err, E->getBase());
7494   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7495   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7496   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7497   auto ToMemberDecl = importChecked(Err, E->getMemberDecl());
7498   auto ToType = importChecked(Err, E->getType());
7499   auto ToDecl = importChecked(Err, E->getFoundDecl().getDecl());
7500   auto ToName = importChecked(Err, E->getMemberNameInfo().getName());
7501   auto ToLoc = importChecked(Err, E->getMemberNameInfo().getLoc());
7502   if (Err)
7503     return std::move(Err);
7504 
7505   DeclAccessPair ToFoundDecl =
7506       DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess());
7507 
7508   DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc);
7509 
7510   TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7511   if (E->hasExplicitTemplateArgs()) {
7512     if (Error Err =
7513             ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7514                                            E->template_arguments(), ToTAInfo))
7515       return std::move(Err);
7516     ResInfo = &ToTAInfo;
7517   }
7518 
7519   return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(),
7520                             ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
7521                             ToMemberDecl, ToFoundDecl, ToMemberNameInfo,
7522                             ResInfo, ToType, E->getValueKind(),
7523                             E->getObjectKind(), E->isNonOdrUse());
7524 }
7525 
7526 ExpectedStmt
VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr * E)7527 ASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
7528   Error Err = Error::success();
7529   auto ToBase = importChecked(Err, E->getBase());
7530   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7531   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7532   auto ToScopeTypeInfo = importChecked(Err, E->getScopeTypeInfo());
7533   auto ToColonColonLoc = importChecked(Err, E->getColonColonLoc());
7534   auto ToTildeLoc = importChecked(Err, E->getTildeLoc());
7535   if (Err)
7536     return std::move(Err);
7537 
7538   PseudoDestructorTypeStorage Storage;
7539   if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) {
7540     IdentifierInfo *ToII = Importer.Import(FromII);
7541     ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc());
7542     if (!ToDestroyedTypeLocOrErr)
7543       return ToDestroyedTypeLocOrErr.takeError();
7544     Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr);
7545   } else {
7546     if (auto ToTIOrErr = import(E->getDestroyedTypeInfo()))
7547       Storage = PseudoDestructorTypeStorage(*ToTIOrErr);
7548     else
7549       return ToTIOrErr.takeError();
7550   }
7551 
7552   return new (Importer.getToContext()) CXXPseudoDestructorExpr(
7553       Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc,
7554       ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage);
7555 }
7556 
VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr * E)7557 ExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr(
7558     CXXDependentScopeMemberExpr *E) {
7559   Error Err = Error::success();
7560   auto ToType = importChecked(Err, E->getType());
7561   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7562   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7563   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7564   auto ToFirstQualifierFoundInScope =
7565       importChecked(Err, E->getFirstQualifierFoundInScope());
7566   if (Err)
7567     return std::move(Err);
7568 
7569   Expr *ToBase = nullptr;
7570   if (!E->isImplicitAccess()) {
7571     if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
7572       ToBase = *ToBaseOrErr;
7573     else
7574       return ToBaseOrErr.takeError();
7575   }
7576 
7577   TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr;
7578 
7579   if (E->hasExplicitTemplateArgs()) {
7580     if (Error Err =
7581             ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
7582                                            E->template_arguments(), ToTAInfo))
7583       return std::move(Err);
7584     ResInfo = &ToTAInfo;
7585   }
7586   auto ToMember = importChecked(Err, E->getMember());
7587   auto ToMemberLoc = importChecked(Err, E->getMemberLoc());
7588   if (Err)
7589     return std::move(Err);
7590   DeclarationNameInfo ToMemberNameInfo(ToMember, ToMemberLoc);
7591 
7592   // Import additional name location/type info.
7593   if (Error Err =
7594           ImportDeclarationNameLoc(E->getMemberNameInfo(), ToMemberNameInfo))
7595     return std::move(Err);
7596 
7597   return CXXDependentScopeMemberExpr::Create(
7598       Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc,
7599       ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope,
7600       ToMemberNameInfo, ResInfo);
7601 }
7602 
7603 ExpectedStmt
VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr * E)7604 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
7605   Error Err = Error::success();
7606   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7607   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7608   auto ToDeclName = importChecked(Err, E->getDeclName());
7609   auto ToNameLoc = importChecked(Err, E->getNameInfo().getLoc());
7610   auto ToLAngleLoc = importChecked(Err, E->getLAngleLoc());
7611   auto ToRAngleLoc = importChecked(Err, E->getRAngleLoc());
7612   if (Err)
7613     return std::move(Err);
7614 
7615   DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc);
7616   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7617     return std::move(Err);
7618 
7619   TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc);
7620   TemplateArgumentListInfo *ResInfo = nullptr;
7621   if (E->hasExplicitTemplateArgs()) {
7622     if (Error Err =
7623         ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
7624       return std::move(Err);
7625     ResInfo = &ToTAInfo;
7626   }
7627 
7628   return DependentScopeDeclRefExpr::Create(
7629       Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
7630       ToNameInfo, ResInfo);
7631 }
7632 
VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr * E)7633 ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
7634     CXXUnresolvedConstructExpr *E) {
7635   Error Err = Error::success();
7636   auto ToLParenLoc = importChecked(Err, E->getLParenLoc());
7637   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7638   auto ToType = importChecked(Err, E->getType());
7639   auto ToTypeSourceInfo = importChecked(Err, E->getTypeSourceInfo());
7640   if (Err)
7641     return std::move(Err);
7642 
7643   SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
7644   if (Error Err =
7645       ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
7646     return std::move(Err);
7647 
7648   return CXXUnresolvedConstructExpr::Create(
7649       Importer.getToContext(), ToType, ToTypeSourceInfo, ToLParenLoc,
7650       llvm::makeArrayRef(ToArgs), ToRParenLoc);
7651 }
7652 
7653 ExpectedStmt
VisitUnresolvedLookupExpr(UnresolvedLookupExpr * E)7654 ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
7655   Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass());
7656   if (!ToNamingClassOrErr)
7657     return ToNamingClassOrErr.takeError();
7658 
7659   auto ToQualifierLocOrErr = import(E->getQualifierLoc());
7660   if (!ToQualifierLocOrErr)
7661     return ToQualifierLocOrErr.takeError();
7662 
7663   Error Err = Error::success();
7664   auto ToName = importChecked(Err, E->getName());
7665   auto ToNameLoc = importChecked(Err, E->getNameLoc());
7666   if (Err)
7667     return std::move(Err);
7668   DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7669 
7670   // Import additional name location/type info.
7671   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7672     return std::move(Err);
7673 
7674   UnresolvedSet<8> ToDecls;
7675   for (auto *D : E->decls())
7676     if (auto ToDOrErr = import(D))
7677       ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7678     else
7679       return ToDOrErr.takeError();
7680 
7681   if (E->hasExplicitTemplateArgs()) {
7682     TemplateArgumentListInfo ToTAInfo;
7683     if (Error Err = ImportTemplateArgumentListInfo(
7684         E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
7685         ToTAInfo))
7686       return std::move(Err);
7687 
7688     ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
7689     if (!ToTemplateKeywordLocOrErr)
7690       return ToTemplateKeywordLocOrErr.takeError();
7691 
7692     return UnresolvedLookupExpr::Create(
7693         Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7694         *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo,
7695         ToDecls.begin(), ToDecls.end());
7696   }
7697 
7698   return UnresolvedLookupExpr::Create(
7699       Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr,
7700       ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(),
7701       ToDecls.end());
7702 }
7703 
7704 ExpectedStmt
VisitUnresolvedMemberExpr(UnresolvedMemberExpr * E)7705 ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
7706   Error Err = Error::success();
7707   auto ToType = importChecked(Err, E->getType());
7708   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7709   auto ToQualifierLoc = importChecked(Err, E->getQualifierLoc());
7710   auto ToTemplateKeywordLoc = importChecked(Err, E->getTemplateKeywordLoc());
7711   auto ToName = importChecked(Err, E->getName());
7712   auto ToNameLoc = importChecked(Err, E->getNameLoc());
7713   if (Err)
7714     return std::move(Err);
7715 
7716   DeclarationNameInfo ToNameInfo(ToName, ToNameLoc);
7717   // Import additional name location/type info.
7718   if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo))
7719     return std::move(Err);
7720 
7721   UnresolvedSet<8> ToDecls;
7722   for (Decl *D : E->decls())
7723     if (auto ToDOrErr = import(D))
7724       ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr));
7725     else
7726       return ToDOrErr.takeError();
7727 
7728   TemplateArgumentListInfo ToTAInfo;
7729   TemplateArgumentListInfo *ResInfo = nullptr;
7730   if (E->hasExplicitTemplateArgs()) {
7731     TemplateArgumentListInfo FromTAInfo;
7732     E->copyTemplateArgumentsInto(FromTAInfo);
7733     if (Error Err = ImportTemplateArgumentListInfo(FromTAInfo, ToTAInfo))
7734       return std::move(Err);
7735     ResInfo = &ToTAInfo;
7736   }
7737 
7738   Expr *ToBase = nullptr;
7739   if (!E->isImplicitAccess()) {
7740     if (ExpectedExpr ToBaseOrErr = import(E->getBase()))
7741       ToBase = *ToBaseOrErr;
7742     else
7743       return ToBaseOrErr.takeError();
7744   }
7745 
7746   return UnresolvedMemberExpr::Create(
7747       Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType,
7748       E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc,
7749       ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end());
7750 }
7751 
VisitCallExpr(CallExpr * E)7752 ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
7753   Error Err = Error::success();
7754   auto ToCallee = importChecked(Err, E->getCallee());
7755   auto ToType = importChecked(Err, E->getType());
7756   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7757   if (Err)
7758     return std::move(Err);
7759 
7760   unsigned NumArgs = E->getNumArgs();
7761   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
7762   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
7763      return std::move(Err);
7764 
7765   if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
7766     return CXXOperatorCallExpr::Create(
7767         Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
7768         OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
7769         OCE->getADLCallKind());
7770   }
7771 
7772   return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
7773                           E->getValueKind(), ToRParenLoc, E->getFPFeatures(),
7774                           /*MinNumArgs=*/0, E->getADLCallKind());
7775 }
7776 
VisitLambdaExpr(LambdaExpr * E)7777 ExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) {
7778   CXXRecordDecl *FromClass = E->getLambdaClass();
7779   auto ToClassOrErr = import(FromClass);
7780   if (!ToClassOrErr)
7781     return ToClassOrErr.takeError();
7782   CXXRecordDecl *ToClass = *ToClassOrErr;
7783 
7784   auto ToCallOpOrErr = import(E->getCallOperator());
7785   if (!ToCallOpOrErr)
7786     return ToCallOpOrErr.takeError();
7787 
7788   SmallVector<Expr *, 8> ToCaptureInits(E->capture_size());
7789   if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits))
7790     return std::move(Err);
7791 
7792   Error Err = Error::success();
7793   auto ToIntroducerRange = importChecked(Err, E->getIntroducerRange());
7794   auto ToCaptureDefaultLoc = importChecked(Err, E->getCaptureDefaultLoc());
7795   auto ToEndLoc = importChecked(Err, E->getEndLoc());
7796   if (Err)
7797     return std::move(Err);
7798 
7799   return LambdaExpr::Create(Importer.getToContext(), ToClass, ToIntroducerRange,
7800                             E->getCaptureDefault(), ToCaptureDefaultLoc,
7801                             E->hasExplicitParameters(),
7802                             E->hasExplicitResultType(), ToCaptureInits,
7803                             ToEndLoc, E->containsUnexpandedParameterPack());
7804 }
7805 
7806 
VisitInitListExpr(InitListExpr * E)7807 ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
7808   Error Err = Error::success();
7809   auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
7810   auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
7811   auto ToType = importChecked(Err, E->getType());
7812   if (Err)
7813     return std::move(Err);
7814 
7815   SmallVector<Expr *, 4> ToExprs(E->getNumInits());
7816   if (Error Err = ImportContainerChecked(E->inits(), ToExprs))
7817     return std::move(Err);
7818 
7819   ASTContext &ToCtx = Importer.getToContext();
7820   InitListExpr *To = new (ToCtx) InitListExpr(
7821       ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
7822   To->setType(ToType);
7823 
7824   if (E->hasArrayFiller()) {
7825     if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller()))
7826       To->setArrayFiller(*ToFillerOrErr);
7827     else
7828       return ToFillerOrErr.takeError();
7829   }
7830 
7831   if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) {
7832     if (auto ToFDOrErr = import(FromFD))
7833       To->setInitializedFieldInUnion(*ToFDOrErr);
7834     else
7835       return ToFDOrErr.takeError();
7836   }
7837 
7838   if (InitListExpr *SyntForm = E->getSyntacticForm()) {
7839     if (auto ToSyntFormOrErr = import(SyntForm))
7840       To->setSyntacticForm(*ToSyntFormOrErr);
7841     else
7842       return ToSyntFormOrErr.takeError();
7843   }
7844 
7845   // Copy InitListExprBitfields, which are not handled in the ctor of
7846   // InitListExpr.
7847   To->sawArrayRangeDesignator(E->hadArrayRangeDesignator());
7848 
7849   return To;
7850 }
7851 
VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr * E)7852 ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
7853     CXXStdInitializerListExpr *E) {
7854   ExpectedType ToTypeOrErr = import(E->getType());
7855   if (!ToTypeOrErr)
7856     return ToTypeOrErr.takeError();
7857 
7858   ExpectedExpr ToSubExprOrErr = import(E->getSubExpr());
7859   if (!ToSubExprOrErr)
7860     return ToSubExprOrErr.takeError();
7861 
7862   return new (Importer.getToContext()) CXXStdInitializerListExpr(
7863       *ToTypeOrErr, *ToSubExprOrErr);
7864 }
7865 
VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr * E)7866 ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
7867     CXXInheritedCtorInitExpr *E) {
7868   Error Err = Error::success();
7869   auto ToLocation = importChecked(Err, E->getLocation());
7870   auto ToType = importChecked(Err, E->getType());
7871   auto ToConstructor = importChecked(Err, E->getConstructor());
7872   if (Err)
7873     return std::move(Err);
7874 
7875   return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
7876       ToLocation, ToType, ToConstructor, E->constructsVBase(),
7877       E->inheritedFromVBase());
7878 }
7879 
VisitArrayInitLoopExpr(ArrayInitLoopExpr * E)7880 ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
7881   Error Err = Error::success();
7882   auto ToType = importChecked(Err, E->getType());
7883   auto ToCommonExpr = importChecked(Err, E->getCommonExpr());
7884   auto ToSubExpr = importChecked(Err, E->getSubExpr());
7885   if (Err)
7886     return std::move(Err);
7887 
7888   return new (Importer.getToContext()) ArrayInitLoopExpr(
7889       ToType, ToCommonExpr, ToSubExpr);
7890 }
7891 
VisitArrayInitIndexExpr(ArrayInitIndexExpr * E)7892 ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
7893   ExpectedType ToTypeOrErr = import(E->getType());
7894   if (!ToTypeOrErr)
7895     return ToTypeOrErr.takeError();
7896   return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr);
7897 }
7898 
VisitCXXDefaultInitExpr(CXXDefaultInitExpr * E)7899 ExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
7900   ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc());
7901   if (!ToBeginLocOrErr)
7902     return ToBeginLocOrErr.takeError();
7903 
7904   auto ToFieldOrErr = import(E->getField());
7905   if (!ToFieldOrErr)
7906     return ToFieldOrErr.takeError();
7907 
7908   auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext());
7909   if (!UsedContextOrErr)
7910     return UsedContextOrErr.takeError();
7911 
7912   return CXXDefaultInitExpr::Create(
7913       Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
7914 }
7915 
VisitCXXNamedCastExpr(CXXNamedCastExpr * E)7916 ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
7917   Error Err = Error::success();
7918   auto ToType = importChecked(Err, E->getType());
7919   auto ToSubExpr = importChecked(Err, E->getSubExpr());
7920   auto ToTypeInfoAsWritten = importChecked(Err, E->getTypeInfoAsWritten());
7921   auto ToOperatorLoc = importChecked(Err, E->getOperatorLoc());
7922   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
7923   auto ToAngleBrackets = importChecked(Err, E->getAngleBrackets());
7924   if (Err)
7925     return std::move(Err);
7926 
7927   ExprValueKind VK = E->getValueKind();
7928   CastKind CK = E->getCastKind();
7929   auto ToBasePathOrErr = ImportCastPath(E);
7930   if (!ToBasePathOrErr)
7931     return ToBasePathOrErr.takeError();
7932 
7933   if (auto CCE = dyn_cast<CXXStaticCastExpr>(E)) {
7934     return CXXStaticCastExpr::Create(
7935         Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7936         ToTypeInfoAsWritten, CCE->getFPFeatures(), ToOperatorLoc, ToRParenLoc,
7937         ToAngleBrackets);
7938   } else if (isa<CXXDynamicCastExpr>(E)) {
7939     return CXXDynamicCastExpr::Create(
7940         Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7941         ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
7942   } else if (isa<CXXReinterpretCastExpr>(E)) {
7943     return CXXReinterpretCastExpr::Create(
7944         Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr),
7945         ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
7946   } else if (isa<CXXConstCastExpr>(E)) {
7947     return CXXConstCastExpr::Create(
7948         Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten,
7949         ToOperatorLoc, ToRParenLoc, ToAngleBrackets);
7950   } else {
7951     llvm_unreachable("Unknown cast type");
7952     return make_error<ImportError>();
7953   }
7954 }
7955 
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * E)7956 ExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr(
7957     SubstNonTypeTemplateParmExpr *E) {
7958   Error Err = Error::success();
7959   auto ToType = importChecked(Err, E->getType());
7960   auto ToExprLoc = importChecked(Err, E->getExprLoc());
7961   auto ToParameter = importChecked(Err, E->getParameter());
7962   auto ToReplacement = importChecked(Err, E->getReplacement());
7963   if (Err)
7964     return std::move(Err);
7965 
7966   return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr(
7967       ToType, E->getValueKind(), ToExprLoc, ToParameter,
7968       E->isReferenceParameter(), ToReplacement);
7969 }
7970 
VisitTypeTraitExpr(TypeTraitExpr * E)7971 ExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) {
7972   Error Err = Error::success();
7973   auto ToType = importChecked(Err, E->getType());
7974   auto ToBeginLoc = importChecked(Err, E->getBeginLoc());
7975   auto ToEndLoc = importChecked(Err, E->getEndLoc());
7976   if (Err)
7977     return std::move(Err);
7978 
7979   SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs());
7980   if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs))
7981     return std::move(Err);
7982 
7983   // According to Sema::BuildTypeTrait(), if E is value-dependent,
7984   // Value is always false.
7985   bool ToValue = (E->isValueDependent() ? false : E->getValue());
7986 
7987   return TypeTraitExpr::Create(
7988       Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
7989       ToEndLoc, ToValue);
7990 }
7991 
VisitCXXTypeidExpr(CXXTypeidExpr * E)7992 ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
7993   ExpectedType ToTypeOrErr = import(E->getType());
7994   if (!ToTypeOrErr)
7995     return ToTypeOrErr.takeError();
7996 
7997   auto ToSourceRangeOrErr = import(E->getSourceRange());
7998   if (!ToSourceRangeOrErr)
7999     return ToSourceRangeOrErr.takeError();
8000 
8001   if (E->isTypeOperand()) {
8002     if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
8003       return new (Importer.getToContext()) CXXTypeidExpr(
8004           *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
8005     else
8006       return ToTSIOrErr.takeError();
8007   }
8008 
8009   ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand());
8010   if (!ToExprOperandOrErr)
8011     return ToExprOperandOrErr.takeError();
8012 
8013   return new (Importer.getToContext()) CXXTypeidExpr(
8014       *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
8015 }
8016 
VisitCXXFoldExpr(CXXFoldExpr * E)8017 ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
8018   Error Err = Error::success();
8019 
8020   QualType ToType = importChecked(Err, E->getType());
8021   UnresolvedLookupExpr *ToCallee = importChecked(Err, E->getCallee());
8022   SourceLocation ToLParenLoc = importChecked(Err, E->getLParenLoc());
8023   Expr *ToLHS = importChecked(Err, E->getLHS());
8024   SourceLocation ToEllipsisLoc = importChecked(Err, E->getEllipsisLoc());
8025   Expr *ToRHS = importChecked(Err, E->getRHS());
8026   SourceLocation ToRParenLoc = importChecked(Err, E->getRParenLoc());
8027 
8028   if (Err)
8029     return std::move(Err);
8030 
8031   return new (Importer.getToContext())
8032       CXXFoldExpr(ToType, ToCallee, ToLParenLoc, ToLHS, E->getOperator(),
8033                   ToEllipsisLoc, ToRHS, ToRParenLoc, E->getNumExpansions());
8034 }
8035 
ImportOverriddenMethods(CXXMethodDecl * ToMethod,CXXMethodDecl * FromMethod)8036 Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,
8037                                                CXXMethodDecl *FromMethod) {
8038   Error ImportErrors = Error::success();
8039   for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
8040     if (auto ImportedOrErr = import(FromOverriddenMethod))
8041       ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
8042           (*ImportedOrErr)->getCanonicalDecl()));
8043     else
8044       ImportErrors =
8045           joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
8046   }
8047   return ImportErrors;
8048 }
8049 
ASTImporter(ASTContext & ToContext,FileManager & ToFileManager,ASTContext & FromContext,FileManager & FromFileManager,bool MinimalImport,std::shared_ptr<ASTImporterSharedState> SharedState)8050 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
8051                          ASTContext &FromContext, FileManager &FromFileManager,
8052                          bool MinimalImport,
8053                          std::shared_ptr<ASTImporterSharedState> SharedState)
8054     : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
8055       ToFileManager(ToFileManager), FromFileManager(FromFileManager),
8056       Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) {
8057 
8058   // Create a default state without the lookup table: LLDB case.
8059   if (!SharedState) {
8060     this->SharedState = std::make_shared<ASTImporterSharedState>();
8061   }
8062 
8063   ImportedDecls[FromContext.getTranslationUnitDecl()] =
8064       ToContext.getTranslationUnitDecl();
8065 }
8066 
8067 ASTImporter::~ASTImporter() = default;
8068 
getFieldIndex(Decl * F)8069 Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
8070   assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
8071       "Try to get field index for non-field.");
8072 
8073   auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
8074   if (!Owner)
8075     return None;
8076 
8077   unsigned Index = 0;
8078   for (const auto *D : Owner->decls()) {
8079     if (D == F)
8080       return Index;
8081 
8082     if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D))
8083       ++Index;
8084   }
8085 
8086   llvm_unreachable("Field was not found in its parent context.");
8087 
8088   return None;
8089 }
8090 
8091 ASTImporter::FoundDeclsTy
findDeclsInToCtx(DeclContext * DC,DeclarationName Name)8092 ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
8093   // We search in the redecl context because of transparent contexts.
8094   // E.g. a simple C language enum is a transparent context:
8095   //   enum E { A, B };
8096   // Now if we had a global variable in the TU
8097   //   int A;
8098   // then the enum constant 'A' and the variable 'A' violates ODR.
8099   // We can diagnose this only if we search in the redecl context.
8100   DeclContext *ReDC = DC->getRedeclContext();
8101   if (SharedState->getLookupTable()) {
8102     ASTImporterLookupTable::LookupResult LookupResult =
8103         SharedState->getLookupTable()->lookup(ReDC, Name);
8104     return FoundDeclsTy(LookupResult.begin(), LookupResult.end());
8105   } else {
8106     DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name);
8107     FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end());
8108     // We must search by the slow case of localUncachedLookup because that is
8109     // working even if there is no LookupPtr for the DC. We could use
8110     // DC::buildLookup() to create the LookupPtr, but that would load external
8111     // decls again, we must avoid that case.
8112     // Also, even if we had the LookupPtr, we must find Decls which are not
8113     // in the LookupPtr, so we need the slow case.
8114     // These cases are handled in ASTImporterLookupTable, but we cannot use
8115     // that with LLDB since that traverses through the AST which initiates the
8116     // load of external decls again via DC::decls().  And again, we must avoid
8117     // loading external decls during the import.
8118     if (Result.empty())
8119       ReDC->localUncachedLookup(Name, Result);
8120     return Result;
8121   }
8122 }
8123 
AddToLookupTable(Decl * ToD)8124 void ASTImporter::AddToLookupTable(Decl *ToD) {
8125   SharedState->addDeclToLookup(ToD);
8126 }
8127 
ImportImpl(Decl * FromD)8128 Expected<Decl *> ASTImporter::ImportImpl(Decl *FromD) {
8129   // Import the decl using ASTNodeImporter.
8130   ASTNodeImporter Importer(*this);
8131   return Importer.Visit(FromD);
8132 }
8133 
RegisterImportedDecl(Decl * FromD,Decl * ToD)8134 void ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) {
8135   MapImported(FromD, ToD);
8136 }
8137 
8138 llvm::Expected<ExprWithCleanups::CleanupObject>
Import(ExprWithCleanups::CleanupObject From)8139 ASTImporter::Import(ExprWithCleanups::CleanupObject From) {
8140   if (auto *CLE = From.dyn_cast<CompoundLiteralExpr *>()) {
8141     if (Expected<Expr *> R = Import(CLE))
8142       return ExprWithCleanups::CleanupObject(cast<CompoundLiteralExpr>(*R));
8143   }
8144 
8145   // FIXME: Handle BlockDecl when we implement importing BlockExpr in
8146   //        ASTNodeImporter.
8147   return make_error<ImportError>(ImportError::UnsupportedConstruct);
8148 }
8149 
Import(QualType FromT)8150 Expected<QualType> ASTImporter::Import(QualType FromT) {
8151   if (FromT.isNull())
8152     return QualType{};
8153 
8154   const Type *FromTy = FromT.getTypePtr();
8155 
8156   // Check whether we've already imported this type.
8157   llvm::DenseMap<const Type *, const Type *>::iterator Pos
8158     = ImportedTypes.find(FromTy);
8159   if (Pos != ImportedTypes.end())
8160     return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers());
8161 
8162   // Import the type
8163   ASTNodeImporter Importer(*this);
8164   ExpectedType ToTOrErr = Importer.Visit(FromTy);
8165   if (!ToTOrErr)
8166     return ToTOrErr.takeError();
8167 
8168   // Record the imported type.
8169   ImportedTypes[FromTy] = (*ToTOrErr).getTypePtr();
8170 
8171   return ToContext.getQualifiedType(*ToTOrErr, FromT.getLocalQualifiers());
8172 }
8173 
Import(TypeSourceInfo * FromTSI)8174 Expected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) {
8175   if (!FromTSI)
8176     return FromTSI;
8177 
8178   // FIXME: For now we just create a "trivial" type source info based
8179   // on the type and a single location. Implement a real version of this.
8180   ExpectedType TOrErr = Import(FromTSI->getType());
8181   if (!TOrErr)
8182     return TOrErr.takeError();
8183   ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc());
8184   if (!BeginLocOrErr)
8185     return BeginLocOrErr.takeError();
8186 
8187   return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
8188 }
8189 
Import(const Attr * FromAttr)8190 Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
8191   Attr *ToAttr = nullptr;
8192   SourceRange ToRange;
8193   if (Error Err = importInto(ToRange, FromAttr->getRange()))
8194     return std::move(Err);
8195 
8196   // FIXME: Is there some kind of AttrVisitor to use here?
8197   switch (FromAttr->getKind()) {
8198   case attr::Aligned: {
8199     auto *From = cast<AlignedAttr>(FromAttr);
8200     AlignedAttr *To;
8201     auto CreateAlign = [&](bool IsAlignmentExpr, void *Alignment) {
8202       return AlignedAttr::Create(ToContext, IsAlignmentExpr, Alignment, ToRange,
8203                                  From->getSyntax(),
8204                                  From->getSemanticSpelling());
8205     };
8206     if (From->isAlignmentExpr()) {
8207       if (auto ToEOrErr = Import(From->getAlignmentExpr()))
8208         To = CreateAlign(true, *ToEOrErr);
8209       else
8210         return ToEOrErr.takeError();
8211     } else {
8212       if (auto ToTOrErr = Import(From->getAlignmentType()))
8213         To = CreateAlign(false, *ToTOrErr);
8214       else
8215         return ToTOrErr.takeError();
8216     }
8217     To->setInherited(From->isInherited());
8218     To->setPackExpansion(From->isPackExpansion());
8219     To->setImplicit(From->isImplicit());
8220     ToAttr = To;
8221     break;
8222   }
8223   case attr::Format: {
8224     const auto *From = cast<FormatAttr>(FromAttr);
8225     FormatAttr *To;
8226     IdentifierInfo *ToAttrType = Import(From->getType());
8227     To = FormatAttr::Create(ToContext, ToAttrType, From->getFormatIdx(),
8228                             From->getFirstArg(), ToRange, From->getSyntax());
8229     To->setInherited(From->isInherited());
8230     ToAttr = To;
8231     break;
8232   }
8233   default:
8234     // FIXME: 'clone' copies every member but some of them should be imported.
8235     // Handle other Attrs that have parameters that should be imported.
8236     ToAttr = FromAttr->clone(ToContext);
8237     ToAttr->setRange(ToRange);
8238     break;
8239   }
8240   assert(ToAttr && "Attribute should be created.");
8241 
8242   return ToAttr;
8243 }
8244 
GetAlreadyImportedOrNull(const Decl * FromD) const8245 Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
8246   auto Pos = ImportedDecls.find(FromD);
8247   if (Pos != ImportedDecls.end())
8248     return Pos->second;
8249   else
8250     return nullptr;
8251 }
8252 
GetFromTU(Decl * ToD)8253 TranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) {
8254   auto FromDPos = ImportedFromDecls.find(ToD);
8255   if (FromDPos == ImportedFromDecls.end())
8256     return nullptr;
8257   return FromDPos->second->getTranslationUnitDecl();
8258 }
8259 
Import(Decl * FromD)8260 Expected<Decl *> ASTImporter::Import(Decl *FromD) {
8261   if (!FromD)
8262     return nullptr;
8263 
8264   // Push FromD to the stack, and remove that when we return.
8265   ImportPath.push(FromD);
8266   auto ImportPathBuilder =
8267       llvm::make_scope_exit([this]() { ImportPath.pop(); });
8268 
8269   // Check whether there was a previous failed import.
8270   // If yes return the existing error.
8271   if (auto Error = getImportDeclErrorIfAny(FromD))
8272     return make_error<ImportError>(*Error);
8273 
8274   // Check whether we've already imported this declaration.
8275   Decl *ToD = GetAlreadyImportedOrNull(FromD);
8276   if (ToD) {
8277     // Already imported (possibly from another TU) and with an error.
8278     if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8279       setImportDeclError(FromD, *Error);
8280       return make_error<ImportError>(*Error);
8281     }
8282 
8283     // If FromD has some updated flags after last import, apply it.
8284     updateFlags(FromD, ToD);
8285     // If we encounter a cycle during an import then we save the relevant part
8286     // of the import path associated to the Decl.
8287     if (ImportPath.hasCycleAtBack())
8288       SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack());
8289     return ToD;
8290   }
8291 
8292   // Import the declaration.
8293   ExpectedDecl ToDOrErr = ImportImpl(FromD);
8294   if (!ToDOrErr) {
8295     // Failed to import.
8296 
8297     auto Pos = ImportedDecls.find(FromD);
8298     if (Pos != ImportedDecls.end()) {
8299       // Import failed after the object was created.
8300       // Remove all references to it.
8301       auto *ToD = Pos->second;
8302       ImportedDecls.erase(Pos);
8303 
8304       // ImportedDecls and ImportedFromDecls are not symmetric.  It may happen
8305       // (e.g. with namespaces) that several decls from the 'from' context are
8306       // mapped to the same decl in the 'to' context.  If we removed entries
8307       // from the LookupTable here then we may end up removing them multiple
8308       // times.
8309 
8310       // The Lookuptable contains decls only which are in the 'to' context.
8311       // Remove from the Lookuptable only if it is *imported* into the 'to'
8312       // context (and do not remove it if it was added during the initial
8313       // traverse of the 'to' context).
8314       auto PosF = ImportedFromDecls.find(ToD);
8315       if (PosF != ImportedFromDecls.end()) {
8316         SharedState->removeDeclFromLookup(ToD);
8317         ImportedFromDecls.erase(PosF);
8318       }
8319 
8320       // FIXME: AST may contain remaining references to the failed object.
8321       // However, the ImportDeclErrors in the shared state contains all the
8322       // failed objects together with their error.
8323     }
8324 
8325     // Error encountered for the first time.
8326     // After takeError the error is not usable any more in ToDOrErr.
8327     // Get a copy of the error object (any more simple solution for this?).
8328     ImportError ErrOut;
8329     handleAllErrors(ToDOrErr.takeError(),
8330                     [&ErrOut](const ImportError &E) { ErrOut = E; });
8331     setImportDeclError(FromD, ErrOut);
8332     // Set the error for the mapped to Decl, which is in the "to" context.
8333     if (Pos != ImportedDecls.end())
8334       SharedState->setImportDeclError(Pos->second, ErrOut);
8335 
8336     // Set the error for all nodes which have been created before we
8337     // recognized the error.
8338     for (const auto &Path : SavedImportPaths[FromD])
8339       for (Decl *FromDi : Path) {
8340         setImportDeclError(FromDi, ErrOut);
8341         //FIXME Should we remove these Decls from ImportedDecls?
8342         // Set the error for the mapped to Decl, which is in the "to" context.
8343         auto Ii = ImportedDecls.find(FromDi);
8344         if (Ii != ImportedDecls.end())
8345           SharedState->setImportDeclError(Ii->second, ErrOut);
8346           // FIXME Should we remove these Decls from the LookupTable,
8347           // and from ImportedFromDecls?
8348       }
8349     SavedImportPaths.erase(FromD);
8350 
8351     // Do not return ToDOrErr, error was taken out of it.
8352     return make_error<ImportError>(ErrOut);
8353   }
8354 
8355   ToD = *ToDOrErr;
8356 
8357   // FIXME: Handle the "already imported with error" case. We can get here
8358   // nullptr only if GetImportedOrCreateDecl returned nullptr (after a
8359   // previously failed create was requested).
8360   // Later GetImportedOrCreateDecl can be updated to return the error.
8361   if (!ToD) {
8362     auto Err = getImportDeclErrorIfAny(FromD);
8363     assert(Err);
8364     return make_error<ImportError>(*Err);
8365   }
8366 
8367   // We could import from the current TU without error.  But previously we
8368   // already had imported a Decl as `ToD` from another TU (with another
8369   // ASTImporter object) and with an error.
8370   if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) {
8371     setImportDeclError(FromD, *Error);
8372     return make_error<ImportError>(*Error);
8373   }
8374 
8375   // Make sure that ImportImpl registered the imported decl.
8376   assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
8377 
8378   if (FromD->hasAttrs())
8379     for (const Attr *FromAttr : FromD->getAttrs()) {
8380       auto ToAttrOrErr = Import(FromAttr);
8381       if (ToAttrOrErr)
8382         ToD->addAttr(*ToAttrOrErr);
8383       else
8384         return ToAttrOrErr.takeError();
8385     }
8386 
8387   // Notify subclasses.
8388   Imported(FromD, ToD);
8389 
8390   updateFlags(FromD, ToD);
8391   SavedImportPaths.erase(FromD);
8392   return ToDOrErr;
8393 }
8394 
ImportContext(DeclContext * FromDC)8395 Expected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) {
8396   if (!FromDC)
8397     return FromDC;
8398 
8399   ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC));
8400   if (!ToDCOrErr)
8401     return ToDCOrErr.takeError();
8402   auto *ToDC = cast<DeclContext>(*ToDCOrErr);
8403 
8404   // When we're using a record/enum/Objective-C class/protocol as a context, we
8405   // need it to have a definition.
8406   if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) {
8407     auto *FromRecord = cast<RecordDecl>(FromDC);
8408     if (ToRecord->isCompleteDefinition())
8409       return ToDC;
8410 
8411     // If FromRecord is not defined we need to force it to be.
8412     // Simply calling CompleteDecl(...) for a RecordDecl will break some cases
8413     // it will start the definition but we never finish it.
8414     // If there are base classes they won't be imported and we will
8415     // be missing anything that we inherit from those bases.
8416     if (FromRecord->getASTContext().getExternalSource() &&
8417         !FromRecord->isCompleteDefinition())
8418       FromRecord->getASTContext().getExternalSource()->CompleteType(FromRecord);
8419 
8420     if (FromRecord->isCompleteDefinition())
8421       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8422           FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
8423         return std::move(Err);
8424   } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
8425     auto *FromEnum = cast<EnumDecl>(FromDC);
8426     if (ToEnum->isCompleteDefinition()) {
8427       // Do nothing.
8428     } else if (FromEnum->isCompleteDefinition()) {
8429       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8430           FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
8431         return std::move(Err);
8432     } else {
8433       CompleteDecl(ToEnum);
8434     }
8435   } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) {
8436     auto *FromClass = cast<ObjCInterfaceDecl>(FromDC);
8437     if (ToClass->getDefinition()) {
8438       // Do nothing.
8439     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
8440       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8441           FromDef, ToClass, ASTNodeImporter::IDK_Basic))
8442         return std::move(Err);
8443     } else {
8444       CompleteDecl(ToClass);
8445     }
8446   } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) {
8447     auto *FromProto = cast<ObjCProtocolDecl>(FromDC);
8448     if (ToProto->getDefinition()) {
8449       // Do nothing.
8450     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
8451       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
8452           FromDef, ToProto, ASTNodeImporter::IDK_Basic))
8453         return std::move(Err);
8454     } else {
8455       CompleteDecl(ToProto);
8456     }
8457   }
8458 
8459   return ToDC;
8460 }
8461 
Import(Expr * FromE)8462 Expected<Expr *> ASTImporter::Import(Expr *FromE) {
8463   if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE)))
8464     return cast_or_null<Expr>(*ToSOrErr);
8465   else
8466     return ToSOrErr.takeError();
8467 }
8468 
Import(Stmt * FromS)8469 Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
8470   if (!FromS)
8471     return nullptr;
8472 
8473   // Check whether we've already imported this statement.
8474   llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
8475   if (Pos != ImportedStmts.end())
8476     return Pos->second;
8477 
8478   // Import the statement.
8479   ASTNodeImporter Importer(*this);
8480   ExpectedStmt ToSOrErr = Importer.Visit(FromS);
8481   if (!ToSOrErr)
8482     return ToSOrErr;
8483 
8484   if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) {
8485     auto *FromE = cast<Expr>(FromS);
8486     // Copy ExprBitfields, which may not be handled in Expr subclasses
8487     // constructors.
8488     ToE->setValueKind(FromE->getValueKind());
8489     ToE->setObjectKind(FromE->getObjectKind());
8490     ToE->setDependence(FromE->getDependence());
8491   }
8492 
8493   // Record the imported statement object.
8494   ImportedStmts[FromS] = *ToSOrErr;
8495   return ToSOrErr;
8496 }
8497 
8498 Expected<NestedNameSpecifier *>
Import(NestedNameSpecifier * FromNNS)8499 ASTImporter::Import(NestedNameSpecifier *FromNNS) {
8500   if (!FromNNS)
8501     return nullptr;
8502 
8503   NestedNameSpecifier *Prefix = nullptr;
8504   if (Error Err = importInto(Prefix, FromNNS->getPrefix()))
8505     return std::move(Err);
8506 
8507   switch (FromNNS->getKind()) {
8508   case NestedNameSpecifier::Identifier:
8509     assert(FromNNS->getAsIdentifier() && "NNS should contain identifier.");
8510     return NestedNameSpecifier::Create(ToContext, Prefix,
8511                                        Import(FromNNS->getAsIdentifier()));
8512 
8513   case NestedNameSpecifier::Namespace:
8514     if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) {
8515       return NestedNameSpecifier::Create(ToContext, Prefix,
8516                                          cast<NamespaceDecl>(*NSOrErr));
8517     } else
8518       return NSOrErr.takeError();
8519 
8520   case NestedNameSpecifier::NamespaceAlias:
8521     if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias()))
8522       return NestedNameSpecifier::Create(ToContext, Prefix,
8523                                          cast<NamespaceAliasDecl>(*NSADOrErr));
8524     else
8525       return NSADOrErr.takeError();
8526 
8527   case NestedNameSpecifier::Global:
8528     return NestedNameSpecifier::GlobalSpecifier(ToContext);
8529 
8530   case NestedNameSpecifier::Super:
8531     if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl()))
8532       return NestedNameSpecifier::SuperSpecifier(ToContext,
8533                                                  cast<CXXRecordDecl>(*RDOrErr));
8534     else
8535       return RDOrErr.takeError();
8536 
8537   case NestedNameSpecifier::TypeSpec:
8538   case NestedNameSpecifier::TypeSpecWithTemplate:
8539     if (Expected<QualType> TyOrErr =
8540             Import(QualType(FromNNS->getAsType(), 0u))) {
8541       bool TSTemplate =
8542           FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate;
8543       return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate,
8544                                          TyOrErr->getTypePtr());
8545     } else {
8546       return TyOrErr.takeError();
8547     }
8548   }
8549 
8550   llvm_unreachable("Invalid nested name specifier kind");
8551 }
8552 
8553 Expected<NestedNameSpecifierLoc>
Import(NestedNameSpecifierLoc FromNNS)8554 ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
8555   // Copied from NestedNameSpecifier mostly.
8556   SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
8557   NestedNameSpecifierLoc NNS = FromNNS;
8558 
8559   // Push each of the nested-name-specifiers's onto a stack for
8560   // serialization in reverse order.
8561   while (NNS) {
8562     NestedNames.push_back(NNS);
8563     NNS = NNS.getPrefix();
8564   }
8565 
8566   NestedNameSpecifierLocBuilder Builder;
8567 
8568   while (!NestedNames.empty()) {
8569     NNS = NestedNames.pop_back_val();
8570     NestedNameSpecifier *Spec = nullptr;
8571     if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier()))
8572       return std::move(Err);
8573 
8574     NestedNameSpecifier::SpecifierKind Kind = Spec->getKind();
8575 
8576     SourceLocation ToLocalBeginLoc, ToLocalEndLoc;
8577     if (Kind != NestedNameSpecifier::Super) {
8578       if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc()))
8579         return std::move(Err);
8580 
8581       if (Kind != NestedNameSpecifier::Global)
8582         if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc()))
8583           return std::move(Err);
8584     }
8585 
8586     switch (Kind) {
8587     case NestedNameSpecifier::Identifier:
8588       Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc,
8589                      ToLocalEndLoc);
8590       break;
8591 
8592     case NestedNameSpecifier::Namespace:
8593       Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc,
8594                      ToLocalEndLoc);
8595       break;
8596 
8597     case NestedNameSpecifier::NamespaceAlias:
8598       Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(),
8599                      ToLocalBeginLoc, ToLocalEndLoc);
8600       break;
8601 
8602     case NestedNameSpecifier::TypeSpec:
8603     case NestedNameSpecifier::TypeSpecWithTemplate: {
8604       SourceLocation ToTLoc;
8605       if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
8606         return std::move(Err);
8607       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
8608             QualType(Spec->getAsType(), 0), ToTLoc);
8609       if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
8610         // ToLocalBeginLoc is here the location of the 'template' keyword.
8611         Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
8612                        ToLocalEndLoc);
8613       else
8614         // No location for 'template' keyword here.
8615         Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(),
8616                        ToLocalEndLoc);
8617       break;
8618     }
8619 
8620     case NestedNameSpecifier::Global:
8621       Builder.MakeGlobal(getToContext(), ToLocalBeginLoc);
8622       break;
8623 
8624     case NestedNameSpecifier::Super: {
8625       auto ToSourceRangeOrErr = Import(NNS.getSourceRange());
8626       if (!ToSourceRangeOrErr)
8627         return ToSourceRangeOrErr.takeError();
8628 
8629       Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(),
8630                         ToSourceRangeOrErr->getBegin(),
8631                         ToSourceRangeOrErr->getEnd());
8632     }
8633   }
8634   }
8635 
8636   return Builder.getWithLocInContext(getToContext());
8637 }
8638 
Import(TemplateName From)8639 Expected<TemplateName> ASTImporter::Import(TemplateName From) {
8640   switch (From.getKind()) {
8641   case TemplateName::Template:
8642     if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
8643       return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr));
8644     else
8645       return ToTemplateOrErr.takeError();
8646 
8647   case TemplateName::OverloadedTemplate: {
8648     OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate();
8649     UnresolvedSet<2> ToTemplates;
8650     for (auto *I : *FromStorage) {
8651       if (auto ToOrErr = Import(I))
8652         ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr));
8653       else
8654         return ToOrErr.takeError();
8655     }
8656     return ToContext.getOverloadedTemplateName(ToTemplates.begin(),
8657                                                ToTemplates.end());
8658   }
8659 
8660   case TemplateName::AssumedTemplate: {
8661     AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName();
8662     auto DeclNameOrErr = Import(FromStorage->getDeclName());
8663     if (!DeclNameOrErr)
8664       return DeclNameOrErr.takeError();
8665     return ToContext.getAssumedTemplateName(*DeclNameOrErr);
8666   }
8667 
8668   case TemplateName::QualifiedTemplate: {
8669     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
8670     auto QualifierOrErr = Import(QTN->getQualifier());
8671     if (!QualifierOrErr)
8672       return QualifierOrErr.takeError();
8673 
8674     if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
8675       return ToContext.getQualifiedTemplateName(
8676           *QualifierOrErr, QTN->hasTemplateKeyword(),
8677           cast<TemplateDecl>(*ToTemplateOrErr));
8678     else
8679       return ToTemplateOrErr.takeError();
8680   }
8681 
8682   case TemplateName::DependentTemplate: {
8683     DependentTemplateName *DTN = From.getAsDependentTemplateName();
8684     auto QualifierOrErr = Import(DTN->getQualifier());
8685     if (!QualifierOrErr)
8686       return QualifierOrErr.takeError();
8687 
8688     if (DTN->isIdentifier()) {
8689       return ToContext.getDependentTemplateName(*QualifierOrErr,
8690                                                 Import(DTN->getIdentifier()));
8691     }
8692 
8693     return ToContext.getDependentTemplateName(*QualifierOrErr,
8694                                               DTN->getOperator());
8695   }
8696 
8697   case TemplateName::SubstTemplateTemplateParm: {
8698     SubstTemplateTemplateParmStorage *Subst =
8699         From.getAsSubstTemplateTemplateParm();
8700     ExpectedDecl ParamOrErr = Import(Subst->getParameter());
8701     if (!ParamOrErr)
8702       return ParamOrErr.takeError();
8703 
8704     auto ReplacementOrErr = Import(Subst->getReplacement());
8705     if (!ReplacementOrErr)
8706       return ReplacementOrErr.takeError();
8707 
8708     return ToContext.getSubstTemplateTemplateParm(
8709         cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr);
8710   }
8711 
8712   case TemplateName::SubstTemplateTemplateParmPack: {
8713     SubstTemplateTemplateParmPackStorage *SubstPack
8714       = From.getAsSubstTemplateTemplateParmPack();
8715     ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack());
8716     if (!ParamOrErr)
8717       return ParamOrErr.takeError();
8718 
8719     ASTNodeImporter Importer(*this);
8720     auto ArgPackOrErr =
8721         Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
8722     if (!ArgPackOrErr)
8723       return ArgPackOrErr.takeError();
8724 
8725     return ToContext.getSubstTemplateTemplateParmPack(
8726         cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
8727   }
8728   }
8729 
8730   llvm_unreachable("Invalid template name kind");
8731 }
8732 
Import(SourceLocation FromLoc)8733 Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
8734   if (FromLoc.isInvalid())
8735     return SourceLocation{};
8736 
8737   SourceManager &FromSM = FromContext.getSourceManager();
8738   bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc);
8739 
8740   std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc);
8741   Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin);
8742   if (!ToFileIDOrErr)
8743     return ToFileIDOrErr.takeError();
8744   SourceManager &ToSM = ToContext.getSourceManager();
8745   return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second);
8746 }
8747 
Import(SourceRange FromRange)8748 Expected<SourceRange> ASTImporter::Import(SourceRange FromRange) {
8749   SourceLocation ToBegin, ToEnd;
8750   if (Error Err = importInto(ToBegin, FromRange.getBegin()))
8751     return std::move(Err);
8752   if (Error Err = importInto(ToEnd, FromRange.getEnd()))
8753     return std::move(Err);
8754 
8755   return SourceRange(ToBegin, ToEnd);
8756 }
8757 
Import(FileID FromID,bool IsBuiltin)8758 Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
8759   llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID);
8760   if (Pos != ImportedFileIDs.end())
8761     return Pos->second;
8762 
8763   SourceManager &FromSM = FromContext.getSourceManager();
8764   SourceManager &ToSM = ToContext.getSourceManager();
8765   const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
8766 
8767   // Map the FromID to the "to" source manager.
8768   FileID ToID;
8769   if (FromSLoc.isExpansion()) {
8770     const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
8771     ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc());
8772     if (!ToSpLoc)
8773       return ToSpLoc.takeError();
8774     ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart());
8775     if (!ToExLocS)
8776       return ToExLocS.takeError();
8777     unsigned TokenLen = FromSM.getFileIDSize(FromID);
8778     SourceLocation MLoc;
8779     if (FromEx.isMacroArgExpansion()) {
8780       MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen);
8781     } else {
8782       if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd()))
8783         MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen,
8784                                        FromEx.isExpansionTokenRange());
8785       else
8786         return ToExLocE.takeError();
8787     }
8788     ToID = ToSM.getFileID(MLoc);
8789   } else {
8790     const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
8791 
8792     if (!IsBuiltin && !Cache->BufferOverridden) {
8793       // Include location of this file.
8794       ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc());
8795       if (!ToIncludeLoc)
8796         return ToIncludeLoc.takeError();
8797 
8798       // Every FileID that is not the main FileID needs to have a valid include
8799       // location so that the include chain points to the main FileID. When
8800       // importing the main FileID (which has no include location), we need to
8801       // create a fake include location in the main file to keep this property
8802       // intact.
8803       SourceLocation ToIncludeLocOrFakeLoc = *ToIncludeLoc;
8804       if (FromID == FromSM.getMainFileID())
8805         ToIncludeLocOrFakeLoc = ToSM.getLocForStartOfFile(ToSM.getMainFileID());
8806 
8807       if (Cache->OrigEntry && Cache->OrigEntry->getDir()) {
8808         // FIXME: We probably want to use getVirtualFile(), so we don't hit the
8809         // disk again
8810         // FIXME: We definitely want to re-use the existing MemoryBuffer, rather
8811         // than mmap the files several times.
8812         auto Entry =
8813             ToFileManager.getOptionalFileRef(Cache->OrigEntry->getName());
8814         // FIXME: The filename may be a virtual name that does probably not
8815         // point to a valid file and we get no Entry here. In this case try with
8816         // the memory buffer below.
8817         if (Entry)
8818           ToID = ToSM.createFileID(*Entry, ToIncludeLocOrFakeLoc,
8819                                    FromSLoc.getFile().getFileCharacteristic());
8820       }
8821     }
8822 
8823     if (ToID.isInvalid() || IsBuiltin) {
8824       // FIXME: We want to re-use the existing MemoryBuffer!
8825       llvm::Optional<llvm::MemoryBufferRef> FromBuf =
8826           Cache->getBufferOrNone(FromContext.getDiagnostics(),
8827                                  FromSM.getFileManager(), SourceLocation{});
8828       if (!FromBuf)
8829         return llvm::make_error<ImportError>(ImportError::Unknown);
8830 
8831       std::unique_ptr<llvm::MemoryBuffer> ToBuf =
8832           llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(),
8833                                                FromBuf->getBufferIdentifier());
8834       ToID = ToSM.createFileID(std::move(ToBuf),
8835                                FromSLoc.getFile().getFileCharacteristic());
8836     }
8837   }
8838 
8839   assert(ToID.isValid() && "Unexpected invalid fileID was created.");
8840 
8841   ImportedFileIDs[FromID] = ToID;
8842 
8843   if (FileIDImportHandler)
8844     FileIDImportHandler(ToID, FromID);
8845 
8846   return ToID;
8847 }
8848 
Import(CXXCtorInitializer * From)8849 Expected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) {
8850   ExpectedExpr ToExprOrErr = Import(From->getInit());
8851   if (!ToExprOrErr)
8852     return ToExprOrErr.takeError();
8853 
8854   auto LParenLocOrErr = Import(From->getLParenLoc());
8855   if (!LParenLocOrErr)
8856     return LParenLocOrErr.takeError();
8857 
8858   auto RParenLocOrErr = Import(From->getRParenLoc());
8859   if (!RParenLocOrErr)
8860     return RParenLocOrErr.takeError();
8861 
8862   if (From->isBaseInitializer()) {
8863     auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
8864     if (!ToTInfoOrErr)
8865       return ToTInfoOrErr.takeError();
8866 
8867     SourceLocation EllipsisLoc;
8868     if (From->isPackExpansion())
8869       if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc()))
8870         return std::move(Err);
8871 
8872     return new (ToContext) CXXCtorInitializer(
8873         ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr,
8874         *ToExprOrErr, *RParenLocOrErr, EllipsisLoc);
8875   } else if (From->isMemberInitializer()) {
8876     ExpectedDecl ToFieldOrErr = Import(From->getMember());
8877     if (!ToFieldOrErr)
8878       return ToFieldOrErr.takeError();
8879 
8880     auto MemberLocOrErr = Import(From->getMemberLocation());
8881     if (!MemberLocOrErr)
8882       return MemberLocOrErr.takeError();
8883 
8884     return new (ToContext) CXXCtorInitializer(
8885         ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr,
8886         *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8887   } else if (From->isIndirectMemberInitializer()) {
8888     ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember());
8889     if (!ToIFieldOrErr)
8890       return ToIFieldOrErr.takeError();
8891 
8892     auto MemberLocOrErr = Import(From->getMemberLocation());
8893     if (!MemberLocOrErr)
8894       return MemberLocOrErr.takeError();
8895 
8896     return new (ToContext) CXXCtorInitializer(
8897         ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr),
8898         *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr);
8899   } else if (From->isDelegatingInitializer()) {
8900     auto ToTInfoOrErr = Import(From->getTypeSourceInfo());
8901     if (!ToTInfoOrErr)
8902       return ToTInfoOrErr.takeError();
8903 
8904     return new (ToContext)
8905         CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr,
8906                            *ToExprOrErr, *RParenLocOrErr);
8907   } else {
8908     // FIXME: assert?
8909     return make_error<ImportError>();
8910   }
8911 }
8912 
8913 Expected<CXXBaseSpecifier *>
Import(const CXXBaseSpecifier * BaseSpec)8914 ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
8915   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
8916   if (Pos != ImportedCXXBaseSpecifiers.end())
8917     return Pos->second;
8918 
8919   Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange());
8920   if (!ToSourceRange)
8921     return ToSourceRange.takeError();
8922   Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo());
8923   if (!ToTSI)
8924     return ToTSI.takeError();
8925   ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc());
8926   if (!ToEllipsisLoc)
8927     return ToEllipsisLoc.takeError();
8928   CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier(
8929       *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(),
8930       BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc);
8931   ImportedCXXBaseSpecifiers[BaseSpec] = Imported;
8932   return Imported;
8933 }
8934 
Import(const APValue & FromValue)8935 llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
8936   ASTNodeImporter Importer(*this);
8937   return Importer.ImportAPValue(FromValue);
8938 }
8939 
ImportDefinition(Decl * From)8940 Error ASTImporter::ImportDefinition(Decl *From) {
8941   ExpectedDecl ToOrErr = Import(From);
8942   if (!ToOrErr)
8943     return ToOrErr.takeError();
8944   Decl *To = *ToOrErr;
8945 
8946   auto *FromDC = cast<DeclContext>(From);
8947   ASTNodeImporter Importer(*this);
8948 
8949   if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
8950     if (!ToRecord->getDefinition()) {
8951       return Importer.ImportDefinition(
8952           cast<RecordDecl>(FromDC), ToRecord,
8953           ASTNodeImporter::IDK_Everything);
8954     }
8955   }
8956 
8957   if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
8958     if (!ToEnum->getDefinition()) {
8959       return Importer.ImportDefinition(
8960           cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything);
8961     }
8962   }
8963 
8964   if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
8965     if (!ToIFace->getDefinition()) {
8966       return Importer.ImportDefinition(
8967           cast<ObjCInterfaceDecl>(FromDC), ToIFace,
8968           ASTNodeImporter::IDK_Everything);
8969     }
8970   }
8971 
8972   if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
8973     if (!ToProto->getDefinition()) {
8974       return Importer.ImportDefinition(
8975           cast<ObjCProtocolDecl>(FromDC), ToProto,
8976           ASTNodeImporter::IDK_Everything);
8977     }
8978   }
8979 
8980   return Importer.ImportDeclContext(FromDC, true);
8981 }
8982 
Import(DeclarationName FromName)8983 Expected<DeclarationName> ASTImporter::Import(DeclarationName FromName) {
8984   if (!FromName)
8985     return DeclarationName{};
8986 
8987   switch (FromName.getNameKind()) {
8988   case DeclarationName::Identifier:
8989     return DeclarationName(Import(FromName.getAsIdentifierInfo()));
8990 
8991   case DeclarationName::ObjCZeroArgSelector:
8992   case DeclarationName::ObjCOneArgSelector:
8993   case DeclarationName::ObjCMultiArgSelector:
8994     if (auto ToSelOrErr = Import(FromName.getObjCSelector()))
8995       return DeclarationName(*ToSelOrErr);
8996     else
8997       return ToSelOrErr.takeError();
8998 
8999   case DeclarationName::CXXConstructorName: {
9000     if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9001       return ToContext.DeclarationNames.getCXXConstructorName(
9002           ToContext.getCanonicalType(*ToTyOrErr));
9003     else
9004       return ToTyOrErr.takeError();
9005   }
9006 
9007   case DeclarationName::CXXDestructorName: {
9008     if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9009       return ToContext.DeclarationNames.getCXXDestructorName(
9010           ToContext.getCanonicalType(*ToTyOrErr));
9011     else
9012       return ToTyOrErr.takeError();
9013   }
9014 
9015   case DeclarationName::CXXDeductionGuideName: {
9016     if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate()))
9017       return ToContext.DeclarationNames.getCXXDeductionGuideName(
9018           cast<TemplateDecl>(*ToTemplateOrErr));
9019     else
9020       return ToTemplateOrErr.takeError();
9021   }
9022 
9023   case DeclarationName::CXXConversionFunctionName: {
9024     if (auto ToTyOrErr = Import(FromName.getCXXNameType()))
9025       return ToContext.DeclarationNames.getCXXConversionFunctionName(
9026           ToContext.getCanonicalType(*ToTyOrErr));
9027     else
9028       return ToTyOrErr.takeError();
9029   }
9030 
9031   case DeclarationName::CXXOperatorName:
9032     return ToContext.DeclarationNames.getCXXOperatorName(
9033                                           FromName.getCXXOverloadedOperator());
9034 
9035   case DeclarationName::CXXLiteralOperatorName:
9036     return ToContext.DeclarationNames.getCXXLiteralOperatorName(
9037         Import(FromName.getCXXLiteralIdentifier()));
9038 
9039   case DeclarationName::CXXUsingDirective:
9040     // FIXME: STATICS!
9041     return DeclarationName::getUsingDirectiveName();
9042   }
9043 
9044   llvm_unreachable("Invalid DeclarationName Kind!");
9045 }
9046 
Import(const IdentifierInfo * FromId)9047 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
9048   if (!FromId)
9049     return nullptr;
9050 
9051   IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName());
9052 
9053   if (!ToId->getBuiltinID() && FromId->getBuiltinID())
9054     ToId->setBuiltinID(FromId->getBuiltinID());
9055 
9056   return ToId;
9057 }
9058 
Import(Selector FromSel)9059 Expected<Selector> ASTImporter::Import(Selector FromSel) {
9060   if (FromSel.isNull())
9061     return Selector{};
9062 
9063   SmallVector<IdentifierInfo *, 4> Idents;
9064   Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0)));
9065   for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I)
9066     Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I)));
9067   return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data());
9068 }
9069 
9070 llvm::Expected<APValue>
ImportAPValue(const APValue & FromValue)9071 ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
9072   APValue Result;
9073   llvm::Error Err = llvm::Error::success();
9074   auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
9075     for (unsigned Idx = 0; Idx < Size; Idx++) {
9076       APValue Tmp = importChecked(Err, From[Idx]);
9077       To[Idx] = Tmp;
9078     }
9079   };
9080   switch (FromValue.getKind()) {
9081   case APValue::None:
9082   case APValue::Indeterminate:
9083   case APValue::Int:
9084   case APValue::Float:
9085   case APValue::FixedPoint:
9086   case APValue::ComplexInt:
9087   case APValue::ComplexFloat:
9088     Result = FromValue;
9089     break;
9090   case APValue::Vector: {
9091     Result.MakeVector();
9092     MutableArrayRef<APValue> Elts =
9093         Result.setVectorUninit(FromValue.getVectorLength());
9094     ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
9095                Elts.data(), FromValue.getVectorLength());
9096     break;
9097   }
9098   case APValue::Array:
9099     Result.MakeArray(FromValue.getArrayInitializedElts(),
9100                      FromValue.getArraySize());
9101     ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
9102                ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
9103                FromValue.getArrayInitializedElts());
9104     break;
9105   case APValue::Struct:
9106     Result.MakeStruct(FromValue.getStructNumBases(),
9107                       FromValue.getStructNumFields());
9108     ImportLoop(
9109         ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
9110         ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
9111         FromValue.getStructNumBases() + FromValue.getStructNumFields());
9112     break;
9113   case APValue::Union: {
9114     Result.MakeUnion();
9115     const Decl *ImpFDecl = importChecked(Err, FromValue.getUnionField());
9116     APValue ImpValue = importChecked(Err, FromValue.getUnionValue());
9117     if (Err)
9118       return std::move(Err);
9119     Result.setUnion(cast<FieldDecl>(ImpFDecl), ImpValue);
9120     break;
9121   }
9122   case APValue::AddrLabelDiff: {
9123     Result.MakeAddrLabelDiff();
9124     const Expr *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
9125     const Expr *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
9126     if (Err)
9127       return std::move(Err);
9128     Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
9129                             cast<AddrLabelExpr>(ImpRHS));
9130     break;
9131   }
9132   case APValue::MemberPointer: {
9133     const Decl *ImpMemPtrDecl =
9134         importChecked(Err, FromValue.getMemberPointerDecl());
9135     if (Err)
9136       return std::move(Err);
9137     MutableArrayRef<const CXXRecordDecl *> ToPath =
9138         Result.setMemberPointerUninit(
9139             cast<const ValueDecl>(ImpMemPtrDecl),
9140             FromValue.isMemberPointerToDerivedMember(),
9141             FromValue.getMemberPointerPath().size());
9142     llvm::ArrayRef<const CXXRecordDecl *> FromPath =
9143         Result.getMemberPointerPath();
9144     for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
9145          Idx++) {
9146       const Decl *ImpDecl = importChecked(Err, FromPath[Idx]);
9147       if (Err)
9148         return std::move(Err);
9149       ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
9150     }
9151     break;
9152   }
9153   case APValue::LValue:
9154     APValue::LValueBase Base;
9155     QualType FromElemTy;
9156     if (FromValue.getLValueBase()) {
9157       assert(!FromValue.getLValueBase().is<DynamicAllocLValue>() &&
9158              "in C++20 dynamic allocation are transient so they shouldn't "
9159              "appear in the AST");
9160       if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
9161         if (const auto *E =
9162                 FromValue.getLValueBase().dyn_cast<const Expr *>()) {
9163           FromElemTy = E->getType();
9164           const Expr *ImpExpr = importChecked(Err, E);
9165           if (Err)
9166             return std::move(Err);
9167           Base = APValue::LValueBase(ImpExpr,
9168                                      FromValue.getLValueBase().getCallIndex(),
9169                                      FromValue.getLValueBase().getVersion());
9170         } else {
9171           FromElemTy =
9172               FromValue.getLValueBase().get<const ValueDecl *>()->getType();
9173           const Decl *ImpDecl = importChecked(
9174               Err, FromValue.getLValueBase().get<const ValueDecl *>());
9175           if (Err)
9176             return std::move(Err);
9177           Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
9178                                      FromValue.getLValueBase().getCallIndex(),
9179                                      FromValue.getLValueBase().getVersion());
9180         }
9181       } else {
9182         FromElemTy = FromValue.getLValueBase().getTypeInfoType();
9183         QualType ImpTypeInfo = importChecked(
9184             Err,
9185             QualType(FromValue.getLValueBase().get<TypeInfoLValue>().getType(),
9186                      0));
9187         QualType ImpType =
9188             importChecked(Err, FromValue.getLValueBase().getTypeInfoType());
9189         if (Err)
9190           return std::move(Err);
9191         Base = APValue::LValueBase::getTypeInfo(
9192             TypeInfoLValue(ImpTypeInfo.getTypePtr()), ImpType);
9193       }
9194     }
9195     CharUnits Offset = FromValue.getLValueOffset();
9196     unsigned PathLength = FromValue.getLValuePath().size();
9197     Result.MakeLValue();
9198     if (FromValue.hasLValuePath()) {
9199       MutableArrayRef<APValue::LValuePathEntry> ToPath = Result.setLValueUninit(
9200           Base, Offset, PathLength, FromValue.isLValueOnePastTheEnd(),
9201           FromValue.isNullPointer());
9202       llvm::ArrayRef<APValue::LValuePathEntry> FromPath =
9203           FromValue.getLValuePath();
9204       for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
9205         if (FromElemTy->isRecordType()) {
9206           const Decl *FromDecl =
9207               FromPath[LoopIdx].getAsBaseOrMember().getPointer();
9208           const Decl *ImpDecl = importChecked(Err, FromDecl);
9209           if (Err)
9210             return std::move(Err);
9211           if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
9212             FromElemTy = Importer.FromContext.getRecordType(RD);
9213           else
9214             FromElemTy = cast<ValueDecl>(FromDecl)->getType();
9215           ToPath[LoopIdx] = APValue::LValuePathEntry(APValue::BaseOrMemberType(
9216               ImpDecl, FromPath[LoopIdx].getAsBaseOrMember().getInt()));
9217         } else {
9218           FromElemTy =
9219               Importer.FromContext.getAsArrayType(FromElemTy)->getElementType();
9220           ToPath[LoopIdx] = APValue::LValuePathEntry::ArrayIndex(
9221               FromPath[LoopIdx].getAsArrayIndex());
9222         }
9223       }
9224     } else
9225       Result.setLValue(Base, Offset, APValue::NoLValuePath{},
9226                        FromValue.isNullPointer());
9227   }
9228   if (Err)
9229     return std::move(Err);
9230   return Result;
9231 }
9232 
HandleNameConflict(DeclarationName Name,DeclContext * DC,unsigned IDNS,NamedDecl ** Decls,unsigned NumDecls)9233 Expected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name,
9234                                                           DeclContext *DC,
9235                                                           unsigned IDNS,
9236                                                           NamedDecl **Decls,
9237                                                           unsigned NumDecls) {
9238   if (ODRHandling == ODRHandlingType::Conservative)
9239     // Report error at any name conflict.
9240     return make_error<ImportError>(ImportError::NameConflict);
9241   else
9242     // Allow to create the new Decl with the same name.
9243     return Name;
9244 }
9245 
ToDiag(SourceLocation Loc,unsigned DiagID)9246 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
9247   if (LastDiagFromFrom)
9248     ToContext.getDiagnostics().notePriorDiagnosticFrom(
9249       FromContext.getDiagnostics());
9250   LastDiagFromFrom = false;
9251   return ToContext.getDiagnostics().Report(Loc, DiagID);
9252 }
9253 
FromDiag(SourceLocation Loc,unsigned DiagID)9254 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
9255   if (!LastDiagFromFrom)
9256     FromContext.getDiagnostics().notePriorDiagnosticFrom(
9257       ToContext.getDiagnostics());
9258   LastDiagFromFrom = true;
9259   return FromContext.getDiagnostics().Report(Loc, DiagID);
9260 }
9261 
CompleteDecl(Decl * D)9262 void ASTImporter::CompleteDecl (Decl *D) {
9263   if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9264     if (!ID->getDefinition())
9265       ID->startDefinition();
9266   }
9267   else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
9268     if (!PD->getDefinition())
9269       PD->startDefinition();
9270   }
9271   else if (auto *TD = dyn_cast<TagDecl>(D)) {
9272     if (!TD->getDefinition() && !TD->isBeingDefined()) {
9273       TD->startDefinition();
9274       TD->setCompleteDefinition(true);
9275     }
9276   }
9277   else {
9278     assert(0 && "CompleteDecl called on a Decl that can't be completed");
9279   }
9280 }
9281 
MapImported(Decl * From,Decl * To)9282 Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
9283   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
9284   assert((Pos == ImportedDecls.end() || Pos->second == To) &&
9285       "Try to import an already imported Decl");
9286   if (Pos != ImportedDecls.end())
9287     return Pos->second;
9288   ImportedDecls[From] = To;
9289   // This mapping should be maintained only in this function. Therefore do not
9290   // check for additional consistency.
9291   ImportedFromDecls[To] = From;
9292   // In the case of TypedefNameDecl we create the Decl first and only then we
9293   // import and set its DeclContext. So, the DC is still not set when we reach
9294   // here from GetImportedOrCreateDecl.
9295   if (To->getDeclContext())
9296     AddToLookupTable(To);
9297   return To;
9298 }
9299 
9300 llvm::Optional<ImportError>
getImportDeclErrorIfAny(Decl * FromD) const9301 ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
9302   auto Pos = ImportDeclErrors.find(FromD);
9303   if (Pos != ImportDeclErrors.end())
9304     return Pos->second;
9305   else
9306     return Optional<ImportError>();
9307 }
9308 
setImportDeclError(Decl * From,ImportError Error)9309 void ASTImporter::setImportDeclError(Decl *From, ImportError Error) {
9310   auto InsertRes = ImportDeclErrors.insert({From, Error});
9311   (void)InsertRes;
9312   // Either we set the error for the first time, or we already had set one and
9313   // now we want to set the same error.
9314   assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);
9315 }
9316 
IsStructurallyEquivalent(QualType From,QualType To,bool Complain)9317 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
9318                                            bool Complain) {
9319   llvm::DenseMap<const Type *, const Type *>::iterator Pos =
9320       ImportedTypes.find(From.getTypePtr());
9321   if (Pos != ImportedTypes.end()) {
9322     if (ExpectedType ToFromOrErr = Import(From)) {
9323       if (ToContext.hasSameType(*ToFromOrErr, To))
9324         return true;
9325     } else {
9326       llvm::consumeError(ToFromOrErr.takeError());
9327     }
9328   }
9329 
9330   StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls,
9331                                    getStructuralEquivalenceKind(*this), false,
9332                                    Complain);
9333   return Ctx.IsEquivalent(From, To);
9334 }
9335