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" 47360784Sdim#include "clang/Basic/Builtins.h" 48341825Sdim#include "clang/Basic/ExceptionSpecificationType.h" 49203955Srdivacky#include "clang/Basic/FileManager.h" 50341825Sdim#include "clang/Basic/IdentifierTable.h" 51341825Sdim#include "clang/Basic/LLVM.h" 52341825Sdim#include "clang/Basic/LangOptions.h" 53341825Sdim#include "clang/Basic/SourceLocation.h" 54203955Srdivacky#include "clang/Basic/SourceManager.h" 55341825Sdim#include "clang/Basic/Specifiers.h" 56341825Sdim#include "llvm/ADT/APSInt.h" 57341825Sdim#include "llvm/ADT/ArrayRef.h" 58341825Sdim#include "llvm/ADT/DenseMap.h" 59341825Sdim#include "llvm/ADT/None.h" 60341825Sdim#include "llvm/ADT/Optional.h" 61353358Sdim#include "llvm/ADT/ScopeExit.h" 62341825Sdim#include "llvm/ADT/STLExtras.h" 63341825Sdim#include "llvm/ADT/SmallVector.h" 64341825Sdim#include "llvm/Support/Casting.h" 65341825Sdim#include "llvm/Support/ErrorHandling.h" 66203955Srdivacky#include "llvm/Support/MemoryBuffer.h" 67341825Sdim#include <algorithm> 68341825Sdim#include <cassert> 69341825Sdim#include <cstddef> 70341825Sdim#include <memory> 71341825Sdim#include <type_traits> 72341825Sdim#include <utility> 73203955Srdivacky 74234353Sdimnamespace clang { 75341825Sdim 76344779Sdim using llvm::make_error; 77344779Sdim using llvm::Error; 78344779Sdim using llvm::Expected; 79344779Sdim using ExpectedType = llvm::Expected<QualType>; 80344779Sdim using ExpectedStmt = llvm::Expected<Stmt *>; 81344779Sdim using ExpectedExpr = llvm::Expected<Expr *>; 82344779Sdim using ExpectedDecl = llvm::Expected<Decl *>; 83344779Sdim using ExpectedSLoc = llvm::Expected<SourceLocation>; 84360784Sdim using ExpectedName = llvm::Expected<DeclarationName>; 85344779Sdim 86344779Sdim std::string ImportError::toString() const { 87344779Sdim // FIXME: Improve error texts. 88344779Sdim switch (Error) { 89344779Sdim case NameConflict: 90344779Sdim return "NameConflict"; 91344779Sdim case UnsupportedConstruct: 92344779Sdim return "UnsupportedConstruct"; 93344779Sdim case Unknown: 94344779Sdim return "Unknown error"; 95344779Sdim } 96344779Sdim llvm_unreachable("Invalid error code."); 97344779Sdim return "Invalid error code."; 98344779Sdim } 99344779Sdim 100344779Sdim void ImportError::log(raw_ostream &OS) const { 101344779Sdim OS << toString(); 102344779Sdim } 103344779Sdim 104344779Sdim std::error_code ImportError::convertToErrorCode() const { 105344779Sdim llvm_unreachable("Function not implemented."); 106344779Sdim } 107344779Sdim 108344779Sdim char ImportError::ID; 109344779Sdim 110341825Sdim template <class T> 111344779Sdim SmallVector<Decl *, 2> 112341825Sdim getCanonicalForwardRedeclChain(Redeclarable<T>* D) { 113344779Sdim SmallVector<Decl *, 2> Redecls; 114341825Sdim for (auto *R : D->getFirstDecl()->redecls()) { 115341825Sdim if (R != D->getFirstDecl()) 116341825Sdim Redecls.push_back(R); 117341825Sdim } 118341825Sdim Redecls.push_back(D->getFirstDecl()); 119341825Sdim std::reverse(Redecls.begin(), Redecls.end()); 120341825Sdim return Redecls; 121341825Sdim } 122341825Sdim 123341825Sdim SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) { 124344779Sdim if (auto *FD = dyn_cast<FunctionDecl>(D)) 125344779Sdim return getCanonicalForwardRedeclChain<FunctionDecl>(FD); 126344779Sdim if (auto *VD = dyn_cast<VarDecl>(D)) 127344779Sdim return getCanonicalForwardRedeclChain<VarDecl>(VD); 128344779Sdim if (auto *TD = dyn_cast<TagDecl>(D)) 129344779Sdim return getCanonicalForwardRedeclChain<TagDecl>(TD); 130344779Sdim llvm_unreachable("Bad declaration kind"); 131341825Sdim } 132341825Sdim 133341825Sdim void updateFlags(const Decl *From, Decl *To) { 134341825Sdim // Check if some flags or attrs are new in 'From' and copy into 'To'. 135341825Sdim // FIXME: Other flags or attrs? 136341825Sdim if (From->isUsed(false) && !To->isUsed(false)) 137341825Sdim To->setIsUsed(); 138341825Sdim } 139341825Sdim 140344779Sdim class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>, 141344779Sdim public DeclVisitor<ASTNodeImporter, ExpectedDecl>, 142344779Sdim public StmtVisitor<ASTNodeImporter, ExpectedStmt> { 143203955Srdivacky ASTImporter &Importer; 144309124Sdim 145344779Sdim // Use this instead of Importer.importInto . 146344779Sdim template <typename ImportT> 147344779Sdim LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) { 148344779Sdim return Importer.importInto(To, From); 149344779Sdim } 150344779Sdim 151344779Sdim // Use this to import pointers of specific type. 152344779Sdim template <typename ImportT> 153344779Sdim LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) { 154353358Sdim auto ToOrErr = Importer.Import(From); 155353358Sdim if (ToOrErr) 156353358Sdim To = cast_or_null<ImportT>(*ToOrErr); 157353358Sdim return ToOrErr.takeError(); 158344779Sdim } 159344779Sdim 160344779Sdim // Call the import function of ASTImporter for a baseclass of type `T` and 161344779Sdim // cast the return value to `T`. 162344779Sdim template <typename T> 163344779Sdim Expected<T *> import(T *From) { 164353358Sdim auto ToOrErr = Importer.Import(From); 165353358Sdim if (!ToOrErr) 166353358Sdim return ToOrErr.takeError(); 167353358Sdim return cast_or_null<T>(*ToOrErr); 168344779Sdim } 169344779Sdim 170344779Sdim template <typename T> 171344779Sdim Expected<T *> import(const T *From) { 172344779Sdim return import(const_cast<T *>(From)); 173344779Sdim } 174344779Sdim 175344779Sdim // Call the import function of ASTImporter for type `T`. 176344779Sdim template <typename T> 177344779Sdim Expected<T> import(const T &From) { 178353358Sdim return Importer.Import(From); 179344779Sdim } 180344779Sdim 181353358Sdim // Import an Optional<T> by importing the contained T, if any. 182353358Sdim template<typename T> 183353358Sdim Expected<Optional<T>> import(Optional<T> From) { 184353358Sdim if (!From) 185353358Sdim return Optional<T>(); 186353358Sdim return import(*From); 187353358Sdim } 188353358Sdim 189344779Sdim template <class T> 190344779Sdim Expected<std::tuple<T>> 191344779Sdim importSeq(const T &From) { 192344779Sdim Expected<T> ToOrErr = import(From); 193344779Sdim if (!ToOrErr) 194344779Sdim return ToOrErr.takeError(); 195344779Sdim return std::make_tuple<T>(std::move(*ToOrErr)); 196344779Sdim } 197344779Sdim 198344779Sdim // Import multiple objects with a single function call. 199344779Sdim // This should work for every type for which a variant of `import` exists. 200344779Sdim // The arguments are processed from left to right and import is stopped on 201344779Sdim // first error. 202344779Sdim template <class THead, class... TTail> 203344779Sdim Expected<std::tuple<THead, TTail...>> 204344779Sdim importSeq(const THead &FromHead, const TTail &...FromTail) { 205344779Sdim Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead); 206344779Sdim if (!ToHeadOrErr) 207344779Sdim return ToHeadOrErr.takeError(); 208344779Sdim Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...); 209344779Sdim if (!ToTailOrErr) 210344779Sdim return ToTailOrErr.takeError(); 211344779Sdim return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr); 212344779Sdim } 213344779Sdim 214344779Sdim// Wrapper for an overload set. 215341825Sdim template <typename ToDeclT> struct CallOverloadedCreateFun { 216341825Sdim template <typename... Args> 217341825Sdim auto operator()(Args &&... args) 218341825Sdim -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) { 219341825Sdim return ToDeclT::Create(std::forward<Args>(args)...); 220341825Sdim } 221341825Sdim }; 222341825Sdim 223341825Sdim // Always use these functions to create a Decl during import. There are 224341825Sdim // certain tasks which must be done after the Decl was created, e.g. we 225341825Sdim // must immediately register that as an imported Decl. The parameter `ToD` 226341825Sdim // will be set to the newly created Decl or if had been imported before 227341825Sdim // then to the already imported Decl. Returns a bool value set to true if 228341825Sdim // the `FromD` had been imported before. 229341825Sdim template <typename ToDeclT, typename FromDeclT, typename... Args> 230341825Sdim LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD, 231341825Sdim Args &&... args) { 232341825Sdim // There may be several overloads of ToDeclT::Create. We must make sure 233341825Sdim // to call the one which would be chosen by the arguments, thus we use a 234341825Sdim // wrapper for the overload set. 235341825Sdim CallOverloadedCreateFun<ToDeclT> OC; 236341825Sdim return GetImportedOrCreateSpecialDecl(ToD, OC, FromD, 237341825Sdim std::forward<Args>(args)...); 238341825Sdim } 239341825Sdim // Use this overload if a special Type is needed to be created. E.g if we 240341825Sdim // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl` 241341825Sdim // then: 242341825Sdim // TypedefNameDecl *ToTypedef; 243341825Sdim // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...); 244341825Sdim template <typename NewDeclT, typename ToDeclT, typename FromDeclT, 245341825Sdim typename... Args> 246341825Sdim LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD, 247341825Sdim Args &&... args) { 248341825Sdim CallOverloadedCreateFun<NewDeclT> OC; 249341825Sdim return GetImportedOrCreateSpecialDecl(ToD, OC, FromD, 250341825Sdim std::forward<Args>(args)...); 251341825Sdim } 252341825Sdim // Use this version if a special create function must be 253341825Sdim // used, e.g. CXXRecordDecl::CreateLambda . 254341825Sdim template <typename ToDeclT, typename CreateFunT, typename FromDeclT, 255341825Sdim typename... Args> 256341825Sdim LLVM_NODISCARD bool 257341825Sdim GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun, 258341825Sdim FromDeclT *FromD, Args &&... args) { 259353358Sdim if (Importer.getImportDeclErrorIfAny(FromD)) { 260353358Sdim ToD = nullptr; 261353358Sdim return true; // Already imported but with error. 262353358Sdim } 263341825Sdim ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD)); 264341825Sdim if (ToD) 265341825Sdim return true; // Already imported. 266341825Sdim ToD = CreateFun(std::forward<Args>(args)...); 267344779Sdim // Keep track of imported Decls. 268353358Sdim Importer.RegisterImportedDecl(FromD, ToD); 269341825Sdim InitializeImportedDecl(FromD, ToD); 270341825Sdim return false; // A new Decl is created. 271341825Sdim } 272341825Sdim 273341825Sdim void InitializeImportedDecl(Decl *FromD, Decl *ToD) { 274341825Sdim ToD->IdentifierNamespace = FromD->IdentifierNamespace; 275341825Sdim if (FromD->hasAttrs()) 276353358Sdim for (const Attr *FromAttr : FromD->getAttrs()) { 277353358Sdim // FIXME: Return of the error here is not possible until store of 278353358Sdim // import errors is implemented. 279353358Sdim auto ToAttrOrErr = import(FromAttr); 280353358Sdim if (ToAttrOrErr) 281353358Sdim ToD->addAttr(*ToAttrOrErr); 282353358Sdim else 283353358Sdim llvm::consumeError(ToAttrOrErr.takeError()); 284353358Sdim } 285341825Sdim if (FromD->isUsed()) 286341825Sdim ToD->setIsUsed(); 287341825Sdim if (FromD->isImplicit()) 288341825Sdim ToD->setImplicit(); 289341825Sdim } 290341825Sdim 291353358Sdim // Check if we have found an existing definition. Returns with that 292353358Sdim // definition if yes, otherwise returns null. 293353358Sdim Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) { 294353358Sdim const FunctionDecl *Definition = nullptr; 295353358Sdim if (D->doesThisDeclarationHaveABody() && 296353358Sdim FoundFunction->hasBody(Definition)) 297353358Sdim return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition)); 298353358Sdim return nullptr; 299353358Sdim } 300353358Sdim 301360784Sdim void addDeclToContexts(Decl *FromD, Decl *ToD) { 302360784Sdim if (Importer.isMinimalImport()) { 303360784Sdim // In minimal import case the decl must be added even if it is not 304360784Sdim // contained in original context, for LLDB compatibility. 305360784Sdim // FIXME: Check if a better solution is possible. 306360784Sdim if (!FromD->getDescribedTemplate() && 307360784Sdim FromD->getFriendObjectKind() == Decl::FOK_None) 308360784Sdim ToD->getLexicalDeclContext()->addDeclInternal(ToD); 309360784Sdim return; 310360784Sdim } 311360784Sdim 312360784Sdim DeclContext *FromDC = FromD->getDeclContext(); 313360784Sdim DeclContext *FromLexicalDC = FromD->getLexicalDeclContext(); 314360784Sdim DeclContext *ToDC = ToD->getDeclContext(); 315360784Sdim DeclContext *ToLexicalDC = ToD->getLexicalDeclContext(); 316360784Sdim 317360784Sdim bool Visible = false; 318360784Sdim if (FromDC->containsDeclAndLoad(FromD)) { 319360784Sdim ToDC->addDeclInternal(ToD); 320360784Sdim Visible = true; 321360784Sdim } 322360784Sdim if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) { 323360784Sdim ToLexicalDC->addDeclInternal(ToD); 324360784Sdim Visible = true; 325360784Sdim } 326360784Sdim 327360784Sdim // If the Decl was added to any context, it was made already visible. 328360784Sdim // Otherwise it is still possible that it should be visible. 329360784Sdim if (!Visible) { 330360784Sdim if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) { 331360784Sdim auto *ToNamed = cast<NamedDecl>(ToD); 332360784Sdim DeclContextLookupResult FromLookup = 333360784Sdim FromDC->lookup(FromNamed->getDeclName()); 334360784Sdim for (NamedDecl *ND : FromLookup) 335360784Sdim if (ND == FromNamed) { 336360784Sdim ToDC->makeDeclVisibleInContext(ToNamed); 337360784Sdim break; 338360784Sdim } 339360784Sdim } 340360784Sdim } 341360784Sdim } 342360784Sdim 343203955Srdivacky public: 344341825Sdim explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {} 345341825Sdim 346344779Sdim using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit; 347344779Sdim using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit; 348344779Sdim using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit; 349203955Srdivacky 350203955Srdivacky // Importing types 351344779Sdim ExpectedType VisitType(const Type *T); 352344779Sdim ExpectedType VisitAtomicType(const AtomicType *T); 353344779Sdim ExpectedType VisitBuiltinType(const BuiltinType *T); 354344779Sdim ExpectedType VisitDecayedType(const DecayedType *T); 355344779Sdim ExpectedType VisitComplexType(const ComplexType *T); 356344779Sdim ExpectedType VisitPointerType(const PointerType *T); 357344779Sdim ExpectedType VisitBlockPointerType(const BlockPointerType *T); 358344779Sdim ExpectedType VisitLValueReferenceType(const LValueReferenceType *T); 359344779Sdim ExpectedType VisitRValueReferenceType(const RValueReferenceType *T); 360344779Sdim ExpectedType VisitMemberPointerType(const MemberPointerType *T); 361344779Sdim ExpectedType VisitConstantArrayType(const ConstantArrayType *T); 362344779Sdim ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T); 363344779Sdim ExpectedType VisitVariableArrayType(const VariableArrayType *T); 364344779Sdim ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T); 365203955Srdivacky // FIXME: DependentSizedExtVectorType 366344779Sdim ExpectedType VisitVectorType(const VectorType *T); 367344779Sdim ExpectedType VisitExtVectorType(const ExtVectorType *T); 368344779Sdim ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T); 369344779Sdim ExpectedType VisitFunctionProtoType(const FunctionProtoType *T); 370344779Sdim ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T); 371344779Sdim ExpectedType VisitParenType(const ParenType *T); 372344779Sdim ExpectedType VisitTypedefType(const TypedefType *T); 373344779Sdim ExpectedType VisitTypeOfExprType(const TypeOfExprType *T); 374203955Srdivacky // FIXME: DependentTypeOfExprType 375344779Sdim ExpectedType VisitTypeOfType(const TypeOfType *T); 376344779Sdim ExpectedType VisitDecltypeType(const DecltypeType *T); 377344779Sdim ExpectedType VisitUnaryTransformType(const UnaryTransformType *T); 378344779Sdim ExpectedType VisitAutoType(const AutoType *T); 379344779Sdim ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T); 380203955Srdivacky // FIXME: DependentDecltypeType 381344779Sdim ExpectedType VisitRecordType(const RecordType *T); 382344779Sdim ExpectedType VisitEnumType(const EnumType *T); 383344779Sdim ExpectedType VisitAttributedType(const AttributedType *T); 384344779Sdim ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T); 385344779Sdim ExpectedType VisitSubstTemplateTypeParmType( 386344779Sdim const SubstTemplateTypeParmType *T); 387344779Sdim ExpectedType VisitTemplateSpecializationType( 388344779Sdim const TemplateSpecializationType *T); 389344779Sdim ExpectedType VisitElaboratedType(const ElaboratedType *T); 390344779Sdim ExpectedType VisitDependentNameType(const DependentNameType *T); 391344779Sdim ExpectedType VisitPackExpansionType(const PackExpansionType *T); 392344779Sdim ExpectedType VisitDependentTemplateSpecializationType( 393341825Sdim const DependentTemplateSpecializationType *T); 394344779Sdim ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T); 395344779Sdim ExpectedType VisitObjCObjectType(const ObjCObjectType *T); 396344779Sdim ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 397341825Sdim 398341825Sdim // Importing declarations 399344779Sdim Error ImportDeclParts( 400344779Sdim NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, 401344779Sdim DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc); 402344779Sdim Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 403344779Sdim Error ImportDeclarationNameLoc( 404344779Sdim const DeclarationNameInfo &From, DeclarationNameInfo &To); 405344779Sdim Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 406344779Sdim Error ImportDeclContext( 407344779Sdim Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC); 408344779Sdim Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To); 409309124Sdim 410344779Sdim Expected<CXXCastPath> ImportCastPath(CastExpr *E); 411314564Sdim 412341825Sdim using Designator = DesignatedInitExpr::Designator; 413341825Sdim 414341825Sdim /// What we should import from the definition. 415341825Sdim enum ImportDefinitionKind { 416341825Sdim /// Import the default subset of the definition, which might be 417234353Sdim /// nothing (if minimal import is set) or might be everything (if minimal 418234353Sdim /// import is not set). 419234353Sdim IDK_Default, 420341825Sdim /// Import everything. 421234353Sdim IDK_Everything, 422341825Sdim /// Import only the bare bones needed to establish a valid 423234353Sdim /// DeclContext. 424234353Sdim IDK_Basic 425234353Sdim }; 426234353Sdim 427234353Sdim bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 428234353Sdim return IDK == IDK_Everything || 429234353Sdim (IDK == IDK_Default && !Importer.isMinimalImport()); 430234353Sdim } 431234353Sdim 432344779Sdim Error ImportInitializer(VarDecl *From, VarDecl *To); 433344779Sdim Error ImportDefinition( 434344779Sdim RecordDecl *From, RecordDecl *To, 435344779Sdim ImportDefinitionKind Kind = IDK_Default); 436344779Sdim Error ImportDefinition( 437344779Sdim EnumDecl *From, EnumDecl *To, 438344779Sdim ImportDefinitionKind Kind = IDK_Default); 439344779Sdim Error ImportDefinition( 440344779Sdim ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 441344779Sdim ImportDefinitionKind Kind = IDK_Default); 442344779Sdim Error ImportDefinition( 443344779Sdim ObjCProtocolDecl *From, ObjCProtocolDecl *To, 444344779Sdim ImportDefinitionKind Kind = IDK_Default); 445344779Sdim Error ImportTemplateArguments( 446344779Sdim const TemplateArgument *FromArgs, unsigned NumFromArgs, 447344779Sdim SmallVectorImpl<TemplateArgument> &ToArgs); 448344779Sdim Expected<TemplateArgument> 449344779Sdim ImportTemplateArgument(const TemplateArgument &From); 450341825Sdim 451327952Sdim template <typename InContainerTy> 452344779Sdim Error ImportTemplateArgumentListInfo( 453344779Sdim const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo); 454341825Sdim 455341825Sdim template<typename InContainerTy> 456344779Sdim Error ImportTemplateArgumentListInfo( 457344779Sdim SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc, 458344779Sdim const InContainerTy &Container, TemplateArgumentListInfo &Result); 459341825Sdim 460341825Sdim using TemplateArgsTy = SmallVector<TemplateArgument, 8>; 461344779Sdim using FunctionTemplateAndArgsTy = 462344779Sdim std::tuple<FunctionTemplateDecl *, TemplateArgsTy>; 463344779Sdim Expected<FunctionTemplateAndArgsTy> 464341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization( 465341825Sdim FunctionDecl *FromFD); 466353358Sdim Error ImportTemplateParameterLists(const DeclaratorDecl *FromD, 467353358Sdim DeclaratorDecl *ToD); 468341825Sdim 469344779Sdim Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD); 470341825Sdim 471353358Sdim Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD); 472353358Sdim 473360784Sdim Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam, 474360784Sdim ParmVarDecl *ToParam); 475360784Sdim 476353358Sdim template <typename T> 477353358Sdim bool hasSameVisibilityContext(T *Found, T *From); 478353358Sdim 479341825Sdim bool IsStructuralMatch(Decl *From, Decl *To, bool Complain); 480239462Sdim bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 481239462Sdim bool Complain = true); 482261991Sdim bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 483261991Sdim bool Complain = true); 484203955Srdivacky bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 485249423Sdim bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 486327952Sdim bool IsStructuralMatch(FunctionTemplateDecl *From, 487327952Sdim FunctionTemplateDecl *To); 488341825Sdim bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To); 489218893Sdim bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 490261991Sdim bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 491344779Sdim ExpectedDecl VisitDecl(Decl *D); 492344779Sdim ExpectedDecl VisitImportDecl(ImportDecl *D); 493344779Sdim ExpectedDecl VisitEmptyDecl(EmptyDecl *D); 494344779Sdim ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D); 495344779Sdim ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D); 496344779Sdim ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D); 497344779Sdim ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D); 498344779Sdim ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 499344779Sdim ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 500344779Sdim ExpectedDecl VisitTypedefDecl(TypedefDecl *D); 501344779Sdim ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D); 502344779Sdim ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 503344779Sdim ExpectedDecl VisitLabelDecl(LabelDecl *D); 504344779Sdim ExpectedDecl VisitEnumDecl(EnumDecl *D); 505344779Sdim ExpectedDecl VisitRecordDecl(RecordDecl *D); 506344779Sdim ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D); 507344779Sdim ExpectedDecl VisitFunctionDecl(FunctionDecl *D); 508344779Sdim ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D); 509344779Sdim ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D); 510344779Sdim ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D); 511344779Sdim ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D); 512344779Sdim ExpectedDecl VisitFieldDecl(FieldDecl *D); 513344779Sdim ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D); 514344779Sdim ExpectedDecl VisitFriendDecl(FriendDecl *D); 515344779Sdim ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D); 516344779Sdim ExpectedDecl VisitVarDecl(VarDecl *D); 517344779Sdim ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D); 518344779Sdim ExpectedDecl VisitParmVarDecl(ParmVarDecl *D); 519344779Sdim ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D); 520344779Sdim ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 521344779Sdim ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D); 522344779Sdim ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D); 523344779Sdim ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D); 524344779Sdim ExpectedDecl VisitUsingDecl(UsingDecl *D); 525344779Sdim ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D); 526344779Sdim ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 527344779Sdim ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 528344779Sdim ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 529360784Sdim ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D); 530360784Sdim ExpectedDecl 531360784Sdim VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D); 532288943Sdim 533344779Sdim Expected<ObjCTypeParamList *> 534344779Sdim ImportObjCTypeParamList(ObjCTypeParamList *list); 535344779Sdim 536344779Sdim ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 537344779Sdim ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 538344779Sdim ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D); 539344779Sdim ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D); 540344779Sdim ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 541344779Sdim ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 542344779Sdim ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 543344779Sdim ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 544344779Sdim ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D); 545344779Sdim ExpectedDecl VisitClassTemplateSpecializationDecl( 546218893Sdim ClassTemplateSpecializationDecl *D); 547344779Sdim ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D); 548344779Sdim ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 549344779Sdim ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 550261991Sdim 551203955Srdivacky // Importing statements 552344779Sdim ExpectedStmt VisitStmt(Stmt *S); 553344779Sdim ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S); 554344779Sdim ExpectedStmt VisitDeclStmt(DeclStmt *S); 555344779Sdim ExpectedStmt VisitNullStmt(NullStmt *S); 556344779Sdim ExpectedStmt VisitCompoundStmt(CompoundStmt *S); 557344779Sdim ExpectedStmt VisitCaseStmt(CaseStmt *S); 558344779Sdim ExpectedStmt VisitDefaultStmt(DefaultStmt *S); 559344779Sdim ExpectedStmt VisitLabelStmt(LabelStmt *S); 560344779Sdim ExpectedStmt VisitAttributedStmt(AttributedStmt *S); 561344779Sdim ExpectedStmt VisitIfStmt(IfStmt *S); 562344779Sdim ExpectedStmt VisitSwitchStmt(SwitchStmt *S); 563344779Sdim ExpectedStmt VisitWhileStmt(WhileStmt *S); 564344779Sdim ExpectedStmt VisitDoStmt(DoStmt *S); 565344779Sdim ExpectedStmt VisitForStmt(ForStmt *S); 566344779Sdim ExpectedStmt VisitGotoStmt(GotoStmt *S); 567344779Sdim ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S); 568344779Sdim ExpectedStmt VisitContinueStmt(ContinueStmt *S); 569344779Sdim ExpectedStmt VisitBreakStmt(BreakStmt *S); 570344779Sdim ExpectedStmt VisitReturnStmt(ReturnStmt *S); 571288943Sdim // FIXME: MSAsmStmt 572288943Sdim // FIXME: SEHExceptStmt 573288943Sdim // FIXME: SEHFinallyStmt 574288943Sdim // FIXME: SEHTryStmt 575288943Sdim // FIXME: SEHLeaveStmt 576288943Sdim // FIXME: CapturedStmt 577344779Sdim ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S); 578344779Sdim ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S); 579344779Sdim ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S); 580288943Sdim // FIXME: MSDependentExistsStmt 581344779Sdim ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 582344779Sdim ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 583344779Sdim ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 584344779Sdim ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S); 585344779Sdim ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 586344779Sdim ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 587344779Sdim ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 588203955Srdivacky 589203955Srdivacky // Importing expressions 590344779Sdim ExpectedStmt VisitExpr(Expr *E); 591344779Sdim ExpectedStmt VisitVAArgExpr(VAArgExpr *E); 592353358Sdim ExpectedStmt VisitChooseExpr(ChooseExpr *E); 593344779Sdim ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E); 594344779Sdim ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E); 595344779Sdim ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E); 596344779Sdim ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E); 597344779Sdim ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E); 598344779Sdim ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); 599344779Sdim ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E); 600344779Sdim ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E); 601344779Sdim ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E); 602344779Sdim ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E); 603344779Sdim ExpectedStmt VisitStringLiteral(StringLiteral *E); 604344779Sdim ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 605344779Sdim ExpectedStmt VisitAtomicExpr(AtomicExpr *E); 606344779Sdim ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E); 607344779Sdim ExpectedStmt VisitConstantExpr(ConstantExpr *E); 608344779Sdim ExpectedStmt VisitParenExpr(ParenExpr *E); 609344779Sdim ExpectedStmt VisitParenListExpr(ParenListExpr *E); 610344779Sdim ExpectedStmt VisitStmtExpr(StmtExpr *E); 611344779Sdim ExpectedStmt VisitUnaryOperator(UnaryOperator *E); 612344779Sdim ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 613344779Sdim ExpectedStmt VisitBinaryOperator(BinaryOperator *E); 614344779Sdim ExpectedStmt VisitConditionalOperator(ConditionalOperator *E); 615344779Sdim ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E); 616344779Sdim ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E); 617344779Sdim ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 618344779Sdim ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E); 619344779Sdim ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E); 620344779Sdim ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E); 621344779Sdim ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E); 622344779Sdim ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E); 623344779Sdim ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE); 624344779Sdim ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E); 625344779Sdim ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E); 626344779Sdim ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); 627344779Sdim ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 628344779Sdim ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 629344779Sdim ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E); 630344779Sdim ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 631344779Sdim ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E); 632344779Sdim ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E); 633344779Sdim ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E); 634344779Sdim ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E); 635344779Sdim ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E); 636344779Sdim ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E); 637344779Sdim ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 638344779Sdim ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 639344779Sdim ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E); 640344779Sdim ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E); 641344779Sdim ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E); 642344779Sdim ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E); 643344779Sdim ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E); 644344779Sdim ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); 645344779Sdim ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 646344779Sdim ExpectedStmt VisitMemberExpr(MemberExpr *E); 647344779Sdim ExpectedStmt VisitCallExpr(CallExpr *E); 648344779Sdim ExpectedStmt VisitLambdaExpr(LambdaExpr *LE); 649344779Sdim ExpectedStmt VisitInitListExpr(InitListExpr *E); 650344779Sdim ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E); 651344779Sdim ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E); 652344779Sdim ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E); 653344779Sdim ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E); 654344779Sdim ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E); 655344779Sdim ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E); 656344779Sdim ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E); 657344779Sdim ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E); 658344779Sdim ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E); 659309124Sdim 660309124Sdim template<typename IIter, typename OIter> 661344779Sdim Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) { 662341825Sdim using ItemT = typename std::remove_reference<decltype(*Obegin)>::type; 663344779Sdim for (; Ibegin != Iend; ++Ibegin, ++Obegin) { 664344779Sdim Expected<ItemT> ToOrErr = import(*Ibegin); 665344779Sdim if (!ToOrErr) 666344779Sdim return ToOrErr.takeError(); 667344779Sdim *Obegin = *ToOrErr; 668344779Sdim } 669344779Sdim return Error::success(); 670309124Sdim } 671309124Sdim 672344779Sdim // Import every item from a container structure into an output container. 673344779Sdim // If error occurs, stops at first error and returns the error. 674344779Sdim // The output container should have space for all needed elements (it is not 675344779Sdim // expanded, new items are put into from the beginning). 676314564Sdim template<typename InContainerTy, typename OutContainerTy> 677344779Sdim Error ImportContainerChecked( 678344779Sdim const InContainerTy &InContainer, OutContainerTy &OutContainer) { 679344779Sdim return ImportArrayChecked( 680344779Sdim InContainer.begin(), InContainer.end(), OutContainer.begin()); 681314564Sdim } 682314564Sdim 683314564Sdim template<typename InContainerTy, typename OIter> 684344779Sdim Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) { 685314564Sdim return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin); 686314564Sdim } 687309124Sdim 688360784Sdim Error ImportOverriddenMethods(CXXMethodDecl *ToMethod, 689360784Sdim CXXMethodDecl *FromMethod); 690341825Sdim 691344779Sdim Expected<FunctionDecl *> FindFunctionTemplateSpecialization( 692344779Sdim FunctionDecl *FromFD); 693360784Sdim 694360784Sdim // Returns true if the given function has a placeholder return type and 695360784Sdim // that type is declared inside the body of the function. 696360784Sdim // E.g. auto f() { struct X{}; return X(); } 697360784Sdim bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D); 698203955Srdivacky }; 699341825Sdim 700341825Sdimtemplate <typename InContainerTy> 701344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo( 702341825Sdim SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc, 703341825Sdim const InContainerTy &Container, TemplateArgumentListInfo &Result) { 704344779Sdim auto ToLAngleLocOrErr = import(FromLAngleLoc); 705344779Sdim if (!ToLAngleLocOrErr) 706344779Sdim return ToLAngleLocOrErr.takeError(); 707344779Sdim auto ToRAngleLocOrErr = import(FromRAngleLoc); 708344779Sdim if (!ToRAngleLocOrErr) 709344779Sdim return ToRAngleLocOrErr.takeError(); 710344779Sdim 711344779Sdim TemplateArgumentListInfo ToTAInfo(*ToLAngleLocOrErr, *ToRAngleLocOrErr); 712344779Sdim if (auto Err = ImportTemplateArgumentListInfo(Container, ToTAInfo)) 713344779Sdim return Err; 714341825Sdim Result = ToTAInfo; 715344779Sdim return Error::success(); 716203955Srdivacky} 717203955Srdivacky 718341825Sdimtemplate <> 719344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>( 720341825Sdim const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) { 721341825Sdim return ImportTemplateArgumentListInfo( 722341825Sdim From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result); 723341825Sdim} 724341825Sdim 725341825Sdimtemplate <> 726344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo< 727344779Sdim ASTTemplateArgumentListInfo>( 728344779Sdim const ASTTemplateArgumentListInfo &From, 729344779Sdim TemplateArgumentListInfo &Result) { 730344779Sdim return ImportTemplateArgumentListInfo( 731344779Sdim From.LAngleLoc, From.RAngleLoc, From.arguments(), Result); 732341825Sdim} 733341825Sdim 734344779SdimExpected<ASTNodeImporter::FunctionTemplateAndArgsTy> 735341825SdimASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization( 736341825Sdim FunctionDecl *FromFD) { 737341825Sdim assert(FromFD->getTemplatedKind() == 738344779Sdim FunctionDecl::TK_FunctionTemplateSpecialization); 739344779Sdim 740344779Sdim FunctionTemplateAndArgsTy Result; 741344779Sdim 742341825Sdim auto *FTSInfo = FromFD->getTemplateSpecializationInfo(); 743344779Sdim if (Error Err = importInto(std::get<0>(Result), FTSInfo->getTemplate())) 744344779Sdim return std::move(Err); 745341825Sdim 746341825Sdim // Import template arguments. 747341825Sdim auto TemplArgs = FTSInfo->TemplateArguments->asArray(); 748344779Sdim if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(), 749344779Sdim std::get<1>(Result))) 750344779Sdim return std::move(Err); 751341825Sdim 752344779Sdim return Result; 753341825Sdim} 754341825Sdim 755344779Sdimtemplate <> 756344779SdimExpected<TemplateParameterList *> 757344779SdimASTNodeImporter::import(TemplateParameterList *From) { 758344779Sdim SmallVector<NamedDecl *, 4> To(From->size()); 759344779Sdim if (Error Err = ImportContainerChecked(*From, To)) 760344779Sdim return std::move(Err); 761344779Sdim 762344779Sdim ExpectedExpr ToRequiresClause = import(From->getRequiresClause()); 763344779Sdim if (!ToRequiresClause) 764344779Sdim return ToRequiresClause.takeError(); 765344779Sdim 766344779Sdim auto ToTemplateLocOrErr = import(From->getTemplateLoc()); 767344779Sdim if (!ToTemplateLocOrErr) 768344779Sdim return ToTemplateLocOrErr.takeError(); 769344779Sdim auto ToLAngleLocOrErr = import(From->getLAngleLoc()); 770344779Sdim if (!ToLAngleLocOrErr) 771344779Sdim return ToLAngleLocOrErr.takeError(); 772344779Sdim auto ToRAngleLocOrErr = import(From->getRAngleLoc()); 773344779Sdim if (!ToRAngleLocOrErr) 774344779Sdim return ToRAngleLocOrErr.takeError(); 775344779Sdim 776344779Sdim return TemplateParameterList::Create( 777344779Sdim Importer.getToContext(), 778344779Sdim *ToTemplateLocOrErr, 779344779Sdim *ToLAngleLocOrErr, 780344779Sdim To, 781344779Sdim *ToRAngleLocOrErr, 782344779Sdim *ToRequiresClause); 783344779Sdim} 784344779Sdim 785344779Sdimtemplate <> 786344779SdimExpected<TemplateArgument> 787344779SdimASTNodeImporter::import(const TemplateArgument &From) { 788344779Sdim switch (From.getKind()) { 789344779Sdim case TemplateArgument::Null: 790344779Sdim return TemplateArgument(); 791344779Sdim 792344779Sdim case TemplateArgument::Type: { 793344779Sdim ExpectedType ToTypeOrErr = import(From.getAsType()); 794344779Sdim if (!ToTypeOrErr) 795344779Sdim return ToTypeOrErr.takeError(); 796344779Sdim return TemplateArgument(*ToTypeOrErr); 797344779Sdim } 798344779Sdim 799344779Sdim case TemplateArgument::Integral: { 800344779Sdim ExpectedType ToTypeOrErr = import(From.getIntegralType()); 801344779Sdim if (!ToTypeOrErr) 802344779Sdim return ToTypeOrErr.takeError(); 803344779Sdim return TemplateArgument(From, *ToTypeOrErr); 804344779Sdim } 805344779Sdim 806344779Sdim case TemplateArgument::Declaration: { 807344779Sdim Expected<ValueDecl *> ToOrErr = import(From.getAsDecl()); 808344779Sdim if (!ToOrErr) 809344779Sdim return ToOrErr.takeError(); 810344779Sdim ExpectedType ToTypeOrErr = import(From.getParamTypeForDecl()); 811344779Sdim if (!ToTypeOrErr) 812344779Sdim return ToTypeOrErr.takeError(); 813344779Sdim return TemplateArgument(*ToOrErr, *ToTypeOrErr); 814344779Sdim } 815344779Sdim 816344779Sdim case TemplateArgument::NullPtr: { 817344779Sdim ExpectedType ToTypeOrErr = import(From.getNullPtrType()); 818344779Sdim if (!ToTypeOrErr) 819344779Sdim return ToTypeOrErr.takeError(); 820344779Sdim return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true); 821344779Sdim } 822344779Sdim 823344779Sdim case TemplateArgument::Template: { 824344779Sdim Expected<TemplateName> ToTemplateOrErr = import(From.getAsTemplate()); 825344779Sdim if (!ToTemplateOrErr) 826344779Sdim return ToTemplateOrErr.takeError(); 827344779Sdim 828344779Sdim return TemplateArgument(*ToTemplateOrErr); 829344779Sdim } 830344779Sdim 831344779Sdim case TemplateArgument::TemplateExpansion: { 832344779Sdim Expected<TemplateName> ToTemplateOrErr = 833344779Sdim import(From.getAsTemplateOrTemplatePattern()); 834344779Sdim if (!ToTemplateOrErr) 835344779Sdim return ToTemplateOrErr.takeError(); 836344779Sdim 837344779Sdim return TemplateArgument( 838344779Sdim *ToTemplateOrErr, From.getNumTemplateExpansions()); 839344779Sdim } 840344779Sdim 841344779Sdim case TemplateArgument::Expression: 842344779Sdim if (ExpectedExpr ToExpr = import(From.getAsExpr())) 843344779Sdim return TemplateArgument(*ToExpr); 844344779Sdim else 845344779Sdim return ToExpr.takeError(); 846344779Sdim 847344779Sdim case TemplateArgument::Pack: { 848344779Sdim SmallVector<TemplateArgument, 2> ToPack; 849344779Sdim ToPack.reserve(From.pack_size()); 850344779Sdim if (Error Err = ImportTemplateArguments( 851344779Sdim From.pack_begin(), From.pack_size(), ToPack)) 852344779Sdim return std::move(Err); 853344779Sdim 854344779Sdim return TemplateArgument( 855344779Sdim llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 856344779Sdim } 857344779Sdim } 858344779Sdim 859344779Sdim llvm_unreachable("Invalid template argument kind"); 860344779Sdim} 861344779Sdim 862344779Sdimtemplate <> 863344779SdimExpected<TemplateArgumentLoc> 864344779SdimASTNodeImporter::import(const TemplateArgumentLoc &TALoc) { 865344779Sdim Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument()); 866344779Sdim if (!ArgOrErr) 867344779Sdim return ArgOrErr.takeError(); 868344779Sdim TemplateArgument Arg = *ArgOrErr; 869344779Sdim 870344779Sdim TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo(); 871344779Sdim 872344779Sdim TemplateArgumentLocInfo ToInfo; 873344779Sdim if (Arg.getKind() == TemplateArgument::Expression) { 874344779Sdim ExpectedExpr E = import(FromInfo.getAsExpr()); 875344779Sdim if (!E) 876344779Sdim return E.takeError(); 877344779Sdim ToInfo = TemplateArgumentLocInfo(*E); 878344779Sdim } else if (Arg.getKind() == TemplateArgument::Type) { 879344779Sdim if (auto TSIOrErr = import(FromInfo.getAsTypeSourceInfo())) 880344779Sdim ToInfo = TemplateArgumentLocInfo(*TSIOrErr); 881344779Sdim else 882344779Sdim return TSIOrErr.takeError(); 883344779Sdim } else { 884344779Sdim auto ToTemplateQualifierLocOrErr = 885344779Sdim import(FromInfo.getTemplateQualifierLoc()); 886344779Sdim if (!ToTemplateQualifierLocOrErr) 887344779Sdim return ToTemplateQualifierLocOrErr.takeError(); 888344779Sdim auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc()); 889344779Sdim if (!ToTemplateNameLocOrErr) 890344779Sdim return ToTemplateNameLocOrErr.takeError(); 891344779Sdim auto ToTemplateEllipsisLocOrErr = 892344779Sdim import(FromInfo.getTemplateEllipsisLoc()); 893344779Sdim if (!ToTemplateEllipsisLocOrErr) 894344779Sdim return ToTemplateEllipsisLocOrErr.takeError(); 895344779Sdim 896344779Sdim ToInfo = TemplateArgumentLocInfo( 897344779Sdim *ToTemplateQualifierLocOrErr, 898344779Sdim *ToTemplateNameLocOrErr, 899344779Sdim *ToTemplateEllipsisLocOrErr); 900344779Sdim } 901344779Sdim 902344779Sdim return TemplateArgumentLoc(Arg, ToInfo); 903344779Sdim} 904344779Sdim 905344779Sdimtemplate <> 906344779SdimExpected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) { 907344779Sdim if (DG.isNull()) 908344779Sdim return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 909344779Sdim size_t NumDecls = DG.end() - DG.begin(); 910344779Sdim SmallVector<Decl *, 1> ToDecls; 911344779Sdim ToDecls.reserve(NumDecls); 912344779Sdim for (Decl *FromD : DG) { 913344779Sdim if (auto ToDOrErr = import(FromD)) 914344779Sdim ToDecls.push_back(*ToDOrErr); 915344779Sdim else 916344779Sdim return ToDOrErr.takeError(); 917344779Sdim } 918344779Sdim return DeclGroupRef::Create(Importer.getToContext(), 919344779Sdim ToDecls.begin(), 920344779Sdim NumDecls); 921344779Sdim} 922344779Sdim 923344779Sdimtemplate <> 924344779SdimExpected<ASTNodeImporter::Designator> 925344779SdimASTNodeImporter::import(const Designator &D) { 926344779Sdim if (D.isFieldDesignator()) { 927344779Sdim IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName()); 928344779Sdim 929344779Sdim ExpectedSLoc ToDotLocOrErr = import(D.getDotLoc()); 930344779Sdim if (!ToDotLocOrErr) 931344779Sdim return ToDotLocOrErr.takeError(); 932344779Sdim 933344779Sdim ExpectedSLoc ToFieldLocOrErr = import(D.getFieldLoc()); 934344779Sdim if (!ToFieldLocOrErr) 935344779Sdim return ToFieldLocOrErr.takeError(); 936344779Sdim 937344779Sdim return Designator(ToFieldName, *ToDotLocOrErr, *ToFieldLocOrErr); 938344779Sdim } 939344779Sdim 940344779Sdim ExpectedSLoc ToLBracketLocOrErr = import(D.getLBracketLoc()); 941344779Sdim if (!ToLBracketLocOrErr) 942344779Sdim return ToLBracketLocOrErr.takeError(); 943344779Sdim 944344779Sdim ExpectedSLoc ToRBracketLocOrErr = import(D.getRBracketLoc()); 945344779Sdim if (!ToRBracketLocOrErr) 946344779Sdim return ToRBracketLocOrErr.takeError(); 947344779Sdim 948344779Sdim if (D.isArrayDesignator()) 949344779Sdim return Designator(D.getFirstExprIndex(), 950344779Sdim *ToLBracketLocOrErr, *ToRBracketLocOrErr); 951344779Sdim 952344779Sdim ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc()); 953344779Sdim if (!ToEllipsisLocOrErr) 954344779Sdim return ToEllipsisLocOrErr.takeError(); 955344779Sdim 956344779Sdim assert(D.isArrayRangeDesignator()); 957344779Sdim return Designator( 958344779Sdim D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr, 959344779Sdim *ToRBracketLocOrErr); 960344779Sdim} 961344779Sdim 962344779Sdimtemplate <> 963344779SdimExpected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) { 964344779Sdim VarDecl *Var = nullptr; 965344779Sdim if (From.capturesVariable()) { 966344779Sdim if (auto VarOrErr = import(From.getCapturedVar())) 967344779Sdim Var = *VarOrErr; 968344779Sdim else 969344779Sdim return VarOrErr.takeError(); 970344779Sdim } 971344779Sdim 972344779Sdim auto LocationOrErr = import(From.getLocation()); 973344779Sdim if (!LocationOrErr) 974344779Sdim return LocationOrErr.takeError(); 975344779Sdim 976344779Sdim SourceLocation EllipsisLoc; 977344779Sdim if (From.isPackExpansion()) 978344779Sdim if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc())) 979344779Sdim return std::move(Err); 980344779Sdim 981344779Sdim return LambdaCapture( 982344779Sdim *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var, 983344779Sdim EllipsisLoc); 984344779Sdim} 985344779Sdim 986360784Sdimtemplate <typename T> 987360784Sdimbool ASTNodeImporter::hasSameVisibilityContext(T *Found, T *From) { 988360784Sdim if (From->hasExternalFormalLinkage()) 989360784Sdim return Found->hasExternalFormalLinkage(); 990360784Sdim if (Importer.GetFromTU(Found) != From->getTranslationUnitDecl()) 991360784Sdim return false; 992360784Sdim if (From->isInAnonymousNamespace()) 993360784Sdim return Found->isInAnonymousNamespace(); 994360784Sdim else 995360784Sdim return !Found->isInAnonymousNamespace() && 996360784Sdim !Found->hasExternalFormalLinkage(); 997360784Sdim} 998360784Sdim 999360784Sdimtemplate <> 1000360784Sdimbool ASTNodeImporter::hasSameVisibilityContext(TypedefNameDecl *Found, 1001360784Sdim TypedefNameDecl *From) { 1002360784Sdim if (From->isInAnonymousNamespace() && Found->isInAnonymousNamespace()) 1003360784Sdim return Importer.GetFromTU(Found) == From->getTranslationUnitDecl(); 1004360784Sdim return From->isInAnonymousNamespace() == Found->isInAnonymousNamespace(); 1005360784Sdim} 1006360784Sdim 1007341825Sdim} // namespace clang 1008341825Sdim 1009203955Srdivacky//---------------------------------------------------------------------------- 1010203955Srdivacky// Import Types 1011203955Srdivacky//---------------------------------------------------------------------------- 1012203955Srdivacky 1013321369Sdimusing namespace clang; 1014321369Sdim 1015344779SdimExpectedType ASTNodeImporter::VisitType(const Type *T) { 1016203955Srdivacky Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 1017203955Srdivacky << T->getTypeClassName(); 1018344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 1019203955Srdivacky} 1020203955Srdivacky 1021344779SdimExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){ 1022344779Sdim ExpectedType UnderlyingTypeOrErr = import(T->getValueType()); 1023344779Sdim if (!UnderlyingTypeOrErr) 1024344779Sdim return UnderlyingTypeOrErr.takeError(); 1025314564Sdim 1026344779Sdim return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr); 1027314564Sdim} 1028314564Sdim 1029344779SdimExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 1030203955Srdivacky switch (T->getKind()) { 1031309124Sdim#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 1032309124Sdim case BuiltinType::Id: \ 1033309124Sdim return Importer.getToContext().SingletonId; 1034309124Sdim#include "clang/Basic/OpenCLImageTypes.def" 1035344779Sdim#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 1036344779Sdim case BuiltinType::Id: \ 1037344779Sdim return Importer.getToContext().Id##Ty; 1038344779Sdim#include "clang/Basic/OpenCLExtensionTypes.def" 1039360784Sdim#define SVE_TYPE(Name, Id, SingletonId) \ 1040360784Sdim case BuiltinType::Id: \ 1041360784Sdim return Importer.getToContext().SingletonId; 1042360784Sdim#include "clang/Basic/AArch64SVEACLETypes.def" 1043234353Sdim#define SHARED_SINGLETON_TYPE(Expansion) 1044234353Sdim#define BUILTIN_TYPE(Id, SingletonId) \ 1045234353Sdim case BuiltinType::Id: return Importer.getToContext().SingletonId; 1046234353Sdim#include "clang/AST/BuiltinTypes.def" 1047234353Sdim 1048234353Sdim // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 1049234353Sdim // context supports C++. 1050234353Sdim 1051234353Sdim // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 1052234353Sdim // context supports ObjC. 1053234353Sdim 1054203955Srdivacky case BuiltinType::Char_U: 1055341825Sdim // The context we're importing from has an unsigned 'char'. If we're 1056341825Sdim // importing into a context with a signed 'char', translate to 1057203955Srdivacky // 'unsigned char' instead. 1058234353Sdim if (Importer.getToContext().getLangOpts().CharIsSigned) 1059203955Srdivacky return Importer.getToContext().UnsignedCharTy; 1060341825Sdim 1061203955Srdivacky return Importer.getToContext().CharTy; 1062203955Srdivacky 1063203955Srdivacky case BuiltinType::Char_S: 1064341825Sdim // The context we're importing from has an unsigned 'char'. If we're 1065341825Sdim // importing into a context with a signed 'char', translate to 1066203955Srdivacky // 'unsigned char' instead. 1067234353Sdim if (!Importer.getToContext().getLangOpts().CharIsSigned) 1068203955Srdivacky return Importer.getToContext().SignedCharTy; 1069341825Sdim 1070203955Srdivacky return Importer.getToContext().CharTy; 1071203955Srdivacky 1072218893Sdim case BuiltinType::WChar_S: 1073218893Sdim case BuiltinType::WChar_U: 1074203955Srdivacky // FIXME: If not in C++, shall we translate to the C equivalent of 1075203955Srdivacky // wchar_t? 1076203955Srdivacky return Importer.getToContext().WCharTy; 1077234353Sdim } 1078203955Srdivacky 1079234353Sdim llvm_unreachable("Invalid BuiltinType Kind!"); 1080203955Srdivacky} 1081203955Srdivacky 1082344779SdimExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) { 1083344779Sdim ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType()); 1084344779Sdim if (!ToOriginalTypeOrErr) 1085344779Sdim return ToOriginalTypeOrErr.takeError(); 1086314564Sdim 1087344779Sdim return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr); 1088314564Sdim} 1089314564Sdim 1090344779SdimExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 1091344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1092344779Sdim if (!ToElementTypeOrErr) 1093344779Sdim return ToElementTypeOrErr.takeError(); 1094341825Sdim 1095344779Sdim return Importer.getToContext().getComplexType(*ToElementTypeOrErr); 1096203955Srdivacky} 1097203955Srdivacky 1098344779SdimExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) { 1099344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1100344779Sdim if (!ToPointeeTypeOrErr) 1101344779Sdim return ToPointeeTypeOrErr.takeError(); 1102341825Sdim 1103344779Sdim return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr); 1104203955Srdivacky} 1105203955Srdivacky 1106344779SdimExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 1107203955Srdivacky // FIXME: Check for blocks support in "to" context. 1108344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1109344779Sdim if (!ToPointeeTypeOrErr) 1110344779Sdim return ToPointeeTypeOrErr.takeError(); 1111341825Sdim 1112344779Sdim return Importer.getToContext().getBlockPointerType(*ToPointeeTypeOrErr); 1113203955Srdivacky} 1114203955Srdivacky 1115344779SdimExpectedType 1116218893SdimASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 1117203955Srdivacky // FIXME: Check for C++ support in "to" context. 1118344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten()); 1119344779Sdim if (!ToPointeeTypeOrErr) 1120344779Sdim return ToPointeeTypeOrErr.takeError(); 1121341825Sdim 1122344779Sdim return Importer.getToContext().getLValueReferenceType(*ToPointeeTypeOrErr); 1123203955Srdivacky} 1124203955Srdivacky 1125344779SdimExpectedType 1126218893SdimASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 1127203955Srdivacky // FIXME: Check for C++0x support in "to" context. 1128344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten()); 1129344779Sdim if (!ToPointeeTypeOrErr) 1130344779Sdim return ToPointeeTypeOrErr.takeError(); 1131341825Sdim 1132344779Sdim return Importer.getToContext().getRValueReferenceType(*ToPointeeTypeOrErr); 1133203955Srdivacky} 1134203955Srdivacky 1135344779SdimExpectedType 1136344779SdimASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 1137203955Srdivacky // FIXME: Check for C++ support in "to" context. 1138344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1139344779Sdim if (!ToPointeeTypeOrErr) 1140344779Sdim return ToPointeeTypeOrErr.takeError(); 1141341825Sdim 1142344779Sdim ExpectedType ClassTypeOrErr = import(QualType(T->getClass(), 0)); 1143344779Sdim if (!ClassTypeOrErr) 1144344779Sdim return ClassTypeOrErr.takeError(); 1145344779Sdim 1146344779Sdim return Importer.getToContext().getMemberPointerType( 1147344779Sdim *ToPointeeTypeOrErr, (*ClassTypeOrErr).getTypePtr()); 1148203955Srdivacky} 1149203955Srdivacky 1150344779SdimExpectedType 1151344779SdimASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 1152360784Sdim QualType ToElementType; 1153360784Sdim const Expr *ToSizeExpr; 1154360784Sdim if (auto Imp = importSeq(T->getElementType(), T->getSizeExpr())) 1155360784Sdim std::tie(ToElementType, ToSizeExpr) = *Imp; 1156360784Sdim else 1157360784Sdim return Imp.takeError(); 1158341825Sdim 1159360784Sdim return Importer.getToContext().getConstantArrayType( 1160360784Sdim ToElementType, T->getSize(), ToSizeExpr, T->getSizeModifier(), 1161360784Sdim T->getIndexTypeCVRQualifiers()); 1162203955Srdivacky} 1163203955Srdivacky 1164344779SdimExpectedType 1165218893SdimASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 1166344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1167344779Sdim if (!ToElementTypeOrErr) 1168344779Sdim return ToElementTypeOrErr.takeError(); 1169341825Sdim 1170344779Sdim return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr, 1171203955Srdivacky T->getSizeModifier(), 1172203955Srdivacky T->getIndexTypeCVRQualifiers()); 1173203955Srdivacky} 1174203955Srdivacky 1175344779SdimExpectedType 1176344779SdimASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 1177344779Sdim QualType ToElementType; 1178344779Sdim Expr *ToSizeExpr; 1179344779Sdim SourceRange ToBracketsRange; 1180344779Sdim if (auto Imp = importSeq( 1181344779Sdim T->getElementType(), T->getSizeExpr(), T->getBracketsRange())) 1182344779Sdim std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp; 1183344779Sdim else 1184344779Sdim return Imp.takeError(); 1185203955Srdivacky 1186344779Sdim return Importer.getToContext().getVariableArrayType( 1187344779Sdim ToElementType, ToSizeExpr, T->getSizeModifier(), 1188344779Sdim T->getIndexTypeCVRQualifiers(), ToBracketsRange); 1189203955Srdivacky} 1190203955Srdivacky 1191344779SdimExpectedType ASTNodeImporter::VisitDependentSizedArrayType( 1192341825Sdim const DependentSizedArrayType *T) { 1193344779Sdim QualType ToElementType; 1194344779Sdim Expr *ToSizeExpr; 1195344779Sdim SourceRange ToBracketsRange; 1196344779Sdim if (auto Imp = importSeq( 1197344779Sdim T->getElementType(), T->getSizeExpr(), T->getBracketsRange())) 1198344779Sdim std::tie(ToElementType, ToSizeExpr, ToBracketsRange) = *Imp; 1199344779Sdim else 1200344779Sdim return Imp.takeError(); 1201341825Sdim // SizeExpr may be null if size is not specified directly. 1202341825Sdim // For example, 'int a[]'. 1203341825Sdim 1204341825Sdim return Importer.getToContext().getDependentSizedArrayType( 1205344779Sdim ToElementType, ToSizeExpr, T->getSizeModifier(), 1206344779Sdim T->getIndexTypeCVRQualifiers(), ToBracketsRange); 1207341825Sdim} 1208341825Sdim 1209344779SdimExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) { 1210344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1211344779Sdim if (!ToElementTypeOrErr) 1212344779Sdim return ToElementTypeOrErr.takeError(); 1213341825Sdim 1214344779Sdim return Importer.getToContext().getVectorType(*ToElementTypeOrErr, 1215203955Srdivacky T->getNumElements(), 1216218893Sdim T->getVectorKind()); 1217203955Srdivacky} 1218203955Srdivacky 1219344779SdimExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 1220344779Sdim ExpectedType ToElementTypeOrErr = import(T->getElementType()); 1221344779Sdim if (!ToElementTypeOrErr) 1222344779Sdim return ToElementTypeOrErr.takeError(); 1223341825Sdim 1224344779Sdim return Importer.getToContext().getExtVectorType(*ToElementTypeOrErr, 1225203955Srdivacky T->getNumElements()); 1226203955Srdivacky} 1227203955Srdivacky 1228344779SdimExpectedType 1229218893SdimASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 1230341825Sdim // FIXME: What happens if we're importing a function without a prototype 1231203955Srdivacky // into C++? Should we make it variadic? 1232344779Sdim ExpectedType ToReturnTypeOrErr = import(T->getReturnType()); 1233344779Sdim if (!ToReturnTypeOrErr) 1234344779Sdim return ToReturnTypeOrErr.takeError(); 1235206084Srdivacky 1236344779Sdim return Importer.getToContext().getFunctionNoProtoType(*ToReturnTypeOrErr, 1237206084Srdivacky T->getExtInfo()); 1238203955Srdivacky} 1239203955Srdivacky 1240344779SdimExpectedType 1241344779SdimASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 1242344779Sdim ExpectedType ToReturnTypeOrErr = import(T->getReturnType()); 1243344779Sdim if (!ToReturnTypeOrErr) 1244344779Sdim return ToReturnTypeOrErr.takeError(); 1245341825Sdim 1246203955Srdivacky // Import argument types 1247226633Sdim SmallVector<QualType, 4> ArgTypes; 1248276479Sdim for (const auto &A : T->param_types()) { 1249344779Sdim ExpectedType TyOrErr = import(A); 1250344779Sdim if (!TyOrErr) 1251344779Sdim return TyOrErr.takeError(); 1252344779Sdim ArgTypes.push_back(*TyOrErr); 1253203955Srdivacky } 1254341825Sdim 1255203955Srdivacky // Import exception types 1256226633Sdim SmallVector<QualType, 4> ExceptionTypes; 1257276479Sdim for (const auto &E : T->exceptions()) { 1258344779Sdim ExpectedType TyOrErr = import(E); 1259344779Sdim if (!TyOrErr) 1260344779Sdim return TyOrErr.takeError(); 1261344779Sdim ExceptionTypes.push_back(*TyOrErr); 1262203955Srdivacky } 1263218893Sdim 1264243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 1265243830Sdim FunctionProtoType::ExtProtoInfo ToEPI; 1266243830Sdim 1267344779Sdim auto Imp = importSeq( 1268344779Sdim FromEPI.ExceptionSpec.NoexceptExpr, 1269344779Sdim FromEPI.ExceptionSpec.SourceDecl, 1270344779Sdim FromEPI.ExceptionSpec.SourceTemplate); 1271344779Sdim if (!Imp) 1272344779Sdim return Imp.takeError(); 1273344779Sdim 1274243830Sdim ToEPI.ExtInfo = FromEPI.ExtInfo; 1275243830Sdim ToEPI.Variadic = FromEPI.Variadic; 1276243830Sdim ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 1277243830Sdim ToEPI.TypeQuals = FromEPI.TypeQuals; 1278243830Sdim ToEPI.RefQualifier = FromEPI.RefQualifier; 1279280031Sdim ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 1280280031Sdim ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 1281344779Sdim std::tie( 1282344779Sdim ToEPI.ExceptionSpec.NoexceptExpr, 1283344779Sdim ToEPI.ExceptionSpec.SourceDecl, 1284344779Sdim ToEPI.ExceptionSpec.SourceTemplate) = *Imp; 1285243830Sdim 1286344779Sdim return Importer.getToContext().getFunctionType( 1287344779Sdim *ToReturnTypeOrErr, ArgTypes, ToEPI); 1288203955Srdivacky} 1289203955Srdivacky 1290344779SdimExpectedType ASTNodeImporter::VisitUnresolvedUsingType( 1291327952Sdim const UnresolvedUsingType *T) { 1292344779Sdim UnresolvedUsingTypenameDecl *ToD; 1293344779Sdim Decl *ToPrevD; 1294344779Sdim if (auto Imp = importSeq(T->getDecl(), T->getDecl()->getPreviousDecl())) 1295344779Sdim std::tie(ToD, ToPrevD) = *Imp; 1296344779Sdim else 1297344779Sdim return Imp.takeError(); 1298327952Sdim 1299344779Sdim return Importer.getToContext().getTypeDeclType( 1300344779Sdim ToD, cast_or_null<TypeDecl>(ToPrevD)); 1301327952Sdim} 1302327952Sdim 1303344779SdimExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) { 1304344779Sdim ExpectedType ToInnerTypeOrErr = import(T->getInnerType()); 1305344779Sdim if (!ToInnerTypeOrErr) 1306344779Sdim return ToInnerTypeOrErr.takeError(); 1307341825Sdim 1308344779Sdim return Importer.getToContext().getParenType(*ToInnerTypeOrErr); 1309226633Sdim} 1310226633Sdim 1311344779SdimExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 1312344779Sdim Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl()); 1313344779Sdim if (!ToDeclOrErr) 1314344779Sdim return ToDeclOrErr.takeError(); 1315341825Sdim 1316344779Sdim return Importer.getToContext().getTypeDeclType(*ToDeclOrErr); 1317203955Srdivacky} 1318203955Srdivacky 1319344779SdimExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 1320344779Sdim ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr()); 1321344779Sdim if (!ToExprOrErr) 1322344779Sdim return ToExprOrErr.takeError(); 1323341825Sdim 1324344779Sdim return Importer.getToContext().getTypeOfExprType(*ToExprOrErr); 1325203955Srdivacky} 1326203955Srdivacky 1327344779SdimExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 1328344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1329344779Sdim if (!ToUnderlyingTypeOrErr) 1330344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1331341825Sdim 1332344779Sdim return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr); 1333203955Srdivacky} 1334203955Srdivacky 1335344779SdimExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 1336218893Sdim // FIXME: Make sure that the "to" context supports C++0x! 1337344779Sdim ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr()); 1338344779Sdim if (!ToExprOrErr) 1339344779Sdim return ToExprOrErr.takeError(); 1340341825Sdim 1341344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1342344779Sdim if (!ToUnderlyingTypeOrErr) 1343344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1344234353Sdim 1345344779Sdim return Importer.getToContext().getDecltypeType( 1346344779Sdim *ToExprOrErr, *ToUnderlyingTypeOrErr); 1347203955Srdivacky} 1348203955Srdivacky 1349344779SdimExpectedType 1350344779SdimASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 1351344779Sdim ExpectedType ToBaseTypeOrErr = import(T->getBaseType()); 1352344779Sdim if (!ToBaseTypeOrErr) 1353344779Sdim return ToBaseTypeOrErr.takeError(); 1354223017Sdim 1355344779Sdim ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType()); 1356344779Sdim if (!ToUnderlyingTypeOrErr) 1357344779Sdim return ToUnderlyingTypeOrErr.takeError(); 1358344779Sdim 1359344779Sdim return Importer.getToContext().getUnaryTransformType( 1360344779Sdim *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind()); 1361223017Sdim} 1362223017Sdim 1363344779SdimExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) { 1364251662Sdim // FIXME: Make sure that the "to" context supports C++11! 1365344779Sdim ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType()); 1366344779Sdim if (!ToDeducedTypeOrErr) 1367344779Sdim return ToDeducedTypeOrErr.takeError(); 1368341825Sdim 1369360784Sdim ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept()); 1370360784Sdim if (!ToTypeConstraintConcept) 1371360784Sdim return ToTypeConstraintConcept.takeError(); 1372360784Sdim 1373360784Sdim SmallVector<TemplateArgument, 2> ToTemplateArgs; 1374360784Sdim ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments(); 1375360784Sdim if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(), 1376360784Sdim FromTemplateArgs.size(), 1377360784Sdim ToTemplateArgs)) 1378360784Sdim return std::move(Err); 1379360784Sdim 1380360784Sdim return Importer.getToContext().getAutoType( 1381360784Sdim *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false, 1382360784Sdim /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept), 1383360784Sdim ToTemplateArgs); 1384218893Sdim} 1385218893Sdim 1386344779SdimExpectedType ASTNodeImporter::VisitInjectedClassNameType( 1387309124Sdim const InjectedClassNameType *T) { 1388344779Sdim Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl()); 1389344779Sdim if (!ToDeclOrErr) 1390344779Sdim return ToDeclOrErr.takeError(); 1391309124Sdim 1392344779Sdim ExpectedType ToInjTypeOrErr = import(T->getInjectedSpecializationType()); 1393344779Sdim if (!ToInjTypeOrErr) 1394344779Sdim return ToInjTypeOrErr.takeError(); 1395309124Sdim 1396309124Sdim // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading 1397309124Sdim // See comments in InjectedClassNameType definition for details 1398309124Sdim // return Importer.getToContext().getInjectedClassNameType(D, InjType); 1399309124Sdim enum { 1400309124Sdim TypeAlignmentInBits = 4, 1401309124Sdim TypeAlignment = 1 << TypeAlignmentInBits 1402309124Sdim }; 1403309124Sdim 1404309124Sdim return QualType(new (Importer.getToContext(), TypeAlignment) 1405344779Sdim InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0); 1406309124Sdim} 1407309124Sdim 1408344779SdimExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) { 1409344779Sdim Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl()); 1410344779Sdim if (!ToDeclOrErr) 1411344779Sdim return ToDeclOrErr.takeError(); 1412203955Srdivacky 1413344779Sdim return Importer.getToContext().getTagDeclType(*ToDeclOrErr); 1414203955Srdivacky} 1415203955Srdivacky 1416344779SdimExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) { 1417344779Sdim Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl()); 1418344779Sdim if (!ToDeclOrErr) 1419344779Sdim return ToDeclOrErr.takeError(); 1420203955Srdivacky 1421344779Sdim return Importer.getToContext().getTagDeclType(*ToDeclOrErr); 1422203955Srdivacky} 1423203955Srdivacky 1424344779SdimExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 1425344779Sdim ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType()); 1426344779Sdim if (!ToModifiedTypeOrErr) 1427344779Sdim return ToModifiedTypeOrErr.takeError(); 1428344779Sdim ExpectedType ToEquivalentTypeOrErr = import(T->getEquivalentType()); 1429344779Sdim if (!ToEquivalentTypeOrErr) 1430344779Sdim return ToEquivalentTypeOrErr.takeError(); 1431288943Sdim 1432288943Sdim return Importer.getToContext().getAttributedType(T->getAttrKind(), 1433344779Sdim *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr); 1434288943Sdim} 1435288943Sdim 1436344779SdimExpectedType ASTNodeImporter::VisitTemplateTypeParmType( 1437309124Sdim const TemplateTypeParmType *T) { 1438344779Sdim Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl()); 1439344779Sdim if (!ToDeclOrErr) 1440344779Sdim return ToDeclOrErr.takeError(); 1441309124Sdim 1442309124Sdim return Importer.getToContext().getTemplateTypeParmType( 1443344779Sdim T->getDepth(), T->getIndex(), T->isParameterPack(), *ToDeclOrErr); 1444309124Sdim} 1445309124Sdim 1446344779SdimExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType( 1447321369Sdim const SubstTemplateTypeParmType *T) { 1448344779Sdim ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0)); 1449344779Sdim if (!ReplacedOrErr) 1450344779Sdim return ReplacedOrErr.takeError(); 1451344779Sdim const TemplateTypeParmType *Replaced = 1452344779Sdim cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr()); 1453321369Sdim 1454344779Sdim ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType()); 1455344779Sdim if (!ToReplacementTypeOrErr) 1456344779Sdim return ToReplacementTypeOrErr.takeError(); 1457321369Sdim 1458321369Sdim return Importer.getToContext().getSubstTemplateTypeParmType( 1459344779Sdim Replaced, (*ToReplacementTypeOrErr).getCanonicalType()); 1460321369Sdim} 1461321369Sdim 1462344779SdimExpectedType ASTNodeImporter::VisitTemplateSpecializationType( 1463218893Sdim const TemplateSpecializationType *T) { 1464344779Sdim auto ToTemplateOrErr = import(T->getTemplateName()); 1465344779Sdim if (!ToTemplateOrErr) 1466344779Sdim return ToTemplateOrErr.takeError(); 1467341825Sdim 1468226633Sdim SmallVector<TemplateArgument, 2> ToTemplateArgs; 1469344779Sdim if (Error Err = ImportTemplateArguments( 1470344779Sdim T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 1471344779Sdim return std::move(Err); 1472341825Sdim 1473218893Sdim QualType ToCanonType; 1474218893Sdim if (!QualType(T, 0).isCanonical()) { 1475341825Sdim QualType FromCanonType 1476218893Sdim = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 1477344779Sdim if (ExpectedType TyOrErr = import(FromCanonType)) 1478344779Sdim ToCanonType = *TyOrErr; 1479344779Sdim else 1480344779Sdim return TyOrErr.takeError(); 1481218893Sdim } 1482344779Sdim return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr, 1483309124Sdim ToTemplateArgs, 1484218893Sdim ToCanonType); 1485218893Sdim} 1486218893Sdim 1487344779SdimExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 1488208600Srdivacky // Note: the qualifier in an ElaboratedType is optional. 1489344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1490344779Sdim if (!ToQualifierOrErr) 1491344779Sdim return ToQualifierOrErr.takeError(); 1492203955Srdivacky 1493344779Sdim ExpectedType ToNamedTypeOrErr = import(T->getNamedType()); 1494344779Sdim if (!ToNamedTypeOrErr) 1495344779Sdim return ToNamedTypeOrErr.takeError(); 1496203955Srdivacky 1497344779Sdim Expected<TagDecl *> ToOwnedTagDeclOrErr = import(T->getOwnedTagDecl()); 1498344779Sdim if (!ToOwnedTagDeclOrErr) 1499344779Sdim return ToOwnedTagDeclOrErr.takeError(); 1500341825Sdim 1501208600Srdivacky return Importer.getToContext().getElaboratedType(T->getKeyword(), 1502344779Sdim *ToQualifierOrErr, 1503344779Sdim *ToNamedTypeOrErr, 1504344779Sdim *ToOwnedTagDeclOrErr); 1505203955Srdivacky} 1506203955Srdivacky 1507344779SdimExpectedType 1508344779SdimASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) { 1509344779Sdim ExpectedType ToPatternOrErr = import(T->getPattern()); 1510344779Sdim if (!ToPatternOrErr) 1511344779Sdim return ToPatternOrErr.takeError(); 1512327952Sdim 1513344779Sdim return Importer.getToContext().getPackExpansionType(*ToPatternOrErr, 1514327952Sdim T->getNumExpansions()); 1515327952Sdim} 1516327952Sdim 1517344779SdimExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType( 1518341825Sdim const DependentTemplateSpecializationType *T) { 1519344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1520344779Sdim if (!ToQualifierOrErr) 1521344779Sdim return ToQualifierOrErr.takeError(); 1522341825Sdim 1523344779Sdim IdentifierInfo *ToName = Importer.Import(T->getIdentifier()); 1524341825Sdim 1525341825Sdim SmallVector<TemplateArgument, 2> ToPack; 1526341825Sdim ToPack.reserve(T->getNumArgs()); 1527344779Sdim if (Error Err = ImportTemplateArguments( 1528344779Sdim T->getArgs(), T->getNumArgs(), ToPack)) 1529344779Sdim return std::move(Err); 1530341825Sdim 1531341825Sdim return Importer.getToContext().getDependentTemplateSpecializationType( 1532344779Sdim T->getKeyword(), *ToQualifierOrErr, ToName, ToPack); 1533341825Sdim} 1534341825Sdim 1535344779SdimExpectedType 1536344779SdimASTNodeImporter::VisitDependentNameType(const DependentNameType *T) { 1537344779Sdim auto ToQualifierOrErr = import(T->getQualifier()); 1538344779Sdim if (!ToQualifierOrErr) 1539344779Sdim return ToQualifierOrErr.takeError(); 1540341825Sdim 1541341825Sdim IdentifierInfo *Name = Importer.Import(T->getIdentifier()); 1542341825Sdim 1543344779Sdim QualType Canon; 1544344779Sdim if (T != T->getCanonicalTypeInternal().getTypePtr()) { 1545344779Sdim if (ExpectedType TyOrErr = import(T->getCanonicalTypeInternal())) 1546344779Sdim Canon = (*TyOrErr).getCanonicalType(); 1547344779Sdim else 1548344779Sdim return TyOrErr.takeError(); 1549344779Sdim } 1550341825Sdim 1551344779Sdim return Importer.getToContext().getDependentNameType(T->getKeyword(), 1552344779Sdim *ToQualifierOrErr, 1553341825Sdim Name, Canon); 1554341825Sdim} 1555341825Sdim 1556344779SdimExpectedType 1557344779SdimASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 1558344779Sdim Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl()); 1559344779Sdim if (!ToDeclOrErr) 1560344779Sdim return ToDeclOrErr.takeError(); 1561203955Srdivacky 1562344779Sdim return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr); 1563208600Srdivacky} 1564208600Srdivacky 1565344779SdimExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 1566344779Sdim ExpectedType ToBaseTypeOrErr = import(T->getBaseType()); 1567344779Sdim if (!ToBaseTypeOrErr) 1568344779Sdim return ToBaseTypeOrErr.takeError(); 1569208600Srdivacky 1570288943Sdim SmallVector<QualType, 4> TypeArgs; 1571288943Sdim for (auto TypeArg : T->getTypeArgsAsWritten()) { 1572344779Sdim if (ExpectedType TyOrErr = import(TypeArg)) 1573344779Sdim TypeArgs.push_back(*TyOrErr); 1574344779Sdim else 1575344779Sdim return TyOrErr.takeError(); 1576288943Sdim } 1577288943Sdim 1578226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 1579276479Sdim for (auto *P : T->quals()) { 1580344779Sdim if (Expected<ObjCProtocolDecl *> ProtocolOrErr = import(P)) 1581344779Sdim Protocols.push_back(*ProtocolOrErr); 1582344779Sdim else 1583344779Sdim return ProtocolOrErr.takeError(); 1584344779Sdim 1585203955Srdivacky } 1586203955Srdivacky 1587344779Sdim return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs, 1588288943Sdim Protocols, 1589288943Sdim T->isKindOfTypeAsWritten()); 1590203955Srdivacky} 1591203955Srdivacky 1592344779SdimExpectedType 1593218893SdimASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 1594344779Sdim ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType()); 1595344779Sdim if (!ToPointeeTypeOrErr) 1596344779Sdim return ToPointeeTypeOrErr.takeError(); 1597203955Srdivacky 1598344779Sdim return Importer.getToContext().getObjCObjectPointerType(*ToPointeeTypeOrErr); 1599203955Srdivacky} 1600203955Srdivacky 1601203955Srdivacky//---------------------------------------------------------------------------- 1602203955Srdivacky// Import Declarations 1603203955Srdivacky//---------------------------------------------------------------------------- 1604344779SdimError ASTNodeImporter::ImportDeclParts( 1605344779Sdim NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, 1606344779Sdim DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) { 1607341825Sdim // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop. 1608341825Sdim // example: int struct_in_proto(struct data_t{int a;int b;} *d); 1609360784Sdim // FIXME: We could support these constructs by importing a different type of 1610360784Sdim // this parameter and by importing the original type of the parameter only 1611360784Sdim // after the FunctionDecl is created. See 1612360784Sdim // VisitFunctionDecl::UsedDifferentProtoType. 1613341825Sdim DeclContext *OrigDC = D->getDeclContext(); 1614341825Sdim FunctionDecl *FunDecl; 1615341825Sdim if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) && 1616341825Sdim FunDecl->hasBody()) { 1617344779Sdim auto getLeafPointeeType = [](const Type *T) { 1618344779Sdim while (T->isPointerType() || T->isArrayType()) { 1619344779Sdim T = T->getPointeeOrArrayElementType(); 1620344779Sdim } 1621344779Sdim return T; 1622344779Sdim }; 1623344779Sdim for (const ParmVarDecl *P : FunDecl->parameters()) { 1624344779Sdim const Type *LeafT = 1625344779Sdim getLeafPointeeType(P->getType().getCanonicalType().getTypePtr()); 1626344779Sdim auto *RT = dyn_cast<RecordType>(LeafT); 1627344779Sdim if (RT && RT->getDecl() == D) { 1628344779Sdim Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 1629344779Sdim << D->getDeclKindName(); 1630344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 1631344779Sdim } 1632341825Sdim } 1633341825Sdim } 1634341825Sdim 1635203955Srdivacky // Import the context of this declaration. 1636344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 1637344779Sdim return Err; 1638341825Sdim 1639203955Srdivacky // Import the name of this declaration. 1640344779Sdim if (Error Err = importInto(Name, D->getDeclName())) 1641344779Sdim return Err; 1642341825Sdim 1643203955Srdivacky // Import the location of this declaration. 1644344779Sdim if (Error Err = importInto(Loc, D->getLocation())) 1645344779Sdim return Err; 1646344779Sdim 1647288943Sdim ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 1648344779Sdim if (ToD) 1649344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinitionIfNeeded(D, ToD)) 1650344779Sdim return Err; 1651344779Sdim 1652344779Sdim return Error::success(); 1653203955Srdivacky} 1654203955Srdivacky 1655344779SdimError ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 1656226633Sdim if (!FromD) 1657344779Sdim return Error::success(); 1658341825Sdim 1659344779Sdim if (!ToD) 1660344779Sdim if (Error Err = importInto(ToD, FromD)) 1661344779Sdim return Err; 1662341825Sdim 1663344779Sdim if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) { 1664344779Sdim if (RecordDecl *ToRecord = cast<RecordDecl>(ToD)) { 1665344779Sdim if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && 1666344779Sdim !ToRecord->getDefinition()) { 1667344779Sdim if (Error Err = ImportDefinition(FromRecord, ToRecord)) 1668344779Sdim return Err; 1669226633Sdim } 1670226633Sdim } 1671344779Sdim return Error::success(); 1672226633Sdim } 1673226633Sdim 1674344779Sdim if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) { 1675344779Sdim if (EnumDecl *ToEnum = cast<EnumDecl>(ToD)) { 1676226633Sdim if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 1677344779Sdim if (Error Err = ImportDefinition(FromEnum, ToEnum)) 1678344779Sdim return Err; 1679226633Sdim } 1680226633Sdim } 1681344779Sdim return Error::success(); 1682226633Sdim } 1683344779Sdim 1684344779Sdim return Error::success(); 1685226633Sdim} 1686226633Sdim 1687344779SdimError 1688344779SdimASTNodeImporter::ImportDeclarationNameLoc( 1689344779Sdim const DeclarationNameInfo &From, DeclarationNameInfo& To) { 1690212904Sdim // NOTE: To.Name and To.Loc are already imported. 1691212904Sdim // We only have to import To.LocInfo. 1692212904Sdim switch (To.getName().getNameKind()) { 1693212904Sdim case DeclarationName::Identifier: 1694212904Sdim case DeclarationName::ObjCZeroArgSelector: 1695212904Sdim case DeclarationName::ObjCOneArgSelector: 1696212904Sdim case DeclarationName::ObjCMultiArgSelector: 1697212904Sdim case DeclarationName::CXXUsingDirective: 1698321369Sdim case DeclarationName::CXXDeductionGuideName: 1699344779Sdim return Error::success(); 1700212904Sdim 1701212904Sdim case DeclarationName::CXXOperatorName: { 1702344779Sdim if (auto ToRangeOrErr = import(From.getCXXOperatorNameRange())) 1703344779Sdim To.setCXXOperatorNameRange(*ToRangeOrErr); 1704344779Sdim else 1705344779Sdim return ToRangeOrErr.takeError(); 1706344779Sdim return Error::success(); 1707212904Sdim } 1708212904Sdim case DeclarationName::CXXLiteralOperatorName: { 1709344779Sdim if (ExpectedSLoc LocOrErr = import(From.getCXXLiteralOperatorNameLoc())) 1710344779Sdim To.setCXXLiteralOperatorNameLoc(*LocOrErr); 1711344779Sdim else 1712344779Sdim return LocOrErr.takeError(); 1713344779Sdim return Error::success(); 1714212904Sdim } 1715212904Sdim case DeclarationName::CXXConstructorName: 1716212904Sdim case DeclarationName::CXXDestructorName: 1717212904Sdim case DeclarationName::CXXConversionFunctionName: { 1718344779Sdim if (auto ToTInfoOrErr = import(From.getNamedTypeInfo())) 1719344779Sdim To.setNamedTypeInfo(*ToTInfoOrErr); 1720344779Sdim else 1721344779Sdim return ToTInfoOrErr.takeError(); 1722344779Sdim return Error::success(); 1723212904Sdim } 1724212904Sdim } 1725234353Sdim llvm_unreachable("Unknown name kind."); 1726212904Sdim} 1727212904Sdim 1728344779SdimError 1729344779SdimASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 1730218893Sdim if (Importer.isMinimalImport() && !ForceImport) { 1731344779Sdim auto ToDCOrErr = Importer.ImportContext(FromDC); 1732344779Sdim return ToDCOrErr.takeError(); 1733218893Sdim } 1734353358Sdim 1735353358Sdim // We use strict error handling in case of records and enums, but not 1736353358Sdim // with e.g. namespaces. 1737353358Sdim // 1738353358Sdim // FIXME Clients of the ASTImporter should be able to choose an 1739353358Sdim // appropriate error handling strategy for their needs. For instance, 1740353358Sdim // they may not want to mark an entire namespace as erroneous merely 1741353358Sdim // because there is an ODR error with two typedefs. As another example, 1742353358Sdim // the client may allow EnumConstantDecls with same names but with 1743353358Sdim // different values in two distinct translation units. 1744353358Sdim bool AccumulateChildErrors = isa<TagDecl>(FromDC); 1745353358Sdim 1746353358Sdim Error ChildErrors = Error::success(); 1747344779Sdim for (auto *From : FromDC->decls()) { 1748344779Sdim ExpectedDecl ImportedOrErr = import(From); 1749360784Sdim 1750360784Sdim // If we are in the process of ImportDefinition(...) for a RecordDecl we 1751360784Sdim // want to make sure that we are also completing each FieldDecl. There 1752360784Sdim // are currently cases where this does not happen and this is correctness 1753360784Sdim // fix since operations such as code generation will expect this to be so. 1754360784Sdim if (ImportedOrErr) { 1755360784Sdim FieldDecl *FieldFrom = dyn_cast_or_null<FieldDecl>(From); 1756360784Sdim Decl *ImportedDecl = (Decl*)*ImportedOrErr; 1757360784Sdim FieldDecl *FieldTo = dyn_cast_or_null<FieldDecl>(ImportedDecl); 1758360784Sdim if (FieldFrom && FieldTo) { 1759360784Sdim const RecordType *RecordFrom = FieldFrom->getType()->getAs<RecordType>(); 1760360784Sdim const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>(); 1761360784Sdim if (RecordFrom && RecordTo) { 1762360784Sdim RecordDecl *FromRecordDecl = RecordFrom->getDecl(); 1763360784Sdim RecordDecl *ToRecordDecl = RecordTo->getDecl(); 1764360784Sdim 1765360784Sdim if (FromRecordDecl->isCompleteDefinition() && 1766360784Sdim !ToRecordDecl->isCompleteDefinition()) { 1767360784Sdim Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl); 1768360784Sdim 1769360784Sdim if (Err && AccumulateChildErrors) 1770360784Sdim ChildErrors = joinErrors(std::move(ChildErrors), std::move(Err)); 1771360784Sdim else 1772360784Sdim consumeError(std::move(Err)); 1773360784Sdim } 1774360784Sdim } 1775360784Sdim } 1776360784Sdim } else { 1777353358Sdim if (AccumulateChildErrors) 1778353358Sdim ChildErrors = 1779353358Sdim joinErrors(std::move(ChildErrors), ImportedOrErr.takeError()); 1780353358Sdim else 1781353358Sdim consumeError(ImportedOrErr.takeError()); 1782353358Sdim } 1783344779Sdim } 1784341825Sdim 1785360784Sdim // We reorder declarations in RecordDecls because they may have another order 1786360784Sdim // in the "to" context than they have in the "from" context. This may happen 1787360784Sdim // e.g when we import a class like this: 1788360784Sdim // struct declToImport { 1789360784Sdim // int a = c + b; 1790360784Sdim // int b = 1; 1791360784Sdim // int c = 2; 1792360784Sdim // }; 1793360784Sdim // During the import of `a` we import first the dependencies in sequence, 1794360784Sdim // thus the order would be `c`, `b`, `a`. We will get the normal order by 1795360784Sdim // first removing the already imported members and then adding them in the 1796360784Sdim // order as they apper in the "from" context. 1797360784Sdim // 1798360784Sdim // Keeping field order is vital because it determines structure layout. 1799360784Sdim // 1800360784Sdim // Here and below, we cannot call field_begin() method and its callers on 1801360784Sdim // ToDC if it has an external storage. Calling field_begin() will 1802360784Sdim // automatically load all the fields by calling 1803360784Sdim // LoadFieldsFromExternalStorage(). LoadFieldsFromExternalStorage() would 1804360784Sdim // call ASTImporter::Import(). This is because the ExternalASTSource 1805360784Sdim // interface in LLDB is implemented by the means of the ASTImporter. However, 1806360784Sdim // calling an import at this point would result in an uncontrolled import, we 1807360784Sdim // must avoid that. 1808360784Sdim const auto *FromRD = dyn_cast<RecordDecl>(FromDC); 1809360784Sdim if (!FromRD) 1810360784Sdim return ChildErrors; 1811360784Sdim 1812360784Sdim auto ToDCOrErr = Importer.ImportContext(FromDC); 1813360784Sdim if (!ToDCOrErr) { 1814360784Sdim consumeError(std::move(ChildErrors)); 1815360784Sdim return ToDCOrErr.takeError(); 1816360784Sdim } 1817360784Sdim 1818360784Sdim DeclContext *ToDC = *ToDCOrErr; 1819360784Sdim // Remove all declarations, which may be in wrong order in the 1820360784Sdim // lexical DeclContext and then add them in the proper order. 1821360784Sdim for (auto *D : FromRD->decls()) { 1822360784Sdim if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FriendDecl>(D)) { 1823360784Sdim assert(D && "DC contains a null decl"); 1824360784Sdim Decl *ToD = Importer.GetAlreadyImportedOrNull(D); 1825360784Sdim // Remove only the decls which we successfully imported. 1826360784Sdim if (ToD) { 1827360784Sdim assert(ToDC == ToD->getLexicalDeclContext() && ToDC->containsDecl(ToD)); 1828360784Sdim // Remove the decl from its wrong place in the linked list. 1829360784Sdim ToDC->removeDecl(ToD); 1830360784Sdim // Add the decl to the end of the linked list. 1831360784Sdim // This time it will be at the proper place because the enclosing for 1832360784Sdim // loop iterates in the original (good) order of the decls. 1833360784Sdim ToDC->addDeclInternal(ToD); 1834360784Sdim } 1835360784Sdim } 1836360784Sdim } 1837360784Sdim 1838353358Sdim return ChildErrors; 1839204643Srdivacky} 1840204643Srdivacky 1841344779SdimError ASTNodeImporter::ImportDeclContext( 1842344779Sdim Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) { 1843344779Sdim auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext()); 1844344779Sdim if (!ToDCOrErr) 1845344779Sdim return ToDCOrErr.takeError(); 1846344779Sdim ToDC = *ToDCOrErr; 1847344779Sdim 1848344779Sdim if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) { 1849344779Sdim auto ToLexicalDCOrErr = Importer.ImportContext( 1850344779Sdim FromD->getLexicalDeclContext()); 1851344779Sdim if (!ToLexicalDCOrErr) 1852344779Sdim return ToLexicalDCOrErr.takeError(); 1853344779Sdim ToLexicalDC = *ToLexicalDCOrErr; 1854344779Sdim } else 1855344779Sdim ToLexicalDC = ToDC; 1856344779Sdim 1857344779Sdim return Error::success(); 1858344779Sdim} 1859344779Sdim 1860344779SdimError ASTNodeImporter::ImportImplicitMethods( 1861341825Sdim const CXXRecordDecl *From, CXXRecordDecl *To) { 1862341825Sdim assert(From->isCompleteDefinition() && To->getDefinition() == To && 1863341825Sdim "Import implicit methods to or from non-definition"); 1864341825Sdim 1865341825Sdim for (CXXMethodDecl *FromM : From->methods()) 1866344779Sdim if (FromM->isImplicit()) { 1867344779Sdim Expected<CXXMethodDecl *> ToMOrErr = import(FromM); 1868344779Sdim if (!ToMOrErr) 1869344779Sdim return ToMOrErr.takeError(); 1870344779Sdim } 1871344779Sdim 1872344779Sdim return Error::success(); 1873341825Sdim} 1874341825Sdim 1875344779Sdimstatic Error setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, 1876344779Sdim ASTImporter &Importer) { 1877341825Sdim if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) { 1878353358Sdim if (ExpectedDecl ToTypedefOrErr = Importer.Import(FromTypedef)) 1879353358Sdim To->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(*ToTypedefOrErr)); 1880353358Sdim else 1881353358Sdim return ToTypedefOrErr.takeError(); 1882341825Sdim } 1883344779Sdim return Error::success(); 1884341825Sdim} 1885341825Sdim 1886344779SdimError ASTNodeImporter::ImportDefinition( 1887344779Sdim RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) { 1888353358Sdim auto DefinitionCompleter = [To]() { 1889353358Sdim // There are cases in LLDB when we first import a class without its 1890353358Sdim // members. The class will have DefinitionData, but no members. Then, 1891353358Sdim // importDefinition is called from LLDB, which tries to get the members, so 1892353358Sdim // when we get here, the class already has the DefinitionData set, so we 1893353358Sdim // must unset the CompleteDefinition here to be able to complete again the 1894353358Sdim // definition. 1895353358Sdim To->setCompleteDefinition(false); 1896353358Sdim To->completeDefinition(); 1897353358Sdim }; 1898353358Sdim 1899234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 1900353358Sdim if (Kind == IDK_Everything || 1901353358Sdim // In case of lambdas, the class already has a definition ptr set, but 1902353358Sdim // the contained decls are not imported yet. Also, isBeingDefined was 1903353358Sdim // set in CXXRecordDecl::CreateLambda. We must import the contained 1904353358Sdim // decls here and finish the definition. 1905353358Sdim (To->isLambda() && shouldForceImportDeclContext(Kind))) { 1906353358Sdim Error Result = ImportDeclContext(From, /*ForceImport=*/true); 1907353358Sdim // Finish the definition of the lambda, set isBeingDefined to false. 1908353358Sdim if (To->isLambda()) 1909353358Sdim DefinitionCompleter(); 1910353358Sdim return Result; 1911353358Sdim } 1912341825Sdim 1913344779Sdim return Error::success(); 1914234353Sdim } 1915341825Sdim 1916218893Sdim To->startDefinition(); 1917353358Sdim // Complete the definition even if error is returned. 1918353358Sdim // The RecordDecl may be already part of the AST so it is better to 1919353358Sdim // have it in complete state even if something is wrong with it. 1920353358Sdim auto DefinitionCompleterScopeExit = 1921353358Sdim llvm::make_scope_exit(DefinitionCompleter); 1922341825Sdim 1923344779Sdim if (Error Err = setTypedefNameForAnonDecl(From, To, Importer)) 1924344779Sdim return Err; 1925341825Sdim 1926218893Sdim // Add base classes. 1927344779Sdim auto *ToCXX = dyn_cast<CXXRecordDecl>(To); 1928344779Sdim auto *FromCXX = dyn_cast<CXXRecordDecl>(From); 1929344779Sdim if (ToCXX && FromCXX && ToCXX->dataPtr() && FromCXX->dataPtr()) { 1930234353Sdim 1931234353Sdim struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 1932234353Sdim struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 1933234353Sdim 1934360784Sdim #define FIELD(Name, Width, Merge) \ 1935360784Sdim ToData.Name = FromData.Name; 1936360784Sdim #include "clang/AST/CXXRecordDeclDefinitionBits.def" 1937360784Sdim 1938353358Sdim // Copy over the data stored in RecordDeclBits 1939353358Sdim ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions()); 1940353358Sdim 1941226633Sdim SmallVector<CXXBaseSpecifier *, 4> Bases; 1942276479Sdim for (const auto &Base1 : FromCXX->bases()) { 1943344779Sdim ExpectedType TyOrErr = import(Base1.getType()); 1944344779Sdim if (!TyOrErr) 1945344779Sdim return TyOrErr.takeError(); 1946218893Sdim 1947218893Sdim SourceLocation EllipsisLoc; 1948344779Sdim if (Base1.isPackExpansion()) { 1949344779Sdim if (ExpectedSLoc LocOrErr = import(Base1.getEllipsisLoc())) 1950344779Sdim EllipsisLoc = *LocOrErr; 1951344779Sdim else 1952344779Sdim return LocOrErr.takeError(); 1953344779Sdim } 1954226633Sdim 1955226633Sdim // Ensure that we have a definition for the base. 1956344779Sdim if (Error Err = 1957344779Sdim ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl())) 1958344779Sdim return Err; 1959341825Sdim 1960344779Sdim auto RangeOrErr = import(Base1.getSourceRange()); 1961344779Sdim if (!RangeOrErr) 1962344779Sdim return RangeOrErr.takeError(); 1963344779Sdim 1964344779Sdim auto TSIOrErr = import(Base1.getTypeSourceInfo()); 1965344779Sdim if (!TSIOrErr) 1966344779Sdim return TSIOrErr.takeError(); 1967344779Sdim 1968218893Sdim Bases.push_back( 1969344779Sdim new (Importer.getToContext()) CXXBaseSpecifier( 1970344779Sdim *RangeOrErr, 1971344779Sdim Base1.isVirtual(), 1972344779Sdim Base1.isBaseOfClass(), 1973344779Sdim Base1.getAccessSpecifierAsWritten(), 1974344779Sdim *TSIOrErr, 1975344779Sdim EllipsisLoc)); 1976218893Sdim } 1977218893Sdim if (!Bases.empty()) 1978218893Sdim ToCXX->setBases(Bases.data(), Bases.size()); 1979218893Sdim } 1980341825Sdim 1981234353Sdim if (shouldForceImportDeclContext(Kind)) 1982344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 1983344779Sdim return Err; 1984341825Sdim 1985344779Sdim return Error::success(); 1986218893Sdim} 1987218893Sdim 1988344779SdimError ASTNodeImporter::ImportInitializer(VarDecl *From, VarDecl *To) { 1989288943Sdim if (To->getAnyInitializer()) 1990344779Sdim return Error::success(); 1991261991Sdim 1992344779Sdim Expr *FromInit = From->getInit(); 1993344779Sdim if (!FromInit) 1994344779Sdim return Error::success(); 1995261991Sdim 1996344779Sdim ExpectedExpr ToInitOrErr = import(FromInit); 1997344779Sdim if (!ToInitOrErr) 1998344779Sdim return ToInitOrErr.takeError(); 1999344779Sdim 2000344779Sdim To->setInit(*ToInitOrErr); 2001344779Sdim if (From->isInitKnownICE()) { 2002344779Sdim EvaluatedStmt *Eval = To->ensureEvaluatedStmt(); 2003344779Sdim Eval->CheckedICE = true; 2004344779Sdim Eval->IsICE = From->isInitICE(); 2005344779Sdim } 2006344779Sdim 2007261991Sdim // FIXME: Other bits to merge? 2008344779Sdim return Error::success(); 2009261991Sdim} 2010261991Sdim 2011344779SdimError ASTNodeImporter::ImportDefinition( 2012344779Sdim EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) { 2013234353Sdim if (To->getDefinition() || To->isBeingDefined()) { 2014234353Sdim if (Kind == IDK_Everything) 2015344779Sdim return ImportDeclContext(From, /*ForceImport=*/true); 2016344779Sdim return Error::success(); 2017234353Sdim } 2018341825Sdim 2019226633Sdim To->startDefinition(); 2020226633Sdim 2021344779Sdim if (Error Err = setTypedefNameForAnonDecl(From, To, Importer)) 2022344779Sdim return Err; 2023341825Sdim 2024344779Sdim ExpectedType ToTypeOrErr = 2025344779Sdim import(Importer.getFromContext().getTypeDeclType(From)); 2026344779Sdim if (!ToTypeOrErr) 2027344779Sdim return ToTypeOrErr.takeError(); 2028341825Sdim 2029344779Sdim ExpectedType ToPromotionTypeOrErr = import(From->getPromotionType()); 2030344779Sdim if (!ToPromotionTypeOrErr) 2031344779Sdim return ToPromotionTypeOrErr.takeError(); 2032234353Sdim 2033234353Sdim if (shouldForceImportDeclContext(Kind)) 2034344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 2035344779Sdim return Err; 2036341825Sdim 2037226633Sdim // FIXME: we might need to merge the number of positive or negative bits 2038226633Sdim // if the enumerator lists don't match. 2039344779Sdim To->completeDefinition(*ToTypeOrErr, *ToPromotionTypeOrErr, 2040226633Sdim From->getNumPositiveBits(), 2041226633Sdim From->getNumNegativeBits()); 2042344779Sdim return Error::success(); 2043226633Sdim} 2044226633Sdim 2045344779SdimError ASTNodeImporter::ImportTemplateArguments( 2046344779Sdim const TemplateArgument *FromArgs, unsigned NumFromArgs, 2047344779Sdim SmallVectorImpl<TemplateArgument> &ToArgs) { 2048344779Sdim for (unsigned I = 0; I != NumFromArgs; ++I) { 2049344779Sdim if (auto ToOrErr = import(FromArgs[I])) 2050344779Sdim ToArgs.push_back(*ToOrErr); 2051314564Sdim else 2052344779Sdim return ToOrErr.takeError(); 2053314564Sdim } 2054344779Sdim 2055344779Sdim return Error::success(); 2056314564Sdim} 2057314564Sdim 2058344779Sdim// FIXME: Do not forget to remove this and use only 'import'. 2059344779SdimExpected<TemplateArgument> 2060344779SdimASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 2061344779Sdim return import(From); 2062218893Sdim} 2063218893Sdim 2064327952Sdimtemplate <typename InContainerTy> 2065344779SdimError ASTNodeImporter::ImportTemplateArgumentListInfo( 2066327952Sdim const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) { 2067327952Sdim for (const auto &FromLoc : Container) { 2068344779Sdim if (auto ToLocOrErr = import(FromLoc)) 2069344779Sdim ToTAInfo.addArgument(*ToLocOrErr); 2070327952Sdim else 2071344779Sdim return ToLocOrErr.takeError(); 2072327952Sdim } 2073344779Sdim return Error::success(); 2074327952Sdim} 2075327952Sdim 2076341825Sdimstatic StructuralEquivalenceKind 2077341825SdimgetStructuralEquivalenceKind(const ASTImporter &Importer) { 2078341825Sdim return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal 2079341825Sdim : StructuralEquivalenceKind::Default; 2080341825Sdim} 2081341825Sdim 2082341825Sdimbool ASTNodeImporter::IsStructuralMatch(Decl *From, Decl *To, bool Complain) { 2083341825Sdim StructuralEquivalenceContext Ctx( 2084341825Sdim Importer.getFromContext(), Importer.getToContext(), 2085341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2086341825Sdim false, Complain); 2087341825Sdim return Ctx.IsEquivalent(From, To); 2088341825Sdim} 2089341825Sdim 2090341825Sdimbool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 2091239462Sdim RecordDecl *ToRecord, bool Complain) { 2092261991Sdim // Eliminate a potential failure point where we attempt to re-import 2093261991Sdim // something we're trying to import while completing ToRecord. 2094261991Sdim Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 2095261991Sdim if (ToOrigin) { 2096341825Sdim auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 2097261991Sdim if (ToOriginRecord) 2098261991Sdim ToRecord = ToOriginRecord; 2099261991Sdim } 2100261991Sdim 2101204643Srdivacky StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2102261991Sdim ToRecord->getASTContext(), 2103239462Sdim Importer.getNonEquivalentDecls(), 2104341825Sdim getStructuralEquivalenceKind(Importer), 2105239462Sdim false, Complain); 2106341825Sdim return Ctx.IsEquivalent(FromRecord, ToRecord); 2107203955Srdivacky} 2108203955Srdivacky 2109261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 2110261991Sdim bool Complain) { 2111261991Sdim StructuralEquivalenceContext Ctx( 2112261991Sdim Importer.getFromContext(), Importer.getToContext(), 2113341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2114341825Sdim false, Complain); 2115341825Sdim return Ctx.IsEquivalent(FromVar, ToVar); 2116261991Sdim} 2117261991Sdim 2118203955Srdivackybool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 2119353358Sdim // Eliminate a potential failure point where we attempt to re-import 2120353358Sdim // something we're trying to import while completing ToEnum. 2121353358Sdim if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum)) 2122353358Sdim if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin)) 2123353358Sdim ToEnum = ToOriginEnum; 2124353358Sdim 2125341825Sdim StructuralEquivalenceContext Ctx( 2126341825Sdim Importer.getFromContext(), Importer.getToContext(), 2127341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer)); 2128341825Sdim return Ctx.IsEquivalent(FromEnum, ToEnum); 2129203955Srdivacky} 2130203955Srdivacky 2131327952Sdimbool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From, 2132327952Sdim FunctionTemplateDecl *To) { 2133327952Sdim StructuralEquivalenceContext Ctx( 2134327952Sdim Importer.getFromContext(), Importer.getToContext(), 2135341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2136341825Sdim false, false); 2137341825Sdim return Ctx.IsEquivalent(From, To); 2138327952Sdim} 2139327952Sdim 2140341825Sdimbool ASTNodeImporter::IsStructuralMatch(FunctionDecl *From, FunctionDecl *To) { 2141341825Sdim StructuralEquivalenceContext Ctx( 2142341825Sdim Importer.getFromContext(), Importer.getToContext(), 2143341825Sdim Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer), 2144341825Sdim false, false); 2145341825Sdim return Ctx.IsEquivalent(From, To); 2146341825Sdim} 2147341825Sdim 2148249423Sdimbool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 2149341825Sdim EnumConstantDecl *ToEC) { 2150249423Sdim const llvm::APSInt &FromVal = FromEC->getInitVal(); 2151249423Sdim const llvm::APSInt &ToVal = ToEC->getInitVal(); 2152249423Sdim 2153249423Sdim return FromVal.isSigned() == ToVal.isSigned() && 2154249423Sdim FromVal.getBitWidth() == ToVal.getBitWidth() && 2155249423Sdim FromVal == ToVal; 2156249423Sdim} 2157249423Sdim 2158249423Sdimbool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 2159218893Sdim ClassTemplateDecl *To) { 2160218893Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2161218893Sdim Importer.getToContext(), 2162341825Sdim Importer.getNonEquivalentDecls(), 2163341825Sdim getStructuralEquivalenceKind(Importer)); 2164341825Sdim return Ctx.IsEquivalent(From, To); 2165218893Sdim} 2166218893Sdim 2167261991Sdimbool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 2168261991Sdim VarTemplateDecl *To) { 2169261991Sdim StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2170261991Sdim Importer.getToContext(), 2171341825Sdim Importer.getNonEquivalentDecls(), 2172341825Sdim getStructuralEquivalenceKind(Importer)); 2173341825Sdim return Ctx.IsEquivalent(From, To); 2174261991Sdim} 2175261991Sdim 2176344779SdimExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) { 2177203955Srdivacky Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 2178203955Srdivacky << D->getDeclKindName(); 2179344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 2180203955Srdivacky} 2181203955Srdivacky 2182344779SdimExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) { 2183344779Sdim Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 2184344779Sdim << D->getDeclKindName(); 2185344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 2186344779Sdim} 2187344779Sdim 2188344779SdimExpectedDecl ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) { 2189327952Sdim // Import the context of this declaration. 2190344779Sdim DeclContext *DC, *LexicalDC; 2191344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 2192344779Sdim return std::move(Err); 2193327952Sdim 2194327952Sdim // Import the location of this declaration. 2195344779Sdim ExpectedSLoc LocOrErr = import(D->getLocation()); 2196344779Sdim if (!LocOrErr) 2197344779Sdim return LocOrErr.takeError(); 2198327952Sdim 2199341825Sdim EmptyDecl *ToD; 2200344779Sdim if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, *LocOrErr)) 2201341825Sdim return ToD; 2202341825Sdim 2203327952Sdim ToD->setLexicalDeclContext(LexicalDC); 2204327952Sdim LexicalDC->addDeclInternal(ToD); 2205327952Sdim return ToD; 2206327952Sdim} 2207327952Sdim 2208344779SdimExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 2209341825Sdim TranslationUnitDecl *ToD = 2210234353Sdim Importer.getToContext().getTranslationUnitDecl(); 2211341825Sdim 2212341825Sdim Importer.MapImported(D, ToD); 2213341825Sdim 2214234353Sdim return ToD; 2215234353Sdim} 2216234353Sdim 2217344779SdimExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) { 2218344779Sdim ExpectedSLoc LocOrErr = import(D->getLocation()); 2219344779Sdim if (!LocOrErr) 2220344779Sdim return LocOrErr.takeError(); 2221344779Sdim auto ColonLocOrErr = import(D->getColonLoc()); 2222344779Sdim if (!ColonLocOrErr) 2223344779Sdim return ColonLocOrErr.takeError(); 2224309124Sdim 2225309124Sdim // Import the context of this declaration. 2226344779Sdim auto DCOrErr = Importer.ImportContext(D->getDeclContext()); 2227344779Sdim if (!DCOrErr) 2228344779Sdim return DCOrErr.takeError(); 2229344779Sdim DeclContext *DC = *DCOrErr; 2230309124Sdim 2231341825Sdim AccessSpecDecl *ToD; 2232341825Sdim if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), D->getAccess(), 2233344779Sdim DC, *LocOrErr, *ColonLocOrErr)) 2234341825Sdim return ToD; 2235309124Sdim 2236309124Sdim // Lexical DeclContext and Semantic DeclContext 2237309124Sdim // is always the same for the accessSpec. 2238341825Sdim ToD->setLexicalDeclContext(DC); 2239341825Sdim DC->addDeclInternal(ToD); 2240309124Sdim 2241341825Sdim return ToD; 2242309124Sdim} 2243309124Sdim 2244344779SdimExpectedDecl ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) { 2245344779Sdim auto DCOrErr = Importer.ImportContext(D->getDeclContext()); 2246344779Sdim if (!DCOrErr) 2247344779Sdim return DCOrErr.takeError(); 2248344779Sdim DeclContext *DC = *DCOrErr; 2249314564Sdim DeclContext *LexicalDC = DC; 2250314564Sdim 2251344779Sdim SourceLocation ToLocation, ToRParenLoc; 2252344779Sdim Expr *ToAssertExpr; 2253344779Sdim StringLiteral *ToMessage; 2254344779Sdim if (auto Imp = importSeq( 2255344779Sdim D->getLocation(), D->getAssertExpr(), D->getMessage(), D->getRParenLoc())) 2256344779Sdim std::tie(ToLocation, ToAssertExpr, ToMessage, ToRParenLoc) = *Imp; 2257344779Sdim else 2258344779Sdim return Imp.takeError(); 2259314564Sdim 2260341825Sdim StaticAssertDecl *ToD; 2261341825Sdim if (GetImportedOrCreateDecl( 2262344779Sdim ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage, 2263344779Sdim ToRParenLoc, D->isFailed())) 2264341825Sdim return ToD; 2265314564Sdim 2266314564Sdim ToD->setLexicalDeclContext(LexicalDC); 2267314564Sdim LexicalDC->addDeclInternal(ToD); 2268314564Sdim return ToD; 2269314564Sdim} 2270314564Sdim 2271344779SdimExpectedDecl ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 2272204643Srdivacky // Import the major distinguishing characteristics of this namespace. 2273204643Srdivacky DeclContext *DC, *LexicalDC; 2274204643Srdivacky DeclarationName Name; 2275204643Srdivacky SourceLocation Loc; 2276288943Sdim NamedDecl *ToD; 2277344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2278344779Sdim return std::move(Err); 2279288943Sdim if (ToD) 2280288943Sdim return ToD; 2281276479Sdim 2282276479Sdim NamespaceDecl *MergeWithNamespace = nullptr; 2283204643Srdivacky if (!Name) { 2284204643Srdivacky // This is an anonymous namespace. Adopt an existing anonymous 2285204643Srdivacky // namespace if we can. 2286204643Srdivacky // FIXME: Not testable. 2287341825Sdim if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 2288204643Srdivacky MergeWithNamespace = TU->getAnonymousNamespace(); 2289204643Srdivacky else 2290204643Srdivacky MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 2291204643Srdivacky } else { 2292226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2293344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2294341825Sdim for (auto *FoundDecl : FoundDecls) { 2295341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace)) 2296204643Srdivacky continue; 2297341825Sdim 2298341825Sdim if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) { 2299204643Srdivacky MergeWithNamespace = FoundNS; 2300204643Srdivacky ConflictingDecls.clear(); 2301204643Srdivacky break; 2302204643Srdivacky } 2303341825Sdim 2304341825Sdim ConflictingDecls.push_back(FoundDecl); 2305204643Srdivacky } 2306341825Sdim 2307204643Srdivacky if (!ConflictingDecls.empty()) { 2308360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2309360784Sdim Name, DC, Decl::IDNS_Namespace, ConflictingDecls.data(), 2310360784Sdim ConflictingDecls.size()); 2311360784Sdim if (NameOrErr) 2312360784Sdim Name = NameOrErr.get(); 2313360784Sdim else 2314360784Sdim return NameOrErr.takeError(); 2315204643Srdivacky } 2316204643Srdivacky } 2317341825Sdim 2318344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2319344779Sdim if (!BeginLocOrErr) 2320344779Sdim return BeginLocOrErr.takeError(); 2321360784Sdim ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc()); 2322360784Sdim if (!RBraceLocOrErr) 2323360784Sdim return RBraceLocOrErr.takeError(); 2324344779Sdim 2325204643Srdivacky // Create the "to" namespace, if needed. 2326204643Srdivacky NamespaceDecl *ToNamespace = MergeWithNamespace; 2327204643Srdivacky if (!ToNamespace) { 2328341825Sdim if (GetImportedOrCreateDecl( 2329341825Sdim ToNamespace, D, Importer.getToContext(), DC, D->isInline(), 2330344779Sdim *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(), 2331341825Sdim /*PrevDecl=*/nullptr)) 2332341825Sdim return ToNamespace; 2333360784Sdim ToNamespace->setRBraceLoc(*RBraceLocOrErr); 2334204643Srdivacky ToNamespace->setLexicalDeclContext(LexicalDC); 2335234353Sdim LexicalDC->addDeclInternal(ToNamespace); 2336341825Sdim 2337204643Srdivacky // If this is an anonymous namespace, register it as the anonymous 2338204643Srdivacky // namespace within its context. 2339204643Srdivacky if (!Name) { 2340341825Sdim if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 2341204643Srdivacky TU->setAnonymousNamespace(ToNamespace); 2342204643Srdivacky else 2343204643Srdivacky cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 2344204643Srdivacky } 2345204643Srdivacky } 2346341825Sdim Importer.MapImported(D, ToNamespace); 2347341825Sdim 2348344779Sdim if (Error Err = ImportDeclContext(D)) 2349344779Sdim return std::move(Err); 2350341825Sdim 2351204643Srdivacky return ToNamespace; 2352204643Srdivacky} 2353204643Srdivacky 2354344779SdimExpectedDecl ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 2355327952Sdim // Import the major distinguishing characteristics of this namespace. 2356327952Sdim DeclContext *DC, *LexicalDC; 2357327952Sdim DeclarationName Name; 2358327952Sdim SourceLocation Loc; 2359327952Sdim NamedDecl *LookupD; 2360344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc)) 2361344779Sdim return std::move(Err); 2362327952Sdim if (LookupD) 2363327952Sdim return LookupD; 2364327952Sdim 2365327952Sdim // NOTE: No conflict resolution is done for namespace aliases now. 2366327952Sdim 2367344779Sdim SourceLocation ToNamespaceLoc, ToAliasLoc, ToTargetNameLoc; 2368344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 2369344779Sdim NamespaceDecl *ToNamespace; 2370344779Sdim if (auto Imp = importSeq( 2371344779Sdim D->getNamespaceLoc(), D->getAliasLoc(), D->getQualifierLoc(), 2372344779Sdim D->getTargetNameLoc(), D->getNamespace())) 2373344779Sdim std::tie( 2374344779Sdim ToNamespaceLoc, ToAliasLoc, ToQualifierLoc, ToTargetNameLoc, 2375344779Sdim ToNamespace) = *Imp; 2376344779Sdim else 2377344779Sdim return Imp.takeError(); 2378344779Sdim IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier()); 2379327952Sdim 2380341825Sdim NamespaceAliasDecl *ToD; 2381344779Sdim if (GetImportedOrCreateDecl( 2382344779Sdim ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc, 2383344779Sdim ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace)) 2384341825Sdim return ToD; 2385327952Sdim 2386327952Sdim ToD->setLexicalDeclContext(LexicalDC); 2387327952Sdim LexicalDC->addDeclInternal(ToD); 2388327952Sdim 2389327952Sdim return ToD; 2390327952Sdim} 2391327952Sdim 2392344779SdimExpectedDecl 2393344779SdimASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 2394203955Srdivacky // Import the major distinguishing characteristics of this typedef. 2395203955Srdivacky DeclContext *DC, *LexicalDC; 2396203955Srdivacky DeclarationName Name; 2397203955Srdivacky SourceLocation Loc; 2398288943Sdim NamedDecl *ToD; 2399344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2400344779Sdim return std::move(Err); 2401288943Sdim if (ToD) 2402288943Sdim return ToD; 2403276479Sdim 2404203955Srdivacky // If this typedef is not in block scope, determine whether we've 2405203955Srdivacky // seen a typedef with the same name (that we can merge with) or any 2406203955Srdivacky // other entity by that name (which name lookup could conflict with). 2407360784Sdim // Note: Repeated typedefs are not valid in C99: 2408360784Sdim // 'typedef int T; typedef int T;' is invalid 2409360784Sdim // We do not care about this now. 2410203955Srdivacky if (!DC->isFunctionOrMethod()) { 2411226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2412203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2413344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2414341825Sdim for (auto *FoundDecl : FoundDecls) { 2415341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2416203955Srdivacky continue; 2417341825Sdim if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) { 2418360784Sdim if (!hasSameVisibilityContext(FoundTypedef, D)) 2419360784Sdim continue; 2420360784Sdim 2421344779Sdim QualType FromUT = D->getUnderlyingType(); 2422344779Sdim QualType FoundUT = FoundTypedef->getUnderlyingType(); 2423344779Sdim if (Importer.IsStructurallyEquivalent(FromUT, FoundUT)) { 2424344779Sdim // If the "From" context has a complete underlying type but we 2425344779Sdim // already have a complete underlying type then return with that. 2426344779Sdim if (!FromUT->isIncompleteType() && !FoundUT->isIncompleteType()) 2427344779Sdim return Importer.MapImported(D, FoundTypedef); 2428360784Sdim // FIXME Handle redecl chain. When you do that make consistent changes 2429360784Sdim // in ASTImporterLookupTable too. 2430360784Sdim } else { 2431360784Sdim ConflictingDecls.push_back(FoundDecl); 2432344779Sdim } 2433203955Srdivacky } 2434203955Srdivacky } 2435321369Sdim 2436203955Srdivacky if (!ConflictingDecls.empty()) { 2437360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2438360784Sdim Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size()); 2439360784Sdim if (NameOrErr) 2440360784Sdim Name = NameOrErr.get(); 2441360784Sdim else 2442360784Sdim return NameOrErr.takeError(); 2443203955Srdivacky } 2444203955Srdivacky } 2445321369Sdim 2446344779Sdim QualType ToUnderlyingType; 2447344779Sdim TypeSourceInfo *ToTypeSourceInfo; 2448344779Sdim SourceLocation ToBeginLoc; 2449344779Sdim if (auto Imp = importSeq( 2450344779Sdim D->getUnderlyingType(), D->getTypeSourceInfo(), D->getBeginLoc())) 2451344779Sdim std::tie(ToUnderlyingType, ToTypeSourceInfo, ToBeginLoc) = *Imp; 2452344779Sdim else 2453344779Sdim return Imp.takeError(); 2454276479Sdim 2455203955Srdivacky // Create the new typedef node. 2456344779Sdim // FIXME: ToUnderlyingType is not used. 2457221345Sdim TypedefNameDecl *ToTypedef; 2458341825Sdim if (IsAlias) { 2459341825Sdim if (GetImportedOrCreateDecl<TypeAliasDecl>( 2460344779Sdim ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc, 2461344779Sdim Name.getAsIdentifierInfo(), ToTypeSourceInfo)) 2462341825Sdim return ToTypedef; 2463341825Sdim } else if (GetImportedOrCreateDecl<TypedefDecl>( 2464344779Sdim ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc, 2465344779Sdim Name.getAsIdentifierInfo(), ToTypeSourceInfo)) 2466341825Sdim return ToTypedef; 2467321369Sdim 2468204643Srdivacky ToTypedef->setAccess(D->getAccess()); 2469203955Srdivacky ToTypedef->setLexicalDeclContext(LexicalDC); 2470321369Sdim 2471341825Sdim // Templated declarations should not appear in DeclContext. 2472341825Sdim TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr; 2473341825Sdim if (!FromAlias || !FromAlias->getDescribedAliasTemplate()) 2474341825Sdim LexicalDC->addDeclInternal(ToTypedef); 2475341825Sdim 2476203955Srdivacky return ToTypedef; 2477203955Srdivacky} 2478203955Srdivacky 2479344779SdimExpectedDecl ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 2480221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/false); 2481221345Sdim} 2482221345Sdim 2483344779SdimExpectedDecl ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 2484221345Sdim return VisitTypedefNameDecl(D, /*IsAlias=*/true); 2485221345Sdim} 2486221345Sdim 2487344779SdimExpectedDecl 2488344779SdimASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 2489327952Sdim // Import the major distinguishing characteristics of this typedef. 2490327952Sdim DeclContext *DC, *LexicalDC; 2491327952Sdim DeclarationName Name; 2492327952Sdim SourceLocation Loc; 2493341825Sdim NamedDecl *FoundD; 2494344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc)) 2495344779Sdim return std::move(Err); 2496341825Sdim if (FoundD) 2497341825Sdim return FoundD; 2498327952Sdim 2499327952Sdim // If this typedef is not in block scope, determine whether we've 2500327952Sdim // seen a typedef with the same name (that we can merge with) or any 2501327952Sdim // other entity by that name (which name lookup could conflict with). 2502327952Sdim if (!DC->isFunctionOrMethod()) { 2503327952Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2504327952Sdim unsigned IDNS = Decl::IDNS_Ordinary; 2505344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2506341825Sdim for (auto *FoundDecl : FoundDecls) { 2507341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2508327952Sdim continue; 2509341825Sdim if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) 2510341825Sdim return Importer.MapImported(D, FoundAlias); 2511341825Sdim ConflictingDecls.push_back(FoundDecl); 2512327952Sdim } 2513327952Sdim 2514327952Sdim if (!ConflictingDecls.empty()) { 2515360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2516360784Sdim Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size()); 2517360784Sdim if (NameOrErr) 2518360784Sdim Name = NameOrErr.get(); 2519360784Sdim else 2520360784Sdim return NameOrErr.takeError(); 2521327952Sdim } 2522327952Sdim } 2523327952Sdim 2524344779Sdim TemplateParameterList *ToTemplateParameters; 2525344779Sdim TypeAliasDecl *ToTemplatedDecl; 2526344779Sdim if (auto Imp = importSeq(D->getTemplateParameters(), D->getTemplatedDecl())) 2527344779Sdim std::tie(ToTemplateParameters, ToTemplatedDecl) = *Imp; 2528344779Sdim else 2529344779Sdim return Imp.takeError(); 2530327952Sdim 2531341825Sdim TypeAliasTemplateDecl *ToAlias; 2532341825Sdim if (GetImportedOrCreateDecl(ToAlias, D, Importer.getToContext(), DC, Loc, 2533344779Sdim Name, ToTemplateParameters, ToTemplatedDecl)) 2534341825Sdim return ToAlias; 2535327952Sdim 2536344779Sdim ToTemplatedDecl->setDescribedAliasTemplate(ToAlias); 2537341825Sdim 2538327952Sdim ToAlias->setAccess(D->getAccess()); 2539327952Sdim ToAlias->setLexicalDeclContext(LexicalDC); 2540327952Sdim LexicalDC->addDeclInternal(ToAlias); 2541341825Sdim return ToAlias; 2542327952Sdim} 2543327952Sdim 2544344779SdimExpectedDecl ASTNodeImporter::VisitLabelDecl(LabelDecl *D) { 2545309124Sdim // Import the major distinguishing characteristics of this label. 2546309124Sdim DeclContext *DC, *LexicalDC; 2547309124Sdim DeclarationName Name; 2548309124Sdim SourceLocation Loc; 2549309124Sdim NamedDecl *ToD; 2550344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2551344779Sdim return std::move(Err); 2552309124Sdim if (ToD) 2553309124Sdim return ToD; 2554309124Sdim 2555309124Sdim assert(LexicalDC->isFunctionOrMethod()); 2556309124Sdim 2557341825Sdim LabelDecl *ToLabel; 2558344779Sdim if (D->isGnuLocal()) { 2559344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2560344779Sdim if (!BeginLocOrErr) 2561344779Sdim return BeginLocOrErr.takeError(); 2562344779Sdim if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc, 2563344779Sdim Name.getAsIdentifierInfo(), *BeginLocOrErr)) 2564344779Sdim return ToLabel; 2565309124Sdim 2566344779Sdim } else { 2567344779Sdim if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc, 2568344779Sdim Name.getAsIdentifierInfo())) 2569344779Sdim return ToLabel; 2570309124Sdim 2571344779Sdim } 2572344779Sdim 2573344779Sdim Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt()); 2574344779Sdim if (!ToStmtOrErr) 2575344779Sdim return ToStmtOrErr.takeError(); 2576344779Sdim 2577344779Sdim ToLabel->setStmt(*ToStmtOrErr); 2578309124Sdim ToLabel->setLexicalDeclContext(LexicalDC); 2579309124Sdim LexicalDC->addDeclInternal(ToLabel); 2580309124Sdim return ToLabel; 2581309124Sdim} 2582309124Sdim 2583344779SdimExpectedDecl ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 2584203955Srdivacky // Import the major distinguishing characteristics of this enum. 2585203955Srdivacky DeclContext *DC, *LexicalDC; 2586203955Srdivacky DeclarationName Name; 2587203955Srdivacky SourceLocation Loc; 2588288943Sdim NamedDecl *ToD; 2589344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2590344779Sdim return std::move(Err); 2591288943Sdim if (ToD) 2592288943Sdim return ToD; 2593276479Sdim 2594203955Srdivacky // Figure out what enum name we're looking for. 2595203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 2596203955Srdivacky DeclarationName SearchName = Name; 2597221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 2598344779Sdim if (Error Err = importInto( 2599344779Sdim SearchName, D->getTypedefNameForAnonDecl()->getDeclName())) 2600344779Sdim return std::move(Err); 2601203955Srdivacky IDNS = Decl::IDNS_Ordinary; 2602234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2603203955Srdivacky IDNS |= Decl::IDNS_Ordinary; 2604341825Sdim 2605203955Srdivacky // We may already have an enum of the same name; try to find and match it. 2606203955Srdivacky if (!DC->isFunctionOrMethod() && SearchName) { 2607226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2608344779Sdim auto FoundDecls = 2609344779Sdim Importer.findDeclsInToCtx(DC, SearchName); 2610341825Sdim for (auto *FoundDecl : FoundDecls) { 2611341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2612203955Srdivacky continue; 2613341825Sdim 2614344779Sdim if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) { 2615341825Sdim if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2616344779Sdim FoundDecl = Tag->getDecl(); 2617203955Srdivacky } 2618341825Sdim 2619344779Sdim if (auto *FoundEnum = dyn_cast<EnumDecl>(FoundDecl)) { 2620353358Sdim if (!hasSameVisibilityContext(FoundEnum, D)) 2621353358Sdim continue; 2622203955Srdivacky if (IsStructuralMatch(D, FoundEnum)) 2623341825Sdim return Importer.MapImported(D, FoundEnum); 2624360784Sdim ConflictingDecls.push_back(FoundDecl); 2625203955Srdivacky } 2626203955Srdivacky } 2627341825Sdim 2628203955Srdivacky if (!ConflictingDecls.empty()) { 2629360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2630360784Sdim SearchName, DC, IDNS, ConflictingDecls.data(), 2631360784Sdim ConflictingDecls.size()); 2632360784Sdim if (NameOrErr) 2633360784Sdim Name = NameOrErr.get(); 2634360784Sdim else 2635360784Sdim return NameOrErr.takeError(); 2636203955Srdivacky } 2637203955Srdivacky } 2638341825Sdim 2639344779Sdim SourceLocation ToBeginLoc; 2640344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 2641344779Sdim QualType ToIntegerType; 2642360784Sdim SourceRange ToBraceRange; 2643360784Sdim if (auto Imp = importSeq(D->getBeginLoc(), D->getQualifierLoc(), 2644360784Sdim D->getIntegerType(), D->getBraceRange())) 2645360784Sdim std::tie(ToBeginLoc, ToQualifierLoc, ToIntegerType, ToBraceRange) = *Imp; 2646344779Sdim else 2647344779Sdim return Imp.takeError(); 2648344779Sdim 2649203955Srdivacky // Create the enum declaration. 2650341825Sdim EnumDecl *D2; 2651341825Sdim if (GetImportedOrCreateDecl( 2652344779Sdim D2, D, Importer.getToContext(), DC, ToBeginLoc, 2653341825Sdim Loc, Name.getAsIdentifierInfo(), nullptr, D->isScoped(), 2654341825Sdim D->isScopedUsingClassTag(), D->isFixed())) 2655341825Sdim return D2; 2656341825Sdim 2657344779Sdim D2->setQualifierInfo(ToQualifierLoc); 2658344779Sdim D2->setIntegerType(ToIntegerType); 2659360784Sdim D2->setBraceRange(ToBraceRange); 2660204643Srdivacky D2->setAccess(D->getAccess()); 2661203955Srdivacky D2->setLexicalDeclContext(LexicalDC); 2662234353Sdim LexicalDC->addDeclInternal(D2); 2663203955Srdivacky 2664203955Srdivacky // Import the definition 2665344779Sdim if (D->isCompleteDefinition()) 2666344779Sdim if (Error Err = ImportDefinition(D, D2)) 2667344779Sdim return std::move(Err); 2668203955Srdivacky 2669203955Srdivacky return D2; 2670203955Srdivacky} 2671203955Srdivacky 2672344779SdimExpectedDecl ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 2673344779Sdim bool IsFriendTemplate = false; 2674344779Sdim if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2675344779Sdim IsFriendTemplate = 2676344779Sdim DCXX->getDescribedClassTemplate() && 2677344779Sdim DCXX->getDescribedClassTemplate()->getFriendObjectKind() != 2678344779Sdim Decl::FOK_None; 2679344779Sdim } 2680344779Sdim 2681203955Srdivacky // Import the major distinguishing characteristics of this record. 2682360784Sdim DeclContext *DC = nullptr, *LexicalDC = nullptr; 2683203955Srdivacky DeclarationName Name; 2684203955Srdivacky SourceLocation Loc; 2685360784Sdim NamedDecl *ToD = nullptr; 2686344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2687344779Sdim return std::move(Err); 2688288943Sdim if (ToD) 2689288943Sdim return ToD; 2690276479Sdim 2691203955Srdivacky // Figure out what structure name we're looking for. 2692203955Srdivacky unsigned IDNS = Decl::IDNS_Tag; 2693203955Srdivacky DeclarationName SearchName = Name; 2694221345Sdim if (!SearchName && D->getTypedefNameForAnonDecl()) { 2695344779Sdim if (Error Err = importInto( 2696344779Sdim SearchName, D->getTypedefNameForAnonDecl()->getDeclName())) 2697344779Sdim return std::move(Err); 2698203955Srdivacky IDNS = Decl::IDNS_Ordinary; 2699234353Sdim } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2700344779Sdim IDNS |= Decl::IDNS_Ordinary | Decl::IDNS_TagFriend; 2701203955Srdivacky 2702203955Srdivacky // We may already have a record of the same name; try to find and match it. 2703321369Sdim RecordDecl *PrevDecl = nullptr; 2704360784Sdim if (!DC->isFunctionOrMethod() && !D->isLambda()) { 2705226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2706344779Sdim auto FoundDecls = 2707344779Sdim Importer.findDeclsInToCtx(DC, SearchName); 2708321369Sdim if (!FoundDecls.empty()) { 2709353358Sdim // We're going to have to compare D against potentially conflicting Decls, 2710353358Sdim // so complete it. 2711321369Sdim if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition()) 2712321369Sdim D->getASTContext().getExternalSource()->CompleteType(D); 2713321369Sdim } 2714321369Sdim 2715341825Sdim for (auto *FoundDecl : FoundDecls) { 2716341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2717203955Srdivacky continue; 2718341825Sdim 2719341825Sdim Decl *Found = FoundDecl; 2720341825Sdim if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 2721341825Sdim if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2722203955Srdivacky Found = Tag->getDecl(); 2723203955Srdivacky } 2724341825Sdim 2725341825Sdim if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) { 2726344779Sdim // Do not emit false positive diagnostic in case of unnamed 2727344779Sdim // struct/union and in case of anonymous structs. Would be false 2728344779Sdim // because there may be several anonymous/unnamed structs in a class. 2729344779Sdim // E.g. these are both valid: 2730344779Sdim // struct A { // unnamed structs 2731344779Sdim // struct { struct A *next; } entry0; 2732344779Sdim // struct { struct A *next; } entry1; 2733344779Sdim // }; 2734344779Sdim // struct X { struct { int a; }; struct { int b; }; }; // anon structs 2735344779Sdim if (!SearchName) 2736341825Sdim if (!IsStructuralMatch(D, FoundRecord, false)) 2737341825Sdim continue; 2738243830Sdim 2739353358Sdim if (!hasSameVisibilityContext(FoundRecord, D)) 2740353358Sdim continue; 2741353358Sdim 2742344779Sdim if (IsStructuralMatch(D, FoundRecord)) { 2743344779Sdim RecordDecl *FoundDef = FoundRecord->getDefinition(); 2744344779Sdim if (D->isThisDeclarationADefinition() && FoundDef) { 2745341825Sdim // FIXME: Structural equivalence check should check for same 2746341825Sdim // user-defined methods. 2747341825Sdim Importer.MapImported(D, FoundDef); 2748341825Sdim if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2749341825Sdim auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef); 2750341825Sdim assert(FoundCXX && "Record type mismatch"); 2751341825Sdim 2752344779Sdim if (!Importer.isMinimalImport()) 2753341825Sdim // FoundDef may not have every implicit method that D has 2754341825Sdim // because implicit methods are created only if they are used. 2755344779Sdim if (Error Err = ImportImplicitMethods(DCXX, FoundCXX)) 2756344779Sdim return std::move(Err); 2757341825Sdim } 2758203955Srdivacky } 2759344779Sdim PrevDecl = FoundRecord->getMostRecentDecl(); 2760344779Sdim break; 2761239462Sdim } 2762360784Sdim ConflictingDecls.push_back(FoundDecl); 2763360784Sdim } // kind is RecordDecl 2764344779Sdim } // for 2765341825Sdim 2766239462Sdim if (!ConflictingDecls.empty() && SearchName) { 2767360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2768360784Sdim SearchName, DC, IDNS, ConflictingDecls.data(), 2769360784Sdim ConflictingDecls.size()); 2770360784Sdim if (NameOrErr) 2771360784Sdim Name = NameOrErr.get(); 2772360784Sdim else 2773360784Sdim return NameOrErr.takeError(); 2774203955Srdivacky } 2775203955Srdivacky } 2776341825Sdim 2777344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 2778344779Sdim if (!BeginLocOrErr) 2779344779Sdim return BeginLocOrErr.takeError(); 2780344779Sdim 2781203955Srdivacky // Create the record declaration. 2782344779Sdim RecordDecl *D2 = nullptr; 2783344779Sdim CXXRecordDecl *D2CXX = nullptr; 2784344779Sdim if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2785344779Sdim if (DCXX->isLambda()) { 2786344779Sdim auto TInfoOrErr = import(DCXX->getLambdaTypeInfo()); 2787344779Sdim if (!TInfoOrErr) 2788344779Sdim return TInfoOrErr.takeError(); 2789344779Sdim if (GetImportedOrCreateSpecialDecl( 2790344779Sdim D2CXX, CXXRecordDecl::CreateLambda, D, Importer.getToContext(), 2791344779Sdim DC, *TInfoOrErr, Loc, DCXX->isDependentLambda(), 2792344779Sdim DCXX->isGenericLambda(), DCXX->getLambdaCaptureDefault())) 2793344779Sdim return D2CXX; 2794344779Sdim ExpectedDecl CDeclOrErr = import(DCXX->getLambdaContextDecl()); 2795344779Sdim if (!CDeclOrErr) 2796344779Sdim return CDeclOrErr.takeError(); 2797360784Sdim D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), *CDeclOrErr, 2798360784Sdim DCXX->hasKnownLambdaInternalLinkage()); 2799344779Sdim } else if (DCXX->isInjectedClassName()) { 2800344779Sdim // We have to be careful to do a similar dance to the one in 2801344779Sdim // Sema::ActOnStartCXXMemberDeclarations 2802344779Sdim const bool DelayTypeCreation = true; 2803344779Sdim if (GetImportedOrCreateDecl( 2804344779Sdim D2CXX, D, Importer.getToContext(), D->getTagKind(), DC, 2805344779Sdim *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(), 2806344779Sdim cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation)) 2807344779Sdim return D2CXX; 2808344779Sdim Importer.getToContext().getTypeDeclType( 2809344779Sdim D2CXX, dyn_cast<CXXRecordDecl>(DC)); 2810344779Sdim } else { 2811344779Sdim if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(), 2812344779Sdim D->getTagKind(), DC, *BeginLocOrErr, Loc, 2813344779Sdim Name.getAsIdentifierInfo(), 2814344779Sdim cast_or_null<CXXRecordDecl>(PrevDecl))) 2815344779Sdim return D2CXX; 2816344779Sdim } 2817341825Sdim 2818344779Sdim D2 = D2CXX; 2819344779Sdim D2->setAccess(D->getAccess()); 2820344779Sdim D2->setLexicalDeclContext(LexicalDC); 2821360784Sdim addDeclToContexts(D, D2); 2822327952Sdim 2823344779Sdim if (ClassTemplateDecl *FromDescribed = 2824344779Sdim DCXX->getDescribedClassTemplate()) { 2825344779Sdim ClassTemplateDecl *ToDescribed; 2826344779Sdim if (Error Err = importInto(ToDescribed, FromDescribed)) 2827344779Sdim return std::move(Err); 2828344779Sdim D2CXX->setDescribedClassTemplate(ToDescribed); 2829344779Sdim if (!DCXX->isInjectedClassName() && !IsFriendTemplate) { 2830344779Sdim // In a record describing a template the type should be an 2831344779Sdim // InjectedClassNameType (see Sema::CheckClassTemplate). Update the 2832344779Sdim // previously set type to the correct value here (ToDescribed is not 2833344779Sdim // available at record create). 2834344779Sdim // FIXME: The previous type is cleared but not removed from 2835344779Sdim // ASTContext's internal storage. 2836344779Sdim CXXRecordDecl *Injected = nullptr; 2837344779Sdim for (NamedDecl *Found : D2CXX->noload_lookup(Name)) { 2838344779Sdim auto *Record = dyn_cast<CXXRecordDecl>(Found); 2839344779Sdim if (Record && Record->isInjectedClassName()) { 2840344779Sdim Injected = Record; 2841344779Sdim break; 2842341825Sdim } 2843341825Sdim } 2844344779Sdim // Create an injected type for the whole redecl chain. 2845344779Sdim SmallVector<Decl *, 2> Redecls = 2846344779Sdim getCanonicalForwardRedeclChain(D2CXX); 2847344779Sdim for (auto *R : Redecls) { 2848344779Sdim auto *RI = cast<CXXRecordDecl>(R); 2849344779Sdim RI->setTypeForDecl(nullptr); 2850344779Sdim // Below we create a new injected type and assign that to the 2851344779Sdim // canonical decl, subsequent declarations in the chain will reuse 2852344779Sdim // that type. 2853344779Sdim Importer.getToContext().getInjectedClassNameType( 2854344779Sdim RI, ToDescribed->getInjectedClassNameSpecialization()); 2855344779Sdim } 2856344779Sdim // Set the new type for the previous injected decl too. 2857344779Sdim if (Injected) { 2858344779Sdim Injected->setTypeForDecl(nullptr); 2859344779Sdim Importer.getToContext().getTypeDeclType(Injected, D2CXX); 2860344779Sdim } 2861344779Sdim } 2862344779Sdim } else if (MemberSpecializationInfo *MemberInfo = 2863327952Sdim DCXX->getMemberSpecializationInfo()) { 2864327952Sdim TemplateSpecializationKind SK = 2865327952Sdim MemberInfo->getTemplateSpecializationKind(); 2866327952Sdim CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass(); 2867344779Sdim 2868344779Sdim if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst)) 2869344779Sdim D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK); 2870344779Sdim else 2871344779Sdim return ToInstOrErr.takeError(); 2872344779Sdim 2873344779Sdim if (ExpectedSLoc POIOrErr = 2874344779Sdim import(MemberInfo->getPointOfInstantiation())) 2875344779Sdim D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation( 2876344779Sdim *POIOrErr); 2877344779Sdim else 2878344779Sdim return POIOrErr.takeError(); 2879203955Srdivacky } 2880341825Sdim 2881344779Sdim } else { 2882344779Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), 2883344779Sdim D->getTagKind(), DC, *BeginLocOrErr, Loc, 2884344779Sdim Name.getAsIdentifierInfo(), PrevDecl)) 2885344779Sdim return D2; 2886344779Sdim D2->setLexicalDeclContext(LexicalDC); 2887360784Sdim addDeclToContexts(D, D2); 2888203955Srdivacky } 2889203955Srdivacky 2890360784Sdim if (auto BraceRangeOrErr = import(D->getBraceRange())) 2891360784Sdim D2->setBraceRange(*BraceRangeOrErr); 2892360784Sdim else 2893360784Sdim return BraceRangeOrErr.takeError(); 2894344779Sdim if (auto QualifierLocOrErr = import(D->getQualifierLoc())) 2895344779Sdim D2->setQualifierInfo(*QualifierLocOrErr); 2896344779Sdim else 2897344779Sdim return QualifierLocOrErr.takeError(); 2898341825Sdim 2899344779Sdim if (D->isAnonymousStructOrUnion()) 2900344779Sdim D2->setAnonymousStructOrUnion(true); 2901276479Sdim 2902344779Sdim if (D->isCompleteDefinition()) 2903344779Sdim if (Error Err = ImportDefinition(D, D2, IDK_Default)) 2904344779Sdim return std::move(Err); 2905344779Sdim 2906203955Srdivacky return D2; 2907203955Srdivacky} 2908203955Srdivacky 2909344779SdimExpectedDecl ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 2910203955Srdivacky // Import the major distinguishing characteristics of this enumerator. 2911203955Srdivacky DeclContext *DC, *LexicalDC; 2912203955Srdivacky DeclarationName Name; 2913203955Srdivacky SourceLocation Loc; 2914288943Sdim NamedDecl *ToD; 2915344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2916344779Sdim return std::move(Err); 2917288943Sdim if (ToD) 2918288943Sdim return ToD; 2919203955Srdivacky 2920341825Sdim // Determine whether there are any other declarations with the same name and 2921203955Srdivacky // in the same context. 2922203955Srdivacky if (!LexicalDC->isFunctionOrMethod()) { 2923226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 2924203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 2925344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 2926341825Sdim for (auto *FoundDecl : FoundDecls) { 2927341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2928203955Srdivacky continue; 2929249423Sdim 2930341825Sdim if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) { 2931249423Sdim if (IsStructuralMatch(D, FoundEnumConstant)) 2932341825Sdim return Importer.MapImported(D, FoundEnumConstant); 2933360784Sdim ConflictingDecls.push_back(FoundDecl); 2934249423Sdim } 2935203955Srdivacky } 2936341825Sdim 2937203955Srdivacky if (!ConflictingDecls.empty()) { 2938360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 2939360784Sdim Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size()); 2940360784Sdim if (NameOrErr) 2941360784Sdim Name = NameOrErr.get(); 2942360784Sdim else 2943360784Sdim return NameOrErr.takeError(); 2944203955Srdivacky } 2945203955Srdivacky } 2946341825Sdim 2947344779Sdim ExpectedType TypeOrErr = import(D->getType()); 2948344779Sdim if (!TypeOrErr) 2949344779Sdim return TypeOrErr.takeError(); 2950276479Sdim 2951344779Sdim ExpectedExpr InitOrErr = import(D->getInitExpr()); 2952344779Sdim if (!InitOrErr) 2953344779Sdim return InitOrErr.takeError(); 2954344779Sdim 2955341825Sdim EnumConstantDecl *ToEnumerator; 2956341825Sdim if (GetImportedOrCreateDecl( 2957341825Sdim ToEnumerator, D, Importer.getToContext(), cast<EnumDecl>(DC), Loc, 2958344779Sdim Name.getAsIdentifierInfo(), *TypeOrErr, *InitOrErr, D->getInitVal())) 2959341825Sdim return ToEnumerator; 2960341825Sdim 2961204643Srdivacky ToEnumerator->setAccess(D->getAccess()); 2962203955Srdivacky ToEnumerator->setLexicalDeclContext(LexicalDC); 2963234353Sdim LexicalDC->addDeclInternal(ToEnumerator); 2964203955Srdivacky return ToEnumerator; 2965203955Srdivacky} 2966203955Srdivacky 2967353358SdimError ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD, 2968353358Sdim DeclaratorDecl *ToD) { 2969353358Sdim unsigned int Num = FromD->getNumTemplateParameterLists(); 2970353358Sdim if (Num == 0) 2971353358Sdim return Error::success(); 2972353358Sdim SmallVector<TemplateParameterList *, 2> ToTPLists(Num); 2973353358Sdim for (unsigned int I = 0; I < Num; ++I) 2974353358Sdim if (Expected<TemplateParameterList *> ToTPListOrErr = 2975353358Sdim import(FromD->getTemplateParameterList(I))) 2976353358Sdim ToTPLists[I] = *ToTPListOrErr; 2977353358Sdim else 2978353358Sdim return ToTPListOrErr.takeError(); 2979353358Sdim ToD->setTemplateParameterListsInfo(Importer.ToContext, ToTPLists); 2980353358Sdim return Error::success(); 2981353358Sdim} 2982353358Sdim 2983344779SdimError ASTNodeImporter::ImportTemplateInformation( 2984344779Sdim FunctionDecl *FromFD, FunctionDecl *ToFD) { 2985341825Sdim switch (FromFD->getTemplatedKind()) { 2986341825Sdim case FunctionDecl::TK_NonTemplate: 2987341825Sdim case FunctionDecl::TK_FunctionTemplate: 2988344779Sdim return Error::success(); 2989341825Sdim 2990341825Sdim case FunctionDecl::TK_MemberSpecialization: { 2991344779Sdim TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind(); 2992341825Sdim 2993344779Sdim if (Expected<FunctionDecl *> InstFDOrErr = 2994344779Sdim import(FromFD->getInstantiatedFromMemberFunction())) 2995344779Sdim ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK); 2996344779Sdim else 2997344779Sdim return InstFDOrErr.takeError(); 2998344779Sdim 2999344779Sdim if (ExpectedSLoc POIOrErr = import( 3000344779Sdim FromFD->getMemberSpecializationInfo()->getPointOfInstantiation())) 3001344779Sdim ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr); 3002344779Sdim else 3003344779Sdim return POIOrErr.takeError(); 3004344779Sdim 3005344779Sdim return Error::success(); 3006341825Sdim } 3007341825Sdim 3008341825Sdim case FunctionDecl::TK_FunctionTemplateSpecialization: { 3009344779Sdim auto FunctionAndArgsOrErr = 3010341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD); 3011344779Sdim if (!FunctionAndArgsOrErr) 3012344779Sdim return FunctionAndArgsOrErr.takeError(); 3013341825Sdim 3014341825Sdim TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy( 3015344779Sdim Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr)); 3016341825Sdim 3017341825Sdim auto *FTSInfo = FromFD->getTemplateSpecializationInfo(); 3018341825Sdim TemplateArgumentListInfo ToTAInfo; 3019341825Sdim const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten; 3020341825Sdim if (FromTAArgsAsWritten) 3021344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 3022344779Sdim *FromTAArgsAsWritten, ToTAInfo)) 3023344779Sdim return Err; 3024341825Sdim 3025344779Sdim ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation()); 3026344779Sdim if (!POIOrErr) 3027344779Sdim return POIOrErr.takeError(); 3028341825Sdim 3029353358Sdim if (Error Err = ImportTemplateParameterLists(FromFD, ToFD)) 3030353358Sdim return Err; 3031353358Sdim 3032341825Sdim TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind(); 3033341825Sdim ToFD->setFunctionTemplateSpecialization( 3034344779Sdim std::get<0>(*FunctionAndArgsOrErr), ToTAList, /* InsertPos= */ nullptr, 3035344779Sdim TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, *POIOrErr); 3036344779Sdim return Error::success(); 3037341825Sdim } 3038341825Sdim 3039341825Sdim case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 3040341825Sdim auto *FromInfo = FromFD->getDependentSpecializationInfo(); 3041341825Sdim UnresolvedSet<8> TemplDecls; 3042341825Sdim unsigned NumTemplates = FromInfo->getNumTemplates(); 3043341825Sdim for (unsigned I = 0; I < NumTemplates; I++) { 3044344779Sdim if (Expected<FunctionTemplateDecl *> ToFTDOrErr = 3045344779Sdim import(FromInfo->getTemplate(I))) 3046344779Sdim TemplDecls.addDecl(*ToFTDOrErr); 3047341825Sdim else 3048344779Sdim return ToFTDOrErr.takeError(); 3049341825Sdim } 3050341825Sdim 3051341825Sdim // Import TemplateArgumentListInfo. 3052341825Sdim TemplateArgumentListInfo ToTAInfo; 3053344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 3054344779Sdim FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(), 3055344779Sdim llvm::makeArrayRef( 3056344779Sdim FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()), 3057344779Sdim ToTAInfo)) 3058344779Sdim return Err; 3059341825Sdim 3060341825Sdim ToFD->setDependentTemplateSpecialization(Importer.getToContext(), 3061341825Sdim TemplDecls, ToTAInfo); 3062344779Sdim return Error::success(); 3063341825Sdim } 3064341825Sdim } 3065341825Sdim llvm_unreachable("All cases should be covered!"); 3066341825Sdim} 3067341825Sdim 3068344779SdimExpected<FunctionDecl *> 3069341825SdimASTNodeImporter::FindFunctionTemplateSpecialization(FunctionDecl *FromFD) { 3070344779Sdim auto FunctionAndArgsOrErr = 3071341825Sdim ImportFunctionTemplateWithTemplateArgsFromSpecialization(FromFD); 3072344779Sdim if (!FunctionAndArgsOrErr) 3073344779Sdim return FunctionAndArgsOrErr.takeError(); 3074341825Sdim 3075344779Sdim FunctionTemplateDecl *Template; 3076344779Sdim TemplateArgsTy ToTemplArgs; 3077344779Sdim std::tie(Template, ToTemplArgs) = *FunctionAndArgsOrErr; 3078341825Sdim void *InsertPos = nullptr; 3079344779Sdim auto *FoundSpec = Template->findSpecialization(ToTemplArgs, InsertPos); 3080341825Sdim return FoundSpec; 3081341825Sdim} 3082341825Sdim 3083353358SdimError ASTNodeImporter::ImportFunctionDeclBody(FunctionDecl *FromFD, 3084353358Sdim FunctionDecl *ToFD) { 3085353358Sdim if (Stmt *FromBody = FromFD->getBody()) { 3086353358Sdim if (ExpectedStmt ToBodyOrErr = import(FromBody)) 3087353358Sdim ToFD->setBody(*ToBodyOrErr); 3088353358Sdim else 3089353358Sdim return ToBodyOrErr.takeError(); 3090353358Sdim } 3091353358Sdim return Error::success(); 3092353358Sdim} 3093353358Sdim 3094360784Sdim// Returns true if the given D has a DeclContext up to the TranslationUnitDecl 3095360784Sdim// which is equal to the given DC. 3096360784Sdimstatic bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) { 3097360784Sdim const DeclContext *DCi = D->getDeclContext(); 3098360784Sdim while (DCi != D->getTranslationUnitDecl()) { 3099360784Sdim if (DCi == DC) 3100360784Sdim return true; 3101360784Sdim DCi = DCi->getParent(); 3102360784Sdim } 3103360784Sdim return false; 3104353358Sdim} 3105353358Sdim 3106360784Sdimbool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) { 3107360784Sdim QualType FromTy = D->getType(); 3108360784Sdim const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>(); 3109360784Sdim assert(FromFPT && "Must be called on FunctionProtoType"); 3110360784Sdim if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) { 3111360784Sdim QualType DeducedT = AutoT->getDeducedType(); 3112360784Sdim if (const RecordType *RecordT = 3113360784Sdim DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) { 3114360784Sdim RecordDecl *RD = RecordT->getDecl(); 3115360784Sdim assert(RD); 3116360784Sdim if (isAncestorDeclContextOf(D, RD)) { 3117360784Sdim assert(RD->getLexicalDeclContext() == RD->getDeclContext()); 3118360784Sdim return true; 3119360784Sdim } 3120360784Sdim } 3121360784Sdim } 3122360784Sdim if (const TypedefType *TypedefT = 3123360784Sdim dyn_cast<TypedefType>(FromFPT->getReturnType())) { 3124360784Sdim TypedefNameDecl *TD = TypedefT->getDecl(); 3125360784Sdim assert(TD); 3126360784Sdim if (isAncestorDeclContextOf(D, TD)) { 3127360784Sdim assert(TD->getLexicalDeclContext() == TD->getDeclContext()); 3128360784Sdim return true; 3129360784Sdim } 3130360784Sdim } 3131360784Sdim return false; 3132360784Sdim} 3133360784Sdim 3134344779SdimExpectedDecl ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 3135341825Sdim 3136344779Sdim SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D); 3137341825Sdim auto RedeclIt = Redecls.begin(); 3138341825Sdim // Import the first part of the decl chain. I.e. import all previous 3139341825Sdim // declarations starting from the canonical decl. 3140344779Sdim for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) { 3141344779Sdim ExpectedDecl ToRedeclOrErr = import(*RedeclIt); 3142344779Sdim if (!ToRedeclOrErr) 3143344779Sdim return ToRedeclOrErr.takeError(); 3144344779Sdim } 3145341825Sdim assert(*RedeclIt == D); 3146341825Sdim 3147203955Srdivacky // Import the major distinguishing characteristics of this function. 3148203955Srdivacky DeclContext *DC, *LexicalDC; 3149203955Srdivacky DeclarationName Name; 3150203955Srdivacky SourceLocation Loc; 3151288943Sdim NamedDecl *ToD; 3152344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3153344779Sdim return std::move(Err); 3154288943Sdim if (ToD) 3155288943Sdim return ToD; 3156212904Sdim 3157353358Sdim FunctionDecl *FoundByLookup = nullptr; 3158341825Sdim FunctionTemplateDecl *FromFT = D->getDescribedFunctionTemplate(); 3159327952Sdim 3160341825Sdim // If this is a function template specialization, then try to find the same 3161344779Sdim // existing specialization in the "to" context. The lookup below will not 3162344779Sdim // find any specialization, but would find the primary template; thus, we 3163344779Sdim // have to skip normal lookup in case of specializations. 3164341825Sdim // FIXME handle member function templates (TK_MemberSpecialization) similarly? 3165341825Sdim if (D->getTemplatedKind() == 3166341825Sdim FunctionDecl::TK_FunctionTemplateSpecialization) { 3167344779Sdim auto FoundFunctionOrErr = FindFunctionTemplateSpecialization(D); 3168344779Sdim if (!FoundFunctionOrErr) 3169344779Sdim return FoundFunctionOrErr.takeError(); 3170344779Sdim if (FunctionDecl *FoundFunction = *FoundFunctionOrErr) { 3171353358Sdim if (Decl *Def = FindAndMapDefinition(D, FoundFunction)) 3172353358Sdim return Def; 3173341825Sdim FoundByLookup = FoundFunction; 3174341825Sdim } 3175341825Sdim } 3176203955Srdivacky // Try to find a function in our own ("to") context with the same name, same 3177203955Srdivacky // type, and in the same context as the function we're importing. 3178341825Sdim else if (!LexicalDC->isFunctionOrMethod()) { 3179226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3180341825Sdim unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend; 3181344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3182341825Sdim for (auto *FoundDecl : FoundDecls) { 3183341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 3184203955Srdivacky continue; 3185321369Sdim 3186341825Sdim if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) { 3187353358Sdim if (!hasSameVisibilityContext(FoundFunction, D)) 3188353358Sdim continue; 3189321369Sdim 3190353358Sdim if (IsStructuralMatch(D, FoundFunction)) { 3191353358Sdim if (Decl *Def = FindAndMapDefinition(D, FoundFunction)) 3192353358Sdim return Def; 3193353358Sdim FoundByLookup = FoundFunction; 3194353358Sdim break; 3195353358Sdim } 3196353358Sdim // FIXME: Check for overloading more carefully, e.g., by boosting 3197353358Sdim // Sema::IsOverload out to the AST library. 3198321369Sdim 3199353358Sdim // Function overloading is okay in C++. 3200353358Sdim if (Importer.getToContext().getLangOpts().CPlusPlus) 3201353358Sdim continue; 3202321369Sdim 3203353358Sdim // Complain about inconsistent function types. 3204353358Sdim Importer.ToDiag(Loc, diag::warn_odr_function_type_inconsistent) 3205203955Srdivacky << Name << D->getType() << FoundFunction->getType(); 3206353358Sdim Importer.ToDiag(FoundFunction->getLocation(), diag::note_odr_value_here) 3207203955Srdivacky << FoundFunction->getType(); 3208360784Sdim ConflictingDecls.push_back(FoundDecl); 3209203955Srdivacky } 3210203955Srdivacky } 3211321369Sdim 3212203955Srdivacky if (!ConflictingDecls.empty()) { 3213360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 3214360784Sdim Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size()); 3215360784Sdim if (NameOrErr) 3216360784Sdim Name = NameOrErr.get(); 3217360784Sdim else 3218360784Sdim return NameOrErr.takeError(); 3219341825Sdim } 3220203955Srdivacky } 3221203955Srdivacky 3222353358Sdim // We do not allow more than one in-class declaration of a function. This is 3223353358Sdim // because AST clients like VTableBuilder asserts on this. VTableBuilder 3224353358Sdim // assumes there is only one in-class declaration. Building a redecl 3225353358Sdim // chain would result in more than one in-class declaration for 3226353358Sdim // overrides (even if they are part of the same redecl chain inside the 3227353358Sdim // derived class.) 3228353358Sdim if (FoundByLookup) { 3229353358Sdim if (isa<CXXMethodDecl>(FoundByLookup)) { 3230353358Sdim if (D->getLexicalDeclContext() == D->getDeclContext()) { 3231360784Sdim if (!D->doesThisDeclarationHaveABody()) { 3232360784Sdim if (FunctionTemplateDecl *DescribedD = 3233360784Sdim D->getDescribedFunctionTemplate()) { 3234360784Sdim // Handle a "templated" function together with its described 3235360784Sdim // template. This avoids need for a similar check at import of the 3236360784Sdim // described template. 3237360784Sdim assert(FoundByLookup->getDescribedFunctionTemplate() && 3238360784Sdim "Templated function mapped to non-templated?"); 3239360784Sdim Importer.MapImported(DescribedD, 3240360784Sdim FoundByLookup->getDescribedFunctionTemplate()); 3241360784Sdim } 3242353358Sdim return Importer.MapImported(D, FoundByLookup); 3243360784Sdim } else { 3244353358Sdim // Let's continue and build up the redecl chain in this case. 3245353358Sdim // FIXME Merge the functions into one decl. 3246353358Sdim } 3247353358Sdim } 3248353358Sdim } 3249353358Sdim } 3250353358Sdim 3251212904Sdim DeclarationNameInfo NameInfo(Name, Loc); 3252212904Sdim // Import additional name location/type info. 3253344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 3254344779Sdim return std::move(Err); 3255212904Sdim 3256243830Sdim QualType FromTy = D->getType(); 3257360784Sdim // Set to true if we do not import the type of the function as is. There are 3258360784Sdim // cases when the original type would result in an infinite recursion during 3259360784Sdim // the import. To avoid an infinite recursion when importing, we create the 3260360784Sdim // FunctionDecl with a simplified function type and update it only after the 3261360784Sdim // relevant AST nodes are already imported. 3262360784Sdim bool UsedDifferentProtoType = false; 3263360784Sdim if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) { 3264360784Sdim QualType FromReturnTy = FromFPT->getReturnType(); 3265360784Sdim // Functions with auto return type may define a struct inside their body 3266360784Sdim // and the return type could refer to that struct. 3267360784Sdim // E.g.: auto foo() { struct X{}; return X(); } 3268360784Sdim // To avoid an infinite recursion when importing, create the FunctionDecl 3269360784Sdim // with a simplified return type. 3270360784Sdim if (hasAutoReturnTypeDeclaredInside(D)) { 3271360784Sdim FromReturnTy = Importer.getFromContext().VoidTy; 3272360784Sdim UsedDifferentProtoType = true; 3273360784Sdim } 3274243830Sdim FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 3275243830Sdim // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 3276243830Sdim // FunctionDecl that we are importing the FunctionProtoType for. 3277243830Sdim // To avoid an infinite recursion when importing, create the FunctionDecl 3278360784Sdim // with a simplified function type. 3279280031Sdim if (FromEPI.ExceptionSpec.SourceDecl || 3280280031Sdim FromEPI.ExceptionSpec.SourceTemplate || 3281280031Sdim FromEPI.ExceptionSpec.NoexceptExpr) { 3282243830Sdim FunctionProtoType::ExtProtoInfo DefaultEPI; 3283360784Sdim FromEPI = DefaultEPI; 3284360784Sdim UsedDifferentProtoType = true; 3285243830Sdim } 3286360784Sdim FromTy = Importer.getFromContext().getFunctionType( 3287360784Sdim FromReturnTy, FromFPT->getParamTypes(), FromEPI); 3288243830Sdim } 3289243830Sdim 3290344779Sdim QualType T; 3291344779Sdim TypeSourceInfo *TInfo; 3292344779Sdim SourceLocation ToInnerLocStart, ToEndLoc; 3293344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 3294360784Sdim Expr *TrailingRequiresClause; 3295344779Sdim if (auto Imp = importSeq( 3296344779Sdim FromTy, D->getTypeSourceInfo(), D->getInnerLocStart(), 3297360784Sdim D->getQualifierLoc(), D->getEndLoc(), D->getTrailingRequiresClause())) 3298360784Sdim std::tie(T, TInfo, ToInnerLocStart, ToQualifierLoc, ToEndLoc, 3299360784Sdim TrailingRequiresClause) = *Imp; 3300344779Sdim else 3301344779Sdim return Imp.takeError(); 3302276479Sdim 3303203955Srdivacky // Import the function parameters. 3304226633Sdim SmallVector<ParmVarDecl *, 8> Parameters; 3305309124Sdim for (auto P : D->parameters()) { 3306344779Sdim if (Expected<ParmVarDecl *> ToPOrErr = import(P)) 3307344779Sdim Parameters.push_back(*ToPOrErr); 3308344779Sdim else 3309344779Sdim return ToPOrErr.takeError(); 3310203955Srdivacky } 3311341825Sdim 3312203955Srdivacky // Create the imported function. 3313276479Sdim FunctionDecl *ToFunction = nullptr; 3314341825Sdim if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 3315353358Sdim Expr *ExplicitExpr = nullptr; 3316353358Sdim if (FromConstructor->getExplicitSpecifier().getExpr()) { 3317353358Sdim auto Imp = importSeq(FromConstructor->getExplicitSpecifier().getExpr()); 3318353358Sdim if (!Imp) 3319353358Sdim return Imp.takeError(); 3320353358Sdim std::tie(ExplicitExpr) = *Imp; 3321353358Sdim } 3322341825Sdim if (GetImportedOrCreateDecl<CXXConstructorDecl>( 3323353358Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3324353358Sdim ToInnerLocStart, NameInfo, T, TInfo, 3325353358Sdim ExplicitSpecifier( 3326353358Sdim ExplicitExpr, 3327353358Sdim FromConstructor->getExplicitSpecifier().getKind()), 3328360784Sdim D->isInlineSpecified(), D->isImplicit(), D->getConstexprKind(), 3329360784Sdim InheritedConstructor(), // FIXME: Properly import inherited 3330360784Sdim // constructor info 3331360784Sdim TrailingRequiresClause)) 3332341825Sdim return ToFunction; 3333353358Sdim } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) { 3334353358Sdim 3335353358Sdim auto Imp = 3336353358Sdim importSeq(const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()), 3337353358Sdim FromDtor->getOperatorDeleteThisArg()); 3338353358Sdim 3339353358Sdim if (!Imp) 3340353358Sdim return Imp.takeError(); 3341353358Sdim 3342353358Sdim FunctionDecl *ToOperatorDelete; 3343353358Sdim Expr *ToThisArg; 3344353358Sdim std::tie(ToOperatorDelete, ToThisArg) = *Imp; 3345353358Sdim 3346341825Sdim if (GetImportedOrCreateDecl<CXXDestructorDecl>( 3347344779Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3348344779Sdim ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), 3349360784Sdim D->isImplicit(), D->getConstexprKind(), TrailingRequiresClause)) 3350341825Sdim return ToFunction; 3351353358Sdim 3352353358Sdim CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction); 3353353358Sdim 3354353358Sdim ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg); 3355341825Sdim } else if (CXXConversionDecl *FromConversion = 3356341825Sdim dyn_cast<CXXConversionDecl>(D)) { 3357353358Sdim Expr *ExplicitExpr = nullptr; 3358353358Sdim if (FromConversion->getExplicitSpecifier().getExpr()) { 3359353358Sdim auto Imp = importSeq(FromConversion->getExplicitSpecifier().getExpr()); 3360353358Sdim if (!Imp) 3361353358Sdim return Imp.takeError(); 3362353358Sdim std::tie(ExplicitExpr) = *Imp; 3363353358Sdim } 3364341825Sdim if (GetImportedOrCreateDecl<CXXConversionDecl>( 3365341825Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3366344779Sdim ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(), 3367353358Sdim ExplicitSpecifier(ExplicitExpr, 3368353358Sdim FromConversion->getExplicitSpecifier().getKind()), 3369360784Sdim D->getConstexprKind(), SourceLocation(), TrailingRequiresClause)) 3370341825Sdim return ToFunction; 3371341825Sdim } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) { 3372341825Sdim if (GetImportedOrCreateDecl<CXXMethodDecl>( 3373341825Sdim ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC), 3374344779Sdim ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(), 3375353358Sdim Method->isInlineSpecified(), D->getConstexprKind(), 3376360784Sdim SourceLocation(), TrailingRequiresClause)) 3377341825Sdim return ToFunction; 3378204643Srdivacky } else { 3379353358Sdim if (GetImportedOrCreateDecl( 3380353358Sdim ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart, 3381353358Sdim NameInfo, T, TInfo, D->getStorageClass(), D->isInlineSpecified(), 3382360784Sdim D->hasWrittenPrototype(), D->getConstexprKind(), 3383360784Sdim TrailingRequiresClause)) 3384341825Sdim return ToFunction; 3385204643Srdivacky } 3386205219Srdivacky 3387344779Sdim // Connect the redecl chain. 3388344779Sdim if (FoundByLookup) { 3389344779Sdim auto *Recent = const_cast<FunctionDecl *>( 3390344779Sdim FoundByLookup->getMostRecentDecl()); 3391344779Sdim ToFunction->setPreviousDecl(Recent); 3392353358Sdim // FIXME Probably we should merge exception specifications. E.g. In the 3393353358Sdim // "To" context the existing function may have exception specification with 3394353358Sdim // noexcept-unevaluated, while the newly imported function may have an 3395353358Sdim // evaluated noexcept. A call to adjustExceptionSpec() on the imported 3396353358Sdim // decl and its redeclarations may be required. 3397344779Sdim } 3398344779Sdim 3399344779Sdim ToFunction->setQualifierInfo(ToQualifierLoc); 3400204643Srdivacky ToFunction->setAccess(D->getAccess()); 3401204643Srdivacky ToFunction->setLexicalDeclContext(LexicalDC); 3402218893Sdim ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 3403218893Sdim ToFunction->setTrivial(D->isTrivial()); 3404218893Sdim ToFunction->setPure(D->isPure()); 3405360784Sdim ToFunction->setDefaulted(D->isDefaulted()); 3406360784Sdim ToFunction->setExplicitlyDefaulted(D->isExplicitlyDefaulted()); 3407360784Sdim ToFunction->setDeletedAsWritten(D->isDeletedAsWritten()); 3408344779Sdim ToFunction->setRangeEnd(ToEndLoc); 3409203955Srdivacky 3410203955Srdivacky // Set the parameters. 3411341825Sdim for (auto *Param : Parameters) { 3412341825Sdim Param->setOwningFunction(ToFunction); 3413341825Sdim ToFunction->addDeclInternal(Param); 3414203955Srdivacky } 3415226633Sdim ToFunction->setParams(Parameters); 3416203955Srdivacky 3417341825Sdim // We need to complete creation of FunctionProtoTypeLoc manually with setting 3418341825Sdim // params it refers to. 3419341825Sdim if (TInfo) { 3420341825Sdim if (auto ProtoLoc = 3421341825Sdim TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) { 3422341825Sdim for (unsigned I = 0, N = Parameters.size(); I != N; ++I) 3423341825Sdim ProtoLoc.setParam(I, Parameters[I]); 3424341825Sdim } 3425341825Sdim } 3426341825Sdim 3427341825Sdim // Import the describing template function, if any. 3428344779Sdim if (FromFT) { 3429344779Sdim auto ToFTOrErr = import(FromFT); 3430344779Sdim if (!ToFTOrErr) 3431344779Sdim return ToFTOrErr.takeError(); 3432344779Sdim } 3433341825Sdim 3434360784Sdim // Import Ctor initializers. 3435360784Sdim if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 3436360784Sdim if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) { 3437360784Sdim SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers); 3438360784Sdim // Import first, then allocate memory and copy if there was no error. 3439360784Sdim if (Error Err = ImportContainerChecked( 3440360784Sdim FromConstructor->inits(), CtorInitializers)) 3441360784Sdim return std::move(Err); 3442360784Sdim auto **Memory = 3443360784Sdim new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers]; 3444360784Sdim std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory); 3445360784Sdim auto *ToCtor = cast<CXXConstructorDecl>(ToFunction); 3446360784Sdim ToCtor->setCtorInitializers(Memory); 3447360784Sdim ToCtor->setNumCtorInitializers(NumInitializers); 3448360784Sdim } 3449360784Sdim } 3450360784Sdim 3451341825Sdim if (D->doesThisDeclarationHaveABody()) { 3452353358Sdim Error Err = ImportFunctionDeclBody(D, ToFunction); 3453353358Sdim 3454353358Sdim if (Err) 3455353358Sdim return std::move(Err); 3456288943Sdim } 3457288943Sdim 3458360784Sdim // Import and set the original type in case we used another type. 3459360784Sdim if (UsedDifferentProtoType) { 3460360784Sdim if (ExpectedType TyOrErr = import(D->getType())) 3461360784Sdim ToFunction->setType(*TyOrErr); 3462360784Sdim else 3463360784Sdim return TyOrErr.takeError(); 3464360784Sdim } 3465360784Sdim 3466203955Srdivacky // FIXME: Other bits to merge? 3467218893Sdim 3468341825Sdim // If it is a template, import all related things. 3469344779Sdim if (Error Err = ImportTemplateInformation(D, ToFunction)) 3470344779Sdim return std::move(Err); 3471218893Sdim 3472360784Sdim addDeclToContexts(D, ToFunction); 3473341825Sdim 3474321369Sdim if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D)) 3475360784Sdim if (Error Err = ImportOverriddenMethods(cast<CXXMethodDecl>(ToFunction), 3476360784Sdim FromCXXMethod)) 3477360784Sdim return std::move(Err); 3478321369Sdim 3479344779Sdim // Import the rest of the chain. I.e. import all subsequent declarations. 3480344779Sdim for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) { 3481344779Sdim ExpectedDecl ToRedeclOrErr = import(*RedeclIt); 3482344779Sdim if (!ToRedeclOrErr) 3483344779Sdim return ToRedeclOrErr.takeError(); 3484344779Sdim } 3485344779Sdim 3486204643Srdivacky return ToFunction; 3487203955Srdivacky} 3488203955Srdivacky 3489344779SdimExpectedDecl ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 3490204643Srdivacky return VisitFunctionDecl(D); 3491204643Srdivacky} 3492204643Srdivacky 3493344779SdimExpectedDecl ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 3494204643Srdivacky return VisitCXXMethodDecl(D); 3495204643Srdivacky} 3496204643Srdivacky 3497344779SdimExpectedDecl ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 3498204643Srdivacky return VisitCXXMethodDecl(D); 3499204643Srdivacky} 3500204643Srdivacky 3501344779SdimExpectedDecl ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 3502204643Srdivacky return VisitCXXMethodDecl(D); 3503204643Srdivacky} 3504204643Srdivacky 3505344779SdimExpectedDecl ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 3506203955Srdivacky // Import the major distinguishing characteristics of a variable. 3507203955Srdivacky DeclContext *DC, *LexicalDC; 3508203955Srdivacky DeclarationName Name; 3509203955Srdivacky SourceLocation Loc; 3510288943Sdim NamedDecl *ToD; 3511344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3512344779Sdim return std::move(Err); 3513288943Sdim if (ToD) 3514288943Sdim return ToD; 3515276479Sdim 3516341825Sdim // Determine whether we've already imported this field. 3517344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3518341825Sdim for (auto *FoundDecl : FoundDecls) { 3519344779Sdim if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) { 3520243830Sdim // For anonymous fields, match up by index. 3521344779Sdim if (!Name && 3522344779Sdim ASTImporter::getFieldIndex(D) != 3523344779Sdim ASTImporter::getFieldIndex(FoundField)) 3524243830Sdim continue; 3525243830Sdim 3526321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3527226633Sdim FoundField->getType())) { 3528341825Sdim Importer.MapImported(D, FoundField); 3529344779Sdim // In case of a FieldDecl of a ClassTemplateSpecializationDecl, the 3530344779Sdim // initializer of a FieldDecl might not had been instantiated in the 3531344779Sdim // "To" context. However, the "From" context might instantiated that, 3532344779Sdim // thus we have to merge that. 3533344779Sdim if (Expr *FromInitializer = D->getInClassInitializer()) { 3534344779Sdim // We don't have yet the initializer set. 3535344779Sdim if (FoundField->hasInClassInitializer() && 3536344779Sdim !FoundField->getInClassInitializer()) { 3537344779Sdim if (ExpectedExpr ToInitializerOrErr = import(FromInitializer)) 3538344779Sdim FoundField->setInClassInitializer(*ToInitializerOrErr); 3539344779Sdim else { 3540344779Sdim // We can't return error here, 3541344779Sdim // since we already mapped D as imported. 3542344779Sdim // FIXME: warning message? 3543344779Sdim consumeError(ToInitializerOrErr.takeError()); 3544344779Sdim return FoundField; 3545344779Sdim } 3546344779Sdim } 3547344779Sdim } 3548226633Sdim return FoundField; 3549226633Sdim } 3550321369Sdim 3551344779Sdim // FIXME: Why is this case not handled with calling HandleNameConflict? 3552353358Sdim Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) 3553226633Sdim << Name << D->getType() << FoundField->getType(); 3554226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 3555226633Sdim << FoundField->getType(); 3556344779Sdim 3557344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3558226633Sdim } 3559226633Sdim } 3560226633Sdim 3561344779Sdim QualType ToType; 3562344779Sdim TypeSourceInfo *ToTInfo; 3563344779Sdim Expr *ToBitWidth; 3564344779Sdim SourceLocation ToInnerLocStart; 3565344779Sdim Expr *ToInitializer; 3566344779Sdim if (auto Imp = importSeq( 3567344779Sdim D->getType(), D->getTypeSourceInfo(), D->getBitWidth(), 3568344779Sdim D->getInnerLocStart(), D->getInClassInitializer())) 3569344779Sdim std::tie( 3570344779Sdim ToType, ToTInfo, ToBitWidth, ToInnerLocStart, ToInitializer) = *Imp; 3571344779Sdim else 3572344779Sdim return Imp.takeError(); 3573276479Sdim 3574341825Sdim FieldDecl *ToField; 3575341825Sdim if (GetImportedOrCreateDecl(ToField, D, Importer.getToContext(), DC, 3576344779Sdim ToInnerLocStart, Loc, Name.getAsIdentifierInfo(), 3577344779Sdim ToType, ToTInfo, ToBitWidth, D->isMutable(), 3578344779Sdim D->getInClassInitStyle())) 3579341825Sdim return ToField; 3580341825Sdim 3581204643Srdivacky ToField->setAccess(D->getAccess()); 3582203955Srdivacky ToField->setLexicalDeclContext(LexicalDC); 3583344779Sdim if (ToInitializer) 3584344779Sdim ToField->setInClassInitializer(ToInitializer); 3585243830Sdim ToField->setImplicit(D->isImplicit()); 3586234353Sdim LexicalDC->addDeclInternal(ToField); 3587203955Srdivacky return ToField; 3588203955Srdivacky} 3589203955Srdivacky 3590344779SdimExpectedDecl ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 3591218893Sdim // Import the major distinguishing characteristics of a variable. 3592218893Sdim DeclContext *DC, *LexicalDC; 3593218893Sdim DeclarationName Name; 3594218893Sdim SourceLocation Loc; 3595288943Sdim NamedDecl *ToD; 3596344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3597344779Sdim return std::move(Err); 3598288943Sdim if (ToD) 3599288943Sdim return ToD; 3600218893Sdim 3601341825Sdim // Determine whether we've already imported this field. 3602344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3603226633Sdim for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3604341825Sdim if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 3605243830Sdim // For anonymous indirect fields, match up by index. 3606344779Sdim if (!Name && 3607344779Sdim ASTImporter::getFieldIndex(D) != 3608344779Sdim ASTImporter::getFieldIndex(FoundField)) 3609243830Sdim continue; 3610243830Sdim 3611321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3612239462Sdim FoundField->getType(), 3613261991Sdim !Name.isEmpty())) { 3614341825Sdim Importer.MapImported(D, FoundField); 3615226633Sdim return FoundField; 3616226633Sdim } 3617239462Sdim 3618239462Sdim // If there are more anonymous fields to check, continue. 3619239462Sdim if (!Name && I < N-1) 3620239462Sdim continue; 3621239462Sdim 3622344779Sdim // FIXME: Why is this case not handled with calling HandleNameConflict? 3623353358Sdim Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent) 3624226633Sdim << Name << D->getType() << FoundField->getType(); 3625226633Sdim Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 3626226633Sdim << FoundField->getType(); 3627344779Sdim 3628344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3629226633Sdim } 3630226633Sdim } 3631226633Sdim 3632218893Sdim // Import the type. 3633344779Sdim auto TypeOrErr = import(D->getType()); 3634344779Sdim if (!TypeOrErr) 3635344779Sdim return TypeOrErr.takeError(); 3636218893Sdim 3637341825Sdim auto **NamedChain = 3638341825Sdim new (Importer.getToContext()) NamedDecl*[D->getChainingSize()]; 3639218893Sdim 3640218893Sdim unsigned i = 0; 3641344779Sdim for (auto *PI : D->chain()) 3642344779Sdim if (Expected<NamedDecl *> ToD = import(PI)) 3643344779Sdim NamedChain[i++] = *ToD; 3644344779Sdim else 3645344779Sdim return ToD.takeError(); 3646218893Sdim 3647341825Sdim llvm::MutableArrayRef<NamedDecl *> CH = {NamedChain, D->getChainingSize()}; 3648341825Sdim IndirectFieldDecl *ToIndirectField; 3649341825Sdim if (GetImportedOrCreateDecl(ToIndirectField, D, Importer.getToContext(), DC, 3650344779Sdim Loc, Name.getAsIdentifierInfo(), *TypeOrErr, CH)) 3651341825Sdim // FIXME here we leak `NamedChain` which is allocated before 3652341825Sdim return ToIndirectField; 3653280031Sdim 3654218893Sdim ToIndirectField->setAccess(D->getAccess()); 3655218893Sdim ToIndirectField->setLexicalDeclContext(LexicalDC); 3656234353Sdim LexicalDC->addDeclInternal(ToIndirectField); 3657218893Sdim return ToIndirectField; 3658218893Sdim} 3659218893Sdim 3660344779SdimExpectedDecl ASTNodeImporter::VisitFriendDecl(FriendDecl *D) { 3661314564Sdim // Import the major distinguishing characteristics of a declaration. 3662344779Sdim DeclContext *DC, *LexicalDC; 3663344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 3664344779Sdim return std::move(Err); 3665314564Sdim 3666314564Sdim // Determine whether we've already imported this decl. 3667344779Sdim // FriendDecl is not a NamedDecl so we cannot use lookup. 3668314564Sdim auto *RD = cast<CXXRecordDecl>(DC); 3669314564Sdim FriendDecl *ImportedFriend = RD->getFirstFriend(); 3670314564Sdim 3671314564Sdim while (ImportedFriend) { 3672314564Sdim if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) { 3673341825Sdim if (IsStructuralMatch(D->getFriendDecl(), ImportedFriend->getFriendDecl(), 3674341825Sdim /*Complain=*/false)) 3675341825Sdim return Importer.MapImported(D, ImportedFriend); 3676314564Sdim 3677314564Sdim } else if (D->getFriendType() && ImportedFriend->getFriendType()) { 3678314564Sdim if (Importer.IsStructurallyEquivalent( 3679314564Sdim D->getFriendType()->getType(), 3680314564Sdim ImportedFriend->getFriendType()->getType(), true)) 3681341825Sdim return Importer.MapImported(D, ImportedFriend); 3682314564Sdim } 3683314564Sdim ImportedFriend = ImportedFriend->getNextFriend(); 3684314564Sdim } 3685314564Sdim 3686314564Sdim // Not found. Create it. 3687314564Sdim FriendDecl::FriendUnion ToFU; 3688341825Sdim if (NamedDecl *FriendD = D->getFriendDecl()) { 3689344779Sdim NamedDecl *ToFriendD; 3690344779Sdim if (Error Err = importInto(ToFriendD, FriendD)) 3691344779Sdim return std::move(Err); 3692344779Sdim 3693344779Sdim if (FriendD->getFriendObjectKind() != Decl::FOK_None && 3694341825Sdim !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator))) 3695341825Sdim ToFriendD->setObjectOfFriendDecl(false); 3696341825Sdim 3697341825Sdim ToFU = ToFriendD; 3698344779Sdim } else { // The friend is a type, not a decl. 3699344779Sdim if (auto TSIOrErr = import(D->getFriendType())) 3700344779Sdim ToFU = *TSIOrErr; 3701344779Sdim else 3702344779Sdim return TSIOrErr.takeError(); 3703344779Sdim } 3704314564Sdim 3705314564Sdim SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists); 3706341825Sdim auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>(); 3707314564Sdim for (unsigned I = 0; I < D->NumTPLists; I++) { 3708353358Sdim if (auto ListOrErr = import(FromTPLists[I])) 3709344779Sdim ToTPLists[I] = *ListOrErr; 3710344779Sdim else 3711344779Sdim return ListOrErr.takeError(); 3712314564Sdim } 3713314564Sdim 3714344779Sdim auto LocationOrErr = import(D->getLocation()); 3715344779Sdim if (!LocationOrErr) 3716344779Sdim return LocationOrErr.takeError(); 3717344779Sdim auto FriendLocOrErr = import(D->getFriendLoc()); 3718344779Sdim if (!FriendLocOrErr) 3719344779Sdim return FriendLocOrErr.takeError(); 3720344779Sdim 3721341825Sdim FriendDecl *FrD; 3722341825Sdim if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC, 3723344779Sdim *LocationOrErr, ToFU, 3724344779Sdim *FriendLocOrErr, ToTPLists)) 3725341825Sdim return FrD; 3726314564Sdim 3727314564Sdim FrD->setAccess(D->getAccess()); 3728314564Sdim FrD->setLexicalDeclContext(LexicalDC); 3729314564Sdim LexicalDC->addDeclInternal(FrD); 3730314564Sdim return FrD; 3731314564Sdim} 3732314564Sdim 3733344779SdimExpectedDecl ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 3734204643Srdivacky // Import the major distinguishing characteristics of an ivar. 3735204643Srdivacky DeclContext *DC, *LexicalDC; 3736204643Srdivacky DeclarationName Name; 3737204643Srdivacky SourceLocation Loc; 3738288943Sdim NamedDecl *ToD; 3739344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3740344779Sdim return std::move(Err); 3741288943Sdim if (ToD) 3742288943Sdim return ToD; 3743276479Sdim 3744321369Sdim // Determine whether we've already imported this ivar 3745344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3746341825Sdim for (auto *FoundDecl : FoundDecls) { 3747344779Sdim if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) { 3748321369Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3749204643Srdivacky FoundIvar->getType())) { 3750341825Sdim Importer.MapImported(D, FoundIvar); 3751204643Srdivacky return FoundIvar; 3752204643Srdivacky } 3753204643Srdivacky 3754353358Sdim Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent) 3755204643Srdivacky << Name << D->getType() << FoundIvar->getType(); 3756204643Srdivacky Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 3757204643Srdivacky << FoundIvar->getType(); 3758344779Sdim 3759344779Sdim return make_error<ImportError>(ImportError::NameConflict); 3760204643Srdivacky } 3761204643Srdivacky } 3762204643Srdivacky 3763344779Sdim QualType ToType; 3764344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3765344779Sdim Expr *ToBitWidth; 3766344779Sdim SourceLocation ToInnerLocStart; 3767344779Sdim if (auto Imp = importSeq( 3768344779Sdim D->getType(), D->getTypeSourceInfo(), D->getBitWidth(), D->getInnerLocStart())) 3769344779Sdim std::tie(ToType, ToTypeSourceInfo, ToBitWidth, ToInnerLocStart) = *Imp; 3770344779Sdim else 3771344779Sdim return Imp.takeError(); 3772276479Sdim 3773341825Sdim ObjCIvarDecl *ToIvar; 3774341825Sdim if (GetImportedOrCreateDecl( 3775341825Sdim ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC), 3776344779Sdim ToInnerLocStart, Loc, Name.getAsIdentifierInfo(), 3777344779Sdim ToType, ToTypeSourceInfo, 3778344779Sdim D->getAccessControl(),ToBitWidth, D->getSynthesize())) 3779341825Sdim return ToIvar; 3780341825Sdim 3781204643Srdivacky ToIvar->setLexicalDeclContext(LexicalDC); 3782234353Sdim LexicalDC->addDeclInternal(ToIvar); 3783204643Srdivacky return ToIvar; 3784204643Srdivacky} 3785204643Srdivacky 3786344779SdimExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) { 3787344779Sdim 3788344779Sdim SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D); 3789344779Sdim auto RedeclIt = Redecls.begin(); 3790344779Sdim // Import the first part of the decl chain. I.e. import all previous 3791344779Sdim // declarations starting from the canonical decl. 3792344779Sdim for (; RedeclIt != Redecls.end() && *RedeclIt != D; ++RedeclIt) { 3793344779Sdim ExpectedDecl RedeclOrErr = import(*RedeclIt); 3794344779Sdim if (!RedeclOrErr) 3795344779Sdim return RedeclOrErr.takeError(); 3796344779Sdim } 3797344779Sdim assert(*RedeclIt == D); 3798344779Sdim 3799203955Srdivacky // Import the major distinguishing characteristics of a variable. 3800203955Srdivacky DeclContext *DC, *LexicalDC; 3801203955Srdivacky DeclarationName Name; 3802203955Srdivacky SourceLocation Loc; 3803288943Sdim NamedDecl *ToD; 3804344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3805344779Sdim return std::move(Err); 3806288943Sdim if (ToD) 3807288943Sdim return ToD; 3808276479Sdim 3809203955Srdivacky // Try to find a variable in our own ("to") context with the same name and 3810203955Srdivacky // in the same context as the variable we're importing. 3811344779Sdim VarDecl *FoundByLookup = nullptr; 3812203955Srdivacky if (D->isFileVarDecl()) { 3813226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 3814203955Srdivacky unsigned IDNS = Decl::IDNS_Ordinary; 3815344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 3816341825Sdim for (auto *FoundDecl : FoundDecls) { 3817341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 3818203955Srdivacky continue; 3819321369Sdim 3820341825Sdim if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) { 3821353358Sdim if (!hasSameVisibilityContext(FoundVar, D)) 3822353358Sdim continue; 3823353358Sdim if (Importer.IsStructurallyEquivalent(D->getType(), 3824353358Sdim FoundVar->getType())) { 3825344779Sdim 3826353358Sdim // The VarDecl in the "From" context has a definition, but in the 3827353358Sdim // "To" context we already have a definition. 3828353358Sdim VarDecl *FoundDef = FoundVar->getDefinition(); 3829353358Sdim if (D->isThisDeclarationADefinition() && FoundDef) 3830353358Sdim // FIXME Check for ODR error if the two definitions have 3831353358Sdim // different initializers? 3832353358Sdim return Importer.MapImported(D, FoundDef); 3833344779Sdim 3834353358Sdim // The VarDecl in the "From" context has an initializer, but in the 3835353358Sdim // "To" context we already have an initializer. 3836353358Sdim const VarDecl *FoundDInit = nullptr; 3837353358Sdim if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit)) 3838353358Sdim // FIXME Diagnose ODR error if the two initializers are different? 3839353358Sdim return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit)); 3840344779Sdim 3841353358Sdim FoundByLookup = FoundVar; 3842353358Sdim break; 3843353358Sdim } 3844353358Sdim 3845353358Sdim const ArrayType *FoundArray 3846353358Sdim = Importer.getToContext().getAsArrayType(FoundVar->getType()); 3847353358Sdim const ArrayType *TArray 3848353358Sdim = Importer.getToContext().getAsArrayType(D->getType()); 3849353358Sdim if (FoundArray && TArray) { 3850353358Sdim if (isa<IncompleteArrayType>(FoundArray) && 3851353358Sdim isa<ConstantArrayType>(TArray)) { 3852353358Sdim // Import the type. 3853353358Sdim if (auto TyOrErr = import(D->getType())) 3854353358Sdim FoundVar->setType(*TyOrErr); 3855353358Sdim else 3856353358Sdim return TyOrErr.takeError(); 3857353358Sdim 3858344779Sdim FoundByLookup = FoundVar; 3859203955Srdivacky break; 3860353358Sdim } else if (isa<IncompleteArrayType>(TArray) && 3861353358Sdim isa<ConstantArrayType>(FoundArray)) { 3862353358Sdim FoundByLookup = FoundVar; 3863353358Sdim break; 3864203955Srdivacky } 3865353358Sdim } 3866203955Srdivacky 3867353358Sdim Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent) 3868353358Sdim << Name << D->getType() << FoundVar->getType(); 3869353358Sdim Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 3870353358Sdim << FoundVar->getType(); 3871360784Sdim ConflictingDecls.push_back(FoundDecl); 3872203955Srdivacky } 3873203955Srdivacky } 3874203955Srdivacky 3875203955Srdivacky if (!ConflictingDecls.empty()) { 3876360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 3877360784Sdim Name, DC, IDNS, ConflictingDecls.data(), ConflictingDecls.size()); 3878360784Sdim if (NameOrErr) 3879360784Sdim Name = NameOrErr.get(); 3880360784Sdim else 3881360784Sdim return NameOrErr.takeError(); 3882203955Srdivacky } 3883203955Srdivacky } 3884341825Sdim 3885344779Sdim QualType ToType; 3886344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3887344779Sdim SourceLocation ToInnerLocStart; 3888344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 3889344779Sdim if (auto Imp = importSeq( 3890344779Sdim D->getType(), D->getTypeSourceInfo(), D->getInnerLocStart(), 3891344779Sdim D->getQualifierLoc())) 3892344779Sdim std::tie(ToType, ToTypeSourceInfo, ToInnerLocStart, ToQualifierLoc) = *Imp; 3893344779Sdim else 3894344779Sdim return Imp.takeError(); 3895276479Sdim 3896203955Srdivacky // Create the imported variable. 3897341825Sdim VarDecl *ToVar; 3898341825Sdim if (GetImportedOrCreateDecl(ToVar, D, Importer.getToContext(), DC, 3899344779Sdim ToInnerLocStart, Loc, 3900344779Sdim Name.getAsIdentifierInfo(), 3901344779Sdim ToType, ToTypeSourceInfo, 3902341825Sdim D->getStorageClass())) 3903341825Sdim return ToVar; 3904341825Sdim 3905344779Sdim ToVar->setQualifierInfo(ToQualifierLoc); 3906204643Srdivacky ToVar->setAccess(D->getAccess()); 3907203955Srdivacky ToVar->setLexicalDeclContext(LexicalDC); 3908203955Srdivacky 3909344779Sdim if (FoundByLookup) { 3910344779Sdim auto *Recent = const_cast<VarDecl *>(FoundByLookup->getMostRecentDecl()); 3911344779Sdim ToVar->setPreviousDecl(Recent); 3912344779Sdim } 3913288943Sdim 3914344779Sdim if (Error Err = ImportInitializer(D, ToVar)) 3915344779Sdim return std::move(Err); 3916203955Srdivacky 3917321369Sdim if (D->isConstexpr()) 3918321369Sdim ToVar->setConstexpr(true); 3919321369Sdim 3920360784Sdim addDeclToContexts(D, ToVar); 3921344779Sdim 3922344779Sdim // Import the rest of the chain. I.e. import all subsequent declarations. 3923344779Sdim for (++RedeclIt; RedeclIt != Redecls.end(); ++RedeclIt) { 3924344779Sdim ExpectedDecl RedeclOrErr = import(*RedeclIt); 3925344779Sdim if (!RedeclOrErr) 3926344779Sdim return RedeclOrErr.takeError(); 3927344779Sdim } 3928344779Sdim 3929203955Srdivacky return ToVar; 3930203955Srdivacky} 3931203955Srdivacky 3932344779SdimExpectedDecl ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 3933204643Srdivacky // Parameters are created in the translation unit's context, then moved 3934204643Srdivacky // into the function declaration's context afterward. 3935204643Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3936341825Sdim 3937344779Sdim DeclarationName ToDeclName; 3938344779Sdim SourceLocation ToLocation; 3939344779Sdim QualType ToType; 3940344779Sdim if (auto Imp = importSeq(D->getDeclName(), D->getLocation(), D->getType())) 3941344779Sdim std::tie(ToDeclName, ToLocation, ToType) = *Imp; 3942344779Sdim else 3943344779Sdim return Imp.takeError(); 3944276479Sdim 3945204643Srdivacky // Create the imported parameter. 3946341825Sdim ImplicitParamDecl *ToParm = nullptr; 3947344779Sdim if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, 3948344779Sdim ToLocation, ToDeclName.getAsIdentifierInfo(), 3949344779Sdim ToType, D->getParameterKind())) 3950341825Sdim return ToParm; 3951341825Sdim return ToParm; 3952204643Srdivacky} 3953204643Srdivacky 3954360784SdimError ASTNodeImporter::ImportDefaultArgOfParmVarDecl( 3955360784Sdim const ParmVarDecl *FromParam, ParmVarDecl *ToParam) { 3956360784Sdim ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg()); 3957360784Sdim ToParam->setKNRPromoted(FromParam->isKNRPromoted()); 3958360784Sdim 3959360784Sdim if (FromParam->hasUninstantiatedDefaultArg()) { 3960360784Sdim if (auto ToDefArgOrErr = import(FromParam->getUninstantiatedDefaultArg())) 3961360784Sdim ToParam->setUninstantiatedDefaultArg(*ToDefArgOrErr); 3962360784Sdim else 3963360784Sdim return ToDefArgOrErr.takeError(); 3964360784Sdim } else if (FromParam->hasUnparsedDefaultArg()) { 3965360784Sdim ToParam->setUnparsedDefaultArg(); 3966360784Sdim } else if (FromParam->hasDefaultArg()) { 3967360784Sdim if (auto ToDefArgOrErr = import(FromParam->getDefaultArg())) 3968360784Sdim ToParam->setDefaultArg(*ToDefArgOrErr); 3969360784Sdim else 3970360784Sdim return ToDefArgOrErr.takeError(); 3971360784Sdim } 3972360784Sdim 3973360784Sdim return Error::success(); 3974360784Sdim} 3975360784Sdim 3976344779SdimExpectedDecl ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 3977203955Srdivacky // Parameters are created in the translation unit's context, then moved 3978203955Srdivacky // into the function declaration's context afterward. 3979203955Srdivacky DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3980341825Sdim 3981344779Sdim DeclarationName ToDeclName; 3982344779Sdim SourceLocation ToLocation, ToInnerLocStart; 3983344779Sdim QualType ToType; 3984344779Sdim TypeSourceInfo *ToTypeSourceInfo; 3985344779Sdim if (auto Imp = importSeq( 3986344779Sdim D->getDeclName(), D->getLocation(), D->getType(), D->getInnerLocStart(), 3987344779Sdim D->getTypeSourceInfo())) 3988344779Sdim std::tie( 3989344779Sdim ToDeclName, ToLocation, ToType, ToInnerLocStart, 3990344779Sdim ToTypeSourceInfo) = *Imp; 3991344779Sdim else 3992344779Sdim return Imp.takeError(); 3993276479Sdim 3994341825Sdim ParmVarDecl *ToParm; 3995341825Sdim if (GetImportedOrCreateDecl(ToParm, D, Importer.getToContext(), DC, 3996344779Sdim ToInnerLocStart, ToLocation, 3997344779Sdim ToDeclName.getAsIdentifierInfo(), ToType, 3998344779Sdim ToTypeSourceInfo, D->getStorageClass(), 3999341825Sdim /*DefaultArg*/ nullptr)) 4000341825Sdim return ToParm; 4001321369Sdim 4002360784Sdim // Set the default argument. It should be no problem if it was already done. 4003360784Sdim // Do not import the default expression before GetImportedOrCreateDecl call 4004360784Sdim // to avoid possible infinite import loop because circular dependency. 4005360784Sdim if (Error Err = ImportDefaultArgOfParmVarDecl(D, ToParm)) 4006360784Sdim return std::move(Err); 4007288943Sdim 4008341825Sdim if (D->isObjCMethodParameter()) { 4009341825Sdim ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex()); 4010341825Sdim ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier()); 4011341825Sdim } else { 4012341825Sdim ToParm->setScopeInfo(D->getFunctionScopeDepth(), 4013341825Sdim D->getFunctionScopeIndex()); 4014341825Sdim } 4015288943Sdim 4016341825Sdim return ToParm; 4017203955Srdivacky} 4018203955Srdivacky 4019344779SdimExpectedDecl ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 4020204643Srdivacky // Import the major distinguishing characteristics of a method. 4021204643Srdivacky DeclContext *DC, *LexicalDC; 4022204643Srdivacky DeclarationName Name; 4023204643Srdivacky SourceLocation Loc; 4024288943Sdim NamedDecl *ToD; 4025344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4026344779Sdim return std::move(Err); 4027288943Sdim if (ToD) 4028288943Sdim return ToD; 4029276479Sdim 4030344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4031341825Sdim for (auto *FoundDecl : FoundDecls) { 4032341825Sdim if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) { 4033204643Srdivacky if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 4034204643Srdivacky continue; 4035204643Srdivacky 4036204643Srdivacky // Check return types. 4037276479Sdim if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 4038276479Sdim FoundMethod->getReturnType())) { 4039353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent) 4040276479Sdim << D->isInstanceMethod() << Name << D->getReturnType() 4041276479Sdim << FoundMethod->getReturnType(); 4042341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 4043204643Srdivacky diag::note_odr_objc_method_here) 4044204643Srdivacky << D->isInstanceMethod() << Name; 4045344779Sdim 4046344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4047204643Srdivacky } 4048204643Srdivacky 4049204643Srdivacky // Check the number of parameters. 4050204643Srdivacky if (D->param_size() != FoundMethod->param_size()) { 4051353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent) 4052204643Srdivacky << D->isInstanceMethod() << Name 4053204643Srdivacky << D->param_size() << FoundMethod->param_size(); 4054341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 4055204643Srdivacky diag::note_odr_objc_method_here) 4056204643Srdivacky << D->isInstanceMethod() << Name; 4057344779Sdim 4058344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4059204643Srdivacky } 4060204643Srdivacky 4061204643Srdivacky // Check parameter types. 4062321369Sdim for (ObjCMethodDecl::param_iterator P = D->param_begin(), 4063204643Srdivacky PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 4064204643Srdivacky P != PEnd; ++P, ++FoundP) { 4065321369Sdim if (!Importer.IsStructurallyEquivalent((*P)->getType(), 4066204643Srdivacky (*FoundP)->getType())) { 4067321369Sdim Importer.FromDiag((*P)->getLocation(), 4068353358Sdim diag::warn_odr_objc_method_param_type_inconsistent) 4069204643Srdivacky << D->isInstanceMethod() << Name 4070204643Srdivacky << (*P)->getType() << (*FoundP)->getType(); 4071204643Srdivacky Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 4072204643Srdivacky << (*FoundP)->getType(); 4073344779Sdim 4074344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4075204643Srdivacky } 4076204643Srdivacky } 4077204643Srdivacky 4078204643Srdivacky // Check variadic/non-variadic. 4079204643Srdivacky // Check the number of parameters. 4080204643Srdivacky if (D->isVariadic() != FoundMethod->isVariadic()) { 4081353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent) 4082204643Srdivacky << D->isInstanceMethod() << Name; 4083341825Sdim Importer.ToDiag(FoundMethod->getLocation(), 4084204643Srdivacky diag::note_odr_objc_method_here) 4085204643Srdivacky << D->isInstanceMethod() << Name; 4086344779Sdim 4087344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4088204643Srdivacky } 4089204643Srdivacky 4090204643Srdivacky // FIXME: Any other bits we need to merge? 4091341825Sdim return Importer.MapImported(D, FoundMethod); 4092204643Srdivacky } 4093204643Srdivacky } 4094204643Srdivacky 4095344779Sdim SourceLocation ToEndLoc; 4096344779Sdim QualType ToReturnType; 4097344779Sdim TypeSourceInfo *ToReturnTypeSourceInfo; 4098344779Sdim if (auto Imp = importSeq( 4099344779Sdim D->getEndLoc(), D->getReturnType(), D->getReturnTypeSourceInfo())) 4100344779Sdim std::tie(ToEndLoc, ToReturnType, ToReturnTypeSourceInfo) = *Imp; 4101344779Sdim else 4102344779Sdim return Imp.takeError(); 4103204643Srdivacky 4104341825Sdim ObjCMethodDecl *ToMethod; 4105341825Sdim if (GetImportedOrCreateDecl( 4106360784Sdim ToMethod, D, Importer.getToContext(), Loc, ToEndLoc, 4107360784Sdim Name.getObjCSelector(), ToReturnType, ToReturnTypeSourceInfo, DC, 4108360784Sdim D->isInstanceMethod(), D->isVariadic(), D->isPropertyAccessor(), 4109360784Sdim D->isSynthesizedAccessorStub(), D->isImplicit(), D->isDefined(), 4110341825Sdim D->getImplementationControl(), D->hasRelatedResultType())) 4111341825Sdim return ToMethod; 4112204643Srdivacky 4113204643Srdivacky // FIXME: When we decide to merge method definitions, we'll need to 4114204643Srdivacky // deal with implicit parameters. 4115204643Srdivacky 4116204643Srdivacky // Import the parameters 4117226633Sdim SmallVector<ParmVarDecl *, 5> ToParams; 4118309124Sdim for (auto *FromP : D->parameters()) { 4119344779Sdim if (Expected<ParmVarDecl *> ToPOrErr = import(FromP)) 4120344779Sdim ToParams.push_back(*ToPOrErr); 4121344779Sdim else 4122344779Sdim return ToPOrErr.takeError(); 4123204643Srdivacky } 4124341825Sdim 4125204643Srdivacky // Set the parameters. 4126341825Sdim for (auto *ToParam : ToParams) { 4127341825Sdim ToParam->setOwningFunction(ToMethod); 4128341825Sdim ToMethod->addDeclInternal(ToParam); 4129204643Srdivacky } 4130341825Sdim 4131344779Sdim SmallVector<SourceLocation, 12> FromSelLocs; 4132344779Sdim D->getSelectorLocs(FromSelLocs); 4133344779Sdim SmallVector<SourceLocation, 12> ToSelLocs(FromSelLocs.size()); 4134344779Sdim if (Error Err = ImportContainerChecked(FromSelLocs, ToSelLocs)) 4135344779Sdim return std::move(Err); 4136204643Srdivacky 4137344779Sdim ToMethod->setMethodParams(Importer.getToContext(), ToParams, ToSelLocs); 4138341825Sdim 4139204643Srdivacky ToMethod->setLexicalDeclContext(LexicalDC); 4140234353Sdim LexicalDC->addDeclInternal(ToMethod); 4141360784Sdim 4142360784Sdim // Implicit params are declared when Sema encounters the definition but this 4143360784Sdim // never happens when the method is imported. Manually declare the implicit 4144360784Sdim // params now that the MethodDecl knows its class interface. 4145360784Sdim if (D->getSelfDecl()) 4146360784Sdim ToMethod->createImplicitParams(Importer.getToContext(), 4147360784Sdim ToMethod->getClassInterface()); 4148360784Sdim 4149204643Srdivacky return ToMethod; 4150204643Srdivacky} 4151204643Srdivacky 4152344779SdimExpectedDecl ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 4153288943Sdim // Import the major distinguishing characteristics of a category. 4154288943Sdim DeclContext *DC, *LexicalDC; 4155288943Sdim DeclarationName Name; 4156288943Sdim SourceLocation Loc; 4157288943Sdim NamedDecl *ToD; 4158344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4159344779Sdim return std::move(Err); 4160288943Sdim if (ToD) 4161288943Sdim return ToD; 4162288943Sdim 4163344779Sdim SourceLocation ToVarianceLoc, ToLocation, ToColonLoc; 4164344779Sdim TypeSourceInfo *ToTypeSourceInfo; 4165344779Sdim if (auto Imp = importSeq( 4166344779Sdim D->getVarianceLoc(), D->getLocation(), D->getColonLoc(), 4167344779Sdim D->getTypeSourceInfo())) 4168344779Sdim std::tie(ToVarianceLoc, ToLocation, ToColonLoc, ToTypeSourceInfo) = *Imp; 4169344779Sdim else 4170344779Sdim return Imp.takeError(); 4171288943Sdim 4172341825Sdim ObjCTypeParamDecl *Result; 4173341825Sdim if (GetImportedOrCreateDecl( 4174341825Sdim Result, D, Importer.getToContext(), DC, D->getVariance(), 4175344779Sdim ToVarianceLoc, D->getIndex(), 4176344779Sdim ToLocation, Name.getAsIdentifierInfo(), 4177344779Sdim ToColonLoc, ToTypeSourceInfo)) 4178341825Sdim return Result; 4179341825Sdim 4180288943Sdim Result->setLexicalDeclContext(LexicalDC); 4181288943Sdim return Result; 4182288943Sdim} 4183288943Sdim 4184344779SdimExpectedDecl ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 4185204643Srdivacky // Import the major distinguishing characteristics of a category. 4186204643Srdivacky DeclContext *DC, *LexicalDC; 4187204643Srdivacky DeclarationName Name; 4188204643Srdivacky SourceLocation Loc; 4189288943Sdim NamedDecl *ToD; 4190344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4191344779Sdim return std::move(Err); 4192288943Sdim if (ToD) 4193288943Sdim return ToD; 4194276479Sdim 4195344779Sdim ObjCInterfaceDecl *ToInterface; 4196344779Sdim if (Error Err = importInto(ToInterface, D->getClassInterface())) 4197344779Sdim return std::move(Err); 4198276479Sdim 4199204643Srdivacky // Determine if we've already encountered this category. 4200204643Srdivacky ObjCCategoryDecl *MergeWithCategory 4201204643Srdivacky = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 4202204643Srdivacky ObjCCategoryDecl *ToCategory = MergeWithCategory; 4203204643Srdivacky if (!ToCategory) { 4204344779Sdim SourceLocation ToAtStartLoc, ToCategoryNameLoc; 4205344779Sdim SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc; 4206344779Sdim if (auto Imp = importSeq( 4207344779Sdim D->getAtStartLoc(), D->getCategoryNameLoc(), 4208344779Sdim D->getIvarLBraceLoc(), D->getIvarRBraceLoc())) 4209344779Sdim std::tie( 4210344779Sdim ToAtStartLoc, ToCategoryNameLoc, 4211344779Sdim ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp; 4212344779Sdim else 4213344779Sdim return Imp.takeError(); 4214341825Sdim 4215341825Sdim if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC, 4216344779Sdim ToAtStartLoc, Loc, 4217344779Sdim ToCategoryNameLoc, 4218341825Sdim Name.getAsIdentifierInfo(), ToInterface, 4219341825Sdim /*TypeParamList=*/nullptr, 4220344779Sdim ToIvarLBraceLoc, 4221344779Sdim ToIvarRBraceLoc)) 4222341825Sdim return ToCategory; 4223341825Sdim 4224204643Srdivacky ToCategory->setLexicalDeclContext(LexicalDC); 4225234353Sdim LexicalDC->addDeclInternal(ToCategory); 4226344779Sdim // Import the type parameter list after MapImported, to avoid 4227288943Sdim // loops when bringing in their DeclContext. 4228344779Sdim if (auto PListOrErr = ImportObjCTypeParamList(D->getTypeParamList())) 4229344779Sdim ToCategory->setTypeParamList(*PListOrErr); 4230344779Sdim else 4231344779Sdim return PListOrErr.takeError(); 4232341825Sdim 4233204643Srdivacky // Import protocols 4234226633Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4235226633Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4236204643Srdivacky ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 4237204643Srdivacky = D->protocol_loc_begin(); 4238204643Srdivacky for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 4239204643Srdivacky FromProtoEnd = D->protocol_end(); 4240204643Srdivacky FromProto != FromProtoEnd; 4241204643Srdivacky ++FromProto, ++FromProtoLoc) { 4242344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4243344779Sdim Protocols.push_back(*ToProtoOrErr); 4244344779Sdim else 4245344779Sdim return ToProtoOrErr.takeError(); 4246344779Sdim 4247344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4248344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4249344779Sdim else 4250344779Sdim return ToProtoLocOrErr.takeError(); 4251204643Srdivacky } 4252341825Sdim 4253204643Srdivacky // FIXME: If we're merging, make sure that the protocol list is the same. 4254204643Srdivacky ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 4255204643Srdivacky ProtocolLocs.data(), Importer.getToContext()); 4256344779Sdim 4257204643Srdivacky } else { 4258341825Sdim Importer.MapImported(D, ToCategory); 4259204643Srdivacky } 4260341825Sdim 4261204643Srdivacky // Import all of the members of this category. 4262344779Sdim if (Error Err = ImportDeclContext(D)) 4263344779Sdim return std::move(Err); 4264341825Sdim 4265204643Srdivacky // If we have an implementation, import it as well. 4266204643Srdivacky if (D->getImplementation()) { 4267344779Sdim if (Expected<ObjCCategoryImplDecl *> ToImplOrErr = 4268344779Sdim import(D->getImplementation())) 4269344779Sdim ToCategory->setImplementation(*ToImplOrErr); 4270344779Sdim else 4271344779Sdim return ToImplOrErr.takeError(); 4272204643Srdivacky } 4273341825Sdim 4274204643Srdivacky return ToCategory; 4275204643Srdivacky} 4276204643Srdivacky 4277344779SdimError ASTNodeImporter::ImportDefinition( 4278344779Sdim ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) { 4279234353Sdim if (To->getDefinition()) { 4280234353Sdim if (shouldForceImportDeclContext(Kind)) 4281344779Sdim if (Error Err = ImportDeclContext(From)) 4282344779Sdim return Err; 4283344779Sdim return Error::success(); 4284234353Sdim } 4285234353Sdim 4286234353Sdim // Start the protocol definition 4287234353Sdim To->startDefinition(); 4288341825Sdim 4289234353Sdim // Import protocols 4290234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4291234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4292344779Sdim ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc = 4293344779Sdim From->protocol_loc_begin(); 4294234353Sdim for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 4295234353Sdim FromProtoEnd = From->protocol_end(); 4296234353Sdim FromProto != FromProtoEnd; 4297234353Sdim ++FromProto, ++FromProtoLoc) { 4298344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4299344779Sdim Protocols.push_back(*ToProtoOrErr); 4300344779Sdim else 4301344779Sdim return ToProtoOrErr.takeError(); 4302344779Sdim 4303344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4304344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4305344779Sdim else 4306344779Sdim return ToProtoLocOrErr.takeError(); 4307344779Sdim 4308234353Sdim } 4309341825Sdim 4310234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 4311234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 4312234353Sdim ProtocolLocs.data(), Importer.getToContext()); 4313234353Sdim 4314234353Sdim if (shouldForceImportDeclContext(Kind)) { 4315234353Sdim // Import all of the members of this protocol. 4316344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 4317344779Sdim return Err; 4318234353Sdim } 4319344779Sdim return Error::success(); 4320234353Sdim} 4321234353Sdim 4322344779SdimExpectedDecl ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 4323341825Sdim // If this protocol has a definition in the translation unit we're coming 4324234353Sdim // from, but this particular declaration is not that definition, import the 4325234353Sdim // definition and map to that. 4326234353Sdim ObjCProtocolDecl *Definition = D->getDefinition(); 4327234353Sdim if (Definition && Definition != D) { 4328344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 4329344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 4330344779Sdim else 4331344779Sdim return ImportedDefOrErr.takeError(); 4332234353Sdim } 4333234353Sdim 4334204643Srdivacky // Import the major distinguishing characteristics of a protocol. 4335204643Srdivacky DeclContext *DC, *LexicalDC; 4336204643Srdivacky DeclarationName Name; 4337204643Srdivacky SourceLocation Loc; 4338288943Sdim NamedDecl *ToD; 4339344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4340344779Sdim return std::move(Err); 4341288943Sdim if (ToD) 4342288943Sdim return ToD; 4343204643Srdivacky 4344276479Sdim ObjCProtocolDecl *MergeWithProtocol = nullptr; 4345344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4346341825Sdim for (auto *FoundDecl : FoundDecls) { 4347341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 4348204643Srdivacky continue; 4349341825Sdim 4350341825Sdim if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl))) 4351204643Srdivacky break; 4352204643Srdivacky } 4353341825Sdim 4354204643Srdivacky ObjCProtocolDecl *ToProto = MergeWithProtocol; 4355234353Sdim if (!ToProto) { 4356344779Sdim auto ToAtBeginLocOrErr = import(D->getAtStartLoc()); 4357344779Sdim if (!ToAtBeginLocOrErr) 4358344779Sdim return ToAtBeginLocOrErr.takeError(); 4359344779Sdim 4360341825Sdim if (GetImportedOrCreateDecl(ToProto, D, Importer.getToContext(), DC, 4361341825Sdim Name.getAsIdentifierInfo(), Loc, 4362344779Sdim *ToAtBeginLocOrErr, 4363341825Sdim /*PrevDecl=*/nullptr)) 4364341825Sdim return ToProto; 4365234353Sdim ToProto->setLexicalDeclContext(LexicalDC); 4366234353Sdim LexicalDC->addDeclInternal(ToProto); 4367234353Sdim } 4368234353Sdim 4369341825Sdim Importer.MapImported(D, ToProto); 4370341825Sdim 4371344779Sdim if (D->isThisDeclarationADefinition()) 4372344779Sdim if (Error Err = ImportDefinition(D, ToProto)) 4373344779Sdim return std::move(Err); 4374276479Sdim 4375234353Sdim return ToProto; 4376234353Sdim} 4377234353Sdim 4378344779SdimExpectedDecl ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 4379344779Sdim DeclContext *DC, *LexicalDC; 4380344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4381344779Sdim return std::move(Err); 4382280031Sdim 4383344779Sdim ExpectedSLoc ExternLocOrErr = import(D->getExternLoc()); 4384344779Sdim if (!ExternLocOrErr) 4385344779Sdim return ExternLocOrErr.takeError(); 4386280031Sdim 4387344779Sdim ExpectedSLoc LangLocOrErr = import(D->getLocation()); 4388344779Sdim if (!LangLocOrErr) 4389344779Sdim return LangLocOrErr.takeError(); 4390344779Sdim 4391280031Sdim bool HasBraces = D->hasBraces(); 4392280031Sdim 4393341825Sdim LinkageSpecDecl *ToLinkageSpec; 4394341825Sdim if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC, 4395344779Sdim *ExternLocOrErr, *LangLocOrErr, 4396344779Sdim D->getLanguage(), HasBraces)) 4397341825Sdim return ToLinkageSpec; 4398341825Sdim 4399280031Sdim if (HasBraces) { 4400344779Sdim ExpectedSLoc RBraceLocOrErr = import(D->getRBraceLoc()); 4401344779Sdim if (!RBraceLocOrErr) 4402344779Sdim return RBraceLocOrErr.takeError(); 4403344779Sdim ToLinkageSpec->setRBraceLoc(*RBraceLocOrErr); 4404280031Sdim } 4405280031Sdim 4406280031Sdim ToLinkageSpec->setLexicalDeclContext(LexicalDC); 4407280031Sdim LexicalDC->addDeclInternal(ToLinkageSpec); 4408280031Sdim 4409280031Sdim return ToLinkageSpec; 4410280031Sdim} 4411280031Sdim 4412344779SdimExpectedDecl ASTNodeImporter::VisitUsingDecl(UsingDecl *D) { 4413327952Sdim DeclContext *DC, *LexicalDC; 4414327952Sdim DeclarationName Name; 4415327952Sdim SourceLocation Loc; 4416327952Sdim NamedDecl *ToD = nullptr; 4417344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4418344779Sdim return std::move(Err); 4419327952Sdim if (ToD) 4420327952Sdim return ToD; 4421327952Sdim 4422344779Sdim SourceLocation ToLoc, ToUsingLoc; 4423344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4424344779Sdim if (auto Imp = importSeq( 4425344779Sdim D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc())) 4426344779Sdim std::tie(ToLoc, ToUsingLoc, ToQualifierLoc) = *Imp; 4427344779Sdim else 4428344779Sdim return Imp.takeError(); 4429327952Sdim 4430344779Sdim DeclarationNameInfo NameInfo(Name, ToLoc); 4431344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 4432344779Sdim return std::move(Err); 4433344779Sdim 4434341825Sdim UsingDecl *ToUsing; 4435341825Sdim if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC, 4436344779Sdim ToUsingLoc, ToQualifierLoc, NameInfo, 4437341825Sdim D->hasTypename())) 4438341825Sdim return ToUsing; 4439341825Sdim 4440327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 4441327952Sdim LexicalDC->addDeclInternal(ToUsing); 4442327952Sdim 4443327952Sdim if (NamedDecl *FromPattern = 4444327952Sdim Importer.getFromContext().getInstantiatedFromUsingDecl(D)) { 4445344779Sdim if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern)) 4446344779Sdim Importer.getToContext().setInstantiatedFromUsingDecl( 4447344779Sdim ToUsing, *ToPatternOrErr); 4448327952Sdim else 4449344779Sdim return ToPatternOrErr.takeError(); 4450327952Sdim } 4451327952Sdim 4452344779Sdim for (UsingShadowDecl *FromShadow : D->shadows()) { 4453344779Sdim if (Expected<UsingShadowDecl *> ToShadowOrErr = import(FromShadow)) 4454344779Sdim ToUsing->addShadowDecl(*ToShadowOrErr); 4455327952Sdim else 4456344779Sdim // FIXME: We return error here but the definition is already created 4457327952Sdim // and available with lookups. How to fix this?.. 4458344779Sdim return ToShadowOrErr.takeError(); 4459327952Sdim } 4460327952Sdim return ToUsing; 4461327952Sdim} 4462327952Sdim 4463344779SdimExpectedDecl ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) { 4464327952Sdim DeclContext *DC, *LexicalDC; 4465327952Sdim DeclarationName Name; 4466327952Sdim SourceLocation Loc; 4467327952Sdim NamedDecl *ToD = nullptr; 4468344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4469344779Sdim return std::move(Err); 4470327952Sdim if (ToD) 4471327952Sdim return ToD; 4472327952Sdim 4473344779Sdim Expected<UsingDecl *> ToUsingOrErr = import(D->getUsingDecl()); 4474344779Sdim if (!ToUsingOrErr) 4475344779Sdim return ToUsingOrErr.takeError(); 4476327952Sdim 4477344779Sdim Expected<NamedDecl *> ToTargetOrErr = import(D->getTargetDecl()); 4478344779Sdim if (!ToTargetOrErr) 4479344779Sdim return ToTargetOrErr.takeError(); 4480327952Sdim 4481341825Sdim UsingShadowDecl *ToShadow; 4482341825Sdim if (GetImportedOrCreateDecl(ToShadow, D, Importer.getToContext(), DC, Loc, 4483344779Sdim *ToUsingOrErr, *ToTargetOrErr)) 4484341825Sdim return ToShadow; 4485327952Sdim 4486327952Sdim ToShadow->setLexicalDeclContext(LexicalDC); 4487327952Sdim ToShadow->setAccess(D->getAccess()); 4488327952Sdim 4489327952Sdim if (UsingShadowDecl *FromPattern = 4490327952Sdim Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) { 4491344779Sdim if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern)) 4492344779Sdim Importer.getToContext().setInstantiatedFromUsingShadowDecl( 4493344779Sdim ToShadow, *ToPatternOrErr); 4494327952Sdim else 4495344779Sdim // FIXME: We return error here but the definition is already created 4496327952Sdim // and available with lookups. How to fix this?.. 4497344779Sdim return ToPatternOrErr.takeError(); 4498327952Sdim } 4499327952Sdim 4500327952Sdim LexicalDC->addDeclInternal(ToShadow); 4501327952Sdim 4502327952Sdim return ToShadow; 4503327952Sdim} 4504327952Sdim 4505344779SdimExpectedDecl ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 4506327952Sdim DeclContext *DC, *LexicalDC; 4507327952Sdim DeclarationName Name; 4508327952Sdim SourceLocation Loc; 4509327952Sdim NamedDecl *ToD = nullptr; 4510344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4511344779Sdim return std::move(Err); 4512327952Sdim if (ToD) 4513327952Sdim return ToD; 4514327952Sdim 4515344779Sdim auto ToComAncestorOrErr = Importer.ImportContext(D->getCommonAncestor()); 4516344779Sdim if (!ToComAncestorOrErr) 4517344779Sdim return ToComAncestorOrErr.takeError(); 4518327952Sdim 4519344779Sdim NamespaceDecl *ToNominatedNamespace; 4520344779Sdim SourceLocation ToUsingLoc, ToNamespaceKeyLocation, ToIdentLocation; 4521344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4522344779Sdim if (auto Imp = importSeq( 4523344779Sdim D->getNominatedNamespace(), D->getUsingLoc(), 4524344779Sdim D->getNamespaceKeyLocation(), D->getQualifierLoc(), 4525344779Sdim D->getIdentLocation())) 4526344779Sdim std::tie( 4527344779Sdim ToNominatedNamespace, ToUsingLoc, ToNamespaceKeyLocation, 4528344779Sdim ToQualifierLoc, ToIdentLocation) = *Imp; 4529344779Sdim else 4530344779Sdim return Imp.takeError(); 4531327952Sdim 4532341825Sdim UsingDirectiveDecl *ToUsingDir; 4533341825Sdim if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC, 4534344779Sdim ToUsingLoc, 4535344779Sdim ToNamespaceKeyLocation, 4536344779Sdim ToQualifierLoc, 4537344779Sdim ToIdentLocation, 4538344779Sdim ToNominatedNamespace, *ToComAncestorOrErr)) 4539341825Sdim return ToUsingDir; 4540341825Sdim 4541327952Sdim ToUsingDir->setLexicalDeclContext(LexicalDC); 4542327952Sdim LexicalDC->addDeclInternal(ToUsingDir); 4543327952Sdim 4544327952Sdim return ToUsingDir; 4545327952Sdim} 4546327952Sdim 4547344779SdimExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl( 4548327952Sdim UnresolvedUsingValueDecl *D) { 4549327952Sdim DeclContext *DC, *LexicalDC; 4550327952Sdim DeclarationName Name; 4551327952Sdim SourceLocation Loc; 4552327952Sdim NamedDecl *ToD = nullptr; 4553344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4554344779Sdim return std::move(Err); 4555327952Sdim if (ToD) 4556327952Sdim return ToD; 4557327952Sdim 4558344779Sdim SourceLocation ToLoc, ToUsingLoc, ToEllipsisLoc; 4559344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4560344779Sdim if (auto Imp = importSeq( 4561344779Sdim D->getNameInfo().getLoc(), D->getUsingLoc(), D->getQualifierLoc(), 4562344779Sdim D->getEllipsisLoc())) 4563344779Sdim std::tie(ToLoc, ToUsingLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp; 4564344779Sdim else 4565344779Sdim return Imp.takeError(); 4566327952Sdim 4567344779Sdim DeclarationNameInfo NameInfo(Name, ToLoc); 4568344779Sdim if (Error Err = ImportDeclarationNameLoc(D->getNameInfo(), NameInfo)) 4569344779Sdim return std::move(Err); 4570344779Sdim 4571341825Sdim UnresolvedUsingValueDecl *ToUsingValue; 4572341825Sdim if (GetImportedOrCreateDecl(ToUsingValue, D, Importer.getToContext(), DC, 4573344779Sdim ToUsingLoc, ToQualifierLoc, NameInfo, 4574344779Sdim ToEllipsisLoc)) 4575341825Sdim return ToUsingValue; 4576327952Sdim 4577327952Sdim ToUsingValue->setAccess(D->getAccess()); 4578327952Sdim ToUsingValue->setLexicalDeclContext(LexicalDC); 4579327952Sdim LexicalDC->addDeclInternal(ToUsingValue); 4580327952Sdim 4581327952Sdim return ToUsingValue; 4582327952Sdim} 4583327952Sdim 4584344779SdimExpectedDecl ASTNodeImporter::VisitUnresolvedUsingTypenameDecl( 4585327952Sdim UnresolvedUsingTypenameDecl *D) { 4586327952Sdim DeclContext *DC, *LexicalDC; 4587327952Sdim DeclarationName Name; 4588327952Sdim SourceLocation Loc; 4589327952Sdim NamedDecl *ToD = nullptr; 4590344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4591344779Sdim return std::move(Err); 4592327952Sdim if (ToD) 4593327952Sdim return ToD; 4594327952Sdim 4595344779Sdim SourceLocation ToUsingLoc, ToTypenameLoc, ToEllipsisLoc; 4596344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 4597344779Sdim if (auto Imp = importSeq( 4598344779Sdim D->getUsingLoc(), D->getTypenameLoc(), D->getQualifierLoc(), 4599344779Sdim D->getEllipsisLoc())) 4600344779Sdim std::tie(ToUsingLoc, ToTypenameLoc, ToQualifierLoc, ToEllipsisLoc) = *Imp; 4601344779Sdim else 4602344779Sdim return Imp.takeError(); 4603344779Sdim 4604341825Sdim UnresolvedUsingTypenameDecl *ToUsing; 4605341825Sdim if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC, 4606344779Sdim ToUsingLoc, ToTypenameLoc, 4607344779Sdim ToQualifierLoc, Loc, Name, ToEllipsisLoc)) 4608341825Sdim return ToUsing; 4609327952Sdim 4610327952Sdim ToUsing->setAccess(D->getAccess()); 4611327952Sdim ToUsing->setLexicalDeclContext(LexicalDC); 4612327952Sdim LexicalDC->addDeclInternal(ToUsing); 4613327952Sdim 4614327952Sdim return ToUsing; 4615327952Sdim} 4616327952Sdim 4617360784SdimExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) { 4618360784Sdim Decl* ToD = nullptr; 4619360784Sdim switch (D->getBuiltinTemplateKind()) { 4620360784Sdim case BuiltinTemplateKind::BTK__make_integer_seq: 4621360784Sdim ToD = Importer.getToContext().getMakeIntegerSeqDecl(); 4622360784Sdim break; 4623360784Sdim case BuiltinTemplateKind::BTK__type_pack_element: 4624360784Sdim ToD = Importer.getToContext().getTypePackElementDecl(); 4625360784Sdim break; 4626360784Sdim } 4627360784Sdim assert(ToD && "BuiltinTemplateDecl of unsupported kind!"); 4628360784Sdim Importer.MapImported(D, ToD); 4629360784Sdim return ToD; 4630360784Sdim} 4631344779Sdim 4632344779SdimError ASTNodeImporter::ImportDefinition( 4633344779Sdim ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) { 4634234353Sdim if (To->getDefinition()) { 4635234353Sdim // Check consistency of superclass. 4636234353Sdim ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 4637234353Sdim if (FromSuper) { 4638344779Sdim if (auto FromSuperOrErr = import(FromSuper)) 4639344779Sdim FromSuper = *FromSuperOrErr; 4640344779Sdim else 4641344779Sdim return FromSuperOrErr.takeError(); 4642204643Srdivacky } 4643341825Sdim 4644341825Sdim ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 4645234353Sdim if ((bool)FromSuper != (bool)ToSuper || 4646234353Sdim (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 4647341825Sdim Importer.ToDiag(To->getLocation(), 4648353358Sdim diag::warn_odr_objc_superclass_inconsistent) 4649234353Sdim << To->getDeclName(); 4650234353Sdim if (ToSuper) 4651234353Sdim Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 4652234353Sdim << To->getSuperClass()->getDeclName(); 4653234353Sdim else 4654341825Sdim Importer.ToDiag(To->getLocation(), 4655234353Sdim diag::note_odr_objc_missing_superclass); 4656234353Sdim if (From->getSuperClass()) 4657341825Sdim Importer.FromDiag(From->getSuperClassLoc(), 4658234353Sdim diag::note_odr_objc_superclass) 4659234353Sdim << From->getSuperClass()->getDeclName(); 4660234353Sdim else 4661341825Sdim Importer.FromDiag(From->getLocation(), 4662341825Sdim diag::note_odr_objc_missing_superclass); 4663234353Sdim } 4664341825Sdim 4665234353Sdim if (shouldForceImportDeclContext(Kind)) 4666344779Sdim if (Error Err = ImportDeclContext(From)) 4667344779Sdim return Err; 4668344779Sdim return Error::success(); 4669234353Sdim } 4670341825Sdim 4671234353Sdim // Start the definition. 4672234353Sdim To->startDefinition(); 4673341825Sdim 4674234353Sdim // If this class has a superclass, import it. 4675234353Sdim if (From->getSuperClass()) { 4676344779Sdim if (auto SuperTInfoOrErr = import(From->getSuperClassTInfo())) 4677344779Sdim To->setSuperClass(*SuperTInfoOrErr); 4678344779Sdim else 4679344779Sdim return SuperTInfoOrErr.takeError(); 4680234353Sdim } 4681341825Sdim 4682234353Sdim // Import protocols 4683234353Sdim SmallVector<ObjCProtocolDecl *, 4> Protocols; 4684234353Sdim SmallVector<SourceLocation, 4> ProtocolLocs; 4685344779Sdim ObjCInterfaceDecl::protocol_loc_iterator FromProtoLoc = 4686344779Sdim From->protocol_loc_begin(); 4687341825Sdim 4688234353Sdim for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 4689234353Sdim FromProtoEnd = From->protocol_end(); 4690204643Srdivacky FromProto != FromProtoEnd; 4691204643Srdivacky ++FromProto, ++FromProtoLoc) { 4692344779Sdim if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto)) 4693344779Sdim Protocols.push_back(*ToProtoOrErr); 4694344779Sdim else 4695344779Sdim return ToProtoOrErr.takeError(); 4696344779Sdim 4697344779Sdim if (ExpectedSLoc ToProtoLocOrErr = import(*FromProtoLoc)) 4698344779Sdim ProtocolLocs.push_back(*ToProtoLocOrErr); 4699344779Sdim else 4700344779Sdim return ToProtoLocOrErr.takeError(); 4701344779Sdim 4702234353Sdim } 4703341825Sdim 4704234353Sdim // FIXME: If we're merging, make sure that the protocol list is the same. 4705234353Sdim To->setProtocolList(Protocols.data(), Protocols.size(), 4706234353Sdim ProtocolLocs.data(), Importer.getToContext()); 4707341825Sdim 4708234353Sdim // Import categories. When the categories themselves are imported, they'll 4709234353Sdim // hook themselves into this interface. 4710344779Sdim for (auto *Cat : From->known_categories()) { 4711344779Sdim auto ToCatOrErr = import(Cat); 4712344779Sdim if (!ToCatOrErr) 4713344779Sdim return ToCatOrErr.takeError(); 4714344779Sdim } 4715341825Sdim 4716234353Sdim // If we have an @implementation, import it as well. 4717234353Sdim if (From->getImplementation()) { 4718344779Sdim if (Expected<ObjCImplementationDecl *> ToImplOrErr = 4719344779Sdim import(From->getImplementation())) 4720344779Sdim To->setImplementation(*ToImplOrErr); 4721344779Sdim else 4722344779Sdim return ToImplOrErr.takeError(); 4723204643Srdivacky } 4724204643Srdivacky 4725234353Sdim if (shouldForceImportDeclContext(Kind)) { 4726234353Sdim // Import all of the members of this class. 4727344779Sdim if (Error Err = ImportDeclContext(From, /*ForceImport=*/true)) 4728344779Sdim return Err; 4729234353Sdim } 4730344779Sdim return Error::success(); 4731204643Srdivacky} 4732204643Srdivacky 4733344779SdimExpected<ObjCTypeParamList *> 4734288943SdimASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 4735288943Sdim if (!list) 4736288943Sdim return nullptr; 4737288943Sdim 4738288943Sdim SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 4739344779Sdim for (auto *fromTypeParam : *list) { 4740344779Sdim if (auto toTypeParamOrErr = import(fromTypeParam)) 4741344779Sdim toTypeParams.push_back(*toTypeParamOrErr); 4742344779Sdim else 4743344779Sdim return toTypeParamOrErr.takeError(); 4744288943Sdim } 4745288943Sdim 4746344779Sdim auto LAngleLocOrErr = import(list->getLAngleLoc()); 4747344779Sdim if (!LAngleLocOrErr) 4748344779Sdim return LAngleLocOrErr.takeError(); 4749344779Sdim 4750344779Sdim auto RAngleLocOrErr = import(list->getRAngleLoc()); 4751344779Sdim if (!RAngleLocOrErr) 4752344779Sdim return RAngleLocOrErr.takeError(); 4753344779Sdim 4754288943Sdim return ObjCTypeParamList::create(Importer.getToContext(), 4755344779Sdim *LAngleLocOrErr, 4756288943Sdim toTypeParams, 4757344779Sdim *RAngleLocOrErr); 4758288943Sdim} 4759288943Sdim 4760344779SdimExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 4761234353Sdim // If this class has a definition in the translation unit we're coming from, 4762234353Sdim // but this particular declaration is not that definition, import the 4763234353Sdim // definition and map to that. 4764234353Sdim ObjCInterfaceDecl *Definition = D->getDefinition(); 4765234353Sdim if (Definition && Definition != D) { 4766344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 4767344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 4768344779Sdim else 4769344779Sdim return ImportedDefOrErr.takeError(); 4770234353Sdim } 4771234353Sdim 4772203955Srdivacky // Import the major distinguishing characteristics of an @interface. 4773203955Srdivacky DeclContext *DC, *LexicalDC; 4774203955Srdivacky DeclarationName Name; 4775203955Srdivacky SourceLocation Loc; 4776288943Sdim NamedDecl *ToD; 4777344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4778344779Sdim return std::move(Err); 4779288943Sdim if (ToD) 4780288943Sdim return ToD; 4781203955Srdivacky 4782234353Sdim // Look for an existing interface with the same name. 4783276479Sdim ObjCInterfaceDecl *MergeWithIface = nullptr; 4784344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4785341825Sdim for (auto *FoundDecl : FoundDecls) { 4786341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4787203955Srdivacky continue; 4788341825Sdim 4789341825Sdim if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl))) 4790203955Srdivacky break; 4791203955Srdivacky } 4792341825Sdim 4793234353Sdim // Create an interface declaration, if one does not already exist. 4794203955Srdivacky ObjCInterfaceDecl *ToIface = MergeWithIface; 4795234353Sdim if (!ToIface) { 4796344779Sdim ExpectedSLoc AtBeginLocOrErr = import(D->getAtStartLoc()); 4797344779Sdim if (!AtBeginLocOrErr) 4798344779Sdim return AtBeginLocOrErr.takeError(); 4799344779Sdim 4800341825Sdim if (GetImportedOrCreateDecl( 4801341825Sdim ToIface, D, Importer.getToContext(), DC, 4802344779Sdim *AtBeginLocOrErr, Name.getAsIdentifierInfo(), 4803341825Sdim /*TypeParamList=*/nullptr, 4804341825Sdim /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl())) 4805341825Sdim return ToIface; 4806234353Sdim ToIface->setLexicalDeclContext(LexicalDC); 4807234353Sdim LexicalDC->addDeclInternal(ToIface); 4808203955Srdivacky } 4809341825Sdim Importer.MapImported(D, ToIface); 4810344779Sdim // Import the type parameter list after MapImported, to avoid 4811288943Sdim // loops when bringing in their DeclContext. 4812344779Sdim if (auto ToPListOrErr = 4813344779Sdim ImportObjCTypeParamList(D->getTypeParamListAsWritten())) 4814344779Sdim ToIface->setTypeParamList(*ToPListOrErr); 4815344779Sdim else 4816344779Sdim return ToPListOrErr.takeError(); 4817341825Sdim 4818344779Sdim if (D->isThisDeclarationADefinition()) 4819344779Sdim if (Error Err = ImportDefinition(D, ToIface)) 4820344779Sdim return std::move(Err); 4821276479Sdim 4822204643Srdivacky return ToIface; 4823203955Srdivacky} 4824203955Srdivacky 4825344779SdimExpectedDecl 4826344779SdimASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 4827344779Sdim ObjCCategoryDecl *Category; 4828344779Sdim if (Error Err = importInto(Category, D->getCategoryDecl())) 4829344779Sdim return std::move(Err); 4830276479Sdim 4831218893Sdim ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 4832218893Sdim if (!ToImpl) { 4833344779Sdim DeclContext *DC, *LexicalDC; 4834344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4835344779Sdim return std::move(Err); 4836276479Sdim 4837344779Sdim SourceLocation ToLocation, ToAtStartLoc, ToCategoryNameLoc; 4838344779Sdim if (auto Imp = importSeq( 4839344779Sdim D->getLocation(), D->getAtStartLoc(), D->getCategoryNameLoc())) 4840344779Sdim std::tie(ToLocation, ToAtStartLoc, ToCategoryNameLoc) = *Imp; 4841344779Sdim else 4842344779Sdim return Imp.takeError(); 4843344779Sdim 4844341825Sdim if (GetImportedOrCreateDecl( 4845341825Sdim ToImpl, D, Importer.getToContext(), DC, 4846341825Sdim Importer.Import(D->getIdentifier()), Category->getClassInterface(), 4847344779Sdim ToLocation, ToAtStartLoc, ToCategoryNameLoc)) 4848341825Sdim return ToImpl; 4849341825Sdim 4850344779Sdim ToImpl->setLexicalDeclContext(LexicalDC); 4851234353Sdim LexicalDC->addDeclInternal(ToImpl); 4852218893Sdim Category->setImplementation(ToImpl); 4853218893Sdim } 4854341825Sdim 4855341825Sdim Importer.MapImported(D, ToImpl); 4856344779Sdim if (Error Err = ImportDeclContext(D)) 4857344779Sdim return std::move(Err); 4858344779Sdim 4859218893Sdim return ToImpl; 4860218893Sdim} 4861218893Sdim 4862344779SdimExpectedDecl 4863344779SdimASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 4864218893Sdim // Find the corresponding interface. 4865344779Sdim ObjCInterfaceDecl *Iface; 4866344779Sdim if (Error Err = importInto(Iface, D->getClassInterface())) 4867344779Sdim return std::move(Err); 4868218893Sdim 4869218893Sdim // Import the superclass, if any. 4870344779Sdim ObjCInterfaceDecl *Super; 4871344779Sdim if (Error Err = importInto(Super, D->getSuperClass())) 4872344779Sdim return std::move(Err); 4873218893Sdim 4874218893Sdim ObjCImplementationDecl *Impl = Iface->getImplementation(); 4875218893Sdim if (!Impl) { 4876218893Sdim // We haven't imported an implementation yet. Create a new @implementation 4877218893Sdim // now. 4878344779Sdim DeclContext *DC, *LexicalDC; 4879344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 4880344779Sdim return std::move(Err); 4881344779Sdim 4882344779Sdim SourceLocation ToLocation, ToAtStartLoc, ToSuperClassLoc; 4883344779Sdim SourceLocation ToIvarLBraceLoc, ToIvarRBraceLoc; 4884344779Sdim if (auto Imp = importSeq( 4885344779Sdim D->getLocation(), D->getAtStartLoc(), D->getSuperClassLoc(), 4886344779Sdim D->getIvarLBraceLoc(), D->getIvarRBraceLoc())) 4887344779Sdim std::tie( 4888344779Sdim ToLocation, ToAtStartLoc, ToSuperClassLoc, 4889344779Sdim ToIvarLBraceLoc, ToIvarRBraceLoc) = *Imp; 4890344779Sdim else 4891344779Sdim return Imp.takeError(); 4892344779Sdim 4893341825Sdim if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(), 4894344779Sdim DC, Iface, Super, 4895344779Sdim ToLocation, 4896344779Sdim ToAtStartLoc, 4897344779Sdim ToSuperClassLoc, 4898344779Sdim ToIvarLBraceLoc, 4899344779Sdim ToIvarRBraceLoc)) 4900341825Sdim return Impl; 4901341825Sdim 4902344779Sdim Impl->setLexicalDeclContext(LexicalDC); 4903341825Sdim 4904218893Sdim // Associate the implementation with the class it implements. 4905218893Sdim Iface->setImplementation(Impl); 4906341825Sdim Importer.MapImported(D, Iface->getImplementation()); 4907218893Sdim } else { 4908341825Sdim Importer.MapImported(D, Iface->getImplementation()); 4909218893Sdim 4910218893Sdim // Verify that the existing @implementation has the same superclass. 4911218893Sdim if ((Super && !Impl->getSuperClass()) || 4912218893Sdim (!Super && Impl->getSuperClass()) || 4913276479Sdim (Super && Impl->getSuperClass() && 4914276479Sdim !declaresSameEntity(Super->getCanonicalDecl(), 4915276479Sdim Impl->getSuperClass()))) { 4916276479Sdim Importer.ToDiag(Impl->getLocation(), 4917353358Sdim diag::warn_odr_objc_superclass_inconsistent) 4918276479Sdim << Iface->getDeclName(); 4919276479Sdim // FIXME: It would be nice to have the location of the superclass 4920276479Sdim // below. 4921276479Sdim if (Impl->getSuperClass()) 4922276479Sdim Importer.ToDiag(Impl->getLocation(), 4923276479Sdim diag::note_odr_objc_superclass) 4924276479Sdim << Impl->getSuperClass()->getDeclName(); 4925276479Sdim else 4926276479Sdim Importer.ToDiag(Impl->getLocation(), 4927276479Sdim diag::note_odr_objc_missing_superclass); 4928276479Sdim if (D->getSuperClass()) 4929276479Sdim Importer.FromDiag(D->getLocation(), 4930218893Sdim diag::note_odr_objc_superclass) 4931276479Sdim << D->getSuperClass()->getDeclName(); 4932276479Sdim else 4933276479Sdim Importer.FromDiag(D->getLocation(), 4934218893Sdim diag::note_odr_objc_missing_superclass); 4935344779Sdim 4936344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4937218893Sdim } 4938218893Sdim } 4939341825Sdim 4940218893Sdim // Import all of the members of this @implementation. 4941344779Sdim if (Error Err = ImportDeclContext(D)) 4942344779Sdim return std::move(Err); 4943218893Sdim 4944218893Sdim return Impl; 4945218893Sdim} 4946218893Sdim 4947344779SdimExpectedDecl ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 4948204643Srdivacky // Import the major distinguishing characteristics of an @property. 4949204643Srdivacky DeclContext *DC, *LexicalDC; 4950204643Srdivacky DeclarationName Name; 4951204643Srdivacky SourceLocation Loc; 4952288943Sdim NamedDecl *ToD; 4953344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4954344779Sdim return std::move(Err); 4955288943Sdim if (ToD) 4956288943Sdim return ToD; 4957204643Srdivacky 4958204643Srdivacky // Check whether we have already imported this property. 4959344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 4960341825Sdim for (auto *FoundDecl : FoundDecls) { 4961341825Sdim if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) { 4962204643Srdivacky // Check property types. 4963321369Sdim if (!Importer.IsStructurallyEquivalent(D->getType(), 4964204643Srdivacky FoundProp->getType())) { 4965353358Sdim Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent) 4966204643Srdivacky << Name << D->getType() << FoundProp->getType(); 4967204643Srdivacky Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 4968204643Srdivacky << FoundProp->getType(); 4969344779Sdim 4970344779Sdim return make_error<ImportError>(ImportError::NameConflict); 4971204643Srdivacky } 4972204643Srdivacky 4973204643Srdivacky // FIXME: Check property attributes, getters, setters, etc.? 4974204643Srdivacky 4975204643Srdivacky // Consider these properties to be equivalent. 4976341825Sdim Importer.MapImported(D, FoundProp); 4977204643Srdivacky return FoundProp; 4978204643Srdivacky } 4979204643Srdivacky } 4980204643Srdivacky 4981344779Sdim QualType ToType; 4982344779Sdim TypeSourceInfo *ToTypeSourceInfo; 4983344779Sdim SourceLocation ToAtLoc, ToLParenLoc; 4984344779Sdim if (auto Imp = importSeq( 4985344779Sdim D->getType(), D->getTypeSourceInfo(), D->getAtLoc(), D->getLParenLoc())) 4986344779Sdim std::tie(ToType, ToTypeSourceInfo, ToAtLoc, ToLParenLoc) = *Imp; 4987344779Sdim else 4988344779Sdim return Imp.takeError(); 4989204643Srdivacky 4990204643Srdivacky // Create the new property. 4991341825Sdim ObjCPropertyDecl *ToProperty; 4992341825Sdim if (GetImportedOrCreateDecl( 4993341825Sdim ToProperty, D, Importer.getToContext(), DC, Loc, 4994344779Sdim Name.getAsIdentifierInfo(), ToAtLoc, 4995344779Sdim ToLParenLoc, ToType, 4996344779Sdim ToTypeSourceInfo, D->getPropertyImplementation())) 4997341825Sdim return ToProperty; 4998341825Sdim 4999344779Sdim Selector ToGetterName, ToSetterName; 5000344779Sdim SourceLocation ToGetterNameLoc, ToSetterNameLoc; 5001344779Sdim ObjCMethodDecl *ToGetterMethodDecl, *ToSetterMethodDecl; 5002344779Sdim ObjCIvarDecl *ToPropertyIvarDecl; 5003344779Sdim if (auto Imp = importSeq( 5004344779Sdim D->getGetterName(), D->getSetterName(), 5005344779Sdim D->getGetterNameLoc(), D->getSetterNameLoc(), 5006344779Sdim D->getGetterMethodDecl(), D->getSetterMethodDecl(), 5007344779Sdim D->getPropertyIvarDecl())) 5008344779Sdim std::tie( 5009344779Sdim ToGetterName, ToSetterName, 5010344779Sdim ToGetterNameLoc, ToSetterNameLoc, 5011344779Sdim ToGetterMethodDecl, ToSetterMethodDecl, 5012344779Sdim ToPropertyIvarDecl) = *Imp; 5013344779Sdim else 5014344779Sdim return Imp.takeError(); 5015344779Sdim 5016204643Srdivacky ToProperty->setLexicalDeclContext(LexicalDC); 5017234353Sdim LexicalDC->addDeclInternal(ToProperty); 5018204643Srdivacky 5019204643Srdivacky ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 5020210299Sed ToProperty->setPropertyAttributesAsWritten( 5021210299Sed D->getPropertyAttributesAsWritten()); 5022344779Sdim ToProperty->setGetterName(ToGetterName, ToGetterNameLoc); 5023344779Sdim ToProperty->setSetterName(ToSetterName, ToSetterNameLoc); 5024344779Sdim ToProperty->setGetterMethodDecl(ToGetterMethodDecl); 5025344779Sdim ToProperty->setSetterMethodDecl(ToSetterMethodDecl); 5026344779Sdim ToProperty->setPropertyIvarDecl(ToPropertyIvarDecl); 5027204643Srdivacky return ToProperty; 5028204643Srdivacky} 5029204643Srdivacky 5030344779SdimExpectedDecl 5031344779SdimASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 5032344779Sdim ObjCPropertyDecl *Property; 5033344779Sdim if (Error Err = importInto(Property, D->getPropertyDecl())) 5034344779Sdim return std::move(Err); 5035218893Sdim 5036344779Sdim DeclContext *DC, *LexicalDC; 5037344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 5038344779Sdim return std::move(Err); 5039276479Sdim 5040344779Sdim auto *InImpl = cast<ObjCImplDecl>(LexicalDC); 5041218893Sdim 5042218893Sdim // Import the ivar (for an @synthesize). 5043276479Sdim ObjCIvarDecl *Ivar = nullptr; 5044344779Sdim if (Error Err = importInto(Ivar, D->getPropertyIvarDecl())) 5045344779Sdim return std::move(Err); 5046218893Sdim 5047218893Sdim ObjCPropertyImplDecl *ToImpl 5048309124Sdim = InImpl->FindPropertyImplDecl(Property->getIdentifier(), 5049309124Sdim Property->getQueryKind()); 5050341825Sdim if (!ToImpl) { 5051344779Sdim SourceLocation ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc; 5052344779Sdim if (auto Imp = importSeq( 5053344779Sdim D->getBeginLoc(), D->getLocation(), D->getPropertyIvarDeclLoc())) 5054344779Sdim std::tie(ToBeginLoc, ToLocation, ToPropertyIvarDeclLoc) = *Imp; 5055344779Sdim else 5056344779Sdim return Imp.takeError(); 5057344779Sdim 5058341825Sdim if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC, 5059344779Sdim ToBeginLoc, 5060344779Sdim ToLocation, Property, 5061341825Sdim D->getPropertyImplementation(), Ivar, 5062344779Sdim ToPropertyIvarDeclLoc)) 5063341825Sdim return ToImpl; 5064341825Sdim 5065218893Sdim ToImpl->setLexicalDeclContext(LexicalDC); 5066234353Sdim LexicalDC->addDeclInternal(ToImpl); 5067218893Sdim } else { 5068218893Sdim // Check that we have the same kind of property implementation (@synthesize 5069218893Sdim // vs. @dynamic). 5070218893Sdim if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 5071341825Sdim Importer.ToDiag(ToImpl->getLocation(), 5072353358Sdim diag::warn_odr_objc_property_impl_kind_inconsistent) 5073341825Sdim << Property->getDeclName() 5074341825Sdim << (ToImpl->getPropertyImplementation() 5075218893Sdim == ObjCPropertyImplDecl::Dynamic); 5076218893Sdim Importer.FromDiag(D->getLocation(), 5077218893Sdim diag::note_odr_objc_property_impl_kind) 5078218893Sdim << D->getPropertyDecl()->getDeclName() 5079218893Sdim << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 5080344779Sdim 5081344779Sdim return make_error<ImportError>(ImportError::NameConflict); 5082218893Sdim } 5083341825Sdim 5084341825Sdim // For @synthesize, check that we have the same 5085218893Sdim if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 5086218893Sdim Ivar != ToImpl->getPropertyIvarDecl()) { 5087341825Sdim Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 5088353358Sdim diag::warn_odr_objc_synthesize_ivar_inconsistent) 5089218893Sdim << Property->getDeclName() 5090218893Sdim << ToImpl->getPropertyIvarDecl()->getDeclName() 5091218893Sdim << Ivar->getDeclName(); 5092341825Sdim Importer.FromDiag(D->getPropertyIvarDeclLoc(), 5093218893Sdim diag::note_odr_objc_synthesize_ivar_here) 5094218893Sdim << D->getPropertyIvarDecl()->getDeclName(); 5095344779Sdim 5096344779Sdim return make_error<ImportError>(ImportError::NameConflict); 5097218893Sdim } 5098341825Sdim 5099218893Sdim // Merge the existing implementation with the new implementation. 5100341825Sdim Importer.MapImported(D, ToImpl); 5101218893Sdim } 5102341825Sdim 5103218893Sdim return ToImpl; 5104218893Sdim} 5105218893Sdim 5106344779SdimExpectedDecl 5107344779SdimASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 5108218893Sdim // For template arguments, we adopt the translation unit as our declaration 5109218893Sdim // context. This context will be fixed when the actual template declaration 5110218893Sdim // is created. 5111341825Sdim 5112360784Sdim // FIXME: Import default argument and constraint expression. 5113344779Sdim 5114344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 5115344779Sdim if (!BeginLocOrErr) 5116344779Sdim return BeginLocOrErr.takeError(); 5117344779Sdim 5118344779Sdim ExpectedSLoc LocationOrErr = import(D->getLocation()); 5119344779Sdim if (!LocationOrErr) 5120344779Sdim return LocationOrErr.takeError(); 5121344779Sdim 5122341825Sdim TemplateTypeParmDecl *ToD = nullptr; 5123360784Sdim if (GetImportedOrCreateDecl( 5124341825Sdim ToD, D, Importer.getToContext(), 5125341825Sdim Importer.getToContext().getTranslationUnitDecl(), 5126344779Sdim *BeginLocOrErr, *LocationOrErr, 5127341825Sdim D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()), 5128360784Sdim D->wasDeclaredWithTypename(), D->isParameterPack(), 5129360784Sdim D->hasTypeConstraint())) 5130360784Sdim return ToD; 5131360784Sdim 5132360784Sdim // Import the type-constraint 5133360784Sdim if (const TypeConstraint *TC = D->getTypeConstraint()) { 5134360784Sdim NestedNameSpecifierLoc ToNNS; 5135360784Sdim DeclarationName ToName; 5136360784Sdim SourceLocation ToNameLoc; 5137360784Sdim NamedDecl *ToFoundDecl; 5138360784Sdim ConceptDecl *ToNamedConcept; 5139360784Sdim Expr *ToIDC; 5140360784Sdim if (auto Imp = importSeq(TC->getNestedNameSpecifierLoc(), 5141360784Sdim TC->getConceptNameInfo().getName(), TC->getConceptNameInfo().getLoc(), 5142360784Sdim TC->getFoundDecl(), TC->getNamedConcept(), 5143360784Sdim TC->getImmediatelyDeclaredConstraint())) 5144360784Sdim std::tie(ToNNS, ToName, ToNameLoc, ToFoundDecl, ToNamedConcept, 5145360784Sdim ToIDC) = *Imp; 5146360784Sdim else 5147360784Sdim return Imp.takeError(); 5148360784Sdim 5149360784Sdim TemplateArgumentListInfo ToTAInfo; 5150360784Sdim const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten(); 5151360784Sdim if (ASTTemplateArgs) 5152360784Sdim if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs, 5153360784Sdim ToTAInfo)) 5154360784Sdim return std::move(Err); 5155360784Sdim 5156360784Sdim ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc), 5157360784Sdim ToFoundDecl, ToNamedConcept, 5158360784Sdim ASTTemplateArgs ? 5159360784Sdim ASTTemplateArgumentListInfo::Create(Importer.getToContext(), 5160360784Sdim ToTAInfo) : nullptr, 5161360784Sdim ToIDC); 5162360784Sdim } 5163360784Sdim 5164341825Sdim return ToD; 5165218893Sdim} 5166218893Sdim 5167344779SdimExpectedDecl 5168218893SdimASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 5169344779Sdim DeclarationName ToDeclName; 5170344779Sdim SourceLocation ToLocation, ToInnerLocStart; 5171344779Sdim QualType ToType; 5172344779Sdim TypeSourceInfo *ToTypeSourceInfo; 5173344779Sdim if (auto Imp = importSeq( 5174344779Sdim D->getDeclName(), D->getLocation(), D->getType(), D->getTypeSourceInfo(), 5175344779Sdim D->getInnerLocStart())) 5176344779Sdim std::tie( 5177344779Sdim ToDeclName, ToLocation, ToType, ToTypeSourceInfo, 5178344779Sdim ToInnerLocStart) = *Imp; 5179344779Sdim else 5180344779Sdim return Imp.takeError(); 5181276479Sdim 5182218893Sdim // FIXME: Import default argument. 5183341825Sdim 5184341825Sdim NonTypeTemplateParmDecl *ToD = nullptr; 5185341825Sdim (void)GetImportedOrCreateDecl( 5186341825Sdim ToD, D, Importer.getToContext(), 5187341825Sdim Importer.getToContext().getTranslationUnitDecl(), 5188344779Sdim ToInnerLocStart, ToLocation, D->getDepth(), 5189344779Sdim D->getPosition(), ToDeclName.getAsIdentifierInfo(), ToType, 5190344779Sdim D->isParameterPack(), ToTypeSourceInfo); 5191341825Sdim return ToD; 5192218893Sdim} 5193218893Sdim 5194344779SdimExpectedDecl 5195218893SdimASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 5196218893Sdim // Import the name of this declaration. 5197344779Sdim auto NameOrErr = import(D->getDeclName()); 5198344779Sdim if (!NameOrErr) 5199344779Sdim return NameOrErr.takeError(); 5200276479Sdim 5201218893Sdim // Import the location of this declaration. 5202344779Sdim ExpectedSLoc LocationOrErr = import(D->getLocation()); 5203344779Sdim if (!LocationOrErr) 5204344779Sdim return LocationOrErr.takeError(); 5205341825Sdim 5206218893Sdim // Import template parameters. 5207353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 5208344779Sdim if (!TemplateParamsOrErr) 5209344779Sdim return TemplateParamsOrErr.takeError(); 5210276479Sdim 5211218893Sdim // FIXME: Import default argument. 5212341825Sdim 5213341825Sdim TemplateTemplateParmDecl *ToD = nullptr; 5214341825Sdim (void)GetImportedOrCreateDecl( 5215341825Sdim ToD, D, Importer.getToContext(), 5216344779Sdim Importer.getToContext().getTranslationUnitDecl(), *LocationOrErr, 5217344779Sdim D->getDepth(), D->getPosition(), D->isParameterPack(), 5218344779Sdim (*NameOrErr).getAsIdentifierInfo(), 5219344779Sdim *TemplateParamsOrErr); 5220341825Sdim return ToD; 5221218893Sdim} 5222218893Sdim 5223353358Sdim// Returns the definition for a (forward) declaration of a TemplateDecl, if 5224341825Sdim// it has any definition in the redecl chain. 5225353358Sdimtemplate <typename T> static auto getTemplateDefinition(T *D) -> T * { 5226353358Sdim assert(D->getTemplatedDecl() && "Should be called on templates only"); 5227353358Sdim auto *ToTemplatedDef = D->getTemplatedDecl()->getDefinition(); 5228341825Sdim if (!ToTemplatedDef) 5229341825Sdim return nullptr; 5230353358Sdim auto *TemplateWithDef = ToTemplatedDef->getDescribedTemplate(); 5231353358Sdim return cast_or_null<T>(TemplateWithDef); 5232341825Sdim} 5233341825Sdim 5234344779SdimExpectedDecl ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 5235344779Sdim 5236218893Sdim // Import the major distinguishing characteristics of this class template. 5237218893Sdim DeclContext *DC, *LexicalDC; 5238218893Sdim DeclarationName Name; 5239218893Sdim SourceLocation Loc; 5240288943Sdim NamedDecl *ToD; 5241344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 5242344779Sdim return std::move(Err); 5243288943Sdim if (ToD) 5244288943Sdim return ToD; 5245276479Sdim 5246344779Sdim ClassTemplateDecl *FoundByLookup = nullptr; 5247344779Sdim 5248218893Sdim // We may already have a template of the same name; try to find and match it. 5249218893Sdim if (!DC->isFunctionOrMethod()) { 5250226633Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 5251344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5252341825Sdim for (auto *FoundDecl : FoundDecls) { 5253344779Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary | 5254344779Sdim Decl::IDNS_TagFriend)) 5255218893Sdim continue; 5256341825Sdim 5257341825Sdim Decl *Found = FoundDecl; 5258344779Sdim auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found); 5259344779Sdim if (FoundTemplate) { 5260360784Sdim if (!hasSameVisibilityContext(FoundTemplate, D)) 5261360784Sdim continue; 5262341825Sdim 5263344779Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5264353358Sdim ClassTemplateDecl *TemplateWithDef = 5265353358Sdim getTemplateDefinition(FoundTemplate); 5266360784Sdim if (D->isThisDeclarationADefinition() && TemplateWithDef) 5267344779Sdim return Importer.MapImported(D, TemplateWithDef); 5268360784Sdim if (!FoundByLookup) 5269360784Sdim FoundByLookup = FoundTemplate; 5270360784Sdim // Search in all matches because there may be multiple decl chains, 5271360784Sdim // see ASTTests test ImportExistingFriendClassTemplateDef. 5272360784Sdim continue; 5273341825Sdim } 5274360784Sdim ConflictingDecls.push_back(FoundDecl); 5275218893Sdim } 5276218893Sdim } 5277341825Sdim 5278218893Sdim if (!ConflictingDecls.empty()) { 5279360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 5280360784Sdim Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(), 5281360784Sdim ConflictingDecls.size()); 5282360784Sdim if (NameOrErr) 5283360784Sdim Name = NameOrErr.get(); 5284360784Sdim else 5285360784Sdim return NameOrErr.takeError(); 5286218893Sdim } 5287218893Sdim } 5288218893Sdim 5289341825Sdim CXXRecordDecl *FromTemplated = D->getTemplatedDecl(); 5290341825Sdim 5291218893Sdim // Create the declaration that is being templated. 5292344779Sdim CXXRecordDecl *ToTemplated; 5293344779Sdim if (Error Err = importInto(ToTemplated, FromTemplated)) 5294344779Sdim return std::move(Err); 5295309124Sdim 5296218893Sdim // Create the class template declaration itself. 5297353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 5298344779Sdim if (!TemplateParamsOrErr) 5299344779Sdim return TemplateParamsOrErr.takeError(); 5300276479Sdim 5301341825Sdim ClassTemplateDecl *D2; 5302341825Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, Loc, Name, 5303344779Sdim *TemplateParamsOrErr, ToTemplated)) 5304341825Sdim return D2; 5305341825Sdim 5306341825Sdim ToTemplated->setDescribedClassTemplate(D2); 5307341825Sdim 5308218893Sdim D2->setAccess(D->getAccess()); 5309218893Sdim D2->setLexicalDeclContext(LexicalDC); 5310218893Sdim 5311360784Sdim addDeclToContexts(D, D2); 5312344779Sdim 5313344779Sdim if (FoundByLookup) { 5314344779Sdim auto *Recent = 5315344779Sdim const_cast<ClassTemplateDecl *>(FoundByLookup->getMostRecentDecl()); 5316344779Sdim 5317344779Sdim // It is possible that during the import of the class template definition 5318344779Sdim // we start the import of a fwd friend decl of the very same class template 5319344779Sdim // and we add the fwd friend decl to the lookup table. But the ToTemplated 5320344779Sdim // had been created earlier and by that time the lookup could not find 5321344779Sdim // anything existing, so it has no previous decl. Later, (still during the 5322344779Sdim // import of the fwd friend decl) we start to import the definition again 5323344779Sdim // and this time the lookup finds the previous fwd friend class template. 5324344779Sdim // In this case we must set up the previous decl for the templated decl. 5325344779Sdim if (!ToTemplated->getPreviousDecl()) { 5326353358Sdim assert(FoundByLookup->getTemplatedDecl() && 5327353358Sdim "Found decl must have its templated decl set"); 5328344779Sdim CXXRecordDecl *PrevTemplated = 5329344779Sdim FoundByLookup->getTemplatedDecl()->getMostRecentDecl(); 5330344779Sdim if (ToTemplated != PrevTemplated) 5331344779Sdim ToTemplated->setPreviousDecl(PrevTemplated); 5332344779Sdim } 5333344779Sdim 5334344779Sdim D2->setPreviousDecl(Recent); 5335344779Sdim } 5336344779Sdim 5337341825Sdim if (FromTemplated->isCompleteDefinition() && 5338341825Sdim !ToTemplated->isCompleteDefinition()) { 5339218893Sdim // FIXME: Import definition! 5340218893Sdim } 5341341825Sdim 5342218893Sdim return D2; 5343218893Sdim} 5344218893Sdim 5345344779SdimExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl( 5346218893Sdim ClassTemplateSpecializationDecl *D) { 5347344779Sdim ClassTemplateDecl *ClassTemplate; 5348344779Sdim if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate())) 5349344779Sdim return std::move(Err); 5350276479Sdim 5351218893Sdim // Import the context of this declaration. 5352344779Sdim DeclContext *DC, *LexicalDC; 5353344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 5354344779Sdim return std::move(Err); 5355276479Sdim 5356218893Sdim // Import template arguments. 5357226633Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 5358344779Sdim if (Error Err = ImportTemplateArguments( 5359344779Sdim D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs)) 5360344779Sdim return std::move(Err); 5361360784Sdim // Try to find an existing specialization with these template arguments and 5362360784Sdim // template parameter list. 5363276479Sdim void *InsertPos = nullptr; 5364353358Sdim ClassTemplateSpecializationDecl *PrevDecl = nullptr; 5365344779Sdim ClassTemplatePartialSpecializationDecl *PartialSpec = 5366344779Sdim dyn_cast<ClassTemplatePartialSpecializationDecl>(D); 5367360784Sdim 5368360784Sdim // Import template parameters. 5369360784Sdim TemplateParameterList *ToTPList = nullptr; 5370360784Sdim 5371360784Sdim if (PartialSpec) { 5372360784Sdim auto ToTPListOrErr = import(PartialSpec->getTemplateParameters()); 5373360784Sdim if (!ToTPListOrErr) 5374360784Sdim return ToTPListOrErr.takeError(); 5375360784Sdim ToTPList = *ToTPListOrErr; 5376360784Sdim PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs, 5377360784Sdim *ToTPListOrErr, 5378360784Sdim InsertPos); 5379360784Sdim } else 5380353358Sdim PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 5381341825Sdim 5382353358Sdim if (PrevDecl) { 5383353358Sdim if (IsStructuralMatch(D, PrevDecl)) { 5384353358Sdim if (D->isThisDeclarationADefinition() && PrevDecl->getDefinition()) { 5385353358Sdim Importer.MapImported(D, PrevDecl->getDefinition()); 5386353358Sdim // Import those default field initializers which have been 5387353358Sdim // instantiated in the "From" context, but not in the "To" context. 5388353358Sdim for (auto *FromField : D->fields()) { 5389353358Sdim auto ToOrErr = import(FromField); 5390353358Sdim if (!ToOrErr) 5391353358Sdim return ToOrErr.takeError(); 5392353358Sdim } 5393341825Sdim 5394353358Sdim // Import those methods which have been instantiated in the 5395353358Sdim // "From" context, but not in the "To" context. 5396353358Sdim for (CXXMethodDecl *FromM : D->methods()) { 5397353358Sdim auto ToOrErr = import(FromM); 5398353358Sdim if (!ToOrErr) 5399353358Sdim return ToOrErr.takeError(); 5400353358Sdim } 5401344779Sdim 5402353358Sdim // TODO Import instantiated default arguments. 5403353358Sdim // TODO Import instantiated exception specifications. 5404353358Sdim // 5405353358Sdim // Generally, ASTCommon.h/DeclUpdateKind enum gives a very good hint 5406353358Sdim // what else could be fused during an AST merge. 5407353358Sdim return PrevDecl; 5408218893Sdim } 5409353358Sdim } else { // ODR violation. 5410353358Sdim // FIXME HandleNameConflict 5411353358Sdim return make_error<ImportError>(ImportError::NameConflict); 5412353358Sdim } 5413353358Sdim } 5414344779Sdim 5415353358Sdim // Import the location of this declaration. 5416353358Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 5417353358Sdim if (!BeginLocOrErr) 5418353358Sdim return BeginLocOrErr.takeError(); 5419353358Sdim ExpectedSLoc IdLocOrErr = import(D->getLocation()); 5420353358Sdim if (!IdLocOrErr) 5421353358Sdim return IdLocOrErr.takeError(); 5422344779Sdim 5423353358Sdim // Create the specialization. 5424353358Sdim ClassTemplateSpecializationDecl *D2 = nullptr; 5425353358Sdim if (PartialSpec) { 5426353358Sdim // Import TemplateArgumentListInfo. 5427353358Sdim TemplateArgumentListInfo ToTAInfo; 5428353358Sdim const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten(); 5429353358Sdim if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo)) 5430353358Sdim return std::move(Err); 5431344779Sdim 5432353358Sdim QualType CanonInjType; 5433353358Sdim if (Error Err = importInto( 5434353358Sdim CanonInjType, PartialSpec->getInjectedSpecializationType())) 5435353358Sdim return std::move(Err); 5436353358Sdim CanonInjType = CanonInjType.getCanonicalType(); 5437344779Sdim 5438353358Sdim if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>( 5439353358Sdim D2, D, Importer.getToContext(), D->getTagKind(), DC, 5440360784Sdim *BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate, 5441353358Sdim llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), 5442353358Sdim ToTAInfo, CanonInjType, 5443353358Sdim cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl))) 5444353358Sdim return D2; 5445321369Sdim 5446353358Sdim // Update InsertPos, because preceding import calls may have invalidated 5447353358Sdim // it by adding new specializations. 5448360784Sdim auto *PartSpec2 = cast<ClassTemplatePartialSpecializationDecl>(D2); 5449360784Sdim if (!ClassTemplate->findPartialSpecialization(TemplateArgs, ToTPList, 5450360784Sdim InsertPos)) 5451353358Sdim // Add this partial specialization to the class template. 5452360784Sdim ClassTemplate->AddPartialSpecialization(PartSpec2, InsertPos); 5453321369Sdim 5454353358Sdim } else { // Not a partial specialization. 5455353358Sdim if (GetImportedOrCreateDecl( 5456353358Sdim D2, D, Importer.getToContext(), D->getTagKind(), DC, 5457353358Sdim *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs, 5458353358Sdim PrevDecl)) 5459353358Sdim return D2; 5460321369Sdim 5461353358Sdim // Update InsertPos, because preceding import calls may have invalidated 5462353358Sdim // it by adding new specializations. 5463353358Sdim if (!ClassTemplate->findSpecialization(TemplateArgs, InsertPos)) 5464353358Sdim // Add this specialization to the class template. 5465353358Sdim ClassTemplate->AddSpecialization(D2, InsertPos); 5466353358Sdim } 5467321369Sdim 5468353358Sdim D2->setSpecializationKind(D->getSpecializationKind()); 5469344779Sdim 5470353358Sdim // Set the context of this specialization/instantiation. 5471353358Sdim D2->setLexicalDeclContext(LexicalDC); 5472344779Sdim 5473353358Sdim // Add to the DC only if it was an explicit specialization/instantiation. 5474353358Sdim if (D2->isExplicitInstantiationOrSpecialization()) { 5475353358Sdim LexicalDC->addDeclInternal(D2); 5476353358Sdim } 5477321369Sdim 5478360784Sdim if (auto BraceRangeOrErr = import(D->getBraceRange())) 5479360784Sdim D2->setBraceRange(*BraceRangeOrErr); 5480360784Sdim else 5481360784Sdim return BraceRangeOrErr.takeError(); 5482360784Sdim 5483353358Sdim // Import the qualifier, if any. 5484353358Sdim if (auto LocOrErr = import(D->getQualifierLoc())) 5485353358Sdim D2->setQualifierInfo(*LocOrErr); 5486353358Sdim else 5487353358Sdim return LocOrErr.takeError(); 5488218893Sdim 5489353358Sdim if (auto *TSI = D->getTypeAsWritten()) { 5490353358Sdim if (auto TInfoOrErr = import(TSI)) 5491353358Sdim D2->setTypeAsWritten(*TInfoOrErr); 5492344779Sdim else 5493353358Sdim return TInfoOrErr.takeError(); 5494353358Sdim 5495353358Sdim if (auto LocOrErr = import(D->getTemplateKeywordLoc())) 5496353358Sdim D2->setTemplateKeywordLoc(*LocOrErr); 5497353358Sdim else 5498344779Sdim return LocOrErr.takeError(); 5499321369Sdim 5500353358Sdim if (auto LocOrErr = import(D->getExternLoc())) 5501353358Sdim D2->setExternLoc(*LocOrErr); 5502353358Sdim else 5503353358Sdim return LocOrErr.takeError(); 5504353358Sdim } 5505344779Sdim 5506353358Sdim if (D->getPointOfInstantiation().isValid()) { 5507353358Sdim if (auto POIOrErr = import(D->getPointOfInstantiation())) 5508353358Sdim D2->setPointOfInstantiation(*POIOrErr); 5509353358Sdim else 5510353358Sdim return POIOrErr.takeError(); 5511353358Sdim } 5512344779Sdim 5513353358Sdim D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind()); 5514321369Sdim 5515344779Sdim if (D->isCompleteDefinition()) 5516344779Sdim if (Error Err = ImportDefinition(D, D2)) 5517344779Sdim return std::move(Err); 5518276479Sdim 5519218893Sdim return D2; 5520218893Sdim} 5521218893Sdim 5522344779SdimExpectedDecl ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 5523261991Sdim // If this variable has a definition in the translation unit we're coming 5524261991Sdim // from, 5525261991Sdim // but this particular declaration is not that definition, import the 5526261991Sdim // definition and map to that. 5527341825Sdim auto *Definition = 5528261991Sdim cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 5529261991Sdim if (Definition && Definition != D->getTemplatedDecl()) { 5530344779Sdim if (ExpectedDecl ImportedDefOrErr = import( 5531344779Sdim Definition->getDescribedVarTemplate())) 5532344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 5533344779Sdim else 5534344779Sdim return ImportedDefOrErr.takeError(); 5535261991Sdim } 5536261991Sdim 5537261991Sdim // Import the major distinguishing characteristics of this variable template. 5538261991Sdim DeclContext *DC, *LexicalDC; 5539261991Sdim DeclarationName Name; 5540261991Sdim SourceLocation Loc; 5541288943Sdim NamedDecl *ToD; 5542344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 5543344779Sdim return std::move(Err); 5544288943Sdim if (ToD) 5545288943Sdim return ToD; 5546261991Sdim 5547261991Sdim // We may already have a template of the same name; try to find and match it. 5548261991Sdim assert(!DC->isFunctionOrMethod() && 5549261991Sdim "Variable templates cannot be declared at function scope"); 5550261991Sdim SmallVector<NamedDecl *, 4> ConflictingDecls; 5551344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5552341825Sdim for (auto *FoundDecl : FoundDecls) { 5553341825Sdim if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 5554261991Sdim continue; 5555261991Sdim 5556341825Sdim Decl *Found = FoundDecl; 5557344779Sdim if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 5558261991Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5559261991Sdim // The variable templates structurally match; call it the same template. 5560341825Sdim Importer.MapImported(D->getTemplatedDecl(), 5561341825Sdim FoundTemplate->getTemplatedDecl()); 5562341825Sdim return Importer.MapImported(D, FoundTemplate); 5563261991Sdim } 5564360784Sdim ConflictingDecls.push_back(FoundDecl); 5565261991Sdim } 5566261991Sdim } 5567261991Sdim 5568261991Sdim if (!ConflictingDecls.empty()) { 5569360784Sdim ExpectedName NameOrErr = Importer.HandleNameConflict( 5570360784Sdim Name, DC, Decl::IDNS_Ordinary, ConflictingDecls.data(), 5571360784Sdim ConflictingDecls.size()); 5572360784Sdim if (NameOrErr) 5573360784Sdim Name = NameOrErr.get(); 5574360784Sdim else 5575360784Sdim return NameOrErr.takeError(); 5576261991Sdim } 5577261991Sdim 5578261991Sdim VarDecl *DTemplated = D->getTemplatedDecl(); 5579261991Sdim 5580261991Sdim // Import the type. 5581344779Sdim // FIXME: Value not used? 5582344779Sdim ExpectedType TypeOrErr = import(DTemplated->getType()); 5583344779Sdim if (!TypeOrErr) 5584344779Sdim return TypeOrErr.takeError(); 5585261991Sdim 5586261991Sdim // Create the declaration that is being templated. 5587344779Sdim VarDecl *ToTemplated; 5588344779Sdim if (Error Err = importInto(ToTemplated, DTemplated)) 5589344779Sdim return std::move(Err); 5590261991Sdim 5591261991Sdim // Create the variable template declaration itself. 5592353358Sdim auto TemplateParamsOrErr = import(D->getTemplateParameters()); 5593344779Sdim if (!TemplateParamsOrErr) 5594344779Sdim return TemplateParamsOrErr.takeError(); 5595261991Sdim 5596341825Sdim VarTemplateDecl *ToVarTD; 5597341825Sdim if (GetImportedOrCreateDecl(ToVarTD, D, Importer.getToContext(), DC, Loc, 5598344779Sdim Name, *TemplateParamsOrErr, ToTemplated)) 5599341825Sdim return ToVarTD; 5600261991Sdim 5601341825Sdim ToTemplated->setDescribedVarTemplate(ToVarTD); 5602261991Sdim 5603341825Sdim ToVarTD->setAccess(D->getAccess()); 5604341825Sdim ToVarTD->setLexicalDeclContext(LexicalDC); 5605341825Sdim LexicalDC->addDeclInternal(ToVarTD); 5606261991Sdim 5607261991Sdim if (DTemplated->isThisDeclarationADefinition() && 5608341825Sdim !ToTemplated->isThisDeclarationADefinition()) { 5609261991Sdim // FIXME: Import definition! 5610261991Sdim } 5611261991Sdim 5612341825Sdim return ToVarTD; 5613261991Sdim} 5614261991Sdim 5615344779SdimExpectedDecl ASTNodeImporter::VisitVarTemplateSpecializationDecl( 5616261991Sdim VarTemplateSpecializationDecl *D) { 5617261991Sdim // If this record has a definition in the translation unit we're coming from, 5618261991Sdim // but this particular declaration is not that definition, import the 5619261991Sdim // definition and map to that. 5620261991Sdim VarDecl *Definition = D->getDefinition(); 5621261991Sdim if (Definition && Definition != D) { 5622344779Sdim if (ExpectedDecl ImportedDefOrErr = import(Definition)) 5623344779Sdim return Importer.MapImported(D, *ImportedDefOrErr); 5624344779Sdim else 5625344779Sdim return ImportedDefOrErr.takeError(); 5626261991Sdim } 5627261991Sdim 5628353358Sdim VarTemplateDecl *VarTemplate = nullptr; 5629344779Sdim if (Error Err = importInto(VarTemplate, D->getSpecializedTemplate())) 5630344779Sdim return std::move(Err); 5631261991Sdim 5632261991Sdim // Import the context of this declaration. 5633344779Sdim DeclContext *DC, *LexicalDC; 5634344779Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 5635344779Sdim return std::move(Err); 5636261991Sdim 5637261991Sdim // Import the location of this declaration. 5638344779Sdim ExpectedSLoc BeginLocOrErr = import(D->getBeginLoc()); 5639344779Sdim if (!BeginLocOrErr) 5640344779Sdim return BeginLocOrErr.takeError(); 5641261991Sdim 5642344779Sdim auto IdLocOrErr = import(D->getLocation()); 5643344779Sdim if (!IdLocOrErr) 5644344779Sdim return IdLocOrErr.takeError(); 5645344779Sdim 5646261991Sdim // Import template arguments. 5647261991Sdim SmallVector<TemplateArgument, 2> TemplateArgs; 5648344779Sdim if (Error Err = ImportTemplateArguments( 5649344779Sdim D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs)) 5650344779Sdim return std::move(Err); 5651261991Sdim 5652261991Sdim // Try to find an existing specialization with these template arguments. 5653276479Sdim void *InsertPos = nullptr; 5654261991Sdim VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 5655276479Sdim TemplateArgs, InsertPos); 5656261991Sdim if (D2) { 5657261991Sdim // We already have a variable template specialization with these template 5658261991Sdim // arguments. 5659261991Sdim 5660261991Sdim // FIXME: Check for specialization vs. instantiation errors. 5661261991Sdim 5662261991Sdim if (VarDecl *FoundDef = D2->getDefinition()) { 5663261991Sdim if (!D->isThisDeclarationADefinition() || 5664261991Sdim IsStructuralMatch(D, FoundDef)) { 5665261991Sdim // The record types structurally match, or the "from" translation 5666261991Sdim // unit only had a forward declaration anyway; call it the same 5667261991Sdim // variable. 5668341825Sdim return Importer.MapImported(D, FoundDef); 5669261991Sdim } 5670261991Sdim } 5671261991Sdim } else { 5672261991Sdim // Import the type. 5673344779Sdim QualType T; 5674344779Sdim if (Error Err = importInto(T, D->getType())) 5675344779Sdim return std::move(Err); 5676341825Sdim 5677344779Sdim auto TInfoOrErr = import(D->getTypeSourceInfo()); 5678344779Sdim if (!TInfoOrErr) 5679344779Sdim return TInfoOrErr.takeError(); 5680261991Sdim 5681341825Sdim TemplateArgumentListInfo ToTAInfo; 5682344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 5683344779Sdim D->getTemplateArgsInfo(), ToTAInfo)) 5684344779Sdim return std::move(Err); 5685341825Sdim 5686341825Sdim using PartVarSpecDecl = VarTemplatePartialSpecializationDecl; 5687261991Sdim // Create a new specialization. 5688341825Sdim if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) { 5689341825Sdim // Import TemplateArgumentListInfo 5690341825Sdim TemplateArgumentListInfo ArgInfos; 5691341825Sdim const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten(); 5692341825Sdim // NOTE: FromTAArgsAsWritten and template parameter list are non-null. 5693344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 5694344779Sdim *FromTAArgsAsWritten, ArgInfos)) 5695344779Sdim return std::move(Err); 5696341825Sdim 5697353358Sdim auto ToTPListOrErr = import(FromPartial->getTemplateParameters()); 5698344779Sdim if (!ToTPListOrErr) 5699344779Sdim return ToTPListOrErr.takeError(); 5700341825Sdim 5701341825Sdim PartVarSpecDecl *ToPartial; 5702341825Sdim if (GetImportedOrCreateDecl(ToPartial, D, Importer.getToContext(), DC, 5703344779Sdim *BeginLocOrErr, *IdLocOrErr, *ToTPListOrErr, 5704344779Sdim VarTemplate, T, *TInfoOrErr, 5705344779Sdim D->getStorageClass(), TemplateArgs, ArgInfos)) 5706341825Sdim return ToPartial; 5707341825Sdim 5708344779Sdim if (Expected<PartVarSpecDecl *> ToInstOrErr = import( 5709344779Sdim FromPartial->getInstantiatedFromMember())) 5710344779Sdim ToPartial->setInstantiatedFromMember(*ToInstOrErr); 5711344779Sdim else 5712344779Sdim return ToInstOrErr.takeError(); 5713341825Sdim 5714341825Sdim if (FromPartial->isMemberSpecialization()) 5715341825Sdim ToPartial->setMemberSpecialization(); 5716341825Sdim 5717341825Sdim D2 = ToPartial; 5718344779Sdim 5719341825Sdim } else { // Full specialization 5720344779Sdim if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, 5721344779Sdim *BeginLocOrErr, *IdLocOrErr, VarTemplate, 5722344779Sdim T, *TInfoOrErr, 5723341825Sdim D->getStorageClass(), TemplateArgs)) 5724341825Sdim return D2; 5725341825Sdim } 5726341825Sdim 5727344779Sdim if (D->getPointOfInstantiation().isValid()) { 5728344779Sdim if (ExpectedSLoc POIOrErr = import(D->getPointOfInstantiation())) 5729344779Sdim D2->setPointOfInstantiation(*POIOrErr); 5730344779Sdim else 5731344779Sdim return POIOrErr.takeError(); 5732344779Sdim } 5733341825Sdim 5734261991Sdim D2->setSpecializationKind(D->getSpecializationKind()); 5735341825Sdim D2->setTemplateArgsInfo(ToTAInfo); 5736261991Sdim 5737261991Sdim // Add this specialization to the class template. 5738261991Sdim VarTemplate->AddSpecialization(D2, InsertPos); 5739261991Sdim 5740261991Sdim // Import the qualifier, if any. 5741344779Sdim if (auto LocOrErr = import(D->getQualifierLoc())) 5742344779Sdim D2->setQualifierInfo(*LocOrErr); 5743344779Sdim else 5744344779Sdim return LocOrErr.takeError(); 5745261991Sdim 5746341825Sdim if (D->isConstexpr()) 5747341825Sdim D2->setConstexpr(true); 5748341825Sdim 5749261991Sdim // Add the specialization to this context. 5750261991Sdim D2->setLexicalDeclContext(LexicalDC); 5751261991Sdim LexicalDC->addDeclInternal(D2); 5752341825Sdim 5753341825Sdim D2->setAccess(D->getAccess()); 5754261991Sdim } 5755261991Sdim 5756344779Sdim if (Error Err = ImportInitializer(D, D2)) 5757344779Sdim return std::move(Err); 5758261991Sdim 5759261991Sdim return D2; 5760261991Sdim} 5761261991Sdim 5762344779SdimExpectedDecl 5763344779SdimASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 5764327952Sdim DeclContext *DC, *LexicalDC; 5765327952Sdim DeclarationName Name; 5766327952Sdim SourceLocation Loc; 5767327952Sdim NamedDecl *ToD; 5768327952Sdim 5769344779Sdim if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 5770344779Sdim return std::move(Err); 5771327952Sdim 5772327952Sdim if (ToD) 5773327952Sdim return ToD; 5774327952Sdim 5775353358Sdim const FunctionTemplateDecl *FoundByLookup = nullptr; 5776353358Sdim 5777327952Sdim // Try to find a function in our own ("to") context with the same name, same 5778327952Sdim // type, and in the same context as the function we're importing. 5779353358Sdim // FIXME Split this into a separate function. 5780327952Sdim if (!LexicalDC->isFunctionOrMethod()) { 5781353358Sdim unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_OrdinaryFriend; 5782344779Sdim auto FoundDecls = Importer.findDeclsInToCtx(DC, Name); 5783341825Sdim for (auto *FoundDecl : FoundDecls) { 5784341825Sdim if (!FoundDecl->isInIdentifierNamespace(IDNS)) 5785327952Sdim continue; 5786327952Sdim 5787353358Sdim if (auto *FoundTemplate = dyn_cast<FunctionTemplateDecl>(FoundDecl)) { 5788360784Sdim if (!hasSameVisibilityContext(FoundTemplate, D)) 5789360784Sdim continue; 5790360784Sdim if (IsStructuralMatch(D, FoundTemplate)) { 5791360784Sdim FunctionTemplateDecl *TemplateWithDef = 5792360784Sdim getTemplateDefinition(FoundTemplate); 5793360784Sdim if (D->isThisDeclarationADefinition() && TemplateWithDef) 5794360784Sdim return Importer.MapImported(D, TemplateWithDef); 5795360784Sdim 5796360784Sdim FoundByLookup = FoundTemplate; 5797360784Sdim break; 5798353358Sdim // TODO: handle conflicting names 5799327952Sdim } 5800327952Sdim } 5801327952Sdim } 5802327952Sdim } 5803327952Sdim 5804353358Sdim auto ParamsOrErr = import(D->getTemplateParameters()); 5805344779Sdim if (!ParamsOrErr) 5806344779Sdim return ParamsOrErr.takeError(); 5807327952Sdim 5808344779Sdim FunctionDecl *TemplatedFD; 5809344779Sdim if (Error Err = importInto(TemplatedFD, D->getTemplatedDecl())) 5810344779Sdim return std::move(Err); 5811327952Sdim 5812341825Sdim FunctionTemplateDecl *ToFunc; 5813341825Sdim if (GetImportedOrCreateDecl(ToFunc, D, Importer.getToContext(), DC, Loc, Name, 5814344779Sdim *ParamsOrErr, TemplatedFD)) 5815341825Sdim return ToFunc; 5816327952Sdim 5817327952Sdim TemplatedFD->setDescribedFunctionTemplate(ToFunc); 5818353358Sdim 5819327952Sdim ToFunc->setAccess(D->getAccess()); 5820327952Sdim ToFunc->setLexicalDeclContext(LexicalDC); 5821353358Sdim LexicalDC->addDeclInternal(ToFunc); 5822327952Sdim 5823353358Sdim if (FoundByLookup) { 5824353358Sdim auto *Recent = 5825353358Sdim const_cast<FunctionTemplateDecl *>(FoundByLookup->getMostRecentDecl()); 5826353358Sdim if (!TemplatedFD->getPreviousDecl()) { 5827353358Sdim assert(FoundByLookup->getTemplatedDecl() && 5828353358Sdim "Found decl must have its templated decl set"); 5829353358Sdim auto *PrevTemplated = 5830353358Sdim FoundByLookup->getTemplatedDecl()->getMostRecentDecl(); 5831353358Sdim if (TemplatedFD != PrevTemplated) 5832353358Sdim TemplatedFD->setPreviousDecl(PrevTemplated); 5833353358Sdim } 5834353358Sdim ToFunc->setPreviousDecl(Recent); 5835353358Sdim } 5836353358Sdim 5837327952Sdim return ToFunc; 5838327952Sdim} 5839327952Sdim 5840203955Srdivacky//---------------------------------------------------------------------------- 5841203955Srdivacky// Import Statements 5842203955Srdivacky//---------------------------------------------------------------------------- 5843203955Srdivacky 5844344779SdimExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) { 5845344779Sdim Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node) 5846344779Sdim << S->getStmtClassName(); 5847344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 5848203955Srdivacky} 5849203955Srdivacky 5850309124Sdim 5851344779SdimExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) { 5852353358Sdim if (Importer.returnWithErrorInTest()) 5853353358Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 5854309124Sdim SmallVector<IdentifierInfo *, 4> Names; 5855309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 5856309124Sdim IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I)); 5857321369Sdim // ToII is nullptr when no symbolic name is given for output operand 5858321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 5859309124Sdim Names.push_back(ToII); 5860309124Sdim } 5861344779Sdim 5862309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 5863309124Sdim IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I)); 5864321369Sdim // ToII is nullptr when no symbolic name is given for input operand 5865321369Sdim // see ParseStmtAsm::ParseAsmOperandsOpt 5866309124Sdim Names.push_back(ToII); 5867309124Sdim } 5868309124Sdim 5869309124Sdim SmallVector<StringLiteral *, 4> Clobbers; 5870309124Sdim for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) { 5871344779Sdim if (auto ClobberOrErr = import(S->getClobberStringLiteral(I))) 5872344779Sdim Clobbers.push_back(*ClobberOrErr); 5873344779Sdim else 5874344779Sdim return ClobberOrErr.takeError(); 5875344779Sdim 5876309124Sdim } 5877309124Sdim 5878309124Sdim SmallVector<StringLiteral *, 4> Constraints; 5879309124Sdim for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 5880344779Sdim if (auto OutputOrErr = import(S->getOutputConstraintLiteral(I))) 5881344779Sdim Constraints.push_back(*OutputOrErr); 5882344779Sdim else 5883344779Sdim return OutputOrErr.takeError(); 5884309124Sdim } 5885309124Sdim 5886309124Sdim for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 5887344779Sdim if (auto InputOrErr = import(S->getInputConstraintLiteral(I))) 5888344779Sdim Constraints.push_back(*InputOrErr); 5889344779Sdim else 5890344779Sdim return InputOrErr.takeError(); 5891309124Sdim } 5892309124Sdim 5893353358Sdim SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs() + 5894353358Sdim S->getNumLabels()); 5895344779Sdim if (Error Err = ImportContainerChecked(S->outputs(), Exprs)) 5896344779Sdim return std::move(Err); 5897309124Sdim 5898353358Sdim if (Error Err = 5899353358Sdim ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs())) 5900353358Sdim return std::move(Err); 5901353358Sdim 5902344779Sdim if (Error Err = ImportArrayChecked( 5903353358Sdim S->labels(), Exprs.begin() + S->getNumOutputs() + S->getNumInputs())) 5904344779Sdim return std::move(Err); 5905309124Sdim 5906344779Sdim ExpectedSLoc AsmLocOrErr = import(S->getAsmLoc()); 5907344779Sdim if (!AsmLocOrErr) 5908344779Sdim return AsmLocOrErr.takeError(); 5909344779Sdim auto AsmStrOrErr = import(S->getAsmString()); 5910344779Sdim if (!AsmStrOrErr) 5911344779Sdim return AsmStrOrErr.takeError(); 5912344779Sdim ExpectedSLoc RParenLocOrErr = import(S->getRParenLoc()); 5913344779Sdim if (!RParenLocOrErr) 5914344779Sdim return RParenLocOrErr.takeError(); 5915309124Sdim 5916309124Sdim return new (Importer.getToContext()) GCCAsmStmt( 5917344779Sdim Importer.getToContext(), 5918344779Sdim *AsmLocOrErr, 5919344779Sdim S->isSimple(), 5920344779Sdim S->isVolatile(), 5921344779Sdim S->getNumOutputs(), 5922344779Sdim S->getNumInputs(), 5923344779Sdim Names.data(), 5924344779Sdim Constraints.data(), 5925344779Sdim Exprs.data(), 5926344779Sdim *AsmStrOrErr, 5927344779Sdim S->getNumClobbers(), 5928344779Sdim Clobbers.data(), 5929353358Sdim S->getNumLabels(), 5930344779Sdim *RParenLocOrErr); 5931309124Sdim} 5932309124Sdim 5933344779SdimExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 5934344779Sdim auto Imp = importSeq(S->getDeclGroup(), S->getBeginLoc(), S->getEndLoc()); 5935344779Sdim if (!Imp) 5936344779Sdim return Imp.takeError(); 5937344779Sdim 5938344779Sdim DeclGroupRef ToDG; 5939344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 5940344779Sdim std::tie(ToDG, ToBeginLoc, ToEndLoc) = *Imp; 5941344779Sdim 5942344779Sdim return new (Importer.getToContext()) DeclStmt(ToDG, ToBeginLoc, ToEndLoc); 5943288943Sdim} 5944288943Sdim 5945344779SdimExpectedStmt ASTNodeImporter::VisitNullStmt(NullStmt *S) { 5946344779Sdim ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc()); 5947344779Sdim if (!ToSemiLocOrErr) 5948344779Sdim return ToSemiLocOrErr.takeError(); 5949344779Sdim return new (Importer.getToContext()) NullStmt( 5950344779Sdim *ToSemiLocOrErr, S->hasLeadingEmptyMacro()); 5951288943Sdim} 5952288943Sdim 5953344779SdimExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 5954341825Sdim SmallVector<Stmt *, 8> ToStmts(S->size()); 5955314564Sdim 5956344779Sdim if (Error Err = ImportContainerChecked(S->body(), ToStmts)) 5957344779Sdim return std::move(Err); 5958309124Sdim 5959344779Sdim ExpectedSLoc ToLBracLocOrErr = import(S->getLBracLoc()); 5960344779Sdim if (!ToLBracLocOrErr) 5961344779Sdim return ToLBracLocOrErr.takeError(); 5962344779Sdim 5963344779Sdim ExpectedSLoc ToRBracLocOrErr = import(S->getRBracLoc()); 5964344779Sdim if (!ToRBracLocOrErr) 5965344779Sdim return ToRBracLocOrErr.takeError(); 5966344779Sdim 5967344779Sdim return CompoundStmt::Create( 5968344779Sdim Importer.getToContext(), ToStmts, 5969344779Sdim *ToLBracLocOrErr, *ToRBracLocOrErr); 5970288943Sdim} 5971288943Sdim 5972344779SdimExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 5973344779Sdim auto Imp = importSeq( 5974344779Sdim S->getLHS(), S->getRHS(), S->getSubStmt(), S->getCaseLoc(), 5975344779Sdim S->getEllipsisLoc(), S->getColonLoc()); 5976344779Sdim if (!Imp) 5977344779Sdim return Imp.takeError(); 5978344779Sdim 5979344779Sdim Expr *ToLHS, *ToRHS; 5980344779Sdim Stmt *ToSubStmt; 5981344779Sdim SourceLocation ToCaseLoc, ToEllipsisLoc, ToColonLoc; 5982344779Sdim std::tie(ToLHS, ToRHS, ToSubStmt, ToCaseLoc, ToEllipsisLoc, ToColonLoc) = 5983344779Sdim *Imp; 5984344779Sdim 5985344779Sdim auto *ToStmt = CaseStmt::Create(Importer.getToContext(), ToLHS, ToRHS, 5986344779Sdim ToCaseLoc, ToEllipsisLoc, ToColonLoc); 5987327952Sdim ToStmt->setSubStmt(ToSubStmt); 5988344779Sdim 5989327952Sdim return ToStmt; 5990288943Sdim} 5991288943Sdim 5992344779SdimExpectedStmt ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 5993344779Sdim auto Imp = importSeq(S->getDefaultLoc(), S->getColonLoc(), S->getSubStmt()); 5994344779Sdim if (!Imp) 5995344779Sdim return Imp.takeError(); 5996344779Sdim 5997344779Sdim SourceLocation ToDefaultLoc, ToColonLoc; 5998344779Sdim Stmt *ToSubStmt; 5999344779Sdim std::tie(ToDefaultLoc, ToColonLoc, ToSubStmt) = *Imp; 6000344779Sdim 6001344779Sdim return new (Importer.getToContext()) DefaultStmt( 6002344779Sdim ToDefaultLoc, ToColonLoc, ToSubStmt); 6003288943Sdim} 6004288943Sdim 6005344779SdimExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 6006344779Sdim auto Imp = importSeq(S->getIdentLoc(), S->getDecl(), S->getSubStmt()); 6007344779Sdim if (!Imp) 6008344779Sdim return Imp.takeError(); 6009344779Sdim 6010344779Sdim SourceLocation ToIdentLoc; 6011344779Sdim LabelDecl *ToLabelDecl; 6012344779Sdim Stmt *ToSubStmt; 6013344779Sdim std::tie(ToIdentLoc, ToLabelDecl, ToSubStmt) = *Imp; 6014344779Sdim 6015344779Sdim return new (Importer.getToContext()) LabelStmt( 6016344779Sdim ToIdentLoc, ToLabelDecl, ToSubStmt); 6017288943Sdim} 6018288943Sdim 6019344779SdimExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 6020344779Sdim ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc()); 6021344779Sdim if (!ToAttrLocOrErr) 6022344779Sdim return ToAttrLocOrErr.takeError(); 6023288943Sdim ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 6024288943Sdim SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 6025344779Sdim if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs)) 6026344779Sdim return std::move(Err); 6027344779Sdim ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt()); 6028344779Sdim if (!ToSubStmtOrErr) 6029344779Sdim return ToSubStmtOrErr.takeError(); 6030344779Sdim 6031344779Sdim return AttributedStmt::Create( 6032344779Sdim Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr); 6033288943Sdim} 6034288943Sdim 6035344779SdimExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) { 6036344779Sdim auto Imp = importSeq( 6037344779Sdim S->getIfLoc(), S->getInit(), S->getConditionVariable(), S->getCond(), 6038344779Sdim S->getThen(), S->getElseLoc(), S->getElse()); 6039344779Sdim if (!Imp) 6040344779Sdim return Imp.takeError(); 6041344779Sdim 6042344779Sdim SourceLocation ToIfLoc, ToElseLoc; 6043344779Sdim Stmt *ToInit, *ToThen, *ToElse; 6044344779Sdim VarDecl *ToConditionVariable; 6045344779Sdim Expr *ToCond; 6046344779Sdim std::tie( 6047344779Sdim ToIfLoc, ToInit, ToConditionVariable, ToCond, ToThen, ToElseLoc, ToElse) = 6048344779Sdim *Imp; 6049344779Sdim 6050344779Sdim return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(), 6051344779Sdim ToInit, ToConditionVariable, ToCond, ToThen, ToElseLoc, 6052344779Sdim ToElse); 6053288943Sdim} 6054288943Sdim 6055344779SdimExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 6056344779Sdim auto Imp = importSeq( 6057344779Sdim S->getInit(), S->getConditionVariable(), S->getCond(), 6058344779Sdim S->getBody(), S->getSwitchLoc()); 6059344779Sdim if (!Imp) 6060344779Sdim return Imp.takeError(); 6061344779Sdim 6062344779Sdim Stmt *ToInit, *ToBody; 6063344779Sdim VarDecl *ToConditionVariable; 6064344779Sdim Expr *ToCond; 6065344779Sdim SourceLocation ToSwitchLoc; 6066344779Sdim std::tie(ToInit, ToConditionVariable, ToCond, ToBody, ToSwitchLoc) = *Imp; 6067344779Sdim 6068344779Sdim auto *ToStmt = SwitchStmt::Create(Importer.getToContext(), ToInit, 6069344779Sdim ToConditionVariable, ToCond); 6070288943Sdim ToStmt->setBody(ToBody); 6071344779Sdim ToStmt->setSwitchLoc(ToSwitchLoc); 6072344779Sdim 6073288943Sdim // Now we have to re-chain the cases. 6074288943Sdim SwitchCase *LastChainedSwitchCase = nullptr; 6075288943Sdim for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 6076288943Sdim SC = SC->getNextSwitchCase()) { 6077344779Sdim Expected<SwitchCase *> ToSCOrErr = import(SC); 6078344779Sdim if (!ToSCOrErr) 6079344779Sdim return ToSCOrErr.takeError(); 6080288943Sdim if (LastChainedSwitchCase) 6081344779Sdim LastChainedSwitchCase->setNextSwitchCase(*ToSCOrErr); 6082288943Sdim else 6083344779Sdim ToStmt->setSwitchCaseList(*ToSCOrErr); 6084344779Sdim LastChainedSwitchCase = *ToSCOrErr; 6085288943Sdim } 6086344779Sdim 6087288943Sdim return ToStmt; 6088288943Sdim} 6089288943Sdim 6090344779SdimExpectedStmt ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 6091344779Sdim auto Imp = importSeq( 6092344779Sdim S->getConditionVariable(), S->getCond(), S->getBody(), S->getWhileLoc()); 6093344779Sdim if (!Imp) 6094344779Sdim return Imp.takeError(); 6095344779Sdim 6096344779Sdim VarDecl *ToConditionVariable; 6097344779Sdim Expr *ToCond; 6098344779Sdim Stmt *ToBody; 6099344779Sdim SourceLocation ToWhileLoc; 6100344779Sdim std::tie(ToConditionVariable, ToCond, ToBody, ToWhileLoc) = *Imp; 6101344779Sdim 6102344779Sdim return WhileStmt::Create(Importer.getToContext(), ToConditionVariable, ToCond, 6103344779Sdim ToBody, ToWhileLoc); 6104288943Sdim} 6105288943Sdim 6106344779SdimExpectedStmt ASTNodeImporter::VisitDoStmt(DoStmt *S) { 6107344779Sdim auto Imp = importSeq( 6108344779Sdim S->getBody(), S->getCond(), S->getDoLoc(), S->getWhileLoc(), 6109344779Sdim S->getRParenLoc()); 6110344779Sdim if (!Imp) 6111344779Sdim return Imp.takeError(); 6112344779Sdim 6113344779Sdim Stmt *ToBody; 6114344779Sdim Expr *ToCond; 6115344779Sdim SourceLocation ToDoLoc, ToWhileLoc, ToRParenLoc; 6116344779Sdim std::tie(ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc) = *Imp; 6117344779Sdim 6118344779Sdim return new (Importer.getToContext()) DoStmt( 6119344779Sdim ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc); 6120288943Sdim} 6121288943Sdim 6122344779SdimExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) { 6123344779Sdim auto Imp = importSeq( 6124344779Sdim S->getInit(), S->getCond(), S->getConditionVariable(), S->getInc(), 6125344779Sdim S->getBody(), S->getForLoc(), S->getLParenLoc(), S->getRParenLoc()); 6126344779Sdim if (!Imp) 6127344779Sdim return Imp.takeError(); 6128344779Sdim 6129344779Sdim Stmt *ToInit; 6130344779Sdim Expr *ToCond, *ToInc; 6131344779Sdim VarDecl *ToConditionVariable; 6132344779Sdim Stmt *ToBody; 6133344779Sdim SourceLocation ToForLoc, ToLParenLoc, ToRParenLoc; 6134344779Sdim std::tie( 6135344779Sdim ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, 6136344779Sdim ToLParenLoc, ToRParenLoc) = *Imp; 6137344779Sdim 6138344779Sdim return new (Importer.getToContext()) ForStmt( 6139344779Sdim Importer.getToContext(), 6140344779Sdim ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc, 6141344779Sdim ToRParenLoc); 6142288943Sdim} 6143288943Sdim 6144344779SdimExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 6145344779Sdim auto Imp = importSeq(S->getLabel(), S->getGotoLoc(), S->getLabelLoc()); 6146344779Sdim if (!Imp) 6147344779Sdim return Imp.takeError(); 6148344779Sdim 6149344779Sdim LabelDecl *ToLabel; 6150344779Sdim SourceLocation ToGotoLoc, ToLabelLoc; 6151344779Sdim std::tie(ToLabel, ToGotoLoc, ToLabelLoc) = *Imp; 6152344779Sdim 6153344779Sdim return new (Importer.getToContext()) GotoStmt( 6154344779Sdim ToLabel, ToGotoLoc, ToLabelLoc); 6155288943Sdim} 6156288943Sdim 6157344779SdimExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 6158344779Sdim auto Imp = importSeq(S->getGotoLoc(), S->getStarLoc(), S->getTarget()); 6159344779Sdim if (!Imp) 6160344779Sdim return Imp.takeError(); 6161344779Sdim 6162344779Sdim SourceLocation ToGotoLoc, ToStarLoc; 6163344779Sdim Expr *ToTarget; 6164344779Sdim std::tie(ToGotoLoc, ToStarLoc, ToTarget) = *Imp; 6165344779Sdim 6166344779Sdim return new (Importer.getToContext()) IndirectGotoStmt( 6167344779Sdim ToGotoLoc, ToStarLoc, ToTarget); 6168288943Sdim} 6169288943Sdim 6170344779SdimExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 6171344779Sdim ExpectedSLoc ToContinueLocOrErr = import(S->getContinueLoc()); 6172344779Sdim if (!ToContinueLocOrErr) 6173344779Sdim return ToContinueLocOrErr.takeError(); 6174344779Sdim return new (Importer.getToContext()) ContinueStmt(*ToContinueLocOrErr); 6175288943Sdim} 6176288943Sdim 6177344779SdimExpectedStmt ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 6178344779Sdim auto ToBreakLocOrErr = import(S->getBreakLoc()); 6179344779Sdim if (!ToBreakLocOrErr) 6180344779Sdim return ToBreakLocOrErr.takeError(); 6181344779Sdim return new (Importer.getToContext()) BreakStmt(*ToBreakLocOrErr); 6182288943Sdim} 6183288943Sdim 6184344779SdimExpectedStmt ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 6185344779Sdim auto Imp = importSeq( 6186344779Sdim S->getReturnLoc(), S->getRetValue(), S->getNRVOCandidate()); 6187344779Sdim if (!Imp) 6188344779Sdim return Imp.takeError(); 6189344779Sdim 6190344779Sdim SourceLocation ToReturnLoc; 6191344779Sdim Expr *ToRetValue; 6192344779Sdim const VarDecl *ToNRVOCandidate; 6193344779Sdim std::tie(ToReturnLoc, ToRetValue, ToNRVOCandidate) = *Imp; 6194344779Sdim 6195344779Sdim return ReturnStmt::Create(Importer.getToContext(), ToReturnLoc, ToRetValue, 6196344779Sdim ToNRVOCandidate); 6197288943Sdim} 6198288943Sdim 6199344779SdimExpectedStmt ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 6200344779Sdim auto Imp = importSeq( 6201344779Sdim S->getCatchLoc(), S->getExceptionDecl(), S->getHandlerBlock()); 6202344779Sdim if (!Imp) 6203344779Sdim return Imp.takeError(); 6204344779Sdim 6205344779Sdim SourceLocation ToCatchLoc; 6206344779Sdim VarDecl *ToExceptionDecl; 6207344779Sdim Stmt *ToHandlerBlock; 6208344779Sdim std::tie(ToCatchLoc, ToExceptionDecl, ToHandlerBlock) = *Imp; 6209344779Sdim 6210344779Sdim return new (Importer.getToContext()) CXXCatchStmt ( 6211344779Sdim ToCatchLoc, ToExceptionDecl, ToHandlerBlock); 6212288943Sdim} 6213288943Sdim 6214344779SdimExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 6215344779Sdim ExpectedSLoc ToTryLocOrErr = import(S->getTryLoc()); 6216344779Sdim if (!ToTryLocOrErr) 6217344779Sdim return ToTryLocOrErr.takeError(); 6218344779Sdim 6219344779Sdim ExpectedStmt ToTryBlockOrErr = import(S->getTryBlock()); 6220344779Sdim if (!ToTryBlockOrErr) 6221344779Sdim return ToTryBlockOrErr.takeError(); 6222344779Sdim 6223288943Sdim SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 6224288943Sdim for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 6225288943Sdim CXXCatchStmt *FromHandler = S->getHandler(HI); 6226344779Sdim if (auto ToHandlerOrErr = import(FromHandler)) 6227344779Sdim ToHandlers[HI] = *ToHandlerOrErr; 6228288943Sdim else 6229344779Sdim return ToHandlerOrErr.takeError(); 6230288943Sdim } 6231344779Sdim 6232344779Sdim return CXXTryStmt::Create( 6233344779Sdim Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers); 6234288943Sdim} 6235288943Sdim 6236344779SdimExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 6237344779Sdim auto Imp1 = importSeq( 6238344779Sdim S->getInit(), S->getRangeStmt(), S->getBeginStmt(), S->getEndStmt(), 6239344779Sdim S->getCond(), S->getInc(), S->getLoopVarStmt(), S->getBody()); 6240344779Sdim if (!Imp1) 6241344779Sdim return Imp1.takeError(); 6242344779Sdim auto Imp2 = importSeq( 6243344779Sdim S->getForLoc(), S->getCoawaitLoc(), S->getColonLoc(), S->getRParenLoc()); 6244344779Sdim if (!Imp2) 6245344779Sdim return Imp2.takeError(); 6246344779Sdim 6247344779Sdim DeclStmt *ToRangeStmt, *ToBeginStmt, *ToEndStmt, *ToLoopVarStmt; 6248344779Sdim Expr *ToCond, *ToInc; 6249344779Sdim Stmt *ToInit, *ToBody; 6250344779Sdim std::tie( 6251344779Sdim ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt, 6252344779Sdim ToBody) = *Imp1; 6253344779Sdim SourceLocation ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc; 6254344779Sdim std::tie(ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc) = *Imp2; 6255344779Sdim 6256344779Sdim return new (Importer.getToContext()) CXXForRangeStmt( 6257344779Sdim ToInit, ToRangeStmt, ToBeginStmt, ToEndStmt, ToCond, ToInc, ToLoopVarStmt, 6258344779Sdim ToBody, ToForLoc, ToCoawaitLoc, ToColonLoc, ToRParenLoc); 6259288943Sdim} 6260288943Sdim 6261344779SdimExpectedStmt 6262344779SdimASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 6263344779Sdim auto Imp = importSeq( 6264344779Sdim S->getElement(), S->getCollection(), S->getBody(), 6265344779Sdim S->getForLoc(), S->getRParenLoc()); 6266344779Sdim if (!Imp) 6267344779Sdim return Imp.takeError(); 6268344779Sdim 6269344779Sdim Stmt *ToElement, *ToBody; 6270344779Sdim Expr *ToCollection; 6271344779Sdim SourceLocation ToForLoc, ToRParenLoc; 6272344779Sdim std::tie(ToElement, ToCollection, ToBody, ToForLoc, ToRParenLoc) = *Imp; 6273344779Sdim 6274344779Sdim return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement, 6275344779Sdim ToCollection, 6276344779Sdim ToBody, 6277344779Sdim ToForLoc, 6278288943Sdim ToRParenLoc); 6279288943Sdim} 6280288943Sdim 6281344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 6282344779Sdim auto Imp = importSeq( 6283344779Sdim S->getAtCatchLoc(), S->getRParenLoc(), S->getCatchParamDecl(), 6284344779Sdim S->getCatchBody()); 6285344779Sdim if (!Imp) 6286344779Sdim return Imp.takeError(); 6287344779Sdim 6288344779Sdim SourceLocation ToAtCatchLoc, ToRParenLoc; 6289344779Sdim VarDecl *ToCatchParamDecl; 6290344779Sdim Stmt *ToCatchBody; 6291344779Sdim std::tie(ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody) = *Imp; 6292344779Sdim 6293344779Sdim return new (Importer.getToContext()) ObjCAtCatchStmt ( 6294344779Sdim ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody); 6295288943Sdim} 6296288943Sdim 6297344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 6298344779Sdim ExpectedSLoc ToAtFinallyLocOrErr = import(S->getAtFinallyLoc()); 6299344779Sdim if (!ToAtFinallyLocOrErr) 6300344779Sdim return ToAtFinallyLocOrErr.takeError(); 6301344779Sdim ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody()); 6302344779Sdim if (!ToAtFinallyStmtOrErr) 6303344779Sdim return ToAtFinallyStmtOrErr.takeError(); 6304344779Sdim return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr, 6305344779Sdim *ToAtFinallyStmtOrErr); 6306288943Sdim} 6307288943Sdim 6308344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 6309344779Sdim auto Imp = importSeq( 6310344779Sdim S->getAtTryLoc(), S->getTryBody(), S->getFinallyStmt()); 6311344779Sdim if (!Imp) 6312344779Sdim return Imp.takeError(); 6313344779Sdim 6314344779Sdim SourceLocation ToAtTryLoc; 6315344779Sdim Stmt *ToTryBody, *ToFinallyStmt; 6316344779Sdim std::tie(ToAtTryLoc, ToTryBody, ToFinallyStmt) = *Imp; 6317344779Sdim 6318288943Sdim SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 6319288943Sdim for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 6320288943Sdim ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 6321344779Sdim if (ExpectedStmt ToCatchStmtOrErr = import(FromCatchStmt)) 6322344779Sdim ToCatchStmts[CI] = *ToCatchStmtOrErr; 6323288943Sdim else 6324344779Sdim return ToCatchStmtOrErr.takeError(); 6325288943Sdim } 6326344779Sdim 6327288943Sdim return ObjCAtTryStmt::Create(Importer.getToContext(), 6328344779Sdim ToAtTryLoc, ToTryBody, 6329288943Sdim ToCatchStmts.begin(), ToCatchStmts.size(), 6330344779Sdim ToFinallyStmt); 6331288943Sdim} 6332288943Sdim 6333344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtSynchronizedStmt 6334288943Sdim (ObjCAtSynchronizedStmt *S) { 6335344779Sdim auto Imp = importSeq( 6336344779Sdim S->getAtSynchronizedLoc(), S->getSynchExpr(), S->getSynchBody()); 6337344779Sdim if (!Imp) 6338344779Sdim return Imp.takeError(); 6339344779Sdim 6340344779Sdim SourceLocation ToAtSynchronizedLoc; 6341344779Sdim Expr *ToSynchExpr; 6342344779Sdim Stmt *ToSynchBody; 6343344779Sdim std::tie(ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody) = *Imp; 6344344779Sdim 6345288943Sdim return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 6346288943Sdim ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 6347288943Sdim} 6348288943Sdim 6349344779SdimExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 6350344779Sdim ExpectedSLoc ToThrowLocOrErr = import(S->getThrowLoc()); 6351344779Sdim if (!ToThrowLocOrErr) 6352344779Sdim return ToThrowLocOrErr.takeError(); 6353344779Sdim ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr()); 6354344779Sdim if (!ToThrowExprOrErr) 6355344779Sdim return ToThrowExprOrErr.takeError(); 6356344779Sdim return new (Importer.getToContext()) ObjCAtThrowStmt( 6357344779Sdim *ToThrowLocOrErr, *ToThrowExprOrErr); 6358288943Sdim} 6359288943Sdim 6360344779SdimExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt( 6361344779Sdim ObjCAutoreleasePoolStmt *S) { 6362344779Sdim ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc()); 6363344779Sdim if (!ToAtLocOrErr) 6364344779Sdim return ToAtLocOrErr.takeError(); 6365344779Sdim ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt()); 6366344779Sdim if (!ToSubStmtOrErr) 6367344779Sdim return ToSubStmtOrErr.takeError(); 6368344779Sdim return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr, 6369344779Sdim *ToSubStmtOrErr); 6370288943Sdim} 6371288943Sdim 6372203955Srdivacky//---------------------------------------------------------------------------- 6373203955Srdivacky// Import Expressions 6374203955Srdivacky//---------------------------------------------------------------------------- 6375344779SdimExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) { 6376344779Sdim Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node) 6377344779Sdim << E->getStmtClassName(); 6378344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 6379203955Srdivacky} 6380203955Srdivacky 6381344779SdimExpectedStmt ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) { 6382344779Sdim auto Imp = importSeq( 6383344779Sdim E->getBuiltinLoc(), E->getSubExpr(), E->getWrittenTypeInfo(), 6384344779Sdim E->getRParenLoc(), E->getType()); 6385344779Sdim if (!Imp) 6386344779Sdim return Imp.takeError(); 6387309124Sdim 6388344779Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6389344779Sdim Expr *ToSubExpr; 6390344779Sdim TypeSourceInfo *ToWrittenTypeInfo; 6391344779Sdim QualType ToType; 6392344779Sdim std::tie(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType) = 6393344779Sdim *Imp; 6394309124Sdim 6395309124Sdim return new (Importer.getToContext()) VAArgExpr( 6396344779Sdim ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType, 6397344779Sdim E->isMicrosoftABI()); 6398309124Sdim} 6399309124Sdim 6400353358SdimExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) { 6401353358Sdim auto Imp = importSeq(E->getCond(), E->getLHS(), E->getRHS(), 6402353358Sdim E->getBuiltinLoc(), E->getRParenLoc(), E->getType()); 6403353358Sdim if (!Imp) 6404353358Sdim return Imp.takeError(); 6405309124Sdim 6406353358Sdim Expr *ToCond; 6407353358Sdim Expr *ToLHS; 6408353358Sdim Expr *ToRHS; 6409353358Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6410353358Sdim QualType ToType; 6411353358Sdim std::tie(ToCond, ToLHS, ToRHS, ToBuiltinLoc, ToRParenLoc, ToType) = *Imp; 6412353358Sdim 6413353358Sdim ExprValueKind VK = E->getValueKind(); 6414353358Sdim ExprObjectKind OK = E->getObjectKind(); 6415353358Sdim 6416353358Sdim bool TypeDependent = ToCond->isTypeDependent(); 6417353358Sdim bool ValueDependent = ToCond->isValueDependent(); 6418353358Sdim 6419353358Sdim // The value of CondIsTrue only matters if the value is not 6420353358Sdim // condition-dependent. 6421353358Sdim bool CondIsTrue = !E->isConditionDependent() && E->isConditionTrue(); 6422353358Sdim 6423353358Sdim return new (Importer.getToContext()) 6424353358Sdim ChooseExpr(ToBuiltinLoc, ToCond, ToLHS, ToRHS, ToType, VK, OK, 6425353358Sdim ToRParenLoc, CondIsTrue, TypeDependent, ValueDependent); 6426353358Sdim} 6427353358Sdim 6428344779SdimExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { 6429344779Sdim ExpectedType TypeOrErr = import(E->getType()); 6430344779Sdim if (!TypeOrErr) 6431344779Sdim return TypeOrErr.takeError(); 6432344779Sdim 6433344779Sdim ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc()); 6434344779Sdim if (!BeginLocOrErr) 6435344779Sdim return BeginLocOrErr.takeError(); 6436344779Sdim 6437344779Sdim return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr); 6438309124Sdim} 6439309124Sdim 6440344779SdimExpectedStmt ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) { 6441344779Sdim auto Imp = importSeq( 6442344779Sdim E->getBeginLoc(), E->getType(), E->getFunctionName()); 6443344779Sdim if (!Imp) 6444344779Sdim return Imp.takeError(); 6445309124Sdim 6446344779Sdim SourceLocation ToBeginLoc; 6447344779Sdim QualType ToType; 6448344779Sdim StringLiteral *ToFunctionName; 6449344779Sdim std::tie(ToBeginLoc, ToType, ToFunctionName) = *Imp; 6450309124Sdim 6451344779Sdim return PredefinedExpr::Create(Importer.getToContext(), ToBeginLoc, ToType, 6452344779Sdim E->getIdentKind(), ToFunctionName); 6453309124Sdim} 6454309124Sdim 6455344779SdimExpectedStmt ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 6456344779Sdim auto Imp = importSeq( 6457344779Sdim E->getQualifierLoc(), E->getTemplateKeywordLoc(), E->getDecl(), 6458344779Sdim E->getLocation(), E->getType()); 6459344779Sdim if (!Imp) 6460344779Sdim return Imp.takeError(); 6461221345Sdim 6462344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 6463344779Sdim SourceLocation ToTemplateKeywordLoc, ToLocation; 6464344779Sdim ValueDecl *ToDecl; 6465344779Sdim QualType ToType; 6466344779Sdim std::tie(ToQualifierLoc, ToTemplateKeywordLoc, ToDecl, ToLocation, ToType) = 6467344779Sdim *Imp; 6468344779Sdim 6469344779Sdim NamedDecl *ToFoundD = nullptr; 6470221345Sdim if (E->getDecl() != E->getFoundDecl()) { 6471344779Sdim auto FoundDOrErr = import(E->getFoundDecl()); 6472344779Sdim if (!FoundDOrErr) 6473344779Sdim return FoundDOrErr.takeError(); 6474344779Sdim ToFoundD = *FoundDOrErr; 6475221345Sdim } 6476341825Sdim 6477314564Sdim TemplateArgumentListInfo ToTAInfo; 6478344779Sdim TemplateArgumentListInfo *ToResInfo = nullptr; 6479314564Sdim if (E->hasExplicitTemplateArgs()) { 6480344779Sdim if (Error Err = 6481360784Sdim ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(), 6482360784Sdim E->template_arguments(), ToTAInfo)) 6483344779Sdim return std::move(Err); 6484344779Sdim ToResInfo = &ToTAInfo; 6485314564Sdim } 6486314564Sdim 6487344779Sdim auto *ToE = DeclRefExpr::Create( 6488344779Sdim Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, ToDecl, 6489344779Sdim E->refersToEnclosingVariableOrCapture(), ToLocation, ToType, 6490353358Sdim E->getValueKind(), ToFoundD, ToResInfo, E->isNonOdrUse()); 6491226633Sdim if (E->hadMultipleCandidates()) 6492344779Sdim ToE->setHadMultipleCandidates(true); 6493344779Sdim return ToE; 6494204643Srdivacky} 6495204643Srdivacky 6496344779SdimExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 6497344779Sdim ExpectedType TypeOrErr = import(E->getType()); 6498344779Sdim if (!TypeOrErr) 6499344779Sdim return TypeOrErr.takeError(); 6500309124Sdim 6501344779Sdim return new (Importer.getToContext()) ImplicitValueInitExpr(*TypeOrErr); 6502309124Sdim} 6503309124Sdim 6504344779SdimExpectedStmt ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { 6505344779Sdim ExpectedExpr ToInitOrErr = import(E->getInit()); 6506344779Sdim if (!ToInitOrErr) 6507344779Sdim return ToInitOrErr.takeError(); 6508309124Sdim 6509344779Sdim ExpectedSLoc ToEqualOrColonLocOrErr = import(E->getEqualOrColonLoc()); 6510344779Sdim if (!ToEqualOrColonLocOrErr) 6511344779Sdim return ToEqualOrColonLocOrErr.takeError(); 6512309124Sdim 6513344779Sdim SmallVector<Expr *, 4> ToIndexExprs(E->getNumSubExprs() - 1); 6514309124Sdim // List elements from the second, the first is Init itself 6515344779Sdim for (unsigned I = 1, N = E->getNumSubExprs(); I < N; I++) { 6516344779Sdim if (ExpectedExpr ToArgOrErr = import(E->getSubExpr(I))) 6517344779Sdim ToIndexExprs[I - 1] = *ToArgOrErr; 6518309124Sdim else 6519344779Sdim return ToArgOrErr.takeError(); 6520309124Sdim } 6521309124Sdim 6522344779Sdim SmallVector<Designator, 4> ToDesignators(E->size()); 6523344779Sdim if (Error Err = ImportContainerChecked(E->designators(), ToDesignators)) 6524344779Sdim return std::move(Err); 6525309124Sdim 6526309124Sdim return DesignatedInitExpr::Create( 6527344779Sdim Importer.getToContext(), ToDesignators, 6528344779Sdim ToIndexExprs, *ToEqualOrColonLocOrErr, 6529344779Sdim E->usesGNUSyntax(), *ToInitOrErr); 6530309124Sdim} 6531309124Sdim 6532344779SdimExpectedStmt 6533344779SdimASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 6534344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6535344779Sdim if (!ToTypeOrErr) 6536344779Sdim return ToTypeOrErr.takeError(); 6537309124Sdim 6538344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6539344779Sdim if (!ToLocationOrErr) 6540344779Sdim return ToLocationOrErr.takeError(); 6541344779Sdim 6542344779Sdim return new (Importer.getToContext()) CXXNullPtrLiteralExpr( 6543344779Sdim *ToTypeOrErr, *ToLocationOrErr); 6544309124Sdim} 6545309124Sdim 6546344779SdimExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 6547344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6548344779Sdim if (!ToTypeOrErr) 6549344779Sdim return ToTypeOrErr.takeError(); 6550203955Srdivacky 6551344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6552344779Sdim if (!ToLocationOrErr) 6553344779Sdim return ToLocationOrErr.takeError(); 6554344779Sdim 6555344779Sdim return IntegerLiteral::Create( 6556344779Sdim Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr); 6557203955Srdivacky} 6558203955Srdivacky 6559309124Sdim 6560344779SdimExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) { 6561344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6562344779Sdim if (!ToTypeOrErr) 6563344779Sdim return ToTypeOrErr.takeError(); 6564344779Sdim 6565344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6566344779Sdim if (!ToLocationOrErr) 6567344779Sdim return ToLocationOrErr.takeError(); 6568344779Sdim 6569344779Sdim return FloatingLiteral::Create( 6570344779Sdim Importer.getToContext(), E->getValue(), E->isExact(), 6571344779Sdim *ToTypeOrErr, *ToLocationOrErr); 6572309124Sdim} 6573309124Sdim 6574344779SdimExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) { 6575344779Sdim auto ToTypeOrErr = import(E->getType()); 6576344779Sdim if (!ToTypeOrErr) 6577344779Sdim return ToTypeOrErr.takeError(); 6578276479Sdim 6579344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 6580344779Sdim if (!ToSubExprOrErr) 6581344779Sdim return ToSubExprOrErr.takeError(); 6582344779Sdim 6583344779Sdim return new (Importer.getToContext()) ImaginaryLiteral( 6584344779Sdim *ToSubExprOrErr, *ToTypeOrErr); 6585204643Srdivacky} 6586204643Srdivacky 6587344779SdimExpectedStmt ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 6588344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6589344779Sdim if (!ToTypeOrErr) 6590344779Sdim return ToTypeOrErr.takeError(); 6591309124Sdim 6592344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 6593344779Sdim if (!ToLocationOrErr) 6594344779Sdim return ToLocationOrErr.takeError(); 6595309124Sdim 6596344779Sdim return new (Importer.getToContext()) CharacterLiteral( 6597344779Sdim E->getValue(), E->getKind(), *ToTypeOrErr, *ToLocationOrErr); 6598309124Sdim} 6599309124Sdim 6600344779SdimExpectedStmt ASTNodeImporter::VisitStringLiteral(StringLiteral *E) { 6601344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6602344779Sdim if (!ToTypeOrErr) 6603344779Sdim return ToTypeOrErr.takeError(); 6604309124Sdim 6605344779Sdim SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated()); 6606344779Sdim if (Error Err = ImportArrayChecked( 6607344779Sdim E->tokloc_begin(), E->tokloc_end(), ToLocations.begin())) 6608344779Sdim return std::move(Err); 6609309124Sdim 6610344779Sdim return StringLiteral::Create( 6611344779Sdim Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(), 6612344779Sdim *ToTypeOrErr, ToLocations.data(), ToLocations.size()); 6613344779Sdim} 6614309124Sdim 6615344779SdimExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 6616344779Sdim auto Imp = importSeq( 6617344779Sdim E->getLParenLoc(), E->getTypeSourceInfo(), E->getType(), 6618344779Sdim E->getInitializer()); 6619344779Sdim if (!Imp) 6620344779Sdim return Imp.takeError(); 6621344779Sdim 6622344779Sdim SourceLocation ToLParenLoc; 6623344779Sdim TypeSourceInfo *ToTypeSourceInfo; 6624344779Sdim QualType ToType; 6625344779Sdim Expr *ToInitializer; 6626344779Sdim std::tie(ToLParenLoc, ToTypeSourceInfo, ToType, ToInitializer) = *Imp; 6627344779Sdim 6628309124Sdim return new (Importer.getToContext()) CompoundLiteralExpr( 6629344779Sdim ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(), 6630344779Sdim ToInitializer, E->isFileScope()); 6631309124Sdim} 6632309124Sdim 6633344779SdimExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) { 6634344779Sdim auto Imp = importSeq( 6635344779Sdim E->getBuiltinLoc(), E->getType(), E->getRParenLoc()); 6636344779Sdim if (!Imp) 6637344779Sdim return Imp.takeError(); 6638309124Sdim 6639344779Sdim SourceLocation ToBuiltinLoc, ToRParenLoc; 6640344779Sdim QualType ToType; 6641344779Sdim std::tie(ToBuiltinLoc, ToType, ToRParenLoc) = *Imp; 6642309124Sdim 6643344779Sdim SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs()); 6644344779Sdim if (Error Err = ImportArrayChecked( 6645344779Sdim E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(), 6646344779Sdim ToExprs.begin())) 6647344779Sdim return std::move(Err); 6648344779Sdim 6649309124Sdim return new (Importer.getToContext()) AtomicExpr( 6650344779Sdim ToBuiltinLoc, ToExprs, ToType, E->getOp(), ToRParenLoc); 6651309124Sdim} 6652309124Sdim 6653344779SdimExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) { 6654344779Sdim auto Imp = importSeq( 6655344779Sdim E->getAmpAmpLoc(), E->getLabelLoc(), E->getLabel(), E->getType()); 6656344779Sdim if (!Imp) 6657344779Sdim return Imp.takeError(); 6658309124Sdim 6659344779Sdim SourceLocation ToAmpAmpLoc, ToLabelLoc; 6660344779Sdim LabelDecl *ToLabel; 6661344779Sdim QualType ToType; 6662344779Sdim std::tie(ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType) = *Imp; 6663309124Sdim 6664309124Sdim return new (Importer.getToContext()) AddrLabelExpr( 6665344779Sdim ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType); 6666309124Sdim} 6667309124Sdim 6668344779SdimExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) { 6669344779Sdim auto Imp = importSeq(E->getSubExpr()); 6670344779Sdim if (!Imp) 6671344779Sdim return Imp.takeError(); 6672276479Sdim 6673344779Sdim Expr *ToSubExpr; 6674344779Sdim std::tie(ToSubExpr) = *Imp; 6675344779Sdim 6676353358Sdim // TODO : Handle APValue::ValueKind that require importing. 6677353358Sdim APValue::ValueKind Kind = E->getResultAPValueKind(); 6678353358Sdim if (Kind == APValue::Int || Kind == APValue::Float || 6679353358Sdim Kind == APValue::FixedPoint || Kind == APValue::ComplexFloat || 6680353358Sdim Kind == APValue::ComplexInt) 6681353358Sdim return ConstantExpr::Create(Importer.getToContext(), ToSubExpr, 6682353358Sdim E->getAPValueResult()); 6683344779Sdim return ConstantExpr::Create(Importer.getToContext(), ToSubExpr); 6684344779Sdim} 6685344779Sdim 6686344779SdimExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 6687344779Sdim auto Imp = importSeq(E->getLParen(), E->getRParen(), E->getSubExpr()); 6688344779Sdim if (!Imp) 6689344779Sdim return Imp.takeError(); 6690344779Sdim 6691344779Sdim SourceLocation ToLParen, ToRParen; 6692344779Sdim Expr *ToSubExpr; 6693344779Sdim std::tie(ToLParen, ToRParen, ToSubExpr) = *Imp; 6694344779Sdim 6695341825Sdim return new (Importer.getToContext()) 6696344779Sdim ParenExpr(ToLParen, ToRParen, ToSubExpr); 6697204643Srdivacky} 6698204643Srdivacky 6699344779SdimExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) { 6700344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumExprs()); 6701344779Sdim if (Error Err = ImportContainerChecked(E->exprs(), ToExprs)) 6702344779Sdim return std::move(Err); 6703309124Sdim 6704344779Sdim ExpectedSLoc ToLParenLocOrErr = import(E->getLParenLoc()); 6705344779Sdim if (!ToLParenLocOrErr) 6706344779Sdim return ToLParenLocOrErr.takeError(); 6707344779Sdim 6708344779Sdim ExpectedSLoc ToRParenLocOrErr = import(E->getRParenLoc()); 6709344779Sdim if (!ToRParenLocOrErr) 6710344779Sdim return ToRParenLocOrErr.takeError(); 6711344779Sdim 6712344779Sdim return ParenListExpr::Create(Importer.getToContext(), *ToLParenLocOrErr, 6713344779Sdim ToExprs, *ToRParenLocOrErr); 6714309124Sdim} 6715309124Sdim 6716344779SdimExpectedStmt ASTNodeImporter::VisitStmtExpr(StmtExpr *E) { 6717344779Sdim auto Imp = importSeq( 6718344779Sdim E->getSubStmt(), E->getType(), E->getLParenLoc(), E->getRParenLoc()); 6719344779Sdim if (!Imp) 6720344779Sdim return Imp.takeError(); 6721309124Sdim 6722344779Sdim CompoundStmt *ToSubStmt; 6723344779Sdim QualType ToType; 6724344779Sdim SourceLocation ToLParenLoc, ToRParenLoc; 6725344779Sdim std::tie(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc) = *Imp; 6726309124Sdim 6727360784Sdim return new (Importer.getToContext()) 6728360784Sdim StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc, 6729360784Sdim E->getTemplateDepth()); 6730309124Sdim} 6731309124Sdim 6732344779SdimExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 6733344779Sdim auto Imp = importSeq( 6734344779Sdim E->getSubExpr(), E->getType(), E->getOperatorLoc()); 6735344779Sdim if (!Imp) 6736344779Sdim return Imp.takeError(); 6737204643Srdivacky 6738344779Sdim Expr *ToSubExpr; 6739344779Sdim QualType ToType; 6740344779Sdim SourceLocation ToOperatorLoc; 6741344779Sdim std::tie(ToSubExpr, ToType, ToOperatorLoc) = *Imp; 6742276479Sdim 6743341825Sdim return new (Importer.getToContext()) UnaryOperator( 6744344779Sdim ToSubExpr, E->getOpcode(), ToType, E->getValueKind(), E->getObjectKind(), 6745344779Sdim ToOperatorLoc, E->canOverflow()); 6746204643Srdivacky} 6747204643Srdivacky 6748344779SdimExpectedStmt 6749341825SdimASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 6750344779Sdim auto Imp = importSeq(E->getType(), E->getOperatorLoc(), E->getRParenLoc()); 6751344779Sdim if (!Imp) 6752344779Sdim return Imp.takeError(); 6753341825Sdim 6754344779Sdim QualType ToType; 6755344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 6756344779Sdim std::tie(ToType, ToOperatorLoc, ToRParenLoc) = *Imp; 6757344779Sdim 6758204643Srdivacky if (E->isArgumentType()) { 6759344779Sdim Expected<TypeSourceInfo *> ToArgumentTypeInfoOrErr = 6760344779Sdim import(E->getArgumentTypeInfo()); 6761344779Sdim if (!ToArgumentTypeInfoOrErr) 6762344779Sdim return ToArgumentTypeInfoOrErr.takeError(); 6763276479Sdim 6764344779Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr( 6765344779Sdim E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc, 6766344779Sdim ToRParenLoc); 6767204643Srdivacky } 6768341825Sdim 6769344779Sdim ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr()); 6770344779Sdim if (!ToArgumentExprOrErr) 6771344779Sdim return ToArgumentExprOrErr.takeError(); 6772276479Sdim 6773344779Sdim return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr( 6774344779Sdim E->getKind(), *ToArgumentExprOrErr, ToType, ToOperatorLoc, ToRParenLoc); 6775204643Srdivacky} 6776204643Srdivacky 6777344779SdimExpectedStmt ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 6778344779Sdim auto Imp = importSeq( 6779344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getOperatorLoc()); 6780344779Sdim if (!Imp) 6781344779Sdim return Imp.takeError(); 6782204643Srdivacky 6783344779Sdim Expr *ToLHS, *ToRHS; 6784344779Sdim QualType ToType; 6785344779Sdim SourceLocation ToOperatorLoc; 6786344779Sdim std::tie(ToLHS, ToRHS, ToType, ToOperatorLoc) = *Imp; 6787276479Sdim 6788344779Sdim return new (Importer.getToContext()) BinaryOperator( 6789344779Sdim ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(), 6790344779Sdim E->getObjectKind(), ToOperatorLoc, E->getFPFeatures()); 6791204643Srdivacky} 6792204643Srdivacky 6793344779SdimExpectedStmt ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) { 6794344779Sdim auto Imp = importSeq( 6795344779Sdim E->getCond(), E->getQuestionLoc(), E->getLHS(), E->getColonLoc(), 6796344779Sdim E->getRHS(), E->getType()); 6797344779Sdim if (!Imp) 6798344779Sdim return Imp.takeError(); 6799309124Sdim 6800344779Sdim Expr *ToCond, *ToLHS, *ToRHS; 6801344779Sdim SourceLocation ToQuestionLoc, ToColonLoc; 6802344779Sdim QualType ToType; 6803344779Sdim std::tie(ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType) = *Imp; 6804309124Sdim 6805309124Sdim return new (Importer.getToContext()) ConditionalOperator( 6806344779Sdim ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType, 6807344779Sdim E->getValueKind(), E->getObjectKind()); 6808309124Sdim} 6809309124Sdim 6810344779SdimExpectedStmt ASTNodeImporter::VisitBinaryConditionalOperator( 6811309124Sdim BinaryConditionalOperator *E) { 6812344779Sdim auto Imp = importSeq( 6813344779Sdim E->getCommon(), E->getOpaqueValue(), E->getCond(), E->getTrueExpr(), 6814344779Sdim E->getFalseExpr(), E->getQuestionLoc(), E->getColonLoc(), E->getType()); 6815344779Sdim if (!Imp) 6816344779Sdim return Imp.takeError(); 6817309124Sdim 6818344779Sdim Expr *ToCommon, *ToCond, *ToTrueExpr, *ToFalseExpr; 6819344779Sdim OpaqueValueExpr *ToOpaqueValue; 6820344779Sdim SourceLocation ToQuestionLoc, ToColonLoc; 6821344779Sdim QualType ToType; 6822344779Sdim std::tie( 6823344779Sdim ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr, ToQuestionLoc, 6824344779Sdim ToColonLoc, ToType) = *Imp; 6825309124Sdim 6826309124Sdim return new (Importer.getToContext()) BinaryConditionalOperator( 6827344779Sdim ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr, 6828344779Sdim ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(), 6829344779Sdim E->getObjectKind()); 6830309124Sdim} 6831309124Sdim 6832344779SdimExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 6833344779Sdim auto Imp = importSeq( 6834344779Sdim E->getBeginLoc(), E->getQueriedTypeSourceInfo(), 6835344779Sdim E->getDimensionExpression(), E->getEndLoc(), E->getType()); 6836344779Sdim if (!Imp) 6837344779Sdim return Imp.takeError(); 6838314564Sdim 6839344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6840344779Sdim TypeSourceInfo *ToQueriedTypeSourceInfo; 6841344779Sdim Expr *ToDimensionExpression; 6842344779Sdim QualType ToType; 6843344779Sdim std::tie( 6844344779Sdim ToBeginLoc, ToQueriedTypeSourceInfo, ToDimensionExpression, ToEndLoc, 6845344779Sdim ToType) = *Imp; 6846314564Sdim 6847314564Sdim return new (Importer.getToContext()) ArrayTypeTraitExpr( 6848344779Sdim ToBeginLoc, E->getTrait(), ToQueriedTypeSourceInfo, E->getValue(), 6849344779Sdim ToDimensionExpression, ToEndLoc, ToType); 6850314564Sdim} 6851314564Sdim 6852344779SdimExpectedStmt ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 6853344779Sdim auto Imp = importSeq( 6854344779Sdim E->getBeginLoc(), E->getQueriedExpression(), E->getEndLoc(), E->getType()); 6855344779Sdim if (!Imp) 6856344779Sdim return Imp.takeError(); 6857314564Sdim 6858344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 6859344779Sdim Expr *ToQueriedExpression; 6860344779Sdim QualType ToType; 6861344779Sdim std::tie(ToBeginLoc, ToQueriedExpression, ToEndLoc, ToType) = *Imp; 6862314564Sdim 6863314564Sdim return new (Importer.getToContext()) ExpressionTraitExpr( 6864344779Sdim ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(), 6865344779Sdim ToEndLoc, ToType); 6866314564Sdim} 6867314564Sdim 6868344779SdimExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 6869344779Sdim auto Imp = importSeq( 6870344779Sdim E->getLocation(), E->getType(), E->getSourceExpr()); 6871344779Sdim if (!Imp) 6872344779Sdim return Imp.takeError(); 6873309124Sdim 6874344779Sdim SourceLocation ToLocation; 6875344779Sdim QualType ToType; 6876344779Sdim Expr *ToSourceExpr; 6877344779Sdim std::tie(ToLocation, ToType, ToSourceExpr) = *Imp; 6878309124Sdim 6879309124Sdim return new (Importer.getToContext()) OpaqueValueExpr( 6880344779Sdim ToLocation, ToType, E->getValueKind(), E->getObjectKind(), ToSourceExpr); 6881309124Sdim} 6882309124Sdim 6883344779SdimExpectedStmt ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 6884344779Sdim auto Imp = importSeq( 6885344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getRBracketLoc()); 6886344779Sdim if (!Imp) 6887344779Sdim return Imp.takeError(); 6888314564Sdim 6889344779Sdim Expr *ToLHS, *ToRHS; 6890344779Sdim SourceLocation ToRBracketLoc; 6891344779Sdim QualType ToType; 6892344779Sdim std::tie(ToLHS, ToRHS, ToType, ToRBracketLoc) = *Imp; 6893314564Sdim 6894314564Sdim return new (Importer.getToContext()) ArraySubscriptExpr( 6895344779Sdim ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(), 6896344779Sdim ToRBracketLoc); 6897314564Sdim} 6898314564Sdim 6899344779SdimExpectedStmt 6900344779SdimASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 6901344779Sdim auto Imp = importSeq( 6902344779Sdim E->getLHS(), E->getRHS(), E->getType(), E->getComputationLHSType(), 6903344779Sdim E->getComputationResultType(), E->getOperatorLoc()); 6904344779Sdim if (!Imp) 6905344779Sdim return Imp.takeError(); 6906276479Sdim 6907344779Sdim Expr *ToLHS, *ToRHS; 6908344779Sdim QualType ToType, ToComputationLHSType, ToComputationResultType; 6909344779Sdim SourceLocation ToOperatorLoc; 6910344779Sdim std::tie(ToLHS, ToRHS, ToType, ToComputationLHSType, ToComputationResultType, 6911344779Sdim ToOperatorLoc) = *Imp; 6912276479Sdim 6913344779Sdim return new (Importer.getToContext()) CompoundAssignOperator( 6914344779Sdim ToLHS, ToRHS, E->getOpcode(), ToType, E->getValueKind(), 6915344779Sdim E->getObjectKind(), ToComputationLHSType, ToComputationResultType, 6916344779Sdim ToOperatorLoc, E->getFPFeatures()); 6917204643Srdivacky} 6918204643Srdivacky 6919344779SdimExpected<CXXCastPath> 6920344779SdimASTNodeImporter::ImportCastPath(CastExpr *CE) { 6921344779Sdim CXXCastPath Path; 6922314564Sdim for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) { 6923344779Sdim if (auto SpecOrErr = import(*I)) 6924344779Sdim Path.push_back(*SpecOrErr); 6925314564Sdim else 6926344779Sdim return SpecOrErr.takeError(); 6927314564Sdim } 6928344779Sdim return Path; 6929212904Sdim} 6930212904Sdim 6931344779SdimExpectedStmt ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 6932344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 6933344779Sdim if (!ToTypeOrErr) 6934344779Sdim return ToTypeOrErr.takeError(); 6935203955Srdivacky 6936344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 6937344779Sdim if (!ToSubExprOrErr) 6938344779Sdim return ToSubExprOrErr.takeError(); 6939212904Sdim 6940344779Sdim Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E); 6941344779Sdim if (!ToBasePathOrErr) 6942344779Sdim return ToBasePathOrErr.takeError(); 6943212904Sdim 6944344779Sdim return ImplicitCastExpr::Create( 6945344779Sdim Importer.getToContext(), *ToTypeOrErr, E->getCastKind(), *ToSubExprOrErr, 6946344779Sdim &(*ToBasePathOrErr), E->getValueKind()); 6947203955Srdivacky} 6948203955Srdivacky 6949344779SdimExpectedStmt ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 6950344779Sdim auto Imp1 = importSeq( 6951344779Sdim E->getType(), E->getSubExpr(), E->getTypeInfoAsWritten()); 6952344779Sdim if (!Imp1) 6953344779Sdim return Imp1.takeError(); 6954276479Sdim 6955344779Sdim QualType ToType; 6956344779Sdim Expr *ToSubExpr; 6957344779Sdim TypeSourceInfo *ToTypeInfoAsWritten; 6958344779Sdim std::tie(ToType, ToSubExpr, ToTypeInfoAsWritten) = *Imp1; 6959204643Srdivacky 6960344779Sdim Expected<CXXCastPath> ToBasePathOrErr = ImportCastPath(E); 6961344779Sdim if (!ToBasePathOrErr) 6962344779Sdim return ToBasePathOrErr.takeError(); 6963344779Sdim CXXCastPath *ToBasePath = &(*ToBasePathOrErr); 6964276479Sdim 6965314564Sdim switch (E->getStmtClass()) { 6966314564Sdim case Stmt::CStyleCastExprClass: { 6967341825Sdim auto *CCE = cast<CStyleCastExpr>(E); 6968344779Sdim ExpectedSLoc ToLParenLocOrErr = import(CCE->getLParenLoc()); 6969344779Sdim if (!ToLParenLocOrErr) 6970344779Sdim return ToLParenLocOrErr.takeError(); 6971344779Sdim ExpectedSLoc ToRParenLocOrErr = import(CCE->getRParenLoc()); 6972344779Sdim if (!ToRParenLocOrErr) 6973344779Sdim return ToRParenLocOrErr.takeError(); 6974344779Sdim return CStyleCastExpr::Create( 6975344779Sdim Importer.getToContext(), ToType, E->getValueKind(), E->getCastKind(), 6976344779Sdim ToSubExpr, ToBasePath, ToTypeInfoAsWritten, *ToLParenLocOrErr, 6977344779Sdim *ToRParenLocOrErr); 6978314564Sdim } 6979314564Sdim 6980314564Sdim case Stmt::CXXFunctionalCastExprClass: { 6981341825Sdim auto *FCE = cast<CXXFunctionalCastExpr>(E); 6982344779Sdim ExpectedSLoc ToLParenLocOrErr = import(FCE->getLParenLoc()); 6983344779Sdim if (!ToLParenLocOrErr) 6984344779Sdim return ToLParenLocOrErr.takeError(); 6985344779Sdim ExpectedSLoc ToRParenLocOrErr = import(FCE->getRParenLoc()); 6986344779Sdim if (!ToRParenLocOrErr) 6987344779Sdim return ToRParenLocOrErr.takeError(); 6988344779Sdim return CXXFunctionalCastExpr::Create( 6989344779Sdim Importer.getToContext(), ToType, E->getValueKind(), ToTypeInfoAsWritten, 6990344779Sdim E->getCastKind(), ToSubExpr, ToBasePath, *ToLParenLocOrErr, 6991344779Sdim *ToRParenLocOrErr); 6992314564Sdim } 6993314564Sdim 6994314564Sdim case Stmt::ObjCBridgedCastExprClass: { 6995344779Sdim auto *OCE = cast<ObjCBridgedCastExpr>(E); 6996344779Sdim ExpectedSLoc ToLParenLocOrErr = import(OCE->getLParenLoc()); 6997344779Sdim if (!ToLParenLocOrErr) 6998344779Sdim return ToLParenLocOrErr.takeError(); 6999344779Sdim ExpectedSLoc ToBridgeKeywordLocOrErr = import(OCE->getBridgeKeywordLoc()); 7000344779Sdim if (!ToBridgeKeywordLocOrErr) 7001344779Sdim return ToBridgeKeywordLocOrErr.takeError(); 7002344779Sdim return new (Importer.getToContext()) ObjCBridgedCastExpr( 7003344779Sdim *ToLParenLocOrErr, OCE->getBridgeKind(), E->getCastKind(), 7004344779Sdim *ToBridgeKeywordLocOrErr, ToTypeInfoAsWritten, ToSubExpr); 7005314564Sdim } 7006314564Sdim default: 7007314564Sdim llvm_unreachable("Cast expression of unsupported type!"); 7008344779Sdim return make_error<ImportError>(ImportError::UnsupportedConstruct); 7009314564Sdim } 7010204643Srdivacky} 7011204643Srdivacky 7012344779SdimExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) { 7013344779Sdim SmallVector<OffsetOfNode, 4> ToNodes; 7014344779Sdim for (int I = 0, N = E->getNumComponents(); I < N; ++I) { 7015344779Sdim const OffsetOfNode &FromNode = E->getComponent(I); 7016314564Sdim 7017344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 7018344779Sdim if (FromNode.getKind() != OffsetOfNode::Base) { 7019344779Sdim auto Imp = importSeq(FromNode.getBeginLoc(), FromNode.getEndLoc()); 7020344779Sdim if (!Imp) 7021344779Sdim return Imp.takeError(); 7022344779Sdim std::tie(ToBeginLoc, ToEndLoc) = *Imp; 7023344779Sdim } 7024314564Sdim 7025344779Sdim switch (FromNode.getKind()) { 7026314564Sdim case OffsetOfNode::Array: 7027344779Sdim ToNodes.push_back( 7028344779Sdim OffsetOfNode(ToBeginLoc, FromNode.getArrayExprIndex(), ToEndLoc)); 7029314564Sdim break; 7030314564Sdim case OffsetOfNode::Base: { 7031344779Sdim auto ToBSOrErr = import(FromNode.getBase()); 7032344779Sdim if (!ToBSOrErr) 7033344779Sdim return ToBSOrErr.takeError(); 7034344779Sdim ToNodes.push_back(OffsetOfNode(*ToBSOrErr)); 7035314564Sdim break; 7036314564Sdim } 7037314564Sdim case OffsetOfNode::Field: { 7038344779Sdim auto ToFieldOrErr = import(FromNode.getField()); 7039344779Sdim if (!ToFieldOrErr) 7040344779Sdim return ToFieldOrErr.takeError(); 7041344779Sdim ToNodes.push_back(OffsetOfNode(ToBeginLoc, *ToFieldOrErr, ToEndLoc)); 7042314564Sdim break; 7043314564Sdim } 7044314564Sdim case OffsetOfNode::Identifier: { 7045344779Sdim IdentifierInfo *ToII = Importer.Import(FromNode.getFieldName()); 7046344779Sdim ToNodes.push_back(OffsetOfNode(ToBeginLoc, ToII, ToEndLoc)); 7047314564Sdim break; 7048314564Sdim } 7049314564Sdim } 7050314564Sdim } 7051314564Sdim 7052344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumExpressions()); 7053344779Sdim for (int I = 0, N = E->getNumExpressions(); I < N; ++I) { 7054344779Sdim ExpectedExpr ToIndexExprOrErr = import(E->getIndexExpr(I)); 7055344779Sdim if (!ToIndexExprOrErr) 7056344779Sdim return ToIndexExprOrErr.takeError(); 7057344779Sdim ToExprs[I] = *ToIndexExprOrErr; 7058314564Sdim } 7059314564Sdim 7060344779Sdim auto Imp = importSeq( 7061344779Sdim E->getType(), E->getTypeSourceInfo(), E->getOperatorLoc(), 7062344779Sdim E->getRParenLoc()); 7063344779Sdim if (!Imp) 7064344779Sdim return Imp.takeError(); 7065314564Sdim 7066344779Sdim QualType ToType; 7067344779Sdim TypeSourceInfo *ToTypeSourceInfo; 7068344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 7069344779Sdim std::tie(ToType, ToTypeSourceInfo, ToOperatorLoc, ToRParenLoc) = *Imp; 7070344779Sdim 7071344779Sdim return OffsetOfExpr::Create( 7072344779Sdim Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes, 7073344779Sdim ToExprs, ToRParenLoc); 7074314564Sdim} 7075314564Sdim 7076344779SdimExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 7077344779Sdim auto Imp = importSeq( 7078344779Sdim E->getType(), E->getOperand(), E->getBeginLoc(), E->getEndLoc()); 7079344779Sdim if (!Imp) 7080344779Sdim return Imp.takeError(); 7081314564Sdim 7082344779Sdim QualType ToType; 7083344779Sdim Expr *ToOperand; 7084344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 7085344779Sdim std::tie(ToType, ToOperand, ToBeginLoc, ToEndLoc) = *Imp; 7086314564Sdim 7087344779Sdim CanThrowResult ToCanThrow; 7088314564Sdim if (E->isValueDependent()) 7089344779Sdim ToCanThrow = CT_Dependent; 7090314564Sdim else 7091344779Sdim ToCanThrow = E->getValue() ? CT_Can : CT_Cannot; 7092314564Sdim 7093314564Sdim return new (Importer.getToContext()) CXXNoexceptExpr( 7094344779Sdim ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc); 7095314564Sdim} 7096314564Sdim 7097344779SdimExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) { 7098344779Sdim auto Imp = importSeq(E->getSubExpr(), E->getType(), E->getThrowLoc()); 7099344779Sdim if (!Imp) 7100344779Sdim return Imp.takeError(); 7101314564Sdim 7102344779Sdim Expr *ToSubExpr; 7103344779Sdim QualType ToType; 7104344779Sdim SourceLocation ToThrowLoc; 7105344779Sdim std::tie(ToSubExpr, ToType, ToThrowLoc) = *Imp; 7106314564Sdim 7107314564Sdim return new (Importer.getToContext()) CXXThrowExpr( 7108344779Sdim ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope()); 7109314564Sdim} 7110314564Sdim 7111344779SdimExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 7112344779Sdim ExpectedSLoc ToUsedLocOrErr = import(E->getUsedLocation()); 7113344779Sdim if (!ToUsedLocOrErr) 7114344779Sdim return ToUsedLocOrErr.takeError(); 7115314564Sdim 7116344779Sdim auto ToParamOrErr = import(E->getParam()); 7117344779Sdim if (!ToParamOrErr) 7118344779Sdim return ToParamOrErr.takeError(); 7119344779Sdim 7120353358Sdim auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext()); 7121353358Sdim if (!UsedContextOrErr) 7122353358Sdim return UsedContextOrErr.takeError(); 7123353358Sdim 7124360784Sdim // Import the default arg if it was not imported yet. 7125360784Sdim // This is needed because it can happen that during the import of the 7126360784Sdim // default expression (from VisitParmVarDecl) the same ParmVarDecl is 7127360784Sdim // encountered here. The default argument for a ParmVarDecl is set in the 7128360784Sdim // ParmVarDecl only after it is imported (set in VisitParmVarDecl if not here, 7129360784Sdim // see VisitParmVarDecl). 7130360784Sdim ParmVarDecl *ToParam = *ToParamOrErr; 7131360784Sdim if (!ToParam->getDefaultArg()) { 7132360784Sdim Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam); 7133360784Sdim assert(FromParam && "ParmVarDecl was not imported?"); 7134360784Sdim 7135360784Sdim if (Error Err = ImportDefaultArgOfParmVarDecl(*FromParam, ToParam)) 7136360784Sdim return std::move(Err); 7137360784Sdim } 7138360784Sdim 7139360784Sdim return CXXDefaultArgExpr::Create(Importer.getToContext(), *ToUsedLocOrErr, 7140360784Sdim *ToParamOrErr, *UsedContextOrErr); 7141314564Sdim} 7142314564Sdim 7143344779SdimExpectedStmt 7144344779SdimASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 7145344779Sdim auto Imp = importSeq( 7146344779Sdim E->getType(), E->getTypeSourceInfo(), E->getRParenLoc()); 7147344779Sdim if (!Imp) 7148344779Sdim return Imp.takeError(); 7149314564Sdim 7150344779Sdim QualType ToType; 7151344779Sdim TypeSourceInfo *ToTypeSourceInfo; 7152344779Sdim SourceLocation ToRParenLoc; 7153344779Sdim std::tie(ToType, ToTypeSourceInfo, ToRParenLoc) = *Imp; 7154314564Sdim 7155314564Sdim return new (Importer.getToContext()) CXXScalarValueInitExpr( 7156344779Sdim ToType, ToTypeSourceInfo, ToRParenLoc); 7157314564Sdim} 7158314564Sdim 7159344779SdimExpectedStmt 7160344779SdimASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 7161344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 7162344779Sdim if (!ToSubExprOrErr) 7163344779Sdim return ToSubExprOrErr.takeError(); 7164314564Sdim 7165344779Sdim auto ToDtorOrErr = import(E->getTemporary()->getDestructor()); 7166344779Sdim if (!ToDtorOrErr) 7167344779Sdim return ToDtorOrErr.takeError(); 7168314564Sdim 7169314564Sdim ASTContext &ToCtx = Importer.getToContext(); 7170344779Sdim CXXTemporary *Temp = CXXTemporary::Create(ToCtx, *ToDtorOrErr); 7171344779Sdim return CXXBindTemporaryExpr::Create(ToCtx, Temp, *ToSubExprOrErr); 7172314564Sdim} 7173314564Sdim 7174344779SdimExpectedStmt 7175344779SdimASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) { 7176344779Sdim auto Imp = importSeq( 7177344779Sdim E->getConstructor(), E->getType(), E->getTypeSourceInfo(), 7178344779Sdim E->getParenOrBraceRange()); 7179344779Sdim if (!Imp) 7180344779Sdim return Imp.takeError(); 7181314564Sdim 7182344779Sdim CXXConstructorDecl *ToConstructor; 7183344779Sdim QualType ToType; 7184344779Sdim TypeSourceInfo *ToTypeSourceInfo; 7185344779Sdim SourceRange ToParenOrBraceRange; 7186344779Sdim std::tie(ToConstructor, ToType, ToTypeSourceInfo, ToParenOrBraceRange) = *Imp; 7187341825Sdim 7188344779Sdim SmallVector<Expr *, 8> ToArgs(E->getNumArgs()); 7189344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7190344779Sdim return std::move(Err); 7191314564Sdim 7192344779Sdim return CXXTemporaryObjectExpr::Create( 7193344779Sdim Importer.getToContext(), ToConstructor, ToType, ToTypeSourceInfo, ToArgs, 7194344779Sdim ToParenOrBraceRange, E->hadMultipleCandidates(), 7195344779Sdim E->isListInitialization(), E->isStdInitListInitialization(), 7196344779Sdim E->requiresZeroInitialization()); 7197314564Sdim} 7198314564Sdim 7199360784SdimExpectedDecl ASTNodeImporter::VisitLifetimeExtendedTemporaryDecl( 7200360784Sdim LifetimeExtendedTemporaryDecl *D) { 7201360784Sdim DeclContext *DC, *LexicalDC; 7202360784Sdim if (Error Err = ImportDeclContext(D, DC, LexicalDC)) 7203360784Sdim return std::move(Err); 7204360784Sdim 7205360784Sdim auto Imp = importSeq(D->getTemporaryExpr(), D->getExtendingDecl()); 7206360784Sdim // FIXME: the APValue should be imported as well if present. 7207360784Sdim if (!Imp) 7208360784Sdim return Imp.takeError(); 7209360784Sdim 7210360784Sdim Expr *Temporary; 7211360784Sdim ValueDecl *ExtendingDecl; 7212360784Sdim std::tie(Temporary, ExtendingDecl) = *Imp; 7213360784Sdim // FIXME: Should ManglingNumber get numbers associated with 'to' context? 7214360784Sdim 7215360784Sdim LifetimeExtendedTemporaryDecl *To; 7216360784Sdim if (GetImportedOrCreateDecl(To, D, Temporary, ExtendingDecl, 7217360784Sdim D->getManglingNumber())) 7218360784Sdim return To; 7219360784Sdim 7220360784Sdim To->setLexicalDeclContext(LexicalDC); 7221360784Sdim LexicalDC->addDeclInternal(To); 7222360784Sdim return To; 7223360784Sdim} 7224360784Sdim 7225344779SdimExpectedStmt 7226314564SdimASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 7227360784Sdim auto Imp = importSeq(E->getType(), 7228360784Sdim E->getLifetimeExtendedTemporaryDecl() ? nullptr 7229360784Sdim : E->getSubExpr(), 7230360784Sdim E->getLifetimeExtendedTemporaryDecl()); 7231344779Sdim if (!Imp) 7232344779Sdim return Imp.takeError(); 7233314564Sdim 7234344779Sdim QualType ToType; 7235344779Sdim Expr *ToTemporaryExpr; 7236360784Sdim LifetimeExtendedTemporaryDecl *ToMaterializedDecl; 7237360784Sdim std::tie(ToType, ToTemporaryExpr, ToMaterializedDecl) = *Imp; 7238360784Sdim if (!ToTemporaryExpr) 7239360784Sdim ToTemporaryExpr = cast<Expr>(ToMaterializedDecl->getTemporaryExpr()); 7240314564Sdim 7241360784Sdim auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr( 7242360784Sdim ToType, ToTemporaryExpr, E->isBoundToLvalueReference(), 7243360784Sdim ToMaterializedDecl); 7244314564Sdim 7245314564Sdim return ToMTE; 7246314564Sdim} 7247314564Sdim 7248344779SdimExpectedStmt ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) { 7249344779Sdim auto Imp = importSeq( 7250344779Sdim E->getType(), E->getPattern(), E->getEllipsisLoc()); 7251344779Sdim if (!Imp) 7252344779Sdim return Imp.takeError(); 7253327952Sdim 7254344779Sdim QualType ToType; 7255344779Sdim Expr *ToPattern; 7256344779Sdim SourceLocation ToEllipsisLoc; 7257344779Sdim std::tie(ToType, ToPattern, ToEllipsisLoc) = *Imp; 7258327952Sdim 7259327952Sdim return new (Importer.getToContext()) PackExpansionExpr( 7260344779Sdim ToType, ToPattern, ToEllipsisLoc, E->getNumExpansions()); 7261327952Sdim} 7262327952Sdim 7263344779SdimExpectedStmt ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 7264344779Sdim auto Imp = importSeq( 7265344779Sdim E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc()); 7266344779Sdim if (!Imp) 7267344779Sdim return Imp.takeError(); 7268341825Sdim 7269344779Sdim SourceLocation ToOperatorLoc, ToPackLoc, ToRParenLoc; 7270344779Sdim NamedDecl *ToPack; 7271344779Sdim std::tie(ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc) = *Imp; 7272344779Sdim 7273341825Sdim Optional<unsigned> Length; 7274341825Sdim if (!E->isValueDependent()) 7275341825Sdim Length = E->getPackLength(); 7276341825Sdim 7277344779Sdim SmallVector<TemplateArgument, 8> ToPartialArguments; 7278341825Sdim if (E->isPartiallySubstituted()) { 7279344779Sdim if (Error Err = ImportTemplateArguments( 7280344779Sdim E->getPartialArguments().data(), 7281344779Sdim E->getPartialArguments().size(), 7282344779Sdim ToPartialArguments)) 7283344779Sdim return std::move(Err); 7284341825Sdim } 7285341825Sdim 7286341825Sdim return SizeOfPackExpr::Create( 7287344779Sdim Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc, 7288344779Sdim Length, ToPartialArguments); 7289341825Sdim} 7290341825Sdim 7291314564Sdim 7292344779SdimExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) { 7293344779Sdim auto Imp = importSeq( 7294344779Sdim E->getOperatorNew(), E->getOperatorDelete(), E->getTypeIdParens(), 7295344779Sdim E->getArraySize(), E->getInitializer(), E->getType(), 7296344779Sdim E->getAllocatedTypeSourceInfo(), E->getSourceRange(), 7297344779Sdim E->getDirectInitRange()); 7298344779Sdim if (!Imp) 7299344779Sdim return Imp.takeError(); 7300314564Sdim 7301344779Sdim FunctionDecl *ToOperatorNew, *ToOperatorDelete; 7302344779Sdim SourceRange ToTypeIdParens, ToSourceRange, ToDirectInitRange; 7303353358Sdim Optional<Expr *> ToArraySize; 7304353358Sdim Expr *ToInitializer; 7305344779Sdim QualType ToType; 7306344779Sdim TypeSourceInfo *ToAllocatedTypeSourceInfo; 7307344779Sdim std::tie( 7308344779Sdim ToOperatorNew, ToOperatorDelete, ToTypeIdParens, ToArraySize, ToInitializer, 7309344779Sdim ToType, ToAllocatedTypeSourceInfo, ToSourceRange, ToDirectInitRange) = *Imp; 7310314564Sdim 7311344779Sdim SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs()); 7312344779Sdim if (Error Err = 7313344779Sdim ImportContainerChecked(E->placement_arguments(), ToPlacementArgs)) 7314344779Sdim return std::move(Err); 7315314564Sdim 7316344779Sdim return CXXNewExpr::Create( 7317344779Sdim Importer.getToContext(), E->isGlobalNew(), ToOperatorNew, 7318344779Sdim ToOperatorDelete, E->passAlignment(), E->doesUsualArrayDeleteWantSize(), 7319344779Sdim ToPlacementArgs, ToTypeIdParens, ToArraySize, E->getInitializationStyle(), 7320344779Sdim ToInitializer, ToType, ToAllocatedTypeSourceInfo, ToSourceRange, 7321344779Sdim ToDirectInitRange); 7322314564Sdim} 7323314564Sdim 7324344779SdimExpectedStmt ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 7325344779Sdim auto Imp = importSeq( 7326344779Sdim E->getType(), E->getOperatorDelete(), E->getArgument(), E->getBeginLoc()); 7327344779Sdim if (!Imp) 7328344779Sdim return Imp.takeError(); 7329314564Sdim 7330344779Sdim QualType ToType; 7331344779Sdim FunctionDecl *ToOperatorDelete; 7332344779Sdim Expr *ToArgument; 7333344779Sdim SourceLocation ToBeginLoc; 7334344779Sdim std::tie(ToType, ToOperatorDelete, ToArgument, ToBeginLoc) = *Imp; 7335314564Sdim 7336314564Sdim return new (Importer.getToContext()) CXXDeleteExpr( 7337344779Sdim ToType, E->isGlobalDelete(), E->isArrayForm(), E->isArrayFormAsWritten(), 7338344779Sdim E->doesUsualArrayDeleteWantSize(), ToOperatorDelete, ToArgument, 7339344779Sdim ToBeginLoc); 7340314564Sdim} 7341314564Sdim 7342344779SdimExpectedStmt ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 7343344779Sdim auto Imp = importSeq( 7344344779Sdim E->getType(), E->getLocation(), E->getConstructor(), 7345344779Sdim E->getParenOrBraceRange()); 7346344779Sdim if (!Imp) 7347344779Sdim return Imp.takeError(); 7348288943Sdim 7349344779Sdim QualType ToType; 7350344779Sdim SourceLocation ToLocation; 7351344779Sdim CXXConstructorDecl *ToConstructor; 7352344779Sdim SourceRange ToParenOrBraceRange; 7353344779Sdim std::tie(ToType, ToLocation, ToConstructor, ToParenOrBraceRange) = *Imp; 7354288943Sdim 7355309124Sdim SmallVector<Expr *, 6> ToArgs(E->getNumArgs()); 7356344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7357344779Sdim return std::move(Err); 7358288943Sdim 7359344779Sdim return CXXConstructExpr::Create( 7360344779Sdim Importer.getToContext(), ToType, ToLocation, ToConstructor, 7361344779Sdim E->isElidable(), ToArgs, E->hadMultipleCandidates(), 7362344779Sdim E->isListInitialization(), E->isStdInitListInitialization(), 7363344779Sdim E->requiresZeroInitialization(), E->getConstructionKind(), 7364344779Sdim ToParenOrBraceRange); 7365288943Sdim} 7366288943Sdim 7367344779SdimExpectedStmt ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *E) { 7368344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 7369344779Sdim if (!ToSubExprOrErr) 7370344779Sdim return ToSubExprOrErr.takeError(); 7371314564Sdim 7372344779Sdim SmallVector<ExprWithCleanups::CleanupObject, 8> ToObjects(E->getNumObjects()); 7373344779Sdim if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects)) 7374344779Sdim return std::move(Err); 7375314564Sdim 7376344779Sdim return ExprWithCleanups::Create( 7377344779Sdim Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(), 7378344779Sdim ToObjects); 7379314564Sdim} 7380314564Sdim 7381344779SdimExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 7382344779Sdim auto Imp = importSeq( 7383344779Sdim E->getCallee(), E->getType(), E->getRParenLoc()); 7384344779Sdim if (!Imp) 7385344779Sdim return Imp.takeError(); 7386341825Sdim 7387344779Sdim Expr *ToCallee; 7388344779Sdim QualType ToType; 7389344779Sdim SourceLocation ToRParenLoc; 7390344779Sdim std::tie(ToCallee, ToType, ToRParenLoc) = *Imp; 7391341825Sdim 7392309124Sdim SmallVector<Expr *, 4> ToArgs(E->getNumArgs()); 7393344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7394344779Sdim return std::move(Err); 7395309124Sdim 7396344779Sdim return CXXMemberCallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, 7397344779Sdim ToType, E->getValueKind(), ToRParenLoc); 7398309124Sdim} 7399309124Sdim 7400344779SdimExpectedStmt ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) { 7401344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7402344779Sdim if (!ToTypeOrErr) 7403344779Sdim return ToTypeOrErr.takeError(); 7404341825Sdim 7405344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 7406344779Sdim if (!ToLocationOrErr) 7407344779Sdim return ToLocationOrErr.takeError(); 7408344779Sdim 7409344779Sdim return new (Importer.getToContext()) CXXThisExpr( 7410344779Sdim *ToLocationOrErr, *ToTypeOrErr, E->isImplicit()); 7411309124Sdim} 7412309124Sdim 7413344779SdimExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 7414344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7415344779Sdim if (!ToTypeOrErr) 7416344779Sdim return ToTypeOrErr.takeError(); 7417341825Sdim 7418344779Sdim ExpectedSLoc ToLocationOrErr = import(E->getLocation()); 7419344779Sdim if (!ToLocationOrErr) 7420344779Sdim return ToLocationOrErr.takeError(); 7421344779Sdim 7422344779Sdim return new (Importer.getToContext()) CXXBoolLiteralExpr( 7423344779Sdim E->getValue(), *ToTypeOrErr, *ToLocationOrErr); 7424309124Sdim} 7425309124Sdim 7426344779SdimExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 7427344779Sdim auto Imp1 = importSeq( 7428344779Sdim E->getBase(), E->getOperatorLoc(), E->getQualifierLoc(), 7429344779Sdim E->getTemplateKeywordLoc(), E->getMemberDecl(), E->getType()); 7430344779Sdim if (!Imp1) 7431344779Sdim return Imp1.takeError(); 7432309124Sdim 7433344779Sdim Expr *ToBase; 7434344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7435344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7436344779Sdim ValueDecl *ToMemberDecl; 7437344779Sdim QualType ToType; 7438344779Sdim std::tie( 7439344779Sdim ToBase, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, ToMemberDecl, 7440344779Sdim ToType) = *Imp1; 7441288943Sdim 7442344779Sdim auto Imp2 = importSeq( 7443344779Sdim E->getFoundDecl().getDecl(), E->getMemberNameInfo().getName(), 7444344779Sdim E->getMemberNameInfo().getLoc(), E->getLAngleLoc(), E->getRAngleLoc()); 7445344779Sdim if (!Imp2) 7446344779Sdim return Imp2.takeError(); 7447344779Sdim NamedDecl *ToDecl; 7448344779Sdim DeclarationName ToName; 7449344779Sdim SourceLocation ToLoc, ToLAngleLoc, ToRAngleLoc; 7450344779Sdim std::tie(ToDecl, ToName, ToLoc, ToLAngleLoc, ToRAngleLoc) = *Imp2; 7451288943Sdim 7452341825Sdim DeclAccessPair ToFoundDecl = 7453341825Sdim DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess()); 7454341825Sdim 7455344779Sdim DeclarationNameInfo ToMemberNameInfo(ToName, ToLoc); 7456288943Sdim 7457353358Sdim TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 7458288943Sdim if (E->hasExplicitTemplateArgs()) { 7459353358Sdim if (Error Err = 7460353358Sdim ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(), 7461353358Sdim E->template_arguments(), ToTAInfo)) 7462353358Sdim return std::move(Err); 7463353358Sdim ResInfo = &ToTAInfo; 7464288943Sdim } 7465288943Sdim 7466353358Sdim return MemberExpr::Create(Importer.getToContext(), ToBase, E->isArrow(), 7467353358Sdim ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7468353358Sdim ToMemberDecl, ToFoundDecl, ToMemberNameInfo, 7469353358Sdim ResInfo, ToType, E->getValueKind(), 7470353358Sdim E->getObjectKind(), E->isNonOdrUse()); 7471288943Sdim} 7472288943Sdim 7473344779SdimExpectedStmt 7474344779SdimASTNodeImporter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 7475344779Sdim auto Imp = importSeq( 7476344779Sdim E->getBase(), E->getOperatorLoc(), E->getQualifierLoc(), 7477344779Sdim E->getScopeTypeInfo(), E->getColonColonLoc(), E->getTildeLoc()); 7478344779Sdim if (!Imp) 7479344779Sdim return Imp.takeError(); 7480327952Sdim 7481344779Sdim Expr *ToBase; 7482344779Sdim SourceLocation ToOperatorLoc, ToColonColonLoc, ToTildeLoc; 7483344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7484344779Sdim TypeSourceInfo *ToScopeTypeInfo; 7485344779Sdim std::tie( 7486344779Sdim ToBase, ToOperatorLoc, ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, 7487344779Sdim ToTildeLoc) = *Imp; 7488327952Sdim 7489327952Sdim PseudoDestructorTypeStorage Storage; 7490327952Sdim if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) { 7491327952Sdim IdentifierInfo *ToII = Importer.Import(FromII); 7492344779Sdim ExpectedSLoc ToDestroyedTypeLocOrErr = import(E->getDestroyedTypeLoc()); 7493344779Sdim if (!ToDestroyedTypeLocOrErr) 7494344779Sdim return ToDestroyedTypeLocOrErr.takeError(); 7495344779Sdim Storage = PseudoDestructorTypeStorage(ToII, *ToDestroyedTypeLocOrErr); 7496327952Sdim } else { 7497344779Sdim if (auto ToTIOrErr = import(E->getDestroyedTypeInfo())) 7498344779Sdim Storage = PseudoDestructorTypeStorage(*ToTIOrErr); 7499344779Sdim else 7500344779Sdim return ToTIOrErr.takeError(); 7501327952Sdim } 7502327952Sdim 7503327952Sdim return new (Importer.getToContext()) CXXPseudoDestructorExpr( 7504344779Sdim Importer.getToContext(), ToBase, E->isArrow(), ToOperatorLoc, 7505344779Sdim ToQualifierLoc, ToScopeTypeInfo, ToColonColonLoc, ToTildeLoc, Storage); 7506327952Sdim} 7507327952Sdim 7508344779SdimExpectedStmt ASTNodeImporter::VisitCXXDependentScopeMemberExpr( 7509327952Sdim CXXDependentScopeMemberExpr *E) { 7510344779Sdim auto Imp = importSeq( 7511344779Sdim E->getType(), E->getOperatorLoc(), E->getQualifierLoc(), 7512344779Sdim E->getTemplateKeywordLoc(), E->getFirstQualifierFoundInScope()); 7513344779Sdim if (!Imp) 7514344779Sdim return Imp.takeError(); 7515344779Sdim 7516344779Sdim QualType ToType; 7517344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7518344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7519344779Sdim NamedDecl *ToFirstQualifierFoundInScope; 7520344779Sdim std::tie( 7521344779Sdim ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7522344779Sdim ToFirstQualifierFoundInScope) = *Imp; 7523344779Sdim 7524344779Sdim Expr *ToBase = nullptr; 7525327952Sdim if (!E->isImplicitAccess()) { 7526344779Sdim if (ExpectedExpr ToBaseOrErr = import(E->getBase())) 7527344779Sdim ToBase = *ToBaseOrErr; 7528344779Sdim else 7529344779Sdim return ToBaseOrErr.takeError(); 7530327952Sdim } 7531327952Sdim 7532341825Sdim TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 7533327952Sdim if (E->hasExplicitTemplateArgs()) { 7534344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 7535344779Sdim E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(), 7536344779Sdim ToTAInfo)) 7537344779Sdim return std::move(Err); 7538327952Sdim ResInfo = &ToTAInfo; 7539327952Sdim } 7540327952Sdim 7541344779Sdim auto ToMemberNameInfoOrErr = importSeq(E->getMember(), E->getMemberLoc()); 7542344779Sdim if (!ToMemberNameInfoOrErr) 7543344779Sdim return ToMemberNameInfoOrErr.takeError(); 7544344779Sdim DeclarationNameInfo ToMemberNameInfo( 7545344779Sdim std::get<0>(*ToMemberNameInfoOrErr), std::get<1>(*ToMemberNameInfoOrErr)); 7546327952Sdim // Import additional name location/type info. 7547344779Sdim if (Error Err = ImportDeclarationNameLoc( 7548344779Sdim E->getMemberNameInfo(), ToMemberNameInfo)) 7549344779Sdim return std::move(Err); 7550327952Sdim 7551327952Sdim return CXXDependentScopeMemberExpr::Create( 7552344779Sdim Importer.getToContext(), ToBase, ToType, E->isArrow(), ToOperatorLoc, 7553344779Sdim ToQualifierLoc, ToTemplateKeywordLoc, ToFirstQualifierFoundInScope, 7554344779Sdim ToMemberNameInfo, ResInfo); 7555327952Sdim} 7556327952Sdim 7557344779SdimExpectedStmt 7558341825SdimASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 7559360784Sdim auto Imp = importSeq(E->getQualifierLoc(), E->getTemplateKeywordLoc(), 7560360784Sdim E->getDeclName(), E->getNameInfo().getLoc(), 7561360784Sdim E->getLAngleLoc(), E->getRAngleLoc()); 7562344779Sdim if (!Imp) 7563344779Sdim return Imp.takeError(); 7564341825Sdim 7565344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7566360784Sdim SourceLocation ToTemplateKeywordLoc, ToNameLoc, ToLAngleLoc, ToRAngleLoc; 7567344779Sdim DeclarationName ToDeclName; 7568360784Sdim std::tie(ToQualifierLoc, ToTemplateKeywordLoc, ToDeclName, ToNameLoc, 7569360784Sdim ToLAngleLoc, ToRAngleLoc) = *Imp; 7570341825Sdim 7571360784Sdim DeclarationNameInfo ToNameInfo(ToDeclName, ToNameLoc); 7572344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7573344779Sdim return std::move(Err); 7574344779Sdim 7575344779Sdim TemplateArgumentListInfo ToTAInfo(ToLAngleLoc, ToRAngleLoc); 7576341825Sdim TemplateArgumentListInfo *ResInfo = nullptr; 7577341825Sdim if (E->hasExplicitTemplateArgs()) { 7578344779Sdim if (Error Err = 7579344779Sdim ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 7580344779Sdim return std::move(Err); 7581341825Sdim ResInfo = &ToTAInfo; 7582341825Sdim } 7583341825Sdim 7584341825Sdim return DependentScopeDeclRefExpr::Create( 7585344779Sdim Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc, 7586344779Sdim ToNameInfo, ResInfo); 7587341825Sdim} 7588341825Sdim 7589344779SdimExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr( 7590344779Sdim CXXUnresolvedConstructExpr *E) { 7591344779Sdim auto Imp = importSeq( 7592344779Sdim E->getLParenLoc(), E->getRParenLoc(), E->getTypeSourceInfo()); 7593344779Sdim if (!Imp) 7594344779Sdim return Imp.takeError(); 7595341825Sdim 7596344779Sdim SourceLocation ToLParenLoc, ToRParenLoc; 7597344779Sdim TypeSourceInfo *ToTypeSourceInfo; 7598344779Sdim std::tie(ToLParenLoc, ToRParenLoc, ToTypeSourceInfo) = *Imp; 7599341825Sdim 7600344779Sdim SmallVector<Expr *, 8> ToArgs(E->arg_size()); 7601344779Sdim if (Error Err = 7602344779Sdim ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin())) 7603344779Sdim return std::move(Err); 7604344779Sdim 7605341825Sdim return CXXUnresolvedConstructExpr::Create( 7606344779Sdim Importer.getToContext(), ToTypeSourceInfo, ToLParenLoc, 7607344779Sdim llvm::makeArrayRef(ToArgs), ToRParenLoc); 7608341825Sdim} 7609341825Sdim 7610344779SdimExpectedStmt 7611344779SdimASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 7612344779Sdim Expected<CXXRecordDecl *> ToNamingClassOrErr = import(E->getNamingClass()); 7613344779Sdim if (!ToNamingClassOrErr) 7614344779Sdim return ToNamingClassOrErr.takeError(); 7615341825Sdim 7616344779Sdim auto ToQualifierLocOrErr = import(E->getQualifierLoc()); 7617344779Sdim if (!ToQualifierLocOrErr) 7618344779Sdim return ToQualifierLocOrErr.takeError(); 7619341825Sdim 7620344779Sdim auto ToNameInfoOrErr = importSeq(E->getName(), E->getNameLoc()); 7621344779Sdim if (!ToNameInfoOrErr) 7622344779Sdim return ToNameInfoOrErr.takeError(); 7623344779Sdim DeclarationNameInfo ToNameInfo( 7624344779Sdim std::get<0>(*ToNameInfoOrErr), std::get<1>(*ToNameInfoOrErr)); 7625341825Sdim // Import additional name location/type info. 7626344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7627344779Sdim return std::move(Err); 7628341825Sdim 7629341825Sdim UnresolvedSet<8> ToDecls; 7630344779Sdim for (auto *D : E->decls()) 7631344779Sdim if (auto ToDOrErr = import(D)) 7632344779Sdim ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr)); 7633341825Sdim else 7634344779Sdim return ToDOrErr.takeError(); 7635341825Sdim 7636360784Sdim if (E->hasExplicitTemplateArgs()) { 7637344779Sdim TemplateArgumentListInfo ToTAInfo; 7638344779Sdim if (Error Err = ImportTemplateArgumentListInfo( 7639344779Sdim E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(), 7640344779Sdim ToTAInfo)) 7641344779Sdim return std::move(Err); 7642341825Sdim 7643344779Sdim ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc()); 7644344779Sdim if (!ToTemplateKeywordLocOrErr) 7645344779Sdim return ToTemplateKeywordLocOrErr.takeError(); 7646344779Sdim 7647341825Sdim return UnresolvedLookupExpr::Create( 7648344779Sdim Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr, 7649344779Sdim *ToTemplateKeywordLocOrErr, ToNameInfo, E->requiresADL(), &ToTAInfo, 7650344779Sdim ToDecls.begin(), ToDecls.end()); 7651344779Sdim } 7652341825Sdim 7653341825Sdim return UnresolvedLookupExpr::Create( 7654344779Sdim Importer.getToContext(), *ToNamingClassOrErr, *ToQualifierLocOrErr, 7655344779Sdim ToNameInfo, E->requiresADL(), E->isOverloaded(), ToDecls.begin(), 7656344779Sdim ToDecls.end()); 7657341825Sdim} 7658341825Sdim 7659344779SdimExpectedStmt 7660344779SdimASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 7661344779Sdim auto Imp1 = importSeq( 7662344779Sdim E->getType(), E->getOperatorLoc(), E->getQualifierLoc(), 7663344779Sdim E->getTemplateKeywordLoc()); 7664344779Sdim if (!Imp1) 7665344779Sdim return Imp1.takeError(); 7666344779Sdim 7667344779Sdim QualType ToType; 7668344779Sdim SourceLocation ToOperatorLoc, ToTemplateKeywordLoc; 7669344779Sdim NestedNameSpecifierLoc ToQualifierLoc; 7670344779Sdim std::tie(ToType, ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc) = *Imp1; 7671344779Sdim 7672344779Sdim auto Imp2 = importSeq(E->getName(), E->getNameLoc()); 7673344779Sdim if (!Imp2) 7674344779Sdim return Imp2.takeError(); 7675344779Sdim DeclarationNameInfo ToNameInfo(std::get<0>(*Imp2), std::get<1>(*Imp2)); 7676341825Sdim // Import additional name location/type info. 7677344779Sdim if (Error Err = ImportDeclarationNameLoc(E->getNameInfo(), ToNameInfo)) 7678344779Sdim return std::move(Err); 7679341825Sdim 7680341825Sdim UnresolvedSet<8> ToDecls; 7681344779Sdim for (Decl *D : E->decls()) 7682344779Sdim if (auto ToDOrErr = import(D)) 7683344779Sdim ToDecls.addDecl(cast<NamedDecl>(*ToDOrErr)); 7684341825Sdim else 7685344779Sdim return ToDOrErr.takeError(); 7686341825Sdim 7687341825Sdim TemplateArgumentListInfo ToTAInfo; 7688341825Sdim TemplateArgumentListInfo *ResInfo = nullptr; 7689341825Sdim if (E->hasExplicitTemplateArgs()) { 7690360784Sdim TemplateArgumentListInfo FromTAInfo; 7691360784Sdim E->copyTemplateArgumentsInto(FromTAInfo); 7692360784Sdim if (Error Err = ImportTemplateArgumentListInfo(FromTAInfo, ToTAInfo)) 7693344779Sdim return std::move(Err); 7694341825Sdim ResInfo = &ToTAInfo; 7695341825Sdim } 7696341825Sdim 7697344779Sdim Expr *ToBase = nullptr; 7698344779Sdim if (!E->isImplicitAccess()) { 7699344779Sdim if (ExpectedExpr ToBaseOrErr = import(E->getBase())) 7700344779Sdim ToBase = *ToBaseOrErr; 7701344779Sdim else 7702344779Sdim return ToBaseOrErr.takeError(); 7703341825Sdim } 7704341825Sdim 7705341825Sdim return UnresolvedMemberExpr::Create( 7706344779Sdim Importer.getToContext(), E->hasUnresolvedUsing(), ToBase, ToType, 7707344779Sdim E->isArrow(), ToOperatorLoc, ToQualifierLoc, ToTemplateKeywordLoc, 7708344779Sdim ToNameInfo, ResInfo, ToDecls.begin(), ToDecls.end()); 7709341825Sdim} 7710341825Sdim 7711344779SdimExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) { 7712344779Sdim auto Imp = importSeq(E->getCallee(), E->getType(), E->getRParenLoc()); 7713344779Sdim if (!Imp) 7714344779Sdim return Imp.takeError(); 7715288943Sdim 7716344779Sdim Expr *ToCallee; 7717344779Sdim QualType ToType; 7718344779Sdim SourceLocation ToRParenLoc; 7719344779Sdim std::tie(ToCallee, ToType, ToRParenLoc) = *Imp; 7720288943Sdim 7721288943Sdim unsigned NumArgs = E->getNumArgs(); 7722344779Sdim llvm::SmallVector<Expr *, 2> ToArgs(NumArgs); 7723344779Sdim if (Error Err = ImportContainerChecked(E->arguments(), ToArgs)) 7724344779Sdim return std::move(Err); 7725288943Sdim 7726341825Sdim if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) { 7727344779Sdim return CXXOperatorCallExpr::Create( 7728344779Sdim Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType, 7729344779Sdim OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(), 7730344779Sdim OCE->getADLCallKind()); 7731341825Sdim } 7732341825Sdim 7733344779Sdim return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType, 7734344779Sdim E->getValueKind(), ToRParenLoc, /*MinNumArgs=*/0, 7735344779Sdim E->getADLCallKind()); 7736288943Sdim} 7737288943Sdim 7738344779SdimExpectedStmt ASTNodeImporter::VisitLambdaExpr(LambdaExpr *E) { 7739344779Sdim CXXRecordDecl *FromClass = E->getLambdaClass(); 7740344779Sdim auto ToClassOrErr = import(FromClass); 7741344779Sdim if (!ToClassOrErr) 7742344779Sdim return ToClassOrErr.takeError(); 7743344779Sdim CXXRecordDecl *ToClass = *ToClassOrErr; 7744341825Sdim 7745344779Sdim auto ToCallOpOrErr = import(E->getCallOperator()); 7746344779Sdim if (!ToCallOpOrErr) 7747344779Sdim return ToCallOpOrErr.takeError(); 7748341825Sdim 7749344779Sdim SmallVector<LambdaCapture, 8> ToCaptures; 7750344779Sdim ToCaptures.reserve(E->capture_size()); 7751344779Sdim for (const auto &FromCapture : E->captures()) { 7752344779Sdim if (auto ToCaptureOrErr = import(FromCapture)) 7753344779Sdim ToCaptures.push_back(*ToCaptureOrErr); 7754341825Sdim else 7755344779Sdim return ToCaptureOrErr.takeError(); 7756341825Sdim } 7757341825Sdim 7758344779Sdim SmallVector<Expr *, 8> ToCaptureInits(E->capture_size()); 7759344779Sdim if (Error Err = ImportContainerChecked(E->capture_inits(), ToCaptureInits)) 7760344779Sdim return std::move(Err); 7761341825Sdim 7762344779Sdim auto Imp = importSeq( 7763344779Sdim E->getIntroducerRange(), E->getCaptureDefaultLoc(), E->getEndLoc()); 7764344779Sdim if (!Imp) 7765344779Sdim return Imp.takeError(); 7766344779Sdim 7767344779Sdim SourceRange ToIntroducerRange; 7768344779Sdim SourceLocation ToCaptureDefaultLoc, ToEndLoc; 7769344779Sdim std::tie(ToIntroducerRange, ToCaptureDefaultLoc, ToEndLoc) = *Imp; 7770344779Sdim 7771344779Sdim return LambdaExpr::Create( 7772344779Sdim Importer.getToContext(), ToClass, ToIntroducerRange, 7773344779Sdim E->getCaptureDefault(), ToCaptureDefaultLoc, ToCaptures, 7774344779Sdim E->hasExplicitParameters(), E->hasExplicitResultType(), ToCaptureInits, 7775344779Sdim ToEndLoc, E->containsUnexpandedParameterPack()); 7776341825Sdim} 7777341825Sdim 7778309124Sdim 7779344779SdimExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) { 7780344779Sdim auto Imp = importSeq(E->getLBraceLoc(), E->getRBraceLoc(), E->getType()); 7781344779Sdim if (!Imp) 7782344779Sdim return Imp.takeError(); 7783309124Sdim 7784344779Sdim SourceLocation ToLBraceLoc, ToRBraceLoc; 7785344779Sdim QualType ToType; 7786344779Sdim std::tie(ToLBraceLoc, ToRBraceLoc, ToType) = *Imp; 7787344779Sdim 7788344779Sdim SmallVector<Expr *, 4> ToExprs(E->getNumInits()); 7789344779Sdim if (Error Err = ImportContainerChecked(E->inits(), ToExprs)) 7790344779Sdim return std::move(Err); 7791344779Sdim 7792309124Sdim ASTContext &ToCtx = Importer.getToContext(); 7793309124Sdim InitListExpr *To = new (ToCtx) InitListExpr( 7794344779Sdim ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc); 7795344779Sdim To->setType(ToType); 7796309124Sdim 7797344779Sdim if (E->hasArrayFiller()) { 7798344779Sdim if (ExpectedExpr ToFillerOrErr = import(E->getArrayFiller())) 7799344779Sdim To->setArrayFiller(*ToFillerOrErr); 7800344779Sdim else 7801344779Sdim return ToFillerOrErr.takeError(); 7802309124Sdim } 7803309124Sdim 7804344779Sdim if (FieldDecl *FromFD = E->getInitializedFieldInUnion()) { 7805344779Sdim if (auto ToFDOrErr = import(FromFD)) 7806344779Sdim To->setInitializedFieldInUnion(*ToFDOrErr); 7807344779Sdim else 7808344779Sdim return ToFDOrErr.takeError(); 7809309124Sdim } 7810309124Sdim 7811344779Sdim if (InitListExpr *SyntForm = E->getSyntacticForm()) { 7812344779Sdim if (auto ToSyntFormOrErr = import(SyntForm)) 7813344779Sdim To->setSyntacticForm(*ToSyntFormOrErr); 7814344779Sdim else 7815344779Sdim return ToSyntFormOrErr.takeError(); 7816309124Sdim } 7817309124Sdim 7818344779Sdim // Copy InitListExprBitfields, which are not handled in the ctor of 7819344779Sdim // InitListExpr. 7820344779Sdim To->sawArrayRangeDesignator(E->hadArrayRangeDesignator()); 7821309124Sdim 7822309124Sdim return To; 7823309124Sdim} 7824309124Sdim 7825344779SdimExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr( 7826341825Sdim CXXStdInitializerListExpr *E) { 7827344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7828344779Sdim if (!ToTypeOrErr) 7829344779Sdim return ToTypeOrErr.takeError(); 7830341825Sdim 7831344779Sdim ExpectedExpr ToSubExprOrErr = import(E->getSubExpr()); 7832344779Sdim if (!ToSubExprOrErr) 7833344779Sdim return ToSubExprOrErr.takeError(); 7834341825Sdim 7835344779Sdim return new (Importer.getToContext()) CXXStdInitializerListExpr( 7836344779Sdim *ToTypeOrErr, *ToSubExprOrErr); 7837341825Sdim} 7838341825Sdim 7839344779SdimExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr( 7840341825Sdim CXXInheritedCtorInitExpr *E) { 7841344779Sdim auto Imp = importSeq(E->getLocation(), E->getType(), E->getConstructor()); 7842344779Sdim if (!Imp) 7843344779Sdim return Imp.takeError(); 7844341825Sdim 7845344779Sdim SourceLocation ToLocation; 7846344779Sdim QualType ToType; 7847344779Sdim CXXConstructorDecl *ToConstructor; 7848344779Sdim std::tie(ToLocation, ToType, ToConstructor) = *Imp; 7849341825Sdim 7850341825Sdim return new (Importer.getToContext()) CXXInheritedCtorInitExpr( 7851344779Sdim ToLocation, ToType, ToConstructor, E->constructsVBase(), 7852344779Sdim E->inheritedFromVBase()); 7853341825Sdim} 7854341825Sdim 7855344779SdimExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 7856344779Sdim auto Imp = importSeq(E->getType(), E->getCommonExpr(), E->getSubExpr()); 7857344779Sdim if (!Imp) 7858344779Sdim return Imp.takeError(); 7859314564Sdim 7860344779Sdim QualType ToType; 7861344779Sdim Expr *ToCommonExpr, *ToSubExpr; 7862344779Sdim std::tie(ToType, ToCommonExpr, ToSubExpr) = *Imp; 7863314564Sdim 7864344779Sdim return new (Importer.getToContext()) ArrayInitLoopExpr( 7865344779Sdim ToType, ToCommonExpr, ToSubExpr); 7866314564Sdim} 7867314564Sdim 7868344779SdimExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 7869344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7870344779Sdim if (!ToTypeOrErr) 7871344779Sdim return ToTypeOrErr.takeError(); 7872344779Sdim return new (Importer.getToContext()) ArrayInitIndexExpr(*ToTypeOrErr); 7873314564Sdim} 7874314564Sdim 7875344779SdimExpectedStmt ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) { 7876344779Sdim ExpectedSLoc ToBeginLocOrErr = import(E->getBeginLoc()); 7877344779Sdim if (!ToBeginLocOrErr) 7878344779Sdim return ToBeginLocOrErr.takeError(); 7879309124Sdim 7880344779Sdim auto ToFieldOrErr = import(E->getField()); 7881344779Sdim if (!ToFieldOrErr) 7882344779Sdim return ToFieldOrErr.takeError(); 7883344779Sdim 7884353358Sdim auto UsedContextOrErr = Importer.ImportContext(E->getUsedContext()); 7885353358Sdim if (!UsedContextOrErr) 7886353358Sdim return UsedContextOrErr.takeError(); 7887353358Sdim 7888309124Sdim return CXXDefaultInitExpr::Create( 7889353358Sdim Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr); 7890309124Sdim} 7891309124Sdim 7892344779SdimExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 7893344779Sdim auto Imp = importSeq( 7894344779Sdim E->getType(), E->getSubExpr(), E->getTypeInfoAsWritten(), 7895344779Sdim E->getOperatorLoc(), E->getRParenLoc(), E->getAngleBrackets()); 7896344779Sdim if (!Imp) 7897344779Sdim return Imp.takeError(); 7898344779Sdim 7899344779Sdim QualType ToType; 7900344779Sdim Expr *ToSubExpr; 7901344779Sdim TypeSourceInfo *ToTypeInfoAsWritten; 7902344779Sdim SourceLocation ToOperatorLoc, ToRParenLoc; 7903344779Sdim SourceRange ToAngleBrackets; 7904344779Sdim std::tie( 7905344779Sdim ToType, ToSubExpr, ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, 7906344779Sdim ToAngleBrackets) = *Imp; 7907344779Sdim 7908309124Sdim ExprValueKind VK = E->getValueKind(); 7909309124Sdim CastKind CK = E->getCastKind(); 7910344779Sdim auto ToBasePathOrErr = ImportCastPath(E); 7911344779Sdim if (!ToBasePathOrErr) 7912344779Sdim return ToBasePathOrErr.takeError(); 7913341825Sdim 7914309124Sdim if (isa<CXXStaticCastExpr>(E)) { 7915309124Sdim return CXXStaticCastExpr::Create( 7916344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7917344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7918309124Sdim } else if (isa<CXXDynamicCastExpr>(E)) { 7919309124Sdim return CXXDynamicCastExpr::Create( 7920344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7921344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7922309124Sdim } else if (isa<CXXReinterpretCastExpr>(E)) { 7923309124Sdim return CXXReinterpretCastExpr::Create( 7924344779Sdim Importer.getToContext(), ToType, VK, CK, ToSubExpr, &(*ToBasePathOrErr), 7925344779Sdim ToTypeInfoAsWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7926344779Sdim } else if (isa<CXXConstCastExpr>(E)) { 7927344779Sdim return CXXConstCastExpr::Create( 7928344779Sdim Importer.getToContext(), ToType, VK, ToSubExpr, ToTypeInfoAsWritten, 7929344779Sdim ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 7930309124Sdim } else { 7931344779Sdim llvm_unreachable("Unknown cast type"); 7932344779Sdim return make_error<ImportError>(); 7933309124Sdim } 7934309124Sdim} 7935309124Sdim 7936344779SdimExpectedStmt ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr( 7937321369Sdim SubstNonTypeTemplateParmExpr *E) { 7938344779Sdim auto Imp = importSeq( 7939344779Sdim E->getType(), E->getExprLoc(), E->getParameter(), E->getReplacement()); 7940344779Sdim if (!Imp) 7941344779Sdim return Imp.takeError(); 7942321369Sdim 7943344779Sdim QualType ToType; 7944344779Sdim SourceLocation ToExprLoc; 7945344779Sdim NonTypeTemplateParmDecl *ToParameter; 7946344779Sdim Expr *ToReplacement; 7947344779Sdim std::tie(ToType, ToExprLoc, ToParameter, ToReplacement) = *Imp; 7948321369Sdim 7949321369Sdim return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr( 7950344779Sdim ToType, E->getValueKind(), ToExprLoc, ToParameter, ToReplacement); 7951321369Sdim} 7952321369Sdim 7953344779SdimExpectedStmt ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) { 7954344779Sdim auto Imp = importSeq( 7955344779Sdim E->getType(), E->getBeginLoc(), E->getEndLoc()); 7956344779Sdim if (!Imp) 7957344779Sdim return Imp.takeError(); 7958327952Sdim 7959344779Sdim QualType ToType; 7960344779Sdim SourceLocation ToBeginLoc, ToEndLoc; 7961344779Sdim std::tie(ToType, ToBeginLoc, ToEndLoc) = *Imp; 7962344779Sdim 7963327952Sdim SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs()); 7964344779Sdim if (Error Err = ImportContainerChecked(E->getArgs(), ToArgs)) 7965344779Sdim return std::move(Err); 7966327952Sdim 7967327952Sdim // According to Sema::BuildTypeTrait(), if E is value-dependent, 7968327952Sdim // Value is always false. 7969344779Sdim bool ToValue = (E->isValueDependent() ? false : E->getValue()); 7970327952Sdim 7971327952Sdim return TypeTraitExpr::Create( 7972344779Sdim Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs, 7973344779Sdim ToEndLoc, ToValue); 7974327952Sdim} 7975327952Sdim 7976344779SdimExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 7977344779Sdim ExpectedType ToTypeOrErr = import(E->getType()); 7978344779Sdim if (!ToTypeOrErr) 7979344779Sdim return ToTypeOrErr.takeError(); 7980341825Sdim 7981344779Sdim auto ToSourceRangeOrErr = import(E->getSourceRange()); 7982344779Sdim if (!ToSourceRangeOrErr) 7983344779Sdim return ToSourceRangeOrErr.takeError(); 7984344779Sdim 7985341825Sdim if (E->isTypeOperand()) { 7986344779Sdim if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo())) 7987344779Sdim return new (Importer.getToContext()) CXXTypeidExpr( 7988344779Sdim *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr); 7989344779Sdim else 7990344779Sdim return ToTSIOrErr.takeError(); 7991341825Sdim } 7992341825Sdim 7993344779Sdim ExpectedExpr ToExprOperandOrErr = import(E->getExprOperand()); 7994344779Sdim if (!ToExprOperandOrErr) 7995344779Sdim return ToExprOperandOrErr.takeError(); 7996341825Sdim 7997344779Sdim return new (Importer.getToContext()) CXXTypeidExpr( 7998344779Sdim *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr); 7999341825Sdim} 8000341825Sdim 8001360784SdimError ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod, 8002360784Sdim CXXMethodDecl *FromMethod) { 8003360784Sdim Error ImportErrors = Error::success(); 8004344779Sdim for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) { 8005344779Sdim if (auto ImportedOrErr = import(FromOverriddenMethod)) 8006344779Sdim ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>( 8007344779Sdim (*ImportedOrErr)->getCanonicalDecl())); 8008344779Sdim else 8009360784Sdim ImportErrors = 8010360784Sdim joinErrors(std::move(ImportErrors), ImportedOrErr.takeError()); 8011344779Sdim } 8012360784Sdim return ImportErrors; 8013321369Sdim} 8014321369Sdim 8015218893SdimASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 8016218893Sdim ASTContext &FromContext, FileManager &FromFileManager, 8017344779Sdim bool MinimalImport, 8018353358Sdim std::shared_ptr<ASTImporterSharedState> SharedState) 8019353358Sdim : SharedState(SharedState), ToContext(ToContext), FromContext(FromContext), 8020341825Sdim ToFileManager(ToFileManager), FromFileManager(FromFileManager), 8021360784Sdim Minimal(MinimalImport), ODRHandling(ODRHandlingType::Conservative) { 8022344779Sdim 8023353358Sdim // Create a default state without the lookup table: LLDB case. 8024353358Sdim if (!SharedState) { 8025353358Sdim this->SharedState = std::make_shared<ASTImporterSharedState>(); 8026353358Sdim } 8027353358Sdim 8028344779Sdim ImportedDecls[FromContext.getTranslationUnitDecl()] = 8029344779Sdim ToContext.getTranslationUnitDecl(); 8030203955Srdivacky} 8031203955Srdivacky 8032341825SdimASTImporter::~ASTImporter() = default; 8033203955Srdivacky 8034344779SdimOptional<unsigned> ASTImporter::getFieldIndex(Decl *F) { 8035344779Sdim assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) && 8036344779Sdim "Try to get field index for non-field."); 8037344779Sdim 8038344779Sdim auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 8039344779Sdim if (!Owner) 8040344779Sdim return None; 8041344779Sdim 8042344779Sdim unsigned Index = 0; 8043344779Sdim for (const auto *D : Owner->decls()) { 8044344779Sdim if (D == F) 8045344779Sdim return Index; 8046344779Sdim 8047344779Sdim if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 8048344779Sdim ++Index; 8049344779Sdim } 8050344779Sdim 8051344779Sdim llvm_unreachable("Field was not found in its parent context."); 8052344779Sdim 8053344779Sdim return None; 8054344779Sdim} 8055344779Sdim 8056344779SdimASTImporter::FoundDeclsTy 8057344779SdimASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) { 8058344779Sdim // We search in the redecl context because of transparent contexts. 8059344779Sdim // E.g. a simple C language enum is a transparent context: 8060344779Sdim // enum E { A, B }; 8061344779Sdim // Now if we had a global variable in the TU 8062344779Sdim // int A; 8063344779Sdim // then the enum constant 'A' and the variable 'A' violates ODR. 8064344779Sdim // We can diagnose this only if we search in the redecl context. 8065344779Sdim DeclContext *ReDC = DC->getRedeclContext(); 8066353358Sdim if (SharedState->getLookupTable()) { 8067344779Sdim ASTImporterLookupTable::LookupResult LookupResult = 8068353358Sdim SharedState->getLookupTable()->lookup(ReDC, Name); 8069344779Sdim return FoundDeclsTy(LookupResult.begin(), LookupResult.end()); 8070344779Sdim } else { 8071353358Sdim DeclContext::lookup_result NoloadLookupResult = ReDC->noload_lookup(Name); 8072353358Sdim FoundDeclsTy Result(NoloadLookupResult.begin(), NoloadLookupResult.end()); 8073353358Sdim // We must search by the slow case of localUncachedLookup because that is 8074353358Sdim // working even if there is no LookupPtr for the DC. We could use 8075353358Sdim // DC::buildLookup() to create the LookupPtr, but that would load external 8076353358Sdim // decls again, we must avoid that case. 8077353358Sdim // Also, even if we had the LookupPtr, we must find Decls which are not 8078353358Sdim // in the LookupPtr, so we need the slow case. 8079353358Sdim // These cases are handled in ASTImporterLookupTable, but we cannot use 8080353358Sdim // that with LLDB since that traverses through the AST which initiates the 8081353358Sdim // load of external decls again via DC::decls(). And again, we must avoid 8082353358Sdim // loading external decls during the import. 8083353358Sdim if (Result.empty()) 8084353358Sdim ReDC->localUncachedLookup(Name, Result); 8085344779Sdim return Result; 8086344779Sdim } 8087344779Sdim} 8088344779Sdim 8089344779Sdimvoid ASTImporter::AddToLookupTable(Decl *ToD) { 8090353358Sdim SharedState->addDeclToLookup(ToD); 8091344779Sdim} 8092344779Sdim 8093353358SdimExpected<Decl *> ASTImporter::ImportImpl(Decl *FromD) { 8094353358Sdim // Import the decl using ASTNodeImporter. 8095353358Sdim ASTNodeImporter Importer(*this); 8096353358Sdim return Importer.Visit(FromD); 8097353358Sdim} 8098353358Sdim 8099353358Sdimvoid ASTImporter::RegisterImportedDecl(Decl *FromD, Decl *ToD) { 8100353358Sdim MapImported(FromD, ToD); 8101353358Sdim} 8102353358Sdim 8103353358SdimExpected<QualType> ASTImporter::Import(QualType FromT) { 8104203955Srdivacky if (FromT.isNull()) 8105353358Sdim return QualType{}; 8106218893Sdim 8107344779Sdim const Type *FromTy = FromT.getTypePtr(); 8108341825Sdim 8109341825Sdim // Check whether we've already imported this type. 8110218893Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos 8111344779Sdim = ImportedTypes.find(FromTy); 8112203955Srdivacky if (Pos != ImportedTypes.end()) 8113218893Sdim return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 8114341825Sdim 8115203955Srdivacky // Import the type 8116203955Srdivacky ASTNodeImporter Importer(*this); 8117344779Sdim ExpectedType ToTOrErr = Importer.Visit(FromTy); 8118353358Sdim if (!ToTOrErr) 8119353358Sdim return ToTOrErr.takeError(); 8120341825Sdim 8121203955Srdivacky // Record the imported type. 8122344779Sdim ImportedTypes[FromTy] = (*ToTOrErr).getTypePtr(); 8123341825Sdim 8124344779Sdim return ToContext.getQualifiedType(*ToTOrErr, FromT.getLocalQualifiers()); 8125203955Srdivacky} 8126203955Srdivacky 8127353358SdimExpected<TypeSourceInfo *> ASTImporter::Import(TypeSourceInfo *FromTSI) { 8128203955Srdivacky if (!FromTSI) 8129203955Srdivacky return FromTSI; 8130203955Srdivacky 8131203955Srdivacky // FIXME: For now we just create a "trivial" type source info based 8132212904Sdim // on the type and a single location. Implement a real version of this. 8133353358Sdim ExpectedType TOrErr = Import(FromTSI->getType()); 8134353358Sdim if (!TOrErr) 8135353358Sdim return TOrErr.takeError(); 8136353358Sdim ExpectedSLoc BeginLocOrErr = Import(FromTSI->getTypeLoc().getBeginLoc()); 8137353358Sdim if (!BeginLocOrErr) 8138353358Sdim return BeginLocOrErr.takeError(); 8139203955Srdivacky 8140353358Sdim return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr); 8141203955Srdivacky} 8142203955Srdivacky 8143353358SdimExpected<Attr *> ASTImporter::Import(const Attr *FromAttr) { 8144341825Sdim Attr *ToAttr = FromAttr->clone(ToContext); 8145353358Sdim if (auto ToRangeOrErr = Import(FromAttr->getRange())) 8146353358Sdim ToAttr->setRange(*ToRangeOrErr); 8147353358Sdim else 8148353358Sdim return ToRangeOrErr.takeError(); 8149353358Sdim 8150341825Sdim return ToAttr; 8151341825Sdim} 8152341825Sdim 8153344779SdimDecl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const { 8154344779Sdim auto Pos = ImportedDecls.find(FromD); 8155344779Sdim if (Pos != ImportedDecls.end()) 8156344779Sdim return Pos->second; 8157344779Sdim else 8158288943Sdim return nullptr; 8159288943Sdim} 8160288943Sdim 8161353358SdimTranslationUnitDecl *ASTImporter::GetFromTU(Decl *ToD) { 8162353358Sdim auto FromDPos = ImportedFromDecls.find(ToD); 8163353358Sdim if (FromDPos == ImportedFromDecls.end()) 8164353358Sdim return nullptr; 8165353358Sdim return FromDPos->second->getTranslationUnitDecl(); 8166344779Sdim} 8167353358Sdim 8168353358SdimExpected<Decl *> ASTImporter::Import(Decl *FromD) { 8169203955Srdivacky if (!FromD) 8170276479Sdim return nullptr; 8171203955Srdivacky 8172353358Sdim // Push FromD to the stack, and remove that when we return. 8173353358Sdim ImportPath.push(FromD); 8174353358Sdim auto ImportPathBuilder = 8175353358Sdim llvm::make_scope_exit([this]() { ImportPath.pop(); }); 8176226633Sdim 8177353358Sdim // Check whether there was a previous failed import. 8178353358Sdim // If yes return the existing error. 8179353358Sdim if (auto Error = getImportDeclErrorIfAny(FromD)) 8180353358Sdim return make_error<ImportError>(*Error); 8181353358Sdim 8182341825Sdim // Check whether we've already imported this declaration. 8183341825Sdim Decl *ToD = GetAlreadyImportedOrNull(FromD); 8184341825Sdim if (ToD) { 8185353358Sdim // Already imported (possibly from another TU) and with an error. 8186353358Sdim if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) { 8187353358Sdim setImportDeclError(FromD, *Error); 8188353358Sdim return make_error<ImportError>(*Error); 8189353358Sdim } 8190353358Sdim 8191341825Sdim // If FromD has some updated flags after last import, apply it 8192341825Sdim updateFlags(FromD, ToD); 8193353358Sdim // If we encounter a cycle during an import then we save the relevant part 8194353358Sdim // of the import path associated to the Decl. 8195353358Sdim if (ImportPath.hasCycleAtBack()) 8196353358Sdim SavedImportPaths[FromD].push_back(ImportPath.copyCycleAtBack()); 8197226633Sdim return ToD; 8198226633Sdim } 8199341825Sdim 8200353358Sdim // Import the declaration. 8201353358Sdim ExpectedDecl ToDOrErr = ImportImpl(FromD); 8202344779Sdim if (!ToDOrErr) { 8203353358Sdim // Failed to import. 8204353358Sdim 8205353358Sdim auto Pos = ImportedDecls.find(FromD); 8206353358Sdim if (Pos != ImportedDecls.end()) { 8207353358Sdim // Import failed after the object was created. 8208353358Sdim // Remove all references to it. 8209353358Sdim auto *ToD = Pos->second; 8210353358Sdim ImportedDecls.erase(Pos); 8211353358Sdim 8212353358Sdim // ImportedDecls and ImportedFromDecls are not symmetric. It may happen 8213353358Sdim // (e.g. with namespaces) that several decls from the 'from' context are 8214353358Sdim // mapped to the same decl in the 'to' context. If we removed entries 8215353358Sdim // from the LookupTable here then we may end up removing them multiple 8216353358Sdim // times. 8217353358Sdim 8218353358Sdim // The Lookuptable contains decls only which are in the 'to' context. 8219353358Sdim // Remove from the Lookuptable only if it is *imported* into the 'to' 8220353358Sdim // context (and do not remove it if it was added during the initial 8221353358Sdim // traverse of the 'to' context). 8222353358Sdim auto PosF = ImportedFromDecls.find(ToD); 8223353358Sdim if (PosF != ImportedFromDecls.end()) { 8224353358Sdim SharedState->removeDeclFromLookup(ToD); 8225353358Sdim ImportedFromDecls.erase(PosF); 8226353358Sdim } 8227353358Sdim 8228353358Sdim // FIXME: AST may contain remaining references to the failed object. 8229353358Sdim // However, the ImportDeclErrors in the shared state contains all the 8230353358Sdim // failed objects together with their error. 8231353358Sdim } 8232353358Sdim 8233353358Sdim // Error encountered for the first time. 8234353358Sdim // After takeError the error is not usable any more in ToDOrErr. 8235353358Sdim // Get a copy of the error object (any more simple solution for this?). 8236353358Sdim ImportError ErrOut; 8237353358Sdim handleAllErrors(ToDOrErr.takeError(), 8238353358Sdim [&ErrOut](const ImportError &E) { ErrOut = E; }); 8239353358Sdim setImportDeclError(FromD, ErrOut); 8240353358Sdim // Set the error for the mapped to Decl, which is in the "to" context. 8241353358Sdim if (Pos != ImportedDecls.end()) 8242353358Sdim SharedState->setImportDeclError(Pos->second, ErrOut); 8243353358Sdim 8244353358Sdim // Set the error for all nodes which have been created before we 8245353358Sdim // recognized the error. 8246353358Sdim for (const auto &Path : SavedImportPaths[FromD]) 8247353358Sdim for (Decl *FromDi : Path) { 8248353358Sdim setImportDeclError(FromDi, ErrOut); 8249353358Sdim //FIXME Should we remove these Decls from ImportedDecls? 8250353358Sdim // Set the error for the mapped to Decl, which is in the "to" context. 8251353358Sdim auto Ii = ImportedDecls.find(FromDi); 8252353358Sdim if (Ii != ImportedDecls.end()) 8253353358Sdim SharedState->setImportDeclError(Ii->second, ErrOut); 8254353358Sdim // FIXME Should we remove these Decls from the LookupTable, 8255353358Sdim // and from ImportedFromDecls? 8256353358Sdim } 8257353358Sdim SavedImportPaths[FromD].clear(); 8258353358Sdim 8259353358Sdim // Do not return ToDOrErr, error was taken out of it. 8260353358Sdim return make_error<ImportError>(ErrOut); 8261344779Sdim } 8262353358Sdim 8263344779Sdim ToD = *ToDOrErr; 8264276479Sdim 8265353358Sdim // FIXME: Handle the "already imported with error" case. We can get here 8266353358Sdim // nullptr only if GetImportedOrCreateDecl returned nullptr (after a 8267353358Sdim // previously failed create was requested). 8268353358Sdim // Later GetImportedOrCreateDecl can be updated to return the error. 8269353358Sdim if (!ToD) { 8270353358Sdim auto Err = getImportDeclErrorIfAny(FromD); 8271353358Sdim assert(Err); 8272353358Sdim return make_error<ImportError>(*Err); 8273353358Sdim } 8274344779Sdim 8275353358Sdim // We could import from the current TU without error. But previously we 8276353358Sdim // already had imported a Decl as `ToD` from another TU (with another 8277353358Sdim // ASTImporter object) and with an error. 8278353358Sdim if (auto Error = SharedState->getImportDeclErrorIfAny(ToD)) { 8279353358Sdim setImportDeclError(FromD, *Error); 8280353358Sdim return make_error<ImportError>(*Error); 8281353358Sdim } 8282353358Sdim 8283353358Sdim // Make sure that ImportImpl registered the imported decl. 8284353358Sdim assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?"); 8285353358Sdim 8286341825Sdim // Notify subclasses. 8287341825Sdim Imported(FromD, ToD); 8288341825Sdim 8289344779Sdim updateFlags(FromD, ToD); 8290353358Sdim SavedImportPaths[FromD].clear(); 8291353358Sdim return ToDOrErr; 8292203955Srdivacky} 8293203955Srdivacky 8294344779SdimExpected<DeclContext *> ASTImporter::ImportContext(DeclContext *FromDC) { 8295203955Srdivacky if (!FromDC) 8296203955Srdivacky return FromDC; 8297203955Srdivacky 8298353358Sdim ExpectedDecl ToDCOrErr = Import(cast<Decl>(FromDC)); 8299353358Sdim if (!ToDCOrErr) 8300353358Sdim return ToDCOrErr.takeError(); 8301353358Sdim auto *ToDC = cast<DeclContext>(*ToDCOrErr); 8302276479Sdim 8303341825Sdim // When we're using a record/enum/Objective-C class/protocol as a context, we 8304234353Sdim // need it to have a definition. 8305341825Sdim if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 8306341825Sdim auto *FromRecord = cast<RecordDecl>(FromDC); 8307234353Sdim if (ToRecord->isCompleteDefinition()) { 8308234353Sdim // Do nothing. 8309234353Sdim } else if (FromRecord->isCompleteDefinition()) { 8310344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8311344779Sdim FromRecord, ToRecord, ASTNodeImporter::IDK_Basic)) 8312344779Sdim return std::move(Err); 8313234353Sdim } else { 8314234353Sdim CompleteDecl(ToRecord); 8315234353Sdim } 8316341825Sdim } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 8317341825Sdim auto *FromEnum = cast<EnumDecl>(FromDC); 8318234353Sdim if (ToEnum->isCompleteDefinition()) { 8319234353Sdim // Do nothing. 8320234353Sdim } else if (FromEnum->isCompleteDefinition()) { 8321344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8322344779Sdim FromEnum, ToEnum, ASTNodeImporter::IDK_Basic)) 8323344779Sdim return std::move(Err); 8324234353Sdim } else { 8325234353Sdim CompleteDecl(ToEnum); 8326341825Sdim } 8327341825Sdim } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 8328341825Sdim auto *FromClass = cast<ObjCInterfaceDecl>(FromDC); 8329234353Sdim if (ToClass->getDefinition()) { 8330234353Sdim // Do nothing. 8331234353Sdim } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 8332344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8333344779Sdim FromDef, ToClass, ASTNodeImporter::IDK_Basic)) 8334344779Sdim return std::move(Err); 8335234353Sdim } else { 8336234353Sdim CompleteDecl(ToClass); 8337234353Sdim } 8338341825Sdim } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 8339341825Sdim auto *FromProto = cast<ObjCProtocolDecl>(FromDC); 8340234353Sdim if (ToProto->getDefinition()) { 8341234353Sdim // Do nothing. 8342234353Sdim } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 8343344779Sdim if (Error Err = ASTNodeImporter(*this).ImportDefinition( 8344344779Sdim FromDef, ToProto, ASTNodeImporter::IDK_Basic)) 8345344779Sdim return std::move(Err); 8346234353Sdim } else { 8347234353Sdim CompleteDecl(ToProto); 8348341825Sdim } 8349234353Sdim } 8350341825Sdim 8351234353Sdim return ToDC; 8352203955Srdivacky} 8353203955Srdivacky 8354353358SdimExpected<Expr *> ASTImporter::Import(Expr *FromE) { 8355353358Sdim if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE))) 8356353358Sdim return cast_or_null<Expr>(*ToSOrErr); 8357353358Sdim else 8358353358Sdim return ToSOrErr.takeError(); 8359344779Sdim} 8360203955Srdivacky 8361353358SdimExpected<Stmt *> ASTImporter::Import(Stmt *FromS) { 8362203955Srdivacky if (!FromS) 8363276479Sdim return nullptr; 8364203955Srdivacky 8365353358Sdim // Check whether we've already imported this statement. 8366203955Srdivacky llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 8367203955Srdivacky if (Pos != ImportedStmts.end()) 8368203955Srdivacky return Pos->second; 8369341825Sdim 8370344779Sdim // Import the statement. 8371203955Srdivacky ASTNodeImporter Importer(*this); 8372344779Sdim ExpectedStmt ToSOrErr = Importer.Visit(FromS); 8373353358Sdim if (!ToSOrErr) 8374353358Sdim return ToSOrErr; 8375276479Sdim 8376344779Sdim if (auto *ToE = dyn_cast<Expr>(*ToSOrErr)) { 8377344779Sdim auto *FromE = cast<Expr>(FromS); 8378344779Sdim // Copy ExprBitfields, which may not be handled in Expr subclasses 8379344779Sdim // constructors. 8380344779Sdim ToE->setValueKind(FromE->getValueKind()); 8381344779Sdim ToE->setObjectKind(FromE->getObjectKind()); 8382344779Sdim ToE->setTypeDependent(FromE->isTypeDependent()); 8383344779Sdim ToE->setValueDependent(FromE->isValueDependent()); 8384344779Sdim ToE->setInstantiationDependent(FromE->isInstantiationDependent()); 8385344779Sdim ToE->setContainsUnexpandedParameterPack( 8386344779Sdim FromE->containsUnexpandedParameterPack()); 8387344779Sdim } 8388344779Sdim 8389353358Sdim // Record the imported statement object. 8390344779Sdim ImportedStmts[FromS] = *ToSOrErr; 8391353358Sdim return ToSOrErr; 8392203955Srdivacky} 8393203955Srdivacky 8394344779SdimExpected<NestedNameSpecifier *> 8395353358SdimASTImporter::Import(NestedNameSpecifier *FromNNS) { 8396203955Srdivacky if (!FromNNS) 8397276479Sdim return nullptr; 8398203955Srdivacky 8399353358Sdim NestedNameSpecifier *Prefix = nullptr; 8400353358Sdim if (Error Err = importInto(Prefix, FromNNS->getPrefix())) 8401353358Sdim return std::move(Err); 8402221345Sdim 8403221345Sdim switch (FromNNS->getKind()) { 8404221345Sdim case NestedNameSpecifier::Identifier: 8405353358Sdim assert(FromNNS->getAsIdentifier() && "NNS should contain identifier."); 8406353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8407353358Sdim Import(FromNNS->getAsIdentifier())); 8408221345Sdim 8409221345Sdim case NestedNameSpecifier::Namespace: 8410353358Sdim if (ExpectedDecl NSOrErr = Import(FromNNS->getAsNamespace())) { 8411353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8412353358Sdim cast<NamespaceDecl>(*NSOrErr)); 8413353358Sdim } else 8414353358Sdim return NSOrErr.takeError(); 8415221345Sdim 8416221345Sdim case NestedNameSpecifier::NamespaceAlias: 8417353358Sdim if (ExpectedDecl NSADOrErr = Import(FromNNS->getAsNamespaceAlias())) 8418353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, 8419353358Sdim cast<NamespaceAliasDecl>(*NSADOrErr)); 8420353358Sdim else 8421353358Sdim return NSADOrErr.takeError(); 8422221345Sdim 8423221345Sdim case NestedNameSpecifier::Global: 8424221345Sdim return NestedNameSpecifier::GlobalSpecifier(ToContext); 8425221345Sdim 8426280031Sdim case NestedNameSpecifier::Super: 8427353358Sdim if (ExpectedDecl RDOrErr = Import(FromNNS->getAsRecordDecl())) 8428353358Sdim return NestedNameSpecifier::SuperSpecifier(ToContext, 8429353358Sdim cast<CXXRecordDecl>(*RDOrErr)); 8430353358Sdim else 8431353358Sdim return RDOrErr.takeError(); 8432280031Sdim 8433221345Sdim case NestedNameSpecifier::TypeSpec: 8434353358Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 8435353358Sdim if (Expected<QualType> TyOrErr = 8436353358Sdim Import(QualType(FromNNS->getAsType(), 0u))) { 8437353358Sdim bool TSTemplate = 8438353358Sdim FromNNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate; 8439353358Sdim return NestedNameSpecifier::Create(ToContext, Prefix, TSTemplate, 8440353358Sdim TyOrErr->getTypePtr()); 8441353358Sdim } else { 8442353358Sdim return TyOrErr.takeError(); 8443221345Sdim } 8444221345Sdim } 8445221345Sdim 8446221345Sdim llvm_unreachable("Invalid nested name specifier kind"); 8447203955Srdivacky} 8448203955Srdivacky 8449344779SdimExpected<NestedNameSpecifierLoc> 8450353358SdimASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 8451321369Sdim // Copied from NestedNameSpecifier mostly. 8452321369Sdim SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 8453321369Sdim NestedNameSpecifierLoc NNS = FromNNS; 8454321369Sdim 8455321369Sdim // Push each of the nested-name-specifiers's onto a stack for 8456321369Sdim // serialization in reverse order. 8457321369Sdim while (NNS) { 8458321369Sdim NestedNames.push_back(NNS); 8459321369Sdim NNS = NNS.getPrefix(); 8460321369Sdim } 8461321369Sdim 8462321369Sdim NestedNameSpecifierLocBuilder Builder; 8463321369Sdim 8464321369Sdim while (!NestedNames.empty()) { 8465321369Sdim NNS = NestedNames.pop_back_val(); 8466353358Sdim NestedNameSpecifier *Spec = nullptr; 8467353358Sdim if (Error Err = importInto(Spec, NNS.getNestedNameSpecifier())) 8468353358Sdim return std::move(Err); 8469321369Sdim 8470321369Sdim NestedNameSpecifier::SpecifierKind Kind = Spec->getKind(); 8471353358Sdim 8472353358Sdim SourceLocation ToLocalBeginLoc, ToLocalEndLoc; 8473353358Sdim if (Kind != NestedNameSpecifier::Super) { 8474353358Sdim if (Error Err = importInto(ToLocalBeginLoc, NNS.getLocalBeginLoc())) 8475353358Sdim return std::move(Err); 8476353358Sdim 8477353358Sdim if (Kind != NestedNameSpecifier::Global) 8478353358Sdim if (Error Err = importInto(ToLocalEndLoc, NNS.getLocalEndLoc())) 8479353358Sdim return std::move(Err); 8480353358Sdim } 8481353358Sdim 8482321369Sdim switch (Kind) { 8483321369Sdim case NestedNameSpecifier::Identifier: 8484353358Sdim Builder.Extend(getToContext(), Spec->getAsIdentifier(), ToLocalBeginLoc, 8485353358Sdim ToLocalEndLoc); 8486321369Sdim break; 8487321369Sdim 8488321369Sdim case NestedNameSpecifier::Namespace: 8489353358Sdim Builder.Extend(getToContext(), Spec->getAsNamespace(), ToLocalBeginLoc, 8490353358Sdim ToLocalEndLoc); 8491321369Sdim break; 8492321369Sdim 8493321369Sdim case NestedNameSpecifier::NamespaceAlias: 8494353358Sdim Builder.Extend(getToContext(), Spec->getAsNamespaceAlias(), 8495353358Sdim ToLocalBeginLoc, ToLocalEndLoc); 8496321369Sdim break; 8497321369Sdim 8498321369Sdim case NestedNameSpecifier::TypeSpec: 8499321369Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 8500353358Sdim SourceLocation ToTLoc; 8501353358Sdim if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc())) 8502353358Sdim return std::move(Err); 8503321369Sdim TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo( 8504353358Sdim QualType(Spec->getAsType(), 0), ToTLoc); 8505360784Sdim if (Kind == NestedNameSpecifier::TypeSpecWithTemplate) 8506360784Sdim // ToLocalBeginLoc is here the location of the 'template' keyword. 8507360784Sdim Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(), 8508360784Sdim ToLocalEndLoc); 8509360784Sdim else 8510360784Sdim // No location for 'template' keyword here. 8511360784Sdim Builder.Extend(getToContext(), SourceLocation{}, TSI->getTypeLoc(), 8512360784Sdim ToLocalEndLoc); 8513321369Sdim break; 8514321369Sdim } 8515321369Sdim 8516321369Sdim case NestedNameSpecifier::Global: 8517353358Sdim Builder.MakeGlobal(getToContext(), ToLocalBeginLoc); 8518321369Sdim break; 8519321369Sdim 8520321369Sdim case NestedNameSpecifier::Super: { 8521353358Sdim auto ToSourceRangeOrErr = Import(NNS.getSourceRange()); 8522353358Sdim if (!ToSourceRangeOrErr) 8523353358Sdim return ToSourceRangeOrErr.takeError(); 8524353358Sdim 8525353358Sdim Builder.MakeSuper(getToContext(), Spec->getAsRecordDecl(), 8526353358Sdim ToSourceRangeOrErr->getBegin(), 8527353358Sdim ToSourceRangeOrErr->getEnd()); 8528321369Sdim } 8529321369Sdim } 8530321369Sdim } 8531321369Sdim 8532321369Sdim return Builder.getWithLocInContext(getToContext()); 8533219077Sdim} 8534219077Sdim 8535353358SdimExpected<TemplateName> ASTImporter::Import(TemplateName From) { 8536218893Sdim switch (From.getKind()) { 8537218893Sdim case TemplateName::Template: 8538353358Sdim if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl())) 8539353358Sdim return TemplateName(cast<TemplateDecl>(*ToTemplateOrErr)); 8540353358Sdim else 8541353358Sdim return ToTemplateOrErr.takeError(); 8542341825Sdim 8543218893Sdim case TemplateName::OverloadedTemplate: { 8544218893Sdim OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 8545218893Sdim UnresolvedSet<2> ToTemplates; 8546341825Sdim for (auto *I : *FromStorage) { 8547353358Sdim if (auto ToOrErr = Import(I)) 8548353358Sdim ToTemplates.addDecl(cast<NamedDecl>(*ToOrErr)); 8549218893Sdim else 8550353358Sdim return ToOrErr.takeError(); 8551218893Sdim } 8552341825Sdim return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 8553218893Sdim ToTemplates.end()); 8554218893Sdim } 8555341825Sdim 8556353358Sdim case TemplateName::AssumedTemplate: { 8557353358Sdim AssumedTemplateStorage *FromStorage = From.getAsAssumedTemplateName(); 8558353358Sdim auto DeclNameOrErr = Import(FromStorage->getDeclName()); 8559353358Sdim if (!DeclNameOrErr) 8560353358Sdim return DeclNameOrErr.takeError(); 8561353358Sdim return ToContext.getAssumedTemplateName(*DeclNameOrErr); 8562353358Sdim } 8563353358Sdim 8564218893Sdim case TemplateName::QualifiedTemplate: { 8565218893Sdim QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 8566353358Sdim auto QualifierOrErr = Import(QTN->getQualifier()); 8567353358Sdim if (!QualifierOrErr) 8568353358Sdim return QualifierOrErr.takeError(); 8569341825Sdim 8570353358Sdim if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl())) 8571353358Sdim return ToContext.getQualifiedTemplateName( 8572353358Sdim *QualifierOrErr, QTN->hasTemplateKeyword(), 8573353358Sdim cast<TemplateDecl>(*ToTemplateOrErr)); 8574353358Sdim else 8575353358Sdim return ToTemplateOrErr.takeError(); 8576218893Sdim } 8577341825Sdim 8578218893Sdim case TemplateName::DependentTemplate: { 8579218893Sdim DependentTemplateName *DTN = From.getAsDependentTemplateName(); 8580353358Sdim auto QualifierOrErr = Import(DTN->getQualifier()); 8581353358Sdim if (!QualifierOrErr) 8582353358Sdim return QualifierOrErr.takeError(); 8583341825Sdim 8584218893Sdim if (DTN->isIdentifier()) { 8585353358Sdim return ToContext.getDependentTemplateName(*QualifierOrErr, 8586218893Sdim Import(DTN->getIdentifier())); 8587218893Sdim } 8588341825Sdim 8589353358Sdim return ToContext.getDependentTemplateName(*QualifierOrErr, 8590353358Sdim DTN->getOperator()); 8591218893Sdim } 8592224145Sdim 8593224145Sdim case TemplateName::SubstTemplateTemplateParm: { 8594353358Sdim SubstTemplateTemplateParmStorage *Subst = 8595353358Sdim From.getAsSubstTemplateTemplateParm(); 8596353358Sdim ExpectedDecl ParamOrErr = Import(Subst->getParameter()); 8597353358Sdim if (!ParamOrErr) 8598353358Sdim return ParamOrErr.takeError(); 8599224145Sdim 8600353358Sdim auto ReplacementOrErr = Import(Subst->getReplacement()); 8601353358Sdim if (!ReplacementOrErr) 8602353358Sdim return ReplacementOrErr.takeError(); 8603341825Sdim 8604353358Sdim return ToContext.getSubstTemplateTemplateParm( 8605353358Sdim cast<TemplateTemplateParmDecl>(*ParamOrErr), *ReplacementOrErr); 8606224145Sdim } 8607341825Sdim 8608218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 8609218893Sdim SubstTemplateTemplateParmPackStorage *SubstPack 8610218893Sdim = From.getAsSubstTemplateTemplateParmPack(); 8611353358Sdim ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack()); 8612353358Sdim if (!ParamOrErr) 8613353358Sdim return ParamOrErr.takeError(); 8614341825Sdim 8615218893Sdim ASTNodeImporter Importer(*this); 8616353358Sdim auto ArgPackOrErr = 8617353358Sdim Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 8618353358Sdim if (!ArgPackOrErr) 8619353358Sdim return ArgPackOrErr.takeError(); 8620341825Sdim 8621353358Sdim return ToContext.getSubstTemplateTemplateParmPack( 8622353358Sdim cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr); 8623218893Sdim } 8624218893Sdim } 8625341825Sdim 8626218893Sdim llvm_unreachable("Invalid template name kind"); 8627218893Sdim} 8628218893Sdim 8629353358SdimExpected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) { 8630203955Srdivacky if (FromLoc.isInvalid()) 8631353358Sdim return SourceLocation{}; 8632203955Srdivacky 8633203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 8634353358Sdim bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc); 8635341825Sdim 8636203955Srdivacky std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 8637353358Sdim Expected<FileID> ToFileIDOrErr = Import(Decomposed.first, IsBuiltin); 8638353358Sdim if (!ToFileIDOrErr) 8639353358Sdim return ToFileIDOrErr.takeError(); 8640341825Sdim SourceManager &ToSM = ToContext.getSourceManager(); 8641353358Sdim return ToSM.getComposedLoc(*ToFileIDOrErr, Decomposed.second); 8642203955Srdivacky} 8643203955Srdivacky 8644353358SdimExpected<SourceRange> ASTImporter::Import(SourceRange FromRange) { 8645353358Sdim SourceLocation ToBegin, ToEnd; 8646353358Sdim if (Error Err = importInto(ToBegin, FromRange.getBegin())) 8647353358Sdim return std::move(Err); 8648353358Sdim if (Error Err = importInto(ToEnd, FromRange.getEnd())) 8649353358Sdim return std::move(Err); 8650353358Sdim 8651353358Sdim return SourceRange(ToBegin, ToEnd); 8652344779Sdim} 8653203955Srdivacky 8654353358SdimExpected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) { 8655341825Sdim llvm::DenseMap<FileID, FileID>::iterator Pos = ImportedFileIDs.find(FromID); 8656203955Srdivacky if (Pos != ImportedFileIDs.end()) 8657203955Srdivacky return Pos->second; 8658341825Sdim 8659203955Srdivacky SourceManager &FromSM = FromContext.getSourceManager(); 8660203955Srdivacky SourceManager &ToSM = ToContext.getSourceManager(); 8661203955Srdivacky const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 8662341825Sdim 8663341825Sdim // Map the FromID to the "to" source manager. 8664203955Srdivacky FileID ToID; 8665341825Sdim if (FromSLoc.isExpansion()) { 8666341825Sdim const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion(); 8667353358Sdim ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc()); 8668353358Sdim if (!ToSpLoc) 8669353358Sdim return ToSpLoc.takeError(); 8670353358Sdim ExpectedSLoc ToExLocS = Import(FromEx.getExpansionLocStart()); 8671353358Sdim if (!ToExLocS) 8672353358Sdim return ToExLocS.takeError(); 8673341825Sdim unsigned TokenLen = FromSM.getFileIDSize(FromID); 8674341825Sdim SourceLocation MLoc; 8675341825Sdim if (FromEx.isMacroArgExpansion()) { 8676353358Sdim MLoc = ToSM.createMacroArgExpansionLoc(*ToSpLoc, *ToExLocS, TokenLen); 8677341825Sdim } else { 8678353358Sdim if (ExpectedSLoc ToExLocE = Import(FromEx.getExpansionLocEnd())) 8679353358Sdim MLoc = ToSM.createExpansionLoc(*ToSpLoc, *ToExLocS, *ToExLocE, TokenLen, 8680353358Sdim FromEx.isExpansionTokenRange()); 8681353358Sdim else 8682353358Sdim return ToExLocE.takeError(); 8683341825Sdim } 8684341825Sdim ToID = ToSM.getFileID(MLoc); 8685203955Srdivacky } else { 8686353358Sdim const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 8687341825Sdim 8688353358Sdim if (!IsBuiltin) { 8689353358Sdim // Include location of this file. 8690353358Sdim ExpectedSLoc ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 8691353358Sdim if (!ToIncludeLoc) 8692353358Sdim return ToIncludeLoc.takeError(); 8693353358Sdim 8694353358Sdim if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 8695353358Sdim // FIXME: We probably want to use getVirtualFile(), so we don't hit the 8696353358Sdim // disk again 8697353358Sdim // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 8698353358Sdim // than mmap the files several times. 8699360784Sdim auto Entry = 8700353358Sdim ToFileManager.getFile(Cache->OrigEntry->getName()); 8701353358Sdim // FIXME: The filename may be a virtual name that does probably not 8702353358Sdim // point to a valid file and we get no Entry here. In this case try with 8703353358Sdim // the memory buffer below. 8704353358Sdim if (Entry) 8705360784Sdim ToID = ToSM.createFileID(*Entry, *ToIncludeLoc, 8706353358Sdim FromSLoc.getFile().getFileCharacteristic()); 8707353358Sdim } 8708353358Sdim } 8709353358Sdim 8710353358Sdim if (ToID.isInvalid() || IsBuiltin) { 8711341825Sdim // FIXME: We want to re-use the existing MemoryBuffer! 8712353358Sdim bool Invalid = true; 8713360784Sdim const llvm::MemoryBuffer *FromBuf = 8714360784Sdim Cache->getBuffer(FromContext.getDiagnostics(), 8715360784Sdim FromSM.getFileManager(), SourceLocation{}, &Invalid); 8716353358Sdim if (!FromBuf || Invalid) 8717353358Sdim // FIXME: Use a new error kind? 8718353358Sdim return llvm::make_error<ImportError>(ImportError::Unknown); 8719353358Sdim 8720341825Sdim std::unique_ptr<llvm::MemoryBuffer> ToBuf = 8721341825Sdim llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 8722341825Sdim FromBuf->getBufferIdentifier()); 8723341825Sdim ToID = ToSM.createFileID(std::move(ToBuf), 8724341825Sdim FromSLoc.getFile().getFileCharacteristic()); 8725341825Sdim } 8726203955Srdivacky } 8727341825Sdim 8728353358Sdim assert(ToID.isValid() && "Unexpected invalid fileID was created."); 8729353358Sdim 8730218893Sdim ImportedFileIDs[FromID] = ToID; 8731360784Sdim 8732360784Sdim if (FileIDImportHandler) 8733360784Sdim FileIDImportHandler(ToID, FromID); 8734360784Sdim 8735203955Srdivacky return ToID; 8736203955Srdivacky} 8737203955Srdivacky 8738353358SdimExpected<CXXCtorInitializer *> ASTImporter::Import(CXXCtorInitializer *From) { 8739353358Sdim ExpectedExpr ToExprOrErr = Import(From->getInit()); 8740353358Sdim if (!ToExprOrErr) 8741353358Sdim return ToExprOrErr.takeError(); 8742309124Sdim 8743353358Sdim auto LParenLocOrErr = Import(From->getLParenLoc()); 8744353358Sdim if (!LParenLocOrErr) 8745353358Sdim return LParenLocOrErr.takeError(); 8746353358Sdim 8747353358Sdim auto RParenLocOrErr = Import(From->getRParenLoc()); 8748353358Sdim if (!RParenLocOrErr) 8749353358Sdim return RParenLocOrErr.takeError(); 8750353358Sdim 8751309124Sdim if (From->isBaseInitializer()) { 8752353358Sdim auto ToTInfoOrErr = Import(From->getTypeSourceInfo()); 8753353358Sdim if (!ToTInfoOrErr) 8754353358Sdim return ToTInfoOrErr.takeError(); 8755309124Sdim 8756353358Sdim SourceLocation EllipsisLoc; 8757353358Sdim if (From->isPackExpansion()) 8758353358Sdim if (Error Err = importInto(EllipsisLoc, From->getEllipsisLoc())) 8759353358Sdim return std::move(Err); 8760353358Sdim 8761309124Sdim return new (ToContext) CXXCtorInitializer( 8762353358Sdim ToContext, *ToTInfoOrErr, From->isBaseVirtual(), *LParenLocOrErr, 8763353358Sdim *ToExprOrErr, *RParenLocOrErr, EllipsisLoc); 8764309124Sdim } else if (From->isMemberInitializer()) { 8765353358Sdim ExpectedDecl ToFieldOrErr = Import(From->getMember()); 8766353358Sdim if (!ToFieldOrErr) 8767353358Sdim return ToFieldOrErr.takeError(); 8768309124Sdim 8769353358Sdim auto MemberLocOrErr = Import(From->getMemberLocation()); 8770353358Sdim if (!MemberLocOrErr) 8771353358Sdim return MemberLocOrErr.takeError(); 8772353358Sdim 8773309124Sdim return new (ToContext) CXXCtorInitializer( 8774353358Sdim ToContext, cast_or_null<FieldDecl>(*ToFieldOrErr), *MemberLocOrErr, 8775353358Sdim *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr); 8776309124Sdim } else if (From->isIndirectMemberInitializer()) { 8777353358Sdim ExpectedDecl ToIFieldOrErr = Import(From->getIndirectMember()); 8778353358Sdim if (!ToIFieldOrErr) 8779353358Sdim return ToIFieldOrErr.takeError(); 8780309124Sdim 8781353358Sdim auto MemberLocOrErr = Import(From->getMemberLocation()); 8782353358Sdim if (!MemberLocOrErr) 8783353358Sdim return MemberLocOrErr.takeError(); 8784353358Sdim 8785309124Sdim return new (ToContext) CXXCtorInitializer( 8786353358Sdim ToContext, cast_or_null<IndirectFieldDecl>(*ToIFieldOrErr), 8787353358Sdim *MemberLocOrErr, *LParenLocOrErr, *ToExprOrErr, *RParenLocOrErr); 8788309124Sdim } else if (From->isDelegatingInitializer()) { 8789353358Sdim auto ToTInfoOrErr = Import(From->getTypeSourceInfo()); 8790353358Sdim if (!ToTInfoOrErr) 8791353358Sdim return ToTInfoOrErr.takeError(); 8792309124Sdim 8793309124Sdim return new (ToContext) 8794353358Sdim CXXCtorInitializer(ToContext, *ToTInfoOrErr, *LParenLocOrErr, 8795353358Sdim *ToExprOrErr, *RParenLocOrErr); 8796309124Sdim } else { 8797353358Sdim // FIXME: assert? 8798353358Sdim return make_error<ImportError>(); 8799309124Sdim } 8800309124Sdim} 8801309124Sdim 8802344779SdimExpected<CXXBaseSpecifier *> 8803353358SdimASTImporter::Import(const CXXBaseSpecifier *BaseSpec) { 8804314564Sdim auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec); 8805314564Sdim if (Pos != ImportedCXXBaseSpecifiers.end()) 8806314564Sdim return Pos->second; 8807314564Sdim 8808353358Sdim Expected<SourceRange> ToSourceRange = Import(BaseSpec->getSourceRange()); 8809353358Sdim if (!ToSourceRange) 8810353358Sdim return ToSourceRange.takeError(); 8811353358Sdim Expected<TypeSourceInfo *> ToTSI = Import(BaseSpec->getTypeSourceInfo()); 8812353358Sdim if (!ToTSI) 8813353358Sdim return ToTSI.takeError(); 8814353358Sdim ExpectedSLoc ToEllipsisLoc = Import(BaseSpec->getEllipsisLoc()); 8815353358Sdim if (!ToEllipsisLoc) 8816353358Sdim return ToEllipsisLoc.takeError(); 8817314564Sdim CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier( 8818353358Sdim *ToSourceRange, BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(), 8819353358Sdim BaseSpec->getAccessSpecifierAsWritten(), *ToTSI, *ToEllipsisLoc); 8820314564Sdim ImportedCXXBaseSpecifiers[BaseSpec] = Imported; 8821314564Sdim return Imported; 8822314564Sdim} 8823314564Sdim 8824353358SdimError ASTImporter::ImportDefinition(Decl *From) { 8825353358Sdim ExpectedDecl ToOrErr = Import(From); 8826353358Sdim if (!ToOrErr) 8827353358Sdim return ToOrErr.takeError(); 8828353358Sdim Decl *To = *ToOrErr; 8829341825Sdim 8830353358Sdim auto *FromDC = cast<DeclContext>(From); 8831353358Sdim ASTNodeImporter Importer(*this); 8832341825Sdim 8833353358Sdim if (auto *ToRecord = dyn_cast<RecordDecl>(To)) { 8834353358Sdim if (!ToRecord->getDefinition()) { 8835353358Sdim return Importer.ImportDefinition( 8836353358Sdim cast<RecordDecl>(FromDC), ToRecord, 8837353358Sdim ASTNodeImporter::IDK_Everything); 8838226633Sdim } 8839353358Sdim } 8840226633Sdim 8841353358Sdim if (auto *ToEnum = dyn_cast<EnumDecl>(To)) { 8842353358Sdim if (!ToEnum->getDefinition()) { 8843353358Sdim return Importer.ImportDefinition( 8844353358Sdim cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything); 8845226633Sdim } 8846353358Sdim } 8847341825Sdim 8848353358Sdim if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 8849353358Sdim if (!ToIFace->getDefinition()) { 8850353358Sdim return Importer.ImportDefinition( 8851353358Sdim cast<ObjCInterfaceDecl>(FromDC), ToIFace, 8852353358Sdim ASTNodeImporter::IDK_Everything); 8853234353Sdim } 8854353358Sdim } 8855226633Sdim 8856353358Sdim if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 8857353358Sdim if (!ToProto->getDefinition()) { 8858353358Sdim return Importer.ImportDefinition( 8859353358Sdim cast<ObjCProtocolDecl>(FromDC), ToProto, 8860353358Sdim ASTNodeImporter::IDK_Everything); 8861234353Sdim } 8862218893Sdim } 8863344779Sdim 8864353358Sdim return Importer.ImportDeclContext(FromDC, true); 8865218893Sdim} 8866218893Sdim 8867353358SdimExpected<DeclarationName> ASTImporter::Import(DeclarationName FromName) { 8868203955Srdivacky if (!FromName) 8869353358Sdim return DeclarationName{}; 8870203955Srdivacky 8871203955Srdivacky switch (FromName.getNameKind()) { 8872203955Srdivacky case DeclarationName::Identifier: 8873353358Sdim return DeclarationName(Import(FromName.getAsIdentifierInfo())); 8874203955Srdivacky 8875203955Srdivacky case DeclarationName::ObjCZeroArgSelector: 8876203955Srdivacky case DeclarationName::ObjCOneArgSelector: 8877203955Srdivacky case DeclarationName::ObjCMultiArgSelector: 8878353358Sdim if (auto ToSelOrErr = Import(FromName.getObjCSelector())) 8879353358Sdim return DeclarationName(*ToSelOrErr); 8880353358Sdim else 8881353358Sdim return ToSelOrErr.takeError(); 8882203955Srdivacky 8883203955Srdivacky case DeclarationName::CXXConstructorName: { 8884353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8885353358Sdim return ToContext.DeclarationNames.getCXXConstructorName( 8886353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8887353358Sdim else 8888353358Sdim return ToTyOrErr.takeError(); 8889203955Srdivacky } 8890203955Srdivacky 8891203955Srdivacky case DeclarationName::CXXDestructorName: { 8892353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8893353358Sdim return ToContext.DeclarationNames.getCXXDestructorName( 8894353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8895353358Sdim else 8896353358Sdim return ToTyOrErr.takeError(); 8897203955Srdivacky } 8898203955Srdivacky 8899321369Sdim case DeclarationName::CXXDeductionGuideName: { 8900353358Sdim if (auto ToTemplateOrErr = Import(FromName.getCXXDeductionGuideTemplate())) 8901353358Sdim return ToContext.DeclarationNames.getCXXDeductionGuideName( 8902353358Sdim cast<TemplateDecl>(*ToTemplateOrErr)); 8903353358Sdim else 8904353358Sdim return ToTemplateOrErr.takeError(); 8905321369Sdim } 8906321369Sdim 8907203955Srdivacky case DeclarationName::CXXConversionFunctionName: { 8908353358Sdim if (auto ToTyOrErr = Import(FromName.getCXXNameType())) 8909353358Sdim return ToContext.DeclarationNames.getCXXConversionFunctionName( 8910353358Sdim ToContext.getCanonicalType(*ToTyOrErr)); 8911353358Sdim else 8912353358Sdim return ToTyOrErr.takeError(); 8913203955Srdivacky } 8914203955Srdivacky 8915203955Srdivacky case DeclarationName::CXXOperatorName: 8916203955Srdivacky return ToContext.DeclarationNames.getCXXOperatorName( 8917203955Srdivacky FromName.getCXXOverloadedOperator()); 8918203955Srdivacky 8919203955Srdivacky case DeclarationName::CXXLiteralOperatorName: 8920203955Srdivacky return ToContext.DeclarationNames.getCXXLiteralOperatorName( 8921353358Sdim Import(FromName.getCXXLiteralIdentifier())); 8922203955Srdivacky 8923203955Srdivacky case DeclarationName::CXXUsingDirective: 8924203955Srdivacky // FIXME: STATICS! 8925203955Srdivacky return DeclarationName::getUsingDirectiveName(); 8926203955Srdivacky } 8927203955Srdivacky 8928234353Sdim llvm_unreachable("Invalid DeclarationName Kind!"); 8929203955Srdivacky} 8930203955Srdivacky 8931218893SdimIdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 8932203955Srdivacky if (!FromId) 8933276479Sdim return nullptr; 8934203955Srdivacky 8935309124Sdim IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName()); 8936309124Sdim 8937309124Sdim if (!ToId->getBuiltinID() && FromId->getBuiltinID()) 8938309124Sdim ToId->setBuiltinID(FromId->getBuiltinID()); 8939309124Sdim 8940309124Sdim return ToId; 8941203955Srdivacky} 8942203955Srdivacky 8943353358SdimExpected<Selector> ASTImporter::Import(Selector FromSel) { 8944204643Srdivacky if (FromSel.isNull()) 8945353358Sdim return Selector{}; 8946204643Srdivacky 8947226633Sdim SmallVector<IdentifierInfo *, 4> Idents; 8948204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 8949204643Srdivacky for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 8950204643Srdivacky Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 8951204643Srdivacky return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 8952204643Srdivacky} 8953204643Srdivacky 8954360784SdimExpected<DeclarationName> ASTImporter::HandleNameConflict(DeclarationName Name, 8955360784Sdim DeclContext *DC, 8956360784Sdim unsigned IDNS, 8957360784Sdim NamedDecl **Decls, 8958360784Sdim unsigned NumDecls) { 8959360784Sdim if (ODRHandling == ODRHandlingType::Conservative) 8960360784Sdim // Report error at any name conflict. 8961360784Sdim return make_error<ImportError>(ImportError::NameConflict); 8962360784Sdim else 8963360784Sdim // Allow to create the new Decl with the same name. 8964360784Sdim return Name; 8965203955Srdivacky} 8966203955Srdivacky 8967203955SrdivackyDiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 8968249423Sdim if (LastDiagFromFrom) 8969249423Sdim ToContext.getDiagnostics().notePriorDiagnosticFrom( 8970249423Sdim FromContext.getDiagnostics()); 8971249423Sdim LastDiagFromFrom = false; 8972218893Sdim return ToContext.getDiagnostics().Report(Loc, DiagID); 8973203955Srdivacky} 8974203955Srdivacky 8975203955SrdivackyDiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 8976249423Sdim if (!LastDiagFromFrom) 8977249423Sdim FromContext.getDiagnostics().notePriorDiagnosticFrom( 8978249423Sdim ToContext.getDiagnostics()); 8979249423Sdim LastDiagFromFrom = true; 8980218893Sdim return FromContext.getDiagnostics().Report(Loc, DiagID); 8981203955Srdivacky} 8982203955Srdivacky 8983234353Sdimvoid ASTImporter::CompleteDecl (Decl *D) { 8984341825Sdim if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 8985234353Sdim if (!ID->getDefinition()) 8986234353Sdim ID->startDefinition(); 8987234353Sdim } 8988341825Sdim else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) { 8989234353Sdim if (!PD->getDefinition()) 8990234353Sdim PD->startDefinition(); 8991234353Sdim } 8992341825Sdim else if (auto *TD = dyn_cast<TagDecl>(D)) { 8993234353Sdim if (!TD->getDefinition() && !TD->isBeingDefined()) { 8994234353Sdim TD->startDefinition(); 8995234353Sdim TD->setCompleteDefinition(true); 8996234353Sdim } 8997234353Sdim } 8998234353Sdim else { 8999341825Sdim assert(0 && "CompleteDecl called on a Decl that can't be completed"); 9000234353Sdim } 9001234353Sdim} 9002234353Sdim 9003341825SdimDecl *ASTImporter::MapImported(Decl *From, Decl *To) { 9004341825Sdim llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From); 9005341825Sdim assert((Pos == ImportedDecls.end() || Pos->second == To) && 9006341825Sdim "Try to import an already imported Decl"); 9007341825Sdim if (Pos != ImportedDecls.end()) 9008341825Sdim return Pos->second; 9009203955Srdivacky ImportedDecls[From] = To; 9010353358Sdim // This mapping should be maintained only in this function. Therefore do not 9011353358Sdim // check for additional consistency. 9012353358Sdim ImportedFromDecls[To] = From; 9013353358Sdim AddToLookupTable(To); 9014203955Srdivacky return To; 9015203955Srdivacky} 9016203955Srdivacky 9017353358Sdimllvm::Optional<ImportError> 9018353358SdimASTImporter::getImportDeclErrorIfAny(Decl *FromD) const { 9019353358Sdim auto Pos = ImportDeclErrors.find(FromD); 9020353358Sdim if (Pos != ImportDeclErrors.end()) 9021353358Sdim return Pos->second; 9022353358Sdim else 9023353358Sdim return Optional<ImportError>(); 9024353358Sdim} 9025353358Sdim 9026353358Sdimvoid ASTImporter::setImportDeclError(Decl *From, ImportError Error) { 9027353358Sdim auto InsertRes = ImportDeclErrors.insert({From, Error}); 9028353358Sdim (void)InsertRes; 9029353358Sdim // Either we set the error for the first time, or we already had set one and 9030353358Sdim // now we want to set the same error. 9031353358Sdim assert(InsertRes.second || InsertRes.first->second.Error == Error.Error); 9032353358Sdim} 9033353358Sdim 9034239462Sdimbool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 9035239462Sdim bool Complain) { 9036353358Sdim llvm::DenseMap<const Type *, const Type *>::iterator Pos = 9037353358Sdim ImportedTypes.find(From.getTypePtr()); 9038353358Sdim if (Pos != ImportedTypes.end()) { 9039353358Sdim if (ExpectedType ToFromOrErr = Import(From)) { 9040353358Sdim if (ToContext.hasSameType(*ToFromOrErr, To)) 9041353358Sdim return true; 9042353358Sdim } else { 9043353358Sdim llvm::consumeError(ToFromOrErr.takeError()); 9044353358Sdim } 9045353358Sdim } 9046321369Sdim 9047239462Sdim StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 9048341825Sdim getStructuralEquivalenceKind(*this), false, 9049341825Sdim Complain); 9050341825Sdim return Ctx.IsEquivalent(From, To); 9051203955Srdivacky} 9052