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