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