ASTImporter.cpp revision 353358
1341825Sdim//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===// 2203955Srdivacky// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6203955Srdivacky// 7203955Srdivacky//===----------------------------------------------------------------------===// 8203955Srdivacky// 9203955Srdivacky// This file defines the ASTImporter class which imports AST nodes from one 10203955Srdivacky// context into another context. 11203955Srdivacky// 12203955Srdivacky//===----------------------------------------------------------------------===// 13341825Sdim 14203955Srdivacky#include "clang/AST/ASTImporter.h" 15353358Sdim#include "clang/AST/ASTImporterSharedState.h" 16203955Srdivacky#include "clang/AST/ASTContext.h" 17203955Srdivacky#include "clang/AST/ASTDiagnostic.h" 18321369Sdim#include "clang/AST/ASTStructuralEquivalence.h" 19341825Sdim#include "clang/AST/Attr.h" 20341825Sdim#include "clang/AST/Decl.h" 21341825Sdim#include "clang/AST/DeclAccessPair.h" 22341825Sdim#include "clang/AST/DeclBase.h" 23203955Srdivacky#include "clang/AST/DeclCXX.h" 24341825Sdim#include "clang/AST/DeclFriend.h" 25341825Sdim#include "clang/AST/DeclGroup.h" 26203955Srdivacky#include "clang/AST/DeclObjC.h" 27341825Sdim#include "clang/AST/DeclTemplate.h" 28203955Srdivacky#include "clang/AST/DeclVisitor.h" 29341825Sdim#include "clang/AST/DeclarationName.h" 30341825Sdim#include "clang/AST/Expr.h" 31341825Sdim#include "clang/AST/ExprCXX.h" 32341825Sdim#include "clang/AST/ExprObjC.h" 33341825Sdim#include "clang/AST/ExternalASTSource.h" 34341825Sdim#include "clang/AST/LambdaCapture.h" 35341825Sdim#include "clang/AST/NestedNameSpecifier.h" 36341825Sdim#include "clang/AST/OperationKinds.h" 37341825Sdim#include "clang/AST/Stmt.h" 38341825Sdim#include "clang/AST/StmtCXX.h" 39341825Sdim#include "clang/AST/StmtObjC.h" 40203955Srdivacky#include "clang/AST/StmtVisitor.h" 41341825Sdim#include "clang/AST/TemplateBase.h" 42341825Sdim#include "clang/AST/TemplateName.h" 43341825Sdim#include "clang/AST/Type.h" 44341825Sdim#include "clang/AST/TypeLoc.h" 45203955Srdivacky#include "clang/AST/TypeVisitor.h" 46341825Sdim#include "clang/AST/UnresolvedSet.h" 47341825Sdim#include "clang/Basic/ExceptionSpecificationType.h" 48203955Srdivacky#include "clang/Basic/FileManager.h" 49341825Sdim#include "clang/Basic/IdentifierTable.h" 50341825Sdim#include "clang/Basic/LLVM.h" 51341825Sdim#include "clang/Basic/LangOptions.h" 52341825Sdim#include "clang/Basic/SourceLocation.h" 53203955Srdivacky#include "clang/Basic/SourceManager.h" 54341825Sdim#include "clang/Basic/Specifiers.h" 55341825Sdim#include "llvm/ADT/APSInt.h" 56341825Sdim#include "llvm/ADT/ArrayRef.h" 57341825Sdim#include "llvm/ADT/DenseMap.h" 58341825Sdim#include "llvm/ADT/None.h" 59341825Sdim#include "llvm/ADT/Optional.h" 60353358Sdim#include "llvm/ADT/ScopeExit.h" 61341825Sdim#include "llvm/ADT/STLExtras.h" 62341825Sdim#include "llvm/ADT/SmallVector.h" 63341825Sdim#include "llvm/Support/Casting.h" 64341825Sdim#include "llvm/Support/ErrorHandling.h" 65203955Srdivacky#include "llvm/Support/MemoryBuffer.h" 66341825Sdim#include <algorithm> 67341825Sdim#include <cassert> 68341825Sdim#include <cstddef> 69341825Sdim#include <memory> 70341825Sdim#include <type_traits> 71341825Sdim#include <utility> 72203955Srdivacky 73234353Sdimnamespace clang { 74341825Sdim 75344779Sdim using llvm::make_error; 76344779Sdim using llvm::Error; 77344779Sdim using llvm::Expected; 78344779Sdim using ExpectedType = llvm::Expected<QualType>; 79344779Sdim using ExpectedStmt = llvm::Expected<Stmt *>; 80344779Sdim using ExpectedExpr = llvm::Expected<Expr *>; 81344779Sdim using ExpectedDecl = llvm::Expected<Decl *>; 82344779Sdim using ExpectedSLoc = llvm::Expected<SourceLocation>; 83344779Sdim 84344779Sdim std::string ImportError::toString() const { 85344779Sdim // FIXME: Improve error texts. 86344779Sdim switch (Error) { 87344779Sdim case NameConflict: 88344779Sdim return "NameConflict"; 89344779Sdim case UnsupportedConstruct: 90344779Sdim return "UnsupportedConstruct"; 91344779Sdim case Unknown: 92344779Sdim return "Unknown error"; 93344779Sdim } 94344779Sdim llvm_unreachable("Invalid error code."); 95344779Sdim return "Invalid error code."; 96344779Sdim } 97344779Sdim 98344779Sdim void ImportError::log(raw_ostream &OS) const { 99344779Sdim OS << toString(); 100344779Sdim } 101344779Sdim 102344779Sdim std::error_code ImportError::convertToErrorCode() const { 103344779Sdim llvm_unreachable("Function not implemented."); 104344779Sdim } 105344779Sdim 106344779Sdim char ImportError::ID; 107344779Sdim 108341825Sdim template <class T> 109344779Sdim SmallVector<Decl *, 2> 110341825Sdim getCanonicalForwardRedeclChain(Redeclarable<T>* D) { 111344779Sdim SmallVector<Decl *, 2> Redecls; 112341825Sdim for (auto *R : D->getFirstDecl()->redecls()) { 113341825Sdim if (R != D->getFirstDecl()) 114341825Sdim Redecls.push_back(R); 115341825Sdim } 116341825Sdim Redecls.push_back(D->getFirstDecl()); 117341825Sdim std::reverse(Redecls.begin(), Redecls.end()); 118341825Sdim return Redecls; 119341825Sdim } 120341825Sdim 121341825Sdim SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) { 122344779Sdim if (auto *FD = dyn_cast<FunctionDecl>(D)) 123344779Sdim return getCanonicalForwardRedeclChain<FunctionDecl>(FD); 124344779Sdim if (auto *VD = dyn_cast<VarDecl>(D)) 125344779Sdim return getCanonicalForwardRedeclChain<VarDecl>(VD); 126344779Sdim if (auto *TD = dyn_cast<TagDecl>(D)) 127344779Sdim return getCanonicalForwardRedeclChain<TagDecl>(TD); 128344779Sdim llvm_unreachable("Bad declaration kind"); 129341825Sdim } 130341825Sdim 131341825Sdim void updateFlags(const Decl *From, Decl *To) { 132341825Sdim // Check if some flags or attrs are new in 'From' and copy into 'To'. 133341825Sdim // FIXME: Other flags or attrs? 134341825Sdim if (From->isUsed(false) && !To->isUsed(false)) 135341825Sdim To->setIsUsed(); 136341825Sdim } 137341825Sdim 138344779Sdim class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>, 139344779Sdim public DeclVisitor<ASTNodeImporter, ExpectedDecl>, 140344779Sdim public StmtVisitor<ASTNodeImporter, ExpectedStmt> { 141203955Srdivacky ASTImporter &Importer; 142309124Sdim 143344779Sdim // Use this instead of Importer.importInto . 144344779Sdim template <typename ImportT> 145344779Sdim LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) { 146344779Sdim return Importer.importInto(To, From); 147344779Sdim } 148344779Sdim 149344779Sdim // Use this to import pointers of specific type. 150344779Sdim template <typename ImportT> 151344779Sdim LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) { 152353358Sdim auto ToOrErr = Importer.Import(From); 153353358Sdim if (ToOrErr) 154353358Sdim To = cast_or_null<ImportT>(*ToOrErr); 155353358Sdim return ToOrErr.takeError(); 156344779Sdim } 157344779Sdim 158344779Sdim // Call the import function of ASTImporter for a baseclass of type `T` and 159344779Sdim // cast the return value to `T`. 160344779Sdim template <typename T> 161344779Sdim Expected<T *> import(T *From) { 162353358Sdim auto ToOrErr = Importer.Import(From); 163353358Sdim if (!ToOrErr) 164353358Sdim return ToOrErr.takeError(); 165353358Sdim return cast_or_null<T>(*ToOrErr); 166344779Sdim } 167344779Sdim 168344779Sdim template <typename T> 169344779Sdim Expected<T *> import(const T *From) { 170344779Sdim return import(const_cast<T *>(From)); 171344779Sdim } 172344779Sdim 173344779Sdim // Call the import function of ASTImporter for type `T`. 174344779Sdim template <typename T> 175344779Sdim Expected<T> import(const T &From) { 176353358Sdim return Importer.Import(From); 177344779Sdim } 178344779Sdim 179353358Sdim // Import an Optional<T> by importing the contained T, if any. 180353358Sdim template<typename T> 181353358Sdim Expected<Optional<T>> import(Optional<T> From) { 182353358Sdim if (!From) 183353358Sdim return Optional<T>(); 184353358Sdim return import(*From); 185353358Sdim } 186353358Sdim 187344779Sdim template <class T> 188344779Sdim Expected<std::tuple<T>> 189344779Sdim importSeq(const T &From) { 190344779Sdim Expected<T> ToOrErr = import(From); 191344779Sdim if (!ToOrErr) 192344779Sdim return ToOrErr.takeError(); 193344779Sdim return std::make_tuple<T>(std::move(*ToOrErr)); 194344779Sdim } 195344779Sdim 196344779Sdim // Import multiple objects with a single function call. 197344779Sdim // This should work for every type for which a variant of `import` exists. 198344779Sdim // The arguments are processed from left to right and import is stopped on 199344779Sdim // first error. 200344779Sdim template <class THead, class... TTail> 201344779Sdim Expected<std::tuple<THead, TTail...>> 202344779Sdim importSeq(const THead &FromHead, const TTail &...FromTail) { 203344779Sdim Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead); 204344779Sdim if (!ToHeadOrErr) 205344779Sdim return ToHeadOrErr.takeError(); 206344779Sdim Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...); 207344779Sdim if (!ToTailOrErr) 208344779Sdim return ToTailOrErr.takeError(); 209344779Sdim return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr); 210344779Sdim } 211344779Sdim 212344779Sdim// Wrapper for an overload set. 213341825Sdim template <typename ToDeclT> struct CallOverloadedCreateFun { 214341825Sdim template <typename... Args> 215341825Sdim auto operator()(Args &&... args) 216341825Sdim -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) { 217341825Sdim return ToDeclT::Create(std::forward<Args>(args)...); 218341825Sdim } 219341825Sdim }; 220341825Sdim 221341825Sdim // Always use these functions to create a Decl during import. There are 222341825Sdim // certain tasks which must be done after the Decl was created, e.g. we 223341825Sdim // must immediately register that as an imported Decl. The parameter `ToD` 224341825Sdim // will be set to the newly created Decl or if had been imported before 225341825Sdim // then to the already imported Decl. Returns a bool value set to true if 226341825Sdim // the `FromD` had been imported before. 227341825Sdim template <typename ToDeclT, typename FromDeclT, typename... Args> 228341825Sdim LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD, 229341825Sdim Args &&... args) { 230341825Sdim // There may be several overloads of ToDeclT::Create. We must make sure 231341825Sdim // to call the one which would be chosen by the arguments, thus we use a 232341825Sdim // wrapper for the overload set. 233341825Sdim CallOverloadedCreateFun<ToDeclT> OC; 234341825Sdim return GetImportedOrCreateSpecialDecl(ToD, OC, FromD, 235341825Sdim std::forward<Args>(args)...); 236341825Sdim } 237341825Sdim // Use this overload if a special Type is needed to be created. E.g if we 238341825Sdim // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl` 239341825Sdim // then: 240341825Sdim // TypedefNameDecl *ToTypedef; 241341825Sdim // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...); 242341825Sdim template <typename NewDeclT, typename ToDeclT, typename FromDeclT, 243341825Sdim typename... Args> 244341825Sdim LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD, 245341825Sdim Args &&... args) { 246341825Sdim CallOverloadedCreateFun<NewDeclT> OC; 247341825Sdim return GetImportedOrCreateSpecialDecl(ToD, OC, FromD, 248341825Sdim std::forward<Args>(args)...); 249341825Sdim } 250341825Sdim // Use this version if a special create function must be 251341825Sdim // used, e.g. CXXRecordDecl::CreateLambda . 252341825Sdim template <typename ToDeclT, typename CreateFunT, typename FromDeclT, 253341825Sdim typename... Args> 254341825Sdim LLVM_NODISCARD bool 255341825Sdim GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun, 256341825Sdim FromDeclT *FromD, Args &&... args) { 257353358Sdim if (Importer.getImportDeclErrorIfAny(FromD)) { 258353358Sdim ToD = nullptr; 259353358Sdim return true; // Already imported but with error. 260353358Sdim } 261341825Sdim ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD)); 262341825Sdim if (ToD) 263341825Sdim return true; // Already imported. 264341825Sdim ToD = CreateFun(std::forward<Args>(args)...); 265344779Sdim // Keep track of imported Decls. 266353358Sdim Importer.RegisterImportedDecl(FromD, ToD); 267341825Sdim InitializeImportedDecl(FromD, ToD); 268341825Sdim return false; // A new Decl is created. 269341825Sdim } 270341825Sdim 271341825Sdim void InitializeImportedDecl(Decl *FromD, Decl *ToD) { 272341825Sdim ToD->IdentifierNamespace = FromD->IdentifierNamespace; 273341825Sdim if (FromD->hasAttrs()) 274353358Sdim for (const Attr *FromAttr : FromD->getAttrs()) { 275353358Sdim // FIXME: Return of the error here is not possible until store of 276353358Sdim // import errors is implemented. 277353358Sdim auto ToAttrOrErr = import(FromAttr); 278353358Sdim if (ToAttrOrErr) 279353358Sdim ToD->addAttr(*ToAttrOrErr); 280353358Sdim else 281353358Sdim llvm::consumeError(ToAttrOrErr.takeError()); 282353358Sdim } 283341825Sdim if (FromD->isUsed()) 284341825Sdim ToD->setIsUsed(); 285341825Sdim if (FromD->isImplicit()) 286341825Sdim ToD->setImplicit(); 287341825Sdim } 288341825Sdim 289353358Sdim // Check if we have found an existing definition. Returns with that 290353358Sdim // definition if yes, otherwise returns null. 291353358Sdim Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) { 292353358Sdim const FunctionDecl *Definition = nullptr; 293353358Sdim if (D->doesThisDeclarationHaveABody() && 294353358Sdim FoundFunction->hasBody(Definition)) 295353358Sdim return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition)); 296353358Sdim return nullptr; 297353358Sdim } 298353358Sdim 299203955Srdivacky public: 300341825Sdim explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {} 301341825Sdim 302344779Sdim using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit; 303344779Sdim using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit; 304344779Sdim using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit; 305203955Srdivacky 306203955Srdivacky // Importing types 307344779Sdim ExpectedType VisitType(const Type *T); 308344779Sdim ExpectedType VisitAtomicType(const AtomicType *T); 309344779Sdim ExpectedType VisitBuiltinType(const BuiltinType *T); 310344779Sdim ExpectedType VisitDecayedType(const DecayedType *T); 311344779Sdim ExpectedType VisitComplexType(const ComplexType *T); 312344779Sdim ExpectedType VisitPointerType(const PointerType *T); 313344779Sdim ExpectedType VisitBlockPointerType(const BlockPointerType *T); 314344779Sdim ExpectedType VisitLValueReferenceType(const LValueReferenceType *T); 315344779Sdim ExpectedType VisitRValueReferenceType(const RValueReferenceType *T); 316344779Sdim ExpectedType VisitMemberPointerType(const MemberPointerType *T); 317344779Sdim ExpectedType VisitConstantArrayType(const ConstantArrayType *T); 318344779Sdim ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T); 319344779Sdim ExpectedType VisitVariableArrayType(const VariableArrayType *T); 320344779Sdim ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T); 321203955Srdivacky // FIXME: DependentSizedExtVectorType 322344779Sdim ExpectedType VisitVectorType(const VectorType *T); 323344779Sdim ExpectedType VisitExtVectorType(const ExtVectorType *T); 324344779Sdim ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T); 325344779Sdim ExpectedType VisitFunctionProtoType(const FunctionProtoType *T); 326344779Sdim ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T); 327344779Sdim ExpectedType VisitParenType(const ParenType *T); 328344779Sdim ExpectedType VisitTypedefType(const TypedefType *T); 329344779Sdim ExpectedType VisitTypeOfExprType(const TypeOfExprType *T); 330203955Srdivacky // FIXME: DependentTypeOfExprType 331344779Sdim ExpectedType VisitTypeOfType(const TypeOfType *T); 332344779Sdim ExpectedType VisitDecltypeType(const DecltypeType *T); 333344779Sdim ExpectedType VisitUnaryTransformType(const UnaryTransformType *T); 334344779Sdim ExpectedType VisitAutoType(const AutoType *T); 335344779Sdim ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T); 336203955Srdivacky // FIXME: DependentDecltypeType 337344779Sdim ExpectedType VisitRecordType(const RecordType *T); 338344779Sdim ExpectedType VisitEnumType(const EnumType *T); 339344779Sdim ExpectedType VisitAttributedType(const AttributedType *T); 340344779Sdim ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T); 341344779Sdim ExpectedType VisitSubstTemplateTypeParmType( 342344779Sdim const SubstTemplateTypeParmType *T); 343344779Sdim ExpectedType VisitTemplateSpecializationType( 344344779Sdim const TemplateSpecializationType *T); 345344779Sdim ExpectedType VisitElaboratedType(const ElaboratedType *T); 346344779Sdim ExpectedType VisitDependentNameType(const DependentNameType *T); 347344779Sdim ExpectedType VisitPackExpansionType(const PackExpansionType *T); 348344779Sdim ExpectedType VisitDependentTemplateSpecializationType( 349341825Sdim const DependentTemplateSpecializationType *T); 350344779Sdim ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T); 351344779Sdim ExpectedType VisitObjCObjectType(const ObjCObjectType *T); 352344779Sdim ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 353341825Sdim 354341825Sdim // Importing declarations 355344779Sdim Error ImportDeclParts( 356344779Sdim NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, 357344779Sdim DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc); 358344779Sdim Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 359344779Sdim Error ImportDeclarationNameLoc( 360344779Sdim const DeclarationNameInfo &From, DeclarationNameInfo &To); 361344779Sdim Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 362344779Sdim Error ImportDeclContext( 363344779Sdim Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC); 364344779Sdim Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To); 365309124Sdim 366344779Sdim Expected<CXXCastPath> ImportCastPath(CastExpr *E); 367314564Sdim 368341825Sdim using Designator = DesignatedInitExpr::Designator; 369341825Sdim 370341825Sdim /// What we should import from the definition. 371341825Sdim enum ImportDefinitionKind { 372341825Sdim /// Import the default subset of the definition, which might be 373234353Sdim /// nothing (if minimal import is set) or might be everything (if minimal 374234353Sdim /// import is not set). 375234353Sdim IDK_Default, 376341825Sdim /// Import everything. 377234353Sdim IDK_Everything, 378341825Sdim /// Import only the bare bones needed to establish a valid 379234353Sdim /// DeclContext. 380234353Sdim IDK_Basic 381234353Sdim }; 382234353Sdim 383234353Sdim bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 384234353Sdim return IDK == IDK_Everything || 385234353Sdim (IDK == IDK_Default && !Importer.isMinimalImport()); 386234353Sdim } 387234353Sdim 388344779Sdim Error ImportInitializer(VarDecl *From, VarDecl *To); 389344779Sdim Error ImportDefinition( 390344779Sdim RecordDecl *From, RecordDecl *To, 391344779Sdim ImportDefinitionKind Kind = IDK_Default); 392344779Sdim Error ImportDefinition( 393344779Sdim EnumDecl *From, EnumDecl *To, 394344779Sdim ImportDefinitionKind Kind = IDK_Default); 395344779Sdim Error ImportDefinition( 396344779Sdim ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 397344779Sdim ImportDefinitionKind Kind = IDK_Default); 398344779Sdim Error ImportDefinition( 399344779Sdim ObjCProtocolDecl *From, ObjCProtocolDecl *To, 400344779Sdim ImportDefinitionKind Kind = IDK_Default); 401344779Sdim Error ImportTemplateArguments( 402344779Sdim const TemplateArgument *FromArgs, unsigned NumFromArgs, 403344779Sdim SmallVectorImpl<TemplateArgument> &ToArgs); 404344779Sdim Expected<TemplateArgument> 405344779Sdim ImportTemplateArgument(const TemplateArgument &From); 406341825Sdim 407327952Sdim template <typename InContainerTy> 408344779Sdim Error ImportTemplateArgumentListInfo( 409344779Sdim const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo); 410341825Sdim 411341825Sdim template<typename InContainerTy> 412344779Sdim Error ImportTemplateArgumentListInfo( 413344779Sdim SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc, 414344779Sdim const InContainerTy &Container, TemplateArgumentListInfo &Result); 415341825Sdim 416341825Sdim using TemplateArgsTy = SmallVector<TemplateArgument, 8>; 417344779Sdim using FunctionTemplateAndArgsTy = 418344779Sdim std::tuple<FunctionTemplateDecl *, TemplateArgsTy>; 419344779Sdim Expected<FunctionTemplateAndArgsTy> 420341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization( 421341825Sdim FunctionDecl *FromFD); 422353358Sdim Error ImportTemplateParameterLists(const DeclaratorDecl *FromD, 423353358Sdim DeclaratorDecl *ToD); 424341825Sdim 425344779Sdim Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD); 426341825Sdim 427353358Sdim Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD); 428353358Sdim 429353358Sdim template <typename T> 430353358Sdim bool hasSameVisibilityContext(T *Found, T *From); 431353358Sdim 432341825Sdim bool IsStructuralMatch(Decl *From, Decl *To, bool Complain); 433239462Sdim bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 434239462Sdim bool Complain = true); 435261991Sdim bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 436261991Sdim bool Complain = true); 437203955Srdivacky bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 438249423Sdim bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 439327952Sdim bool IsStructuralMatch(FunctionTemplateDecl *From, 440327952Sdim FunctionTemplateDecl *To); 441341825Sdim bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To); 442218893Sdim bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 443261991Sdim bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 444344779Sdim ExpectedDecl VisitDecl(Decl *D); 445344779Sdim ExpectedDecl VisitImportDecl(ImportDecl *D); 446344779Sdim ExpectedDecl VisitEmptyDecl(EmptyDecl *D); 447344779Sdim ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D); 448344779Sdim ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D); 449344779Sdim ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D); 450344779Sdim ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D); 451344779Sdim ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 452344779Sdim ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 453344779Sdim ExpectedDecl VisitTypedefDecl(TypedefDecl *D); 454344779Sdim ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D); 455344779Sdim ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 456344779Sdim ExpectedDecl VisitLabelDecl(LabelDecl *D); 457344779Sdim ExpectedDecl VisitEnumDecl(EnumDecl *D); 458344779Sdim ExpectedDecl VisitRecordDecl(RecordDecl *D); 459344779Sdim ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D); 460344779Sdim ExpectedDecl VisitFunctionDecl(FunctionDecl *D); 461344779Sdim ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D); 462344779Sdim ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D); 463344779Sdim ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D); 464344779Sdim ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D); 465344779Sdim ExpectedDecl VisitFieldDecl(FieldDecl *D); 466344779Sdim ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D); 467344779Sdim ExpectedDecl VisitFriendDecl(FriendDecl *D); 468344779Sdim ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D); 469344779Sdim ExpectedDecl VisitVarDecl(VarDecl *D); 470344779Sdim ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D); 471344779Sdim ExpectedDecl VisitParmVarDecl(ParmVarDecl *D); 472344779Sdim ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D); 473344779Sdim ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 474344779Sdim ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D); 475344779Sdim ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D); 476344779Sdim ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D); 477344779Sdim ExpectedDecl VisitUsingDecl(UsingDecl *D); 478344779Sdim ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D); 479344779Sdim ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 480344779Sdim ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 481344779Sdim ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 482288943Sdim 483344779Sdim Expected<ObjCTypeParamList *> 484344779Sdim ImportObjCTypeParamList(ObjCTypeParamList *list); 485344779Sdim 486344779Sdim ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 487344779Sdim ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 488344779Sdim ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D); 489344779Sdim ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D); 490344779Sdim ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 491344779Sdim ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 492344779Sdim ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 493344779Sdim ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 494344779Sdim ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D); 495344779Sdim ExpectedDecl VisitClassTemplateSpecializationDecl( 496218893Sdim ClassTemplateSpecializationDecl *D); 497344779Sdim ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D); 498344779Sdim ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 499344779Sdim ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 500261991Sdim 501203955Srdivacky // Importing statements 502344779Sdim ExpectedStmt VisitStmt(Stmt *S); 503344779Sdim ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S); 504344779Sdim ExpectedStmt VisitDeclStmt(DeclStmt *S); 505344779Sdim ExpectedStmt VisitNullStmt(NullStmt *S); 506344779Sdim ExpectedStmt VisitCompoundStmt(CompoundStmt *S); 507344779Sdim ExpectedStmt VisitCaseStmt(CaseStmt *S); 508344779Sdim ExpectedStmt VisitDefaultStmt(DefaultStmt *S); 509344779Sdim ExpectedStmt VisitLabelStmt(LabelStmt *S); 510344779Sdim ExpectedStmt VisitAttributedStmt(AttributedStmt *S); 511344779Sdim ExpectedStmt VisitIfStmt(IfStmt *S); 512344779Sdim ExpectedStmt VisitSwitchStmt(SwitchStmt *S); 513344779Sdim ExpectedStmt VisitWhileStmt(WhileStmt *S); 514344779Sdim ExpectedStmt VisitDoStmt(DoStmt *S); 515344779Sdim ExpectedStmt VisitForStmt(ForStmt *S); 516344779Sdim ExpectedStmt VisitGotoStmt(GotoStmt *S); 517344779Sdim ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S); 518344779Sdim ExpectedStmt VisitContinueStmt(ContinueStmt *S); 519344779Sdim ExpectedStmt VisitBreakStmt(BreakStmt *S); 520344779Sdim ExpectedStmt VisitReturnStmt(ReturnStmt *S); 521288943Sdim // FIXME: MSAsmStmt 522288943Sdim // FIXME: SEHExceptStmt 523288943Sdim // FIXME: SEHFinallyStmt 524288943Sdim // FIXME: SEHTryStmt 525288943Sdim // FIXME: SEHLeaveStmt 526288943Sdim // FIXME: CapturedStmt 527344779Sdim ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S); 528344779Sdim ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S); 529344779Sdim ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S); 530288943Sdim // FIXME: MSDependentExistsStmt 531344779Sdim ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 532344779Sdim ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 533344779Sdim ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 534344779Sdim ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S); 535344779Sdim ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 536344779Sdim ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 537344779Sdim ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 538203955Srdivacky 539203955Srdivacky // Importing expressions 540344779Sdim ExpectedStmt VisitExpr(Expr *E); 541344779Sdim ExpectedStmt VisitVAArgExpr(VAArgExpr *E); 542353358Sdim ExpectedStmt VisitChooseExpr(ChooseExpr *E); 543344779Sdim ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E); 544344779Sdim ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E); 545344779Sdim ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E); 546344779Sdim ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); 547344779Sdim ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E); 548344779Sdim ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); 549344779Sdim ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E); 550344779Sdim ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E); 551344779Sdim ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E); 552344779Sdim ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E); 553344779Sdim ExpectedStmt VisitStringLiteral(StringLiteral *E); 554344779Sdim ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 555344779Sdim ExpectedStmt VisitAtomicExpr(AtomicExpr *E); 556344779Sdim ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E); 557344779Sdim ExpectedStmt VisitConstantExpr(ConstantExpr *E); 558344779Sdim ExpectedStmt VisitParenExpr(ParenExpr *E); 559344779Sdim ExpectedStmt VisitParenListExpr(ParenListExpr *E); 560344779Sdim ExpectedStmt VisitStmtExpr(StmtExpr *E); 561344779Sdim ExpectedStmt VisitUnaryOperator(UnaryOperator *E); 562344779Sdim ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 563344779Sdim ExpectedStmt VisitBinaryOperator(BinaryOperator *E); 564344779Sdim ExpectedStmt VisitConditionalOperator(ConditionalOperator *E); 565344779Sdim ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E); 566344779Sdim ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E); 567344779Sdim ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 568344779Sdim ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E); 569344779Sdim ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E); 570344779Sdim ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E); 571344779Sdim ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E); 572344779Sdim ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E); 573344779Sdim ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE); 574344779Sdim ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E); 575344779Sdim ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E); 576344779Sdim ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); 577344779Sdim ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 578344779Sdim ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 579344779Sdim ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); 580344779Sdim ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 581344779Sdim ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E); 582344779Sdim ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E); 583344779Sdim ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E); 584344779Sdim ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E); 585344779Sdim ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E); 586344779Sdim ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E); 587344779Sdim ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 588344779Sdim ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 589344779Sdim ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); 590344779Sdim ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E); 591344779Sdim ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E); 592344779Sdim ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E); 593344779Sdim ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E); 594344779Sdim ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); 595344779Sdim ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 596344779Sdim ExpectedStmt VisitMemberExpr(MemberExpr *E); 597344779Sdim ExpectedStmt VisitCallExpr(CallExpr *E); 598344779Sdim ExpectedStmt VisitLambdaExpr(LambdaExpr *LE); 599344779Sdim ExpectedStmt VisitInitListExpr(InitListExpr *E); 600344779Sdim ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E); 601344779Sdim ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E); 602344779Sdim ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E); 603344779Sdim ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E); 604344779Sdim ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E); 605344779Sdim ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E); 606344779Sdim ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E); 607344779Sdim ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E); 608344779Sdim ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E); 609309124Sdim 610309124Sdim template<typename IIter, typename OIter> 611344779Sdim Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) { 612341825Sdim using ItemT = typename std::remove_reference<decltype(*Obegin)>::type; 613344779Sdim for (; Ibegin != Iend; ++Ibegin, ++Obegin) { 614344779Sdim Expected<ItemT> ToOrErr = import(*Ibegin); 615344779Sdim if (!ToOrErr) 616344779Sdim return ToOrErr.takeError(); 617344779Sdim *Obegin = *ToOrErr; 618344779Sdim } 619344779Sdim return Error::success(); 620309124Sdim } 621309124Sdim 622344779Sdim // Import every item from a container structure into an output container. 623344779Sdim // If error occurs, stops at first error and returns the error. 624344779Sdim // The output container should have space for all needed elements (it is not 625344779Sdim // expanded, new items are put into from the beginning). 626314564Sdim template<typename InContainerTy, typename OutContainerTy> 627344779Sdim Error ImportContainerChecked( 628344779Sdim const InContainerTy &InContainer, OutContainerTy &OutContainer) { 629344779Sdim return ImportArrayChecked( 630344779Sdim InContainer.begin(), InContainer.end(), OutContainer.begin()); 631314564Sdim } 632314564Sdim 633314564Sdim template<typename InContainerTy, typename OIter> 634344779Sdim Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) { 635314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin); 636314564Sdim } 637309124Sdim 638321369Sdim void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod); 639341825Sdim 640344779Sdim Expected<FunctionDecl *> FindFunctionTemplateSpecialization( 641344779Sdim FunctionDecl *FromFD); 642203955Srdivacky }; 643341825Sdim 644341825Sdimtemplate <typename InContainerTy> 645344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo( 646341825Sdim SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc, 647341825Sdim const InContainerTy &Container, TemplateArgumentListInfo &Result) { 648344779Sdim auto ToLAngleLocOrErr = import(FromLAngleLoc); 649344779Sdim if (!ToLAngleLocOrErr) 650344779Sdim return ToLAngleLocOrErr.takeError(); 651344779Sdim auto ToRAngleLocOrErr = import(FromRAngleLoc); 652344779Sdim if (!ToRAngleLocOrErr) 653344779Sdim return ToRAngleLocOrErr.takeError(); 654344779Sdim 655344779Sdim TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr); 656344779Sdim if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo)) 657344779Sdim return Err; 658341825Sdim Result = ToTAInfo; 659344779Sdim return Error::success(); 660203955Srdivacky} 661203955Srdivacky 662341825Sdimtemplate <> 663344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>( 664341825Sdim const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) { 665341825Sdim return ImportTemplateArgumentListInfo( 666341825Sdim From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result); 667341825Sdim} 668341825Sdim 669341825Sdimtemplate <> 670344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo< 671344779Sdim ASTTemplateArgumentListInfo>( 672344779Sdim const ASTTemplateArgumentListInfo &From, 673344779Sdim TemplateArgumentListInfo &Result) { 674344779Sdim return ImportTemplateArgumentListInfo( 675344779Sdim From.LAngleLoc, From.RAngleLoc, From.arguments(), Result); 676341825Sdim} 677341825Sdim 678344779SdimExpected<ASTNodeImporter::FunctionTemplateAndArgsTy> 679341825SdimASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization( 680341825Sdim FunctionDecl *FromFD) { 681341825Sdim assert(FromFD->getTemplatedKind() == 682344779Sdim FunctionDecl::TK_FunctionTemplateSpecialization); 683344779Sdim 684344779Sdim FunctionTemplateAndArgsTy Result; 685344779Sdim 686341825Sdim auto *FTSInfo = FromFD->getTemplateSpecializationInfo(); 687344779Sdim if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate())) 688344779Sdim return std::move(Err); 689341825Sdim 690341825Sdim // Import template arguments. 691341825Sdim auto TemplArgs = FTSInfo->TemplateArguments->asArray(); 692344779Sdim if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(), 693344779Sdim std::get<1>(Result))) 694344779Sdim return std::move(Err); 695341825Sdim 696344779Sdim return Result; 697341825Sdim} 698341825Sdim 699344779Sdimtemplate <> 700344779SdimExpected<TemplateParameterList *> 701344779SdimASTNodeImporter::import(TemplateParameterList *From) { 702344779Sdim SmallVector<NamedDecl *, 4> To(From->size()); 703344779Sdim if (Error Err = ImportContainerChecked(*From, To)) 704344779Sdim return std::move(Err); 705344779Sdim 706344779Sdim ExpectedExpr ToRequiresClause = import(From->getRequiresClause()); 707344779Sdim if (!ToRequiresClause) 708344779Sdim return ToRequiresClause.takeError(); 709344779Sdim 710344779Sdim auto ToTemplateLocOrErr = import(From->getTemplateLoc()); 711344779Sdim if (!ToTemplateLocOrErr) 712344779Sdim return ToTemplateLocOrErr.takeError(); 713344779Sdim auto ToLAngleLocOrErr = import(From->getLAngleLoc()); 714344779Sdim if (!ToLAngleLocOrErr) 715344779Sdim return ToLAngleLocOrErr.takeError(); 716344779Sdim auto ToRAngleLocOrErr = import(From->getRAngleLoc()); 717344779Sdim if (!ToRAngleLocOrErr) 718344779Sdim return ToRAngleLocOrErr.takeError(); 719344779Sdim 720344779Sdim return TemplateParameterList::Create( 721344779Sdim Importer.getToContext(), 722344779Sdim *ToTemplateLocOrErr, 723344779Sdim *ToLAngleLocOrErr, 724344779Sdim To, 725344779Sdim *ToRAngleLocOrErr, 726344779Sdim *ToRequiresClause); 727344779Sdim} 728344779Sdim 729344779Sdimtemplate <> 730344779SdimExpected<TemplateArgument> 731344779SdimASTNodeImporter::import(const TemplateArgument &From) { 732344779Sdim switch (From.getKind()) { 733344779Sdim case TemplateArgument::Null: 734344779Sdim return TemplateArgument(); 735344779Sdim 736344779Sdim case TemplateArgument::Type: { 737344779Sdim ExpectedType ToTypeOrErr = import(From.getAsType()); 738344779Sdim if (!ToTypeOrErr) 739344779Sdim return ToTypeOrErr.takeError(); 740344779Sdim return TemplateArgument(*ToTypeOrErr); 741344779Sdim } 742344779Sdim 743344779Sdim case TemplateArgument::Integral: { 744344779Sdim ExpectedType ToTypeOrErr = import(From.getIntegralType()); 745344779Sdim if (!ToTypeOrErr) 746344779Sdim return ToTypeOrErr.takeError(); 747344779Sdim return TemplateArgument(From, *ToTypeOrErr); 748344779Sdim } 749344779Sdim 750344779Sdim case TemplateArgument::Declaration: { 751344779Sdim Expected<ValueDecl *> ToOrErr = import(From.getAsDecl()); 752344779Sdim if (!ToOrErr) 753344779Sdim return ToOrErr.takeError(); 754344779Sdim ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl()); 755344779Sdim if (!ToTypeOrErr) 756344779Sdim return ToTypeOrErr.takeError(); 757344779Sdim return TemplateArgument(*ToOrErr, *ToTypeOrErr); 758344779Sdim } 759344779Sdim 760344779Sdim case TemplateArgument::NullPtr: { 761344779Sdim ExpectedType ToTypeOrErr = import(From.getNullPtrType()); 762344779Sdim if (!ToTypeOrErr) 763344779Sdim return ToTypeOrErr.takeError(); 764344779Sdim return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true); 765344779Sdim } 766344779Sdim 767344779Sdim case TemplateArgument::Template: { 768344779Sdim Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate()); 769344779Sdim if (!ToTemplateOrErr) 770344779Sdim return ToTemplateOrErr.takeError(); 771344779Sdim 772344779Sdim return TemplateArgument(*ToTemplateOrErr); 773344779Sdim } 774344779Sdim 775344779Sdim case TemplateArgument::TemplateExpansion: { 776344779Sdim Expected<TemplateName> ToTemplateOrErr = 777344779Sdim import(From.getAsTemplateOrTemplatePattern()); 778344779Sdim if (!ToTemplateOrErr) 779344779Sdim return ToTemplateOrErr.takeError(); 780344779Sdim 781344779Sdim return TemplateArgument( 782344779Sdim *ToTemplateOrErr, From.getNumTemplateExpansions()); 783344779Sdim } 784344779Sdim 785344779Sdim case TemplateArgument::Expression: 786344779Sdim if (ExpectedExpr ToExpr = import(From.getAsExpr())) 787344779Sdim return TemplateArgument(*ToExpr); 788344779Sdim else 789344779Sdim return ToExpr.takeError(); 790344779Sdim 791344779Sdim case TemplateArgument::Pack: { 792344779Sdim SmallVector<TemplateArgument, 2> ToPack; 793344779Sdim ToPack.reserve(From.pack_size()); 794344779Sdim if (Error Err = ImportTemplateArguments( 795344779Sdim From.pack_begin(), From.pack_size(), ToPack)) 796344779Sdim return std::move(Err); 797344779Sdim 798344779Sdim return TemplateArgument( 799344779Sdim llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 800344779Sdim } 801344779Sdim } 802344779Sdim 803344779Sdim llvm_unreachable("Invalid template argument kind"); 804344779Sdim} 805344779Sdim 806344779Sdimtemplate <> 807344779SdimExpected<TemplateArgumentLoc> 808344779SdimASTNodeImporter::import(const TemplateArgumentLoc &TALoc) { 809344779Sdim Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument()); 810344779Sdim if (!ArgOrErr) 811344779Sdim return ArgOrErr.takeError(); 812344779Sdim TemplateArgument Arg = *ArgOrErr; 813344779Sdim 814344779Sdim TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo(); 815344779Sdim 816344779Sdim TemplateArgumentLocInfo ToInfo; 817344779Sdim if (Arg.getKind() == TemplateArgument::Expression) { 818344779Sdim ExpectedExpr E = import(FromInfo.getAsExpr()); 819344779Sdim if (!E) 820344779Sdim return E.takeError(); 821344779Sdim ToInfo = TemplateArgumentLocInfo(*E); 822344779Sdim } else if (Arg.getKind() == TemplateArgument::Type) { 823344779Sdim if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo())) 824344779Sdim ToInfo = TemplateArgumentLocInfo(*TSIOrErr); 825344779Sdim else 826344779Sdim return TSIOrErr.takeError(); 827344779Sdim } else { 828344779Sdim auto ToTemplateQualifierLocOrErr = 829344779Sdim import(FromInfo.getTemplateQualifierLoc()); 830344779Sdim if (!ToTemplateQualifierLocOrErr) 831344779Sdim return ToTemplateQualifierLocOrErr.takeError(); 832344779Sdim auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc()); 833344779Sdim if (!ToTemplateNameLocOrErr) 834344779Sdim return ToTemplateNameLocOrErr.takeError(); 835344779Sdim auto ToTemplateEllipsisLocOrErr = 836344779Sdim import(FromInfo.getTemplateEllipsisLoc()); 837344779Sdim if (!ToTemplateEllipsisLocOrErr) 838344779Sdim return ToTemplateEllipsisLocOrErr.takeError(); 839344779Sdim 840344779Sdim ToInfo = TemplateArgumentLocInfo( 841344779Sdim *ToTemplateQualifierLocOrErr, 842344779Sdim *ToTemplateNameLocOrErr, 843344779Sdim *ToTemplateEllipsisLocOrErr); 844344779Sdim } 845344779Sdim 846344779Sdim return TemplateArgumentLoc(Arg, ToInfo); 847344779Sdim} 848344779Sdim 849344779Sdimtemplate <> 850344779SdimExpected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) { 851344779Sdim if (DG.isNull()) 852344779Sdim return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 853344779Sdim size_t NumDecls = DG.end() - DG.begin(); 854344779Sdim SmallVector<Decl *, 1> ToDecls; 855344779Sdim ToDecls.reserve(NumDecls); 856344779Sdim for (Decl *FromD : DG) { 857344779Sdim if (auto ToDOrErr = import(FromD)) 858344779Sdim ToDecls.push_back(*ToDOrErr); 859344779Sdim else 860344779Sdim return ToDOrErr.takeError(); 861344779Sdim } 862344779Sdim return DeclGroupRef::Create(Importer.getToContext(), 863344779Sdim ToDecls.begin(), 864344779Sdim NumDecls); 865344779Sdim} 866344779Sdim 867344779Sdimtemplate <> 868344779SdimExpected<ASTNodeImporter::Designator> 869344779SdimASTNodeImporter::import(const Designator &D) { 870344779Sdim if (D.isFieldDesignator()) { 871344779Sdim IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName()); 872344779Sdim 873344779Sdim ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc()); 874344779Sdim if (!ToDotLocOrErr) 875344779Sdim return ToDotLocOrErr.takeError(); 876344779Sdim 877344779Sdim ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc()); 878344779Sdim if (!ToFieldLocOrErr) 879344779Sdim return ToFieldLocOrErr.takeError(); 880344779Sdim 881344779Sdim return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr); 882344779Sdim } 883344779Sdim 884344779Sdim ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc()); 885344779Sdim if (!ToLBracketLocOrErr) 886344779Sdim return ToLBracketLocOrErr.takeError(); 887344779Sdim 888344779Sdim ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc()); 889344779Sdim if (!ToRBracketLocOrErr) 890344779Sdim return ToRBracketLocOrErr.takeError(); 891344779Sdim 892344779Sdim if (D.isArrayDesignator()) 893344779Sdim return Designator(D.getFirstExprIndex(), 894344779Sdim *ToLBracketLocOrErr, *ToRBracketLocOrErr); 895344779Sdim 896344779Sdim ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc()); 897344779Sdim if (!ToEllipsisLocOrErr) 898344779Sdim return ToEllipsisLocOrErr.takeError(); 899344779Sdim 900344779Sdim assert(D.isArrayRangeDesignator()); 901344779Sdim return Designator( 902344779Sdim D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr, 903344779Sdim *ToRBracketLocOrErr); 904344779Sdim} 905344779Sdim 906344779Sdimtemplate <> 907344779SdimExpected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) { 908344779Sdim VarDecl *Var = nullptr; 909344779Sdim if (From.capturesVariable()) { 910344779Sdim if (auto VarOrErr = import(From.getCapturedVar())) 911344779Sdim Var = *VarOrErr; 912344779Sdim else 913344779Sdim return VarOrErr.takeError(); 914344779Sdim } 915344779Sdim 916344779Sdim auto LocationOrErr = import(From.getLocation()); 917344779Sdim if (!LocationOrErr) 918344779Sdim return LocationOrErr.takeError(); 919344779Sdim 920344779Sdim SourceLocation EllipsisLoc; 921344779Sdim if (From.isPackExpansion()) 922344779Sdim if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc())) 923344779Sdim return std::move(Err); 924344779Sdim 925344779Sdim return LambdaCapture( 926344779Sdim *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var, 927344779Sdim EllipsisLoc); 928344779Sdim} 929344779Sdim 930341825Sdim} // namespace clang 931341825Sdim 932203955Srdivacky//---------------------------------------------------------------------------- 933203955Srdivacky// Import Types 934203955Srdivacky//---------------------------------------------------------------------------- 935203955Srdivacky 936321369Sdimusing namespace clang; 937321369Sdim 938344779SdimExpectedType ASTNodeImporter::VisitType(const Type *T) { 939203955Srdivacky Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 940203955Srdivacky << T->getTypeClassName(); 941344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 942203955Srdivacky} 943203955Srdivacky 944344779SdimExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){ 945344779Sdim ExpectedType UnderlyingTypeOrErr = import(T->getValueType()); 946344779Sdim if (!UnderlyingTypeOrErr) 947344779Sdim return UnderlyingTypeOrErr.takeError(); 948314564Sdim 949344779Sdim return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr); 950314564Sdim} 951314564Sdim 952344779SdimExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 953203955Srdivacky switch (T->getKind()) { 954309124Sdim#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 955309124Sdim case BuiltinType::Id: \ 956309124Sdim return Importer.getToContext().SingletonId; 957309124Sdim#include "clang/Basic/OpenCLImageTypes.def" 958344779Sdim#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 959344779Sdim case BuiltinType::Id: \ 960344779Sdim return Importer.getToContext().Id##Ty; 961344779Sdim#include "clang/Basic/OpenCLExtensionTypes.def" 962234353Sdim#define SHARED_SINGLETON_TYPE(Expansion) 963234353Sdim#define BUILTIN_TYPE(Id, SingletonId) \ 964234353Sdim case BuiltinType::Id: return Importer.getToContext().SingletonId; 965234353Sdim#include "clang/AST/BuiltinTypes.def" 966234353Sdim 967234353Sdim // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 968234353Sdim // context supports C++. 969234353Sdim 970234353Sdim // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 971234353Sdim // context supports ObjC. 972234353Sdim 973203955Srdivacky case BuiltinType::Char_U: 974341825Sdim // The context we're importing from has an unsigned 'char'. If we're 975341825Sdim // importing into a context with a signed 'char', translate to 976203955Srdivacky // 'unsigned char' instead. 977234353Sdim if (Importer.getToContext().getLangOpts().CharIsSigned) 978203955Srdivacky return Importer.getToContext().UnsignedCharTy; 979341825Sdim 980203955Srdivacky return Importer.getToContext().CharTy; 981203955Srdivacky 982203955Srdivacky case BuiltinType::Char_S: 983341825Sdim // The context we're importing from has an unsigned 'char'. If we're 984341825Sdim // importing into a context with a signed 'char', translate to 985203955Srdivacky // 'unsigned char' instead. 986234353Sdim if (!Importer.getToContext().getLangOpts().CharIsSigned) 987203955Srdivacky return Importer.getToContext().SignedCharTy; 988341825Sdim 989203955Srdivacky return Importer.getToContext().CharTy; 990203955Srdivacky 991218893Sdim case BuiltinType::WChar_S: 992218893Sdim case BuiltinType::WChar_U: 993203955Srdivacky // FIXME: If not in C++, shall we translate to the C equivalent of 994203955Srdivacky // wchar_t? 995203955Srdivacky return Importer.getToContext().WCharTy; 996234353Sdim } 997203955Srdivacky 998234353Sdim llvm_unreachable("Invalid BuiltinType Kind!"); 999203955Srdivacky} 1000203955Srdivacky 1001344779SdimExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) { 1002344779Sdim ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType()); 1003344779Sdim if (!ToOriginalTypeOrErr) 1004344779Sdim return ToOriginalTypeOrErr.takeError(); 1005314564Sdim 1006344779Sdim return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr); 1007314564Sdim} 1008314564Sdim 1009344779SdimExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 1010344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1011344779Sdim if (!ToElementTypeOrErr) 1012344779Sdim return ToElementTypeOrErr.takeError(); 1013341825Sdim 1014344779Sdim return Importer.getToContext().getComplexType(*ToElementTypeOrErr); 1015203955Srdivacky} 1016203955Srdivacky 1017344779SdimExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) { 1018344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1019344779Sdim if (!ToPointeeTypeOrErr) 1020344779Sdim return ToPointeeTypeOrErr.takeError(); 1021341825Sdim 1022344779Sdim return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr); 1023203955Srdivacky} 1024203955Srdivacky 1025344779SdimExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 1026203955Srdivacky // FIXME: Check for blocks support in "to" context. 1027344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1028344779Sdim if (!ToPointeeTypeOrErr) 1029344779Sdim return ToPointeeTypeOrErr.takeError(); 1030341825Sdim 1031344779Sdim return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr); 1032203955Srdivacky} 1033203955Srdivacky 1034344779SdimExpectedType 1035218893SdimASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 1036203955Srdivacky // FIXME: Check for C++ support in "to" context. 1037344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten()); 1038344779Sdim if (!ToPointeeTypeOrErr) 1039344779Sdim return ToPointeeTypeOrErr.takeError(); 1040341825Sdim 1041344779Sdim return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr); 1042203955Srdivacky} 1043203955Srdivacky 1044344779SdimExpectedType 1045218893SdimASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 1046203955Srdivacky // FIXME: Check for C++0x support in "to" context. 1047344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten()); 1048344779Sdim if (!ToPointeeTypeOrErr) 1049344779Sdim return ToPointeeTypeOrErr.takeError(); 1050341825Sdim 1051344779Sdim return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr); 1052203955Srdivacky} 1053203955Srdivacky 1054344779SdimExpectedType 1055344779SdimASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 1056203955Srdivacky // FIXME: Check for C++ support in "to" context. 1057344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1058344779Sdim if (!ToPointeeTypeOrErr) 1059344779Sdim return ToPointeeTypeOrErr.takeError(); 1060341825Sdim 1061344779Sdim ExpectedType ClassTypeOrErr = import(QualType(T->getClass(), 0)); 1062344779Sdim if (!ClassTypeOrErr) 1063344779Sdim return ClassTypeOrErr.takeError(); 1064344779Sdim 1065344779Sdim return Importer.getToContext().getMemberPointerType( 1066344779Sdim *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr()); 1067203955Srdivacky} 1068203955Srdivacky 1069344779SdimExpectedType 1070344779SdimASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 1071344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1072344779Sdim if (!ToElementTypeOrErr) 1073344779Sdim return ToElementTypeOrErr.takeError(); 1074341825Sdim 1075344779Sdim return Importer.getToContext().getConstantArrayType(*ToElementTypeOrErr, 1076203955Srdivacky T->getSize(), 1077203955Srdivacky T->getSizeModifier(), 1078203955Srdivacky T->getIndexTypeCVRQualifiers()); 1079203955Srdivacky} 1080203955Srdivacky 1081344779SdimExpectedType 1082218893SdimASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 1083344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1084344779Sdim if (!ToElementTypeOrErr) 1085344779Sdim return ToElementTypeOrErr.takeError(); 1086341825Sdim 1087344779Sdim return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr, 1088203955Srdivacky T->getSizeModifier(), 1089203955Srdivacky T->getIndexTypeCVRQualifiers()); 1090203955Srdivacky} 1091203955Srdivacky 1092344779SdimExpectedType 1093344779SdimASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 1094344779Sdim QualType ToElementType; 1095344779Sdim Expr *ToSizeExpr; 1096344779Sdim SourceRange ToBracketsRange; 1097344779Sdim if (auto Imp = importSeq( 1098344779Sdim T->getElementType(), T->getSizeExpr(), T->getBracketsRange())) 1099344779Sdim std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp; 1100344779Sdim else 1101344779Sdim return Imp.takeError(); 1102203955Srdivacky 1103344779Sdim return Importer.getToContext().getVariableArrayType( 1104344779Sdim ToElementType, ToSizeExpr, T->getSizeModifier(), 1105344779Sdim T->getIndexTypeCVRQualifiers(), ToBracketsRange); 1106203955Srdivacky} 1107203955Srdivacky 1108344779SdimExpectedType ASTNodeImporter::VisitDependentSizedArrayType( 1109341825Sdim const DependentSizedArrayType *T) { 1110344779Sdim QualType ToElementType; 1111344779Sdim Expr *ToSizeExpr; 1112344779Sdim SourceRange ToBracketsRange; 1113344779Sdim if (auto Imp = importSeq( 1114344779Sdim T->getElementType(), T->getSizeExpr(), T->getBracketsRange())) 1115344779Sdim std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp; 1116344779Sdim else 1117344779Sdim return Imp.takeError(); 1118341825Sdim // SizeExpr may be null if size is not specified directly. 1119341825Sdim // For example, 'int a[]'. 1120341825Sdim 1121341825Sdim return Importer.getToContext().getDependentSizedArrayType( 1122344779Sdim ToElementType, ToSizeExpr, T->getSizeModifier(), 1123344779Sdim T->getIndexTypeCVRQualifiers(), ToBracketsRange); 1124341825Sdim} 1125341825Sdim 1126344779SdimExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) { 1127344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1128344779Sdim if (!ToElementTypeOrErr) 1129344779Sdim return ToElementTypeOrErr.takeError(); 1130341825Sdim 1131344779Sdim return Importer.getToContext().getVectorType(*ToElementTypeOrErr, 1132203955Srdivacky T->getNumElements(), 1133218893Sdim T->getVectorKind()); 1134203955Srdivacky} 1135203955Srdivacky 1136344779SdimExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 1137344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1138344779Sdim if (!ToElementTypeOrErr) 1139344779Sdim return ToElementTypeOrErr.takeError(); 1140341825Sdim 1141344779Sdim return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr, 1142203955Srdivacky T->getNumElements()); 1143203955Srdivacky} 1144203955Srdivacky 1145344779SdimExpectedType 1146218893SdimASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 1147341825Sdim // FIXME: What happens if we're importing a function without a prototype 1148203955Srdivacky // into C++? Should we make it variadic? 1149344779Sdim ExpectedType ToReturnTypeOrErr = import(T->getReturnType()); 1150344779Sdim if (!ToReturnTypeOrErr) 1151344779Sdim return ToReturnTypeOrErr.takeError(); 1152206084Srdivacky 1153344779Sdim return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr, 1154206084Srdivacky T->getExtInfo()); 1155203955Srdivacky} 1156203955Srdivacky 1157344779SdimExpectedType 1158344779SdimASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 1159344779Sdim ExpectedType ToReturnTypeOrErr = import(T->getReturnType()); 1160344779Sdim if (!ToReturnTypeOrErr) 1161344779Sdim return ToReturnTypeOrErr.takeError(); 1162341825Sdim 1163203955Srdivacky // Import argument types 1164226633Sdim SmallVector<QualType, 4> ArgTypes; 1165276479Sdim for (const auto &A : T->param_types()) { 1166344779Sdim ExpectedType TyOrErr = import(A); 1167344779Sdim if (!TyOrErr) 1168344779Sdim return TyOrErr.takeError(); 1169344779Sdim ArgTypes.push_back(*TyOrErr); 1170203955Srdivacky } 1171341825Sdim 1172203955Srdivacky // Import exception types 1173226633Sdim SmallVector<QualType, 4> ExceptionTypes; 1174276479Sdim for (const auto &E : T->exceptions()) { 1175344779Sdim ExpectedType TyOrErr = import(E); 1176344779Sdim if (!TyOrErr) 1177344779Sdim return TyOrErr.takeError(); 1178344779Sdim ExceptionTypes.push_back(*TyOrErr); 1179203955Srdivacky } 1180218893Sdim 1181243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 1182243830Sdim FunctionProtoType::ExtProtoInfo ToEPI; 1183243830Sdim 1184344779Sdim auto Imp = importSeq( 1185344779Sdim FromEPI.ExceptionSpec.NoexceptExpr, 1186344779Sdim FromEPI.ExceptionSpec.SourceDecl, 1187344779Sdim FromEPI.ExceptionSpec.SourceTemplate); 1188344779Sdim if (!Imp) 1189344779Sdim return Imp.takeError(); 1190344779Sdim 1191243830Sdim ToEPI.ExtInfo = FromEPI.ExtInfo; 1192243830Sdim ToEPI.Variadic = FromEPI.Variadic; 1193243830Sdim ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 1194243830Sdim ToEPI.TypeQuals = FromEPI.TypeQuals; 1195243830Sdim ToEPI.RefQualifier = FromEPI.RefQualifier; 1196280031Sdim ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 1197280031Sdim ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 1198344779Sdim std::tie( 1199344779Sdim ToEPI.ExceptionSpec.NoexceptExpr, 1200344779Sdim ToEPI.ExceptionSpec.SourceDecl, 1201344779Sdim ToEPI.ExceptionSpec.SourceTemplate) = *Imp; 1202243830Sdim 1203344779Sdim return Importer.getToContext().getFunctionType( 1204344779Sdim *ToReturnTypeOrErr, ArgTypes, ToEPI); 1205203955Srdivacky} 1206203955Srdivacky 1207344779SdimExpectedType ASTNodeImporter::VisitUnresolvedUsingType( 1208327952Sdim const UnresolvedUsingType *T) { 1209344779Sdim UnresolvedUsingTypenameDecl *ToD; 1210344779Sdim Decl *ToPrevD; 1211344779Sdim if (auto Imp = importSeq(T->getDecl(), T->getDecl()->getPreviousDecl())) 1212344779Sdim std::tie(ToD, ToPrevD) = *Imp; 1213344779Sdim else 1214344779Sdim return Imp.takeError(); 1215327952Sdim 1216344779Sdim return Importer.getToContext().getTypeDeclType( 1217344779Sdim ToD, cast_or_null<TypeDecl>(ToPrevD)); 1218327952Sdim} 1219327952Sdim 1220344779SdimExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) { 1221344779Sdim ExpectedType ToInnerTypeOrErr = import(T->getInnerType()); 1222344779Sdim if (!ToInnerTypeOrErr) 1223344779Sdim return ToInnerTypeOrErr.takeError(); 1224341825Sdim 1225344779Sdim return Importer.getToContext().getParenType(*ToInnerTypeOrErr); 1226226633Sdim} 1227226633Sdim 1228344779SdimExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 1229344779Sdim Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl()); 1230344779Sdim if (!ToDeclOrErr) 1231344779Sdim return ToDeclOrErr.takeError(); 1232341825Sdim 1233344779Sdim return Importer.getToContext().getTypeDeclType(*ToDeclOrErr); 1234203955Srdivacky} 1235203955Srdivacky 1236344779SdimExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 1237344779Sdim ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr()); 1238344779Sdim if (!ToExprOrErr) 1239344779Sdim return ToExprOrErr.takeError(); 1240341825Sdim 1241344779Sdim return Importer.getToContext().getTypeOfExprType(*ToExprOrErr); 1242203955Srdivacky} 1243203955Srdivacky 1244344779SdimExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 1245344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1246344779Sdim if (!ToUnderlyingTypeOrErr) 1247344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1248341825Sdim 1249344779Sdim return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr); 1250203955Srdivacky} 1251203955Srdivacky 1252344779SdimExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 1253218893Sdim // FIXME: Make sure that the "to" context supports C++0x! 1254344779Sdim ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr()); 1255344779Sdim if (!ToExprOrErr) 1256344779Sdim return ToExprOrErr.takeError(); 1257341825Sdim 1258344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1259344779Sdim if (!ToUnderlyingTypeOrErr) 1260344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1261234353Sdim 1262344779Sdim return Importer.getToContext().getDecltypeType( 1263344779Sdim *ToExprOrErr, *ToUnderlyingTypeOrErr); 1264203955Srdivacky} 1265203955Srdivacky 1266344779SdimExpectedType 1267344779SdimASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 1268344779Sdim ExpectedType ToBaseTypeOrErr = import(T->getBaseType()); 1269344779Sdim if (!ToBaseTypeOrErr) 1270344779Sdim return ToBaseTypeOrErr.takeError(); 1271223017Sdim 1272344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1273344779Sdim if (!ToUnderlyingTypeOrErr) 1274344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1275344779Sdim 1276344779Sdim return Importer.getToContext().getUnaryTransformType( 1277344779Sdim *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind()); 1278223017Sdim} 1279223017Sdim 1280344779SdimExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) { 1281251662Sdim // FIXME: Make sure that the "to" context supports C++11! 1282344779Sdim ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType()); 1283344779Sdim if (!ToDeducedTypeOrErr) 1284344779Sdim return ToDeducedTypeOrErr.takeError(); 1285341825Sdim 1286344779Sdim return Importer.getToContext().getAutoType(*ToDeducedTypeOrErr, 1287344779Sdim T->getKeyword(), 1288261991Sdim /*IsDependent*/false); 1289218893Sdim} 1290218893Sdim 1291344779SdimExpectedType ASTNodeImporter::VisitInjectedClassNameType( 1292309124Sdim const InjectedClassNameType *T) { 1293344779Sdim Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl()); 1294344779Sdim if (!ToDeclOrErr) 1295344779Sdim return ToDeclOrErr.takeError(); 1296309124Sdim 1297344779Sdim ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType()); 1298344779Sdim if (!ToInjTypeOrErr) 1299344779Sdim return ToInjTypeOrErr.takeError(); 1300309124Sdim 1301309124Sdim // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading 1302309124Sdim // See comments in InjectedClassNameType definition for details 1303309124Sdim // return Importer.getToContext().getInjectedClassNameType(D, InjType); 1304309124Sdim enum { 1305309124Sdim TypeAlignmentInBits = 4, 1306309124Sdim TypeAlignment = 1 << TypeAlignmentInBits 1307309124Sdim }; 1308309124Sdim 1309309124Sdim return QualType(new (Importer.getToContext(), TypeAlignment) 1310344779Sdim InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0); 1311309124Sdim} 1312309124Sdim 1313344779SdimExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) { 1314344779Sdim Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl()); 1315344779Sdim if (!ToDeclOrErr) 1316344779Sdim return ToDeclOrErr.takeError(); 1317203955Srdivacky 1318344779Sdim return Importer.getToContext().getTagDeclType(*ToDeclOrErr); 1319203955Srdivacky} 1320203955Srdivacky 1321344779SdimExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) { 1322344779Sdim Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl()); 1323344779Sdim if (!ToDeclOrErr) 1324344779Sdim return ToDeclOrErr.takeError(); 1325203955Srdivacky 1326344779Sdim return Importer.getToContext().getTagDeclType(*ToDeclOrErr); 1327203955Srdivacky} 1328203955Srdivacky 1329344779SdimExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 1330344779Sdim ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType()); 1331344779Sdim if (!ToModifiedTypeOrErr) 1332344779Sdim return ToModifiedTypeOrErr.takeError(); 1333344779Sdim ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType()); 1334344779Sdim if (!ToEquivalentTypeOrErr) 1335344779Sdim return ToEquivalentTypeOrErr.takeError(); 1336288943Sdim 1337288943Sdim return Importer.getToContext().getAttributedType(T->getAttrKind(), 1338344779Sdim *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr); 1339288943Sdim} 1340288943Sdim 1341344779SdimExpectedType ASTNodeImporter::VisitTemplateTypeParmType( 1342309124Sdim const TemplateTypeParmType *T) { 1343344779Sdim Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl()); 1344344779Sdim if (!ToDeclOrErr) 1345344779Sdim return ToDeclOrErr.takeError(); 1346309124Sdim 1347309124Sdim return Importer.getToContext().getTemplateTypeParmType( 1348344779Sdim T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr); 1349309124Sdim} 1350309124Sdim 1351344779SdimExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType( 1352321369Sdim const SubstTemplateTypeParmType *T) { 1353344779Sdim ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0)); 1354344779Sdim if (!ReplacedOrErr) 1355344779Sdim return ReplacedOrErr.takeError(); 1356344779Sdim const TemplateTypeParmType *Replaced = 1357344779Sdim cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr()); 1358321369Sdim 1359344779Sdim ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType()); 1360344779Sdim if (!ToReplacementTypeOrErr) 1361344779Sdim return ToReplacementTypeOrErr.takeError(); 1362321369Sdim 1363321369Sdim return Importer.getToContext().getSubstTemplateTypeParmType( 1364344779Sdim Replaced, (*ToReplacementTypeOrErr).getCanonicalType()); 1365321369Sdim} 1366321369Sdim 1367344779SdimExpectedType ASTNodeImporter::VisitTemplateSpecializationType( 1368218893Sdim const TemplateSpecializationType *T) { 1369344779Sdim auto ToTemplateOrErr = import(T->getTemplateName()); 1370344779Sdim if (!ToTemplateOrErr) 1371344779Sdim return ToTemplateOrErr.takeError(); 1372341825Sdim 1373226633Sdim SmallVector<TemplateArgument, 2> ToTemplateArgs; 1374344779Sdim if (Error Err = ImportTemplateArguments( 1375344779Sdim T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 1376344779Sdim return std::move(Err); 1377341825Sdim 1378218893Sdim QualType ToCanonType; 1379218893Sdim if (!QualType(T, 0).isCanonical()) { 1380341825Sdim QualType FromCanonType 1381218893Sdim = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 1382344779Sdim if (ExpectedType TyOrErr = import(FromCanonType)) 1383344779Sdim ToCanonType = *TyOrErr; 1384344779Sdim else 1385344779Sdim return TyOrErr.takeError(); 1386218893Sdim } 1387344779Sdim return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr, 1388309124Sdim ToTemplateArgs, 1389218893Sdim ToCanonType); 1390218893Sdim} 1391218893Sdim 1392344779SdimExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 1393208600Srdivacky // Note: the qualifier in an ElaboratedType is optional. 1394344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1395344779Sdim if (!ToQualifierOrErr) 1396344779Sdim return ToQualifierOrErr.takeError(); 1397203955Srdivacky 1398344779Sdim ExpectedType ToNamedTypeOrErr = import(T->getNamedType()); 1399344779Sdim if (!ToNamedTypeOrErr) 1400344779Sdim return ToNamedTypeOrErr.takeError(); 1401203955Srdivacky 1402344779Sdim Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl()); 1403344779Sdim if (!ToOwnedTagDeclOrErr) 1404344779Sdim return ToOwnedTagDeclOrErr.takeError(); 1405341825Sdim 1406208600Srdivacky return Importer.getToContext().getElaboratedType(T->getKeyword(), 1407344779Sdim *ToQualifierOrErr, 1408344779Sdim *ToNamedTypeOrErr, 1409344779Sdim *ToOwnedTagDeclOrErr); 1410203955Srdivacky} 1411203955Srdivacky 1412344779SdimExpectedType 1413344779SdimASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) { 1414344779Sdim ExpectedType ToPatternOrErr = import(T->getPattern()); 1415344779Sdim if (!ToPatternOrErr) 1416344779Sdim return ToPatternOrErr.takeError(); 1417327952Sdim 1418344779Sdim return Importer.getToContext().getPackExpansionType(*ToPatternOrErr, 1419327952Sdim T->getNumExpansions()); 1420327952Sdim} 1421327952Sdim 1422344779SdimExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType( 1423341825Sdim const DependentTemplateSpecializationType *T) { 1424344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1425344779Sdim if (!ToQualifierOrErr) 1426344779Sdim return ToQualifierOrErr.takeError(); 1427341825Sdim 1428344779Sdim IdentifierInfo *ToName = Importer.Import(T->getIdentifier()); 1429341825Sdim 1430341825Sdim SmallVector<TemplateArgument, 2> ToPack; 1431341825Sdim ToPack.reserve(T->getNumArgs()); 1432344779Sdim if (Error Err = ImportTemplateArguments( 1433344779Sdim T->getArgs(), T->getNumArgs(), ToPack)) 1434344779Sdim return std::move(Err); 1435341825Sdim 1436341825Sdim return Importer.getToContext().getDependentTemplateSpecializationType( 1437344779Sdim T->getKeyword(), *ToQualifierOrErr, ToName, ToPack); 1438341825Sdim} 1439341825Sdim 1440344779SdimExpectedType 1441344779SdimASTNodeImporter::VisitDependentNameType(const DependentNameType *T) { 1442344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1443344779Sdim if (!ToQualifierOrErr) 1444344779Sdim return ToQualifierOrErr.takeError(); 1445341825Sdim 1446341825Sdim IdentifierInfo *Name = Importer.Import(T->getIdentifier()); 1447341825Sdim 1448344779Sdim QualType Canon; 1449344779Sdim if (T != T->getCanonicalTypeInternal().getTypePtr()) { 1450344779Sdim if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal())) 1451344779Sdim Canon = (*TyOrErr).getCanonicalType(); 1452344779Sdim else 1453344779Sdim return TyOrErr.takeError(); 1454344779Sdim } 1455341825Sdim 1456344779Sdim return Importer.getToContext().getDependentNameType(T->getKeyword(), 1457344779Sdim *ToQualifierOrErr, 1458341825Sdim Name, Canon); 1459341825Sdim} 1460341825Sdim 1461344779SdimExpectedType 1462344779SdimASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 1463344779Sdim Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl()); 1464344779Sdim if (!ToDeclOrErr) 1465344779Sdim return ToDeclOrErr.takeError(); 1466203955Srdivacky 1467344779Sdim return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr); 1468208600Srdivacky} 1469208600Srdivacky 1470344779SdimExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 1471344779Sdim ExpectedType ToBaseTypeOrErr = import(T->getBaseType()); 1472344779Sdim if (!ToBaseTypeOrErr) 1473344779Sdim return ToBaseTypeOrErr.takeError(); 1474208600Srdivacky 1475288943Sdim SmallVector<QualType, 4> TypeArgs; 1476288943Sdim for (auto TypeArg : T->getTypeArgsAsWritten()) { 1477344779Sdim if (ExpectedType TyOrErr = import(TypeArg)) 1478344779Sdim TypeArgs.push_back(*TyOrErr); 1479344779Sdim else 1480344779Sdim return TyOrErr.takeError(); 1481288943Sdim } 1482288943Sdim 1483226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 1484276479Sdim for (auto *P : T->quals()) { 1485344779Sdim if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P)) 1486344779Sdim Protocols.push_back(*ProtocolOrErr); 1487344779Sdim else 1488344779Sdim return ProtocolOrErr.takeError(); 1489344779Sdim 1490203955Srdivacky } 1491203955Srdivacky 1492344779Sdim return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs, 1493288943Sdim Protocols, 1494288943Sdim T->isKindOfTypeAsWritten()); 1495203955Srdivacky} 1496203955Srdivacky 1497344779SdimExpectedType 1498218893SdimASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 1499344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1500344779Sdim if (!ToPointeeTypeOrErr) 1501344779Sdim return ToPointeeTypeOrErr.takeError(); 1502203955Srdivacky 1503344779Sdim return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr); 1504203955Srdivacky} 1505203955Srdivacky 1506203955Srdivacky//---------------------------------------------------------------------------- 1507203955Srdivacky// Import Declarations 1508203955Srdivacky//---------------------------------------------------------------------------- 1509344779SdimError ASTNodeImporter::ImportDeclParts( 1510344779Sdim NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, 1511344779Sdim DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) { 1512341825Sdim // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop. 1513341825Sdim // example: int struct_in_proto(struct data_t{int a;int b;} *d); 1514341825Sdim DeclContext *OrigDC = D->getDeclContext(); 1515341825Sdim FunctionDecl *FunDecl; 1516341825Sdim if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) && 1517341825Sdim FunDecl->hasBody()) { 1518344779Sdim auto getLeafPointeeType = [](const Type *T) { 1519344779Sdim while (T->isPointerType() || T->isArrayType()) { 1520344779Sdim T = T->getPointeeOrArrayElementType(); 1521344779Sdim } 1522344779Sdim return T; 1523344779Sdim }; 1524344779Sdim for (const ParmVarDecl *P : FunDecl->parameters()) { 1525344779Sdim const Type *LeafT = 1526344779Sdim getLeafPointeeType(P->getType().getCanonicalType().getTypePtr()); 1527344779Sdim auto *RT = dyn_cast<RecordType>(LeafT); 1528344779Sdim if (RT && RT->getDecl() == D) { 1529344779Sdim Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 1530344779Sdim << D->getDeclKindName(); 1531344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 1532344779Sdim } 1533341825Sdim } 1534341825Sdim } 1535341825Sdim 1536203955Srdivacky // Import the context of this declaration. 1537344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 1538344779Sdim return Err; 1539341825Sdim 1540203955Srdivacky // Import the name of this declaration. 1541344779Sdim if (Error Err = importInto(Name, D->getDeclName())) 1542344779Sdim return Err; 1543341825Sdim 1544203955Srdivacky // Import the location of this declaration. 1545344779Sdim if (Error Err = importInto(Loc, D->getLocation())) 1546344779Sdim return Err; 1547344779Sdim 1548288943Sdim ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 1549344779Sdim if (ToD) 1550344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD)) 1551344779Sdim return Err; 1552344779Sdim 1553344779Sdim return Error::success(); 1554203955Srdivacky} 1555203955Srdivacky 1556344779SdimError ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 1557226633Sdim if (!FromD) 1558344779Sdim return Error::success(); 1559341825Sdim 1560344779Sdim if (!ToD) 1561344779Sdim if (Error Err = importInto(ToD, FromD)) 1562344779Sdim return Err; 1563341825Sdim 1564344779Sdim if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) { 1565344779Sdim if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) { 1566344779Sdim if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && 1567344779Sdim !ToRecord->getDefinition()) { 1568344779Sdim if (Error Err = ImportDefinition(FromRecord, ToRecord)) 1569344779Sdim return Err; 1570226633Sdim } 1571226633Sdim } 1572344779Sdim return Error::success(); 1573226633Sdim } 1574226633Sdim 1575344779Sdim if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) { 1576344779Sdim if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) { 1577226633Sdim if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 1578344779Sdim if (Error Err = ImportDefinition(FromEnum, ToEnum)) 1579344779Sdim return Err; 1580226633Sdim } 1581226633Sdim } 1582344779Sdim return Error::success(); 1583226633Sdim } 1584344779Sdim 1585344779Sdim return Error::success(); 1586226633Sdim} 1587226633Sdim 1588344779SdimError 1589344779SdimASTNodeImporter::ImportDeclarationNameLoc( 1590344779Sdim const DeclarationNameInfo &From, DeclarationNameInfo& To) { 1591212904Sdim // NOTE: To.Name and To.Loc are already imported. 1592212904Sdim // We only have to import To.LocInfo. 1593212904Sdim switch (To.getName().getNameKind()) { 1594212904Sdim case DeclarationName::Identifier: 1595212904Sdim case DeclarationName::ObjCZeroArgSelector: 1596212904Sdim case DeclarationName::ObjCOneArgSelector: 1597212904Sdim case DeclarationName::ObjCMultiArgSelector: 1598212904Sdim case DeclarationName::CXXUsingDirective: 1599321369Sdim case DeclarationName::CXXDeductionGuideName: 1600344779Sdim return Error::success(); 1601212904Sdim 1602212904Sdim case DeclarationName::CXXOperatorName: { 1603344779Sdim if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange())) 1604344779Sdim To.setCXXOperatorNameRange(*ToRangeOrErr); 1605344779Sdim else 1606344779Sdim return ToRangeOrErr.takeError(); 1607344779Sdim return Error::success(); 1608212904Sdim } 1609212904Sdim case DeclarationName::CXXLiteralOperatorName: { 1610344779Sdim if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc())) 1611344779Sdim To.setCXXLiteralOperatorNameLoc(*LocOrErr); 1612344779Sdim else 1613344779Sdim return LocOrErr.takeError(); 1614344779Sdim return Error::success(); 1615212904Sdim } 1616212904Sdim case DeclarationName::CXXConstructorName: 1617212904Sdim case DeclarationName::CXXDestructorName: 1618212904Sdim case DeclarationName::CXXConversionFunctionName: { 1619344779Sdim if (auto ToTInfoOrErr = import(From.getNamedTypeInfo())) 1620344779Sdim To.setNamedTypeInfo(*ToTInfoOrErr); 1621344779Sdim else 1622344779Sdim return ToTInfoOrErr.takeError(); 1623344779Sdim return Error::success(); 1624212904Sdim } 1625212904Sdim } 1626234353Sdim llvm_unreachable("Unknown name kind."); 1627212904Sdim} 1628212904Sdim 1629344779SdimError 1630344779SdimASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 1631218893Sdim if (Importer.isMinimalImport() && !ForceImport) { 1632344779Sdim auto ToDCOrErr = Importer.ImportContext(FromDC); 1633344779Sdim return ToDCOrErr.takeError(); 1634218893Sdim } 1635353358Sdim 1636353358Sdim // We use strict error handling in case of records and enums, but not 1637353358Sdim // with e.g. namespaces. 1638353358Sdim // 1639353358Sdim // FIXME Clients of the ASTImporter should be able to choose an 1640353358Sdim // appropriate error handling strategy for their needs. For instance, 1641353358Sdim // they may not want to mark an entire namespace as erroneous merely 1642353358Sdim // because there is an ODR error with two typedefs. As another example, 1643353358Sdim // the client may allow EnumConstantDecls with same names but with 1644353358Sdim // different values in two distinct translation units. 1645353358Sdim bool AccumulateChildErrors = isa<TagDecl>(FromDC); 1646353358Sdim 1647353358Sdim Error ChildErrors = Error::success(); 1648344779Sdim llvm::SmallVector<Decl *, 8> ImportedDecls; 1649344779Sdim for (auto *From : FromDC->decls()) { 1650344779Sdim ExpectedDecl ImportedOrErr = import(From); 1651353358Sdim if (!ImportedOrErr) { 1652353358Sdim if (AccumulateChildErrors) 1653353358Sdim ChildErrors = 1654353358Sdim joinErrors(std::move(ChildErrors), ImportedOrErr.takeError()); 1655353358Sdim else 1656353358Sdim consumeError(ImportedOrErr.takeError()); 1657353358Sdim } 1658344779Sdim } 1659341825Sdim 1660353358Sdim return ChildErrors; 1661204643Srdivacky} 1662204643Srdivacky 1663344779SdimError ASTNodeImporter::ImportDeclContext( 1664344779Sdim Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) { 1665344779Sdim auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext()); 1666344779Sdim if (!ToDCOrErr) 1667344779Sdim return ToDCOrErr.takeError(); 1668344779Sdim ToDC = *ToDCOrErr; 1669344779Sdim 1670344779Sdim if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) { 1671344779Sdim auto ToLexicalDCOrErr = Importer.ImportContext( 1672344779Sdim FromD->getLexicalDeclContext()); 1673344779Sdim if (!ToLexicalDCOrErr) 1674344779Sdim return ToLexicalDCOrErr.takeError(); 1675344779Sdim ToLexicalDC = *ToLexicalDCOrErr; 1676344779Sdim } else 1677344779Sdim ToLexicalDC = ToDC; 1678344779Sdim 1679344779Sdim return Error::success(); 1680344779Sdim} 1681344779Sdim 1682344779SdimError ASTNodeImporter::ImportImplicitMethods( 1683341825Sdim const CXXRecordDecl *From, CXXRecordDecl *To) { 1684341825Sdim assert(From->isCompleteDefinition() && To->getDefinition() == To && 1685341825Sdim "Import implicit methods to or from non-definition"); 1686341825Sdim 1687341825Sdim for (CXXMethodDecl *FromM : From->methods()) 1688344779Sdim if (FromM->isImplicit()) { 1689344779Sdim Expected<CXXMethodDecl *> ToMOrErr = import(FromM); 1690344779Sdim if (!ToMOrErr) 1691344779Sdim return ToMOrErr.takeError(); 1692344779Sdim } 1693344779Sdim 1694344779Sdim return Error::success(); 1695341825Sdim} 1696341825Sdim 1697344779Sdimstatic Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, 1698344779Sdim ASTImporter &Importer) { 1699341825Sdim if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) { 1700353358Sdim if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef)) 1701353358Sdim To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr)); 1702353358Sdim else 1703353358Sdim return ToTypedefOrErr.takeError(); 1704341825Sdim } 1705344779Sdim return Error::success(); 1706341825Sdim} 1707341825Sdim 1708344779SdimError ASTNodeImporter::ImportDefinition( 1709344779Sdim RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) { 1710353358Sdim auto DefinitionCompleter = [To]() { 1711353358Sdim // There are cases in LLDB when we first import a class without its 1712353358Sdim // members. The class will have DefinitionData, but no members. Then, 1713353358Sdim // importDefinition is called from LLDB, which tries to get the members, so 1714353358Sdim // when we get here, the class already has the DefinitionData set, so we 1715353358Sdim // must unset the CompleteDefinition here to be able to complete again the 1716353358Sdim // definition. 1717353358Sdim To->setCompleteDefinition(false); 1718353358Sdim To->completeDefinition(); 1719353358Sdim }; 1720353358Sdim 1721234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 1722353358Sdim if (Kind == IDK_Everything || 1723353358Sdim // In case of lambdas, the class already has a definition ptr set, but 1724353358Sdim // the contained decls are not imported yet. Also, isBeingDefined was 1725353358Sdim // set in CXXRecordDecl::CreateLambda. We must import the contained 1726353358Sdim // decls here and finish the definition. 1727353358Sdim (To->isLambda() && shouldForceImportDeclContext(Kind))) { 1728353358Sdim Error Result = ImportDeclContext(From, /*ForceImport=*/true); 1729353358Sdim // Finish the definition of the lambda, set isBeingDefined to false. 1730353358Sdim if (To->isLambda()) 1731353358Sdim DefinitionCompleter(); 1732353358Sdim return Result; 1733353358Sdim } 1734341825Sdim 1735344779Sdim return Error::success(); 1736234353Sdim } 1737341825Sdim 1738218893Sdim To->startDefinition(); 1739353358Sdim // Complete the definition even if error is returned. 1740353358Sdim // The RecordDecl may be already part of the AST so it is better to 1741353358Sdim // have it in complete state even if something is wrong with it. 1742353358Sdim auto DefinitionCompleterScopeExit = 1743353358Sdim llvm::make_scope_exit(DefinitionCompleter); 1744341825Sdim 1745344779Sdim if (Error Err = setTypedefNameForAnonDecl(From, To, Importer)) 1746344779Sdim return Err; 1747341825Sdim 1748218893Sdim // Add base classes. 1749344779Sdim auto *ToCXX = dyn_cast<CXXRecordDecl>(To); 1750344779Sdim auto *FromCXX = dyn_cast<CXXRecordDecl>(From); 1751344779Sdim if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) { 1752234353Sdim 1753234353Sdim struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 1754234353Sdim struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 1755234353Sdim ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor; 1756249423Sdim ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers; 1757234353Sdim ToData.Aggregate = FromData.Aggregate; 1758234353Sdim ToData.PlainOldData = FromData.PlainOldData; 1759234353Sdim ToData.Empty = FromData.Empty; 1760234353Sdim ToData.Polymorphic = FromData.Polymorphic; 1761234353Sdim ToData.Abstract = FromData.Abstract; 1762234353Sdim ToData.IsStandardLayout = FromData.IsStandardLayout; 1763341825Sdim ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout; 1764341825Sdim ToData.HasBasesWithFields = FromData.HasBasesWithFields; 1765341825Sdim ToData.HasBasesWithNonStaticDataMembers = 1766341825Sdim FromData.HasBasesWithNonStaticDataMembers; 1767234353Sdim ToData.HasPrivateFields = FromData.HasPrivateFields; 1768234353Sdim ToData.HasProtectedFields = FromData.HasProtectedFields; 1769234353Sdim ToData.HasPublicFields = FromData.HasPublicFields; 1770234353Sdim ToData.HasMutableFields = FromData.HasMutableFields; 1771276479Sdim ToData.HasVariantMembers = FromData.HasVariantMembers; 1772234353Sdim ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; 1773239462Sdim ToData.HasInClassInitializer = FromData.HasInClassInitializer; 1774249423Sdim ToData.HasUninitializedReferenceMember 1775249423Sdim = FromData.HasUninitializedReferenceMember; 1776309124Sdim ToData.HasUninitializedFields = FromData.HasUninitializedFields; 1777309124Sdim ToData.HasInheritedConstructor = FromData.HasInheritedConstructor; 1778309124Sdim ToData.HasInheritedAssignment = FromData.HasInheritedAssignment; 1779322855Sdim ToData.NeedOverloadResolutionForCopyConstructor 1780322855Sdim = FromData.NeedOverloadResolutionForCopyConstructor; 1781249423Sdim ToData.NeedOverloadResolutionForMoveConstructor 1782249423Sdim = FromData.NeedOverloadResolutionForMoveConstructor; 1783249423Sdim ToData.NeedOverloadResolutionForMoveAssignment 1784249423Sdim = FromData.NeedOverloadResolutionForMoveAssignment; 1785249423Sdim ToData.NeedOverloadResolutionForDestructor 1786249423Sdim = FromData.NeedOverloadResolutionForDestructor; 1787322855Sdim ToData.DefaultedCopyConstructorIsDeleted 1788322855Sdim = FromData.DefaultedCopyConstructorIsDeleted; 1789249423Sdim ToData.DefaultedMoveConstructorIsDeleted 1790249423Sdim = FromData.DefaultedMoveConstructorIsDeleted; 1791249423Sdim ToData.DefaultedMoveAssignmentIsDeleted 1792249423Sdim = FromData.DefaultedMoveAssignmentIsDeleted; 1793249423Sdim ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted; 1794249423Sdim ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers; 1795249423Sdim ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor; 1796234353Sdim ToData.HasConstexprNonCopyMoveConstructor 1797234353Sdim = FromData.HasConstexprNonCopyMoveConstructor; 1798309124Sdim ToData.HasDefaultedDefaultConstructor 1799309124Sdim = FromData.HasDefaultedDefaultConstructor; 1800234353Sdim ToData.DefaultedDefaultConstructorIsConstexpr 1801234353Sdim = FromData.DefaultedDefaultConstructorIsConstexpr; 1802234353Sdim ToData.HasConstexprDefaultConstructor 1803234353Sdim = FromData.HasConstexprDefaultConstructor; 1804234353Sdim ToData.HasNonLiteralTypeFieldsOrBases 1805234353Sdim = FromData.HasNonLiteralTypeFieldsOrBases; 1806234353Sdim // ComputedVisibleConversions not imported. 1807234353Sdim ToData.UserProvidedDefaultConstructor 1808234353Sdim = FromData.UserProvidedDefaultConstructor; 1809249423Sdim ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers; 1810321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForVBase 1811321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase; 1812321369Sdim ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase 1813321369Sdim = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase; 1814249423Sdim ToData.ImplicitCopyAssignmentHasConstParam 1815249423Sdim = FromData.ImplicitCopyAssignmentHasConstParam; 1816249423Sdim ToData.HasDeclaredCopyConstructorWithConstParam 1817249423Sdim = FromData.HasDeclaredCopyConstructorWithConstParam; 1818249423Sdim ToData.HasDeclaredCopyAssignmentWithConstParam 1819249423Sdim = FromData.HasDeclaredCopyAssignmentWithConstParam; 1820234353Sdim 1821353358Sdim // Copy over the data stored in RecordDeclBits 1822353358Sdim ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions()); 1823353358Sdim 1824226633Sdim SmallVector<CXXBaseSpecifier *, 4> Bases; 1825276479Sdim for (const auto &Base1 : FromCXX->bases()) { 1826344779Sdim ExpectedType TyOrErr = import(Base1.getType()); 1827344779Sdim if (!TyOrErr) 1828344779Sdim return TyOrErr.takeError(); 1829218893Sdim 1830218893Sdim SourceLocation EllipsisLoc; 1831344779Sdim if (Base1.isPackExpansion()) { 1832344779Sdim if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc())) 1833344779Sdim EllipsisLoc = *LocOrErr; 1834344779Sdim else 1835344779Sdim return LocOrErr.takeError(); 1836344779Sdim } 1837226633Sdim 1838226633Sdim // Ensure that we have a definition for the base. 1839344779Sdim if (Error Err = 1840344779Sdim ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl())) 1841344779Sdim return Err; 1842341825Sdim 1843344779Sdim auto RangeOrErr = import(Base1.getSourceRange()); 1844344779Sdim if (!RangeOrErr) 1845344779Sdim return RangeOrErr.takeError(); 1846344779Sdim 1847344779Sdim auto TSIOrErr = import(Base1.getTypeSourceInfo()); 1848344779Sdim if (!TSIOrErr) 1849344779Sdim return TSIOrErr.takeError(); 1850344779Sdim 1851218893Sdim Bases.push_back( 1852344779Sdim new (Importer.getToContext()) CXXBaseSpecifier( 1853344779Sdim *RangeOrErr, 1854344779Sdim Base1.isVirtual(), 1855344779Sdim Base1.isBaseOfClass(), 1856344779Sdim Base1.getAccessSpecifierAsWritten(), 1857344779Sdim *TSIOrErr, 1858344779Sdim EllipsisLoc)); 1859218893Sdim } 1860218893Sdim if (!Bases.empty()) 1861218893Sdim ToCXX->setBases(Bases.data(), Bases.size()); 1862218893Sdim } 1863341825Sdim 1864234353Sdim if (shouldForceImportDeclContext(Kind)) 1865344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 1866344779Sdim return Err; 1867341825Sdim 1868344779Sdim return Error::success(); 1869218893Sdim} 1870218893Sdim 1871344779SdimError ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) { 1872288943Sdim if (To->getAnyInitializer()) 1873344779Sdim return Error::success(); 1874261991Sdim 1875344779Sdim Expr *FromInit = From->getInit(); 1876344779Sdim if (!FromInit) 1877344779Sdim return Error::success(); 1878261991Sdim 1879344779Sdim ExpectedExpr ToInitOrErr = import(FromInit); 1880344779Sdim if (!ToInitOrErr) 1881344779Sdim return ToInitOrErr.takeError(); 1882344779Sdim 1883344779Sdim To->setInit(*ToInitOrErr); 1884344779Sdim if (From->isInitKnownICE()) { 1885344779Sdim EvaluatedStmt *Eval = To->ensureEvaluatedStmt(); 1886344779Sdim Eval->CheckedICE = true; 1887344779Sdim Eval->IsICE = From->isInitICE(); 1888344779Sdim } 1889344779Sdim 1890261991Sdim // FIXME: Other bits to merge? 1891344779Sdim return Error::success(); 1892261991Sdim} 1893261991Sdim 1894344779SdimError ASTNodeImporter::ImportDefinition( 1895344779Sdim EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) { 1896234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 1897234353Sdim if (Kind == IDK_Everything) 1898344779Sdim return ImportDeclContext(From, /*ForceImport=*/true); 1899344779Sdim return Error::success(); 1900234353Sdim } 1901341825Sdim 1902226633Sdim To->startDefinition(); 1903226633Sdim 1904344779Sdim if (Error Err = setTypedefNameForAnonDecl(From, To, Importer)) 1905344779Sdim return Err; 1906341825Sdim 1907344779Sdim ExpectedType ToTypeOrErr = 1908344779Sdim import(Importer.getFromContext().getTypeDeclType(From)); 1909344779Sdim if (!ToTypeOrErr) 1910344779Sdim return ToTypeOrErr.takeError(); 1911341825Sdim 1912344779Sdim ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType()); 1913344779Sdim if (!ToPromotionTypeOrErr) 1914344779Sdim return ToPromotionTypeOrErr.takeError(); 1915234353Sdim 1916234353Sdim if (shouldForceImportDeclContext(Kind)) 1917344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 1918344779Sdim return Err; 1919341825Sdim 1920226633Sdim // FIXME: we might need to merge the number of positive or negative bits 1921226633Sdim // if the enumerator lists don't match. 1922344779Sdim To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr, 1923226633Sdim From->getNumPositiveBits(), 1924226633Sdim From->getNumNegativeBits()); 1925344779Sdim return Error::success(); 1926226633Sdim} 1927226633Sdim 1928344779SdimError ASTNodeImporter::ImportTemplateArguments( 1929344779Sdim const TemplateArgument *FromArgs, unsigned NumFromArgs, 1930344779Sdim SmallVectorImpl<TemplateArgument> &ToArgs) { 1931344779Sdim for (unsigned I = 0; I != NumFromArgs; ++I) { 1932344779Sdim if (auto ToOrErr = import(FromArgs[I])) 1933344779Sdim ToArgs.push_back(*ToOrErr); 1934314564Sdim else 1935344779Sdim return ToOrErr.takeError(); 1936314564Sdim } 1937344779Sdim 1938344779Sdim return Error::success(); 1939314564Sdim} 1940314564Sdim 1941344779Sdim// FIXME: Do not forget to remove this and use only 'import'. 1942344779SdimExpected<TemplateArgument> 1943344779SdimASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 1944344779Sdim return import(From); 1945218893Sdim} 1946218893Sdim 1947327952Sdimtemplate <typename InContainerTy> 1948344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo( 1949327952Sdim const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) { 1950327952Sdim for (const auto &FromLoc : Container) { 1951344779Sdim if (auto ToLocOrErr = import(FromLoc)) 1952344779Sdim ToTAInfo.addArgument(*ToLocOrErr); 1953327952Sdim else 1954344779Sdim return ToLocOrErr.takeError(); 1955327952Sdim } 1956344779Sdim return Error::success(); 1957327952Sdim} 1958327952Sdim 1959341825Sdimstatic StructuralEquivalenceKind 1960341825SdimgetStructuralEquivalenceKind(const ASTImporter &Importer) { 1961341825Sdim return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal 1962341825Sdim : StructuralEquivalenceKind::Default; 1963341825Sdim} 1964341825Sdim 1965341825Sdimbool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) { 1966341825Sdim StructuralEquivalenceContext Ctx( 1967341825Sdim Importer.getFromContext(), Importer.getToContext(), 1968341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 1969341825Sdim false, Complain); 1970341825Sdim return Ctx.IsEquivalent(From, To); 1971341825Sdim} 1972341825Sdim 1973341825Sdimbool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 1974239462Sdim RecordDecl *ToRecord, bool Complain) { 1975261991Sdim // Eliminate a potential failure point where we attempt to re-import 1976261991Sdim // something we're trying to import while completing ToRecord. 1977261991Sdim Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 1978261991Sdim if (ToOrigin) { 1979341825Sdim auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 1980261991Sdim if (ToOriginRecord) 1981261991Sdim ToRecord = ToOriginRecord; 1982261991Sdim } 1983261991Sdim 1984204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1985261991Sdim ToRecord->getASTContext(), 1986239462Sdim Importer.getNonEquivalentDecls(), 1987341825Sdim getStructuralEquivalenceKind(Importer), 1988239462Sdim false, Complain); 1989341825Sdim return Ctx.IsEquivalent(FromRecord, ToRecord); 1990203955Srdivacky} 1991203955Srdivacky 1992261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 1993261991Sdim bool Complain) { 1994261991Sdim StructuralEquivalenceContext Ctx( 1995261991Sdim Importer.getFromContext(), Importer.getToContext(), 1996341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 1997341825Sdim false, Complain); 1998341825Sdim return Ctx.IsEquivalent(FromVar, ToVar); 1999261991Sdim} 2000261991Sdim 2001203955Srdivackybool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 2002353358Sdim // Eliminate a potential failure point where we attempt to re-import 2003353358Sdim // something we're trying to import while completing ToEnum. 2004353358Sdim if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum)) 2005353358Sdim if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin)) 2006353358Sdim ToEnum = ToOriginEnum; 2007353358Sdim 2008341825Sdim StructuralEquivalenceContext Ctx( 2009341825Sdim Importer.getFromContext(), Importer.getToContext(), 2010341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer)); 2011341825Sdim return Ctx.IsEquivalent(FromEnum, ToEnum); 2012203955Srdivacky} 2013203955Srdivacky 2014327952Sdimbool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From, 2015327952Sdim FunctionTemplateDecl *To) { 2016327952Sdim StructuralEquivalenceContext Ctx( 2017327952Sdim Importer.getFromContext(), Importer.getToContext(), 2018341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2019341825Sdim false, false); 2020341825Sdim return Ctx.IsEquivalent(From, To); 2021327952Sdim} 2022327952Sdim 2023341825Sdimbool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) { 2024341825Sdim StructuralEquivalenceContext Ctx( 2025341825Sdim Importer.getFromContext(), Importer.getToContext(), 2026341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2027341825Sdim false, false); 2028341825Sdim return Ctx.IsEquivalent(From, To); 2029341825Sdim} 2030341825Sdim 2031249423Sdimbool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 2032341825Sdim EnumConstantDecl *ToEC) { 2033249423Sdim const llvm::APSInt &FromVal = FromEC->getInitVal(); 2034249423Sdim const llvm::APSInt &ToVal = ToEC->getInitVal(); 2035249423Sdim 2036249423Sdim return FromVal.isSigned() == ToVal.isSigned() && 2037249423Sdim FromVal.getBitWidth() == ToVal.getBitWidth() && 2038249423Sdim FromVal == ToVal; 2039249423Sdim} 2040249423Sdim 2041249423Sdimbool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 2042218893Sdim ClassTemplateDecl *To) { 2043218893Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2044218893Sdim Importer.getToContext(), 2045341825Sdim Importer.getNonEquivalentDecls(), 2046341825Sdim getStructuralEquivalenceKind(Importer)); 2047341825Sdim return Ctx.IsEquivalent(From, To); 2048218893Sdim} 2049218893Sdim 2050261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 2051261991Sdim VarTemplateDecl *To) { 2052261991Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2053261991Sdim Importer.getToContext(), 2054341825Sdim Importer.getNonEquivalentDecls(), 2055341825Sdim getStructuralEquivalenceKind(Importer)); 2056341825Sdim return Ctx.IsEquivalent(From, To); 2057261991Sdim} 2058261991Sdim 2059344779SdimExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) { 2060203955Srdivacky Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 2061203955Srdivacky << D->getDeclKindName(); 2062344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 2063203955Srdivacky} 2064203955Srdivacky 2065344779SdimExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) { 2066344779Sdim Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 2067344779Sdim << D->getDeclKindName(); 2068344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 2069344779Sdim} 2070344779Sdim 2071344779SdimExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) { 2072327952Sdim // Import the context of this declaration. 2073344779Sdim DeclContext *DC, *LexicalDC; 2074344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 2075344779Sdim return std::move(Err); 2076327952Sdim 2077327952Sdim // Import the location of this declaration. 2078344779Sdim ExpectedSLoc LocOrErr = import(D->getLocation()); 2079344779Sdim if (!LocOrErr) 2080344779Sdim return LocOrErr.takeError(); 2081327952Sdim 2082341825Sdim EmptyDecl *ToD; 2083344779Sdim if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr)) 2084341825Sdim return ToD; 2085341825Sdim 2086327952Sdim ToD->setLexicalDeclContext(LexicalDC); 2087327952Sdim LexicalDC->addDeclInternal(ToD); 2088327952Sdim return ToD; 2089327952Sdim} 2090327952Sdim 2091344779SdimExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 2092341825Sdim TranslationUnitDecl *ToD = 2093234353Sdim Importer.getToContext().getTranslationUnitDecl(); 2094341825Sdim 2095341825Sdim Importer.MapImported(D, ToD); 2096341825Sdim 2097234353Sdim return ToD; 2098234353Sdim} 2099234353Sdim 2100344779SdimExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) { 2101344779Sdim ExpectedSLoc LocOrErr = import(D->getLocation()); 2102344779Sdim if (!LocOrErr) 2103344779Sdim return LocOrErr.takeError(); 2104344779Sdim auto ColonLocOrErr = import(D->getColonLoc()); 2105344779Sdim if (!ColonLocOrErr) 2106344779Sdim return ColonLocOrErr.takeError(); 2107309124Sdim 2108309124Sdim // Import the context of this declaration. 2109344779Sdim auto DCOrErr = Importer.ImportContext(D->getDeclContext()); 2110344779Sdim if (!DCOrErr) 2111344779Sdim return DCOrErr.takeError(); 2112344779Sdim DeclContext *DC = *DCOrErr; 2113309124Sdim 2114341825Sdim AccessSpecDecl *ToD; 2115341825Sdim if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(), 2116344779Sdim DC, *LocOrErr, *ColonLocOrErr)) 2117341825Sdim return ToD; 2118309124Sdim 2119309124Sdim // Lexical DeclContext and Semantic DeclContext 2120309124Sdim // is always the same for the accessSpec. 2121341825Sdim ToD->setLexicalDeclContext(DC); 2122341825Sdim DC->addDeclInternal(ToD); 2123309124Sdim 2124341825Sdim return ToD; 2125309124Sdim} 2126309124Sdim 2127344779SdimExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) { 2128344779Sdim auto DCOrErr = Importer.ImportContext(D->getDeclContext()); 2129344779Sdim if (!DCOrErr) 2130344779Sdim return DCOrErr.takeError(); 2131344779Sdim DeclContext *DC = *DCOrErr; 2132314564Sdim DeclContext *LexicalDC = DC; 2133314564Sdim 2134344779Sdim SourceLocation ToLocation, ToRParenLoc; 2135344779Sdim Expr *ToAssertExpr; 2136344779Sdim StringLiteral *ToMessage; 2137344779Sdim if (auto Imp = importSeq( 2138344779Sdim D->getLocation(), D->getAssertExpr(), D->getMessage(), D->getRParenLoc())) 2139344779Sdim std::tie(ToLocation, ToAssertExpr, ToMessage, ToRParenLoc) = *Imp; 2140344779Sdim else 2141344779Sdim return Imp.takeError(); 2142314564Sdim 2143341825Sdim StaticAssertDecl *ToD; 2144341825Sdim if (GetImportedOrCreateDecl( 2145344779Sdim ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage, 2146344779Sdim ToRParenLoc, D->isFailed())) 2147341825Sdim return ToD; 2148314564Sdim 2149314564Sdim ToD->setLexicalDeclContext(LexicalDC); 2150314564Sdim LexicalDC->addDeclInternal(ToD); 2151314564Sdim return ToD; 2152314564Sdim} 2153314564Sdim 2154344779SdimExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 2155204643Srdivacky // Import the major distinguishing characteristics of this namespace. 2156204643Srdivacky DeclContext *DC, *LexicalDC; 2157204643Srdivacky DeclarationName Name; 2158204643Srdivacky SourceLocation Loc; 2159288943Sdim NamedDecl *ToD; 2160344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2161344779Sdim return std::move(Err); 2162288943Sdim if (ToD) 2163288943Sdim return ToD; 2164276479Sdim 2165276479Sdim NamespaceDecl *MergeWithNamespace = nullptr; 2166204643Srdivacky if (!Name) { 2167204643Srdivacky // This is an anonymous namespace. Adopt an existing anonymous 2168204643Srdivacky // namespace if we can. 2169204643Srdivacky // FIXME: Not testable. 2170341825Sdim if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 2171204643Srdivacky MergeWithNamespace = TU->getAnonymousNamespace(); 2172204643Srdivacky else 2173204643Srdivacky MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 2174204643Srdivacky } else { 2175226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2176344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2177341825Sdim for (auto *FoundDecl : FoundDecls) { 2178341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace)) 2179204643Srdivacky continue; 2180341825Sdim 2181341825Sdim if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) { 2182204643Srdivacky MergeWithNamespace = FoundNS; 2183204643Srdivacky ConflictingDecls.clear(); 2184204643Srdivacky break; 2185204643Srdivacky } 2186341825Sdim 2187341825Sdim ConflictingDecls.push_back(FoundDecl); 2188204643Srdivacky } 2189341825Sdim 2190204643Srdivacky if (!ConflictingDecls.empty()) { 2191207619Srdivacky Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace, 2192341825Sdim ConflictingDecls.data(), 2193204643Srdivacky ConflictingDecls.size()); 2194344779Sdim if (!Name) 2195344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2196204643Srdivacky } 2197204643Srdivacky } 2198341825Sdim 2199344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2200344779Sdim if (!BeginLocOrErr) 2201344779Sdim return BeginLocOrErr.takeError(); 2202344779Sdim 2203204643Srdivacky // Create the "to" namespace, if needed. 2204204643Srdivacky NamespaceDecl *ToNamespace = MergeWithNamespace; 2205204643Srdivacky if (!ToNamespace) { 2206341825Sdim if (GetImportedOrCreateDecl( 2207341825Sdim ToNamespace, D, Importer.getToContext(), DC, D->isInline(), 2208344779Sdim *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(), 2209341825Sdim /*PrevDecl=*/nullptr)) 2210341825Sdim return ToNamespace; 2211204643Srdivacky ToNamespace->setLexicalDeclContext(LexicalDC); 2212234353Sdim LexicalDC->addDeclInternal(ToNamespace); 2213341825Sdim 2214204643Srdivacky // If this is an anonymous namespace, register it as the anonymous 2215204643Srdivacky // namespace within its context. 2216204643Srdivacky if (!Name) { 2217341825Sdim if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 2218204643Srdivacky TU->setAnonymousNamespace(ToNamespace); 2219204643Srdivacky else 2220204643Srdivacky cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 2221204643Srdivacky } 2222204643Srdivacky } 2223341825Sdim Importer.MapImported(D, ToNamespace); 2224341825Sdim 2225344779Sdim if (Error Err = ImportDeclContext(D)) 2226344779Sdim return std::move(Err); 2227341825Sdim 2228204643Srdivacky return ToNamespace; 2229204643Srdivacky} 2230204643Srdivacky 2231344779SdimExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 2232327952Sdim // Import the major distinguishing characteristics of this namespace. 2233327952Sdim DeclContext *DC, *LexicalDC; 2234327952Sdim DeclarationName Name; 2235327952Sdim SourceLocation Loc; 2236327952Sdim NamedDecl *LookupD; 2237344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc)) 2238344779Sdim return std::move(Err); 2239327952Sdim if (LookupD) 2240327952Sdim return LookupD; 2241327952Sdim 2242327952Sdim // NOTE: No conflict resolution is done for namespace aliases now. 2243327952Sdim 2244344779Sdim SourceLocation ToNamespaceLoc, ToAliasLoc, ToTargetNameLoc; 2245344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 2246344779Sdim NamespaceDecl *ToNamespace; 2247344779Sdim if (auto Imp = importSeq( 2248344779Sdim D->getNamespaceLoc(), D->getAliasLoc(), D->getQualifierLoc(), 2249344779Sdim D->getTargetNameLoc(), D->getNamespace())) 2250344779Sdim std::tie( 2251344779Sdim ToNamespaceLoc, ToAliasLoc, ToQualifierLoc, ToTargetNameLoc, 2252344779Sdim ToNamespace) = *Imp; 2253344779Sdim else 2254344779Sdim return Imp.takeError(); 2255344779Sdim IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier()); 2256327952Sdim 2257341825Sdim NamespaceAliasDecl *ToD; 2258344779Sdim if (GetImportedOrCreateDecl( 2259344779Sdim ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc, 2260344779Sdim ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace)) 2261341825Sdim return ToD; 2262327952Sdim 2263327952Sdim ToD->setLexicalDeclContext(LexicalDC); 2264327952Sdim LexicalDC->addDeclInternal(ToD); 2265327952Sdim 2266327952Sdim return ToD; 2267327952Sdim} 2268327952Sdim 2269344779SdimExpectedDecl 2270344779SdimASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 2271203955Srdivacky // Import the major distinguishing characteristics of this typedef. 2272203955Srdivacky DeclContext *DC, *LexicalDC; 2273203955Srdivacky DeclarationName Name; 2274203955Srdivacky SourceLocation Loc; 2275288943Sdim NamedDecl *ToD; 2276344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2277344779Sdim return std::move(Err); 2278288943Sdim if (ToD) 2279288943Sdim return ToD; 2280276479Sdim 2281203955Srdivacky // If this typedef is not in block scope, determine whether we've 2282203955Srdivacky // seen a typedef with the same name (that we can merge with) or any 2283203955Srdivacky // other entity by that name (which name lookup could conflict with). 2284203955Srdivacky if (!DC->isFunctionOrMethod()) { 2285226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2286203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2287344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2288341825Sdim for (auto *FoundDecl : FoundDecls) { 2289341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2290203955Srdivacky continue; 2291341825Sdim if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) { 2292344779Sdim QualType FromUT = D->getUnderlyingType(); 2293344779Sdim QualType FoundUT = FoundTypedef->getUnderlyingType(); 2294344779Sdim if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) { 2295344779Sdim // If the "From" context has a complete underlying type but we 2296344779Sdim // already have a complete underlying type then return with that. 2297344779Sdim if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType()) 2298344779Sdim return Importer.MapImported(D, FoundTypedef); 2299344779Sdim } 2300353358Sdim // FIXME Handle redecl chain. When you do that make consistent changes 2301353358Sdim // in ASTImporterLookupTable too. 2302344779Sdim break; 2303203955Srdivacky } 2304321369Sdim 2305341825Sdim ConflictingDecls.push_back(FoundDecl); 2306203955Srdivacky } 2307321369Sdim 2308203955Srdivacky if (!ConflictingDecls.empty()) { 2309203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2310341825Sdim ConflictingDecls.data(), 2311203955Srdivacky ConflictingDecls.size()); 2312203955Srdivacky if (!Name) 2313344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2314203955Srdivacky } 2315203955Srdivacky } 2316321369Sdim 2317344779Sdim QualType ToUnderlyingType; 2318344779Sdim TypeSourceInfo *ToTypeSourceInfo; 2319344779Sdim SourceLocation ToBeginLoc; 2320344779Sdim if (auto Imp = importSeq( 2321344779Sdim D->getUnderlyingType(), D->getTypeSourceInfo(), D->getBeginLoc())) 2322344779Sdim std::tie(ToUnderlyingType, ToTypeSourceInfo, ToBeginLoc) = *Imp; 2323344779Sdim else 2324344779Sdim return Imp.takeError(); 2325276479Sdim 2326203955Srdivacky // Create the new typedef node. 2327344779Sdim // FIXME: ToUnderlyingType is not used. 2328221345Sdim TypedefNameDecl *ToTypedef; 2329341825Sdim if (IsAlias) { 2330341825Sdim if (GetImportedOrCreateDecl<TypeAliasDecl>( 2331344779Sdim ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc, 2332344779Sdim Name.getAsIdentifierInfo(), ToTypeSourceInfo)) 2333341825Sdim return ToTypedef; 2334341825Sdim } else if (GetImportedOrCreateDecl<TypedefDecl>( 2335344779Sdim ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc, 2336344779Sdim Name.getAsIdentifierInfo(), ToTypeSourceInfo)) 2337341825Sdim return ToTypedef; 2338321369Sdim 2339204643Srdivacky ToTypedef->setAccess(D->getAccess()); 2340203955Srdivacky ToTypedef->setLexicalDeclContext(LexicalDC); 2341321369Sdim 2342341825Sdim // Templated declarations should not appear in DeclContext. 2343341825Sdim TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr; 2344341825Sdim if (!FromAlias || !FromAlias->getDescribedAliasTemplate()) 2345341825Sdim LexicalDC->addDeclInternal(ToTypedef); 2346341825Sdim 2347203955Srdivacky return ToTypedef; 2348203955Srdivacky} 2349203955Srdivacky 2350344779SdimExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 2351221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/false); 2352221345Sdim} 2353221345Sdim 2354344779SdimExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 2355221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/true); 2356221345Sdim} 2357221345Sdim 2358344779SdimExpectedDecl 2359344779SdimASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 2360327952Sdim // Import the major distinguishing characteristics of this typedef. 2361327952Sdim DeclContext *DC, *LexicalDC; 2362327952Sdim DeclarationName Name; 2363327952Sdim SourceLocation Loc; 2364341825Sdim NamedDecl *FoundD; 2365344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc)) 2366344779Sdim return std::move(Err); 2367341825Sdim if (FoundD) 2368341825Sdim return FoundD; 2369327952Sdim 2370327952Sdim // If this typedef is not in block scope, determine whether we've 2371327952Sdim // seen a typedef with the same name (that we can merge with) or any 2372327952Sdim // other entity by that name (which name lookup could conflict with). 2373327952Sdim if (!DC->isFunctionOrMethod()) { 2374327952Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2375327952Sdim unsigned IDNS = Decl::IDNS_Ordinary; 2376344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2377341825Sdim for (auto *FoundDecl : FoundDecls) { 2378341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2379327952Sdim continue; 2380341825Sdim if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) 2381341825Sdim return Importer.MapImported(D, FoundAlias); 2382341825Sdim ConflictingDecls.push_back(FoundDecl); 2383327952Sdim } 2384327952Sdim 2385327952Sdim if (!ConflictingDecls.empty()) { 2386327952Sdim Name = Importer.HandleNameConflict(Name, DC, IDNS, 2387327952Sdim ConflictingDecls.data(), 2388327952Sdim ConflictingDecls.size()); 2389327952Sdim if (!Name) 2390344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2391327952Sdim } 2392327952Sdim } 2393327952Sdim 2394344779Sdim TemplateParameterList *ToTemplateParameters; 2395344779Sdim TypeAliasDecl *ToTemplatedDecl; 2396344779Sdim if (auto Imp = importSeq(D->getTemplateParameters(), D->getTemplatedDecl())) 2397344779Sdim std::tie(ToTemplateParameters, ToTemplatedDecl) = *Imp; 2398344779Sdim else 2399344779Sdim return Imp.takeError(); 2400327952Sdim 2401341825Sdim TypeAliasTemplateDecl *ToAlias; 2402341825Sdim if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc, 2403344779Sdim Name, ToTemplateParameters, ToTemplatedDecl)) 2404341825Sdim return ToAlias; 2405327952Sdim 2406344779Sdim ToTemplatedDecl->setDescribedAliasTemplate(ToAlias); 2407341825Sdim 2408327952Sdim ToAlias->setAccess(D->getAccess()); 2409327952Sdim ToAlias->setLexicalDeclContext(LexicalDC); 2410327952Sdim LexicalDC->addDeclInternal(ToAlias); 2411341825Sdim return ToAlias; 2412327952Sdim} 2413327952Sdim 2414344779SdimExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) { 2415309124Sdim // Import the major distinguishing characteristics of this label. 2416309124Sdim DeclContext *DC, *LexicalDC; 2417309124Sdim DeclarationName Name; 2418309124Sdim SourceLocation Loc; 2419309124Sdim NamedDecl *ToD; 2420344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2421344779Sdim return std::move(Err); 2422309124Sdim if (ToD) 2423309124Sdim return ToD; 2424309124Sdim 2425309124Sdim assert(LexicalDC->isFunctionOrMethod()); 2426309124Sdim 2427341825Sdim LabelDecl *ToLabel; 2428344779Sdim if (D->isGnuLocal()) { 2429344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2430344779Sdim if (!BeginLocOrErr) 2431344779Sdim return BeginLocOrErr.takeError(); 2432344779Sdim if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc, 2433344779Sdim Name.getAsIdentifierInfo(), *BeginLocOrErr)) 2434344779Sdim return ToLabel; 2435309124Sdim 2436344779Sdim } else { 2437344779Sdim if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc, 2438344779Sdim Name.getAsIdentifierInfo())) 2439344779Sdim return ToLabel; 2440309124Sdim 2441344779Sdim } 2442344779Sdim 2443344779Sdim Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt()); 2444344779Sdim if (!ToStmtOrErr) 2445344779Sdim return ToStmtOrErr.takeError(); 2446344779Sdim 2447344779Sdim ToLabel->setStmt(*ToStmtOrErr); 2448309124Sdim ToLabel->setLexicalDeclContext(LexicalDC); 2449309124Sdim LexicalDC->addDeclInternal(ToLabel); 2450309124Sdim return ToLabel; 2451309124Sdim} 2452309124Sdim 2453344779SdimExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 2454203955Srdivacky // Import the major distinguishing characteristics of this enum. 2455203955Srdivacky DeclContext *DC, *LexicalDC; 2456203955Srdivacky DeclarationName Name; 2457203955Srdivacky SourceLocation Loc; 2458288943Sdim NamedDecl *ToD; 2459344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2460344779Sdim return std::move(Err); 2461288943Sdim if (ToD) 2462288943Sdim return ToD; 2463276479Sdim 2464203955Srdivacky // Figure out what enum name we're looking for. 2465203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 2466203955Srdivacky DeclarationName SearchName = Name; 2467221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 2468344779Sdim if (Error Err = importInto( 2469344779Sdim SearchName, D->getTypedefNameForAnonDecl()->getDeclName())) 2470344779Sdim return std::move(Err); 2471203955Srdivacky IDNS = Decl::IDNS_Ordinary; 2472234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2473203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 2474341825Sdim 2475203955Srdivacky // We may already have an enum of the same name; try to find and match it. 2476203955Srdivacky if (!DC->isFunctionOrMethod() && SearchName) { 2477226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2478344779Sdim auto FoundDecls = 2479344779Sdim Importer.findDeclsInToCtx(DC, SearchName); 2480341825Sdim for (auto *FoundDecl : FoundDecls) { 2481341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2482203955Srdivacky continue; 2483341825Sdim 2484344779Sdim if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) { 2485341825Sdim if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2486344779Sdim FoundDecl = Tag->getDecl(); 2487203955Srdivacky } 2488341825Sdim 2489344779Sdim if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) { 2490353358Sdim if (!hasSameVisibilityContext(FoundEnum, D)) 2491353358Sdim continue; 2492203955Srdivacky if (IsStructuralMatch(D, FoundEnum)) 2493341825Sdim return Importer.MapImported(D, FoundEnum); 2494203955Srdivacky } 2495341825Sdim 2496341825Sdim ConflictingDecls.push_back(FoundDecl); 2497203955Srdivacky } 2498341825Sdim 2499203955Srdivacky if (!ConflictingDecls.empty()) { 2500353358Sdim Name = Importer.HandleNameConflict(SearchName, DC, IDNS, 2501341825Sdim ConflictingDecls.data(), 2502203955Srdivacky ConflictingDecls.size()); 2503344779Sdim if (!Name) 2504344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2505203955Srdivacky } 2506203955Srdivacky } 2507341825Sdim 2508344779Sdim SourceLocation ToBeginLoc; 2509344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 2510344779Sdim QualType ToIntegerType; 2511344779Sdim if (auto Imp = importSeq( 2512344779Sdim D->getBeginLoc(), D->getQualifierLoc(), D->getIntegerType())) 2513344779Sdim std::tie(ToBeginLoc, ToQualifierLoc, ToIntegerType) = *Imp; 2514344779Sdim else 2515344779Sdim return Imp.takeError(); 2516344779Sdim 2517203955Srdivacky // Create the enum declaration. 2518341825Sdim EnumDecl *D2; 2519341825Sdim if (GetImportedOrCreateDecl( 2520344779Sdim D2, D, Importer.getToContext(), DC, ToBeginLoc, 2521341825Sdim Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(), 2522341825Sdim D->isScopedUsingClassTag(), D->isFixed())) 2523341825Sdim return D2; 2524341825Sdim 2525344779Sdim D2->setQualifierInfo(ToQualifierLoc); 2526344779Sdim D2->setIntegerType(ToIntegerType); 2527204643Srdivacky D2->setAccess(D->getAccess()); 2528203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 2529234353Sdim LexicalDC->addDeclInternal(D2); 2530203955Srdivacky 2531203955Srdivacky // Import the definition 2532344779Sdim if (D->isCompleteDefinition()) 2533344779Sdim if (Error Err = ImportDefinition(D, D2)) 2534344779Sdim return std::move(Err); 2535203955Srdivacky 2536203955Srdivacky return D2; 2537203955Srdivacky} 2538203955Srdivacky 2539344779SdimExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 2540344779Sdim bool IsFriendTemplate = false; 2541344779Sdim if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2542344779Sdim IsFriendTemplate = 2543344779Sdim DCXX->getDescribedClassTemplate() && 2544344779Sdim DCXX->getDescribedClassTemplate()->getFriendObjectKind() != 2545344779Sdim Decl::FOK_None; 2546344779Sdim } 2547344779Sdim 2548203955Srdivacky // Import the major distinguishing characteristics of this record. 2549203955Srdivacky DeclContext *DC, *LexicalDC; 2550203955Srdivacky DeclarationName Name; 2551203955Srdivacky SourceLocation Loc; 2552288943Sdim NamedDecl *ToD; 2553344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2554344779Sdim return std::move(Err); 2555288943Sdim if (ToD) 2556288943Sdim return ToD; 2557276479Sdim 2558203955Srdivacky // Figure out what structure name we're looking for. 2559203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 2560203955Srdivacky DeclarationName SearchName = Name; 2561221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 2562344779Sdim if (Error Err = importInto( 2563344779Sdim SearchName, D->getTypedefNameForAnonDecl()->getDeclName())) 2564344779Sdim return std::move(Err); 2565203955Srdivacky IDNS = Decl::IDNS_Ordinary; 2566234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2567344779Sdim IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend; 2568203955Srdivacky 2569203955Srdivacky // We may already have a record of the same name; try to find and match it. 2570321369Sdim RecordDecl *PrevDecl = nullptr; 2571239462Sdim if (!DC->isFunctionOrMethod()) { 2572226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2573344779Sdim auto FoundDecls = 2574344779Sdim Importer.findDeclsInToCtx(DC, SearchName); 2575321369Sdim if (!FoundDecls.empty()) { 2576353358Sdim // We're going to have to compare D against potentially conflicting Decls, 2577353358Sdim // so complete it. 2578321369Sdim if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition()) 2579321369Sdim D->getASTContext().getExternalSource()->CompleteType(D); 2580321369Sdim } 2581321369Sdim 2582341825Sdim for (auto *FoundDecl : FoundDecls) { 2583341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2584203955Srdivacky continue; 2585341825Sdim 2586341825Sdim Decl *Found = FoundDecl; 2587341825Sdim if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 2588341825Sdim if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2589203955Srdivacky Found = Tag->getDecl(); 2590203955Srdivacky } 2591341825Sdim 2592341825Sdim if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) { 2593344779Sdim // Do not emit false positive diagnostic in case of unnamed 2594344779Sdim // struct/union and in case of anonymous structs. Would be false 2595344779Sdim // because there may be several anonymous/unnamed structs in a class. 2596344779Sdim // E.g. these are both valid: 2597344779Sdim // struct A { // unnamed structs 2598344779Sdim // struct { struct A *next; } entry0; 2599344779Sdim // struct { struct A *next; } entry1; 2600344779Sdim // }; 2601344779Sdim // struct X { struct { int a; }; struct { int b; }; }; // anon structs 2602344779Sdim if (!SearchName) 2603341825Sdim if (!IsStructuralMatch(D, FoundRecord, false)) 2604341825Sdim continue; 2605243830Sdim 2606353358Sdim if (!hasSameVisibilityContext(FoundRecord, D)) 2607353358Sdim continue; 2608353358Sdim 2609344779Sdim if (IsStructuralMatch(D, FoundRecord)) { 2610344779Sdim RecordDecl *FoundDef = FoundRecord->getDefinition(); 2611344779Sdim if (D->isThisDeclarationADefinition() && FoundDef) { 2612341825Sdim // FIXME: Structural equivalence check should check for same 2613341825Sdim // user-defined methods. 2614341825Sdim Importer.MapImported(D, FoundDef); 2615341825Sdim if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2616341825Sdim auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef); 2617341825Sdim assert(FoundCXX && "Record type mismatch"); 2618341825Sdim 2619344779Sdim if (!Importer.isMinimalImport()) 2620341825Sdim // FoundDef may not have every implicit method that D has 2621341825Sdim // because implicit methods are created only if they are used. 2622344779Sdim if (Error Err = ImportImplicitMethods(DCXX, FoundCXX)) 2623344779Sdim return std::move(Err); 2624341825Sdim } 2625203955Srdivacky } 2626344779Sdim PrevDecl = FoundRecord->getMostRecentDecl(); 2627344779Sdim break; 2628239462Sdim } 2629203955Srdivacky } 2630341825Sdim 2631341825Sdim ConflictingDecls.push_back(FoundDecl); 2632344779Sdim } // for 2633341825Sdim 2634239462Sdim if (!ConflictingDecls.empty() && SearchName) { 2635353358Sdim Name = Importer.HandleNameConflict(SearchName, DC, IDNS, 2636341825Sdim ConflictingDecls.data(), 2637203955Srdivacky ConflictingDecls.size()); 2638344779Sdim if (!Name) 2639344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2640203955Srdivacky } 2641203955Srdivacky } 2642341825Sdim 2643344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2644344779Sdim if (!BeginLocOrErr) 2645344779Sdim return BeginLocOrErr.takeError(); 2646344779Sdim 2647203955Srdivacky // Create the record declaration. 2648344779Sdim RecordDecl *D2 = nullptr; 2649344779Sdim CXXRecordDecl *D2CXX = nullptr; 2650344779Sdim if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2651344779Sdim if (DCXX->isLambda()) { 2652344779Sdim auto TInfoOrErr = import(DCXX->getLambdaTypeInfo()); 2653344779Sdim if (!TInfoOrErr) 2654344779Sdim return TInfoOrErr.takeError(); 2655344779Sdim if (GetImportedOrCreateSpecialDecl( 2656344779Sdim D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(), 2657344779Sdim DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(), 2658344779Sdim DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault())) 2659344779Sdim return D2CXX; 2660344779Sdim ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl()); 2661344779Sdim if (!CDeclOrErr) 2662344779Sdim return CDeclOrErr.takeError(); 2663344779Sdim D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr); 2664344779Sdim } else if (DCXX->isInjectedClassName()) { 2665344779Sdim // We have to be careful to do a similar dance to the one in 2666344779Sdim // Sema::ActOnStartCXXMemberDeclarations 2667344779Sdim const bool DelayTypeCreation = true; 2668344779Sdim if (GetImportedOrCreateDecl( 2669344779Sdim D2CXX, D, Importer.getToContext(), D->getTagKind(), DC, 2670344779Sdim *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(), 2671344779Sdim cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation)) 2672344779Sdim return D2CXX; 2673344779Sdim Importer.getToContext().getTypeDeclType( 2674344779Sdim D2CXX, dyn_cast<CXXRecordDecl>(DC)); 2675344779Sdim } else { 2676344779Sdim if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(), 2677344779Sdim D->getTagKind(), DC, *BeginLocOrErr, Loc, 2678344779Sdim Name.getAsIdentifierInfo(), 2679344779Sdim cast_or_null<CXXRecordDecl>(PrevDecl))) 2680344779Sdim return D2CXX; 2681344779Sdim } 2682341825Sdim 2683344779Sdim D2 = D2CXX; 2684344779Sdim D2->setAccess(D->getAccess()); 2685344779Sdim D2->setLexicalDeclContext(LexicalDC); 2686344779Sdim if (!DCXX->getDescribedClassTemplate() || DCXX->isImplicit()) 2687344779Sdim LexicalDC->addDeclInternal(D2); 2688327952Sdim 2689344779Sdim if (LexicalDC != DC && D->isInIdentifierNamespace(Decl::IDNS_TagFriend)) 2690344779Sdim DC->makeDeclVisibleInContext(D2); 2691344779Sdim 2692344779Sdim if (ClassTemplateDecl *FromDescribed = 2693344779Sdim DCXX->getDescribedClassTemplate()) { 2694344779Sdim ClassTemplateDecl *ToDescribed; 2695344779Sdim if (Error Err = importInto(ToDescribed, FromDescribed)) 2696344779Sdim return std::move(Err); 2697344779Sdim D2CXX->setDescribedClassTemplate(ToDescribed); 2698344779Sdim if (!DCXX->isInjectedClassName() && !IsFriendTemplate) { 2699344779Sdim // In a record describing a template the type should be an 2700344779Sdim // InjectedClassNameType (see Sema::CheckClassTemplate). Update the 2701344779Sdim // previously set type to the correct value here (ToDescribed is not 2702344779Sdim // available at record create). 2703344779Sdim // FIXME: The previous type is cleared but not removed from 2704344779Sdim // ASTContext's internal storage. 2705344779Sdim CXXRecordDecl *Injected = nullptr; 2706344779Sdim for (NamedDecl *Found : D2CXX->noload_lookup(Name)) { 2707344779Sdim auto *Record = dyn_cast<CXXRecordDecl>(Found); 2708344779Sdim if (Record && Record->isInjectedClassName()) { 2709344779Sdim Injected = Record; 2710344779Sdim break; 2711341825Sdim } 2712341825Sdim } 2713344779Sdim // Create an injected type for the whole redecl chain. 2714344779Sdim SmallVector<Decl *, 2> Redecls = 2715344779Sdim getCanonicalForwardRedeclChain(D2CXX); 2716344779Sdim for (auto *R : Redecls) { 2717344779Sdim auto *RI = cast<CXXRecordDecl>(R); 2718344779Sdim RI->setTypeForDecl(nullptr); 2719344779Sdim // Below we create a new injected type and assign that to the 2720344779Sdim // canonical decl, subsequent declarations in the chain will reuse 2721344779Sdim // that type. 2722344779Sdim Importer.getToContext().getInjectedClassNameType( 2723344779Sdim RI, ToDescribed->getInjectedClassNameSpecialization()); 2724344779Sdim } 2725344779Sdim // Set the new type for the previous injected decl too. 2726344779Sdim if (Injected) { 2727344779Sdim Injected->setTypeForDecl(nullptr); 2728344779Sdim Importer.getToContext().getTypeDeclType(Injected, D2CXX); 2729344779Sdim } 2730344779Sdim } 2731344779Sdim } else if (MemberSpecializationInfo *MemberInfo = 2732327952Sdim DCXX->getMemberSpecializationInfo()) { 2733327952Sdim TemplateSpecializationKind SK = 2734327952Sdim MemberInfo->getTemplateSpecializationKind(); 2735327952Sdim CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass(); 2736344779Sdim 2737344779Sdim if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst)) 2738344779Sdim D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK); 2739344779Sdim else 2740344779Sdim return ToInstOrErr.takeError(); 2741344779Sdim 2742344779Sdim if (ExpectedSLoc POIOrErr = 2743344779Sdim import(MemberInfo->getPointOfInstantiation())) 2744344779Sdim D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation( 2745344779Sdim *POIOrErr); 2746344779Sdim else 2747344779Sdim return POIOrErr.takeError(); 2748203955Srdivacky } 2749341825Sdim 2750344779Sdim } else { 2751344779Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), 2752344779Sdim D->getTagKind(), DC, *BeginLocOrErr, Loc, 2753344779Sdim Name.getAsIdentifierInfo(), PrevDecl)) 2754344779Sdim return D2; 2755344779Sdim D2->setLexicalDeclContext(LexicalDC); 2756344779Sdim LexicalDC->addDeclInternal(D2); 2757203955Srdivacky } 2758203955Srdivacky 2759344779Sdim if (auto QualifierLocOrErr = import(D->getQualifierLoc())) 2760344779Sdim D2->setQualifierInfo(*QualifierLocOrErr); 2761344779Sdim else 2762344779Sdim return QualifierLocOrErr.takeError(); 2763341825Sdim 2764344779Sdim if (D->isAnonymousStructOrUnion()) 2765344779Sdim D2->setAnonymousStructOrUnion(true); 2766276479Sdim 2767344779Sdim if (D->isCompleteDefinition()) 2768344779Sdim if (Error Err = ImportDefinition(D, D2, IDK_Default)) 2769344779Sdim return std::move(Err); 2770344779Sdim 2771203955Srdivacky return D2; 2772203955Srdivacky} 2773203955Srdivacky 2774344779SdimExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 2775203955Srdivacky // Import the major distinguishing characteristics of this enumerator. 2776203955Srdivacky DeclContext *DC, *LexicalDC; 2777203955Srdivacky DeclarationName Name; 2778203955Srdivacky SourceLocation Loc; 2779288943Sdim NamedDecl *ToD; 2780344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2781344779Sdim return std::move(Err); 2782288943Sdim if (ToD) 2783288943Sdim return ToD; 2784203955Srdivacky 2785341825Sdim // Determine whether there are any other declarations with the same name and 2786203955Srdivacky // in the same context. 2787203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 2788226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2789203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2790344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2791341825Sdim for (auto *FoundDecl : FoundDecls) { 2792341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2793203955Srdivacky continue; 2794249423Sdim 2795341825Sdim if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) { 2796249423Sdim if (IsStructuralMatch(D, FoundEnumConstant)) 2797341825Sdim return Importer.MapImported(D, FoundEnumConstant); 2798249423Sdim } 2799249423Sdim 2800341825Sdim ConflictingDecls.push_back(FoundDecl); 2801203955Srdivacky } 2802341825Sdim 2803203955Srdivacky if (!ConflictingDecls.empty()) { 2804203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 2805341825Sdim ConflictingDecls.data(), 2806203955Srdivacky ConflictingDecls.size()); 2807203955Srdivacky if (!Name) 2808344779Sdim return make_error<ImportError>(ImportError::NameConflict); 2809203955Srdivacky } 2810203955Srdivacky } 2811341825Sdim 2812344779Sdim ExpectedType TypeOrErr = import(D->getType()); 2813344779Sdim if (!TypeOrErr) 2814344779Sdim return TypeOrErr.takeError(); 2815276479Sdim 2816344779Sdim ExpectedExpr InitOrErr = import(D->getInitExpr()); 2817344779Sdim if (!InitOrErr) 2818344779Sdim return InitOrErr.takeError(); 2819344779Sdim 2820341825Sdim EnumConstantDecl *ToEnumerator; 2821341825Sdim if (GetImportedOrCreateDecl( 2822341825Sdim ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc, 2823344779Sdim Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal())) 2824341825Sdim return ToEnumerator; 2825341825Sdim 2826204643Srdivacky ToEnumerator->setAccess(D->getAccess()); 2827203955Srdivacky ToEnumerator->setLexicalDeclContext(LexicalDC); 2828234353Sdim LexicalDC->addDeclInternal(ToEnumerator); 2829203955Srdivacky return ToEnumerator; 2830203955Srdivacky} 2831203955Srdivacky 2832353358SdimError ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD, 2833353358Sdim DeclaratorDecl *ToD) { 2834353358Sdim unsigned int Num = FromD->getNumTemplateParameterLists(); 2835353358Sdim if (Num == 0) 2836353358Sdim return Error::success(); 2837353358Sdim SmallVector<TemplateParameterList *, 2> ToTPLists(Num); 2838353358Sdim for (unsigned int I = 0; I < Num; ++I) 2839353358Sdim if (Expected<TemplateParameterList *> ToTPListOrErr = 2840353358Sdim import(FromD->getTemplateParameterList(I))) 2841353358Sdim ToTPLists[I] = *ToTPListOrErr; 2842353358Sdim else 2843353358Sdim return ToTPListOrErr.takeError(); 2844353358Sdim ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists); 2845353358Sdim return Error::success(); 2846353358Sdim} 2847353358Sdim 2848344779SdimError ASTNodeImporter::ImportTemplateInformation( 2849344779Sdim FunctionDecl *FromFD, FunctionDecl *ToFD) { 2850341825Sdim switch (FromFD->getTemplatedKind()) { 2851341825Sdim case FunctionDecl::TK_NonTemplate: 2852341825Sdim case FunctionDecl::TK_FunctionTemplate: 2853344779Sdim return Error::success(); 2854341825Sdim 2855341825Sdim case FunctionDecl::TK_MemberSpecialization: { 2856344779Sdim TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind(); 2857341825Sdim 2858344779Sdim if (Expected<FunctionDecl *> InstFDOrErr = 2859344779Sdim import(FromFD->getInstantiatedFromMemberFunction())) 2860344779Sdim ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK); 2861344779Sdim else 2862344779Sdim return InstFDOrErr.takeError(); 2863344779Sdim 2864344779Sdim if (ExpectedSLoc POIOrErr = import( 2865344779Sdim FromFD->getMemberSpecializationInfo()->getPointOfInstantiation())) 2866344779Sdim ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr); 2867344779Sdim else 2868344779Sdim return POIOrErr.takeError(); 2869344779Sdim 2870344779Sdim return Error::success(); 2871341825Sdim } 2872341825Sdim 2873341825Sdim case FunctionDecl::TK_FunctionTemplateSpecialization: { 2874344779Sdim auto FunctionAndArgsOrErr = 2875341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD); 2876344779Sdim if (!FunctionAndArgsOrErr) 2877344779Sdim return FunctionAndArgsOrErr.takeError(); 2878341825Sdim 2879341825Sdim TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy( 2880344779Sdim Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr)); 2881341825Sdim 2882341825Sdim auto *FTSInfo = FromFD->getTemplateSpecializationInfo(); 2883341825Sdim TemplateArgumentListInfo ToTAInfo; 2884341825Sdim const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten; 2885341825Sdim if (FromTAArgsAsWritten) 2886344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 2887344779Sdim *FromTAArgsAsWritten, ToTAInfo)) 2888344779Sdim return Err; 2889341825Sdim 2890344779Sdim ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation()); 2891344779Sdim if (!POIOrErr) 2892344779Sdim return POIOrErr.takeError(); 2893341825Sdim 2894353358Sdim if (Error Err = ImportTemplateParameterLists(FromFD, ToFD)) 2895353358Sdim return Err; 2896353358Sdim 2897341825Sdim TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind(); 2898341825Sdim ToFD->setFunctionTemplateSpecialization( 2899344779Sdim std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr, 2900344779Sdim TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr); 2901344779Sdim return Error::success(); 2902341825Sdim } 2903341825Sdim 2904341825Sdim case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 2905341825Sdim auto *FromInfo = FromFD->getDependentSpecializationInfo(); 2906341825Sdim UnresolvedSet<8> TemplDecls; 2907341825Sdim unsigned NumTemplates = FromInfo->getNumTemplates(); 2908341825Sdim for (unsigned I = 0; I < NumTemplates; I++) { 2909344779Sdim if (Expected<FunctionTemplateDecl *> ToFTDOrErr = 2910344779Sdim import(FromInfo->getTemplate(I))) 2911344779Sdim TemplDecls.addDecl(*ToFTDOrErr); 2912341825Sdim else 2913344779Sdim return ToFTDOrErr.takeError(); 2914341825Sdim } 2915341825Sdim 2916341825Sdim // Import TemplateArgumentListInfo. 2917341825Sdim TemplateArgumentListInfo ToTAInfo; 2918344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 2919344779Sdim FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(), 2920344779Sdim llvm::makeArrayRef( 2921344779Sdim FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()), 2922344779Sdim ToTAInfo)) 2923344779Sdim return Err; 2924341825Sdim 2925341825Sdim ToFD->setDependentTemplateSpecialization(Importer.getToContext(), 2926341825Sdim TemplDecls, ToTAInfo); 2927344779Sdim return Error::success(); 2928341825Sdim } 2929341825Sdim } 2930341825Sdim llvm_unreachable("All cases should be covered!"); 2931341825Sdim} 2932341825Sdim 2933344779SdimExpected<FunctionDecl *> 2934341825SdimASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) { 2935344779Sdim auto FunctionAndArgsOrErr = 2936341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD); 2937344779Sdim if (!FunctionAndArgsOrErr) 2938344779Sdim return FunctionAndArgsOrErr.takeError(); 2939341825Sdim 2940344779Sdim FunctionTemplateDecl *Template; 2941344779Sdim TemplateArgsTy ToTemplArgs; 2942344779Sdim std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr; 2943341825Sdim void *InsertPos = nullptr; 2944344779Sdim auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos); 2945341825Sdim return FoundSpec; 2946341825Sdim} 2947341825Sdim 2948353358SdimError ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD, 2949353358Sdim FunctionDecl *ToFD) { 2950353358Sdim if (Stmt *FromBody = FromFD->getBody()) { 2951353358Sdim if (ExpectedStmt ToBodyOrErr = import(FromBody)) 2952353358Sdim ToFD->setBody(*ToBodyOrErr); 2953353358Sdim else 2954353358Sdim return ToBodyOrErr.takeError(); 2955353358Sdim } 2956353358Sdim return Error::success(); 2957353358Sdim} 2958353358Sdim 2959353358Sdimtemplate <typename T> 2960353358Sdimbool ASTNodeImporter::hasSameVisibilityContext(T *Found, T *From) { 2961353358Sdim if (From->hasExternalFormalLinkage()) 2962353358Sdim return Found->hasExternalFormalLinkage(); 2963353358Sdim if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl()) 2964353358Sdim return false; 2965353358Sdim if (From->isInAnonymousNamespace()) 2966353358Sdim return Found->isInAnonymousNamespace(); 2967353358Sdim else 2968353358Sdim return !Found->isInAnonymousNamespace() && 2969353358Sdim !Found->hasExternalFormalLinkage(); 2970353358Sdim} 2971353358Sdim 2972344779SdimExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 2973341825Sdim 2974344779Sdim SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D); 2975341825Sdim auto RedeclIt = Redecls.begin(); 2976341825Sdim // Import the first part of the decl chain. I.e. import all previous 2977341825Sdim // declarations starting from the canonical decl. 2978344779Sdim for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) { 2979344779Sdim ExpectedDecl ToRedeclOrErr = import(*RedeclIt); 2980344779Sdim if (!ToRedeclOrErr) 2981344779Sdim return ToRedeclOrErr.takeError(); 2982344779Sdim } 2983341825Sdim assert(*RedeclIt == D); 2984341825Sdim 2985203955Srdivacky // Import the major distinguishing characteristics of this function. 2986203955Srdivacky DeclContext *DC, *LexicalDC; 2987203955Srdivacky DeclarationName Name; 2988203955Srdivacky SourceLocation Loc; 2989288943Sdim NamedDecl *ToD; 2990344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2991344779Sdim return std::move(Err); 2992288943Sdim if (ToD) 2993288943Sdim return ToD; 2994212904Sdim 2995353358Sdim FunctionDecl *FoundByLookup = nullptr; 2996341825Sdim FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate(); 2997327952Sdim 2998341825Sdim // If this is a function template specialization, then try to find the same 2999344779Sdim // existing specialization in the "to" context. The lookup below will not 3000344779Sdim // find any specialization, but would find the primary template; thus, we 3001344779Sdim // have to skip normal lookup in case of specializations. 3002341825Sdim // FIXME handle member function templates (TK_MemberSpecialization) similarly? 3003341825Sdim if (D->getTemplatedKind() == 3004341825Sdim FunctionDecl::TK_FunctionTemplateSpecialization) { 3005344779Sdim auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D); 3006344779Sdim if (!FoundFunctionOrErr) 3007344779Sdim return FoundFunctionOrErr.takeError(); 3008344779Sdim if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) { 3009353358Sdim if (Decl *Def = FindAndMapDefinition(D, FoundFunction)) 3010353358Sdim return Def; 3011341825Sdim FoundByLookup = FoundFunction; 3012341825Sdim } 3013341825Sdim } 3014203955Srdivacky // Try to find a function in our own ("to") context with the same name, same 3015203955Srdivacky // type, and in the same context as the function we're importing. 3016341825Sdim else if (!LexicalDC->isFunctionOrMethod()) { 3017226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3018341825Sdim unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend; 3019344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3020341825Sdim for (auto *FoundDecl : FoundDecls) { 3021341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 3022203955Srdivacky continue; 3023321369Sdim 3024341825Sdim if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) { 3025353358Sdim if (!hasSameVisibilityContext(FoundFunction, D)) 3026353358Sdim continue; 3027321369Sdim 3028353358Sdim if (IsStructuralMatch(D, FoundFunction)) { 3029353358Sdim if (Decl *Def = FindAndMapDefinition(D, FoundFunction)) 3030353358Sdim return Def; 3031353358Sdim FoundByLookup = FoundFunction; 3032353358Sdim break; 3033353358Sdim } 3034353358Sdim // FIXME: Check for overloading more carefully, e.g., by boosting 3035353358Sdim // Sema::IsOverload out to the AST library. 3036321369Sdim 3037353358Sdim // Function overloading is okay in C++. 3038353358Sdim if (Importer.getToContext().getLangOpts().CPlusPlus) 3039353358Sdim continue; 3040321369Sdim 3041353358Sdim // Complain about inconsistent function types. 3042353358Sdim Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent) 3043203955Srdivacky << Name << D->getType() << FoundFunction->getType(); 3044353358Sdim Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here) 3045203955Srdivacky << FoundFunction->getType(); 3046203955Srdivacky } 3047321369Sdim 3048341825Sdim ConflictingDecls.push_back(FoundDecl); 3049203955Srdivacky } 3050321369Sdim 3051203955Srdivacky if (!ConflictingDecls.empty()) { 3052203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 3053341825Sdim ConflictingDecls.data(), 3054203955Srdivacky ConflictingDecls.size()); 3055203955Srdivacky if (!Name) 3056344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3057341825Sdim } 3058203955Srdivacky } 3059203955Srdivacky 3060353358Sdim // We do not allow more than one in-class declaration of a function. This is 3061353358Sdim // because AST clients like VTableBuilder asserts on this. VTableBuilder 3062353358Sdim // assumes there is only one in-class declaration. Building a redecl 3063353358Sdim // chain would result in more than one in-class declaration for 3064353358Sdim // overrides (even if they are part of the same redecl chain inside the 3065353358Sdim // derived class.) 3066353358Sdim if (FoundByLookup) { 3067353358Sdim if (isa<CXXMethodDecl>(FoundByLookup)) { 3068353358Sdim if (D->getLexicalDeclContext() == D->getDeclContext()) { 3069353358Sdim if (!D->doesThisDeclarationHaveABody()) 3070353358Sdim return Importer.MapImported(D, FoundByLookup); 3071353358Sdim else { 3072353358Sdim // Let's continue and build up the redecl chain in this case. 3073353358Sdim // FIXME Merge the functions into one decl. 3074353358Sdim } 3075353358Sdim } 3076353358Sdim } 3077353358Sdim } 3078353358Sdim 3079212904Sdim DeclarationNameInfo NameInfo(Name, Loc); 3080212904Sdim // Import additional name location/type info. 3081344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 3082344779Sdim return std::move(Err); 3083212904Sdim 3084243830Sdim QualType FromTy = D->getType(); 3085243830Sdim bool usedDifferentExceptionSpec = false; 3086243830Sdim 3087341825Sdim if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) { 3088243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 3089243830Sdim // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 3090243830Sdim // FunctionDecl that we are importing the FunctionProtoType for. 3091243830Sdim // To avoid an infinite recursion when importing, create the FunctionDecl 3092243830Sdim // with a simplified function type and update it afterwards. 3093280031Sdim if (FromEPI.ExceptionSpec.SourceDecl || 3094280031Sdim FromEPI.ExceptionSpec.SourceTemplate || 3095280031Sdim FromEPI.ExceptionSpec.NoexceptExpr) { 3096243830Sdim FunctionProtoType::ExtProtoInfo DefaultEPI; 3097243830Sdim FromTy = Importer.getFromContext().getFunctionType( 3098276479Sdim FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI); 3099243830Sdim usedDifferentExceptionSpec = true; 3100243830Sdim } 3101243830Sdim } 3102243830Sdim 3103344779Sdim QualType T; 3104344779Sdim TypeSourceInfo *TInfo; 3105344779Sdim SourceLocation ToInnerLocStart, ToEndLoc; 3106344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 3107344779Sdim if (auto Imp = importSeq( 3108344779Sdim FromTy, D->getTypeSourceInfo(), D->getInnerLocStart(), 3109344779Sdim D->getQualifierLoc(), D->getEndLoc())) 3110344779Sdim std::tie(T, TInfo, ToInnerLocStart, ToQualifierLoc, ToEndLoc) = *Imp; 3111344779Sdim else 3112344779Sdim return Imp.takeError(); 3113276479Sdim 3114203955Srdivacky // Import the function parameters. 3115226633Sdim SmallVector<ParmVarDecl *, 8> Parameters; 3116309124Sdim for (auto P : D->parameters()) { 3117344779Sdim if (Expected<ParmVarDecl *> ToPOrErr = import(P)) 3118344779Sdim Parameters.push_back(*ToPOrErr); 3119344779Sdim else 3120344779Sdim return ToPOrErr.takeError(); 3121203955Srdivacky } 3122341825Sdim 3123203955Srdivacky // Create the imported function. 3124276479Sdim FunctionDecl *ToFunction = nullptr; 3125341825Sdim if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 3126353358Sdim Expr *ExplicitExpr = nullptr; 3127353358Sdim if (FromConstructor->getExplicitSpecifier().getExpr()) { 3128353358Sdim auto Imp = importSeq(FromConstructor->getExplicitSpecifier().getExpr()); 3129353358Sdim if (!Imp) 3130353358Sdim return Imp.takeError(); 3131353358Sdim std::tie(ExplicitExpr) = *Imp; 3132353358Sdim } 3133341825Sdim if (GetImportedOrCreateDecl<CXXConstructorDecl>( 3134353358Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3135353358Sdim ToInnerLocStart, NameInfo, T, TInfo, 3136353358Sdim ExplicitSpecifier( 3137353358Sdim ExplicitExpr, 3138353358Sdim FromConstructor->getExplicitSpecifier().getKind()), 3139353358Sdim D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind())) 3140341825Sdim return ToFunction; 3141353358Sdim } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) { 3142353358Sdim 3143353358Sdim auto Imp = 3144353358Sdim importSeq(const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()), 3145353358Sdim FromDtor->getOperatorDeleteThisArg()); 3146353358Sdim 3147353358Sdim if (!Imp) 3148353358Sdim return Imp.takeError(); 3149353358Sdim 3150353358Sdim FunctionDecl *ToOperatorDelete; 3151353358Sdim Expr *ToThisArg; 3152353358Sdim std::tie(ToOperatorDelete, ToThisArg) = *Imp; 3153353358Sdim 3154341825Sdim if (GetImportedOrCreateDecl<CXXDestructorDecl>( 3155344779Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3156344779Sdim ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), 3157344779Sdim D->isImplicit())) 3158341825Sdim return ToFunction; 3159353358Sdim 3160353358Sdim CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction); 3161353358Sdim 3162353358Sdim ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg); 3163341825Sdim } else if (CXXConversionDecl *FromConversion = 3164341825Sdim dyn_cast<CXXConversionDecl>(D)) { 3165353358Sdim Expr *ExplicitExpr = nullptr; 3166353358Sdim if (FromConversion->getExplicitSpecifier().getExpr()) { 3167353358Sdim auto Imp = importSeq(FromConversion->getExplicitSpecifier().getExpr()); 3168353358Sdim if (!Imp) 3169353358Sdim return Imp.takeError(); 3170353358Sdim std::tie(ExplicitExpr) = *Imp; 3171353358Sdim } 3172341825Sdim if (GetImportedOrCreateDecl<CXXConversionDecl>( 3173341825Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3174344779Sdim ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), 3175353358Sdim ExplicitSpecifier(ExplicitExpr, 3176353358Sdim FromConversion->getExplicitSpecifier().getKind()), 3177353358Sdim D->getConstexprKind(), SourceLocation())) 3178341825Sdim return ToFunction; 3179341825Sdim } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) { 3180341825Sdim if (GetImportedOrCreateDecl<CXXMethodDecl>( 3181341825Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3182344779Sdim ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(), 3183353358Sdim Method->isInlineSpecified(), D->getConstexprKind(), 3184353358Sdim SourceLocation())) 3185341825Sdim return ToFunction; 3186204643Srdivacky } else { 3187353358Sdim if (GetImportedOrCreateDecl( 3188353358Sdim ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, 3189353358Sdim NameInfo, T, TInfo, D->getStorageClass(), D->isInlineSpecified(), 3190353358Sdim D->hasWrittenPrototype(), D->getConstexprKind())) 3191341825Sdim return ToFunction; 3192204643Srdivacky } 3193205219Srdivacky 3194344779Sdim // Connect the redecl chain. 3195344779Sdim if (FoundByLookup) { 3196344779Sdim auto *Recent = const_cast<FunctionDecl *>( 3197344779Sdim FoundByLookup->getMostRecentDecl()); 3198344779Sdim ToFunction->setPreviousDecl(Recent); 3199353358Sdim // FIXME Probably we should merge exception specifications. E.g. In the 3200353358Sdim // "To" context the existing function may have exception specification with 3201353358Sdim // noexcept-unevaluated, while the newly imported function may have an 3202353358Sdim // evaluated noexcept. A call to adjustExceptionSpec() on the imported 3203353358Sdim // decl and its redeclarations may be required. 3204344779Sdim } 3205344779Sdim 3206344779Sdim // Import Ctor initializers. 3207344779Sdim if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 3208344779Sdim if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) { 3209344779Sdim SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers); 3210344779Sdim // Import first, then allocate memory and copy if there was no error. 3211344779Sdim if (Error Err = ImportContainerChecked( 3212344779Sdim FromConstructor->inits(), CtorInitializers)) 3213344779Sdim return std::move(Err); 3214344779Sdim auto **Memory = 3215344779Sdim new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers]; 3216344779Sdim std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory); 3217344779Sdim auto *ToCtor = cast<CXXConstructorDecl>(ToFunction); 3218344779Sdim ToCtor->setCtorInitializers(Memory); 3219344779Sdim ToCtor->setNumCtorInitializers(NumInitializers); 3220344779Sdim } 3221344779Sdim } 3222344779Sdim 3223344779Sdim ToFunction->setQualifierInfo(ToQualifierLoc); 3224204643Srdivacky ToFunction->setAccess(D->getAccess()); 3225204643Srdivacky ToFunction->setLexicalDeclContext(LexicalDC); 3226218893Sdim ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 3227218893Sdim ToFunction->setTrivial(D->isTrivial()); 3228218893Sdim ToFunction->setPure(D->isPure()); 3229344779Sdim ToFunction->setRangeEnd(ToEndLoc); 3230203955Srdivacky 3231203955Srdivacky // Set the parameters. 3232341825Sdim for (auto *Param : Parameters) { 3233341825Sdim Param->setOwningFunction(ToFunction); 3234341825Sdim ToFunction->addDeclInternal(Param); 3235203955Srdivacky } 3236226633Sdim ToFunction->setParams(Parameters); 3237203955Srdivacky 3238341825Sdim // We need to complete creation of FunctionProtoTypeLoc manually with setting 3239341825Sdim // params it refers to. 3240341825Sdim if (TInfo) { 3241341825Sdim if (auto ProtoLoc = 3242341825Sdim TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) { 3243341825Sdim for (unsigned I = 0, N = Parameters.size(); I != N; ++I) 3244341825Sdim ProtoLoc.setParam(I, Parameters[I]); 3245341825Sdim } 3246341825Sdim } 3247341825Sdim 3248243830Sdim if (usedDifferentExceptionSpec) { 3249243830Sdim // Update FunctionProtoType::ExtProtoInfo. 3250344779Sdim if (ExpectedType TyOrErr = import(D->getType())) 3251344779Sdim ToFunction->setType(*TyOrErr); 3252344779Sdim else 3253344779Sdim return TyOrErr.takeError(); 3254243830Sdim } 3255243830Sdim 3256341825Sdim // Import the describing template function, if any. 3257344779Sdim if (FromFT) { 3258344779Sdim auto ToFTOrErr = import(FromFT); 3259344779Sdim if (!ToFTOrErr) 3260344779Sdim return ToFTOrErr.takeError(); 3261344779Sdim } 3262341825Sdim 3263341825Sdim if (D->doesThisDeclarationHaveABody()) { 3264353358Sdim Error Err = ImportFunctionDeclBody(D, ToFunction); 3265353358Sdim 3266353358Sdim if (Err) 3267353358Sdim return std::move(Err); 3268288943Sdim } 3269288943Sdim 3270203955Srdivacky // FIXME: Other bits to merge? 3271218893Sdim 3272341825Sdim // If it is a template, import all related things. 3273344779Sdim if (Error Err = ImportTemplateInformation(D, ToFunction)) 3274344779Sdim return std::move(Err); 3275218893Sdim 3276341825Sdim bool IsFriend = D->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend); 3277341825Sdim 3278341825Sdim // TODO Can we generalize this approach to other AST nodes as well? 3279341825Sdim if (D->getDeclContext()->containsDeclAndLoad(D)) 3280341825Sdim DC->addDeclInternal(ToFunction); 3281341825Sdim if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D)) 3282341825Sdim LexicalDC->addDeclInternal(ToFunction); 3283341825Sdim 3284341825Sdim // Friend declaration's lexical context is the befriending class, but the 3285341825Sdim // semantic context is the enclosing scope of the befriending class. 3286341825Sdim // We want the friend functions to be found in the semantic context by lookup. 3287341825Sdim // FIXME should we handle this generically in VisitFriendDecl? 3288341825Sdim // In Other cases when LexicalDC != DC we don't want it to be added, 3289341825Sdim // e.g out-of-class definitions like void B::f() {} . 3290341825Sdim if (LexicalDC != DC && IsFriend) { 3291341825Sdim DC->makeDeclVisibleInContext(ToFunction); 3292341825Sdim } 3293341825Sdim 3294321369Sdim if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D)) 3295321369Sdim ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod); 3296321369Sdim 3297344779Sdim // Import the rest of the chain. I.e. import all subsequent declarations. 3298344779Sdim for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) { 3299344779Sdim ExpectedDecl ToRedeclOrErr = import(*RedeclIt); 3300344779Sdim if (!ToRedeclOrErr) 3301344779Sdim return ToRedeclOrErr.takeError(); 3302344779Sdim } 3303344779Sdim 3304204643Srdivacky return ToFunction; 3305203955Srdivacky} 3306203955Srdivacky 3307344779SdimExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 3308204643Srdivacky return VisitFunctionDecl(D); 3309204643Srdivacky} 3310204643Srdivacky 3311344779SdimExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 3312204643Srdivacky return VisitCXXMethodDecl(D); 3313204643Srdivacky} 3314204643Srdivacky 3315344779SdimExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 3316204643Srdivacky return VisitCXXMethodDecl(D); 3317204643Srdivacky} 3318204643Srdivacky 3319344779SdimExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 3320204643Srdivacky return VisitCXXMethodDecl(D); 3321204643Srdivacky} 3322204643Srdivacky 3323344779SdimExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 3324203955Srdivacky // Import the major distinguishing characteristics of a variable. 3325203955Srdivacky DeclContext *DC, *LexicalDC; 3326203955Srdivacky DeclarationName Name; 3327203955Srdivacky SourceLocation Loc; 3328288943Sdim NamedDecl *ToD; 3329344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3330344779Sdim return std::move(Err); 3331288943Sdim if (ToD) 3332288943Sdim return ToD; 3333276479Sdim 3334341825Sdim // Determine whether we've already imported this field. 3335344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3336341825Sdim for (auto *FoundDecl : FoundDecls) { 3337344779Sdim if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) { 3338243830Sdim // For anonymous fields, match up by index. 3339344779Sdim if (!Name && 3340344779Sdim ASTImporter::getFieldIndex(D) != 3341344779Sdim ASTImporter::getFieldIndex(FoundField)) 3342243830Sdim continue; 3343243830Sdim 3344321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3345226633Sdim FoundField->getType())) { 3346341825Sdim Importer.MapImported(D, FoundField); 3347344779Sdim // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the 3348344779Sdim // initializer of a FieldDecl might not had been instantiated in the 3349344779Sdim // "To" context. However, the "From" context might instantiated that, 3350344779Sdim // thus we have to merge that. 3351344779Sdim if (Expr *FromInitializer = D->getInClassInitializer()) { 3352344779Sdim // We don't have yet the initializer set. 3353344779Sdim if (FoundField->hasInClassInitializer() && 3354344779Sdim !FoundField->getInClassInitializer()) { 3355344779Sdim if (ExpectedExpr ToInitializerOrErr = import(FromInitializer)) 3356344779Sdim FoundField->setInClassInitializer(*ToInitializerOrErr); 3357344779Sdim else { 3358344779Sdim // We can't return error here, 3359344779Sdim // since we already mapped D as imported. 3360344779Sdim // FIXME: warning message? 3361344779Sdim consumeError(ToInitializerOrErr.takeError()); 3362344779Sdim return FoundField; 3363344779Sdim } 3364344779Sdim } 3365344779Sdim } 3366226633Sdim return FoundField; 3367226633Sdim } 3368321369Sdim 3369344779Sdim // FIXME: Why is this case not handled with calling HandleNameConflict? 3370353358Sdim Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) 3371226633Sdim << Name << D->getType() << FoundField->getType(); 3372226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 3373226633Sdim << FoundField->getType(); 3374344779Sdim 3375344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3376226633Sdim } 3377226633Sdim } 3378226633Sdim 3379344779Sdim QualType ToType; 3380344779Sdim TypeSourceInfo *ToTInfo; 3381344779Sdim Expr *ToBitWidth; 3382344779Sdim SourceLocation ToInnerLocStart; 3383344779Sdim Expr *ToInitializer; 3384344779Sdim if (auto Imp = importSeq( 3385344779Sdim D->getType(), D->getTypeSourceInfo(), D->getBitWidth(), 3386344779Sdim D->getInnerLocStart(), D->getInClassInitializer())) 3387344779Sdim std::tie( 3388344779Sdim ToType, ToTInfo, ToBitWidth, ToInnerLocStart, ToInitializer) = *Imp; 3389344779Sdim else 3390344779Sdim return Imp.takeError(); 3391276479Sdim 3392341825Sdim FieldDecl *ToField; 3393341825Sdim if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC, 3394344779Sdim ToInnerLocStart, Loc, Name.getAsIdentifierInfo(), 3395344779Sdim ToType, ToTInfo, ToBitWidth, D->isMutable(), 3396344779Sdim D->getInClassInitStyle())) 3397341825Sdim return ToField; 3398341825Sdim 3399204643Srdivacky ToField->setAccess(D->getAccess()); 3400203955Srdivacky ToField->setLexicalDeclContext(LexicalDC); 3401344779Sdim if (ToInitializer) 3402344779Sdim ToField->setInClassInitializer(ToInitializer); 3403243830Sdim ToField->setImplicit(D->isImplicit()); 3404234353Sdim LexicalDC->addDeclInternal(ToField); 3405203955Srdivacky return ToField; 3406203955Srdivacky} 3407203955Srdivacky 3408344779SdimExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 3409218893Sdim // Import the major distinguishing characteristics of a variable. 3410218893Sdim DeclContext *DC, *LexicalDC; 3411218893Sdim DeclarationName Name; 3412218893Sdim SourceLocation Loc; 3413288943Sdim NamedDecl *ToD; 3414344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3415344779Sdim return std::move(Err); 3416288943Sdim if (ToD) 3417288943Sdim return ToD; 3418218893Sdim 3419341825Sdim // Determine whether we've already imported this field. 3420344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3421226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3422341825Sdim if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 3423243830Sdim // For anonymous indirect fields, match up by index. 3424344779Sdim if (!Name && 3425344779Sdim ASTImporter::getFieldIndex(D) != 3426344779Sdim ASTImporter::getFieldIndex(FoundField)) 3427243830Sdim continue; 3428243830Sdim 3429321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3430239462Sdim FoundField->getType(), 3431261991Sdim !Name.isEmpty())) { 3432341825Sdim Importer.MapImported(D, FoundField); 3433226633Sdim return FoundField; 3434226633Sdim } 3435239462Sdim 3436239462Sdim // If there are more anonymous fields to check, continue. 3437239462Sdim if (!Name && I < N-1) 3438239462Sdim continue; 3439239462Sdim 3440344779Sdim // FIXME: Why is this case not handled with calling HandleNameConflict? 3441353358Sdim Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) 3442226633Sdim << Name << D->getType() << FoundField->getType(); 3443226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 3444226633Sdim << FoundField->getType(); 3445344779Sdim 3446344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3447226633Sdim } 3448226633Sdim } 3449226633Sdim 3450218893Sdim // Import the type. 3451344779Sdim auto TypeOrErr = import(D->getType()); 3452344779Sdim if (!TypeOrErr) 3453344779Sdim return TypeOrErr.takeError(); 3454218893Sdim 3455341825Sdim auto **NamedChain = 3456341825Sdim new (Importer.getToContext()) NamedDecl*[D->getChainingSize()]; 3457218893Sdim 3458218893Sdim unsigned i = 0; 3459344779Sdim for (auto *PI : D->chain()) 3460344779Sdim if (Expected<NamedDecl *> ToD = import(PI)) 3461344779Sdim NamedChain[i++] = *ToD; 3462344779Sdim else 3463344779Sdim return ToD.takeError(); 3464218893Sdim 3465341825Sdim llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()}; 3466341825Sdim IndirectFieldDecl *ToIndirectField; 3467341825Sdim if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC, 3468344779Sdim Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH)) 3469341825Sdim // FIXME here we leak `NamedChain` which is allocated before 3470341825Sdim return ToIndirectField; 3471280031Sdim 3472218893Sdim ToIndirectField->setAccess(D->getAccess()); 3473218893Sdim ToIndirectField->setLexicalDeclContext(LexicalDC); 3474234353Sdim LexicalDC->addDeclInternal(ToIndirectField); 3475218893Sdim return ToIndirectField; 3476218893Sdim} 3477218893Sdim 3478344779SdimExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) { 3479314564Sdim // Import the major distinguishing characteristics of a declaration. 3480344779Sdim DeclContext *DC, *LexicalDC; 3481344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 3482344779Sdim return std::move(Err); 3483314564Sdim 3484314564Sdim // Determine whether we've already imported this decl. 3485344779Sdim // FriendDecl is not a NamedDecl so we cannot use lookup. 3486314564Sdim auto *RD = cast<CXXRecordDecl>(DC); 3487314564Sdim FriendDecl *ImportedFriend = RD->getFirstFriend(); 3488314564Sdim 3489314564Sdim while (ImportedFriend) { 3490314564Sdim if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) { 3491341825Sdim if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(), 3492341825Sdim /*Complain=*/false)) 3493341825Sdim return Importer.MapImported(D, ImportedFriend); 3494314564Sdim 3495314564Sdim } else if (D->getFriendType() && ImportedFriend->getFriendType()) { 3496314564Sdim if (Importer.IsStructurallyEquivalent( 3497314564Sdim D->getFriendType()->getType(), 3498314564Sdim ImportedFriend->getFriendType()->getType(), true)) 3499341825Sdim return Importer.MapImported(D, ImportedFriend); 3500314564Sdim } 3501314564Sdim ImportedFriend = ImportedFriend->getNextFriend(); 3502314564Sdim } 3503314564Sdim 3504314564Sdim // Not found. Create it. 3505314564Sdim FriendDecl::FriendUnion ToFU; 3506341825Sdim if (NamedDecl *FriendD = D->getFriendDecl()) { 3507344779Sdim NamedDecl *ToFriendD; 3508344779Sdim if (Error Err = importInto(ToFriendD, FriendD)) 3509344779Sdim return std::move(Err); 3510344779Sdim 3511344779Sdim if (FriendD->getFriendObjectKind() != Decl::FOK_None && 3512341825Sdim !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator))) 3513341825Sdim ToFriendD->setObjectOfFriendDecl(false); 3514341825Sdim 3515341825Sdim ToFU = ToFriendD; 3516344779Sdim } else { // The friend is a type, not a decl. 3517344779Sdim if (auto TSIOrErr = import(D->getFriendType())) 3518344779Sdim ToFU = *TSIOrErr; 3519344779Sdim else 3520344779Sdim return TSIOrErr.takeError(); 3521344779Sdim } 3522314564Sdim 3523314564Sdim SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists); 3524341825Sdim auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>(); 3525314564Sdim for (unsigned I = 0; I < D->NumTPLists; I++) { 3526353358Sdim if (auto ListOrErr = import(FromTPLists[I])) 3527344779Sdim ToTPLists[I] = *ListOrErr; 3528344779Sdim else 3529344779Sdim return ListOrErr.takeError(); 3530314564Sdim } 3531314564Sdim 3532344779Sdim auto LocationOrErr = import(D->getLocation()); 3533344779Sdim if (!LocationOrErr) 3534344779Sdim return LocationOrErr.takeError(); 3535344779Sdim auto FriendLocOrErr = import(D->getFriendLoc()); 3536344779Sdim if (!FriendLocOrErr) 3537344779Sdim return FriendLocOrErr.takeError(); 3538344779Sdim 3539341825Sdim FriendDecl *FrD; 3540341825Sdim if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC, 3541344779Sdim *LocationOrErr, ToFU, 3542344779Sdim *FriendLocOrErr, ToTPLists)) 3543341825Sdim return FrD; 3544314564Sdim 3545314564Sdim FrD->setAccess(D->getAccess()); 3546314564Sdim FrD->setLexicalDeclContext(LexicalDC); 3547314564Sdim LexicalDC->addDeclInternal(FrD); 3548314564Sdim return FrD; 3549314564Sdim} 3550314564Sdim 3551344779SdimExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 3552204643Srdivacky // Import the major distinguishing characteristics of an ivar. 3553204643Srdivacky DeclContext *DC, *LexicalDC; 3554204643Srdivacky DeclarationName Name; 3555204643Srdivacky SourceLocation Loc; 3556288943Sdim NamedDecl *ToD; 3557344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3558344779Sdim return std::move(Err); 3559288943Sdim if (ToD) 3560288943Sdim return ToD; 3561276479Sdim 3562321369Sdim // Determine whether we've already imported this ivar 3563344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3564341825Sdim for (auto *FoundDecl : FoundDecls) { 3565344779Sdim if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) { 3566321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3567204643Srdivacky FoundIvar->getType())) { 3568341825Sdim Importer.MapImported(D, FoundIvar); 3569204643Srdivacky return FoundIvar; 3570204643Srdivacky } 3571204643Srdivacky 3572353358Sdim Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent) 3573204643Srdivacky << Name << D->getType() << FoundIvar->getType(); 3574204643Srdivacky Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 3575204643Srdivacky << FoundIvar->getType(); 3576344779Sdim 3577344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3578204643Srdivacky } 3579204643Srdivacky } 3580204643Srdivacky 3581344779Sdim QualType ToType; 3582344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3583344779Sdim Expr *ToBitWidth; 3584344779Sdim SourceLocation ToInnerLocStart; 3585344779Sdim if (auto Imp = importSeq( 3586344779Sdim D->getType(), D->getTypeSourceInfo(), D->getBitWidth(), D->getInnerLocStart())) 3587344779Sdim std::tie(ToType, ToTypeSourceInfo, ToBitWidth, ToInnerLocStart) = *Imp; 3588344779Sdim else 3589344779Sdim return Imp.takeError(); 3590276479Sdim 3591341825Sdim ObjCIvarDecl *ToIvar; 3592341825Sdim if (GetImportedOrCreateDecl( 3593341825Sdim ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC), 3594344779Sdim ToInnerLocStart, Loc, Name.getAsIdentifierInfo(), 3595344779Sdim ToType, ToTypeSourceInfo, 3596344779Sdim D->getAccessControl(),ToBitWidth, D->getSynthesize())) 3597341825Sdim return ToIvar; 3598341825Sdim 3599204643Srdivacky ToIvar->setLexicalDeclContext(LexicalDC); 3600234353Sdim LexicalDC->addDeclInternal(ToIvar); 3601204643Srdivacky return ToIvar; 3602204643Srdivacky} 3603204643Srdivacky 3604344779SdimExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) { 3605344779Sdim 3606344779Sdim SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D); 3607344779Sdim auto RedeclIt = Redecls.begin(); 3608344779Sdim // Import the first part of the decl chain. I.e. import all previous 3609344779Sdim // declarations starting from the canonical decl. 3610344779Sdim for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) { 3611344779Sdim ExpectedDecl RedeclOrErr = import(*RedeclIt); 3612344779Sdim if (!RedeclOrErr) 3613344779Sdim return RedeclOrErr.takeError(); 3614344779Sdim } 3615344779Sdim assert(*RedeclIt == D); 3616344779Sdim 3617203955Srdivacky // Import the major distinguishing characteristics of a variable. 3618203955Srdivacky DeclContext *DC, *LexicalDC; 3619203955Srdivacky DeclarationName Name; 3620203955Srdivacky SourceLocation Loc; 3621288943Sdim NamedDecl *ToD; 3622344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3623344779Sdim return std::move(Err); 3624288943Sdim if (ToD) 3625288943Sdim return ToD; 3626276479Sdim 3627203955Srdivacky // Try to find a variable in our own ("to") context with the same name and 3628203955Srdivacky // in the same context as the variable we're importing. 3629344779Sdim VarDecl *FoundByLookup = nullptr; 3630203955Srdivacky if (D->isFileVarDecl()) { 3631226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3632203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 3633344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3634341825Sdim for (auto *FoundDecl : FoundDecls) { 3635341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 3636203955Srdivacky continue; 3637321369Sdim 3638341825Sdim if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) { 3639353358Sdim if (!hasSameVisibilityContext(FoundVar, D)) 3640353358Sdim continue; 3641353358Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3642353358Sdim FoundVar->getType())) { 3643344779Sdim 3644353358Sdim // The VarDecl in the "From" context has a definition, but in the 3645353358Sdim // "To" context we already have a definition. 3646353358Sdim VarDecl *FoundDef = FoundVar->getDefinition(); 3647353358Sdim if (D->isThisDeclarationADefinition() && FoundDef) 3648353358Sdim // FIXME Check for ODR error if the two definitions have 3649353358Sdim // different initializers? 3650353358Sdim return Importer.MapImported(D, FoundDef); 3651344779Sdim 3652353358Sdim // The VarDecl in the "From" context has an initializer, but in the 3653353358Sdim // "To" context we already have an initializer. 3654353358Sdim const VarDecl *FoundDInit = nullptr; 3655353358Sdim if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit)) 3656353358Sdim // FIXME Diagnose ODR error if the two initializers are different? 3657353358Sdim return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit)); 3658344779Sdim 3659353358Sdim FoundByLookup = FoundVar; 3660353358Sdim break; 3661353358Sdim } 3662353358Sdim 3663353358Sdim const ArrayType *FoundArray 3664353358Sdim = Importer.getToContext().getAsArrayType(FoundVar->getType()); 3665353358Sdim const ArrayType *TArray 3666353358Sdim = Importer.getToContext().getAsArrayType(D->getType()); 3667353358Sdim if (FoundArray && TArray) { 3668353358Sdim if (isa<IncompleteArrayType>(FoundArray) && 3669353358Sdim isa<ConstantArrayType>(TArray)) { 3670353358Sdim // Import the type. 3671353358Sdim if (auto TyOrErr = import(D->getType())) 3672353358Sdim FoundVar->setType(*TyOrErr); 3673353358Sdim else 3674353358Sdim return TyOrErr.takeError(); 3675353358Sdim 3676344779Sdim FoundByLookup = FoundVar; 3677203955Srdivacky break; 3678353358Sdim } else if (isa<IncompleteArrayType>(TArray) && 3679353358Sdim isa<ConstantArrayType>(FoundArray)) { 3680353358Sdim FoundByLookup = FoundVar; 3681353358Sdim break; 3682203955Srdivacky } 3683353358Sdim } 3684203955Srdivacky 3685353358Sdim Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent) 3686353358Sdim << Name << D->getType() << FoundVar->getType(); 3687353358Sdim Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 3688353358Sdim << FoundVar->getType(); 3689203955Srdivacky } 3690341825Sdim 3691341825Sdim ConflictingDecls.push_back(FoundDecl); 3692203955Srdivacky } 3693203955Srdivacky 3694203955Srdivacky if (!ConflictingDecls.empty()) { 3695203955Srdivacky Name = Importer.HandleNameConflict(Name, DC, IDNS, 3696341825Sdim ConflictingDecls.data(), 3697203955Srdivacky ConflictingDecls.size()); 3698203955Srdivacky if (!Name) 3699344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3700203955Srdivacky } 3701203955Srdivacky } 3702341825Sdim 3703344779Sdim QualType ToType; 3704344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3705344779Sdim SourceLocation ToInnerLocStart; 3706344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 3707344779Sdim if (auto Imp = importSeq( 3708344779Sdim D->getType(), D->getTypeSourceInfo(), D->getInnerLocStart(), 3709344779Sdim D->getQualifierLoc())) 3710344779Sdim std::tie(ToType, ToTypeSourceInfo, ToInnerLocStart, ToQualifierLoc) = *Imp; 3711344779Sdim else 3712344779Sdim return Imp.takeError(); 3713276479Sdim 3714203955Srdivacky // Create the imported variable. 3715341825Sdim VarDecl *ToVar; 3716341825Sdim if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC, 3717344779Sdim ToInnerLocStart, Loc, 3718344779Sdim Name.getAsIdentifierInfo(), 3719344779Sdim ToType, ToTypeSourceInfo, 3720341825Sdim D->getStorageClass())) 3721341825Sdim return ToVar; 3722341825Sdim 3723344779Sdim ToVar->setQualifierInfo(ToQualifierLoc); 3724204643Srdivacky ToVar->setAccess(D->getAccess()); 3725203955Srdivacky ToVar->setLexicalDeclContext(LexicalDC); 3726203955Srdivacky 3727344779Sdim if (FoundByLookup) { 3728344779Sdim auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl()); 3729344779Sdim ToVar->setPreviousDecl(Recent); 3730344779Sdim } 3731288943Sdim 3732344779Sdim if (Error Err = ImportInitializer(D, ToVar)) 3733344779Sdim return std::move(Err); 3734203955Srdivacky 3735321369Sdim if (D->isConstexpr()) 3736321369Sdim ToVar->setConstexpr(true); 3737321369Sdim 3738344779Sdim if (D->getDeclContext()->containsDeclAndLoad(D)) 3739344779Sdim DC->addDeclInternal(ToVar); 3740344779Sdim if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D)) 3741344779Sdim LexicalDC->addDeclInternal(ToVar); 3742344779Sdim 3743344779Sdim // Import the rest of the chain. I.e. import all subsequent declarations. 3744344779Sdim for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) { 3745344779Sdim ExpectedDecl RedeclOrErr = import(*RedeclIt); 3746344779Sdim if (!RedeclOrErr) 3747344779Sdim return RedeclOrErr.takeError(); 3748344779Sdim } 3749344779Sdim 3750203955Srdivacky return ToVar; 3751203955Srdivacky} 3752203955Srdivacky 3753344779SdimExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 3754204643Srdivacky // Parameters are created in the translation unit's context, then moved 3755204643Srdivacky // into the function declaration's context afterward. 3756204643Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3757341825Sdim 3758344779Sdim DeclarationName ToDeclName; 3759344779Sdim SourceLocation ToLocation; 3760344779Sdim QualType ToType; 3761344779Sdim if (auto Imp = importSeq(D->getDeclName(), D->getLocation(), D->getType())) 3762344779Sdim std::tie(ToDeclName, ToLocation, ToType) = *Imp; 3763344779Sdim else 3764344779Sdim return Imp.takeError(); 3765276479Sdim 3766204643Srdivacky // Create the imported parameter. 3767341825Sdim ImplicitParamDecl *ToParm = nullptr; 3768344779Sdim if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, 3769344779Sdim ToLocation, ToDeclName.getAsIdentifierInfo(), 3770344779Sdim ToType, D->getParameterKind())) 3771341825Sdim return ToParm; 3772341825Sdim return ToParm; 3773204643Srdivacky} 3774204643Srdivacky 3775344779SdimExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 3776203955Srdivacky // Parameters are created in the translation unit's context, then moved 3777203955Srdivacky // into the function declaration's context afterward. 3778203955Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3779341825Sdim 3780344779Sdim DeclarationName ToDeclName; 3781344779Sdim SourceLocation ToLocation, ToInnerLocStart; 3782344779Sdim QualType ToType; 3783344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3784344779Sdim if (auto Imp = importSeq( 3785344779Sdim D->getDeclName(), D->getLocation(), D->getType(), D->getInnerLocStart(), 3786344779Sdim D->getTypeSourceInfo())) 3787344779Sdim std::tie( 3788344779Sdim ToDeclName, ToLocation, ToType, ToInnerLocStart, 3789344779Sdim ToTypeSourceInfo) = *Imp; 3790344779Sdim else 3791344779Sdim return Imp.takeError(); 3792276479Sdim 3793341825Sdim ParmVarDecl *ToParm; 3794341825Sdim if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, 3795344779Sdim ToInnerLocStart, ToLocation, 3796344779Sdim ToDeclName.getAsIdentifierInfo(), ToType, 3797344779Sdim ToTypeSourceInfo, D->getStorageClass(), 3798341825Sdim /*DefaultArg*/ nullptr)) 3799341825Sdim return ToParm; 3800321369Sdim 3801321369Sdim // Set the default argument. 3802205219Srdivacky ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg()); 3803321369Sdim ToParm->setKNRPromoted(D->isKNRPromoted()); 3804288943Sdim 3805321369Sdim if (D->hasUninstantiatedDefaultArg()) { 3806344779Sdim if (auto ToDefArgOrErr = import(D->getUninstantiatedDefaultArg())) 3807344779Sdim ToParm->setUninstantiatedDefaultArg(*ToDefArgOrErr); 3808344779Sdim else 3809344779Sdim return ToDefArgOrErr.takeError(); 3810321369Sdim } else if (D->hasUnparsedDefaultArg()) { 3811321369Sdim ToParm->setUnparsedDefaultArg(); 3812321369Sdim } else if (D->hasDefaultArg()) { 3813344779Sdim if (auto ToDefArgOrErr = import(D->getDefaultArg())) 3814344779Sdim ToParm->setDefaultArg(*ToDefArgOrErr); 3815344779Sdim else 3816344779Sdim return ToDefArgOrErr.takeError(); 3817321369Sdim } 3818321369Sdim 3819341825Sdim if (D->isObjCMethodParameter()) { 3820341825Sdim ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex()); 3821341825Sdim ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier()); 3822341825Sdim } else { 3823341825Sdim ToParm->setScopeInfo(D->getFunctionScopeDepth(), 3824341825Sdim D->getFunctionScopeIndex()); 3825341825Sdim } 3826288943Sdim 3827341825Sdim return ToParm; 3828203955Srdivacky} 3829203955Srdivacky 3830344779SdimExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 3831204643Srdivacky // Import the major distinguishing characteristics of a method. 3832204643Srdivacky DeclContext *DC, *LexicalDC; 3833204643Srdivacky DeclarationName Name; 3834204643Srdivacky SourceLocation Loc; 3835288943Sdim NamedDecl *ToD; 3836344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3837344779Sdim return std::move(Err); 3838288943Sdim if (ToD) 3839288943Sdim return ToD; 3840276479Sdim 3841344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3842341825Sdim for (auto *FoundDecl : FoundDecls) { 3843341825Sdim if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) { 3844204643Srdivacky if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 3845204643Srdivacky continue; 3846204643Srdivacky 3847204643Srdivacky // Check return types. 3848276479Sdim if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 3849276479Sdim FoundMethod->getReturnType())) { 3850353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent) 3851276479Sdim << D->isInstanceMethod() << Name << D->getReturnType() 3852276479Sdim << FoundMethod->getReturnType(); 3853341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 3854204643Srdivacky diag::note_odr_objc_method_here) 3855204643Srdivacky << D->isInstanceMethod() << Name; 3856344779Sdim 3857344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3858204643Srdivacky } 3859204643Srdivacky 3860204643Srdivacky // Check the number of parameters. 3861204643Srdivacky if (D->param_size() != FoundMethod->param_size()) { 3862353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent) 3863204643Srdivacky << D->isInstanceMethod() << Name 3864204643Srdivacky << D->param_size() << FoundMethod->param_size(); 3865341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 3866204643Srdivacky diag::note_odr_objc_method_here) 3867204643Srdivacky << D->isInstanceMethod() << Name; 3868344779Sdim 3869344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3870204643Srdivacky } 3871204643Srdivacky 3872204643Srdivacky // Check parameter types. 3873321369Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 3874204643Srdivacky PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 3875204643Srdivacky P != PEnd; ++P, ++FoundP) { 3876321369Sdim if (!Importer.IsStructurallyEquivalent((*P)->getType(), 3877204643Srdivacky (*FoundP)->getType())) { 3878321369Sdim Importer.FromDiag((*P)->getLocation(), 3879353358Sdim diag::warn_odr_objc_method_param_type_inconsistent) 3880204643Srdivacky << D->isInstanceMethod() << Name 3881204643Srdivacky << (*P)->getType() << (*FoundP)->getType(); 3882204643Srdivacky Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 3883204643Srdivacky << (*FoundP)->getType(); 3884344779Sdim 3885344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3886204643Srdivacky } 3887204643Srdivacky } 3888204643Srdivacky 3889204643Srdivacky // Check variadic/non-variadic. 3890204643Srdivacky // Check the number of parameters. 3891204643Srdivacky if (D->isVariadic() != FoundMethod->isVariadic()) { 3892353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent) 3893204643Srdivacky << D->isInstanceMethod() << Name; 3894341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 3895204643Srdivacky diag::note_odr_objc_method_here) 3896204643Srdivacky << D->isInstanceMethod() << Name; 3897344779Sdim 3898344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3899204643Srdivacky } 3900204643Srdivacky 3901204643Srdivacky // FIXME: Any other bits we need to merge? 3902341825Sdim return Importer.MapImported(D, FoundMethod); 3903204643Srdivacky } 3904204643Srdivacky } 3905204643Srdivacky 3906344779Sdim SourceLocation ToEndLoc; 3907344779Sdim QualType ToReturnType; 3908344779Sdim TypeSourceInfo *ToReturnTypeSourceInfo; 3909344779Sdim if (auto Imp = importSeq( 3910344779Sdim D->getEndLoc(), D->getReturnType(), D->getReturnTypeSourceInfo())) 3911344779Sdim std::tie(ToEndLoc, ToReturnType, ToReturnTypeSourceInfo) = *Imp; 3912344779Sdim else 3913344779Sdim return Imp.takeError(); 3914204643Srdivacky 3915341825Sdim ObjCMethodDecl *ToMethod; 3916341825Sdim if (GetImportedOrCreateDecl( 3917341825Sdim ToMethod, D, Importer.getToContext(), Loc, 3918344779Sdim ToEndLoc, Name.getObjCSelector(), ToReturnType, 3919344779Sdim ToReturnTypeSourceInfo, DC, D->isInstanceMethod(), D->isVariadic(), 3920341825Sdim D->isPropertyAccessor(), D->isImplicit(), D->isDefined(), 3921341825Sdim D->getImplementationControl(), D->hasRelatedResultType())) 3922341825Sdim return ToMethod; 3923204643Srdivacky 3924204643Srdivacky // FIXME: When we decide to merge method definitions, we'll need to 3925204643Srdivacky // deal with implicit parameters. 3926204643Srdivacky 3927204643Srdivacky // Import the parameters 3928226633Sdim SmallVector<ParmVarDecl *, 5> ToParams; 3929309124Sdim for (auto *FromP : D->parameters()) { 3930344779Sdim if (Expected<ParmVarDecl *> ToPOrErr = import(FromP)) 3931344779Sdim ToParams.push_back(*ToPOrErr); 3932344779Sdim else 3933344779Sdim return ToPOrErr.takeError(); 3934204643Srdivacky } 3935341825Sdim 3936204643Srdivacky // Set the parameters. 3937341825Sdim for (auto *ToParam : ToParams) { 3938341825Sdim ToParam->setOwningFunction(ToMethod); 3939341825Sdim ToMethod->addDeclInternal(ToParam); 3940204643Srdivacky } 3941341825Sdim 3942344779Sdim SmallVector<SourceLocation, 12> FromSelLocs; 3943344779Sdim D->getSelectorLocs(FromSelLocs); 3944344779Sdim SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size()); 3945344779Sdim if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs)) 3946344779Sdim return std::move(Err); 3947204643Srdivacky 3948344779Sdim ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs); 3949341825Sdim 3950204643Srdivacky ToMethod->setLexicalDeclContext(LexicalDC); 3951234353Sdim LexicalDC->addDeclInternal(ToMethod); 3952204643Srdivacky return ToMethod; 3953204643Srdivacky} 3954204643Srdivacky 3955344779SdimExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 3956288943Sdim // Import the major distinguishing characteristics of a category. 3957288943Sdim DeclContext *DC, *LexicalDC; 3958288943Sdim DeclarationName Name; 3959288943Sdim SourceLocation Loc; 3960288943Sdim NamedDecl *ToD; 3961344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3962344779Sdim return std::move(Err); 3963288943Sdim if (ToD) 3964288943Sdim return ToD; 3965288943Sdim 3966344779Sdim SourceLocation ToVarianceLoc, ToLocation, ToColonLoc; 3967344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3968344779Sdim if (auto Imp = importSeq( 3969344779Sdim D->getVarianceLoc(), D->getLocation(), D->getColonLoc(), 3970344779Sdim D->getTypeSourceInfo())) 3971344779Sdim std::tie(ToVarianceLoc, ToLocation, ToColonLoc, ToTypeSourceInfo) = *Imp; 3972344779Sdim else 3973344779Sdim return Imp.takeError(); 3974288943Sdim 3975341825Sdim ObjCTypeParamDecl *Result; 3976341825Sdim if (GetImportedOrCreateDecl( 3977341825Sdim Result, D, Importer.getToContext(), DC, D->getVariance(), 3978344779Sdim ToVarianceLoc, D->getIndex(), 3979344779Sdim ToLocation, Name.getAsIdentifierInfo(), 3980344779Sdim ToColonLoc, ToTypeSourceInfo)) 3981341825Sdim return Result; 3982341825Sdim 3983288943Sdim Result->setLexicalDeclContext(LexicalDC); 3984288943Sdim return Result; 3985288943Sdim} 3986288943Sdim 3987344779SdimExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 3988204643Srdivacky // Import the major distinguishing characteristics of a category. 3989204643Srdivacky DeclContext *DC, *LexicalDC; 3990204643Srdivacky DeclarationName Name; 3991204643Srdivacky SourceLocation Loc; 3992288943Sdim NamedDecl *ToD; 3993344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3994344779Sdim return std::move(Err); 3995288943Sdim if (ToD) 3996288943Sdim return ToD; 3997276479Sdim 3998344779Sdim ObjCInterfaceDecl *ToInterface; 3999344779Sdim if (Error Err = importInto(ToInterface, D->getClassInterface())) 4000344779Sdim return std::move(Err); 4001276479Sdim 4002204643Srdivacky // Determine if we've already encountered this category. 4003204643Srdivacky ObjCCategoryDecl *MergeWithCategory 4004204643Srdivacky = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 4005204643Srdivacky ObjCCategoryDecl *ToCategory = MergeWithCategory; 4006204643Srdivacky if (!ToCategory) { 4007344779Sdim SourceLocation ToAtStartLoc, ToCategoryNameLoc; 4008344779Sdim SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc; 4009344779Sdim if (auto Imp = importSeq( 4010344779Sdim D->getAtStartLoc(), D->getCategoryNameLoc(), 4011344779Sdim D->getIvarLBraceLoc(), D->getIvarRBraceLoc())) 4012344779Sdim std::tie( 4013344779Sdim ToAtStartLoc, ToCategoryNameLoc, 4014344779Sdim ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp; 4015344779Sdim else 4016344779Sdim return Imp.takeError(); 4017341825Sdim 4018341825Sdim if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC, 4019344779Sdim ToAtStartLoc, Loc, 4020344779Sdim ToCategoryNameLoc, 4021341825Sdim Name.getAsIdentifierInfo(), ToInterface, 4022341825Sdim /*TypeParamList=*/nullptr, 4023344779Sdim ToIvarLBraceLoc, 4024344779Sdim ToIvarRBraceLoc)) 4025341825Sdim return ToCategory; 4026341825Sdim 4027204643Srdivacky ToCategory->setLexicalDeclContext(LexicalDC); 4028234353Sdim LexicalDC->addDeclInternal(ToCategory); 4029344779Sdim // Import the type parameter list after MapImported, to avoid 4030288943Sdim // loops when bringing in their DeclContext. 4031344779Sdim if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList())) 4032344779Sdim ToCategory->setTypeParamList(*PListOrErr); 4033344779Sdim else 4034344779Sdim return PListOrErr.takeError(); 4035341825Sdim 4036204643Srdivacky // Import protocols 4037226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4038226633Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4039204643Srdivacky ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 4040204643Srdivacky = D->protocol_loc_begin(); 4041204643Srdivacky for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 4042204643Srdivacky FromProtoEnd = D->protocol_end(); 4043204643Srdivacky FromProto != FromProtoEnd; 4044204643Srdivacky ++FromProto, ++FromProtoLoc) { 4045344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4046344779Sdim Protocols.push_back(*ToProtoOrErr); 4047344779Sdim else 4048344779Sdim return ToProtoOrErr.takeError(); 4049344779Sdim 4050344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4051344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4052344779Sdim else 4053344779Sdim return ToProtoLocOrErr.takeError(); 4054204643Srdivacky } 4055341825Sdim 4056204643Srdivacky // FIXME: If we're merging, make sure that the protocol list is the same. 4057204643Srdivacky ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 4058204643Srdivacky ProtocolLocs.data(), Importer.getToContext()); 4059344779Sdim 4060204643Srdivacky } else { 4061341825Sdim Importer.MapImported(D, ToCategory); 4062204643Srdivacky } 4063341825Sdim 4064204643Srdivacky // Import all of the members of this category. 4065344779Sdim if (Error Err = ImportDeclContext(D)) 4066344779Sdim return std::move(Err); 4067341825Sdim 4068204643Srdivacky // If we have an implementation, import it as well. 4069204643Srdivacky if (D->getImplementation()) { 4070344779Sdim if (Expected<ObjCCategoryImplDecl *> ToImplOrErr = 4071344779Sdim import(D->getImplementation())) 4072344779Sdim ToCategory->setImplementation(*ToImplOrErr); 4073344779Sdim else 4074344779Sdim return ToImplOrErr.takeError(); 4075204643Srdivacky } 4076341825Sdim 4077204643Srdivacky return ToCategory; 4078204643Srdivacky} 4079204643Srdivacky 4080344779SdimError ASTNodeImporter::ImportDefinition( 4081344779Sdim ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) { 4082234353Sdim if (To->getDefinition()) { 4083234353Sdim if (shouldForceImportDeclContext(Kind)) 4084344779Sdim if (Error Err = ImportDeclContext(From)) 4085344779Sdim return Err; 4086344779Sdim return Error::success(); 4087234353Sdim } 4088234353Sdim 4089234353Sdim // Start the protocol definition 4090234353Sdim To->startDefinition(); 4091341825Sdim 4092234353Sdim // Import protocols 4093234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4094234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4095344779Sdim ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc = 4096344779Sdim From->protocol_loc_begin(); 4097234353Sdim for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 4098234353Sdim FromProtoEnd = From->protocol_end(); 4099234353Sdim FromProto != FromProtoEnd; 4100234353Sdim ++FromProto, ++FromProtoLoc) { 4101344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4102344779Sdim Protocols.push_back(*ToProtoOrErr); 4103344779Sdim else 4104344779Sdim return ToProtoOrErr.takeError(); 4105344779Sdim 4106344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4107344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4108344779Sdim else 4109344779Sdim return ToProtoLocOrErr.takeError(); 4110344779Sdim 4111234353Sdim } 4112341825Sdim 4113234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 4114234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 4115234353Sdim ProtocolLocs.data(), Importer.getToContext()); 4116234353Sdim 4117234353Sdim if (shouldForceImportDeclContext(Kind)) { 4118234353Sdim // Import all of the members of this protocol. 4119344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 4120344779Sdim return Err; 4121234353Sdim } 4122344779Sdim return Error::success(); 4123234353Sdim} 4124234353Sdim 4125344779SdimExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 4126341825Sdim // If this protocol has a definition in the translation unit we're coming 4127234353Sdim // from, but this particular declaration is not that definition, import the 4128234353Sdim // definition and map to that. 4129234353Sdim ObjCProtocolDecl *Definition = D->getDefinition(); 4130234353Sdim if (Definition && Definition != D) { 4131344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 4132344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 4133344779Sdim else 4134344779Sdim return ImportedDefOrErr.takeError(); 4135234353Sdim } 4136234353Sdim 4137204643Srdivacky // Import the major distinguishing characteristics of a protocol. 4138204643Srdivacky DeclContext *DC, *LexicalDC; 4139204643Srdivacky DeclarationName Name; 4140204643Srdivacky SourceLocation Loc; 4141288943Sdim NamedDecl *ToD; 4142344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4143344779Sdim return std::move(Err); 4144288943Sdim if (ToD) 4145288943Sdim return ToD; 4146204643Srdivacky 4147276479Sdim ObjCProtocolDecl *MergeWithProtocol = nullptr; 4148344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4149341825Sdim for (auto *FoundDecl : FoundDecls) { 4150341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 4151204643Srdivacky continue; 4152341825Sdim 4153341825Sdim if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl))) 4154204643Srdivacky break; 4155204643Srdivacky } 4156341825Sdim 4157204643Srdivacky ObjCProtocolDecl *ToProto = MergeWithProtocol; 4158234353Sdim if (!ToProto) { 4159344779Sdim auto ToAtBeginLocOrErr = import(D->getAtStartLoc()); 4160344779Sdim if (!ToAtBeginLocOrErr) 4161344779Sdim return ToAtBeginLocOrErr.takeError(); 4162344779Sdim 4163341825Sdim if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC, 4164341825Sdim Name.getAsIdentifierInfo(), Loc, 4165344779Sdim *ToAtBeginLocOrErr, 4166341825Sdim /*PrevDecl=*/nullptr)) 4167341825Sdim return ToProto; 4168234353Sdim ToProto->setLexicalDeclContext(LexicalDC); 4169234353Sdim LexicalDC->addDeclInternal(ToProto); 4170234353Sdim } 4171234353Sdim 4172341825Sdim Importer.MapImported(D, ToProto); 4173341825Sdim 4174344779Sdim if (D->isThisDeclarationADefinition()) 4175344779Sdim if (Error Err = ImportDefinition(D, ToProto)) 4176344779Sdim return std::move(Err); 4177276479Sdim 4178234353Sdim return ToProto; 4179234353Sdim} 4180234353Sdim 4181344779SdimExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 4182344779Sdim DeclContext *DC, *LexicalDC; 4183344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4184344779Sdim return std::move(Err); 4185280031Sdim 4186344779Sdim ExpectedSLoc ExternLocOrErr = import(D->getExternLoc()); 4187344779Sdim if (!ExternLocOrErr) 4188344779Sdim return ExternLocOrErr.takeError(); 4189280031Sdim 4190344779Sdim ExpectedSLoc LangLocOrErr = import(D->getLocation()); 4191344779Sdim if (!LangLocOrErr) 4192344779Sdim return LangLocOrErr.takeError(); 4193344779Sdim 4194280031Sdim bool HasBraces = D->hasBraces(); 4195280031Sdim 4196341825Sdim LinkageSpecDecl *ToLinkageSpec; 4197341825Sdim if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC, 4198344779Sdim *ExternLocOrErr, *LangLocOrErr, 4199344779Sdim D->getLanguage(), HasBraces)) 4200341825Sdim return ToLinkageSpec; 4201341825Sdim 4202280031Sdim if (HasBraces) { 4203344779Sdim ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc()); 4204344779Sdim if (!RBraceLocOrErr) 4205344779Sdim return RBraceLocOrErr.takeError(); 4206344779Sdim ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr); 4207280031Sdim } 4208280031Sdim 4209280031Sdim ToLinkageSpec->setLexicalDeclContext(LexicalDC); 4210280031Sdim LexicalDC->addDeclInternal(ToLinkageSpec); 4211280031Sdim 4212280031Sdim return ToLinkageSpec; 4213280031Sdim} 4214280031Sdim 4215344779SdimExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) { 4216327952Sdim DeclContext *DC, *LexicalDC; 4217327952Sdim DeclarationName Name; 4218327952Sdim SourceLocation Loc; 4219327952Sdim NamedDecl *ToD = nullptr; 4220344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4221344779Sdim return std::move(Err); 4222327952Sdim if (ToD) 4223327952Sdim return ToD; 4224327952Sdim 4225344779Sdim SourceLocation ToLoc, ToUsingLoc; 4226344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4227344779Sdim if (auto Imp = importSeq( 4228344779Sdim D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc())) 4229344779Sdim std::tie(ToLoc, ToUsingLoc, ToQualifierLoc) = *Imp; 4230344779Sdim else 4231344779Sdim return Imp.takeError(); 4232327952Sdim 4233344779Sdim DeclarationNameInfo NameInfo(Name, ToLoc); 4234344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 4235344779Sdim return std::move(Err); 4236344779Sdim 4237341825Sdim UsingDecl *ToUsing; 4238341825Sdim if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC, 4239344779Sdim ToUsingLoc, ToQualifierLoc, NameInfo, 4240341825Sdim D->hasTypename())) 4241341825Sdim return ToUsing; 4242341825Sdim 4243327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 4244327952Sdim LexicalDC->addDeclInternal(ToUsing); 4245327952Sdim 4246327952Sdim if (NamedDecl *FromPattern = 4247327952Sdim Importer.getFromContext().getInstantiatedFromUsingDecl(D)) { 4248344779Sdim if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern)) 4249344779Sdim Importer.getToContext().setInstantiatedFromUsingDecl( 4250344779Sdim ToUsing, *ToPatternOrErr); 4251327952Sdim else 4252344779Sdim return ToPatternOrErr.takeError(); 4253327952Sdim } 4254327952Sdim 4255344779Sdim for (UsingShadowDecl *FromShadow : D->shadows()) { 4256344779Sdim if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow)) 4257344779Sdim ToUsing->addShadowDecl(*ToShadowOrErr); 4258327952Sdim else 4259344779Sdim // FIXME: We return error here but the definition is already created 4260327952Sdim // and available with lookups. How to fix this?.. 4261344779Sdim return ToShadowOrErr.takeError(); 4262327952Sdim } 4263327952Sdim return ToUsing; 4264327952Sdim} 4265327952Sdim 4266344779SdimExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) { 4267327952Sdim DeclContext *DC, *LexicalDC; 4268327952Sdim DeclarationName Name; 4269327952Sdim SourceLocation Loc; 4270327952Sdim NamedDecl *ToD = nullptr; 4271344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4272344779Sdim return std::move(Err); 4273327952Sdim if (ToD) 4274327952Sdim return ToD; 4275327952Sdim 4276344779Sdim Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl()); 4277344779Sdim if (!ToUsingOrErr) 4278344779Sdim return ToUsingOrErr.takeError(); 4279327952Sdim 4280344779Sdim Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl()); 4281344779Sdim if (!ToTargetOrErr) 4282344779Sdim return ToTargetOrErr.takeError(); 4283327952Sdim 4284341825Sdim UsingShadowDecl *ToShadow; 4285341825Sdim if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc, 4286344779Sdim *ToUsingOrErr, *ToTargetOrErr)) 4287341825Sdim return ToShadow; 4288327952Sdim 4289327952Sdim ToShadow->setLexicalDeclContext(LexicalDC); 4290327952Sdim ToShadow->setAccess(D->getAccess()); 4291327952Sdim 4292327952Sdim if (UsingShadowDecl *FromPattern = 4293327952Sdim Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) { 4294344779Sdim if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern)) 4295344779Sdim Importer.getToContext().setInstantiatedFromUsingShadowDecl( 4296344779Sdim ToShadow, *ToPatternOrErr); 4297327952Sdim else 4298344779Sdim // FIXME: We return error here but the definition is already created 4299327952Sdim // and available with lookups. How to fix this?.. 4300344779Sdim return ToPatternOrErr.takeError(); 4301327952Sdim } 4302327952Sdim 4303327952Sdim LexicalDC->addDeclInternal(ToShadow); 4304327952Sdim 4305327952Sdim return ToShadow; 4306327952Sdim} 4307327952Sdim 4308344779SdimExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 4309327952Sdim DeclContext *DC, *LexicalDC; 4310327952Sdim DeclarationName Name; 4311327952Sdim SourceLocation Loc; 4312327952Sdim NamedDecl *ToD = nullptr; 4313344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4314344779Sdim return std::move(Err); 4315327952Sdim if (ToD) 4316327952Sdim return ToD; 4317327952Sdim 4318344779Sdim auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor()); 4319344779Sdim if (!ToComAncestorOrErr) 4320344779Sdim return ToComAncestorOrErr.takeError(); 4321327952Sdim 4322344779Sdim NamespaceDecl *ToNominatedNamespace; 4323344779Sdim SourceLocation ToUsingLoc, ToNamespaceKeyLocation, ToIdentLocation; 4324344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4325344779Sdim if (auto Imp = importSeq( 4326344779Sdim D->getNominatedNamespace(), D->getUsingLoc(), 4327344779Sdim D->getNamespaceKeyLocation(), D->getQualifierLoc(), 4328344779Sdim D->getIdentLocation())) 4329344779Sdim std::tie( 4330344779Sdim ToNominatedNamespace, ToUsingLoc, ToNamespaceKeyLocation, 4331344779Sdim ToQualifierLoc, ToIdentLocation) = *Imp; 4332344779Sdim else 4333344779Sdim return Imp.takeError(); 4334327952Sdim 4335341825Sdim UsingDirectiveDecl *ToUsingDir; 4336341825Sdim if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC, 4337344779Sdim ToUsingLoc, 4338344779Sdim ToNamespaceKeyLocation, 4339344779Sdim ToQualifierLoc, 4340344779Sdim ToIdentLocation, 4341344779Sdim ToNominatedNamespace, *ToComAncestorOrErr)) 4342341825Sdim return ToUsingDir; 4343341825Sdim 4344327952Sdim ToUsingDir->setLexicalDeclContext(LexicalDC); 4345327952Sdim LexicalDC->addDeclInternal(ToUsingDir); 4346327952Sdim 4347327952Sdim return ToUsingDir; 4348327952Sdim} 4349327952Sdim 4350344779SdimExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl( 4351327952Sdim UnresolvedUsingValueDecl *D) { 4352327952Sdim DeclContext *DC, *LexicalDC; 4353327952Sdim DeclarationName Name; 4354327952Sdim SourceLocation Loc; 4355327952Sdim NamedDecl *ToD = nullptr; 4356344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4357344779Sdim return std::move(Err); 4358327952Sdim if (ToD) 4359327952Sdim return ToD; 4360327952Sdim 4361344779Sdim SourceLocation ToLoc, ToUsingLoc, ToEllipsisLoc; 4362344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4363344779Sdim if (auto Imp = importSeq( 4364344779Sdim D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc(), 4365344779Sdim D->getEllipsisLoc())) 4366344779Sdim std::tie(ToLoc, ToUsingLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp; 4367344779Sdim else 4368344779Sdim return Imp.takeError(); 4369327952Sdim 4370344779Sdim DeclarationNameInfo NameInfo(Name, ToLoc); 4371344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 4372344779Sdim return std::move(Err); 4373344779Sdim 4374341825Sdim UnresolvedUsingValueDecl *ToUsingValue; 4375341825Sdim if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC, 4376344779Sdim ToUsingLoc, ToQualifierLoc, NameInfo, 4377344779Sdim ToEllipsisLoc)) 4378341825Sdim return ToUsingValue; 4379327952Sdim 4380327952Sdim ToUsingValue->setAccess(D->getAccess()); 4381327952Sdim ToUsingValue->setLexicalDeclContext(LexicalDC); 4382327952Sdim LexicalDC->addDeclInternal(ToUsingValue); 4383327952Sdim 4384327952Sdim return ToUsingValue; 4385327952Sdim} 4386327952Sdim 4387344779SdimExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl( 4388327952Sdim UnresolvedUsingTypenameDecl *D) { 4389327952Sdim DeclContext *DC, *LexicalDC; 4390327952Sdim DeclarationName Name; 4391327952Sdim SourceLocation Loc; 4392327952Sdim NamedDecl *ToD = nullptr; 4393344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4394344779Sdim return std::move(Err); 4395327952Sdim if (ToD) 4396327952Sdim return ToD; 4397327952Sdim 4398344779Sdim SourceLocation ToUsingLoc, ToTypenameLoc, ToEllipsisLoc; 4399344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4400344779Sdim if (auto Imp = importSeq( 4401344779Sdim D->getUsingLoc(), D->getTypenameLoc(), D->getQualifierLoc(), 4402344779Sdim D->getEllipsisLoc())) 4403344779Sdim std::tie(ToUsingLoc, ToTypenameLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp; 4404344779Sdim else 4405344779Sdim return Imp.takeError(); 4406344779Sdim 4407341825Sdim UnresolvedUsingTypenameDecl *ToUsing; 4408341825Sdim if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC, 4409344779Sdim ToUsingLoc, ToTypenameLoc, 4410344779Sdim ToQualifierLoc, Loc, Name, ToEllipsisLoc)) 4411341825Sdim return ToUsing; 4412327952Sdim 4413327952Sdim ToUsing->setAccess(D->getAccess()); 4414327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 4415327952Sdim LexicalDC->addDeclInternal(ToUsing); 4416327952Sdim 4417327952Sdim return ToUsing; 4418327952Sdim} 4419327952Sdim 4420344779Sdim 4421344779SdimError ASTNodeImporter::ImportDefinition( 4422344779Sdim ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) { 4423234353Sdim if (To->getDefinition()) { 4424234353Sdim // Check consistency of superclass. 4425234353Sdim ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 4426234353Sdim if (FromSuper) { 4427344779Sdim if (auto FromSuperOrErr = import(FromSuper)) 4428344779Sdim FromSuper = *FromSuperOrErr; 4429344779Sdim else 4430344779Sdim return FromSuperOrErr.takeError(); 4431204643Srdivacky } 4432341825Sdim 4433341825Sdim ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 4434234353Sdim if ((bool)FromSuper != (bool)ToSuper || 4435234353Sdim (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 4436341825Sdim Importer.ToDiag(To->getLocation(), 4437353358Sdim diag::warn_odr_objc_superclass_inconsistent) 4438234353Sdim << To->getDeclName(); 4439234353Sdim if (ToSuper) 4440234353Sdim Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 4441234353Sdim << To->getSuperClass()->getDeclName(); 4442234353Sdim else 4443341825Sdim Importer.ToDiag(To->getLocation(), 4444234353Sdim diag::note_odr_objc_missing_superclass); 4445234353Sdim if (From->getSuperClass()) 4446341825Sdim Importer.FromDiag(From->getSuperClassLoc(), 4447234353Sdim diag::note_odr_objc_superclass) 4448234353Sdim << From->getSuperClass()->getDeclName(); 4449234353Sdim else 4450341825Sdim Importer.FromDiag(From->getLocation(), 4451341825Sdim diag::note_odr_objc_missing_superclass); 4452234353Sdim } 4453341825Sdim 4454234353Sdim if (shouldForceImportDeclContext(Kind)) 4455344779Sdim if (Error Err = ImportDeclContext(From)) 4456344779Sdim return Err; 4457344779Sdim return Error::success(); 4458234353Sdim } 4459341825Sdim 4460234353Sdim // Start the definition. 4461234353Sdim To->startDefinition(); 4462341825Sdim 4463234353Sdim // If this class has a superclass, import it. 4464234353Sdim if (From->getSuperClass()) { 4465344779Sdim if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo())) 4466344779Sdim To->setSuperClass(*SuperTInfoOrErr); 4467344779Sdim else 4468344779Sdim return SuperTInfoOrErr.takeError(); 4469234353Sdim } 4470341825Sdim 4471234353Sdim // Import protocols 4472234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4473234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4474344779Sdim ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc = 4475344779Sdim From->protocol_loc_begin(); 4476341825Sdim 4477234353Sdim for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 4478234353Sdim FromProtoEnd = From->protocol_end(); 4479204643Srdivacky FromProto != FromProtoEnd; 4480204643Srdivacky ++FromProto, ++FromProtoLoc) { 4481344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4482344779Sdim Protocols.push_back(*ToProtoOrErr); 4483344779Sdim else 4484344779Sdim return ToProtoOrErr.takeError(); 4485344779Sdim 4486344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4487344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4488344779Sdim else 4489344779Sdim return ToProtoLocOrErr.takeError(); 4490344779Sdim 4491234353Sdim } 4492341825Sdim 4493234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 4494234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 4495234353Sdim ProtocolLocs.data(), Importer.getToContext()); 4496341825Sdim 4497234353Sdim // Import categories. When the categories themselves are imported, they'll 4498234353Sdim // hook themselves into this interface. 4499344779Sdim for (auto *Cat : From->known_categories()) { 4500344779Sdim auto ToCatOrErr = import(Cat); 4501344779Sdim if (!ToCatOrErr) 4502344779Sdim return ToCatOrErr.takeError(); 4503344779Sdim } 4504341825Sdim 4505234353Sdim // If we have an @implementation, import it as well. 4506234353Sdim if (From->getImplementation()) { 4507344779Sdim if (Expected<ObjCImplementationDecl *> ToImplOrErr = 4508344779Sdim import(From->getImplementation())) 4509344779Sdim To->setImplementation(*ToImplOrErr); 4510344779Sdim else 4511344779Sdim return ToImplOrErr.takeError(); 4512204643Srdivacky } 4513204643Srdivacky 4514234353Sdim if (shouldForceImportDeclContext(Kind)) { 4515234353Sdim // Import all of the members of this class. 4516344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 4517344779Sdim return Err; 4518234353Sdim } 4519344779Sdim return Error::success(); 4520204643Srdivacky} 4521204643Srdivacky 4522344779SdimExpected<ObjCTypeParamList *> 4523288943SdimASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 4524288943Sdim if (!list) 4525288943Sdim return nullptr; 4526288943Sdim 4527288943Sdim SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 4528344779Sdim for (auto *fromTypeParam : *list) { 4529344779Sdim if (auto toTypeParamOrErr = import(fromTypeParam)) 4530344779Sdim toTypeParams.push_back(*toTypeParamOrErr); 4531344779Sdim else 4532344779Sdim return toTypeParamOrErr.takeError(); 4533288943Sdim } 4534288943Sdim 4535344779Sdim auto LAngleLocOrErr = import(list->getLAngleLoc()); 4536344779Sdim if (!LAngleLocOrErr) 4537344779Sdim return LAngleLocOrErr.takeError(); 4538344779Sdim 4539344779Sdim auto RAngleLocOrErr = import(list->getRAngleLoc()); 4540344779Sdim if (!RAngleLocOrErr) 4541344779Sdim return RAngleLocOrErr.takeError(); 4542344779Sdim 4543288943Sdim return ObjCTypeParamList::create(Importer.getToContext(), 4544344779Sdim *LAngleLocOrErr, 4545288943Sdim toTypeParams, 4546344779Sdim *RAngleLocOrErr); 4547288943Sdim} 4548288943Sdim 4549344779SdimExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 4550234353Sdim // If this class has a definition in the translation unit we're coming from, 4551234353Sdim // but this particular declaration is not that definition, import the 4552234353Sdim // definition and map to that. 4553234353Sdim ObjCInterfaceDecl *Definition = D->getDefinition(); 4554234353Sdim if (Definition && Definition != D) { 4555344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 4556344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 4557344779Sdim else 4558344779Sdim return ImportedDefOrErr.takeError(); 4559234353Sdim } 4560234353Sdim 4561203955Srdivacky // Import the major distinguishing characteristics of an @interface. 4562203955Srdivacky DeclContext *DC, *LexicalDC; 4563203955Srdivacky DeclarationName Name; 4564203955Srdivacky SourceLocation Loc; 4565288943Sdim NamedDecl *ToD; 4566344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4567344779Sdim return std::move(Err); 4568288943Sdim if (ToD) 4569288943Sdim return ToD; 4570203955Srdivacky 4571234353Sdim // Look for an existing interface with the same name. 4572276479Sdim ObjCInterfaceDecl *MergeWithIface = nullptr; 4573344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4574341825Sdim for (auto *FoundDecl : FoundDecls) { 4575341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4576203955Srdivacky continue; 4577341825Sdim 4578341825Sdim if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl))) 4579203955Srdivacky break; 4580203955Srdivacky } 4581341825Sdim 4582234353Sdim // Create an interface declaration, if one does not already exist. 4583203955Srdivacky ObjCInterfaceDecl *ToIface = MergeWithIface; 4584234353Sdim if (!ToIface) { 4585344779Sdim ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc()); 4586344779Sdim if (!AtBeginLocOrErr) 4587344779Sdim return AtBeginLocOrErr.takeError(); 4588344779Sdim 4589341825Sdim if (GetImportedOrCreateDecl( 4590341825Sdim ToIface, D, Importer.getToContext(), DC, 4591344779Sdim *AtBeginLocOrErr, Name.getAsIdentifierInfo(), 4592341825Sdim /*TypeParamList=*/nullptr, 4593341825Sdim /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl())) 4594341825Sdim return ToIface; 4595234353Sdim ToIface->setLexicalDeclContext(LexicalDC); 4596234353Sdim LexicalDC->addDeclInternal(ToIface); 4597203955Srdivacky } 4598341825Sdim Importer.MapImported(D, ToIface); 4599344779Sdim // Import the type parameter list after MapImported, to avoid 4600288943Sdim // loops when bringing in their DeclContext. 4601344779Sdim if (auto ToPListOrErr = 4602344779Sdim ImportObjCTypeParamList(D->getTypeParamListAsWritten())) 4603344779Sdim ToIface->setTypeParamList(*ToPListOrErr); 4604344779Sdim else 4605344779Sdim return ToPListOrErr.takeError(); 4606341825Sdim 4607344779Sdim if (D->isThisDeclarationADefinition()) 4608344779Sdim if (Error Err = ImportDefinition(D, ToIface)) 4609344779Sdim return std::move(Err); 4610276479Sdim 4611204643Srdivacky return ToIface; 4612203955Srdivacky} 4613203955Srdivacky 4614344779SdimExpectedDecl 4615344779SdimASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 4616344779Sdim ObjCCategoryDecl *Category; 4617344779Sdim if (Error Err = importInto(Category, D->getCategoryDecl())) 4618344779Sdim return std::move(Err); 4619276479Sdim 4620218893Sdim ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 4621218893Sdim if (!ToImpl) { 4622344779Sdim DeclContext *DC, *LexicalDC; 4623344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4624344779Sdim return std::move(Err); 4625276479Sdim 4626344779Sdim SourceLocation ToLocation, ToAtStartLoc, ToCategoryNameLoc; 4627344779Sdim if (auto Imp = importSeq( 4628344779Sdim D->getLocation(), D->getAtStartLoc(), D->getCategoryNameLoc())) 4629344779Sdim std::tie(ToLocation, ToAtStartLoc, ToCategoryNameLoc) = *Imp; 4630344779Sdim else 4631344779Sdim return Imp.takeError(); 4632344779Sdim 4633341825Sdim if (GetImportedOrCreateDecl( 4634341825Sdim ToImpl, D, Importer.getToContext(), DC, 4635341825Sdim Importer.Import(D->getIdentifier()), Category->getClassInterface(), 4636344779Sdim ToLocation, ToAtStartLoc, ToCategoryNameLoc)) 4637341825Sdim return ToImpl; 4638341825Sdim 4639344779Sdim ToImpl->setLexicalDeclContext(LexicalDC); 4640234353Sdim LexicalDC->addDeclInternal(ToImpl); 4641218893Sdim Category->setImplementation(ToImpl); 4642218893Sdim } 4643341825Sdim 4644341825Sdim Importer.MapImported(D, ToImpl); 4645344779Sdim if (Error Err = ImportDeclContext(D)) 4646344779Sdim return std::move(Err); 4647344779Sdim 4648218893Sdim return ToImpl; 4649218893Sdim} 4650218893Sdim 4651344779SdimExpectedDecl 4652344779SdimASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 4653218893Sdim // Find the corresponding interface. 4654344779Sdim ObjCInterfaceDecl *Iface; 4655344779Sdim if (Error Err = importInto(Iface, D->getClassInterface())) 4656344779Sdim return std::move(Err); 4657218893Sdim 4658218893Sdim // Import the superclass, if any. 4659344779Sdim ObjCInterfaceDecl *Super; 4660344779Sdim if (Error Err = importInto(Super, D->getSuperClass())) 4661344779Sdim return std::move(Err); 4662218893Sdim 4663218893Sdim ObjCImplementationDecl *Impl = Iface->getImplementation(); 4664218893Sdim if (!Impl) { 4665218893Sdim // We haven't imported an implementation yet. Create a new @implementation 4666218893Sdim // now. 4667344779Sdim DeclContext *DC, *LexicalDC; 4668344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4669344779Sdim return std::move(Err); 4670344779Sdim 4671344779Sdim SourceLocation ToLocation, ToAtStartLoc, ToSuperClassLoc; 4672344779Sdim SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc; 4673344779Sdim if (auto Imp = importSeq( 4674344779Sdim D->getLocation(), D->getAtStartLoc(), D->getSuperClassLoc(), 4675344779Sdim D->getIvarLBraceLoc(), D->getIvarRBraceLoc())) 4676344779Sdim std::tie( 4677344779Sdim ToLocation, ToAtStartLoc, ToSuperClassLoc, 4678344779Sdim ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp; 4679344779Sdim else 4680344779Sdim return Imp.takeError(); 4681344779Sdim 4682341825Sdim if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(), 4683344779Sdim DC, Iface, Super, 4684344779Sdim ToLocation, 4685344779Sdim ToAtStartLoc, 4686344779Sdim ToSuperClassLoc, 4687344779Sdim ToIvarLBraceLoc, 4688344779Sdim ToIvarRBraceLoc)) 4689341825Sdim return Impl; 4690341825Sdim 4691344779Sdim Impl->setLexicalDeclContext(LexicalDC); 4692341825Sdim 4693218893Sdim // Associate the implementation with the class it implements. 4694218893Sdim Iface->setImplementation(Impl); 4695341825Sdim Importer.MapImported(D, Iface->getImplementation()); 4696218893Sdim } else { 4697341825Sdim Importer.MapImported(D, Iface->getImplementation()); 4698218893Sdim 4699218893Sdim // Verify that the existing @implementation has the same superclass. 4700218893Sdim if ((Super && !Impl->getSuperClass()) || 4701218893Sdim (!Super && Impl->getSuperClass()) || 4702276479Sdim (Super && Impl->getSuperClass() && 4703276479Sdim !declaresSameEntity(Super->getCanonicalDecl(), 4704276479Sdim Impl->getSuperClass()))) { 4705276479Sdim Importer.ToDiag(Impl->getLocation(), 4706353358Sdim diag::warn_odr_objc_superclass_inconsistent) 4707276479Sdim << Iface->getDeclName(); 4708276479Sdim // FIXME: It would be nice to have the location of the superclass 4709276479Sdim // below. 4710276479Sdim if (Impl->getSuperClass()) 4711276479Sdim Importer.ToDiag(Impl->getLocation(), 4712276479Sdim diag::note_odr_objc_superclass) 4713276479Sdim << Impl->getSuperClass()->getDeclName(); 4714276479Sdim else 4715276479Sdim Importer.ToDiag(Impl->getLocation(), 4716276479Sdim diag::note_odr_objc_missing_superclass); 4717276479Sdim if (D->getSuperClass()) 4718276479Sdim Importer.FromDiag(D->getLocation(), 4719218893Sdim diag::note_odr_objc_superclass) 4720276479Sdim << D->getSuperClass()->getDeclName(); 4721276479Sdim else 4722276479Sdim Importer.FromDiag(D->getLocation(), 4723218893Sdim diag::note_odr_objc_missing_superclass); 4724344779Sdim 4725344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4726218893Sdim } 4727218893Sdim } 4728341825Sdim 4729218893Sdim // Import all of the members of this @implementation. 4730344779Sdim if (Error Err = ImportDeclContext(D)) 4731344779Sdim return std::move(Err); 4732218893Sdim 4733218893Sdim return Impl; 4734218893Sdim} 4735218893Sdim 4736344779SdimExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 4737204643Srdivacky // Import the major distinguishing characteristics of an @property. 4738204643Srdivacky DeclContext *DC, *LexicalDC; 4739204643Srdivacky DeclarationName Name; 4740204643Srdivacky SourceLocation Loc; 4741288943Sdim NamedDecl *ToD; 4742344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4743344779Sdim return std::move(Err); 4744288943Sdim if (ToD) 4745288943Sdim return ToD; 4746204643Srdivacky 4747204643Srdivacky // Check whether we have already imported this property. 4748344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4749341825Sdim for (auto *FoundDecl : FoundDecls) { 4750341825Sdim if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) { 4751204643Srdivacky // Check property types. 4752321369Sdim if (!Importer.IsStructurallyEquivalent(D->getType(), 4753204643Srdivacky FoundProp->getType())) { 4754353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent) 4755204643Srdivacky << Name << D->getType() << FoundProp->getType(); 4756204643Srdivacky Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 4757204643Srdivacky << FoundProp->getType(); 4758344779Sdim 4759344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4760204643Srdivacky } 4761204643Srdivacky 4762204643Srdivacky // FIXME: Check property attributes, getters, setters, etc.? 4763204643Srdivacky 4764204643Srdivacky // Consider these properties to be equivalent. 4765341825Sdim Importer.MapImported(D, FoundProp); 4766204643Srdivacky return FoundProp; 4767204643Srdivacky } 4768204643Srdivacky } 4769204643Srdivacky 4770344779Sdim QualType ToType; 4771344779Sdim TypeSourceInfo *ToTypeSourceInfo; 4772344779Sdim SourceLocation ToAtLoc, ToLParenLoc; 4773344779Sdim if (auto Imp = importSeq( 4774344779Sdim D->getType(), D->getTypeSourceInfo(), D->getAtLoc(), D->getLParenLoc())) 4775344779Sdim std::tie(ToType, ToTypeSourceInfo, ToAtLoc, ToLParenLoc) = *Imp; 4776344779Sdim else 4777344779Sdim return Imp.takeError(); 4778204643Srdivacky 4779204643Srdivacky // Create the new property. 4780341825Sdim ObjCPropertyDecl *ToProperty; 4781341825Sdim if (GetImportedOrCreateDecl( 4782341825Sdim ToProperty, D, Importer.getToContext(), DC, Loc, 4783344779Sdim Name.getAsIdentifierInfo(), ToAtLoc, 4784344779Sdim ToLParenLoc, ToType, 4785344779Sdim ToTypeSourceInfo, D->getPropertyImplementation())) 4786341825Sdim return ToProperty; 4787341825Sdim 4788344779Sdim Selector ToGetterName, ToSetterName; 4789344779Sdim SourceLocation ToGetterNameLoc, ToSetterNameLoc; 4790344779Sdim ObjCMethodDecl *ToGetterMethodDecl, *ToSetterMethodDecl; 4791344779Sdim ObjCIvarDecl *ToPropertyIvarDecl; 4792344779Sdim if (auto Imp = importSeq( 4793344779Sdim D->getGetterName(), D->getSetterName(), 4794344779Sdim D->getGetterNameLoc(), D->getSetterNameLoc(), 4795344779Sdim D->getGetterMethodDecl(), D->getSetterMethodDecl(), 4796344779Sdim D->getPropertyIvarDecl())) 4797344779Sdim std::tie( 4798344779Sdim ToGetterName, ToSetterName, 4799344779Sdim ToGetterNameLoc, ToSetterNameLoc, 4800344779Sdim ToGetterMethodDecl, ToSetterMethodDecl, 4801344779Sdim ToPropertyIvarDecl) = *Imp; 4802344779Sdim else 4803344779Sdim return Imp.takeError(); 4804344779Sdim 4805204643Srdivacky ToProperty->setLexicalDeclContext(LexicalDC); 4806234353Sdim LexicalDC->addDeclInternal(ToProperty); 4807204643Srdivacky 4808204643Srdivacky ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 4809210299Sed ToProperty->setPropertyAttributesAsWritten( 4810210299Sed D->getPropertyAttributesAsWritten()); 4811344779Sdim ToProperty->setGetterName(ToGetterName, ToGetterNameLoc); 4812344779Sdim ToProperty->setSetterName(ToSetterName, ToSetterNameLoc); 4813344779Sdim ToProperty->setGetterMethodDecl(ToGetterMethodDecl); 4814344779Sdim ToProperty->setSetterMethodDecl(ToSetterMethodDecl); 4815344779Sdim ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl); 4816204643Srdivacky return ToProperty; 4817204643Srdivacky} 4818204643Srdivacky 4819344779SdimExpectedDecl 4820344779SdimASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 4821344779Sdim ObjCPropertyDecl *Property; 4822344779Sdim if (Error Err = importInto(Property, D->getPropertyDecl())) 4823344779Sdim return std::move(Err); 4824218893Sdim 4825344779Sdim DeclContext *DC, *LexicalDC; 4826344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4827344779Sdim return std::move(Err); 4828276479Sdim 4829344779Sdim auto *InImpl = cast<ObjCImplDecl>(LexicalDC); 4830218893Sdim 4831218893Sdim // Import the ivar (for an @synthesize). 4832276479Sdim ObjCIvarDecl *Ivar = nullptr; 4833344779Sdim if (Error Err = importInto(Ivar, D->getPropertyIvarDecl())) 4834344779Sdim return std::move(Err); 4835218893Sdim 4836218893Sdim ObjCPropertyImplDecl *ToImpl 4837309124Sdim = InImpl->FindPropertyImplDecl(Property->getIdentifier(), 4838309124Sdim Property->getQueryKind()); 4839341825Sdim if (!ToImpl) { 4840344779Sdim SourceLocation ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc; 4841344779Sdim if (auto Imp = importSeq( 4842344779Sdim D->getBeginLoc(), D->getLocation(), D->getPropertyIvarDeclLoc())) 4843344779Sdim std::tie(ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc) = *Imp; 4844344779Sdim else 4845344779Sdim return Imp.takeError(); 4846344779Sdim 4847341825Sdim if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC, 4848344779Sdim ToBeginLoc, 4849344779Sdim ToLocation, Property, 4850341825Sdim D->getPropertyImplementation(), Ivar, 4851344779Sdim ToPropertyIvarDeclLoc)) 4852341825Sdim return ToImpl; 4853341825Sdim 4854218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 4855234353Sdim LexicalDC->addDeclInternal(ToImpl); 4856218893Sdim } else { 4857218893Sdim // Check that we have the same kind of property implementation (@synthesize 4858218893Sdim // vs. @dynamic). 4859218893Sdim if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 4860341825Sdim Importer.ToDiag(ToImpl->getLocation(), 4861353358Sdim diag::warn_odr_objc_property_impl_kind_inconsistent) 4862341825Sdim << Property->getDeclName() 4863341825Sdim << (ToImpl->getPropertyImplementation() 4864218893Sdim == ObjCPropertyImplDecl::Dynamic); 4865218893Sdim Importer.FromDiag(D->getLocation(), 4866218893Sdim diag::note_odr_objc_property_impl_kind) 4867218893Sdim << D->getPropertyDecl()->getDeclName() 4868218893Sdim << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 4869344779Sdim 4870344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4871218893Sdim } 4872341825Sdim 4873341825Sdim // For @synthesize, check that we have the same 4874218893Sdim if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 4875218893Sdim Ivar != ToImpl->getPropertyIvarDecl()) { 4876341825Sdim Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 4877353358Sdim diag::warn_odr_objc_synthesize_ivar_inconsistent) 4878218893Sdim << Property->getDeclName() 4879218893Sdim << ToImpl->getPropertyIvarDecl()->getDeclName() 4880218893Sdim << Ivar->getDeclName(); 4881341825Sdim Importer.FromDiag(D->getPropertyIvarDeclLoc(), 4882218893Sdim diag::note_odr_objc_synthesize_ivar_here) 4883218893Sdim << D->getPropertyIvarDecl()->getDeclName(); 4884344779Sdim 4885344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4886218893Sdim } 4887341825Sdim 4888218893Sdim // Merge the existing implementation with the new implementation. 4889341825Sdim Importer.MapImported(D, ToImpl); 4890218893Sdim } 4891341825Sdim 4892218893Sdim return ToImpl; 4893218893Sdim} 4894218893Sdim 4895344779SdimExpectedDecl 4896344779SdimASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 4897218893Sdim // For template arguments, we adopt the translation unit as our declaration 4898218893Sdim // context. This context will be fixed when the actual template declaration 4899218893Sdim // is created. 4900341825Sdim 4901218893Sdim // FIXME: Import default argument. 4902344779Sdim 4903344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 4904344779Sdim if (!BeginLocOrErr) 4905344779Sdim return BeginLocOrErr.takeError(); 4906344779Sdim 4907344779Sdim ExpectedSLoc LocationOrErr = import(D->getLocation()); 4908344779Sdim if (!LocationOrErr) 4909344779Sdim return LocationOrErr.takeError(); 4910344779Sdim 4911341825Sdim TemplateTypeParmDecl *ToD = nullptr; 4912341825Sdim (void)GetImportedOrCreateDecl( 4913341825Sdim ToD, D, Importer.getToContext(), 4914341825Sdim Importer.getToContext().getTranslationUnitDecl(), 4915344779Sdim *BeginLocOrErr, *LocationOrErr, 4916341825Sdim D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()), 4917341825Sdim D->wasDeclaredWithTypename(), D->isParameterPack()); 4918341825Sdim return ToD; 4919218893Sdim} 4920218893Sdim 4921344779SdimExpectedDecl 4922218893SdimASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 4923344779Sdim DeclarationName ToDeclName; 4924344779Sdim SourceLocation ToLocation, ToInnerLocStart; 4925344779Sdim QualType ToType; 4926344779Sdim TypeSourceInfo *ToTypeSourceInfo; 4927344779Sdim if (auto Imp = importSeq( 4928344779Sdim D->getDeclName(), D->getLocation(), D->getType(), D->getTypeSourceInfo(), 4929344779Sdim D->getInnerLocStart())) 4930344779Sdim std::tie( 4931344779Sdim ToDeclName, ToLocation, ToType, ToTypeSourceInfo, 4932344779Sdim ToInnerLocStart) = *Imp; 4933344779Sdim else 4934344779Sdim return Imp.takeError(); 4935276479Sdim 4936218893Sdim // FIXME: Import default argument. 4937341825Sdim 4938341825Sdim NonTypeTemplateParmDecl *ToD = nullptr; 4939341825Sdim (void)GetImportedOrCreateDecl( 4940341825Sdim ToD, D, Importer.getToContext(), 4941341825Sdim Importer.getToContext().getTranslationUnitDecl(), 4942344779Sdim ToInnerLocStart, ToLocation, D->getDepth(), 4943344779Sdim D->getPosition(), ToDeclName.getAsIdentifierInfo(), ToType, 4944344779Sdim D->isParameterPack(), ToTypeSourceInfo); 4945341825Sdim return ToD; 4946218893Sdim} 4947218893Sdim 4948344779SdimExpectedDecl 4949218893SdimASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 4950218893Sdim // Import the name of this declaration. 4951344779Sdim auto NameOrErr = import(D->getDeclName()); 4952344779Sdim if (!NameOrErr) 4953344779Sdim return NameOrErr.takeError(); 4954276479Sdim 4955218893Sdim // Import the location of this declaration. 4956344779Sdim ExpectedSLoc LocationOrErr = import(D->getLocation()); 4957344779Sdim if (!LocationOrErr) 4958344779Sdim return LocationOrErr.takeError(); 4959341825Sdim 4960218893Sdim // Import template parameters. 4961353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 4962344779Sdim if (!TemplateParamsOrErr) 4963344779Sdim return TemplateParamsOrErr.takeError(); 4964276479Sdim 4965218893Sdim // FIXME: Import default argument. 4966341825Sdim 4967341825Sdim TemplateTemplateParmDecl *ToD = nullptr; 4968341825Sdim (void)GetImportedOrCreateDecl( 4969341825Sdim ToD, D, Importer.getToContext(), 4970344779Sdim Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr, 4971344779Sdim D->getDepth(), D->getPosition(), D->isParameterPack(), 4972344779Sdim (*NameOrErr).getAsIdentifierInfo(), 4973344779Sdim *TemplateParamsOrErr); 4974341825Sdim return ToD; 4975218893Sdim} 4976218893Sdim 4977353358Sdim// Returns the definition for a (forward) declaration of a TemplateDecl, if 4978341825Sdim// it has any definition in the redecl chain. 4979353358Sdimtemplate <typename T> static auto getTemplateDefinition(T *D) -> T * { 4980353358Sdim assert(D->getTemplatedDecl() && "Should be called on templates only"); 4981353358Sdim auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition(); 4982341825Sdim if (!ToTemplatedDef) 4983341825Sdim return nullptr; 4984353358Sdim auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate(); 4985353358Sdim return cast_or_null<T>(TemplateWithDef); 4986341825Sdim} 4987341825Sdim 4988344779SdimExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 4989344779Sdim bool IsFriend = D->getFriendObjectKind() != Decl::FOK_None; 4990344779Sdim 4991218893Sdim // Import the major distinguishing characteristics of this class template. 4992218893Sdim DeclContext *DC, *LexicalDC; 4993218893Sdim DeclarationName Name; 4994218893Sdim SourceLocation Loc; 4995288943Sdim NamedDecl *ToD; 4996344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4997344779Sdim return std::move(Err); 4998288943Sdim if (ToD) 4999288943Sdim return ToD; 5000276479Sdim 5001344779Sdim ClassTemplateDecl *FoundByLookup = nullptr; 5002344779Sdim 5003218893Sdim // We may already have a template of the same name; try to find and match it. 5004218893Sdim if (!DC->isFunctionOrMethod()) { 5005226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 5006344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5007341825Sdim for (auto *FoundDecl : FoundDecls) { 5008344779Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary | 5009344779Sdim Decl::IDNS_TagFriend)) 5010218893Sdim continue; 5011341825Sdim 5012341825Sdim Decl *Found = FoundDecl; 5013344779Sdim auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found); 5014344779Sdim if (FoundTemplate) { 5015341825Sdim 5016344779Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5017353358Sdim ClassTemplateDecl *TemplateWithDef = 5018353358Sdim getTemplateDefinition(FoundTemplate); 5019344779Sdim if (D->isThisDeclarationADefinition() && TemplateWithDef) { 5020344779Sdim return Importer.MapImported(D, TemplateWithDef); 5021344779Sdim } 5022344779Sdim FoundByLookup = FoundTemplate; 5023344779Sdim break; 5024341825Sdim } 5025218893Sdim } 5026341825Sdim 5027341825Sdim ConflictingDecls.push_back(FoundDecl); 5028218893Sdim } 5029341825Sdim 5030218893Sdim if (!ConflictingDecls.empty()) { 5031218893Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 5032341825Sdim ConflictingDecls.data(), 5033218893Sdim ConflictingDecls.size()); 5034218893Sdim } 5035341825Sdim 5036218893Sdim if (!Name) 5037344779Sdim return make_error<ImportError>(ImportError::NameConflict); 5038218893Sdim } 5039218893Sdim 5040341825Sdim CXXRecordDecl *FromTemplated = D->getTemplatedDecl(); 5041341825Sdim 5042218893Sdim // Create the declaration that is being templated. 5043344779Sdim CXXRecordDecl *ToTemplated; 5044344779Sdim if (Error Err = importInto(ToTemplated, FromTemplated)) 5045344779Sdim return std::move(Err); 5046309124Sdim 5047218893Sdim // Create the class template declaration itself. 5048353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 5049344779Sdim if (!TemplateParamsOrErr) 5050344779Sdim return TemplateParamsOrErr.takeError(); 5051276479Sdim 5052341825Sdim ClassTemplateDecl *D2; 5053341825Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name, 5054344779Sdim *TemplateParamsOrErr, ToTemplated)) 5055341825Sdim return D2; 5056341825Sdim 5057341825Sdim ToTemplated->setDescribedClassTemplate(D2); 5058341825Sdim 5059218893Sdim D2->setAccess(D->getAccess()); 5060218893Sdim D2->setLexicalDeclContext(LexicalDC); 5061218893Sdim 5062344779Sdim if (D->getDeclContext()->containsDeclAndLoad(D)) 5063344779Sdim DC->addDeclInternal(D2); 5064344779Sdim if (DC != LexicalDC && D->getLexicalDeclContext()->containsDeclAndLoad(D)) 5065344779Sdim LexicalDC->addDeclInternal(D2); 5066344779Sdim 5067344779Sdim if (FoundByLookup) { 5068344779Sdim auto *Recent = 5069344779Sdim const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl()); 5070344779Sdim 5071344779Sdim // It is possible that during the import of the class template definition 5072344779Sdim // we start the import of a fwd friend decl of the very same class template 5073344779Sdim // and we add the fwd friend decl to the lookup table. But the ToTemplated 5074344779Sdim // had been created earlier and by that time the lookup could not find 5075344779Sdim // anything existing, so it has no previous decl. Later, (still during the 5076344779Sdim // import of the fwd friend decl) we start to import the definition again 5077344779Sdim // and this time the lookup finds the previous fwd friend class template. 5078344779Sdim // In this case we must set up the previous decl for the templated decl. 5079344779Sdim if (!ToTemplated->getPreviousDecl()) { 5080353358Sdim assert(FoundByLookup->getTemplatedDecl() && 5081353358Sdim "Found decl must have its templated decl set"); 5082344779Sdim CXXRecordDecl *PrevTemplated = 5083344779Sdim FoundByLookup->getTemplatedDecl()->getMostRecentDecl(); 5084344779Sdim if (ToTemplated != PrevTemplated) 5085344779Sdim ToTemplated->setPreviousDecl(PrevTemplated); 5086344779Sdim } 5087344779Sdim 5088344779Sdim D2->setPreviousDecl(Recent); 5089344779Sdim } 5090344779Sdim 5091344779Sdim if (LexicalDC != DC && IsFriend) 5092344779Sdim DC->makeDeclVisibleInContext(D2); 5093344779Sdim 5094341825Sdim if (FromTemplated->isCompleteDefinition() && 5095341825Sdim !ToTemplated->isCompleteDefinition()) { 5096218893Sdim // FIXME: Import definition! 5097218893Sdim } 5098341825Sdim 5099218893Sdim return D2; 5100218893Sdim} 5101218893Sdim 5102344779SdimExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( 5103218893Sdim ClassTemplateSpecializationDecl *D) { 5104344779Sdim ClassTemplateDecl *ClassTemplate; 5105344779Sdim if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate())) 5106344779Sdim return std::move(Err); 5107276479Sdim 5108218893Sdim // Import the context of this declaration. 5109344779Sdim DeclContext *DC, *LexicalDC; 5110344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 5111344779Sdim return std::move(Err); 5112276479Sdim 5113218893Sdim // Import template arguments. 5114226633Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 5115344779Sdim if (Error Err = ImportTemplateArguments( 5116344779Sdim D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs)) 5117344779Sdim return std::move(Err); 5118276479Sdim 5119218893Sdim // Try to find an existing specialization with these template arguments. 5120276479Sdim void *InsertPos = nullptr; 5121353358Sdim ClassTemplateSpecializationDecl *PrevDecl = nullptr; 5122344779Sdim ClassTemplatePartialSpecializationDecl *PartialSpec = 5123344779Sdim dyn_cast<ClassTemplatePartialSpecializationDecl>(D); 5124344779Sdim if (PartialSpec) 5125353358Sdim PrevDecl = 5126353358Sdim ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos); 5127344779Sdim else 5128353358Sdim PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 5129341825Sdim 5130353358Sdim if (PrevDecl) { 5131353358Sdim if (IsStructuralMatch(D, PrevDecl)) { 5132353358Sdim if (D->isThisDeclarationADefinition() && PrevDecl->getDefinition()) { 5133353358Sdim Importer.MapImported(D, PrevDecl->getDefinition()); 5134353358Sdim // Import those default field initializers which have been 5135353358Sdim // instantiated in the "From" context, but not in the "To" context. 5136353358Sdim for (auto *FromField : D->fields()) { 5137353358Sdim auto ToOrErr = import(FromField); 5138353358Sdim if (!ToOrErr) 5139353358Sdim return ToOrErr.takeError(); 5140353358Sdim } 5141341825Sdim 5142353358Sdim // Import those methods which have been instantiated in the 5143353358Sdim // "From" context, but not in the "To" context. 5144353358Sdim for (CXXMethodDecl *FromM : D->methods()) { 5145353358Sdim auto ToOrErr = import(FromM); 5146353358Sdim if (!ToOrErr) 5147353358Sdim return ToOrErr.takeError(); 5148353358Sdim } 5149344779Sdim 5150353358Sdim // TODO Import instantiated default arguments. 5151353358Sdim // TODO Import instantiated exception specifications. 5152353358Sdim // 5153353358Sdim // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint 5154353358Sdim // what else could be fused during an AST merge. 5155353358Sdim return PrevDecl; 5156218893Sdim } 5157353358Sdim } else { // ODR violation. 5158353358Sdim // FIXME HandleNameConflict 5159353358Sdim return make_error<ImportError>(ImportError::NameConflict); 5160353358Sdim } 5161353358Sdim } 5162344779Sdim 5163353358Sdim // Import the location of this declaration. 5164353358Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 5165353358Sdim if (!BeginLocOrErr) 5166353358Sdim return BeginLocOrErr.takeError(); 5167353358Sdim ExpectedSLoc IdLocOrErr = import(D->getLocation()); 5168353358Sdim if (!IdLocOrErr) 5169353358Sdim return IdLocOrErr.takeError(); 5170344779Sdim 5171353358Sdim // Create the specialization. 5172353358Sdim ClassTemplateSpecializationDecl *D2 = nullptr; 5173353358Sdim if (PartialSpec) { 5174353358Sdim // Import TemplateArgumentListInfo. 5175353358Sdim TemplateArgumentListInfo ToTAInfo; 5176353358Sdim const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten(); 5177353358Sdim if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo)) 5178353358Sdim return std::move(Err); 5179344779Sdim 5180353358Sdim QualType CanonInjType; 5181353358Sdim if (Error Err = importInto( 5182353358Sdim CanonInjType, PartialSpec->getInjectedSpecializationType())) 5183353358Sdim return std::move(Err); 5184353358Sdim CanonInjType = CanonInjType.getCanonicalType(); 5185344779Sdim 5186353358Sdim auto ToTPListOrErr = import(PartialSpec->getTemplateParameters()); 5187353358Sdim if (!ToTPListOrErr) 5188353358Sdim return ToTPListOrErr.takeError(); 5189344779Sdim 5190353358Sdim if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>( 5191353358Sdim D2, D, Importer.getToContext(), D->getTagKind(), DC, 5192353358Sdim *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, ClassTemplate, 5193353358Sdim llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), 5194353358Sdim ToTAInfo, CanonInjType, 5195353358Sdim cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl))) 5196353358Sdim return D2; 5197321369Sdim 5198353358Sdim // Update InsertPos, because preceding import calls may have invalidated 5199353358Sdim // it by adding new specializations. 5200353358Sdim if (!ClassTemplate->findPartialSpecialization(TemplateArgs, InsertPos)) 5201353358Sdim // Add this partial specialization to the class template. 5202353358Sdim ClassTemplate->AddPartialSpecialization( 5203353358Sdim cast<ClassTemplatePartialSpecializationDecl>(D2), InsertPos); 5204321369Sdim 5205353358Sdim } else { // Not a partial specialization. 5206353358Sdim if (GetImportedOrCreateDecl( 5207353358Sdim D2, D, Importer.getToContext(), D->getTagKind(), DC, 5208353358Sdim *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs, 5209353358Sdim PrevDecl)) 5210353358Sdim return D2; 5211321369Sdim 5212353358Sdim // Update InsertPos, because preceding import calls may have invalidated 5213353358Sdim // it by adding new specializations. 5214353358Sdim if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos)) 5215353358Sdim // Add this specialization to the class template. 5216353358Sdim ClassTemplate->AddSpecialization(D2, InsertPos); 5217353358Sdim } 5218321369Sdim 5219353358Sdim D2->setSpecializationKind(D->getSpecializationKind()); 5220344779Sdim 5221353358Sdim // Set the context of this specialization/instantiation. 5222353358Sdim D2->setLexicalDeclContext(LexicalDC); 5223344779Sdim 5224353358Sdim // Add to the DC only if it was an explicit specialization/instantiation. 5225353358Sdim if (D2->isExplicitInstantiationOrSpecialization()) { 5226353358Sdim LexicalDC->addDeclInternal(D2); 5227353358Sdim } 5228321369Sdim 5229353358Sdim // Import the qualifier, if any. 5230353358Sdim if (auto LocOrErr = import(D->getQualifierLoc())) 5231353358Sdim D2->setQualifierInfo(*LocOrErr); 5232353358Sdim else 5233353358Sdim return LocOrErr.takeError(); 5234218893Sdim 5235353358Sdim if (auto *TSI = D->getTypeAsWritten()) { 5236353358Sdim if (auto TInfoOrErr = import(TSI)) 5237353358Sdim D2->setTypeAsWritten(*TInfoOrErr); 5238344779Sdim else 5239353358Sdim return TInfoOrErr.takeError(); 5240353358Sdim 5241353358Sdim if (auto LocOrErr = import(D->getTemplateKeywordLoc())) 5242353358Sdim D2->setTemplateKeywordLoc(*LocOrErr); 5243353358Sdim else 5244344779Sdim return LocOrErr.takeError(); 5245321369Sdim 5246353358Sdim if (auto LocOrErr = import(D->getExternLoc())) 5247353358Sdim D2->setExternLoc(*LocOrErr); 5248353358Sdim else 5249353358Sdim return LocOrErr.takeError(); 5250353358Sdim } 5251344779Sdim 5252353358Sdim if (D->getPointOfInstantiation().isValid()) { 5253353358Sdim if (auto POIOrErr = import(D->getPointOfInstantiation())) 5254353358Sdim D2->setPointOfInstantiation(*POIOrErr); 5255353358Sdim else 5256353358Sdim return POIOrErr.takeError(); 5257353358Sdim } 5258344779Sdim 5259353358Sdim D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind()); 5260321369Sdim 5261344779Sdim if (D->isCompleteDefinition()) 5262344779Sdim if (Error Err = ImportDefinition(D, D2)) 5263344779Sdim return std::move(Err); 5264276479Sdim 5265218893Sdim return D2; 5266218893Sdim} 5267218893Sdim 5268344779SdimExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 5269261991Sdim // If this variable has a definition in the translation unit we're coming 5270261991Sdim // from, 5271261991Sdim // but this particular declaration is not that definition, import the 5272261991Sdim // definition and map to that. 5273341825Sdim auto *Definition = 5274261991Sdim cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 5275261991Sdim if (Definition && Definition != D->getTemplatedDecl()) { 5276344779Sdim if (ExpectedDecl ImportedDefOrErr = import( 5277344779Sdim Definition->getDescribedVarTemplate())) 5278344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 5279344779Sdim else 5280344779Sdim return ImportedDefOrErr.takeError(); 5281261991Sdim } 5282261991Sdim 5283261991Sdim // Import the major distinguishing characteristics of this variable template. 5284261991Sdim DeclContext *DC, *LexicalDC; 5285261991Sdim DeclarationName Name; 5286261991Sdim SourceLocation Loc; 5287288943Sdim NamedDecl *ToD; 5288344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 5289344779Sdim return std::move(Err); 5290288943Sdim if (ToD) 5291288943Sdim return ToD; 5292261991Sdim 5293261991Sdim // We may already have a template of the same name; try to find and match it. 5294261991Sdim assert(!DC->isFunctionOrMethod() && 5295261991Sdim "Variable templates cannot be declared at function scope"); 5296261991Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 5297344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5298341825Sdim for (auto *FoundDecl : FoundDecls) { 5299341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 5300261991Sdim continue; 5301261991Sdim 5302341825Sdim Decl *Found = FoundDecl; 5303344779Sdim if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 5304261991Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5305261991Sdim // The variable templates structurally match; call it the same template. 5306341825Sdim Importer.MapImported(D->getTemplatedDecl(), 5307341825Sdim FoundTemplate->getTemplatedDecl()); 5308341825Sdim return Importer.MapImported(D, FoundTemplate); 5309261991Sdim } 5310261991Sdim } 5311261991Sdim 5312341825Sdim ConflictingDecls.push_back(FoundDecl); 5313261991Sdim } 5314261991Sdim 5315261991Sdim if (!ConflictingDecls.empty()) { 5316261991Sdim Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 5317261991Sdim ConflictingDecls.data(), 5318261991Sdim ConflictingDecls.size()); 5319261991Sdim } 5320261991Sdim 5321261991Sdim if (!Name) 5322344779Sdim // FIXME: Is it possible to get other error than name conflict? 5323344779Sdim // (Put this `if` into the previous `if`?) 5324344779Sdim return make_error<ImportError>(ImportError::NameConflict); 5325261991Sdim 5326261991Sdim VarDecl *DTemplated = D->getTemplatedDecl(); 5327261991Sdim 5328261991Sdim // Import the type. 5329344779Sdim // FIXME: Value not used? 5330344779Sdim ExpectedType TypeOrErr = import(DTemplated->getType()); 5331344779Sdim if (!TypeOrErr) 5332344779Sdim return TypeOrErr.takeError(); 5333261991Sdim 5334261991Sdim // Create the declaration that is being templated. 5335344779Sdim VarDecl *ToTemplated; 5336344779Sdim if (Error Err = importInto(ToTemplated, DTemplated)) 5337344779Sdim return std::move(Err); 5338261991Sdim 5339261991Sdim // Create the variable template declaration itself. 5340353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 5341344779Sdim if (!TemplateParamsOrErr) 5342344779Sdim return TemplateParamsOrErr.takeError(); 5343261991Sdim 5344341825Sdim VarTemplateDecl *ToVarTD; 5345341825Sdim if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc, 5346344779Sdim Name, *TemplateParamsOrErr, ToTemplated)) 5347341825Sdim return ToVarTD; 5348261991Sdim 5349341825Sdim ToTemplated->setDescribedVarTemplate(ToVarTD); 5350261991Sdim 5351341825Sdim ToVarTD->setAccess(D->getAccess()); 5352341825Sdim ToVarTD->setLexicalDeclContext(LexicalDC); 5353341825Sdim LexicalDC->addDeclInternal(ToVarTD); 5354261991Sdim 5355261991Sdim if (DTemplated->isThisDeclarationADefinition() && 5356341825Sdim !ToTemplated->isThisDeclarationADefinition()) { 5357261991Sdim // FIXME: Import definition! 5358261991Sdim } 5359261991Sdim 5360341825Sdim return ToVarTD; 5361261991Sdim} 5362261991Sdim 5363344779SdimExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl( 5364261991Sdim VarTemplateSpecializationDecl *D) { 5365261991Sdim // If this record has a definition in the translation unit we're coming from, 5366261991Sdim // but this particular declaration is not that definition, import the 5367261991Sdim // definition and map to that. 5368261991Sdim VarDecl *Definition = D->getDefinition(); 5369261991Sdim if (Definition && Definition != D) { 5370344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 5371344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 5372344779Sdim else 5373344779Sdim return ImportedDefOrErr.takeError(); 5374261991Sdim } 5375261991Sdim 5376353358Sdim VarTemplateDecl *VarTemplate = nullptr; 5377344779Sdim if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate())) 5378344779Sdim return std::move(Err); 5379261991Sdim 5380261991Sdim // Import the context of this declaration. 5381344779Sdim DeclContext *DC, *LexicalDC; 5382344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 5383344779Sdim return std::move(Err); 5384261991Sdim 5385261991Sdim // Import the location of this declaration. 5386344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 5387344779Sdim if (!BeginLocOrErr) 5388344779Sdim return BeginLocOrErr.takeError(); 5389261991Sdim 5390344779Sdim auto IdLocOrErr = import(D->getLocation()); 5391344779Sdim if (!IdLocOrErr) 5392344779Sdim return IdLocOrErr.takeError(); 5393344779Sdim 5394261991Sdim // Import template arguments. 5395261991Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 5396344779Sdim if (Error Err = ImportTemplateArguments( 5397344779Sdim D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs)) 5398344779Sdim return std::move(Err); 5399261991Sdim 5400261991Sdim // Try to find an existing specialization with these template arguments. 5401276479Sdim void *InsertPos = nullptr; 5402261991Sdim VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 5403276479Sdim TemplateArgs, InsertPos); 5404261991Sdim if (D2) { 5405261991Sdim // We already have a variable template specialization with these template 5406261991Sdim // arguments. 5407261991Sdim 5408261991Sdim // FIXME: Check for specialization vs. instantiation errors. 5409261991Sdim 5410261991Sdim if (VarDecl *FoundDef = D2->getDefinition()) { 5411261991Sdim if (!D->isThisDeclarationADefinition() || 5412261991Sdim IsStructuralMatch(D, FoundDef)) { 5413261991Sdim // The record types structurally match, or the "from" translation 5414261991Sdim // unit only had a forward declaration anyway; call it the same 5415261991Sdim // variable. 5416341825Sdim return Importer.MapImported(D, FoundDef); 5417261991Sdim } 5418261991Sdim } 5419261991Sdim } else { 5420261991Sdim // Import the type. 5421344779Sdim QualType T; 5422344779Sdim if (Error Err = importInto(T, D->getType())) 5423344779Sdim return std::move(Err); 5424341825Sdim 5425344779Sdim auto TInfoOrErr = import(D->getTypeSourceInfo()); 5426344779Sdim if (!TInfoOrErr) 5427344779Sdim return TInfoOrErr.takeError(); 5428261991Sdim 5429341825Sdim TemplateArgumentListInfo ToTAInfo; 5430344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 5431344779Sdim D->getTemplateArgsInfo(), ToTAInfo)) 5432344779Sdim return std::move(Err); 5433341825Sdim 5434341825Sdim using PartVarSpecDecl = VarTemplatePartialSpecializationDecl; 5435261991Sdim // Create a new specialization. 5436341825Sdim if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) { 5437341825Sdim // Import TemplateArgumentListInfo 5438341825Sdim TemplateArgumentListInfo ArgInfos; 5439341825Sdim const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten(); 5440341825Sdim // NOTE: FromTAArgsAsWritten and template parameter list are non-null. 5441344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 5442344779Sdim *FromTAArgsAsWritten, ArgInfos)) 5443344779Sdim return std::move(Err); 5444341825Sdim 5445353358Sdim auto ToTPListOrErr = import(FromPartial->getTemplateParameters()); 5446344779Sdim if (!ToTPListOrErr) 5447344779Sdim return ToTPListOrErr.takeError(); 5448341825Sdim 5449341825Sdim PartVarSpecDecl *ToPartial; 5450341825Sdim if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC, 5451344779Sdim *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, 5452344779Sdim VarTemplate, T, *TInfoOrErr, 5453344779Sdim D->getStorageClass(), TemplateArgs, ArgInfos)) 5454341825Sdim return ToPartial; 5455341825Sdim 5456344779Sdim if (Expected<PartVarSpecDecl *> ToInstOrErr = import( 5457344779Sdim FromPartial->getInstantiatedFromMember())) 5458344779Sdim ToPartial->setInstantiatedFromMember(*ToInstOrErr); 5459344779Sdim else 5460344779Sdim return ToInstOrErr.takeError(); 5461341825Sdim 5462341825Sdim if (FromPartial->isMemberSpecialization()) 5463341825Sdim ToPartial->setMemberSpecialization(); 5464341825Sdim 5465341825Sdim D2 = ToPartial; 5466344779Sdim 5467341825Sdim } else { // Full specialization 5468344779Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, 5469344779Sdim *BeginLocOrErr, *IdLocOrErr, VarTemplate, 5470344779Sdim T, *TInfoOrErr, 5471341825Sdim D->getStorageClass(), TemplateArgs)) 5472341825Sdim return D2; 5473341825Sdim } 5474341825Sdim 5475344779Sdim if (D->getPointOfInstantiation().isValid()) { 5476344779Sdim if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation())) 5477344779Sdim D2->setPointOfInstantiation(*POIOrErr); 5478344779Sdim else 5479344779Sdim return POIOrErr.takeError(); 5480344779Sdim } 5481341825Sdim 5482261991Sdim D2->setSpecializationKind(D->getSpecializationKind()); 5483341825Sdim D2->setTemplateArgsInfo(ToTAInfo); 5484261991Sdim 5485261991Sdim // Add this specialization to the class template. 5486261991Sdim VarTemplate->AddSpecialization(D2, InsertPos); 5487261991Sdim 5488261991Sdim // Import the qualifier, if any. 5489344779Sdim if (auto LocOrErr = import(D->getQualifierLoc())) 5490344779Sdim D2->setQualifierInfo(*LocOrErr); 5491344779Sdim else 5492344779Sdim return LocOrErr.takeError(); 5493261991Sdim 5494341825Sdim if (D->isConstexpr()) 5495341825Sdim D2->setConstexpr(true); 5496341825Sdim 5497261991Sdim // Add the specialization to this context. 5498261991Sdim D2->setLexicalDeclContext(LexicalDC); 5499261991Sdim LexicalDC->addDeclInternal(D2); 5500341825Sdim 5501341825Sdim D2->setAccess(D->getAccess()); 5502261991Sdim } 5503261991Sdim 5504344779Sdim if (Error Err = ImportInitializer(D, D2)) 5505344779Sdim return std::move(Err); 5506261991Sdim 5507261991Sdim return D2; 5508261991Sdim} 5509261991Sdim 5510344779SdimExpectedDecl 5511344779SdimASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 5512327952Sdim DeclContext *DC, *LexicalDC; 5513327952Sdim DeclarationName Name; 5514327952Sdim SourceLocation Loc; 5515327952Sdim NamedDecl *ToD; 5516327952Sdim 5517344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 5518344779Sdim return std::move(Err); 5519327952Sdim 5520327952Sdim if (ToD) 5521327952Sdim return ToD; 5522327952Sdim 5523353358Sdim const FunctionTemplateDecl *FoundByLookup = nullptr; 5524353358Sdim 5525327952Sdim // Try to find a function in our own ("to") context with the same name, same 5526327952Sdim // type, and in the same context as the function we're importing. 5527353358Sdim // FIXME Split this into a separate function. 5528327952Sdim if (!LexicalDC->isFunctionOrMethod()) { 5529353358Sdim unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend; 5530344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5531341825Sdim for (auto *FoundDecl : FoundDecls) { 5532341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 5533327952Sdim continue; 5534327952Sdim 5535353358Sdim if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) { 5536353358Sdim if (FoundTemplate->hasExternalFormalLinkage() && 5537327952Sdim D->hasExternalFormalLinkage()) { 5538353358Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5539353358Sdim FunctionTemplateDecl *TemplateWithDef = 5540353358Sdim getTemplateDefinition(FoundTemplate); 5541353358Sdim if (D->isThisDeclarationADefinition() && TemplateWithDef) { 5542353358Sdim return Importer.MapImported(D, TemplateWithDef); 5543353358Sdim } 5544353358Sdim FoundByLookup = FoundTemplate; 5545353358Sdim break; 5546327952Sdim } 5547353358Sdim // TODO: handle conflicting names 5548327952Sdim } 5549327952Sdim } 5550327952Sdim } 5551327952Sdim } 5552327952Sdim 5553353358Sdim auto ParamsOrErr = import(D->getTemplateParameters()); 5554344779Sdim if (!ParamsOrErr) 5555344779Sdim return ParamsOrErr.takeError(); 5556327952Sdim 5557344779Sdim FunctionDecl *TemplatedFD; 5558344779Sdim if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl())) 5559344779Sdim return std::move(Err); 5560327952Sdim 5561341825Sdim FunctionTemplateDecl *ToFunc; 5562341825Sdim if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name, 5563344779Sdim *ParamsOrErr, TemplatedFD)) 5564341825Sdim return ToFunc; 5565327952Sdim 5566327952Sdim TemplatedFD->setDescribedFunctionTemplate(ToFunc); 5567353358Sdim 5568327952Sdim ToFunc->setAccess(D->getAccess()); 5569327952Sdim ToFunc->setLexicalDeclContext(LexicalDC); 5570353358Sdim LexicalDC->addDeclInternal(ToFunc); 5571327952Sdim 5572353358Sdim if (FoundByLookup) { 5573353358Sdim auto *Recent = 5574353358Sdim const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl()); 5575353358Sdim if (!TemplatedFD->getPreviousDecl()) { 5576353358Sdim assert(FoundByLookup->getTemplatedDecl() && 5577353358Sdim "Found decl must have its templated decl set"); 5578353358Sdim auto *PrevTemplated = 5579353358Sdim FoundByLookup->getTemplatedDecl()->getMostRecentDecl(); 5580353358Sdim if (TemplatedFD != PrevTemplated) 5581353358Sdim TemplatedFD->setPreviousDecl(PrevTemplated); 5582353358Sdim } 5583353358Sdim ToFunc->setPreviousDecl(Recent); 5584353358Sdim } 5585353358Sdim 5586327952Sdim return ToFunc; 5587327952Sdim} 5588327952Sdim 5589203955Srdivacky//---------------------------------------------------------------------------- 5590203955Srdivacky// Import Statements 5591203955Srdivacky//---------------------------------------------------------------------------- 5592203955Srdivacky 5593344779SdimExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) { 5594344779Sdim Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node) 5595344779Sdim << S->getStmtClassName(); 5596344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 5597203955Srdivacky} 5598203955Srdivacky 5599309124Sdim 5600344779SdimExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) { 5601353358Sdim if (Importer.returnWithErrorInTest()) 5602353358Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 5603309124Sdim SmallVector<IdentifierInfo *, 4> Names; 5604309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 5605309124Sdim IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I)); 5606321369Sdim // ToII is nullptr when no symbolic name is given for output operand 5607321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 5608309124Sdim Names.push_back(ToII); 5609309124Sdim } 5610344779Sdim 5611309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 5612309124Sdim IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I)); 5613321369Sdim // ToII is nullptr when no symbolic name is given for input operand 5614321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 5615309124Sdim Names.push_back(ToII); 5616309124Sdim } 5617309124Sdim 5618309124Sdim SmallVector<StringLiteral *, 4> Clobbers; 5619309124Sdim for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) { 5620344779Sdim if (auto ClobberOrErr = import(S->getClobberStringLiteral(I))) 5621344779Sdim Clobbers.push_back(*ClobberOrErr); 5622344779Sdim else 5623344779Sdim return ClobberOrErr.takeError(); 5624344779Sdim 5625309124Sdim } 5626309124Sdim 5627309124Sdim SmallVector<StringLiteral *, 4> Constraints; 5628309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 5629344779Sdim if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I))) 5630344779Sdim Constraints.push_back(*OutputOrErr); 5631344779Sdim else 5632344779Sdim return OutputOrErr.takeError(); 5633309124Sdim } 5634309124Sdim 5635309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 5636344779Sdim if (auto InputOrErr = import(S->getInputConstraintLiteral(I))) 5637344779Sdim Constraints.push_back(*InputOrErr); 5638344779Sdim else 5639344779Sdim return InputOrErr.takeError(); 5640309124Sdim } 5641309124Sdim 5642353358Sdim SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() + 5643353358Sdim S->getNumLabels()); 5644344779Sdim if (Error Err = ImportContainerChecked(S->outputs(), Exprs)) 5645344779Sdim return std::move(Err); 5646309124Sdim 5647353358Sdim if (Error Err = 5648353358Sdim ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs())) 5649353358Sdim return std::move(Err); 5650353358Sdim 5651344779Sdim if (Error Err = ImportArrayChecked( 5652353358Sdim S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs())) 5653344779Sdim return std::move(Err); 5654309124Sdim 5655344779Sdim ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc()); 5656344779Sdim if (!AsmLocOrErr) 5657344779Sdim return AsmLocOrErr.takeError(); 5658344779Sdim auto AsmStrOrErr = import(S->getAsmString()); 5659344779Sdim if (!AsmStrOrErr) 5660344779Sdim return AsmStrOrErr.takeError(); 5661344779Sdim ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc()); 5662344779Sdim if (!RParenLocOrErr) 5663344779Sdim return RParenLocOrErr.takeError(); 5664309124Sdim 5665309124Sdim return new (Importer.getToContext()) GCCAsmStmt( 5666344779Sdim Importer.getToContext(), 5667344779Sdim *AsmLocOrErr, 5668344779Sdim S->isSimple(), 5669344779Sdim S->isVolatile(), 5670344779Sdim S->getNumOutputs(), 5671344779Sdim S->getNumInputs(), 5672344779Sdim Names.data(), 5673344779Sdim Constraints.data(), 5674344779Sdim Exprs.data(), 5675344779Sdim *AsmStrOrErr, 5676344779Sdim S->getNumClobbers(), 5677344779Sdim Clobbers.data(), 5678353358Sdim S->getNumLabels(), 5679344779Sdim *RParenLocOrErr); 5680309124Sdim} 5681309124Sdim 5682344779SdimExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 5683344779Sdim auto Imp = importSeq(S->getDeclGroup(), S->getBeginLoc(), S->getEndLoc()); 5684344779Sdim if (!Imp) 5685344779Sdim return Imp.takeError(); 5686344779Sdim 5687344779Sdim DeclGroupRef ToDG; 5688344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 5689344779Sdim std::tie(ToDG, ToBeginLoc, ToEndLoc) = *Imp; 5690344779Sdim 5691344779Sdim return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc); 5692288943Sdim} 5693288943Sdim 5694344779SdimExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) { 5695344779Sdim ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc()); 5696344779Sdim if (!ToSemiLocOrErr) 5697344779Sdim return ToSemiLocOrErr.takeError(); 5698344779Sdim return new (Importer.getToContext()) NullStmt( 5699344779Sdim *ToSemiLocOrErr, S->hasLeadingEmptyMacro()); 5700288943Sdim} 5701288943Sdim 5702344779SdimExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 5703341825Sdim SmallVector<Stmt *, 8> ToStmts(S->size()); 5704314564Sdim 5705344779Sdim if (Error Err = ImportContainerChecked(S->body(), ToStmts)) 5706344779Sdim return std::move(Err); 5707309124Sdim 5708344779Sdim ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc()); 5709344779Sdim if (!ToLBracLocOrErr) 5710344779Sdim return ToLBracLocOrErr.takeError(); 5711344779Sdim 5712344779Sdim ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc()); 5713344779Sdim if (!ToRBracLocOrErr) 5714344779Sdim return ToRBracLocOrErr.takeError(); 5715344779Sdim 5716344779Sdim return CompoundStmt::Create( 5717344779Sdim Importer.getToContext(), ToStmts, 5718344779Sdim *ToLBracLocOrErr, *ToRBracLocOrErr); 5719288943Sdim} 5720288943Sdim 5721344779SdimExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 5722344779Sdim auto Imp = importSeq( 5723344779Sdim S->getLHS(), S->getRHS(), S->getSubStmt(), S->getCaseLoc(), 5724344779Sdim S->getEllipsisLoc(), S->getColonLoc()); 5725344779Sdim if (!Imp) 5726344779Sdim return Imp.takeError(); 5727344779Sdim 5728344779Sdim Expr *ToLHS, *ToRHS; 5729344779Sdim Stmt *ToSubStmt; 5730344779Sdim SourceLocation ToCaseLoc, ToEllipsisLoc, ToColonLoc; 5731344779Sdim std::tie(ToLHS, ToRHS, ToSubStmt, ToCaseLoc, ToEllipsisLoc, ToColonLoc) = 5732344779Sdim *Imp; 5733344779Sdim 5734344779Sdim auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS, 5735344779Sdim ToCaseLoc, ToEllipsisLoc, ToColonLoc); 5736327952Sdim ToStmt->setSubStmt(ToSubStmt); 5737344779Sdim 5738327952Sdim return ToStmt; 5739288943Sdim} 5740288943Sdim 5741344779SdimExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 5742344779Sdim auto Imp = importSeq(S->getDefaultLoc(), S->getColonLoc(), S->getSubStmt()); 5743344779Sdim if (!Imp) 5744344779Sdim return Imp.takeError(); 5745344779Sdim 5746344779Sdim SourceLocation ToDefaultLoc, ToColonLoc; 5747344779Sdim Stmt *ToSubStmt; 5748344779Sdim std::tie(ToDefaultLoc, ToColonLoc, ToSubStmt) = *Imp; 5749344779Sdim 5750344779Sdim return new (Importer.getToContext()) DefaultStmt( 5751344779Sdim ToDefaultLoc, ToColonLoc, ToSubStmt); 5752288943Sdim} 5753288943Sdim 5754344779SdimExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 5755344779Sdim auto Imp = importSeq(S->getIdentLoc(), S->getDecl(), S->getSubStmt()); 5756344779Sdim if (!Imp) 5757344779Sdim return Imp.takeError(); 5758344779Sdim 5759344779Sdim SourceLocation ToIdentLoc; 5760344779Sdim LabelDecl *ToLabelDecl; 5761344779Sdim Stmt *ToSubStmt; 5762344779Sdim std::tie(ToIdentLoc, ToLabelDecl, ToSubStmt) = *Imp; 5763344779Sdim 5764344779Sdim return new (Importer.getToContext()) LabelStmt( 5765344779Sdim ToIdentLoc, ToLabelDecl, ToSubStmt); 5766288943Sdim} 5767288943Sdim 5768344779SdimExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 5769344779Sdim ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc()); 5770344779Sdim if (!ToAttrLocOrErr) 5771344779Sdim return ToAttrLocOrErr.takeError(); 5772288943Sdim ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 5773288943Sdim SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 5774344779Sdim if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs)) 5775344779Sdim return std::move(Err); 5776344779Sdim ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt()); 5777344779Sdim if (!ToSubStmtOrErr) 5778344779Sdim return ToSubStmtOrErr.takeError(); 5779344779Sdim 5780344779Sdim return AttributedStmt::Create( 5781344779Sdim Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr); 5782288943Sdim} 5783288943Sdim 5784344779SdimExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) { 5785344779Sdim auto Imp = importSeq( 5786344779Sdim S->getIfLoc(), S->getInit(), S->getConditionVariable(), S->getCond(), 5787344779Sdim S->getThen(), S->getElseLoc(), S->getElse()); 5788344779Sdim if (!Imp) 5789344779Sdim return Imp.takeError(); 5790344779Sdim 5791344779Sdim SourceLocation ToIfLoc, ToElseLoc; 5792344779Sdim Stmt *ToInit, *ToThen, *ToElse; 5793344779Sdim VarDecl *ToConditionVariable; 5794344779Sdim Expr *ToCond; 5795344779Sdim std::tie( 5796344779Sdim ToIfLoc, ToInit, ToConditionVariable, ToCond, ToThen, ToElseLoc, ToElse) = 5797344779Sdim *Imp; 5798344779Sdim 5799344779Sdim return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(), 5800344779Sdim ToInit, ToConditionVariable, ToCond, ToThen, ToElseLoc, 5801344779Sdim ToElse); 5802288943Sdim} 5803288943Sdim 5804344779SdimExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 5805344779Sdim auto Imp = importSeq( 5806344779Sdim S->getInit(), S->getConditionVariable(), S->getCond(), 5807344779Sdim S->getBody(), S->getSwitchLoc()); 5808344779Sdim if (!Imp) 5809344779Sdim return Imp.takeError(); 5810344779Sdim 5811344779Sdim Stmt *ToInit, *ToBody; 5812344779Sdim VarDecl *ToConditionVariable; 5813344779Sdim Expr *ToCond; 5814344779Sdim SourceLocation ToSwitchLoc; 5815344779Sdim std::tie(ToInit, ToConditionVariable, ToCond, ToBody, ToSwitchLoc) = *Imp; 5816344779Sdim 5817344779Sdim auto *ToStmt = SwitchStmt::Create(Importer.getToContext(), ToInit, 5818344779Sdim ToConditionVariable, ToCond); 5819288943Sdim ToStmt->setBody(ToBody); 5820344779Sdim ToStmt->setSwitchLoc(ToSwitchLoc); 5821344779Sdim 5822288943Sdim // Now we have to re-chain the cases. 5823288943Sdim SwitchCase *LastChainedSwitchCase = nullptr; 5824288943Sdim for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 5825288943Sdim SC = SC->getNextSwitchCase()) { 5826344779Sdim Expected<SwitchCase *> ToSCOrErr = import(SC); 5827344779Sdim if (!ToSCOrErr) 5828344779Sdim return ToSCOrErr.takeError(); 5829288943Sdim if (LastChainedSwitchCase) 5830344779Sdim LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr); 5831288943Sdim else 5832344779Sdim ToStmt->setSwitchCaseList(*ToSCOrErr); 5833344779Sdim LastChainedSwitchCase = *ToSCOrErr; 5834288943Sdim } 5835344779Sdim 5836288943Sdim return ToStmt; 5837288943Sdim} 5838288943Sdim 5839344779SdimExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 5840344779Sdim auto Imp = importSeq( 5841344779Sdim S->getConditionVariable(), S->getCond(), S->getBody(), S->getWhileLoc()); 5842344779Sdim if (!Imp) 5843344779Sdim return Imp.takeError(); 5844344779Sdim 5845344779Sdim VarDecl *ToConditionVariable; 5846344779Sdim Expr *ToCond; 5847344779Sdim Stmt *ToBody; 5848344779Sdim SourceLocation ToWhileLoc; 5849344779Sdim std::tie(ToConditionVariable, ToCond, ToBody, ToWhileLoc) = *Imp; 5850344779Sdim 5851344779Sdim return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond, 5852344779Sdim ToBody, ToWhileLoc); 5853288943Sdim} 5854288943Sdim 5855344779SdimExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) { 5856344779Sdim auto Imp = importSeq( 5857344779Sdim S->getBody(), S->getCond(), S->getDoLoc(), S->getWhileLoc(), 5858344779Sdim S->getRParenLoc()); 5859344779Sdim if (!Imp) 5860344779Sdim return Imp.takeError(); 5861344779Sdim 5862344779Sdim Stmt *ToBody; 5863344779Sdim Expr *ToCond; 5864344779Sdim SourceLocation ToDoLoc, ToWhileLoc, ToRParenLoc; 5865344779Sdim std::tie(ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc) = *Imp; 5866344779Sdim 5867344779Sdim return new (Importer.getToContext()) DoStmt( 5868344779Sdim ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc); 5869288943Sdim} 5870288943Sdim 5871344779SdimExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) { 5872344779Sdim auto Imp = importSeq( 5873344779Sdim S->getInit(), S->getCond(), S->getConditionVariable(), S->getInc(), 5874344779Sdim S->getBody(), S->getForLoc(), S->getLParenLoc(), S->getRParenLoc()); 5875344779Sdim if (!Imp) 5876344779Sdim return Imp.takeError(); 5877344779Sdim 5878344779Sdim Stmt *ToInit; 5879344779Sdim Expr *ToCond, *ToInc; 5880344779Sdim VarDecl *ToConditionVariable; 5881344779Sdim Stmt *ToBody; 5882344779Sdim SourceLocation ToForLoc, ToLParenLoc, ToRParenLoc; 5883344779Sdim std::tie( 5884344779Sdim ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, 5885344779Sdim ToLParenLoc, ToRParenLoc) = *Imp; 5886344779Sdim 5887344779Sdim return new (Importer.getToContext()) ForStmt( 5888344779Sdim Importer.getToContext(), 5889344779Sdim ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc, 5890344779Sdim ToRParenLoc); 5891288943Sdim} 5892288943Sdim 5893344779SdimExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 5894344779Sdim auto Imp = importSeq(S->getLabel(), S->getGotoLoc(), S->getLabelLoc()); 5895344779Sdim if (!Imp) 5896344779Sdim return Imp.takeError(); 5897344779Sdim 5898344779Sdim LabelDecl *ToLabel; 5899344779Sdim SourceLocation ToGotoLoc, ToLabelLoc; 5900344779Sdim std::tie(ToLabel, ToGotoLoc, ToLabelLoc) = *Imp; 5901344779Sdim 5902344779Sdim return new (Importer.getToContext()) GotoStmt( 5903344779Sdim ToLabel, ToGotoLoc, ToLabelLoc); 5904288943Sdim} 5905288943Sdim 5906344779SdimExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 5907344779Sdim auto Imp = importSeq(S->getGotoLoc(), S->getStarLoc(), S->getTarget()); 5908344779Sdim if (!Imp) 5909344779Sdim return Imp.takeError(); 5910344779Sdim 5911344779Sdim SourceLocation ToGotoLoc, ToStarLoc; 5912344779Sdim Expr *ToTarget; 5913344779Sdim std::tie(ToGotoLoc, ToStarLoc, ToTarget) = *Imp; 5914344779Sdim 5915344779Sdim return new (Importer.getToContext()) IndirectGotoStmt( 5916344779Sdim ToGotoLoc, ToStarLoc, ToTarget); 5917288943Sdim} 5918288943Sdim 5919344779SdimExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 5920344779Sdim ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc()); 5921344779Sdim if (!ToContinueLocOrErr) 5922344779Sdim return ToContinueLocOrErr.takeError(); 5923344779Sdim return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr); 5924288943Sdim} 5925288943Sdim 5926344779SdimExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 5927344779Sdim auto ToBreakLocOrErr = import(S->getBreakLoc()); 5928344779Sdim if (!ToBreakLocOrErr) 5929344779Sdim return ToBreakLocOrErr.takeError(); 5930344779Sdim return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr); 5931288943Sdim} 5932288943Sdim 5933344779SdimExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 5934344779Sdim auto Imp = importSeq( 5935344779Sdim S->getReturnLoc(), S->getRetValue(), S->getNRVOCandidate()); 5936344779Sdim if (!Imp) 5937344779Sdim return Imp.takeError(); 5938344779Sdim 5939344779Sdim SourceLocation ToReturnLoc; 5940344779Sdim Expr *ToRetValue; 5941344779Sdim const VarDecl *ToNRVOCandidate; 5942344779Sdim std::tie(ToReturnLoc, ToRetValue, ToNRVOCandidate) = *Imp; 5943344779Sdim 5944344779Sdim return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue, 5945344779Sdim ToNRVOCandidate); 5946288943Sdim} 5947288943Sdim 5948344779SdimExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 5949344779Sdim auto Imp = importSeq( 5950344779Sdim S->getCatchLoc(), S->getExceptionDecl(), S->getHandlerBlock()); 5951344779Sdim if (!Imp) 5952344779Sdim return Imp.takeError(); 5953344779Sdim 5954344779Sdim SourceLocation ToCatchLoc; 5955344779Sdim VarDecl *ToExceptionDecl; 5956344779Sdim Stmt *ToHandlerBlock; 5957344779Sdim std::tie(ToCatchLoc, ToExceptionDecl, ToHandlerBlock) = *Imp; 5958344779Sdim 5959344779Sdim return new (Importer.getToContext()) CXXCatchStmt ( 5960344779Sdim ToCatchLoc, ToExceptionDecl, ToHandlerBlock); 5961288943Sdim} 5962288943Sdim 5963344779SdimExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 5964344779Sdim ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc()); 5965344779Sdim if (!ToTryLocOrErr) 5966344779Sdim return ToTryLocOrErr.takeError(); 5967344779Sdim 5968344779Sdim ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock()); 5969344779Sdim if (!ToTryBlockOrErr) 5970344779Sdim return ToTryBlockOrErr.takeError(); 5971344779Sdim 5972288943Sdim SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 5973288943Sdim for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 5974288943Sdim CXXCatchStmt *FromHandler = S->getHandler(HI); 5975344779Sdim if (auto ToHandlerOrErr = import(FromHandler)) 5976344779Sdim ToHandlers[HI] = *ToHandlerOrErr; 5977288943Sdim else 5978344779Sdim return ToHandlerOrErr.takeError(); 5979288943Sdim } 5980344779Sdim 5981344779Sdim return CXXTryStmt::Create( 5982344779Sdim Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers); 5983288943Sdim} 5984288943Sdim 5985344779SdimExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 5986344779Sdim auto Imp1 = importSeq( 5987344779Sdim S->getInit(), S->getRangeStmt(), S->getBeginStmt(), S->getEndStmt(), 5988344779Sdim S->getCond(), S->getInc(), S->getLoopVarStmt(), S->getBody()); 5989344779Sdim if (!Imp1) 5990344779Sdim return Imp1.takeError(); 5991344779Sdim auto Imp2 = importSeq( 5992344779Sdim S->getForLoc(), S->getCoawaitLoc(), S->getColonLoc(), S->getRParenLoc()); 5993344779Sdim if (!Imp2) 5994344779Sdim return Imp2.takeError(); 5995344779Sdim 5996344779Sdim DeclStmt *ToRangeStmt, *ToBeginStmt, *ToEndStmt, *ToLoopVarStmt; 5997344779Sdim Expr *ToCond, *ToInc; 5998344779Sdim Stmt *ToInit, *ToBody; 5999344779Sdim std::tie( 6000344779Sdim ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt, 6001344779Sdim ToBody) = *Imp1; 6002344779Sdim SourceLocation ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc; 6003344779Sdim std::tie(ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc) = *Imp2; 6004344779Sdim 6005344779Sdim return new (Importer.getToContext()) CXXForRangeStmt( 6006344779Sdim ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt, 6007344779Sdim ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc); 6008288943Sdim} 6009288943Sdim 6010344779SdimExpectedStmt 6011344779SdimASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 6012344779Sdim auto Imp = importSeq( 6013344779Sdim S->getElement(), S->getCollection(), S->getBody(), 6014344779Sdim S->getForLoc(), S->getRParenLoc()); 6015344779Sdim if (!Imp) 6016344779Sdim return Imp.takeError(); 6017344779Sdim 6018344779Sdim Stmt *ToElement, *ToBody; 6019344779Sdim Expr *ToCollection; 6020344779Sdim SourceLocation ToForLoc, ToRParenLoc; 6021344779Sdim std::tie(ToElement, ToCollection, ToBody, ToForLoc, ToRParenLoc) = *Imp; 6022344779Sdim 6023344779Sdim return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement, 6024344779Sdim ToCollection, 6025344779Sdim ToBody, 6026344779Sdim ToForLoc, 6027288943Sdim ToRParenLoc); 6028288943Sdim} 6029288943Sdim 6030344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 6031344779Sdim auto Imp = importSeq( 6032344779Sdim S->getAtCatchLoc(), S->getRParenLoc(), S->getCatchParamDecl(), 6033344779Sdim S->getCatchBody()); 6034344779Sdim if (!Imp) 6035344779Sdim return Imp.takeError(); 6036344779Sdim 6037344779Sdim SourceLocation ToAtCatchLoc, ToRParenLoc; 6038344779Sdim VarDecl *ToCatchParamDecl; 6039344779Sdim Stmt *ToCatchBody; 6040344779Sdim std::tie(ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody) = *Imp; 6041344779Sdim 6042344779Sdim return new (Importer.getToContext()) ObjCAtCatchStmt ( 6043344779Sdim ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody); 6044288943Sdim} 6045288943Sdim 6046344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 6047344779Sdim ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc()); 6048344779Sdim if (!ToAtFinallyLocOrErr) 6049344779Sdim return ToAtFinallyLocOrErr.takeError(); 6050344779Sdim ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody()); 6051344779Sdim if (!ToAtFinallyStmtOrErr) 6052344779Sdim return ToAtFinallyStmtOrErr.takeError(); 6053344779Sdim return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr, 6054344779Sdim *ToAtFinallyStmtOrErr); 6055288943Sdim} 6056288943Sdim 6057344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 6058344779Sdim auto Imp = importSeq( 6059344779Sdim S->getAtTryLoc(), S->getTryBody(), S->getFinallyStmt()); 6060344779Sdim if (!Imp) 6061344779Sdim return Imp.takeError(); 6062344779Sdim 6063344779Sdim SourceLocation ToAtTryLoc; 6064344779Sdim Stmt *ToTryBody, *ToFinallyStmt; 6065344779Sdim std::tie(ToAtTryLoc, ToTryBody, ToFinallyStmt) = *Imp; 6066344779Sdim 6067288943Sdim SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 6068288943Sdim for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 6069288943Sdim ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 6070344779Sdim if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt)) 6071344779Sdim ToCatchStmts[CI] = *ToCatchStmtOrErr; 6072288943Sdim else 6073344779Sdim return ToCatchStmtOrErr.takeError(); 6074288943Sdim } 6075344779Sdim 6076288943Sdim return ObjCAtTryStmt::Create(Importer.getToContext(), 6077344779Sdim ToAtTryLoc, ToTryBody, 6078288943Sdim ToCatchStmts.begin(), ToCatchStmts.size(), 6079344779Sdim ToFinallyStmt); 6080288943Sdim} 6081288943Sdim 6082344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtSynchronizedStmt 6083288943Sdim (ObjCAtSynchronizedStmt *S) { 6084344779Sdim auto Imp = importSeq( 6085344779Sdim S->getAtSynchronizedLoc(), S->getSynchExpr(), S->getSynchBody()); 6086344779Sdim if (!Imp) 6087344779Sdim return Imp.takeError(); 6088344779Sdim 6089344779Sdim SourceLocation ToAtSynchronizedLoc; 6090344779Sdim Expr *ToSynchExpr; 6091344779Sdim Stmt *ToSynchBody; 6092344779Sdim std::tie(ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody) = *Imp; 6093344779Sdim 6094288943Sdim return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 6095288943Sdim ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 6096288943Sdim} 6097288943Sdim 6098344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 6099344779Sdim ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc()); 6100344779Sdim if (!ToThrowLocOrErr) 6101344779Sdim return ToThrowLocOrErr.takeError(); 6102344779Sdim ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr()); 6103344779Sdim if (!ToThrowExprOrErr) 6104344779Sdim return ToThrowExprOrErr.takeError(); 6105344779Sdim return new (Importer.getToContext()) ObjCAtThrowStmt( 6106344779Sdim *ToThrowLocOrErr, *ToThrowExprOrErr); 6107288943Sdim} 6108288943Sdim 6109344779SdimExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt( 6110344779Sdim ObjCAutoreleasePoolStmt *S) { 6111344779Sdim ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc()); 6112344779Sdim if (!ToAtLocOrErr) 6113344779Sdim return ToAtLocOrErr.takeError(); 6114344779Sdim ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt()); 6115344779Sdim if (!ToSubStmtOrErr) 6116344779Sdim return ToSubStmtOrErr.takeError(); 6117344779Sdim return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr, 6118344779Sdim *ToSubStmtOrErr); 6119288943Sdim} 6120288943Sdim 6121203955Srdivacky//---------------------------------------------------------------------------- 6122203955Srdivacky// Import Expressions 6123203955Srdivacky//---------------------------------------------------------------------------- 6124344779SdimExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) { 6125344779Sdim Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node) 6126344779Sdim << E->getStmtClassName(); 6127344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 6128203955Srdivacky} 6129203955Srdivacky 6130344779SdimExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) { 6131344779Sdim auto Imp = importSeq( 6132344779Sdim E->getBuiltinLoc(), E->getSubExpr(), E->getWrittenTypeInfo(), 6133344779Sdim E->getRParenLoc(), E->getType()); 6134344779Sdim if (!Imp) 6135344779Sdim return Imp.takeError(); 6136309124Sdim 6137344779Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6138344779Sdim Expr *ToSubExpr; 6139344779Sdim TypeSourceInfo *ToWrittenTypeInfo; 6140344779Sdim QualType ToType; 6141344779Sdim std::tie(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType) = 6142344779Sdim *Imp; 6143309124Sdim 6144309124Sdim return new (Importer.getToContext()) VAArgExpr( 6145344779Sdim ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType, 6146344779Sdim E->isMicrosoftABI()); 6147309124Sdim} 6148309124Sdim 6149353358SdimExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) { 6150353358Sdim auto Imp = importSeq(E->getCond(), E->getLHS(), E->getRHS(), 6151353358Sdim E->getBuiltinLoc(), E->getRParenLoc(), E->getType()); 6152353358Sdim if (!Imp) 6153353358Sdim return Imp.takeError(); 6154309124Sdim 6155353358Sdim Expr *ToCond; 6156353358Sdim Expr *ToLHS; 6157353358Sdim Expr *ToRHS; 6158353358Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6159353358Sdim QualType ToType; 6160353358Sdim std::tie(ToCond, ToLHS, ToRHS, ToBuiltinLoc, ToRParenLoc, ToType) = *Imp; 6161353358Sdim 6162353358Sdim ExprValueKind VK = E->getValueKind(); 6163353358Sdim ExprObjectKind OK = E->getObjectKind(); 6164353358Sdim 6165353358Sdim bool TypeDependent = ToCond->isTypeDependent(); 6166353358Sdim bool ValueDependent = ToCond->isValueDependent(); 6167353358Sdim 6168353358Sdim // The value of CondIsTrue only matters if the value is not 6169353358Sdim // condition-dependent. 6170353358Sdim bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue(); 6171353358Sdim 6172353358Sdim return new (Importer.getToContext()) 6173353358Sdim ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK, 6174353358Sdim ToRParenLoc, CondIsTrue, TypeDependent, ValueDependent); 6175353358Sdim} 6176353358Sdim 6177344779SdimExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { 6178344779Sdim ExpectedType TypeOrErr = import(E->getType()); 6179344779Sdim if (!TypeOrErr) 6180344779Sdim return TypeOrErr.takeError(); 6181344779Sdim 6182344779Sdim ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc()); 6183344779Sdim if (!BeginLocOrErr) 6184344779Sdim return BeginLocOrErr.takeError(); 6185344779Sdim 6186344779Sdim return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr); 6187309124Sdim} 6188309124Sdim 6189344779SdimExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) { 6190344779Sdim auto Imp = importSeq( 6191344779Sdim E->getBeginLoc(), E->getType(), E->getFunctionName()); 6192344779Sdim if (!Imp) 6193344779Sdim return Imp.takeError(); 6194309124Sdim 6195344779Sdim SourceLocation ToBeginLoc; 6196344779Sdim QualType ToType; 6197344779Sdim StringLiteral *ToFunctionName; 6198344779Sdim std::tie(ToBeginLoc, ToType, ToFunctionName) = *Imp; 6199309124Sdim 6200344779Sdim return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType, 6201344779Sdim E->getIdentKind(), ToFunctionName); 6202309124Sdim} 6203309124Sdim 6204344779SdimExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 6205344779Sdim auto Imp = importSeq( 6206344779Sdim E->getQualifierLoc(), E->getTemplateKeywordLoc(), E->getDecl(), 6207344779Sdim E->getLocation(), E->getType()); 6208344779Sdim if (!Imp) 6209344779Sdim return Imp.takeError(); 6210221345Sdim 6211344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 6212344779Sdim SourceLocation ToTemplateKeywordLoc, ToLocation; 6213344779Sdim ValueDecl *ToDecl; 6214344779Sdim QualType ToType; 6215344779Sdim std::tie(ToQualifierLoc, ToTemplateKeywordLoc, ToDecl, ToLocation, ToType) = 6216344779Sdim *Imp; 6217344779Sdim 6218344779Sdim NamedDecl *ToFoundD = nullptr; 6219221345Sdim if (E->getDecl() != E->getFoundDecl()) { 6220344779Sdim auto FoundDOrErr = import(E->getFoundDecl()); 6221344779Sdim if (!FoundDOrErr) 6222344779Sdim return FoundDOrErr.takeError(); 6223344779Sdim ToFoundD = *FoundDOrErr; 6224221345Sdim } 6225341825Sdim 6226314564Sdim TemplateArgumentListInfo ToTAInfo; 6227344779Sdim TemplateArgumentListInfo *ToResInfo = nullptr; 6228314564Sdim if (E->hasExplicitTemplateArgs()) { 6229344779Sdim if (Error Err = 6230344779Sdim ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 6231344779Sdim return std::move(Err); 6232344779Sdim ToResInfo = &ToTAInfo; 6233314564Sdim } 6234314564Sdim 6235344779Sdim auto *ToE = DeclRefExpr::Create( 6236344779Sdim Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl, 6237344779Sdim E->refersToEnclosingVariableOrCapture(), ToLocation, ToType, 6238353358Sdim E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse()); 6239226633Sdim if (E->hadMultipleCandidates()) 6240344779Sdim ToE->setHadMultipleCandidates(true); 6241344779Sdim return ToE; 6242204643Srdivacky} 6243204643Srdivacky 6244344779SdimExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 6245344779Sdim ExpectedType TypeOrErr = import(E->getType()); 6246344779Sdim if (!TypeOrErr) 6247344779Sdim return TypeOrErr.takeError(); 6248309124Sdim 6249344779Sdim return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr); 6250309124Sdim} 6251309124Sdim 6252344779SdimExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 6253344779Sdim ExpectedExpr ToInitOrErr = import(E->getInit()); 6254344779Sdim if (!ToInitOrErr) 6255344779Sdim return ToInitOrErr.takeError(); 6256309124Sdim 6257344779Sdim ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc()); 6258344779Sdim if (!ToEqualOrColonLocOrErr) 6259344779Sdim return ToEqualOrColonLocOrErr.takeError(); 6260309124Sdim 6261344779Sdim SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1); 6262309124Sdim // List elements from the second, the first is Init itself 6263344779Sdim for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) { 6264344779Sdim if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I))) 6265344779Sdim ToIndexExprs[I - 1] = *ToArgOrErr; 6266309124Sdim else 6267344779Sdim return ToArgOrErr.takeError(); 6268309124Sdim } 6269309124Sdim 6270344779Sdim SmallVector<Designator, 4> ToDesignators(E->size()); 6271344779Sdim if (Error Err = ImportContainerChecked(E->designators(), ToDesignators)) 6272344779Sdim return std::move(Err); 6273309124Sdim 6274309124Sdim return DesignatedInitExpr::Create( 6275344779Sdim Importer.getToContext(), ToDesignators, 6276344779Sdim ToIndexExprs, *ToEqualOrColonLocOrErr, 6277344779Sdim E->usesGNUSyntax(), *ToInitOrErr); 6278309124Sdim} 6279309124Sdim 6280344779SdimExpectedStmt 6281344779SdimASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 6282344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6283344779Sdim if (!ToTypeOrErr) 6284344779Sdim return ToTypeOrErr.takeError(); 6285309124Sdim 6286344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6287344779Sdim if (!ToLocationOrErr) 6288344779Sdim return ToLocationOrErr.takeError(); 6289344779Sdim 6290344779Sdim return new (Importer.getToContext()) CXXNullPtrLiteralExpr( 6291344779Sdim *ToTypeOrErr, *ToLocationOrErr); 6292309124Sdim} 6293309124Sdim 6294344779SdimExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 6295344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6296344779Sdim if (!ToTypeOrErr) 6297344779Sdim return ToTypeOrErr.takeError(); 6298203955Srdivacky 6299344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6300344779Sdim if (!ToLocationOrErr) 6301344779Sdim return ToLocationOrErr.takeError(); 6302344779Sdim 6303344779Sdim return IntegerLiteral::Create( 6304344779Sdim Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr); 6305203955Srdivacky} 6306203955Srdivacky 6307309124Sdim 6308344779SdimExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) { 6309344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6310344779Sdim if (!ToTypeOrErr) 6311344779Sdim return ToTypeOrErr.takeError(); 6312344779Sdim 6313344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6314344779Sdim if (!ToLocationOrErr) 6315344779Sdim return ToLocationOrErr.takeError(); 6316344779Sdim 6317344779Sdim return FloatingLiteral::Create( 6318344779Sdim Importer.getToContext(), E->getValue(), E->isExact(), 6319344779Sdim *ToTypeOrErr, *ToLocationOrErr); 6320309124Sdim} 6321309124Sdim 6322344779SdimExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) { 6323344779Sdim auto ToTypeOrErr = import(E->getType()); 6324344779Sdim if (!ToTypeOrErr) 6325344779Sdim return ToTypeOrErr.takeError(); 6326276479Sdim 6327344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 6328344779Sdim if (!ToSubExprOrErr) 6329344779Sdim return ToSubExprOrErr.takeError(); 6330344779Sdim 6331344779Sdim return new (Importer.getToContext()) ImaginaryLiteral( 6332344779Sdim *ToSubExprOrErr, *ToTypeOrErr); 6333204643Srdivacky} 6334204643Srdivacky 6335344779SdimExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 6336344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6337344779Sdim if (!ToTypeOrErr) 6338344779Sdim return ToTypeOrErr.takeError(); 6339309124Sdim 6340344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6341344779Sdim if (!ToLocationOrErr) 6342344779Sdim return ToLocationOrErr.takeError(); 6343309124Sdim 6344344779Sdim return new (Importer.getToContext()) CharacterLiteral( 6345344779Sdim E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr); 6346309124Sdim} 6347309124Sdim 6348344779SdimExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) { 6349344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6350344779Sdim if (!ToTypeOrErr) 6351344779Sdim return ToTypeOrErr.takeError(); 6352309124Sdim 6353344779Sdim SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated()); 6354344779Sdim if (Error Err = ImportArrayChecked( 6355344779Sdim E->tokloc_begin(), E->tokloc_end(), ToLocations.begin())) 6356344779Sdim return std::move(Err); 6357309124Sdim 6358344779Sdim return StringLiteral::Create( 6359344779Sdim Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(), 6360344779Sdim *ToTypeOrErr, ToLocations.data(), ToLocations.size()); 6361344779Sdim} 6362309124Sdim 6363344779SdimExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 6364344779Sdim auto Imp = importSeq( 6365344779Sdim E->getLParenLoc(), E->getTypeSourceInfo(), E->getType(), 6366344779Sdim E->getInitializer()); 6367344779Sdim if (!Imp) 6368344779Sdim return Imp.takeError(); 6369344779Sdim 6370344779Sdim SourceLocation ToLParenLoc; 6371344779Sdim TypeSourceInfo *ToTypeSourceInfo; 6372344779Sdim QualType ToType; 6373344779Sdim Expr *ToInitializer; 6374344779Sdim std::tie(ToLParenLoc, ToTypeSourceInfo, ToType, ToInitializer) = *Imp; 6375344779Sdim 6376309124Sdim return new (Importer.getToContext()) CompoundLiteralExpr( 6377344779Sdim ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(), 6378344779Sdim ToInitializer, E->isFileScope()); 6379309124Sdim} 6380309124Sdim 6381344779SdimExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) { 6382344779Sdim auto Imp = importSeq( 6383344779Sdim E->getBuiltinLoc(), E->getType(), E->getRParenLoc()); 6384344779Sdim if (!Imp) 6385344779Sdim return Imp.takeError(); 6386309124Sdim 6387344779Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6388344779Sdim QualType ToType; 6389344779Sdim std::tie(ToBuiltinLoc, ToType, ToRParenLoc) = *Imp; 6390309124Sdim 6391344779Sdim SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs()); 6392344779Sdim if (Error Err = ImportArrayChecked( 6393344779Sdim E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(), 6394344779Sdim ToExprs.begin())) 6395344779Sdim return std::move(Err); 6396344779Sdim 6397309124Sdim return new (Importer.getToContext()) AtomicExpr( 6398344779Sdim ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc); 6399309124Sdim} 6400309124Sdim 6401344779SdimExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) { 6402344779Sdim auto Imp = importSeq( 6403344779Sdim E->getAmpAmpLoc(), E->getLabelLoc(), E->getLabel(), E->getType()); 6404344779Sdim if (!Imp) 6405344779Sdim return Imp.takeError(); 6406309124Sdim 6407344779Sdim SourceLocation ToAmpAmpLoc, ToLabelLoc; 6408344779Sdim LabelDecl *ToLabel; 6409344779Sdim QualType ToType; 6410344779Sdim std::tie(ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType) = *Imp; 6411309124Sdim 6412309124Sdim return new (Importer.getToContext()) AddrLabelExpr( 6413344779Sdim ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType); 6414309124Sdim} 6415309124Sdim 6416344779SdimExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) { 6417344779Sdim auto Imp = importSeq(E->getSubExpr()); 6418344779Sdim if (!Imp) 6419344779Sdim return Imp.takeError(); 6420276479Sdim 6421344779Sdim Expr *ToSubExpr; 6422344779Sdim std::tie(ToSubExpr) = *Imp; 6423344779Sdim 6424353358Sdim // TODO : Handle APValue::ValueKind that require importing. 6425353358Sdim APValue::ValueKind Kind = E->getResultAPValueKind(); 6426353358Sdim if (Kind == APValue::Int || Kind == APValue::Float || 6427353358Sdim Kind == APValue::FixedPoint || Kind == APValue::ComplexFloat || 6428353358Sdim Kind == APValue::ComplexInt) 6429353358Sdim return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, 6430353358Sdim E->getAPValueResult()); 6431344779Sdim return ConstantExpr::Create(Importer.getToContext(), ToSubExpr); 6432344779Sdim} 6433344779Sdim 6434344779SdimExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 6435344779Sdim auto Imp = importSeq(E->getLParen(), E->getRParen(), E->getSubExpr()); 6436344779Sdim if (!Imp) 6437344779Sdim return Imp.takeError(); 6438344779Sdim 6439344779Sdim SourceLocation ToLParen, ToRParen; 6440344779Sdim Expr *ToSubExpr; 6441344779Sdim std::tie(ToLParen, ToRParen, ToSubExpr) = *Imp; 6442344779Sdim 6443341825Sdim return new (Importer.getToContext()) 6444344779Sdim ParenExpr(ToLParen, ToRParen, ToSubExpr); 6445204643Srdivacky} 6446204643Srdivacky 6447344779SdimExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) { 6448344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumExprs()); 6449344779Sdim if (Error Err = ImportContainerChecked(E->exprs(), ToExprs)) 6450344779Sdim return std::move(Err); 6451309124Sdim 6452344779Sdim ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc()); 6453344779Sdim if (!ToLParenLocOrErr) 6454344779Sdim return ToLParenLocOrErr.takeError(); 6455344779Sdim 6456344779Sdim ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc()); 6457344779Sdim if (!ToRParenLocOrErr) 6458344779Sdim return ToRParenLocOrErr.takeError(); 6459344779Sdim 6460344779Sdim return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr, 6461344779Sdim ToExprs, *ToRParenLocOrErr); 6462309124Sdim} 6463309124Sdim 6464344779SdimExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) { 6465344779Sdim auto Imp = importSeq( 6466344779Sdim E->getSubStmt(), E->getType(), E->getLParenLoc(), E->getRParenLoc()); 6467344779Sdim if (!Imp) 6468344779Sdim return Imp.takeError(); 6469309124Sdim 6470344779Sdim CompoundStmt *ToSubStmt; 6471344779Sdim QualType ToType; 6472344779Sdim SourceLocation ToLParenLoc, ToRParenLoc; 6473344779Sdim std::tie(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc) = *Imp; 6474309124Sdim 6475344779Sdim return new (Importer.getToContext()) StmtExpr( 6476344779Sdim ToSubStmt, ToType, ToLParenLoc, ToRParenLoc); 6477309124Sdim} 6478309124Sdim 6479344779SdimExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 6480344779Sdim auto Imp = importSeq( 6481344779Sdim E->getSubExpr(), E->getType(), E->getOperatorLoc()); 6482344779Sdim if (!Imp) 6483344779Sdim return Imp.takeError(); 6484204643Srdivacky 6485344779Sdim Expr *ToSubExpr; 6486344779Sdim QualType ToType; 6487344779Sdim SourceLocation ToOperatorLoc; 6488344779Sdim std::tie(ToSubExpr, ToType, ToOperatorLoc) = *Imp; 6489276479Sdim 6490341825Sdim return new (Importer.getToContext()) UnaryOperator( 6491344779Sdim ToSubExpr, E->getOpcode(), ToType, E->getValueKind(), E->getObjectKind(), 6492344779Sdim ToOperatorLoc, E->canOverflow()); 6493204643Srdivacky} 6494204643Srdivacky 6495344779SdimExpectedStmt 6496341825SdimASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 6497344779Sdim auto Imp = importSeq(E->getType(), E->getOperatorLoc(), E->getRParenLoc()); 6498344779Sdim if (!Imp) 6499344779Sdim return Imp.takeError(); 6500341825Sdim 6501344779Sdim QualType ToType; 6502344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 6503344779Sdim std::tie(ToType, ToOperatorLoc, ToRParenLoc) = *Imp; 6504344779Sdim 6505204643Srdivacky if (E->isArgumentType()) { 6506344779Sdim Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr = 6507344779Sdim import(E->getArgumentTypeInfo()); 6508344779Sdim if (!ToArgumentTypeInfoOrErr) 6509344779Sdim return ToArgumentTypeInfoOrErr.takeError(); 6510276479Sdim 6511344779Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr( 6512344779Sdim E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc, 6513344779Sdim ToRParenLoc); 6514204643Srdivacky } 6515341825Sdim 6516344779Sdim ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr()); 6517344779Sdim if (!ToArgumentExprOrErr) 6518344779Sdim return ToArgumentExprOrErr.takeError(); 6519276479Sdim 6520344779Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr( 6521344779Sdim E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc); 6522204643Srdivacky} 6523204643Srdivacky 6524344779SdimExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 6525344779Sdim auto Imp = importSeq( 6526344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getOperatorLoc()); 6527344779Sdim if (!Imp) 6528344779Sdim return Imp.takeError(); 6529204643Srdivacky 6530344779Sdim Expr *ToLHS, *ToRHS; 6531344779Sdim QualType ToType; 6532344779Sdim SourceLocation ToOperatorLoc; 6533344779Sdim std::tie(ToLHS, ToRHS, ToType, ToOperatorLoc) = *Imp; 6534276479Sdim 6535344779Sdim return new (Importer.getToContext()) BinaryOperator( 6536344779Sdim ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(), 6537344779Sdim E->getObjectKind(), ToOperatorLoc, E->getFPFeatures()); 6538204643Srdivacky} 6539204643Srdivacky 6540344779SdimExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) { 6541344779Sdim auto Imp = importSeq( 6542344779Sdim E->getCond(), E->getQuestionLoc(), E->getLHS(), E->getColonLoc(), 6543344779Sdim E->getRHS(), E->getType()); 6544344779Sdim if (!Imp) 6545344779Sdim return Imp.takeError(); 6546309124Sdim 6547344779Sdim Expr *ToCond, *ToLHS, *ToRHS; 6548344779Sdim SourceLocation ToQuestionLoc, ToColonLoc; 6549344779Sdim QualType ToType; 6550344779Sdim std::tie(ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType) = *Imp; 6551309124Sdim 6552309124Sdim return new (Importer.getToContext()) ConditionalOperator( 6553344779Sdim ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType, 6554344779Sdim E->getValueKind(), E->getObjectKind()); 6555309124Sdim} 6556309124Sdim 6557344779SdimExpectedStmt ASTNodeImporter::VisitBinaryConditionalOperator( 6558309124Sdim BinaryConditionalOperator *E) { 6559344779Sdim auto Imp = importSeq( 6560344779Sdim E->getCommon(), E->getOpaqueValue(), E->getCond(), E->getTrueExpr(), 6561344779Sdim E->getFalseExpr(), E->getQuestionLoc(), E->getColonLoc(), E->getType()); 6562344779Sdim if (!Imp) 6563344779Sdim return Imp.takeError(); 6564309124Sdim 6565344779Sdim Expr *ToCommon, *ToCond, *ToTrueExpr, *ToFalseExpr; 6566344779Sdim OpaqueValueExpr *ToOpaqueValue; 6567344779Sdim SourceLocation ToQuestionLoc, ToColonLoc; 6568344779Sdim QualType ToType; 6569344779Sdim std::tie( 6570344779Sdim ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr, ToQuestionLoc, 6571344779Sdim ToColonLoc, ToType) = *Imp; 6572309124Sdim 6573309124Sdim return new (Importer.getToContext()) BinaryConditionalOperator( 6574344779Sdim ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr, 6575344779Sdim ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(), 6576344779Sdim E->getObjectKind()); 6577309124Sdim} 6578309124Sdim 6579344779SdimExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 6580344779Sdim auto Imp = importSeq( 6581344779Sdim E->getBeginLoc(), E->getQueriedTypeSourceInfo(), 6582344779Sdim E->getDimensionExpression(), E->getEndLoc(), E->getType()); 6583344779Sdim if (!Imp) 6584344779Sdim return Imp.takeError(); 6585314564Sdim 6586344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6587344779Sdim TypeSourceInfo *ToQueriedTypeSourceInfo; 6588344779Sdim Expr *ToDimensionExpression; 6589344779Sdim QualType ToType; 6590344779Sdim std::tie( 6591344779Sdim ToBeginLoc, ToQueriedTypeSourceInfo, ToDimensionExpression, ToEndLoc, 6592344779Sdim ToType) = *Imp; 6593314564Sdim 6594314564Sdim return new (Importer.getToContext()) ArrayTypeTraitExpr( 6595344779Sdim ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(), 6596344779Sdim ToDimensionExpression, ToEndLoc, ToType); 6597314564Sdim} 6598314564Sdim 6599344779SdimExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 6600344779Sdim auto Imp = importSeq( 6601344779Sdim E->getBeginLoc(), E->getQueriedExpression(), E->getEndLoc(), E->getType()); 6602344779Sdim if (!Imp) 6603344779Sdim return Imp.takeError(); 6604314564Sdim 6605344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6606344779Sdim Expr *ToQueriedExpression; 6607344779Sdim QualType ToType; 6608344779Sdim std::tie(ToBeginLoc, ToQueriedExpression, ToEndLoc, ToType) = *Imp; 6609314564Sdim 6610314564Sdim return new (Importer.getToContext()) ExpressionTraitExpr( 6611344779Sdim ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(), 6612344779Sdim ToEndLoc, ToType); 6613314564Sdim} 6614314564Sdim 6615344779SdimExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 6616344779Sdim auto Imp = importSeq( 6617344779Sdim E->getLocation(), E->getType(), E->getSourceExpr()); 6618344779Sdim if (!Imp) 6619344779Sdim return Imp.takeError(); 6620309124Sdim 6621344779Sdim SourceLocation ToLocation; 6622344779Sdim QualType ToType; 6623344779Sdim Expr *ToSourceExpr; 6624344779Sdim std::tie(ToLocation, ToType, ToSourceExpr) = *Imp; 6625309124Sdim 6626309124Sdim return new (Importer.getToContext()) OpaqueValueExpr( 6627344779Sdim ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr); 6628309124Sdim} 6629309124Sdim 6630344779SdimExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 6631344779Sdim auto Imp = importSeq( 6632344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getRBracketLoc()); 6633344779Sdim if (!Imp) 6634344779Sdim return Imp.takeError(); 6635314564Sdim 6636344779Sdim Expr *ToLHS, *ToRHS; 6637344779Sdim SourceLocation ToRBracketLoc; 6638344779Sdim QualType ToType; 6639344779Sdim std::tie(ToLHS, ToRHS, ToType, ToRBracketLoc) = *Imp; 6640314564Sdim 6641314564Sdim return new (Importer.getToContext()) ArraySubscriptExpr( 6642344779Sdim ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(), 6643344779Sdim ToRBracketLoc); 6644314564Sdim} 6645314564Sdim 6646344779SdimExpectedStmt 6647344779SdimASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 6648344779Sdim auto Imp = importSeq( 6649344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getComputationLHSType(), 6650344779Sdim E->getComputationResultType(), E->getOperatorLoc()); 6651344779Sdim if (!Imp) 6652344779Sdim return Imp.takeError(); 6653276479Sdim 6654344779Sdim Expr *ToLHS, *ToRHS; 6655344779Sdim QualType ToType, ToComputationLHSType, ToComputationResultType; 6656344779Sdim SourceLocation ToOperatorLoc; 6657344779Sdim std::tie(ToLHS, ToRHS, ToType, ToComputationLHSType, ToComputationResultType, 6658344779Sdim ToOperatorLoc) = *Imp; 6659276479Sdim 6660344779Sdim return new (Importer.getToContext()) CompoundAssignOperator( 6661344779Sdim ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(), 6662344779Sdim E->getObjectKind(), ToComputationLHSType, ToComputationResultType, 6663344779Sdim ToOperatorLoc, E->getFPFeatures()); 6664204643Srdivacky} 6665204643Srdivacky 6666344779SdimExpected<CXXCastPath> 6667344779SdimASTNodeImporter::ImportCastPath(CastExpr *CE) { 6668344779Sdim CXXCastPath Path; 6669314564Sdim for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) { 6670344779Sdim if (auto SpecOrErr = import(*I)) 6671344779Sdim Path.push_back(*SpecOrErr); 6672314564Sdim else 6673344779Sdim return SpecOrErr.takeError(); 6674314564Sdim } 6675344779Sdim return Path; 6676212904Sdim} 6677212904Sdim 6678344779SdimExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 6679344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6680344779Sdim if (!ToTypeOrErr) 6681344779Sdim return ToTypeOrErr.takeError(); 6682203955Srdivacky 6683344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 6684344779Sdim if (!ToSubExprOrErr) 6685344779Sdim return ToSubExprOrErr.takeError(); 6686212904Sdim 6687344779Sdim Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E); 6688344779Sdim if (!ToBasePathOrErr) 6689344779Sdim return ToBasePathOrErr.takeError(); 6690212904Sdim 6691344779Sdim return ImplicitCastExpr::Create( 6692344779Sdim Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr, 6693344779Sdim &(*ToBasePathOrErr), E->getValueKind()); 6694203955Srdivacky} 6695203955Srdivacky 6696344779SdimExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 6697344779Sdim auto Imp1 = importSeq( 6698344779Sdim E->getType(), E->getSubExpr(), E->getTypeInfoAsWritten()); 6699344779Sdim if (!Imp1) 6700344779Sdim return Imp1.takeError(); 6701276479Sdim 6702344779Sdim QualType ToType; 6703344779Sdim Expr *ToSubExpr; 6704344779Sdim TypeSourceInfo *ToTypeInfoAsWritten; 6705344779Sdim std::tie(ToType, ToSubExpr, ToTypeInfoAsWritten) = *Imp1; 6706204643Srdivacky 6707344779Sdim Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E); 6708344779Sdim if (!ToBasePathOrErr) 6709344779Sdim return ToBasePathOrErr.takeError(); 6710344779Sdim CXXCastPath *ToBasePath = &(*ToBasePathOrErr); 6711276479Sdim 6712314564Sdim switch (E->getStmtClass()) { 6713314564Sdim case Stmt::CStyleCastExprClass: { 6714341825Sdim auto *CCE = cast<CStyleCastExpr>(E); 6715344779Sdim ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc()); 6716344779Sdim if (!ToLParenLocOrErr) 6717344779Sdim return ToLParenLocOrErr.takeError(); 6718344779Sdim ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc()); 6719344779Sdim if (!ToRParenLocOrErr) 6720344779Sdim return ToRParenLocOrErr.takeError(); 6721344779Sdim return CStyleCastExpr::Create( 6722344779Sdim Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(), 6723344779Sdim ToSubExpr, ToBasePath, ToTypeInfoAsWritten, *ToLParenLocOrErr, 6724344779Sdim *ToRParenLocOrErr); 6725314564Sdim } 6726314564Sdim 6727314564Sdim case Stmt::CXXFunctionalCastExprClass: { 6728341825Sdim auto *FCE = cast<CXXFunctionalCastExpr>(E); 6729344779Sdim ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc()); 6730344779Sdim if (!ToLParenLocOrErr) 6731344779Sdim return ToLParenLocOrErr.takeError(); 6732344779Sdim ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc()); 6733344779Sdim if (!ToRParenLocOrErr) 6734344779Sdim return ToRParenLocOrErr.takeError(); 6735344779Sdim return CXXFunctionalCastExpr::Create( 6736344779Sdim Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten, 6737344779Sdim E->getCastKind(), ToSubExpr, ToBasePath, *ToLParenLocOrErr, 6738344779Sdim *ToRParenLocOrErr); 6739314564Sdim } 6740314564Sdim 6741314564Sdim case Stmt::ObjCBridgedCastExprClass: { 6742344779Sdim auto *OCE = cast<ObjCBridgedCastExpr>(E); 6743344779Sdim ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc()); 6744344779Sdim if (!ToLParenLocOrErr) 6745344779Sdim return ToLParenLocOrErr.takeError(); 6746344779Sdim ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc()); 6747344779Sdim if (!ToBridgeKeywordLocOrErr) 6748344779Sdim return ToBridgeKeywordLocOrErr.takeError(); 6749344779Sdim return new (Importer.getToContext()) ObjCBridgedCastExpr( 6750344779Sdim *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(), 6751344779Sdim *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr); 6752314564Sdim } 6753314564Sdim default: 6754314564Sdim llvm_unreachable("Cast expression of unsupported type!"); 6755344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 6756314564Sdim } 6757204643Srdivacky} 6758204643Srdivacky 6759344779SdimExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) { 6760344779Sdim SmallVector<OffsetOfNode, 4> ToNodes; 6761344779Sdim for (int I = 0, N = E->getNumComponents(); I < N; ++I) { 6762344779Sdim const OffsetOfNode &FromNode = E->getComponent(I); 6763314564Sdim 6764344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6765344779Sdim if (FromNode.getKind() != OffsetOfNode::Base) { 6766344779Sdim auto Imp = importSeq(FromNode.getBeginLoc(), FromNode.getEndLoc()); 6767344779Sdim if (!Imp) 6768344779Sdim return Imp.takeError(); 6769344779Sdim std::tie(ToBeginLoc, ToEndLoc) = *Imp; 6770344779Sdim } 6771314564Sdim 6772344779Sdim switch (FromNode.getKind()) { 6773314564Sdim case OffsetOfNode::Array: 6774344779Sdim ToNodes.push_back( 6775344779Sdim OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc)); 6776314564Sdim break; 6777314564Sdim case OffsetOfNode::Base: { 6778344779Sdim auto ToBSOrErr = import(FromNode.getBase()); 6779344779Sdim if (!ToBSOrErr) 6780344779Sdim return ToBSOrErr.takeError(); 6781344779Sdim ToNodes.push_back(OffsetOfNode(*ToBSOrErr)); 6782314564Sdim break; 6783314564Sdim } 6784314564Sdim case OffsetOfNode::Field: { 6785344779Sdim auto ToFieldOrErr = import(FromNode.getField()); 6786344779Sdim if (!ToFieldOrErr) 6787344779Sdim return ToFieldOrErr.takeError(); 6788344779Sdim ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc)); 6789314564Sdim break; 6790314564Sdim } 6791314564Sdim case OffsetOfNode::Identifier: { 6792344779Sdim IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName()); 6793344779Sdim ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc)); 6794314564Sdim break; 6795314564Sdim } 6796314564Sdim } 6797314564Sdim } 6798314564Sdim 6799344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumExpressions()); 6800344779Sdim for (int I = 0, N = E->getNumExpressions(); I < N; ++I) { 6801344779Sdim ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I)); 6802344779Sdim if (!ToIndexExprOrErr) 6803344779Sdim return ToIndexExprOrErr.takeError(); 6804344779Sdim ToExprs[I] = *ToIndexExprOrErr; 6805314564Sdim } 6806314564Sdim 6807344779Sdim auto Imp = importSeq( 6808344779Sdim E->getType(), E->getTypeSourceInfo(), E->getOperatorLoc(), 6809344779Sdim E->getRParenLoc()); 6810344779Sdim if (!Imp) 6811344779Sdim return Imp.takeError(); 6812314564Sdim 6813344779Sdim QualType ToType; 6814344779Sdim TypeSourceInfo *ToTypeSourceInfo; 6815344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 6816344779Sdim std::tie(ToType, ToTypeSourceInfo, ToOperatorLoc, ToRParenLoc) = *Imp; 6817344779Sdim 6818344779Sdim return OffsetOfExpr::Create( 6819344779Sdim Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes, 6820344779Sdim ToExprs, ToRParenLoc); 6821314564Sdim} 6822314564Sdim 6823344779SdimExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 6824344779Sdim auto Imp = importSeq( 6825344779Sdim E->getType(), E->getOperand(), E->getBeginLoc(), E->getEndLoc()); 6826344779Sdim if (!Imp) 6827344779Sdim return Imp.takeError(); 6828314564Sdim 6829344779Sdim QualType ToType; 6830344779Sdim Expr *ToOperand; 6831344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6832344779Sdim std::tie(ToType, ToOperand, ToBeginLoc, ToEndLoc) = *Imp; 6833314564Sdim 6834344779Sdim CanThrowResult ToCanThrow; 6835314564Sdim if (E->isValueDependent()) 6836344779Sdim ToCanThrow = CT_Dependent; 6837314564Sdim else 6838344779Sdim ToCanThrow = E->getValue() ? CT_Can : CT_Cannot; 6839314564Sdim 6840314564Sdim return new (Importer.getToContext()) CXXNoexceptExpr( 6841344779Sdim ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc); 6842314564Sdim} 6843314564Sdim 6844344779SdimExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) { 6845344779Sdim auto Imp = importSeq(E->getSubExpr(), E->getType(), E->getThrowLoc()); 6846344779Sdim if (!Imp) 6847344779Sdim return Imp.takeError(); 6848314564Sdim 6849344779Sdim Expr *ToSubExpr; 6850344779Sdim QualType ToType; 6851344779Sdim SourceLocation ToThrowLoc; 6852344779Sdim std::tie(ToSubExpr, ToType, ToThrowLoc) = *Imp; 6853314564Sdim 6854314564Sdim return new (Importer.getToContext()) CXXThrowExpr( 6855344779Sdim ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope()); 6856314564Sdim} 6857314564Sdim 6858344779SdimExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 6859344779Sdim ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation()); 6860344779Sdim if (!ToUsedLocOrErr) 6861344779Sdim return ToUsedLocOrErr.takeError(); 6862314564Sdim 6863344779Sdim auto ToParamOrErr = import(E->getParam()); 6864344779Sdim if (!ToParamOrErr) 6865344779Sdim return ToParamOrErr.takeError(); 6866344779Sdim 6867353358Sdim auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext()); 6868353358Sdim if (!UsedContextOrErr) 6869353358Sdim return UsedContextOrErr.takeError(); 6870353358Sdim 6871314564Sdim return CXXDefaultArgExpr::Create( 6872353358Sdim Importer.getToContext(), *ToUsedLocOrErr, *ToParamOrErr, *UsedContextOrErr); 6873314564Sdim} 6874314564Sdim 6875344779SdimExpectedStmt 6876344779SdimASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 6877344779Sdim auto Imp = importSeq( 6878344779Sdim E->getType(), E->getTypeSourceInfo(), E->getRParenLoc()); 6879344779Sdim if (!Imp) 6880344779Sdim return Imp.takeError(); 6881314564Sdim 6882344779Sdim QualType ToType; 6883344779Sdim TypeSourceInfo *ToTypeSourceInfo; 6884344779Sdim SourceLocation ToRParenLoc; 6885344779Sdim std::tie(ToType, ToTypeSourceInfo, ToRParenLoc) = *Imp; 6886314564Sdim 6887314564Sdim return new (Importer.getToContext()) CXXScalarValueInitExpr( 6888344779Sdim ToType, ToTypeSourceInfo, ToRParenLoc); 6889314564Sdim} 6890314564Sdim 6891344779SdimExpectedStmt 6892344779SdimASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 6893344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 6894344779Sdim if (!ToSubExprOrErr) 6895344779Sdim return ToSubExprOrErr.takeError(); 6896314564Sdim 6897344779Sdim auto ToDtorOrErr = import(E->getTemporary()->getDestructor()); 6898344779Sdim if (!ToDtorOrErr) 6899344779Sdim return ToDtorOrErr.takeError(); 6900314564Sdim 6901314564Sdim ASTContext &ToCtx = Importer.getToContext(); 6902344779Sdim CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr); 6903344779Sdim return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr); 6904314564Sdim} 6905314564Sdim 6906344779SdimExpectedStmt 6907344779SdimASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 6908344779Sdim auto Imp = importSeq( 6909344779Sdim E->getConstructor(), E->getType(), E->getTypeSourceInfo(), 6910344779Sdim E->getParenOrBraceRange()); 6911344779Sdim if (!Imp) 6912344779Sdim return Imp.takeError(); 6913314564Sdim 6914344779Sdim CXXConstructorDecl *ToConstructor; 6915344779Sdim QualType ToType; 6916344779Sdim TypeSourceInfo *ToTypeSourceInfo; 6917344779Sdim SourceRange ToParenOrBraceRange; 6918344779Sdim std::tie(ToConstructor, ToType, ToTypeSourceInfo, ToParenOrBraceRange) = *Imp; 6919341825Sdim 6920344779Sdim SmallVector<Expr *, 8> ToArgs(E->getNumArgs()); 6921344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 6922344779Sdim return std::move(Err); 6923314564Sdim 6924344779Sdim return CXXTemporaryObjectExpr::Create( 6925344779Sdim Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs, 6926344779Sdim ToParenOrBraceRange, E->hadMultipleCandidates(), 6927344779Sdim E->isListInitialization(), E->isStdInitListInitialization(), 6928344779Sdim E->requiresZeroInitialization()); 6929314564Sdim} 6930314564Sdim 6931344779SdimExpectedStmt 6932314564SdimASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 6933344779Sdim auto Imp = importSeq( 6934344779Sdim E->getType(), E->GetTemporaryExpr(), E->getExtendingDecl()); 6935344779Sdim if (!Imp) 6936344779Sdim return Imp.takeError(); 6937314564Sdim 6938344779Sdim QualType ToType; 6939344779Sdim Expr *ToTemporaryExpr; 6940344779Sdim const ValueDecl *ToExtendingDecl; 6941344779Sdim std::tie(ToType, ToTemporaryExpr, ToExtendingDecl) = *Imp; 6942314564Sdim 6943314564Sdim auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr( 6944344779Sdim ToType, ToTemporaryExpr, E->isBoundToLvalueReference()); 6945314564Sdim 6946314564Sdim // FIXME: Should ManglingNumber get numbers associated with 'to' context? 6947344779Sdim ToMTE->setExtendingDecl(ToExtendingDecl, E->getManglingNumber()); 6948314564Sdim return ToMTE; 6949314564Sdim} 6950314564Sdim 6951344779SdimExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) { 6952344779Sdim auto Imp = importSeq( 6953344779Sdim E->getType(), E->getPattern(), E->getEllipsisLoc()); 6954344779Sdim if (!Imp) 6955344779Sdim return Imp.takeError(); 6956327952Sdim 6957344779Sdim QualType ToType; 6958344779Sdim Expr *ToPattern; 6959344779Sdim SourceLocation ToEllipsisLoc; 6960344779Sdim std::tie(ToType, ToPattern, ToEllipsisLoc) = *Imp; 6961327952Sdim 6962327952Sdim return new (Importer.getToContext()) PackExpansionExpr( 6963344779Sdim ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions()); 6964327952Sdim} 6965327952Sdim 6966344779SdimExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 6967344779Sdim auto Imp = importSeq( 6968344779Sdim E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc()); 6969344779Sdim if (!Imp) 6970344779Sdim return Imp.takeError(); 6971341825Sdim 6972344779Sdim SourceLocation ToOperatorLoc, ToPackLoc, ToRParenLoc; 6973344779Sdim NamedDecl *ToPack; 6974344779Sdim std::tie(ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc) = *Imp; 6975344779Sdim 6976341825Sdim Optional<unsigned> Length; 6977341825Sdim if (!E->isValueDependent()) 6978341825Sdim Length = E->getPackLength(); 6979341825Sdim 6980344779Sdim SmallVector<TemplateArgument, 8> ToPartialArguments; 6981341825Sdim if (E->isPartiallySubstituted()) { 6982344779Sdim if (Error Err = ImportTemplateArguments( 6983344779Sdim E->getPartialArguments().data(), 6984344779Sdim E->getPartialArguments().size(), 6985344779Sdim ToPartialArguments)) 6986344779Sdim return std::move(Err); 6987341825Sdim } 6988341825Sdim 6989341825Sdim return SizeOfPackExpr::Create( 6990344779Sdim Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc, 6991344779Sdim Length, ToPartialArguments); 6992341825Sdim} 6993341825Sdim 6994314564Sdim 6995344779SdimExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) { 6996344779Sdim auto Imp = importSeq( 6997344779Sdim E->getOperatorNew(), E->getOperatorDelete(), E->getTypeIdParens(), 6998344779Sdim E->getArraySize(), E->getInitializer(), E->getType(), 6999344779Sdim E->getAllocatedTypeSourceInfo(), E->getSourceRange(), 7000344779Sdim E->getDirectInitRange()); 7001344779Sdim if (!Imp) 7002344779Sdim return Imp.takeError(); 7003314564Sdim 7004344779Sdim FunctionDecl *ToOperatorNew, *ToOperatorDelete; 7005344779Sdim SourceRange ToTypeIdParens, ToSourceRange, ToDirectInitRange; 7006353358Sdim Optional<Expr *> ToArraySize; 7007353358Sdim Expr *ToInitializer; 7008344779Sdim QualType ToType; 7009344779Sdim TypeSourceInfo *ToAllocatedTypeSourceInfo; 7010344779Sdim std::tie( 7011344779Sdim ToOperatorNew, ToOperatorDelete, ToTypeIdParens, ToArraySize, ToInitializer, 7012344779Sdim ToType, ToAllocatedTypeSourceInfo, ToSourceRange, ToDirectInitRange) = *Imp; 7013314564Sdim 7014344779Sdim SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs()); 7015344779Sdim if (Error Err = 7016344779Sdim ImportContainerChecked(E->placement_arguments(), ToPlacementArgs)) 7017344779Sdim return std::move(Err); 7018314564Sdim 7019344779Sdim return CXXNewExpr::Create( 7020344779Sdim Importer.getToContext(), E->isGlobalNew(), ToOperatorNew, 7021344779Sdim ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(), 7022344779Sdim ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(), 7023344779Sdim ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange, 7024344779Sdim ToDirectInitRange); 7025314564Sdim} 7026314564Sdim 7027344779SdimExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 7028344779Sdim auto Imp = importSeq( 7029344779Sdim E->getType(), E->getOperatorDelete(), E->getArgument(), E->getBeginLoc()); 7030344779Sdim if (!Imp) 7031344779Sdim return Imp.takeError(); 7032314564Sdim 7033344779Sdim QualType ToType; 7034344779Sdim FunctionDecl *ToOperatorDelete; 7035344779Sdim Expr *ToArgument; 7036344779Sdim SourceLocation ToBeginLoc; 7037344779Sdim std::tie(ToType, ToOperatorDelete, ToArgument, ToBeginLoc) = *Imp; 7038314564Sdim 7039314564Sdim return new (Importer.getToContext()) CXXDeleteExpr( 7040344779Sdim ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(), 7041344779Sdim E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument, 7042344779Sdim ToBeginLoc); 7043314564Sdim} 7044314564Sdim 7045344779SdimExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 7046344779Sdim auto Imp = importSeq( 7047344779Sdim E->getType(), E->getLocation(), E->getConstructor(), 7048344779Sdim E->getParenOrBraceRange()); 7049344779Sdim if (!Imp) 7050344779Sdim return Imp.takeError(); 7051288943Sdim 7052344779Sdim QualType ToType; 7053344779Sdim SourceLocation ToLocation; 7054344779Sdim CXXConstructorDecl *ToConstructor; 7055344779Sdim SourceRange ToParenOrBraceRange; 7056344779Sdim std::tie(ToType, ToLocation, ToConstructor, ToParenOrBraceRange) = *Imp; 7057288943Sdim 7058309124Sdim SmallVector<Expr *, 6> ToArgs(E->getNumArgs()); 7059344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7060344779Sdim return std::move(Err); 7061288943Sdim 7062344779Sdim return CXXConstructExpr::Create( 7063344779Sdim Importer.getToContext(), ToType, ToLocation, ToConstructor, 7064344779Sdim E->isElidable(), ToArgs, E->hadMultipleCandidates(), 7065344779Sdim E->isListInitialization(), E->isStdInitListInitialization(), 7066344779Sdim E->requiresZeroInitialization(), E->getConstructionKind(), 7067344779Sdim ToParenOrBraceRange); 7068288943Sdim} 7069288943Sdim 7070344779SdimExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) { 7071344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 7072344779Sdim if (!ToSubExprOrErr) 7073344779Sdim return ToSubExprOrErr.takeError(); 7074314564Sdim 7075344779Sdim SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects()); 7076344779Sdim if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects)) 7077344779Sdim return std::move(Err); 7078314564Sdim 7079344779Sdim return ExprWithCleanups::Create( 7080344779Sdim Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(), 7081344779Sdim ToObjects); 7082314564Sdim} 7083314564Sdim 7084344779SdimExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 7085344779Sdim auto Imp = importSeq( 7086344779Sdim E->getCallee(), E->getType(), E->getRParenLoc()); 7087344779Sdim if (!Imp) 7088344779Sdim return Imp.takeError(); 7089341825Sdim 7090344779Sdim Expr *ToCallee; 7091344779Sdim QualType ToType; 7092344779Sdim SourceLocation ToRParenLoc; 7093344779Sdim std::tie(ToCallee, ToType, ToRParenLoc) = *Imp; 7094341825Sdim 7095309124Sdim SmallVector<Expr *, 4> ToArgs(E->getNumArgs()); 7096344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7097344779Sdim return std::move(Err); 7098309124Sdim 7099344779Sdim return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, 7100344779Sdim ToType, E->getValueKind(), ToRParenLoc); 7101309124Sdim} 7102309124Sdim 7103344779SdimExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) { 7104344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7105344779Sdim if (!ToTypeOrErr) 7106344779Sdim return ToTypeOrErr.takeError(); 7107341825Sdim 7108344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 7109344779Sdim if (!ToLocationOrErr) 7110344779Sdim return ToLocationOrErr.takeError(); 7111344779Sdim 7112344779Sdim return new (Importer.getToContext()) CXXThisExpr( 7113344779Sdim *ToLocationOrErr, *ToTypeOrErr, E->isImplicit()); 7114309124Sdim} 7115309124Sdim 7116344779SdimExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 7117344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7118344779Sdim if (!ToTypeOrErr) 7119344779Sdim return ToTypeOrErr.takeError(); 7120341825Sdim 7121344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 7122344779Sdim if (!ToLocationOrErr) 7123344779Sdim return ToLocationOrErr.takeError(); 7124344779Sdim 7125344779Sdim return new (Importer.getToContext()) CXXBoolLiteralExpr( 7126344779Sdim E->getValue(), *ToTypeOrErr, *ToLocationOrErr); 7127309124Sdim} 7128309124Sdim 7129344779SdimExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 7130344779Sdim auto Imp1 = importSeq( 7131344779Sdim E->getBase(), E->getOperatorLoc(), E->getQualifierLoc(), 7132344779Sdim E->getTemplateKeywordLoc(), E->getMemberDecl(), E->getType()); 7133344779Sdim if (!Imp1) 7134344779Sdim return Imp1.takeError(); 7135309124Sdim 7136344779Sdim Expr *ToBase; 7137344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7138344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7139344779Sdim ValueDecl *ToMemberDecl; 7140344779Sdim QualType ToType; 7141344779Sdim std::tie( 7142344779Sdim ToBase, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, ToMemberDecl, 7143344779Sdim ToType) = *Imp1; 7144288943Sdim 7145344779Sdim auto Imp2 = importSeq( 7146344779Sdim E->getFoundDecl().getDecl(), E->getMemberNameInfo().getName(), 7147344779Sdim E->getMemberNameInfo().getLoc(), E->getLAngleLoc(), E->getRAngleLoc()); 7148344779Sdim if (!Imp2) 7149344779Sdim return Imp2.takeError(); 7150344779Sdim NamedDecl *ToDecl; 7151344779Sdim DeclarationName ToName; 7152344779Sdim SourceLocation ToLoc, ToLAngleLoc, ToRAngleLoc; 7153344779Sdim std::tie(ToDecl, ToName, ToLoc, ToLAngleLoc, ToRAngleLoc) = *Imp2; 7154288943Sdim 7155341825Sdim DeclAccessPair ToFoundDecl = 7156341825Sdim DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess()); 7157341825Sdim 7158344779Sdim DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc); 7159288943Sdim 7160353358Sdim TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 7161288943Sdim if (E->hasExplicitTemplateArgs()) { 7162353358Sdim if (Error Err = 7163353358Sdim ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(), 7164353358Sdim E->template_arguments(), ToTAInfo)) 7165353358Sdim return std::move(Err); 7166353358Sdim ResInfo = &ToTAInfo; 7167288943Sdim } 7168288943Sdim 7169353358Sdim return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(), 7170353358Sdim ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7171353358Sdim ToMemberDecl, ToFoundDecl, ToMemberNameInfo, 7172353358Sdim ResInfo, ToType, E->getValueKind(), 7173353358Sdim E->getObjectKind(), E->isNonOdrUse()); 7174288943Sdim} 7175288943Sdim 7176344779SdimExpectedStmt 7177344779SdimASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 7178344779Sdim auto Imp = importSeq( 7179344779Sdim E->getBase(), E->getOperatorLoc(), E->getQualifierLoc(), 7180344779Sdim E->getScopeTypeInfo(), E->getColonColonLoc(), E->getTildeLoc()); 7181344779Sdim if (!Imp) 7182344779Sdim return Imp.takeError(); 7183327952Sdim 7184344779Sdim Expr *ToBase; 7185344779Sdim SourceLocation ToOperatorLoc, ToColonColonLoc, ToTildeLoc; 7186344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7187344779Sdim TypeSourceInfo *ToScopeTypeInfo; 7188344779Sdim std::tie( 7189344779Sdim ToBase, ToOperatorLoc, ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, 7190344779Sdim ToTildeLoc) = *Imp; 7191327952Sdim 7192327952Sdim PseudoDestructorTypeStorage Storage; 7193327952Sdim if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) { 7194327952Sdim IdentifierInfo *ToII = Importer.Import(FromII); 7195344779Sdim ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc()); 7196344779Sdim if (!ToDestroyedTypeLocOrErr) 7197344779Sdim return ToDestroyedTypeLocOrErr.takeError(); 7198344779Sdim Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr); 7199327952Sdim } else { 7200344779Sdim if (auto ToTIOrErr = import(E->getDestroyedTypeInfo())) 7201344779Sdim Storage = PseudoDestructorTypeStorage(*ToTIOrErr); 7202344779Sdim else 7203344779Sdim return ToTIOrErr.takeError(); 7204327952Sdim } 7205327952Sdim 7206327952Sdim return new (Importer.getToContext()) CXXPseudoDestructorExpr( 7207344779Sdim Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc, 7208344779Sdim ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage); 7209327952Sdim} 7210327952Sdim 7211344779SdimExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr( 7212327952Sdim CXXDependentScopeMemberExpr *E) { 7213344779Sdim auto Imp = importSeq( 7214344779Sdim E->getType(), E->getOperatorLoc(), E->getQualifierLoc(), 7215344779Sdim E->getTemplateKeywordLoc(), E->getFirstQualifierFoundInScope()); 7216344779Sdim if (!Imp) 7217344779Sdim return Imp.takeError(); 7218344779Sdim 7219344779Sdim QualType ToType; 7220344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7221344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7222344779Sdim NamedDecl *ToFirstQualifierFoundInScope; 7223344779Sdim std::tie( 7224344779Sdim ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7225344779Sdim ToFirstQualifierFoundInScope) = *Imp; 7226344779Sdim 7227344779Sdim Expr *ToBase = nullptr; 7228327952Sdim if (!E->isImplicitAccess()) { 7229344779Sdim if (ExpectedExpr ToBaseOrErr = import(E->getBase())) 7230344779Sdim ToBase = *ToBaseOrErr; 7231344779Sdim else 7232344779Sdim return ToBaseOrErr.takeError(); 7233327952Sdim } 7234327952Sdim 7235341825Sdim TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 7236327952Sdim if (E->hasExplicitTemplateArgs()) { 7237344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 7238344779Sdim E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(), 7239344779Sdim ToTAInfo)) 7240344779Sdim return std::move(Err); 7241327952Sdim ResInfo = &ToTAInfo; 7242327952Sdim } 7243327952Sdim 7244344779Sdim auto ToMemberNameInfoOrErr = importSeq(E->getMember(), E->getMemberLoc()); 7245344779Sdim if (!ToMemberNameInfoOrErr) 7246344779Sdim return ToMemberNameInfoOrErr.takeError(); 7247344779Sdim DeclarationNameInfo ToMemberNameInfo( 7248344779Sdim std::get<0>(*ToMemberNameInfoOrErr), std::get<1>(*ToMemberNameInfoOrErr)); 7249327952Sdim // Import additional name location/type info. 7250344779Sdim if (Error Err = ImportDeclarationNameLoc( 7251344779Sdim E->getMemberNameInfo(), ToMemberNameInfo)) 7252344779Sdim return std::move(Err); 7253327952Sdim 7254327952Sdim return CXXDependentScopeMemberExpr::Create( 7255344779Sdim Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc, 7256344779Sdim ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope, 7257344779Sdim ToMemberNameInfo, ResInfo); 7258327952Sdim} 7259327952Sdim 7260344779SdimExpectedStmt 7261341825SdimASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 7262344779Sdim auto Imp = importSeq( 7263344779Sdim E->getQualifierLoc(), E->getTemplateKeywordLoc(), E->getDeclName(), 7264344779Sdim E->getExprLoc(), E->getLAngleLoc(), E->getRAngleLoc()); 7265344779Sdim if (!Imp) 7266344779Sdim return Imp.takeError(); 7267341825Sdim 7268344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7269344779Sdim SourceLocation ToTemplateKeywordLoc, ToExprLoc, ToLAngleLoc, ToRAngleLoc; 7270344779Sdim DeclarationName ToDeclName; 7271344779Sdim std::tie( 7272344779Sdim ToQualifierLoc, ToTemplateKeywordLoc, ToDeclName, ToExprLoc, 7273344779Sdim ToLAngleLoc, ToRAngleLoc) = *Imp; 7274341825Sdim 7275344779Sdim DeclarationNameInfo ToNameInfo(ToDeclName, ToExprLoc); 7276344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7277344779Sdim return std::move(Err); 7278344779Sdim 7279344779Sdim TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc); 7280341825Sdim TemplateArgumentListInfo *ResInfo = nullptr; 7281341825Sdim if (E->hasExplicitTemplateArgs()) { 7282344779Sdim if (Error Err = 7283344779Sdim ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 7284344779Sdim return std::move(Err); 7285341825Sdim ResInfo = &ToTAInfo; 7286341825Sdim } 7287341825Sdim 7288341825Sdim return DependentScopeDeclRefExpr::Create( 7289344779Sdim Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, 7290344779Sdim ToNameInfo, ResInfo); 7291341825Sdim} 7292341825Sdim 7293344779SdimExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr( 7294344779Sdim CXXUnresolvedConstructExpr *E) { 7295344779Sdim auto Imp = importSeq( 7296344779Sdim E->getLParenLoc(), E->getRParenLoc(), E->getTypeSourceInfo()); 7297344779Sdim if (!Imp) 7298344779Sdim return Imp.takeError(); 7299341825Sdim 7300344779Sdim SourceLocation ToLParenLoc, ToRParenLoc; 7301344779Sdim TypeSourceInfo *ToTypeSourceInfo; 7302344779Sdim std::tie(ToLParenLoc, ToRParenLoc, ToTypeSourceInfo) = *Imp; 7303341825Sdim 7304344779Sdim SmallVector<Expr *, 8> ToArgs(E->arg_size()); 7305344779Sdim if (Error Err = 7306344779Sdim ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin())) 7307344779Sdim return std::move(Err); 7308344779Sdim 7309341825Sdim return CXXUnresolvedConstructExpr::Create( 7310344779Sdim Importer.getToContext(), ToTypeSourceInfo, ToLParenLoc, 7311344779Sdim llvm::makeArrayRef(ToArgs), ToRParenLoc); 7312341825Sdim} 7313341825Sdim 7314344779SdimExpectedStmt 7315344779SdimASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 7316344779Sdim Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass()); 7317344779Sdim if (!ToNamingClassOrErr) 7318344779Sdim return ToNamingClassOrErr.takeError(); 7319341825Sdim 7320344779Sdim auto ToQualifierLocOrErr = import(E->getQualifierLoc()); 7321344779Sdim if (!ToQualifierLocOrErr) 7322344779Sdim return ToQualifierLocOrErr.takeError(); 7323341825Sdim 7324344779Sdim auto ToNameInfoOrErr = importSeq(E->getName(), E->getNameLoc()); 7325344779Sdim if (!ToNameInfoOrErr) 7326344779Sdim return ToNameInfoOrErr.takeError(); 7327344779Sdim DeclarationNameInfo ToNameInfo( 7328344779Sdim std::get<0>(*ToNameInfoOrErr), std::get<1>(*ToNameInfoOrErr)); 7329341825Sdim // Import additional name location/type info. 7330344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7331344779Sdim return std::move(Err); 7332341825Sdim 7333341825Sdim UnresolvedSet<8> ToDecls; 7334344779Sdim for (auto *D : E->decls()) 7335344779Sdim if (auto ToDOrErr = import(D)) 7336344779Sdim ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr)); 7337341825Sdim else 7338344779Sdim return ToDOrErr.takeError(); 7339341825Sdim 7340344779Sdim if (E->hasExplicitTemplateArgs() && E->getTemplateKeywordLoc().isValid()) { 7341344779Sdim TemplateArgumentListInfo ToTAInfo; 7342344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 7343344779Sdim E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(), 7344344779Sdim ToTAInfo)) 7345344779Sdim return std::move(Err); 7346341825Sdim 7347344779Sdim ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc()); 7348344779Sdim if (!ToTemplateKeywordLocOrErr) 7349344779Sdim return ToTemplateKeywordLocOrErr.takeError(); 7350344779Sdim 7351341825Sdim return UnresolvedLookupExpr::Create( 7352344779Sdim Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr, 7353344779Sdim *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo, 7354344779Sdim ToDecls.begin(), ToDecls.end()); 7355344779Sdim } 7356341825Sdim 7357341825Sdim return UnresolvedLookupExpr::Create( 7358344779Sdim Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr, 7359344779Sdim ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(), 7360344779Sdim ToDecls.end()); 7361341825Sdim} 7362341825Sdim 7363344779SdimExpectedStmt 7364344779SdimASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 7365344779Sdim auto Imp1 = importSeq( 7366344779Sdim E->getType(), E->getOperatorLoc(), E->getQualifierLoc(), 7367344779Sdim E->getTemplateKeywordLoc()); 7368344779Sdim if (!Imp1) 7369344779Sdim return Imp1.takeError(); 7370344779Sdim 7371344779Sdim QualType ToType; 7372344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7373344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7374344779Sdim std::tie(ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc) = *Imp1; 7375344779Sdim 7376344779Sdim auto Imp2 = importSeq(E->getName(), E->getNameLoc()); 7377344779Sdim if (!Imp2) 7378344779Sdim return Imp2.takeError(); 7379344779Sdim DeclarationNameInfo ToNameInfo(std::get<0>(*Imp2), std::get<1>(*Imp2)); 7380341825Sdim // Import additional name location/type info. 7381344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7382344779Sdim return std::move(Err); 7383341825Sdim 7384341825Sdim UnresolvedSet<8> ToDecls; 7385344779Sdim for (Decl *D : E->decls()) 7386344779Sdim if (auto ToDOrErr = import(D)) 7387344779Sdim ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr)); 7388341825Sdim else 7389344779Sdim return ToDOrErr.takeError(); 7390341825Sdim 7391341825Sdim TemplateArgumentListInfo ToTAInfo; 7392341825Sdim TemplateArgumentListInfo *ResInfo = nullptr; 7393341825Sdim if (E->hasExplicitTemplateArgs()) { 7394344779Sdim if (Error Err = 7395344779Sdim ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 7396344779Sdim return std::move(Err); 7397341825Sdim ResInfo = &ToTAInfo; 7398341825Sdim } 7399341825Sdim 7400344779Sdim Expr *ToBase = nullptr; 7401344779Sdim if (!E->isImplicitAccess()) { 7402344779Sdim if (ExpectedExpr ToBaseOrErr = import(E->getBase())) 7403344779Sdim ToBase = *ToBaseOrErr; 7404344779Sdim else 7405344779Sdim return ToBaseOrErr.takeError(); 7406341825Sdim } 7407341825Sdim 7408341825Sdim return UnresolvedMemberExpr::Create( 7409344779Sdim Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType, 7410344779Sdim E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7411344779Sdim ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end()); 7412341825Sdim} 7413341825Sdim 7414344779SdimExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) { 7415344779Sdim auto Imp = importSeq(E->getCallee(), E->getType(), E->getRParenLoc()); 7416344779Sdim if (!Imp) 7417344779Sdim return Imp.takeError(); 7418288943Sdim 7419344779Sdim Expr *ToCallee; 7420344779Sdim QualType ToType; 7421344779Sdim SourceLocation ToRParenLoc; 7422344779Sdim std::tie(ToCallee, ToType, ToRParenLoc) = *Imp; 7423288943Sdim 7424288943Sdim unsigned NumArgs = E->getNumArgs(); 7425344779Sdim llvm::SmallVector<Expr *, 2> ToArgs(NumArgs); 7426344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7427344779Sdim return std::move(Err); 7428288943Sdim 7429341825Sdim if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) { 7430344779Sdim return CXXOperatorCallExpr::Create( 7431344779Sdim Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType, 7432344779Sdim OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(), 7433344779Sdim OCE->getADLCallKind()); 7434341825Sdim } 7435341825Sdim 7436344779Sdim return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType, 7437344779Sdim E->getValueKind(), ToRParenLoc, /*MinNumArgs=*/0, 7438344779Sdim E->getADLCallKind()); 7439288943Sdim} 7440288943Sdim 7441344779SdimExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) { 7442344779Sdim CXXRecordDecl *FromClass = E->getLambdaClass(); 7443344779Sdim auto ToClassOrErr = import(FromClass); 7444344779Sdim if (!ToClassOrErr) 7445344779Sdim return ToClassOrErr.takeError(); 7446344779Sdim CXXRecordDecl *ToClass = *ToClassOrErr; 7447341825Sdim 7448344779Sdim auto ToCallOpOrErr = import(E->getCallOperator()); 7449344779Sdim if (!ToCallOpOrErr) 7450344779Sdim return ToCallOpOrErr.takeError(); 7451341825Sdim 7452344779Sdim SmallVector<LambdaCapture, 8> ToCaptures; 7453344779Sdim ToCaptures.reserve(E->capture_size()); 7454344779Sdim for (const auto &FromCapture : E->captures()) { 7455344779Sdim if (auto ToCaptureOrErr = import(FromCapture)) 7456344779Sdim ToCaptures.push_back(*ToCaptureOrErr); 7457341825Sdim else 7458344779Sdim return ToCaptureOrErr.takeError(); 7459341825Sdim } 7460341825Sdim 7461344779Sdim SmallVector<Expr *, 8> ToCaptureInits(E->capture_size()); 7462344779Sdim if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits)) 7463344779Sdim return std::move(Err); 7464341825Sdim 7465344779Sdim auto Imp = importSeq( 7466344779Sdim E->getIntroducerRange(), E->getCaptureDefaultLoc(), E->getEndLoc()); 7467344779Sdim if (!Imp) 7468344779Sdim return Imp.takeError(); 7469344779Sdim 7470344779Sdim SourceRange ToIntroducerRange; 7471344779Sdim SourceLocation ToCaptureDefaultLoc, ToEndLoc; 7472344779Sdim std::tie(ToIntroducerRange, ToCaptureDefaultLoc, ToEndLoc) = *Imp; 7473344779Sdim 7474344779Sdim return LambdaExpr::Create( 7475344779Sdim Importer.getToContext(), ToClass, ToIntroducerRange, 7476344779Sdim E->getCaptureDefault(), ToCaptureDefaultLoc, ToCaptures, 7477344779Sdim E->hasExplicitParameters(), E->hasExplicitResultType(), ToCaptureInits, 7478344779Sdim ToEndLoc, E->containsUnexpandedParameterPack()); 7479341825Sdim} 7480341825Sdim 7481309124Sdim 7482344779SdimExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) { 7483344779Sdim auto Imp = importSeq(E->getLBraceLoc(), E->getRBraceLoc(), E->getType()); 7484344779Sdim if (!Imp) 7485344779Sdim return Imp.takeError(); 7486309124Sdim 7487344779Sdim SourceLocation ToLBraceLoc, ToRBraceLoc; 7488344779Sdim QualType ToType; 7489344779Sdim std::tie(ToLBraceLoc, ToRBraceLoc, ToType) = *Imp; 7490344779Sdim 7491344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumInits()); 7492344779Sdim if (Error Err = ImportContainerChecked(E->inits(), ToExprs)) 7493344779Sdim return std::move(Err); 7494344779Sdim 7495309124Sdim ASTContext &ToCtx = Importer.getToContext(); 7496309124Sdim InitListExpr *To = new (ToCtx) InitListExpr( 7497344779Sdim ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc); 7498344779Sdim To->setType(ToType); 7499309124Sdim 7500344779Sdim if (E->hasArrayFiller()) { 7501344779Sdim if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller())) 7502344779Sdim To->setArrayFiller(*ToFillerOrErr); 7503344779Sdim else 7504344779Sdim return ToFillerOrErr.takeError(); 7505309124Sdim } 7506309124Sdim 7507344779Sdim if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) { 7508344779Sdim if (auto ToFDOrErr = import(FromFD)) 7509344779Sdim To->setInitializedFieldInUnion(*ToFDOrErr); 7510344779Sdim else 7511344779Sdim return ToFDOrErr.takeError(); 7512309124Sdim } 7513309124Sdim 7514344779Sdim if (InitListExpr *SyntForm = E->getSyntacticForm()) { 7515344779Sdim if (auto ToSyntFormOrErr = import(SyntForm)) 7516344779Sdim To->setSyntacticForm(*ToSyntFormOrErr); 7517344779Sdim else 7518344779Sdim return ToSyntFormOrErr.takeError(); 7519309124Sdim } 7520309124Sdim 7521344779Sdim // Copy InitListExprBitfields, which are not handled in the ctor of 7522344779Sdim // InitListExpr. 7523344779Sdim To->sawArrayRangeDesignator(E->hadArrayRangeDesignator()); 7524309124Sdim 7525309124Sdim return To; 7526309124Sdim} 7527309124Sdim 7528344779SdimExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr( 7529341825Sdim CXXStdInitializerListExpr *E) { 7530344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7531344779Sdim if (!ToTypeOrErr) 7532344779Sdim return ToTypeOrErr.takeError(); 7533341825Sdim 7534344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 7535344779Sdim if (!ToSubExprOrErr) 7536344779Sdim return ToSubExprOrErr.takeError(); 7537341825Sdim 7538344779Sdim return new (Importer.getToContext()) CXXStdInitializerListExpr( 7539344779Sdim *ToTypeOrErr, *ToSubExprOrErr); 7540341825Sdim} 7541341825Sdim 7542344779SdimExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr( 7543341825Sdim CXXInheritedCtorInitExpr *E) { 7544344779Sdim auto Imp = importSeq(E->getLocation(), E->getType(), E->getConstructor()); 7545344779Sdim if (!Imp) 7546344779Sdim return Imp.takeError(); 7547341825Sdim 7548344779Sdim SourceLocation ToLocation; 7549344779Sdim QualType ToType; 7550344779Sdim CXXConstructorDecl *ToConstructor; 7551344779Sdim std::tie(ToLocation, ToType, ToConstructor) = *Imp; 7552341825Sdim 7553341825Sdim return new (Importer.getToContext()) CXXInheritedCtorInitExpr( 7554344779Sdim ToLocation, ToType, ToConstructor, E->constructsVBase(), 7555344779Sdim E->inheritedFromVBase()); 7556341825Sdim} 7557341825Sdim 7558344779SdimExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 7559344779Sdim auto Imp = importSeq(E->getType(), E->getCommonExpr(), E->getSubExpr()); 7560344779Sdim if (!Imp) 7561344779Sdim return Imp.takeError(); 7562314564Sdim 7563344779Sdim QualType ToType; 7564344779Sdim Expr *ToCommonExpr, *ToSubExpr; 7565344779Sdim std::tie(ToType, ToCommonExpr, ToSubExpr) = *Imp; 7566314564Sdim 7567344779Sdim return new (Importer.getToContext()) ArrayInitLoopExpr( 7568344779Sdim ToType, ToCommonExpr, ToSubExpr); 7569314564Sdim} 7570314564Sdim 7571344779SdimExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 7572344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7573344779Sdim if (!ToTypeOrErr) 7574344779Sdim return ToTypeOrErr.takeError(); 7575344779Sdim return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr); 7576314564Sdim} 7577314564Sdim 7578344779SdimExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 7579344779Sdim ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc()); 7580344779Sdim if (!ToBeginLocOrErr) 7581344779Sdim return ToBeginLocOrErr.takeError(); 7582309124Sdim 7583344779Sdim auto ToFieldOrErr = import(E->getField()); 7584344779Sdim if (!ToFieldOrErr) 7585344779Sdim return ToFieldOrErr.takeError(); 7586344779Sdim 7587353358Sdim auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext()); 7588353358Sdim if (!UsedContextOrErr) 7589353358Sdim return UsedContextOrErr.takeError(); 7590353358Sdim 7591309124Sdim return CXXDefaultInitExpr::Create( 7592353358Sdim Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr); 7593309124Sdim} 7594309124Sdim 7595344779SdimExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 7596344779Sdim auto Imp = importSeq( 7597344779Sdim E->getType(), E->getSubExpr(), E->getTypeInfoAsWritten(), 7598344779Sdim E->getOperatorLoc(), E->getRParenLoc(), E->getAngleBrackets()); 7599344779Sdim if (!Imp) 7600344779Sdim return Imp.takeError(); 7601344779Sdim 7602344779Sdim QualType ToType; 7603344779Sdim Expr *ToSubExpr; 7604344779Sdim TypeSourceInfo *ToTypeInfoAsWritten; 7605344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 7606344779Sdim SourceRange ToAngleBrackets; 7607344779Sdim std::tie( 7608344779Sdim ToType, ToSubExpr, ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, 7609344779Sdim ToAngleBrackets) = *Imp; 7610344779Sdim 7611309124Sdim ExprValueKind VK = E->getValueKind(); 7612309124Sdim CastKind CK = E->getCastKind(); 7613344779Sdim auto ToBasePathOrErr = ImportCastPath(E); 7614344779Sdim if (!ToBasePathOrErr) 7615344779Sdim return ToBasePathOrErr.takeError(); 7616341825Sdim 7617309124Sdim if (isa<CXXStaticCastExpr>(E)) { 7618309124Sdim return CXXStaticCastExpr::Create( 7619344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7620344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7621309124Sdim } else if (isa<CXXDynamicCastExpr>(E)) { 7622309124Sdim return CXXDynamicCastExpr::Create( 7623344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7624344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7625309124Sdim } else if (isa<CXXReinterpretCastExpr>(E)) { 7626309124Sdim return CXXReinterpretCastExpr::Create( 7627344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7628344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7629344779Sdim } else if (isa<CXXConstCastExpr>(E)) { 7630344779Sdim return CXXConstCastExpr::Create( 7631344779Sdim Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten, 7632344779Sdim ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7633309124Sdim } else { 7634344779Sdim llvm_unreachable("Unknown cast type"); 7635344779Sdim return make_error<ImportError>(); 7636309124Sdim } 7637309124Sdim} 7638309124Sdim 7639344779SdimExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr( 7640321369Sdim SubstNonTypeTemplateParmExpr *E) { 7641344779Sdim auto Imp = importSeq( 7642344779Sdim E->getType(), E->getExprLoc(), E->getParameter(), E->getReplacement()); 7643344779Sdim if (!Imp) 7644344779Sdim return Imp.takeError(); 7645321369Sdim 7646344779Sdim QualType ToType; 7647344779Sdim SourceLocation ToExprLoc; 7648344779Sdim NonTypeTemplateParmDecl *ToParameter; 7649344779Sdim Expr *ToReplacement; 7650344779Sdim std::tie(ToType, ToExprLoc, ToParameter, ToReplacement) = *Imp; 7651321369Sdim 7652321369Sdim return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr( 7653344779Sdim ToType, E->getValueKind(), ToExprLoc, ToParameter, ToReplacement); 7654321369Sdim} 7655321369Sdim 7656344779SdimExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) { 7657344779Sdim auto Imp = importSeq( 7658344779Sdim E->getType(), E->getBeginLoc(), E->getEndLoc()); 7659344779Sdim if (!Imp) 7660344779Sdim return Imp.takeError(); 7661327952Sdim 7662344779Sdim QualType ToType; 7663344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 7664344779Sdim std::tie(ToType, ToBeginLoc, ToEndLoc) = *Imp; 7665344779Sdim 7666327952Sdim SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs()); 7667344779Sdim if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs)) 7668344779Sdim return std::move(Err); 7669327952Sdim 7670327952Sdim // According to Sema::BuildTypeTrait(), if E is value-dependent, 7671327952Sdim // Value is always false. 7672344779Sdim bool ToValue = (E->isValueDependent() ? false : E->getValue()); 7673327952Sdim 7674327952Sdim return TypeTraitExpr::Create( 7675344779Sdim Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs, 7676344779Sdim ToEndLoc, ToValue); 7677327952Sdim} 7678327952Sdim 7679344779SdimExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 7680344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7681344779Sdim if (!ToTypeOrErr) 7682344779Sdim return ToTypeOrErr.takeError(); 7683341825Sdim 7684344779Sdim auto ToSourceRangeOrErr = import(E->getSourceRange()); 7685344779Sdim if (!ToSourceRangeOrErr) 7686344779Sdim return ToSourceRangeOrErr.takeError(); 7687344779Sdim 7688341825Sdim if (E->isTypeOperand()) { 7689344779Sdim if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo())) 7690344779Sdim return new (Importer.getToContext()) CXXTypeidExpr( 7691344779Sdim *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr); 7692344779Sdim else 7693344779Sdim return ToTSIOrErr.takeError(); 7694341825Sdim } 7695341825Sdim 7696344779Sdim ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand()); 7697344779Sdim if (!ToExprOperandOrErr) 7698344779Sdim return ToExprOperandOrErr.takeError(); 7699341825Sdim 7700344779Sdim return new (Importer.getToContext()) CXXTypeidExpr( 7701344779Sdim *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr); 7702341825Sdim} 7703341825Sdim 7704321369Sdimvoid ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod, 7705321369Sdim CXXMethodDecl *FromMethod) { 7706344779Sdim for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) { 7707344779Sdim if (auto ImportedOrErr = import(FromOverriddenMethod)) 7708344779Sdim ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>( 7709344779Sdim (*ImportedOrErr)->getCanonicalDecl())); 7710344779Sdim else 7711344779Sdim consumeError(ImportedOrErr.takeError()); 7712344779Sdim } 7713321369Sdim} 7714321369Sdim 7715218893SdimASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 7716218893Sdim ASTContext &FromContext, FileManager &FromFileManager, 7717344779Sdim bool MinimalImport, 7718353358Sdim std::shared_ptr<ASTImporterSharedState> SharedState) 7719353358Sdim : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext), 7720341825Sdim ToFileManager(ToFileManager), FromFileManager(FromFileManager), 7721341825Sdim Minimal(MinimalImport) { 7722344779Sdim 7723353358Sdim // Create a default state without the lookup table: LLDB case. 7724353358Sdim if (!SharedState) { 7725353358Sdim this->SharedState = std::make_shared<ASTImporterSharedState>(); 7726353358Sdim } 7727353358Sdim 7728344779Sdim ImportedDecls[FromContext.getTranslationUnitDecl()] = 7729344779Sdim ToContext.getTranslationUnitDecl(); 7730203955Srdivacky} 7731203955Srdivacky 7732341825SdimASTImporter::~ASTImporter() = default; 7733203955Srdivacky 7734344779SdimOptional<unsigned> ASTImporter::getFieldIndex(Decl *F) { 7735344779Sdim assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) && 7736344779Sdim "Try to get field index for non-field."); 7737344779Sdim 7738344779Sdim auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 7739344779Sdim if (!Owner) 7740344779Sdim return None; 7741344779Sdim 7742344779Sdim unsigned Index = 0; 7743344779Sdim for (const auto *D : Owner->decls()) { 7744344779Sdim if (D == F) 7745344779Sdim return Index; 7746344779Sdim 7747344779Sdim if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 7748344779Sdim ++Index; 7749344779Sdim } 7750344779Sdim 7751344779Sdim llvm_unreachable("Field was not found in its parent context."); 7752344779Sdim 7753344779Sdim return None; 7754344779Sdim} 7755344779Sdim 7756344779SdimASTImporter::FoundDeclsTy 7757344779SdimASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) { 7758344779Sdim // We search in the redecl context because of transparent contexts. 7759344779Sdim // E.g. a simple C language enum is a transparent context: 7760344779Sdim // enum E { A, B }; 7761344779Sdim // Now if we had a global variable in the TU 7762344779Sdim // int A; 7763344779Sdim // then the enum constant 'A' and the variable 'A' violates ODR. 7764344779Sdim // We can diagnose this only if we search in the redecl context. 7765344779Sdim DeclContext *ReDC = DC->getRedeclContext(); 7766353358Sdim if (SharedState->getLookupTable()) { 7767344779Sdim ASTImporterLookupTable::LookupResult LookupResult = 7768353358Sdim SharedState->getLookupTable()->lookup(ReDC, Name); 7769344779Sdim return FoundDeclsTy(LookupResult.begin(), LookupResult.end()); 7770344779Sdim } else { 7771353358Sdim DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name); 7772353358Sdim FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end()); 7773353358Sdim // We must search by the slow case of localUncachedLookup because that is 7774353358Sdim // working even if there is no LookupPtr for the DC. We could use 7775353358Sdim // DC::buildLookup() to create the LookupPtr, but that would load external 7776353358Sdim // decls again, we must avoid that case. 7777353358Sdim // Also, even if we had the LookupPtr, we must find Decls which are not 7778353358Sdim // in the LookupPtr, so we need the slow case. 7779353358Sdim // These cases are handled in ASTImporterLookupTable, but we cannot use 7780353358Sdim // that with LLDB since that traverses through the AST which initiates the 7781353358Sdim // load of external decls again via DC::decls(). And again, we must avoid 7782353358Sdim // loading external decls during the import. 7783353358Sdim if (Result.empty()) 7784353358Sdim ReDC->localUncachedLookup(Name, Result); 7785344779Sdim return Result; 7786344779Sdim } 7787344779Sdim} 7788344779Sdim 7789344779Sdimvoid ASTImporter::AddToLookupTable(Decl *ToD) { 7790353358Sdim SharedState->addDeclToLookup(ToD); 7791344779Sdim} 7792344779Sdim 7793353358SdimExpected<Decl *> ASTImporter::ImportImpl(Decl *FromD) { 7794353358Sdim // Import the decl using ASTNodeImporter. 7795353358Sdim ASTNodeImporter Importer(*this); 7796353358Sdim return Importer.Visit(FromD); 7797353358Sdim} 7798353358Sdim 7799353358Sdimvoid ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) { 7800353358Sdim MapImported(FromD, ToD); 7801353358Sdim} 7802353358Sdim 7803353358SdimExpected<QualType> ASTImporter::Import(QualType FromT) { 7804203955Srdivacky if (FromT.isNull()) 7805353358Sdim return QualType{}; 7806218893Sdim 7807344779Sdim const Type *FromTy = FromT.getTypePtr(); 7808341825Sdim 7809341825Sdim // Check whether we've already imported this type. 7810218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 7811344779Sdim = ImportedTypes.find(FromTy); 7812203955Srdivacky if (Pos != ImportedTypes.end()) 7813218893Sdim return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 7814341825Sdim 7815203955Srdivacky // Import the type 7816203955Srdivacky ASTNodeImporter Importer(*this); 7817344779Sdim ExpectedType ToTOrErr = Importer.Visit(FromTy); 7818353358Sdim if (!ToTOrErr) 7819353358Sdim return ToTOrErr.takeError(); 7820341825Sdim 7821203955Srdivacky // Record the imported type. 7822344779Sdim ImportedTypes[FromTy] = (*ToTOrErr).getTypePtr(); 7823341825Sdim 7824344779Sdim return ToContext.getQualifiedType(*ToTOrErr, FromT.getLocalQualifiers()); 7825203955Srdivacky} 7826203955Srdivacky 7827353358SdimExpected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) { 7828203955Srdivacky if (!FromTSI) 7829203955Srdivacky return FromTSI; 7830203955Srdivacky 7831203955Srdivacky // FIXME: For now we just create a "trivial" type source info based 7832212904Sdim // on the type and a single location. Implement a real version of this. 7833353358Sdim ExpectedType TOrErr = Import(FromTSI->getType()); 7834353358Sdim if (!TOrErr) 7835353358Sdim return TOrErr.takeError(); 7836353358Sdim ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc()); 7837353358Sdim if (!BeginLocOrErr) 7838353358Sdim return BeginLocOrErr.takeError(); 7839203955Srdivacky 7840353358Sdim return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr); 7841203955Srdivacky} 7842203955Srdivacky 7843353358SdimExpected<Attr *> ASTImporter::Import(const Attr *FromAttr) { 7844341825Sdim Attr *ToAttr = FromAttr->clone(ToContext); 7845353358Sdim if (auto ToRangeOrErr = Import(FromAttr->getRange())) 7846353358Sdim ToAttr->setRange(*ToRangeOrErr); 7847353358Sdim else 7848353358Sdim return ToRangeOrErr.takeError(); 7849353358Sdim 7850341825Sdim return ToAttr; 7851341825Sdim} 7852341825Sdim 7853344779SdimDecl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const { 7854344779Sdim auto Pos = ImportedDecls.find(FromD); 7855344779Sdim if (Pos != ImportedDecls.end()) 7856344779Sdim return Pos->second; 7857344779Sdim else 7858288943Sdim return nullptr; 7859288943Sdim} 7860288943Sdim 7861353358SdimTranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) { 7862353358Sdim auto FromDPos = ImportedFromDecls.find(ToD); 7863353358Sdim if (FromDPos == ImportedFromDecls.end()) 7864353358Sdim return nullptr; 7865353358Sdim return FromDPos->second->getTranslationUnitDecl(); 7866344779Sdim} 7867353358Sdim 7868353358SdimExpected<Decl *> ASTImporter::Import(Decl *FromD) { 7869203955Srdivacky if (!FromD) 7870276479Sdim return nullptr; 7871203955Srdivacky 7872353358Sdim // Push FromD to the stack, and remove that when we return. 7873353358Sdim ImportPath.push(FromD); 7874353358Sdim auto ImportPathBuilder = 7875353358Sdim llvm::make_scope_exit([this]() { ImportPath.pop(); }); 7876226633Sdim 7877353358Sdim // Check whether there was a previous failed import. 7878353358Sdim // If yes return the existing error. 7879353358Sdim if (auto Error = getImportDeclErrorIfAny(FromD)) 7880353358Sdim return make_error<ImportError>(*Error); 7881353358Sdim 7882341825Sdim // Check whether we've already imported this declaration. 7883341825Sdim Decl *ToD = GetAlreadyImportedOrNull(FromD); 7884341825Sdim if (ToD) { 7885353358Sdim // Already imported (possibly from another TU) and with an error. 7886353358Sdim if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) { 7887353358Sdim setImportDeclError(FromD, *Error); 7888353358Sdim return make_error<ImportError>(*Error); 7889353358Sdim } 7890353358Sdim 7891341825Sdim // If FromD has some updated flags after last import, apply it 7892341825Sdim updateFlags(FromD, ToD); 7893353358Sdim // If we encounter a cycle during an import then we save the relevant part 7894353358Sdim // of the import path associated to the Decl. 7895353358Sdim if (ImportPath.hasCycleAtBack()) 7896353358Sdim SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack()); 7897226633Sdim return ToD; 7898226633Sdim } 7899341825Sdim 7900353358Sdim // Import the declaration. 7901353358Sdim ExpectedDecl ToDOrErr = ImportImpl(FromD); 7902344779Sdim if (!ToDOrErr) { 7903353358Sdim // Failed to import. 7904353358Sdim 7905353358Sdim auto Pos = ImportedDecls.find(FromD); 7906353358Sdim if (Pos != ImportedDecls.end()) { 7907353358Sdim // Import failed after the object was created. 7908353358Sdim // Remove all references to it. 7909353358Sdim auto *ToD = Pos->second; 7910353358Sdim ImportedDecls.erase(Pos); 7911353358Sdim 7912353358Sdim // ImportedDecls and ImportedFromDecls are not symmetric. It may happen 7913353358Sdim // (e.g. with namespaces) that several decls from the 'from' context are 7914353358Sdim // mapped to the same decl in the 'to' context. If we removed entries 7915353358Sdim // from the LookupTable here then we may end up removing them multiple 7916353358Sdim // times. 7917353358Sdim 7918353358Sdim // The Lookuptable contains decls only which are in the 'to' context. 7919353358Sdim // Remove from the Lookuptable only if it is *imported* into the 'to' 7920353358Sdim // context (and do not remove it if it was added during the initial 7921353358Sdim // traverse of the 'to' context). 7922353358Sdim auto PosF = ImportedFromDecls.find(ToD); 7923353358Sdim if (PosF != ImportedFromDecls.end()) { 7924353358Sdim SharedState->removeDeclFromLookup(ToD); 7925353358Sdim ImportedFromDecls.erase(PosF); 7926353358Sdim } 7927353358Sdim 7928353358Sdim // FIXME: AST may contain remaining references to the failed object. 7929353358Sdim // However, the ImportDeclErrors in the shared state contains all the 7930353358Sdim // failed objects together with their error. 7931353358Sdim } 7932353358Sdim 7933353358Sdim // Error encountered for the first time. 7934353358Sdim // After takeError the error is not usable any more in ToDOrErr. 7935353358Sdim // Get a copy of the error object (any more simple solution for this?). 7936353358Sdim ImportError ErrOut; 7937353358Sdim handleAllErrors(ToDOrErr.takeError(), 7938353358Sdim [&ErrOut](const ImportError &E) { ErrOut = E; }); 7939353358Sdim setImportDeclError(FromD, ErrOut); 7940353358Sdim // Set the error for the mapped to Decl, which is in the "to" context. 7941353358Sdim if (Pos != ImportedDecls.end()) 7942353358Sdim SharedState->setImportDeclError(Pos->second, ErrOut); 7943353358Sdim 7944353358Sdim // Set the error for all nodes which have been created before we 7945353358Sdim // recognized the error. 7946353358Sdim for (const auto &Path : SavedImportPaths[FromD]) 7947353358Sdim for (Decl *FromDi : Path) { 7948353358Sdim setImportDeclError(FromDi, ErrOut); 7949353358Sdim //FIXME Should we remove these Decls from ImportedDecls? 7950353358Sdim // Set the error for the mapped to Decl, which is in the "to" context. 7951353358Sdim auto Ii = ImportedDecls.find(FromDi); 7952353358Sdim if (Ii != ImportedDecls.end()) 7953353358Sdim SharedState->setImportDeclError(Ii->second, ErrOut); 7954353358Sdim // FIXME Should we remove these Decls from the LookupTable, 7955353358Sdim // and from ImportedFromDecls? 7956353358Sdim } 7957353358Sdim SavedImportPaths[FromD].clear(); 7958353358Sdim 7959353358Sdim // Do not return ToDOrErr, error was taken out of it. 7960353358Sdim return make_error<ImportError>(ErrOut); 7961344779Sdim } 7962353358Sdim 7963344779Sdim ToD = *ToDOrErr; 7964276479Sdim 7965353358Sdim // FIXME: Handle the "already imported with error" case. We can get here 7966353358Sdim // nullptr only if GetImportedOrCreateDecl returned nullptr (after a 7967353358Sdim // previously failed create was requested). 7968353358Sdim // Later GetImportedOrCreateDecl can be updated to return the error. 7969353358Sdim if (!ToD) { 7970353358Sdim auto Err = getImportDeclErrorIfAny(FromD); 7971353358Sdim assert(Err); 7972353358Sdim return make_error<ImportError>(*Err); 7973353358Sdim } 7974344779Sdim 7975353358Sdim // We could import from the current TU without error. But previously we 7976353358Sdim // already had imported a Decl as `ToD` from another TU (with another 7977353358Sdim // ASTImporter object) and with an error. 7978353358Sdim if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) { 7979353358Sdim setImportDeclError(FromD, *Error); 7980353358Sdim return make_error<ImportError>(*Error); 7981353358Sdim } 7982353358Sdim 7983353358Sdim // Make sure that ImportImpl registered the imported decl. 7984353358Sdim assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?"); 7985353358Sdim 7986341825Sdim // Notify subclasses. 7987341825Sdim Imported(FromD, ToD); 7988341825Sdim 7989344779Sdim updateFlags(FromD, ToD); 7990353358Sdim SavedImportPaths[FromD].clear(); 7991353358Sdim return ToDOrErr; 7992203955Srdivacky} 7993203955Srdivacky 7994344779SdimExpected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) { 7995203955Srdivacky if (!FromDC) 7996203955Srdivacky return FromDC; 7997203955Srdivacky 7998353358Sdim ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC)); 7999353358Sdim if (!ToDCOrErr) 8000353358Sdim return ToDCOrErr.takeError(); 8001353358Sdim auto *ToDC = cast<DeclContext>(*ToDCOrErr); 8002276479Sdim 8003341825Sdim // When we're using a record/enum/Objective-C class/protocol as a context, we 8004234353Sdim // need it to have a definition. 8005341825Sdim if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 8006341825Sdim auto *FromRecord = cast<RecordDecl>(FromDC); 8007234353Sdim if (ToRecord->isCompleteDefinition()) { 8008234353Sdim // Do nothing. 8009234353Sdim } else if (FromRecord->isCompleteDefinition()) { 8010344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8011344779Sdim FromRecord, ToRecord, ASTNodeImporter::IDK_Basic)) 8012344779Sdim return std::move(Err); 8013234353Sdim } else { 8014234353Sdim CompleteDecl(ToRecord); 8015234353Sdim } 8016341825Sdim } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 8017341825Sdim auto *FromEnum = cast<EnumDecl>(FromDC); 8018234353Sdim if (ToEnum->isCompleteDefinition()) { 8019234353Sdim // Do nothing. 8020234353Sdim } else if (FromEnum->isCompleteDefinition()) { 8021344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8022344779Sdim FromEnum, ToEnum, ASTNodeImporter::IDK_Basic)) 8023344779Sdim return std::move(Err); 8024234353Sdim } else { 8025234353Sdim CompleteDecl(ToEnum); 8026341825Sdim } 8027341825Sdim } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 8028341825Sdim auto *FromClass = cast<ObjCInterfaceDecl>(FromDC); 8029234353Sdim if (ToClass->getDefinition()) { 8030234353Sdim // Do nothing. 8031234353Sdim } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 8032344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8033344779Sdim FromDef, ToClass, ASTNodeImporter::IDK_Basic)) 8034344779Sdim return std::move(Err); 8035234353Sdim } else { 8036234353Sdim CompleteDecl(ToClass); 8037234353Sdim } 8038341825Sdim } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 8039341825Sdim auto *FromProto = cast<ObjCProtocolDecl>(FromDC); 8040234353Sdim if (ToProto->getDefinition()) { 8041234353Sdim // Do nothing. 8042234353Sdim } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 8043344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8044344779Sdim FromDef, ToProto, ASTNodeImporter::IDK_Basic)) 8045344779Sdim return std::move(Err); 8046234353Sdim } else { 8047234353Sdim CompleteDecl(ToProto); 8048341825Sdim } 8049234353Sdim } 8050341825Sdim 8051234353Sdim return ToDC; 8052203955Srdivacky} 8053203955Srdivacky 8054353358SdimExpected<Expr *> ASTImporter::Import(Expr *FromE) { 8055353358Sdim if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE))) 8056353358Sdim return cast_or_null<Expr>(*ToSOrErr); 8057353358Sdim else 8058353358Sdim return ToSOrErr.takeError(); 8059344779Sdim} 8060203955Srdivacky 8061353358SdimExpected<Stmt *> ASTImporter::Import(Stmt *FromS) { 8062203955Srdivacky if (!FromS) 8063276479Sdim return nullptr; 8064203955Srdivacky 8065353358Sdim // Check whether we've already imported this statement. 8066203955Srdivacky llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 8067203955Srdivacky if (Pos != ImportedStmts.end()) 8068203955Srdivacky return Pos->second; 8069341825Sdim 8070344779Sdim // Import the statement. 8071203955Srdivacky ASTNodeImporter Importer(*this); 8072344779Sdim ExpectedStmt ToSOrErr = Importer.Visit(FromS); 8073353358Sdim if (!ToSOrErr) 8074353358Sdim return ToSOrErr; 8075276479Sdim 8076344779Sdim if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) { 8077344779Sdim auto *FromE = cast<Expr>(FromS); 8078344779Sdim // Copy ExprBitfields, which may not be handled in Expr subclasses 8079344779Sdim // constructors. 8080344779Sdim ToE->setValueKind(FromE->getValueKind()); 8081344779Sdim ToE->setObjectKind(FromE->getObjectKind()); 8082344779Sdim ToE->setTypeDependent(FromE->isTypeDependent()); 8083344779Sdim ToE->setValueDependent(FromE->isValueDependent()); 8084344779Sdim ToE->setInstantiationDependent(FromE->isInstantiationDependent()); 8085344779Sdim ToE->setContainsUnexpandedParameterPack( 8086344779Sdim FromE->containsUnexpandedParameterPack()); 8087344779Sdim } 8088344779Sdim 8089353358Sdim // Record the imported statement object. 8090344779Sdim ImportedStmts[FromS] = *ToSOrErr; 8091353358Sdim return ToSOrErr; 8092203955Srdivacky} 8093203955Srdivacky 8094344779SdimExpected<NestedNameSpecifier *> 8095353358SdimASTImporter::Import(NestedNameSpecifier *FromNNS) { 8096203955Srdivacky if (!FromNNS) 8097276479Sdim return nullptr; 8098203955Srdivacky 8099353358Sdim NestedNameSpecifier *Prefix = nullptr; 8100353358Sdim if (Error Err = importInto(Prefix, FromNNS->getPrefix())) 8101353358Sdim return std::move(Err); 8102221345Sdim 8103221345Sdim switch (FromNNS->getKind()) { 8104221345Sdim case NestedNameSpecifier::Identifier: 8105353358Sdim assert(FromNNS->getAsIdentifier() && "NNS should contain identifier."); 8106353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8107353358Sdim Import(FromNNS->getAsIdentifier())); 8108221345Sdim 8109221345Sdim case NestedNameSpecifier::Namespace: 8110353358Sdim if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) { 8111353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8112353358Sdim cast<NamespaceDecl>(*NSOrErr)); 8113353358Sdim } else 8114353358Sdim return NSOrErr.takeError(); 8115221345Sdim 8116221345Sdim case NestedNameSpecifier::NamespaceAlias: 8117353358Sdim if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias())) 8118353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8119353358Sdim cast<NamespaceAliasDecl>(*NSADOrErr)); 8120353358Sdim else 8121353358Sdim return NSADOrErr.takeError(); 8122221345Sdim 8123221345Sdim case NestedNameSpecifier::Global: 8124221345Sdim return NestedNameSpecifier::GlobalSpecifier(ToContext); 8125221345Sdim 8126280031Sdim case NestedNameSpecifier::Super: 8127353358Sdim if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl())) 8128353358Sdim return NestedNameSpecifier::SuperSpecifier(ToContext, 8129353358Sdim cast<CXXRecordDecl>(*RDOrErr)); 8130353358Sdim else 8131353358Sdim return RDOrErr.takeError(); 8132280031Sdim 8133221345Sdim case NestedNameSpecifier::TypeSpec: 8134353358Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 8135353358Sdim if (Expected<QualType> TyOrErr = 8136353358Sdim Import(QualType(FromNNS->getAsType(), 0u))) { 8137353358Sdim bool TSTemplate = 8138353358Sdim FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate; 8139353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate, 8140353358Sdim TyOrErr->getTypePtr()); 8141353358Sdim } else { 8142353358Sdim return TyOrErr.takeError(); 8143221345Sdim } 8144221345Sdim } 8145221345Sdim 8146221345Sdim llvm_unreachable("Invalid nested name specifier kind"); 8147203955Srdivacky} 8148203955Srdivacky 8149344779SdimExpected<NestedNameSpecifierLoc> 8150353358SdimASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 8151321369Sdim // Copied from NestedNameSpecifier mostly. 8152321369Sdim SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 8153321369Sdim NestedNameSpecifierLoc NNS = FromNNS; 8154321369Sdim 8155321369Sdim // Push each of the nested-name-specifiers's onto a stack for 8156321369Sdim // serialization in reverse order. 8157321369Sdim while (NNS) { 8158321369Sdim NestedNames.push_back(NNS); 8159321369Sdim NNS = NNS.getPrefix(); 8160321369Sdim } 8161321369Sdim 8162321369Sdim NestedNameSpecifierLocBuilder Builder; 8163321369Sdim 8164321369Sdim while (!NestedNames.empty()) { 8165321369Sdim NNS = NestedNames.pop_back_val(); 8166353358Sdim NestedNameSpecifier *Spec = nullptr; 8167353358Sdim if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier())) 8168353358Sdim return std::move(Err); 8169321369Sdim 8170321369Sdim NestedNameSpecifier::SpecifierKind Kind = Spec->getKind(); 8171353358Sdim 8172353358Sdim SourceLocation ToLocalBeginLoc, ToLocalEndLoc; 8173353358Sdim if (Kind != NestedNameSpecifier::Super) { 8174353358Sdim if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc())) 8175353358Sdim return std::move(Err); 8176353358Sdim 8177353358Sdim if (Kind != NestedNameSpecifier::Global) 8178353358Sdim if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc())) 8179353358Sdim return std::move(Err); 8180353358Sdim } 8181353358Sdim 8182321369Sdim switch (Kind) { 8183321369Sdim case NestedNameSpecifier::Identifier: 8184353358Sdim Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc, 8185353358Sdim ToLocalEndLoc); 8186321369Sdim break; 8187321369Sdim 8188321369Sdim case NestedNameSpecifier::Namespace: 8189353358Sdim Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc, 8190353358Sdim ToLocalEndLoc); 8191321369Sdim break; 8192321369Sdim 8193321369Sdim case NestedNameSpecifier::NamespaceAlias: 8194353358Sdim Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(), 8195353358Sdim ToLocalBeginLoc, ToLocalEndLoc); 8196321369Sdim break; 8197321369Sdim 8198321369Sdim case NestedNameSpecifier::TypeSpec: 8199321369Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 8200353358Sdim SourceLocation ToTLoc; 8201353358Sdim if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc())) 8202353358Sdim return std::move(Err); 8203321369Sdim TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo( 8204353358Sdim QualType(Spec->getAsType(), 0), ToTLoc); 8205353358Sdim Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(), 8206353358Sdim ToLocalEndLoc); 8207321369Sdim break; 8208321369Sdim } 8209321369Sdim 8210321369Sdim case NestedNameSpecifier::Global: 8211353358Sdim Builder.MakeGlobal(getToContext(), ToLocalBeginLoc); 8212321369Sdim break; 8213321369Sdim 8214321369Sdim case NestedNameSpecifier::Super: { 8215353358Sdim auto ToSourceRangeOrErr = Import(NNS.getSourceRange()); 8216353358Sdim if (!ToSourceRangeOrErr) 8217353358Sdim return ToSourceRangeOrErr.takeError(); 8218353358Sdim 8219353358Sdim Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(), 8220353358Sdim ToSourceRangeOrErr->getBegin(), 8221353358Sdim ToSourceRangeOrErr->getEnd()); 8222321369Sdim } 8223321369Sdim } 8224321369Sdim } 8225321369Sdim 8226321369Sdim return Builder.getWithLocInContext(getToContext()); 8227219077Sdim} 8228219077Sdim 8229353358SdimExpected<TemplateName> ASTImporter::Import(TemplateName From) { 8230218893Sdim switch (From.getKind()) { 8231218893Sdim case TemplateName::Template: 8232353358Sdim if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl())) 8233353358Sdim return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr)); 8234353358Sdim else 8235353358Sdim return ToTemplateOrErr.takeError(); 8236341825Sdim 8237218893Sdim case TemplateName::OverloadedTemplate: { 8238218893Sdim OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 8239218893Sdim UnresolvedSet<2> ToTemplates; 8240341825Sdim for (auto *I : *FromStorage) { 8241353358Sdim if (auto ToOrErr = Import(I)) 8242353358Sdim ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr)); 8243218893Sdim else 8244353358Sdim return ToOrErr.takeError(); 8245218893Sdim } 8246341825Sdim return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 8247218893Sdim ToTemplates.end()); 8248218893Sdim } 8249341825Sdim 8250353358Sdim case TemplateName::AssumedTemplate: { 8251353358Sdim AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName(); 8252353358Sdim auto DeclNameOrErr = Import(FromStorage->getDeclName()); 8253353358Sdim if (!DeclNameOrErr) 8254353358Sdim return DeclNameOrErr.takeError(); 8255353358Sdim return ToContext.getAssumedTemplateName(*DeclNameOrErr); 8256353358Sdim } 8257353358Sdim 8258218893Sdim case TemplateName::QualifiedTemplate: { 8259218893Sdim QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 8260353358Sdim auto QualifierOrErr = Import(QTN->getQualifier()); 8261353358Sdim if (!QualifierOrErr) 8262353358Sdim return QualifierOrErr.takeError(); 8263341825Sdim 8264353358Sdim if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl())) 8265353358Sdim return ToContext.getQualifiedTemplateName( 8266353358Sdim *QualifierOrErr, QTN->hasTemplateKeyword(), 8267353358Sdim cast<TemplateDecl>(*ToTemplateOrErr)); 8268353358Sdim else 8269353358Sdim return ToTemplateOrErr.takeError(); 8270218893Sdim } 8271341825Sdim 8272218893Sdim case TemplateName::DependentTemplate: { 8273218893Sdim DependentTemplateName *DTN = From.getAsDependentTemplateName(); 8274353358Sdim auto QualifierOrErr = Import(DTN->getQualifier()); 8275353358Sdim if (!QualifierOrErr) 8276353358Sdim return QualifierOrErr.takeError(); 8277341825Sdim 8278218893Sdim if (DTN->isIdentifier()) { 8279353358Sdim return ToContext.getDependentTemplateName(*QualifierOrErr, 8280218893Sdim Import(DTN->getIdentifier())); 8281218893Sdim } 8282341825Sdim 8283353358Sdim return ToContext.getDependentTemplateName(*QualifierOrErr, 8284353358Sdim DTN->getOperator()); 8285218893Sdim } 8286224145Sdim 8287224145Sdim case TemplateName::SubstTemplateTemplateParm: { 8288353358Sdim SubstTemplateTemplateParmStorage *Subst = 8289353358Sdim From.getAsSubstTemplateTemplateParm(); 8290353358Sdim ExpectedDecl ParamOrErr = Import(Subst->getParameter()); 8291353358Sdim if (!ParamOrErr) 8292353358Sdim return ParamOrErr.takeError(); 8293224145Sdim 8294353358Sdim auto ReplacementOrErr = Import(Subst->getReplacement()); 8295353358Sdim if (!ReplacementOrErr) 8296353358Sdim return ReplacementOrErr.takeError(); 8297341825Sdim 8298353358Sdim return ToContext.getSubstTemplateTemplateParm( 8299353358Sdim cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr); 8300224145Sdim } 8301341825Sdim 8302218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 8303218893Sdim SubstTemplateTemplateParmPackStorage *SubstPack 8304218893Sdim = From.getAsSubstTemplateTemplateParmPack(); 8305353358Sdim ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack()); 8306353358Sdim if (!ParamOrErr) 8307353358Sdim return ParamOrErr.takeError(); 8308341825Sdim 8309218893Sdim ASTNodeImporter Importer(*this); 8310353358Sdim auto ArgPackOrErr = 8311353358Sdim Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 8312353358Sdim if (!ArgPackOrErr) 8313353358Sdim return ArgPackOrErr.takeError(); 8314341825Sdim 8315353358Sdim return ToContext.getSubstTemplateTemplateParmPack( 8316353358Sdim cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr); 8317218893Sdim } 8318218893Sdim } 8319341825Sdim 8320218893Sdim llvm_unreachable("Invalid template name kind"); 8321218893Sdim} 8322218893Sdim 8323353358SdimExpected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) { 8324203955Srdivacky if (FromLoc.isInvalid()) 8325353358Sdim return SourceLocation{}; 8326203955Srdivacky 8327203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 8328353358Sdim bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc); 8329341825Sdim 8330203955Srdivacky std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 8331353358Sdim Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin); 8332353358Sdim if (!ToFileIDOrErr) 8333353358Sdim return ToFileIDOrErr.takeError(); 8334341825Sdim SourceManager &ToSM = ToContext.getSourceManager(); 8335353358Sdim return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second); 8336203955Srdivacky} 8337203955Srdivacky 8338353358SdimExpected<SourceRange> ASTImporter::Import(SourceRange FromRange) { 8339353358Sdim SourceLocation ToBegin, ToEnd; 8340353358Sdim if (Error Err = importInto(ToBegin, FromRange.getBegin())) 8341353358Sdim return std::move(Err); 8342353358Sdim if (Error Err = importInto(ToEnd, FromRange.getEnd())) 8343353358Sdim return std::move(Err); 8344353358Sdim 8345353358Sdim return SourceRange(ToBegin, ToEnd); 8346344779Sdim} 8347203955Srdivacky 8348353358SdimExpected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) { 8349341825Sdim llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID); 8350203955Srdivacky if (Pos != ImportedFileIDs.end()) 8351203955Srdivacky return Pos->second; 8352341825Sdim 8353203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 8354203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 8355203955Srdivacky const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 8356341825Sdim 8357341825Sdim // Map the FromID to the "to" source manager. 8358203955Srdivacky FileID ToID; 8359341825Sdim if (FromSLoc.isExpansion()) { 8360341825Sdim const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion(); 8361353358Sdim ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc()); 8362353358Sdim if (!ToSpLoc) 8363353358Sdim return ToSpLoc.takeError(); 8364353358Sdim ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart()); 8365353358Sdim if (!ToExLocS) 8366353358Sdim return ToExLocS.takeError(); 8367341825Sdim unsigned TokenLen = FromSM.getFileIDSize(FromID); 8368341825Sdim SourceLocation MLoc; 8369341825Sdim if (FromEx.isMacroArgExpansion()) { 8370353358Sdim MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen); 8371341825Sdim } else { 8372353358Sdim if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd())) 8373353358Sdim MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen, 8374353358Sdim FromEx.isExpansionTokenRange()); 8375353358Sdim else 8376353358Sdim return ToExLocE.takeError(); 8377341825Sdim } 8378341825Sdim ToID = ToSM.getFileID(MLoc); 8379203955Srdivacky } else { 8380353358Sdim const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 8381341825Sdim 8382353358Sdim if (!IsBuiltin) { 8383353358Sdim // Include location of this file. 8384353358Sdim ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 8385353358Sdim if (!ToIncludeLoc) 8386353358Sdim return ToIncludeLoc.takeError(); 8387353358Sdim 8388353358Sdim if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 8389353358Sdim // FIXME: We probably want to use getVirtualFile(), so we don't hit the 8390353358Sdim // disk again 8391353358Sdim // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 8392353358Sdim // than mmap the files several times. 8393353358Sdim const FileEntry *Entry = 8394353358Sdim ToFileManager.getFile(Cache->OrigEntry->getName()); 8395353358Sdim // FIXME: The filename may be a virtual name that does probably not 8396353358Sdim // point to a valid file and we get no Entry here. In this case try with 8397353358Sdim // the memory buffer below. 8398353358Sdim if (Entry) 8399353358Sdim ToID = ToSM.createFileID(Entry, *ToIncludeLoc, 8400353358Sdim FromSLoc.getFile().getFileCharacteristic()); 8401353358Sdim } 8402353358Sdim } 8403353358Sdim 8404353358Sdim if (ToID.isInvalid() || IsBuiltin) { 8405341825Sdim // FIXME: We want to re-use the existing MemoryBuffer! 8406353358Sdim bool Invalid = true; 8407353358Sdim const llvm::MemoryBuffer *FromBuf = Cache->getBuffer( 8408353358Sdim FromContext.getDiagnostics(), FromSM, SourceLocation{}, &Invalid); 8409353358Sdim if (!FromBuf || Invalid) 8410353358Sdim // FIXME: Use a new error kind? 8411353358Sdim return llvm::make_error<ImportError>(ImportError::Unknown); 8412353358Sdim 8413341825Sdim std::unique_ptr<llvm::MemoryBuffer> ToBuf = 8414341825Sdim llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 8415341825Sdim FromBuf->getBufferIdentifier()); 8416341825Sdim ToID = ToSM.createFileID(std::move(ToBuf), 8417341825Sdim FromSLoc.getFile().getFileCharacteristic()); 8418341825Sdim } 8419203955Srdivacky } 8420341825Sdim 8421353358Sdim assert(ToID.isValid() && "Unexpected invalid fileID was created."); 8422353358Sdim 8423218893Sdim ImportedFileIDs[FromID] = ToID; 8424203955Srdivacky return ToID; 8425203955Srdivacky} 8426203955Srdivacky 8427353358SdimExpected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) { 8428353358Sdim ExpectedExpr ToExprOrErr = Import(From->getInit()); 8429353358Sdim if (!ToExprOrErr) 8430353358Sdim return ToExprOrErr.takeError(); 8431309124Sdim 8432353358Sdim auto LParenLocOrErr = Import(From->getLParenLoc()); 8433353358Sdim if (!LParenLocOrErr) 8434353358Sdim return LParenLocOrErr.takeError(); 8435353358Sdim 8436353358Sdim auto RParenLocOrErr = Import(From->getRParenLoc()); 8437353358Sdim if (!RParenLocOrErr) 8438353358Sdim return RParenLocOrErr.takeError(); 8439353358Sdim 8440309124Sdim if (From->isBaseInitializer()) { 8441353358Sdim auto ToTInfoOrErr = Import(From->getTypeSourceInfo()); 8442353358Sdim if (!ToTInfoOrErr) 8443353358Sdim return ToTInfoOrErr.takeError(); 8444309124Sdim 8445353358Sdim SourceLocation EllipsisLoc; 8446353358Sdim if (From->isPackExpansion()) 8447353358Sdim if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc())) 8448353358Sdim return std::move(Err); 8449353358Sdim 8450309124Sdim return new (ToContext) CXXCtorInitializer( 8451353358Sdim ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr, 8452353358Sdim *ToExprOrErr, *RParenLocOrErr, EllipsisLoc); 8453309124Sdim } else if (From->isMemberInitializer()) { 8454353358Sdim ExpectedDecl ToFieldOrErr = Import(From->getMember()); 8455353358Sdim if (!ToFieldOrErr) 8456353358Sdim return ToFieldOrErr.takeError(); 8457309124Sdim 8458353358Sdim auto MemberLocOrErr = Import(From->getMemberLocation()); 8459353358Sdim if (!MemberLocOrErr) 8460353358Sdim return MemberLocOrErr.takeError(); 8461353358Sdim 8462309124Sdim return new (ToContext) CXXCtorInitializer( 8463353358Sdim ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr, 8464353358Sdim *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr); 8465309124Sdim } else if (From->isIndirectMemberInitializer()) { 8466353358Sdim ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember()); 8467353358Sdim if (!ToIFieldOrErr) 8468353358Sdim return ToIFieldOrErr.takeError(); 8469309124Sdim 8470353358Sdim auto MemberLocOrErr = Import(From->getMemberLocation()); 8471353358Sdim if (!MemberLocOrErr) 8472353358Sdim return MemberLocOrErr.takeError(); 8473353358Sdim 8474309124Sdim return new (ToContext) CXXCtorInitializer( 8475353358Sdim ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr), 8476353358Sdim *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr); 8477309124Sdim } else if (From->isDelegatingInitializer()) { 8478353358Sdim auto ToTInfoOrErr = Import(From->getTypeSourceInfo()); 8479353358Sdim if (!ToTInfoOrErr) 8480353358Sdim return ToTInfoOrErr.takeError(); 8481309124Sdim 8482309124Sdim return new (ToContext) 8483353358Sdim CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr, 8484353358Sdim *ToExprOrErr, *RParenLocOrErr); 8485309124Sdim } else { 8486353358Sdim // FIXME: assert? 8487353358Sdim return make_error<ImportError>(); 8488309124Sdim } 8489309124Sdim} 8490309124Sdim 8491344779SdimExpected<CXXBaseSpecifier *> 8492353358SdimASTImporter::Import(const CXXBaseSpecifier *BaseSpec) { 8493314564Sdim auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec); 8494314564Sdim if (Pos != ImportedCXXBaseSpecifiers.end()) 8495314564Sdim return Pos->second; 8496314564Sdim 8497353358Sdim Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange()); 8498353358Sdim if (!ToSourceRange) 8499353358Sdim return ToSourceRange.takeError(); 8500353358Sdim Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo()); 8501353358Sdim if (!ToTSI) 8502353358Sdim return ToTSI.takeError(); 8503353358Sdim ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc()); 8504353358Sdim if (!ToEllipsisLoc) 8505353358Sdim return ToEllipsisLoc.takeError(); 8506314564Sdim CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier( 8507353358Sdim *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(), 8508353358Sdim BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc); 8509314564Sdim ImportedCXXBaseSpecifiers[BaseSpec] = Imported; 8510314564Sdim return Imported; 8511314564Sdim} 8512314564Sdim 8513353358SdimError ASTImporter::ImportDefinition(Decl *From) { 8514353358Sdim ExpectedDecl ToOrErr = Import(From); 8515353358Sdim if (!ToOrErr) 8516353358Sdim return ToOrErr.takeError(); 8517353358Sdim Decl *To = *ToOrErr; 8518341825Sdim 8519353358Sdim auto *FromDC = cast<DeclContext>(From); 8520353358Sdim ASTNodeImporter Importer(*this); 8521341825Sdim 8522353358Sdim if (auto *ToRecord = dyn_cast<RecordDecl>(To)) { 8523353358Sdim if (!ToRecord->getDefinition()) { 8524353358Sdim return Importer.ImportDefinition( 8525353358Sdim cast<RecordDecl>(FromDC), ToRecord, 8526353358Sdim ASTNodeImporter::IDK_Everything); 8527226633Sdim } 8528353358Sdim } 8529226633Sdim 8530353358Sdim if (auto *ToEnum = dyn_cast<EnumDecl>(To)) { 8531353358Sdim if (!ToEnum->getDefinition()) { 8532353358Sdim return Importer.ImportDefinition( 8533353358Sdim cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything); 8534226633Sdim } 8535353358Sdim } 8536341825Sdim 8537353358Sdim if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 8538353358Sdim if (!ToIFace->getDefinition()) { 8539353358Sdim return Importer.ImportDefinition( 8540353358Sdim cast<ObjCInterfaceDecl>(FromDC), ToIFace, 8541353358Sdim ASTNodeImporter::IDK_Everything); 8542234353Sdim } 8543353358Sdim } 8544226633Sdim 8545353358Sdim if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 8546353358Sdim if (!ToProto->getDefinition()) { 8547353358Sdim return Importer.ImportDefinition( 8548353358Sdim cast<ObjCProtocolDecl>(FromDC), ToProto, 8549353358Sdim ASTNodeImporter::IDK_Everything); 8550234353Sdim } 8551218893Sdim } 8552344779Sdim 8553353358Sdim return Importer.ImportDeclContext(FromDC, true); 8554218893Sdim} 8555218893Sdim 8556353358SdimExpected<DeclarationName> ASTImporter::Import(DeclarationName FromName) { 8557203955Srdivacky if (!FromName) 8558353358Sdim return DeclarationName{}; 8559203955Srdivacky 8560203955Srdivacky switch (FromName.getNameKind()) { 8561203955Srdivacky case DeclarationName::Identifier: 8562353358Sdim return DeclarationName(Import(FromName.getAsIdentifierInfo())); 8563203955Srdivacky 8564203955Srdivacky case DeclarationName::ObjCZeroArgSelector: 8565203955Srdivacky case DeclarationName::ObjCOneArgSelector: 8566203955Srdivacky case DeclarationName::ObjCMultiArgSelector: 8567353358Sdim if (auto ToSelOrErr = Import(FromName.getObjCSelector())) 8568353358Sdim return DeclarationName(*ToSelOrErr); 8569353358Sdim else 8570353358Sdim return ToSelOrErr.takeError(); 8571203955Srdivacky 8572203955Srdivacky case DeclarationName::CXXConstructorName: { 8573353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8574353358Sdim return ToContext.DeclarationNames.getCXXConstructorName( 8575353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8576353358Sdim else 8577353358Sdim return ToTyOrErr.takeError(); 8578203955Srdivacky } 8579203955Srdivacky 8580203955Srdivacky case DeclarationName::CXXDestructorName: { 8581353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8582353358Sdim return ToContext.DeclarationNames.getCXXDestructorName( 8583353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8584353358Sdim else 8585353358Sdim return ToTyOrErr.takeError(); 8586203955Srdivacky } 8587203955Srdivacky 8588321369Sdim case DeclarationName::CXXDeductionGuideName: { 8589353358Sdim if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate())) 8590353358Sdim return ToContext.DeclarationNames.getCXXDeductionGuideName( 8591353358Sdim cast<TemplateDecl>(*ToTemplateOrErr)); 8592353358Sdim else 8593353358Sdim return ToTemplateOrErr.takeError(); 8594321369Sdim } 8595321369Sdim 8596203955Srdivacky case DeclarationName::CXXConversionFunctionName: { 8597353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8598353358Sdim return ToContext.DeclarationNames.getCXXConversionFunctionName( 8599353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8600353358Sdim else 8601353358Sdim return ToTyOrErr.takeError(); 8602203955Srdivacky } 8603203955Srdivacky 8604203955Srdivacky case DeclarationName::CXXOperatorName: 8605203955Srdivacky return ToContext.DeclarationNames.getCXXOperatorName( 8606203955Srdivacky FromName.getCXXOverloadedOperator()); 8607203955Srdivacky 8608203955Srdivacky case DeclarationName::CXXLiteralOperatorName: 8609203955Srdivacky return ToContext.DeclarationNames.getCXXLiteralOperatorName( 8610353358Sdim Import(FromName.getCXXLiteralIdentifier())); 8611203955Srdivacky 8612203955Srdivacky case DeclarationName::CXXUsingDirective: 8613203955Srdivacky // FIXME: STATICS! 8614203955Srdivacky return DeclarationName::getUsingDirectiveName(); 8615203955Srdivacky } 8616203955Srdivacky 8617234353Sdim llvm_unreachable("Invalid DeclarationName Kind!"); 8618203955Srdivacky} 8619203955Srdivacky 8620218893SdimIdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 8621203955Srdivacky if (!FromId) 8622276479Sdim return nullptr; 8623203955Srdivacky 8624309124Sdim IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName()); 8625309124Sdim 8626309124Sdim if (!ToId->getBuiltinID() && FromId->getBuiltinID()) 8627309124Sdim ToId->setBuiltinID(FromId->getBuiltinID()); 8628309124Sdim 8629309124Sdim return ToId; 8630203955Srdivacky} 8631203955Srdivacky 8632353358SdimExpected<Selector> ASTImporter::Import(Selector FromSel) { 8633204643Srdivacky if (FromSel.isNull()) 8634353358Sdim return Selector{}; 8635204643Srdivacky 8636226633Sdim SmallVector<IdentifierInfo *, 4> Idents; 8637204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 8638204643Srdivacky for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 8639204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 8640204643Srdivacky return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 8641204643Srdivacky} 8642204643Srdivacky 8643203955SrdivackyDeclarationName ASTImporter::HandleNameConflict(DeclarationName Name, 8644203955Srdivacky DeclContext *DC, 8645203955Srdivacky unsigned IDNS, 8646203955Srdivacky NamedDecl **Decls, 8647203955Srdivacky unsigned NumDecls) { 8648203955Srdivacky return Name; 8649203955Srdivacky} 8650203955Srdivacky 8651203955SrdivackyDiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 8652249423Sdim if (LastDiagFromFrom) 8653249423Sdim ToContext.getDiagnostics().notePriorDiagnosticFrom( 8654249423Sdim FromContext.getDiagnostics()); 8655249423Sdim LastDiagFromFrom = false; 8656218893Sdim return ToContext.getDiagnostics().Report(Loc, DiagID); 8657203955Srdivacky} 8658203955Srdivacky 8659203955SrdivackyDiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 8660249423Sdim if (!LastDiagFromFrom) 8661249423Sdim FromContext.getDiagnostics().notePriorDiagnosticFrom( 8662249423Sdim ToContext.getDiagnostics()); 8663249423Sdim LastDiagFromFrom = true; 8664218893Sdim return FromContext.getDiagnostics().Report(Loc, DiagID); 8665203955Srdivacky} 8666203955Srdivacky 8667234353Sdimvoid ASTImporter::CompleteDecl (Decl *D) { 8668341825Sdim if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 8669234353Sdim if (!ID->getDefinition()) 8670234353Sdim ID->startDefinition(); 8671234353Sdim } 8672341825Sdim else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) { 8673234353Sdim if (!PD->getDefinition()) 8674234353Sdim PD->startDefinition(); 8675234353Sdim } 8676341825Sdim else if (auto *TD = dyn_cast<TagDecl>(D)) { 8677234353Sdim if (!TD->getDefinition() && !TD->isBeingDefined()) { 8678234353Sdim TD->startDefinition(); 8679234353Sdim TD->setCompleteDefinition(true); 8680234353Sdim } 8681234353Sdim } 8682234353Sdim else { 8683341825Sdim assert(0 && "CompleteDecl called on a Decl that can't be completed"); 8684234353Sdim } 8685234353Sdim} 8686234353Sdim 8687341825SdimDecl *ASTImporter::MapImported(Decl *From, Decl *To) { 8688341825Sdim llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From); 8689341825Sdim assert((Pos == ImportedDecls.end() || Pos->second == To) && 8690341825Sdim "Try to import an already imported Decl"); 8691341825Sdim if (Pos != ImportedDecls.end()) 8692341825Sdim return Pos->second; 8693203955Srdivacky ImportedDecls[From] = To; 8694353358Sdim // This mapping should be maintained only in this function. Therefore do not 8695353358Sdim // check for additional consistency. 8696353358Sdim ImportedFromDecls[To] = From; 8697353358Sdim AddToLookupTable(To); 8698203955Srdivacky return To; 8699203955Srdivacky} 8700203955Srdivacky 8701353358Sdimllvm::Optional<ImportError> 8702353358SdimASTImporter::getImportDeclErrorIfAny(Decl *FromD) const { 8703353358Sdim auto Pos = ImportDeclErrors.find(FromD); 8704353358Sdim if (Pos != ImportDeclErrors.end()) 8705353358Sdim return Pos->second; 8706353358Sdim else 8707353358Sdim return Optional<ImportError>(); 8708353358Sdim} 8709353358Sdim 8710353358Sdimvoid ASTImporter::setImportDeclError(Decl *From, ImportError Error) { 8711353358Sdim auto InsertRes = ImportDeclErrors.insert({From, Error}); 8712353358Sdim (void)InsertRes; 8713353358Sdim // Either we set the error for the first time, or we already had set one and 8714353358Sdim // now we want to set the same error. 8715353358Sdim assert(InsertRes.second || InsertRes.first->second.Error == Error.Error); 8716353358Sdim} 8717353358Sdim 8718239462Sdimbool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 8719239462Sdim bool Complain) { 8720353358Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos = 8721353358Sdim ImportedTypes.find(From.getTypePtr()); 8722353358Sdim if (Pos != ImportedTypes.end()) { 8723353358Sdim if (ExpectedType ToFromOrErr = Import(From)) { 8724353358Sdim if (ToContext.hasSameType(*ToFromOrErr, To)) 8725353358Sdim return true; 8726353358Sdim } else { 8727353358Sdim llvm::consumeError(ToFromOrErr.takeError()); 8728353358Sdim } 8729353358Sdim } 8730321369Sdim 8731239462Sdim StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 8732341825Sdim getStructuralEquivalenceKind(*this), false, 8733341825Sdim Complain); 8734341825Sdim return Ctx.IsEquivalent(From, To); 8735203955Srdivacky} 8736