1 //===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the ASTImporter class which imports AST nodes from one 11 // context into another context. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/AST/ASTImporter.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/ExceptionSpecificationType.h" 48 #include "clang/Basic/FileManager.h" 49 #include "clang/Basic/IdentifierTable.h" 50 #include "clang/Basic/LLVM.h" 51 #include "clang/Basic/LangOptions.h" 52 #include "clang/Basic/SourceLocation.h" 53 #include "clang/Basic/SourceManager.h" 54 #include "clang/Basic/Specifiers.h" 55 #include "llvm/ADT/APSInt.h" 56 #include "llvm/ADT/ArrayRef.h" 57 #include "llvm/ADT/DenseMap.h" 58 #include "llvm/ADT/None.h" 59 #include "llvm/ADT/Optional.h" 60 #include "llvm/ADT/STLExtras.h" 61 #include "llvm/ADT/SmallVector.h" 62 #include "llvm/Support/Casting.h" 63 #include "llvm/Support/ErrorHandling.h" 64 #include "llvm/Support/MemoryBuffer.h" 65 #include <algorithm> 66 #include <cassert> 67 #include <cstddef> 68 #include <memory> 69 #include <type_traits> 70 #include <utility> 71 72 namespace clang { 73 74 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>, 75 public DeclVisitor<ASTNodeImporter, Decl *>, 76 public StmtVisitor<ASTNodeImporter, Stmt *> { 77 ASTImporter &Importer; 78 79 public: 80 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {} 81 82 using TypeVisitor<ASTNodeImporter, QualType>::Visit; 83 using DeclVisitor<ASTNodeImporter, Decl *>::Visit; 84 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit; 85 86 // Importing types 87 QualType VisitType(const Type *T); 88 QualType VisitAtomicType(const AtomicType *T); 89 QualType VisitBuiltinType(const BuiltinType *T); 90 QualType VisitDecayedType(const DecayedType *T); 91 QualType VisitComplexType(const ComplexType *T); 92 QualType VisitPointerType(const PointerType *T); 93 QualType VisitBlockPointerType(const BlockPointerType *T); 94 QualType VisitLValueReferenceType(const LValueReferenceType *T); 95 QualType VisitRValueReferenceType(const RValueReferenceType *T); 96 QualType VisitMemberPointerType(const MemberPointerType *T); 97 QualType VisitConstantArrayType(const ConstantArrayType *T); 98 QualType VisitIncompleteArrayType(const IncompleteArrayType *T); 99 QualType VisitVariableArrayType(const VariableArrayType *T); 100 QualType VisitDependentSizedArrayType(const DependentSizedArrayType *T); 101 // FIXME: DependentSizedExtVectorType 102 QualType VisitVectorType(const VectorType *T); 103 QualType VisitExtVectorType(const ExtVectorType *T); 104 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T); 105 QualType VisitFunctionProtoType(const FunctionProtoType *T); 106 QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T); 107 QualType VisitParenType(const ParenType *T); 108 QualType VisitTypedefType(const TypedefType *T); 109 QualType VisitTypeOfExprType(const TypeOfExprType *T); 110 // FIXME: DependentTypeOfExprType 111 QualType VisitTypeOfType(const TypeOfType *T); 112 QualType VisitDecltypeType(const DecltypeType *T); 113 QualType VisitUnaryTransformType(const UnaryTransformType *T); 114 QualType VisitAutoType(const AutoType *T); 115 QualType VisitInjectedClassNameType(const InjectedClassNameType *T); 116 // FIXME: DependentDecltypeType 117 QualType VisitRecordType(const RecordType *T); 118 QualType VisitEnumType(const EnumType *T); 119 QualType VisitAttributedType(const AttributedType *T); 120 QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T); 121 QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T); 122 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T); 123 QualType VisitElaboratedType(const ElaboratedType *T); 124 QualType VisitDependentNameType(const DependentNameType *T); 125 QualType VisitPackExpansionType(const PackExpansionType *T); 126 QualType VisitDependentTemplateSpecializationType( 127 const DependentTemplateSpecializationType *T); 128 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T); 129 QualType VisitObjCObjectType(const ObjCObjectType *T); 130 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 131 132 // Importing declarations 133 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 134 DeclContext *&LexicalDC, DeclarationName &Name, 135 NamedDecl *&ToD, SourceLocation &Loc); 136 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 137 void ImportDeclarationNameLoc(const DeclarationNameInfo &From, 138 DeclarationNameInfo& To); 139 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 140 141 bool ImportCastPath(CastExpr *E, CXXCastPath &Path); 142 143 using Designator = DesignatedInitExpr::Designator; 144 145 Designator ImportDesignator(const Designator &D); 146 147 Optional<LambdaCapture> ImportLambdaCapture(const LambdaCapture &From); 148 149 /// What we should import from the definition. 150 enum ImportDefinitionKind { 151 /// Import the default subset of the definition, which might be 152 /// nothing (if minimal import is set) or might be everything (if minimal 153 /// import is not set). 154 IDK_Default, 155 156 /// Import everything. 157 IDK_Everything, 158 159 /// Import only the bare bones needed to establish a valid 160 /// DeclContext. 161 IDK_Basic 162 }; 163 164 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 165 return IDK == IDK_Everything || 166 (IDK == IDK_Default && !Importer.isMinimalImport()); 167 } 168 169 bool ImportDefinition(RecordDecl *From, RecordDecl *To, 170 ImportDefinitionKind Kind = IDK_Default); 171 bool ImportDefinition(VarDecl *From, VarDecl *To, 172 ImportDefinitionKind Kind = IDK_Default); 173 bool ImportDefinition(EnumDecl *From, EnumDecl *To, 174 ImportDefinitionKind Kind = IDK_Default); 175 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 176 ImportDefinitionKind Kind = IDK_Default); 177 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To, 178 ImportDefinitionKind Kind = IDK_Default); 179 TemplateParameterList *ImportTemplateParameterList( 180 TemplateParameterList *Params); 181 TemplateArgument ImportTemplateArgument(const TemplateArgument &From); 182 Optional<TemplateArgumentLoc> ImportTemplateArgumentLoc( 183 const TemplateArgumentLoc &TALoc); 184 bool ImportTemplateArguments(const TemplateArgument *FromArgs, 185 unsigned NumFromArgs, 186 SmallVectorImpl<TemplateArgument> &ToArgs); 187 188 template <typename InContainerTy> 189 bool ImportTemplateArgumentListInfo(const InContainerTy &Container, 190 TemplateArgumentListInfo &ToTAInfo); 191 192 template<typename InContainerTy> 193 bool ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc, 194 SourceLocation FromRAngleLoc, 195 const InContainerTy &Container, 196 TemplateArgumentListInfo &Result); 197 198 bool ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD); 199 200 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 201 bool Complain = true); 202 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 203 bool Complain = true); 204 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 205 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 206 bool IsStructuralMatch(FunctionTemplateDecl *From, 207 FunctionTemplateDecl *To); 208 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 209 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 210 Decl *VisitDecl(Decl *D); 211 Decl *VisitEmptyDecl(EmptyDecl *D); 212 Decl *VisitAccessSpecDecl(AccessSpecDecl *D); 213 Decl *VisitStaticAssertDecl(StaticAssertDecl *D); 214 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 215 Decl *VisitNamespaceDecl(NamespaceDecl *D); 216 Decl *VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 217 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 218 Decl *VisitTypedefDecl(TypedefDecl *D); 219 Decl *VisitTypeAliasDecl(TypeAliasDecl *D); 220 Decl *VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D); 221 Decl *VisitLabelDecl(LabelDecl *D); 222 Decl *VisitEnumDecl(EnumDecl *D); 223 Decl *VisitRecordDecl(RecordDecl *D); 224 Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 225 Decl *VisitFunctionDecl(FunctionDecl *D); 226 Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 227 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 228 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 229 Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 230 Decl *VisitFieldDecl(FieldDecl *D); 231 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D); 232 Decl *VisitFriendDecl(FriendDecl *D); 233 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D); 234 Decl *VisitVarDecl(VarDecl *D); 235 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D); 236 Decl *VisitParmVarDecl(ParmVarDecl *D); 237 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D); 238 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 239 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D); 240 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D); 241 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D); 242 Decl *VisitUsingDecl(UsingDecl *D); 243 Decl *VisitUsingShadowDecl(UsingShadowDecl *D); 244 Decl *VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 245 Decl *VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 246 Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 247 248 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list); 249 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 250 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 251 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D); 252 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D); 253 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 254 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 255 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 256 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 257 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 258 Decl *VisitClassTemplateSpecializationDecl( 259 ClassTemplateSpecializationDecl *D); 260 Decl *VisitVarTemplateDecl(VarTemplateDecl *D); 261 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 262 Decl *VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 263 264 // Importing statements 265 DeclGroupRef ImportDeclGroup(DeclGroupRef DG); 266 267 Stmt *VisitStmt(Stmt *S); 268 Stmt *VisitGCCAsmStmt(GCCAsmStmt *S); 269 Stmt *VisitDeclStmt(DeclStmt *S); 270 Stmt *VisitNullStmt(NullStmt *S); 271 Stmt *VisitCompoundStmt(CompoundStmt *S); 272 Stmt *VisitCaseStmt(CaseStmt *S); 273 Stmt *VisitDefaultStmt(DefaultStmt *S); 274 Stmt *VisitLabelStmt(LabelStmt *S); 275 Stmt *VisitAttributedStmt(AttributedStmt *S); 276 Stmt *VisitIfStmt(IfStmt *S); 277 Stmt *VisitSwitchStmt(SwitchStmt *S); 278 Stmt *VisitWhileStmt(WhileStmt *S); 279 Stmt *VisitDoStmt(DoStmt *S); 280 Stmt *VisitForStmt(ForStmt *S); 281 Stmt *VisitGotoStmt(GotoStmt *S); 282 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S); 283 Stmt *VisitContinueStmt(ContinueStmt *S); 284 Stmt *VisitBreakStmt(BreakStmt *S); 285 Stmt *VisitReturnStmt(ReturnStmt *S); 286 // FIXME: MSAsmStmt 287 // FIXME: SEHExceptStmt 288 // FIXME: SEHFinallyStmt 289 // FIXME: SEHTryStmt 290 // FIXME: SEHLeaveStmt 291 // FIXME: CapturedStmt 292 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S); 293 Stmt *VisitCXXTryStmt(CXXTryStmt *S); 294 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S); 295 // FIXME: MSDependentExistsStmt 296 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 297 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 298 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 299 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S); 300 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 301 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 302 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 303 304 // Importing expressions 305 Expr *VisitExpr(Expr *E); 306 Expr *VisitVAArgExpr(VAArgExpr *E); 307 Expr *VisitGNUNullExpr(GNUNullExpr *E); 308 Expr *VisitPredefinedExpr(PredefinedExpr *E); 309 Expr *VisitDeclRefExpr(DeclRefExpr *E); 310 Expr *VisitImplicitValueInitExpr(ImplicitValueInitExpr *ILE); 311 Expr *VisitDesignatedInitExpr(DesignatedInitExpr *E); 312 Expr *VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E); 313 Expr *VisitIntegerLiteral(IntegerLiteral *E); 314 Expr *VisitFloatingLiteral(FloatingLiteral *E); 315 Expr *VisitCharacterLiteral(CharacterLiteral *E); 316 Expr *VisitStringLiteral(StringLiteral *E); 317 Expr *VisitCompoundLiteralExpr(CompoundLiteralExpr *E); 318 Expr *VisitAtomicExpr(AtomicExpr *E); 319 Expr *VisitAddrLabelExpr(AddrLabelExpr *E); 320 Expr *VisitParenExpr(ParenExpr *E); 321 Expr *VisitParenListExpr(ParenListExpr *E); 322 Expr *VisitStmtExpr(StmtExpr *E); 323 Expr *VisitUnaryOperator(UnaryOperator *E); 324 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 325 Expr *VisitBinaryOperator(BinaryOperator *E); 326 Expr *VisitConditionalOperator(ConditionalOperator *E); 327 Expr *VisitBinaryConditionalOperator(BinaryConditionalOperator *E); 328 Expr *VisitOpaqueValueExpr(OpaqueValueExpr *E); 329 Expr *VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E); 330 Expr *VisitExpressionTraitExpr(ExpressionTraitExpr *E); 331 Expr *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 332 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E); 333 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E); 334 Expr *VisitExplicitCastExpr(ExplicitCastExpr *E); 335 Expr *VisitOffsetOfExpr(OffsetOfExpr *OE); 336 Expr *VisitCXXThrowExpr(CXXThrowExpr *E); 337 Expr *VisitCXXNoexceptExpr(CXXNoexceptExpr *E); 338 Expr *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E); 339 Expr *VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E); 340 Expr *VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E); 341 Expr *VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE); 342 Expr *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E); 343 Expr *VisitPackExpansionExpr(PackExpansionExpr *E); 344 Expr *VisitSizeOfPackExpr(SizeOfPackExpr *E); 345 Expr *VisitCXXNewExpr(CXXNewExpr *CE); 346 Expr *VisitCXXDeleteExpr(CXXDeleteExpr *E); 347 Expr *VisitCXXConstructExpr(CXXConstructExpr *E); 348 Expr *VisitCXXMemberCallExpr(CXXMemberCallExpr *E); 349 Expr *VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E); 350 Expr *VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E); 351 Expr *VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *CE); 352 Expr *VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E); 353 Expr *VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E); 354 Expr *VisitExprWithCleanups(ExprWithCleanups *EWC); 355 Expr *VisitCXXThisExpr(CXXThisExpr *E); 356 Expr *VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E); 357 Expr *VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E); 358 Expr *VisitMemberExpr(MemberExpr *E); 359 Expr *VisitCallExpr(CallExpr *E); 360 Expr *VisitLambdaExpr(LambdaExpr *LE); 361 Expr *VisitInitListExpr(InitListExpr *E); 362 Expr *VisitArrayInitLoopExpr(ArrayInitLoopExpr *E); 363 Expr *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E); 364 Expr *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E); 365 Expr *VisitCXXNamedCastExpr(CXXNamedCastExpr *E); 366 Expr *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E); 367 Expr *VisitTypeTraitExpr(TypeTraitExpr *E); 368 Expr *VisitCXXTypeidExpr(CXXTypeidExpr *E); 369 370 template<typename IIter, typename OIter> 371 void ImportArray(IIter Ibegin, IIter Iend, OIter Obegin) { 372 using ItemT = typename std::remove_reference<decltype(*Obegin)>::type; 373 374 ASTImporter &ImporterRef = Importer; 375 std::transform(Ibegin, Iend, Obegin, 376 [&ImporterRef](ItemT From) -> ItemT { 377 return ImporterRef.Import(From); 378 }); 379 } 380 381 template<typename IIter, typename OIter> 382 bool ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) { 383 using ItemT = typename std::remove_reference<decltype(**Obegin)>::type; 384 385 ASTImporter &ImporterRef = Importer; 386 bool Failed = false; 387 std::transform(Ibegin, Iend, Obegin, 388 [&ImporterRef, &Failed](ItemT *From) -> ItemT * { 389 auto *To = cast_or_null<ItemT>(ImporterRef.Import(From)); 390 if (!To && From) 391 Failed = true; 392 return To; 393 }); 394 return Failed; 395 } 396 397 template<typename InContainerTy, typename OutContainerTy> 398 bool ImportContainerChecked(const InContainerTy &InContainer, 399 OutContainerTy &OutContainer) { 400 return ImportArrayChecked(InContainer.begin(), InContainer.end(), 401 OutContainer.begin()); 402 } 403 404 template<typename InContainerTy, typename OIter> 405 bool ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) { 406 return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin); 407 } 408 409 // Importing overrides. 410 void ImportOverrides(CXXMethodDecl *ToMethod, CXXMethodDecl *FromMethod); 411 }; 412 413 template <typename InContainerTy> 414 bool ASTNodeImporter::ImportTemplateArgumentListInfo( 415 SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc, 416 const InContainerTy &Container, TemplateArgumentListInfo &Result) { 417 TemplateArgumentListInfo ToTAInfo(Importer.Import(FromLAngleLoc), 418 Importer.Import(FromRAngleLoc)); 419 if (ImportTemplateArgumentListInfo(Container, ToTAInfo)) 420 return true; 421 Result = ToTAInfo; 422 return false; 423 } 424 425 template <> 426 bool ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>( 427 const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) { 428 return ImportTemplateArgumentListInfo( 429 From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result); 430 } 431 432 template <> 433 bool ASTNodeImporter::ImportTemplateArgumentListInfo< 434 ASTTemplateArgumentListInfo>(const ASTTemplateArgumentListInfo &From, 435 TemplateArgumentListInfo &Result) { 436 return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc, 437 From.arguments(), Result); 438 } 439 440 } // namespace clang 441 442 //---------------------------------------------------------------------------- 443 // Import Types 444 //---------------------------------------------------------------------------- 445 446 using namespace clang; 447 448 QualType ASTNodeImporter::VisitType(const Type *T) { 449 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 450 << T->getTypeClassName(); 451 return {}; 452 } 453 454 QualType ASTNodeImporter::VisitAtomicType(const AtomicType *T){ 455 QualType UnderlyingType = Importer.Import(T->getValueType()); 456 if(UnderlyingType.isNull()) 457 return {}; 458 459 return Importer.getToContext().getAtomicType(UnderlyingType); 460 } 461 462 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 463 switch (T->getKind()) { 464 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 465 case BuiltinType::Id: \ 466 return Importer.getToContext().SingletonId; 467 #include "clang/Basic/OpenCLImageTypes.def" 468 #define SHARED_SINGLETON_TYPE(Expansion) 469 #define BUILTIN_TYPE(Id, SingletonId) \ 470 case BuiltinType::Id: return Importer.getToContext().SingletonId; 471 #include "clang/AST/BuiltinTypes.def" 472 473 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 474 // context supports C++. 475 476 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 477 // context supports ObjC. 478 479 case BuiltinType::Char_U: 480 // The context we're importing from has an unsigned 'char'. If we're 481 // importing into a context with a signed 'char', translate to 482 // 'unsigned char' instead. 483 if (Importer.getToContext().getLangOpts().CharIsSigned) 484 return Importer.getToContext().UnsignedCharTy; 485 486 return Importer.getToContext().CharTy; 487 488 case BuiltinType::Char_S: 489 // The context we're importing from has an unsigned 'char'. If we're 490 // importing into a context with a signed 'char', translate to 491 // 'unsigned char' instead. 492 if (!Importer.getToContext().getLangOpts().CharIsSigned) 493 return Importer.getToContext().SignedCharTy; 494 495 return Importer.getToContext().CharTy; 496 497 case BuiltinType::WChar_S: 498 case BuiltinType::WChar_U: 499 // FIXME: If not in C++, shall we translate to the C equivalent of 500 // wchar_t? 501 return Importer.getToContext().WCharTy; 502 } 503 504 llvm_unreachable("Invalid BuiltinType Kind!"); 505 } 506 507 QualType ASTNodeImporter::VisitDecayedType(const DecayedType *T) { 508 QualType OrigT = Importer.Import(T->getOriginalType()); 509 if (OrigT.isNull()) 510 return {}; 511 512 return Importer.getToContext().getDecayedType(OrigT); 513 } 514 515 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 516 QualType ToElementType = Importer.Import(T->getElementType()); 517 if (ToElementType.isNull()) 518 return {}; 519 520 return Importer.getToContext().getComplexType(ToElementType); 521 } 522 523 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) { 524 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 525 if (ToPointeeType.isNull()) 526 return {}; 527 528 return Importer.getToContext().getPointerType(ToPointeeType); 529 } 530 531 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 532 // FIXME: Check for blocks support in "to" context. 533 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 534 if (ToPointeeType.isNull()) 535 return {}; 536 537 return Importer.getToContext().getBlockPointerType(ToPointeeType); 538 } 539 540 QualType 541 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 542 // FIXME: Check for C++ support in "to" context. 543 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 544 if (ToPointeeType.isNull()) 545 return {}; 546 547 return Importer.getToContext().getLValueReferenceType(ToPointeeType); 548 } 549 550 QualType 551 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 552 // FIXME: Check for C++0x support in "to" context. 553 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 554 if (ToPointeeType.isNull()) 555 return {}; 556 557 return Importer.getToContext().getRValueReferenceType(ToPointeeType); 558 } 559 560 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 561 // FIXME: Check for C++ support in "to" context. 562 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 563 if (ToPointeeType.isNull()) 564 return {}; 565 566 QualType ClassType = Importer.Import(QualType(T->getClass(), 0)); 567 return Importer.getToContext().getMemberPointerType(ToPointeeType, 568 ClassType.getTypePtr()); 569 } 570 571 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 572 QualType ToElementType = Importer.Import(T->getElementType()); 573 if (ToElementType.isNull()) 574 return {}; 575 576 return Importer.getToContext().getConstantArrayType(ToElementType, 577 T->getSize(), 578 T->getSizeModifier(), 579 T->getIndexTypeCVRQualifiers()); 580 } 581 582 QualType 583 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 584 QualType ToElementType = Importer.Import(T->getElementType()); 585 if (ToElementType.isNull()) 586 return {}; 587 588 return Importer.getToContext().getIncompleteArrayType(ToElementType, 589 T->getSizeModifier(), 590 T->getIndexTypeCVRQualifiers()); 591 } 592 593 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 594 QualType ToElementType = Importer.Import(T->getElementType()); 595 if (ToElementType.isNull()) 596 return {}; 597 598 Expr *Size = Importer.Import(T->getSizeExpr()); 599 if (!Size) 600 return {}; 601 602 SourceRange Brackets = Importer.Import(T->getBracketsRange()); 603 return Importer.getToContext().getVariableArrayType(ToElementType, Size, 604 T->getSizeModifier(), 605 T->getIndexTypeCVRQualifiers(), 606 Brackets); 607 } 608 609 QualType ASTNodeImporter::VisitDependentSizedArrayType( 610 const DependentSizedArrayType *T) { 611 QualType ToElementType = Importer.Import(T->getElementType()); 612 if (ToElementType.isNull()) 613 return {}; 614 615 // SizeExpr may be null if size is not specified directly. 616 // For example, 'int a[]'. 617 Expr *Size = Importer.Import(T->getSizeExpr()); 618 if (!Size && T->getSizeExpr()) 619 return {}; 620 621 SourceRange Brackets = Importer.Import(T->getBracketsRange()); 622 return Importer.getToContext().getDependentSizedArrayType( 623 ToElementType, Size, T->getSizeModifier(), T->getIndexTypeCVRQualifiers(), 624 Brackets); 625 } 626 627 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) { 628 QualType ToElementType = Importer.Import(T->getElementType()); 629 if (ToElementType.isNull()) 630 return {}; 631 632 return Importer.getToContext().getVectorType(ToElementType, 633 T->getNumElements(), 634 T->getVectorKind()); 635 } 636 637 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 638 QualType ToElementType = Importer.Import(T->getElementType()); 639 if (ToElementType.isNull()) 640 return {}; 641 642 return Importer.getToContext().getExtVectorType(ToElementType, 643 T->getNumElements()); 644 } 645 646 QualType 647 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 648 // FIXME: What happens if we're importing a function without a prototype 649 // into C++? Should we make it variadic? 650 QualType ToResultType = Importer.Import(T->getReturnType()); 651 if (ToResultType.isNull()) 652 return {}; 653 654 return Importer.getToContext().getFunctionNoProtoType(ToResultType, 655 T->getExtInfo()); 656 } 657 658 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 659 QualType ToResultType = Importer.Import(T->getReturnType()); 660 if (ToResultType.isNull()) 661 return {}; 662 663 // Import argument types 664 SmallVector<QualType, 4> ArgTypes; 665 for (const auto &A : T->param_types()) { 666 QualType ArgType = Importer.Import(A); 667 if (ArgType.isNull()) 668 return {}; 669 ArgTypes.push_back(ArgType); 670 } 671 672 // Import exception types 673 SmallVector<QualType, 4> ExceptionTypes; 674 for (const auto &E : T->exceptions()) { 675 QualType ExceptionType = Importer.Import(E); 676 if (ExceptionType.isNull()) 677 return {}; 678 ExceptionTypes.push_back(ExceptionType); 679 } 680 681 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 682 FunctionProtoType::ExtProtoInfo ToEPI; 683 684 ToEPI.ExtInfo = FromEPI.ExtInfo; 685 ToEPI.Variadic = FromEPI.Variadic; 686 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 687 ToEPI.TypeQuals = FromEPI.TypeQuals; 688 ToEPI.RefQualifier = FromEPI.RefQualifier; 689 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 690 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 691 ToEPI.ExceptionSpec.NoexceptExpr = 692 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr); 693 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>( 694 Importer.Import(FromEPI.ExceptionSpec.SourceDecl)); 695 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>( 696 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate)); 697 698 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI); 699 } 700 701 QualType ASTNodeImporter::VisitUnresolvedUsingType( 702 const UnresolvedUsingType *T) { 703 const auto *ToD = 704 cast_or_null<UnresolvedUsingTypenameDecl>(Importer.Import(T->getDecl())); 705 if (!ToD) 706 return {}; 707 708 auto *ToPrevD = 709 cast_or_null<UnresolvedUsingTypenameDecl>( 710 Importer.Import(T->getDecl()->getPreviousDecl())); 711 if (!ToPrevD && T->getDecl()->getPreviousDecl()) 712 return {}; 713 714 return Importer.getToContext().getTypeDeclType(ToD, ToPrevD); 715 } 716 717 QualType ASTNodeImporter::VisitParenType(const ParenType *T) { 718 QualType ToInnerType = Importer.Import(T->getInnerType()); 719 if (ToInnerType.isNull()) 720 return {}; 721 722 return Importer.getToContext().getParenType(ToInnerType); 723 } 724 725 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 726 auto *ToDecl = 727 dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl())); 728 if (!ToDecl) 729 return {}; 730 731 return Importer.getToContext().getTypeDeclType(ToDecl); 732 } 733 734 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 735 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 736 if (!ToExpr) 737 return {}; 738 739 return Importer.getToContext().getTypeOfExprType(ToExpr); 740 } 741 742 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 743 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 744 if (ToUnderlyingType.isNull()) 745 return {}; 746 747 return Importer.getToContext().getTypeOfType(ToUnderlyingType); 748 } 749 750 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 751 // FIXME: Make sure that the "to" context supports C++0x! 752 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 753 if (!ToExpr) 754 return {}; 755 756 QualType UnderlyingType = Importer.Import(T->getUnderlyingType()); 757 if (UnderlyingType.isNull()) 758 return {}; 759 760 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType); 761 } 762 763 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 764 QualType ToBaseType = Importer.Import(T->getBaseType()); 765 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 766 if (ToBaseType.isNull() || ToUnderlyingType.isNull()) 767 return {}; 768 769 return Importer.getToContext().getUnaryTransformType(ToBaseType, 770 ToUnderlyingType, 771 T->getUTTKind()); 772 } 773 774 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) { 775 // FIXME: Make sure that the "to" context supports C++11! 776 QualType FromDeduced = T->getDeducedType(); 777 QualType ToDeduced; 778 if (!FromDeduced.isNull()) { 779 ToDeduced = Importer.Import(FromDeduced); 780 if (ToDeduced.isNull()) 781 return {}; 782 } 783 784 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(), 785 /*IsDependent*/false); 786 } 787 788 QualType ASTNodeImporter::VisitInjectedClassNameType( 789 const InjectedClassNameType *T) { 790 auto *D = cast_or_null<CXXRecordDecl>(Importer.Import(T->getDecl())); 791 if (!D) 792 return {}; 793 794 QualType InjType = Importer.Import(T->getInjectedSpecializationType()); 795 if (InjType.isNull()) 796 return {}; 797 798 // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading 799 // See comments in InjectedClassNameType definition for details 800 // return Importer.getToContext().getInjectedClassNameType(D, InjType); 801 enum { 802 TypeAlignmentInBits = 4, 803 TypeAlignment = 1 << TypeAlignmentInBits 804 }; 805 806 return QualType(new (Importer.getToContext(), TypeAlignment) 807 InjectedClassNameType(D, InjType), 0); 808 } 809 810 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) { 811 auto *ToDecl = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl())); 812 if (!ToDecl) 813 return {}; 814 815 return Importer.getToContext().getTagDeclType(ToDecl); 816 } 817 818 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) { 819 auto *ToDecl = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl())); 820 if (!ToDecl) 821 return {}; 822 823 return Importer.getToContext().getTagDeclType(ToDecl); 824 } 825 826 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 827 QualType FromModifiedType = T->getModifiedType(); 828 QualType FromEquivalentType = T->getEquivalentType(); 829 QualType ToModifiedType; 830 QualType ToEquivalentType; 831 832 if (!FromModifiedType.isNull()) { 833 ToModifiedType = Importer.Import(FromModifiedType); 834 if (ToModifiedType.isNull()) 835 return {}; 836 } 837 if (!FromEquivalentType.isNull()) { 838 ToEquivalentType = Importer.Import(FromEquivalentType); 839 if (ToEquivalentType.isNull()) 840 return {}; 841 } 842 843 return Importer.getToContext().getAttributedType(T->getAttrKind(), 844 ToModifiedType, ToEquivalentType); 845 } 846 847 QualType ASTNodeImporter::VisitTemplateTypeParmType( 848 const TemplateTypeParmType *T) { 849 auto *ParmDecl = 850 cast_or_null<TemplateTypeParmDecl>(Importer.Import(T->getDecl())); 851 if (!ParmDecl && T->getDecl()) 852 return {}; 853 854 return Importer.getToContext().getTemplateTypeParmType( 855 T->getDepth(), T->getIndex(), T->isParameterPack(), ParmDecl); 856 } 857 858 QualType ASTNodeImporter::VisitSubstTemplateTypeParmType( 859 const SubstTemplateTypeParmType *T) { 860 const auto *Replaced = 861 cast_or_null<TemplateTypeParmType>(Importer.Import( 862 QualType(T->getReplacedParameter(), 0)).getTypePtr()); 863 if (!Replaced) 864 return {}; 865 866 QualType Replacement = Importer.Import(T->getReplacementType()); 867 if (Replacement.isNull()) 868 return {}; 869 Replacement = Replacement.getCanonicalType(); 870 871 return Importer.getToContext().getSubstTemplateTypeParmType( 872 Replaced, Replacement); 873 } 874 875 QualType ASTNodeImporter::VisitTemplateSpecializationType( 876 const TemplateSpecializationType *T) { 877 TemplateName ToTemplate = Importer.Import(T->getTemplateName()); 878 if (ToTemplate.isNull()) 879 return {}; 880 881 SmallVector<TemplateArgument, 2> ToTemplateArgs; 882 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 883 return {}; 884 885 QualType ToCanonType; 886 if (!QualType(T, 0).isCanonical()) { 887 QualType FromCanonType 888 = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 889 ToCanonType =Importer.Import(FromCanonType); 890 if (ToCanonType.isNull()) 891 return {}; 892 } 893 return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 894 ToTemplateArgs, 895 ToCanonType); 896 } 897 898 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 899 NestedNameSpecifier *ToQualifier = nullptr; 900 // Note: the qualifier in an ElaboratedType is optional. 901 if (T->getQualifier()) { 902 ToQualifier = Importer.Import(T->getQualifier()); 903 if (!ToQualifier) 904 return {}; 905 } 906 907 QualType ToNamedType = Importer.Import(T->getNamedType()); 908 if (ToNamedType.isNull()) 909 return {}; 910 911 return Importer.getToContext().getElaboratedType(T->getKeyword(), 912 ToQualifier, ToNamedType); 913 } 914 915 QualType ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) { 916 QualType Pattern = Importer.Import(T->getPattern()); 917 if (Pattern.isNull()) 918 return {}; 919 920 return Importer.getToContext().getPackExpansionType(Pattern, 921 T->getNumExpansions()); 922 } 923 924 QualType ASTNodeImporter::VisitDependentTemplateSpecializationType( 925 const DependentTemplateSpecializationType *T) { 926 NestedNameSpecifier *Qualifier = Importer.Import(T->getQualifier()); 927 if (!Qualifier && T->getQualifier()) 928 return {}; 929 930 IdentifierInfo *Name = Importer.Import(T->getIdentifier()); 931 if (!Name && T->getIdentifier()) 932 return {}; 933 934 SmallVector<TemplateArgument, 2> ToPack; 935 ToPack.reserve(T->getNumArgs()); 936 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack)) 937 return {}; 938 939 return Importer.getToContext().getDependentTemplateSpecializationType( 940 T->getKeyword(), Qualifier, Name, ToPack); 941 } 942 943 QualType ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) { 944 NestedNameSpecifier *NNS = Importer.Import(T->getQualifier()); 945 if (!NNS && T->getQualifier()) 946 return QualType(); 947 948 IdentifierInfo *Name = Importer.Import(T->getIdentifier()); 949 if (!Name && T->getIdentifier()) 950 return QualType(); 951 952 QualType Canon = (T == T->getCanonicalTypeInternal().getTypePtr()) 953 ? QualType() 954 : Importer.Import(T->getCanonicalTypeInternal()); 955 if (!Canon.isNull()) 956 Canon = Canon.getCanonicalType(); 957 958 return Importer.getToContext().getDependentNameType(T->getKeyword(), NNS, 959 Name, Canon); 960 } 961 962 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 963 auto *Class = 964 dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl())); 965 if (!Class) 966 return {}; 967 968 return Importer.getToContext().getObjCInterfaceType(Class); 969 } 970 971 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 972 QualType ToBaseType = Importer.Import(T->getBaseType()); 973 if (ToBaseType.isNull()) 974 return {}; 975 976 SmallVector<QualType, 4> TypeArgs; 977 for (auto TypeArg : T->getTypeArgsAsWritten()) { 978 QualType ImportedTypeArg = Importer.Import(TypeArg); 979 if (ImportedTypeArg.isNull()) 980 return {}; 981 982 TypeArgs.push_back(ImportedTypeArg); 983 } 984 985 SmallVector<ObjCProtocolDecl *, 4> Protocols; 986 for (auto *P : T->quals()) { 987 auto *Protocol = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P)); 988 if (!Protocol) 989 return {}; 990 Protocols.push_back(Protocol); 991 } 992 993 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs, 994 Protocols, 995 T->isKindOfTypeAsWritten()); 996 } 997 998 QualType 999 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 1000 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 1001 if (ToPointeeType.isNull()) 1002 return {}; 1003 1004 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType); 1005 } 1006 1007 //---------------------------------------------------------------------------- 1008 // Import Declarations 1009 //---------------------------------------------------------------------------- 1010 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, 1011 DeclContext *&LexicalDC, 1012 DeclarationName &Name, 1013 NamedDecl *&ToD, 1014 SourceLocation &Loc) { 1015 // Import the context of this declaration. 1016 DC = Importer.ImportContext(D->getDeclContext()); 1017 if (!DC) 1018 return true; 1019 1020 LexicalDC = DC; 1021 if (D->getDeclContext() != D->getLexicalDeclContext()) { 1022 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 1023 if (!LexicalDC) 1024 return true; 1025 } 1026 1027 // Import the name of this declaration. 1028 Name = Importer.Import(D->getDeclName()); 1029 if (D->getDeclName() && !Name) 1030 return true; 1031 1032 // Import the location of this declaration. 1033 Loc = Importer.Import(D->getLocation()); 1034 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 1035 return false; 1036 } 1037 1038 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 1039 if (!FromD) 1040 return; 1041 1042 if (!ToD) { 1043 ToD = Importer.Import(FromD); 1044 if (!ToD) 1045 return; 1046 } 1047 1048 if (auto *FromRecord = dyn_cast<RecordDecl>(FromD)) { 1049 if (auto *ToRecord = cast_or_null<RecordDecl>(ToD)) { 1050 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) { 1051 ImportDefinition(FromRecord, ToRecord); 1052 } 1053 } 1054 return; 1055 } 1056 1057 if (auto *FromEnum = dyn_cast<EnumDecl>(FromD)) { 1058 if (auto *ToEnum = cast_or_null<EnumDecl>(ToD)) { 1059 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 1060 ImportDefinition(FromEnum, ToEnum); 1061 } 1062 } 1063 return; 1064 } 1065 } 1066 1067 void 1068 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From, 1069 DeclarationNameInfo& To) { 1070 // NOTE: To.Name and To.Loc are already imported. 1071 // We only have to import To.LocInfo. 1072 switch (To.getName().getNameKind()) { 1073 case DeclarationName::Identifier: 1074 case DeclarationName::ObjCZeroArgSelector: 1075 case DeclarationName::ObjCOneArgSelector: 1076 case DeclarationName::ObjCMultiArgSelector: 1077 case DeclarationName::CXXUsingDirective: 1078 case DeclarationName::CXXDeductionGuideName: 1079 return; 1080 1081 case DeclarationName::CXXOperatorName: { 1082 SourceRange Range = From.getCXXOperatorNameRange(); 1083 To.setCXXOperatorNameRange(Importer.Import(Range)); 1084 return; 1085 } 1086 case DeclarationName::CXXLiteralOperatorName: { 1087 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc(); 1088 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc)); 1089 return; 1090 } 1091 case DeclarationName::CXXConstructorName: 1092 case DeclarationName::CXXDestructorName: 1093 case DeclarationName::CXXConversionFunctionName: { 1094 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo(); 1095 To.setNamedTypeInfo(Importer.Import(FromTInfo)); 1096 return; 1097 } 1098 } 1099 llvm_unreachable("Unknown name kind."); 1100 } 1101 1102 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 1103 if (Importer.isMinimalImport() && !ForceImport) { 1104 Importer.ImportContext(FromDC); 1105 return; 1106 } 1107 1108 for (auto *From : FromDC->decls()) 1109 Importer.Import(From); 1110 } 1111 1112 static void setTypedefNameForAnonDecl(TagDecl *From, TagDecl *To, 1113 ASTImporter &Importer) { 1114 if (TypedefNameDecl *FromTypedef = From->getTypedefNameForAnonDecl()) { 1115 auto *ToTypedef = 1116 cast_or_null<TypedefNameDecl>(Importer.Import(FromTypedef)); 1117 assert (ToTypedef && "Failed to import typedef of an anonymous structure"); 1118 1119 To->setTypedefNameForAnonDecl(ToTypedef); 1120 } 1121 } 1122 1123 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To, 1124 ImportDefinitionKind Kind) { 1125 if (To->getDefinition() || To->isBeingDefined()) { 1126 if (Kind == IDK_Everything) 1127 ImportDeclContext(From, /*ForceImport=*/true); 1128 1129 return false; 1130 } 1131 1132 To->startDefinition(); 1133 1134 setTypedefNameForAnonDecl(From, To, Importer); 1135 1136 // Add base classes. 1137 if (auto *ToCXX = dyn_cast<CXXRecordDecl>(To)) { 1138 auto *FromCXX = cast<CXXRecordDecl>(From); 1139 1140 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 1141 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 1142 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor; 1143 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers; 1144 ToData.Aggregate = FromData.Aggregate; 1145 ToData.PlainOldData = FromData.PlainOldData; 1146 ToData.Empty = FromData.Empty; 1147 ToData.Polymorphic = FromData.Polymorphic; 1148 ToData.Abstract = FromData.Abstract; 1149 ToData.IsStandardLayout = FromData.IsStandardLayout; 1150 ToData.IsCXX11StandardLayout = FromData.IsCXX11StandardLayout; 1151 ToData.HasBasesWithFields = FromData.HasBasesWithFields; 1152 ToData.HasBasesWithNonStaticDataMembers = 1153 FromData.HasBasesWithNonStaticDataMembers; 1154 ToData.HasPrivateFields = FromData.HasPrivateFields; 1155 ToData.HasProtectedFields = FromData.HasProtectedFields; 1156 ToData.HasPublicFields = FromData.HasPublicFields; 1157 ToData.HasMutableFields = FromData.HasMutableFields; 1158 ToData.HasVariantMembers = FromData.HasVariantMembers; 1159 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; 1160 ToData.HasInClassInitializer = FromData.HasInClassInitializer; 1161 ToData.HasUninitializedReferenceMember 1162 = FromData.HasUninitializedReferenceMember; 1163 ToData.HasUninitializedFields = FromData.HasUninitializedFields; 1164 ToData.HasInheritedConstructor = FromData.HasInheritedConstructor; 1165 ToData.HasInheritedAssignment = FromData.HasInheritedAssignment; 1166 ToData.NeedOverloadResolutionForCopyConstructor 1167 = FromData.NeedOverloadResolutionForCopyConstructor; 1168 ToData.NeedOverloadResolutionForMoveConstructor 1169 = FromData.NeedOverloadResolutionForMoveConstructor; 1170 ToData.NeedOverloadResolutionForMoveAssignment 1171 = FromData.NeedOverloadResolutionForMoveAssignment; 1172 ToData.NeedOverloadResolutionForDestructor 1173 = FromData.NeedOverloadResolutionForDestructor; 1174 ToData.DefaultedCopyConstructorIsDeleted 1175 = FromData.DefaultedCopyConstructorIsDeleted; 1176 ToData.DefaultedMoveConstructorIsDeleted 1177 = FromData.DefaultedMoveConstructorIsDeleted; 1178 ToData.DefaultedMoveAssignmentIsDeleted 1179 = FromData.DefaultedMoveAssignmentIsDeleted; 1180 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted; 1181 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers; 1182 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor; 1183 ToData.HasConstexprNonCopyMoveConstructor 1184 = FromData.HasConstexprNonCopyMoveConstructor; 1185 ToData.HasDefaultedDefaultConstructor 1186 = FromData.HasDefaultedDefaultConstructor; 1187 ToData.DefaultedDefaultConstructorIsConstexpr 1188 = FromData.DefaultedDefaultConstructorIsConstexpr; 1189 ToData.HasConstexprDefaultConstructor 1190 = FromData.HasConstexprDefaultConstructor; 1191 ToData.HasNonLiteralTypeFieldsOrBases 1192 = FromData.HasNonLiteralTypeFieldsOrBases; 1193 // ComputedVisibleConversions not imported. 1194 ToData.UserProvidedDefaultConstructor 1195 = FromData.UserProvidedDefaultConstructor; 1196 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers; 1197 ToData.ImplicitCopyConstructorCanHaveConstParamForVBase 1198 = FromData.ImplicitCopyConstructorCanHaveConstParamForVBase; 1199 ToData.ImplicitCopyConstructorCanHaveConstParamForNonVBase 1200 = FromData.ImplicitCopyConstructorCanHaveConstParamForNonVBase; 1201 ToData.ImplicitCopyAssignmentHasConstParam 1202 = FromData.ImplicitCopyAssignmentHasConstParam; 1203 ToData.HasDeclaredCopyConstructorWithConstParam 1204 = FromData.HasDeclaredCopyConstructorWithConstParam; 1205 ToData.HasDeclaredCopyAssignmentWithConstParam 1206 = FromData.HasDeclaredCopyAssignmentWithConstParam; 1207 1208 SmallVector<CXXBaseSpecifier *, 4> Bases; 1209 for (const auto &Base1 : FromCXX->bases()) { 1210 QualType T = Importer.Import(Base1.getType()); 1211 if (T.isNull()) 1212 return true; 1213 1214 SourceLocation EllipsisLoc; 1215 if (Base1.isPackExpansion()) 1216 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc()); 1217 1218 // Ensure that we have a definition for the base. 1219 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()); 1220 1221 Bases.push_back( 1222 new (Importer.getToContext()) 1223 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()), 1224 Base1.isVirtual(), 1225 Base1.isBaseOfClass(), 1226 Base1.getAccessSpecifierAsWritten(), 1227 Importer.Import(Base1.getTypeSourceInfo()), 1228 EllipsisLoc)); 1229 } 1230 if (!Bases.empty()) 1231 ToCXX->setBases(Bases.data(), Bases.size()); 1232 } 1233 1234 if (shouldForceImportDeclContext(Kind)) 1235 ImportDeclContext(From, /*ForceImport=*/true); 1236 1237 To->completeDefinition(); 1238 return false; 1239 } 1240 1241 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To, 1242 ImportDefinitionKind Kind) { 1243 if (To->getAnyInitializer()) 1244 return false; 1245 1246 // FIXME: Can we really import any initializer? Alternatively, we could force 1247 // ourselves to import every declaration of a variable and then only use 1248 // getInit() here. 1249 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer()))); 1250 1251 // FIXME: Other bits to merge? 1252 1253 return false; 1254 } 1255 1256 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 1257 ImportDefinitionKind Kind) { 1258 if (To->getDefinition() || To->isBeingDefined()) { 1259 if (Kind == IDK_Everything) 1260 ImportDeclContext(From, /*ForceImport=*/true); 1261 return false; 1262 } 1263 1264 To->startDefinition(); 1265 1266 setTypedefNameForAnonDecl(From, To, Importer); 1267 1268 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From)); 1269 if (T.isNull()) 1270 return true; 1271 1272 QualType ToPromotionType = Importer.Import(From->getPromotionType()); 1273 if (ToPromotionType.isNull()) 1274 return true; 1275 1276 if (shouldForceImportDeclContext(Kind)) 1277 ImportDeclContext(From, /*ForceImport=*/true); 1278 1279 // FIXME: we might need to merge the number of positive or negative bits 1280 // if the enumerator lists don't match. 1281 To->completeDefinition(T, ToPromotionType, 1282 From->getNumPositiveBits(), 1283 From->getNumNegativeBits()); 1284 return false; 1285 } 1286 1287 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList( 1288 TemplateParameterList *Params) { 1289 SmallVector<NamedDecl *, 4> ToParams(Params->size()); 1290 if (ImportContainerChecked(*Params, ToParams)) 1291 return nullptr; 1292 1293 Expr *ToRequiresClause; 1294 if (Expr *const R = Params->getRequiresClause()) { 1295 ToRequiresClause = Importer.Import(R); 1296 if (!ToRequiresClause) 1297 return nullptr; 1298 } else { 1299 ToRequiresClause = nullptr; 1300 } 1301 1302 return TemplateParameterList::Create(Importer.getToContext(), 1303 Importer.Import(Params->getTemplateLoc()), 1304 Importer.Import(Params->getLAngleLoc()), 1305 ToParams, 1306 Importer.Import(Params->getRAngleLoc()), 1307 ToRequiresClause); 1308 } 1309 1310 TemplateArgument 1311 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 1312 switch (From.getKind()) { 1313 case TemplateArgument::Null: 1314 return TemplateArgument(); 1315 1316 case TemplateArgument::Type: { 1317 QualType ToType = Importer.Import(From.getAsType()); 1318 if (ToType.isNull()) 1319 return {}; 1320 return TemplateArgument(ToType); 1321 } 1322 1323 case TemplateArgument::Integral: { 1324 QualType ToType = Importer.Import(From.getIntegralType()); 1325 if (ToType.isNull()) 1326 return {}; 1327 return TemplateArgument(From, ToType); 1328 } 1329 1330 case TemplateArgument::Declaration: { 1331 auto *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl())); 1332 QualType ToType = Importer.Import(From.getParamTypeForDecl()); 1333 if (!To || ToType.isNull()) 1334 return {}; 1335 return TemplateArgument(To, ToType); 1336 } 1337 1338 case TemplateArgument::NullPtr: { 1339 QualType ToType = Importer.Import(From.getNullPtrType()); 1340 if (ToType.isNull()) 1341 return {}; 1342 return TemplateArgument(ToType, /*isNullPtr*/true); 1343 } 1344 1345 case TemplateArgument::Template: { 1346 TemplateName ToTemplate = Importer.Import(From.getAsTemplate()); 1347 if (ToTemplate.isNull()) 1348 return {}; 1349 1350 return TemplateArgument(ToTemplate); 1351 } 1352 1353 case TemplateArgument::TemplateExpansion: { 1354 TemplateName ToTemplate 1355 = Importer.Import(From.getAsTemplateOrTemplatePattern()); 1356 if (ToTemplate.isNull()) 1357 return {}; 1358 1359 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions()); 1360 } 1361 1362 case TemplateArgument::Expression: 1363 if (Expr *ToExpr = Importer.Import(From.getAsExpr())) 1364 return TemplateArgument(ToExpr); 1365 return TemplateArgument(); 1366 1367 case TemplateArgument::Pack: { 1368 SmallVector<TemplateArgument, 2> ToPack; 1369 ToPack.reserve(From.pack_size()); 1370 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack)) 1371 return {}; 1372 1373 return TemplateArgument( 1374 llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 1375 } 1376 } 1377 1378 llvm_unreachable("Invalid template argument kind"); 1379 } 1380 1381 Optional<TemplateArgumentLoc> 1382 ASTNodeImporter::ImportTemplateArgumentLoc(const TemplateArgumentLoc &TALoc) { 1383 TemplateArgument Arg = ImportTemplateArgument(TALoc.getArgument()); 1384 TemplateArgumentLocInfo FromInfo = TALoc.getLocInfo(); 1385 TemplateArgumentLocInfo ToInfo; 1386 if (Arg.getKind() == TemplateArgument::Expression) { 1387 Expr *E = Importer.Import(FromInfo.getAsExpr()); 1388 ToInfo = TemplateArgumentLocInfo(E); 1389 if (!E) 1390 return None; 1391 } else if (Arg.getKind() == TemplateArgument::Type) { 1392 if (TypeSourceInfo *TSI = Importer.Import(FromInfo.getAsTypeSourceInfo())) 1393 ToInfo = TemplateArgumentLocInfo(TSI); 1394 else 1395 return None; 1396 } else { 1397 ToInfo = TemplateArgumentLocInfo( 1398 Importer.Import(FromInfo.getTemplateQualifierLoc()), 1399 Importer.Import(FromInfo.getTemplateNameLoc()), 1400 Importer.Import(FromInfo.getTemplateEllipsisLoc())); 1401 } 1402 return TemplateArgumentLoc(Arg, ToInfo); 1403 } 1404 1405 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs, 1406 unsigned NumFromArgs, 1407 SmallVectorImpl<TemplateArgument> &ToArgs) { 1408 for (unsigned I = 0; I != NumFromArgs; ++I) { 1409 TemplateArgument To = ImportTemplateArgument(FromArgs[I]); 1410 if (To.isNull() && !FromArgs[I].isNull()) 1411 return true; 1412 1413 ToArgs.push_back(To); 1414 } 1415 1416 return false; 1417 } 1418 1419 // We cannot use Optional<> pattern here and below because 1420 // TemplateArgumentListInfo's operator new is declared as deleted so it cannot 1421 // be stored in Optional. 1422 template <typename InContainerTy> 1423 bool ASTNodeImporter::ImportTemplateArgumentListInfo( 1424 const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) { 1425 for (const auto &FromLoc : Container) { 1426 if (auto ToLoc = ImportTemplateArgumentLoc(FromLoc)) 1427 ToTAInfo.addArgument(*ToLoc); 1428 else 1429 return true; 1430 } 1431 return false; 1432 } 1433 1434 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 1435 RecordDecl *ToRecord, bool Complain) { 1436 // Eliminate a potential failure point where we attempt to re-import 1437 // something we're trying to import while completing ToRecord. 1438 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 1439 if (ToOrigin) { 1440 auto *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 1441 if (ToOriginRecord) 1442 ToRecord = ToOriginRecord; 1443 } 1444 1445 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1446 ToRecord->getASTContext(), 1447 Importer.getNonEquivalentDecls(), 1448 false, Complain); 1449 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord); 1450 } 1451 1452 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 1453 bool Complain) { 1454 StructuralEquivalenceContext Ctx( 1455 Importer.getFromContext(), Importer.getToContext(), 1456 Importer.getNonEquivalentDecls(), false, Complain); 1457 return Ctx.IsStructurallyEquivalent(FromVar, ToVar); 1458 } 1459 1460 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 1461 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1462 Importer.getToContext(), 1463 Importer.getNonEquivalentDecls()); 1464 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum); 1465 } 1466 1467 bool ASTNodeImporter::IsStructuralMatch(FunctionTemplateDecl *From, 1468 FunctionTemplateDecl *To) { 1469 StructuralEquivalenceContext Ctx( 1470 Importer.getFromContext(), Importer.getToContext(), 1471 Importer.getNonEquivalentDecls(), false, false); 1472 return Ctx.IsStructurallyEquivalent(From, To); 1473 } 1474 1475 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 1476 EnumConstantDecl *ToEC) { 1477 const llvm::APSInt &FromVal = FromEC->getInitVal(); 1478 const llvm::APSInt &ToVal = ToEC->getInitVal(); 1479 1480 return FromVal.isSigned() == ToVal.isSigned() && 1481 FromVal.getBitWidth() == ToVal.getBitWidth() && 1482 FromVal == ToVal; 1483 } 1484 1485 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 1486 ClassTemplateDecl *To) { 1487 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1488 Importer.getToContext(), 1489 Importer.getNonEquivalentDecls()); 1490 return Ctx.IsStructurallyEquivalent(From, To); 1491 } 1492 1493 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 1494 VarTemplateDecl *To) { 1495 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 1496 Importer.getToContext(), 1497 Importer.getNonEquivalentDecls()); 1498 return Ctx.IsStructurallyEquivalent(From, To); 1499 } 1500 1501 Decl *ASTNodeImporter::VisitDecl(Decl *D) { 1502 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 1503 << D->getDeclKindName(); 1504 return nullptr; 1505 } 1506 1507 Decl *ASTNodeImporter::VisitEmptyDecl(EmptyDecl *D) { 1508 // Import the context of this declaration. 1509 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1510 if (!DC) 1511 return nullptr; 1512 1513 DeclContext *LexicalDC = DC; 1514 if (D->getDeclContext() != D->getLexicalDeclContext()) { 1515 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 1516 if (!LexicalDC) 1517 return nullptr; 1518 } 1519 1520 // Import the location of this declaration. 1521 SourceLocation Loc = Importer.Import(D->getLocation()); 1522 1523 EmptyDecl *ToD = EmptyDecl::Create(Importer.getToContext(), DC, Loc); 1524 ToD->setLexicalDeclContext(LexicalDC); 1525 Importer.Imported(D, ToD); 1526 LexicalDC->addDeclInternal(ToD); 1527 return ToD; 1528 } 1529 1530 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 1531 TranslationUnitDecl *ToD = 1532 Importer.getToContext().getTranslationUnitDecl(); 1533 1534 Importer.Imported(D, ToD); 1535 1536 return ToD; 1537 } 1538 1539 Decl *ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) { 1540 SourceLocation Loc = Importer.Import(D->getLocation()); 1541 SourceLocation ColonLoc = Importer.Import(D->getColonLoc()); 1542 1543 // Import the context of this declaration. 1544 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1545 if (!DC) 1546 return nullptr; 1547 1548 AccessSpecDecl *accessSpecDecl 1549 = AccessSpecDecl::Create(Importer.getToContext(), D->getAccess(), 1550 DC, Loc, ColonLoc); 1551 1552 if (!accessSpecDecl) 1553 return nullptr; 1554 1555 // Lexical DeclContext and Semantic DeclContext 1556 // is always the same for the accessSpec. 1557 accessSpecDecl->setLexicalDeclContext(DC); 1558 DC->addDeclInternal(accessSpecDecl); 1559 1560 return accessSpecDecl; 1561 } 1562 1563 Decl *ASTNodeImporter::VisitStaticAssertDecl(StaticAssertDecl *D) { 1564 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 1565 if (!DC) 1566 return nullptr; 1567 1568 DeclContext *LexicalDC = DC; 1569 1570 // Import the location of this declaration. 1571 SourceLocation Loc = Importer.Import(D->getLocation()); 1572 1573 Expr *AssertExpr = Importer.Import(D->getAssertExpr()); 1574 if (!AssertExpr) 1575 return nullptr; 1576 1577 StringLiteral *FromMsg = D->getMessage(); 1578 auto *ToMsg = cast_or_null<StringLiteral>(Importer.Import(FromMsg)); 1579 if (!ToMsg && FromMsg) 1580 return nullptr; 1581 1582 StaticAssertDecl *ToD = StaticAssertDecl::Create( 1583 Importer.getToContext(), DC, Loc, AssertExpr, ToMsg, 1584 Importer.Import(D->getRParenLoc()), D->isFailed()); 1585 1586 ToD->setLexicalDeclContext(LexicalDC); 1587 LexicalDC->addDeclInternal(ToD); 1588 Importer.Imported(D, ToD); 1589 return ToD; 1590 } 1591 1592 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 1593 // Import the major distinguishing characteristics of this namespace. 1594 DeclContext *DC, *LexicalDC; 1595 DeclarationName Name; 1596 SourceLocation Loc; 1597 NamedDecl *ToD; 1598 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1599 return nullptr; 1600 if (ToD) 1601 return ToD; 1602 1603 NamespaceDecl *MergeWithNamespace = nullptr; 1604 if (!Name) { 1605 // This is an anonymous namespace. Adopt an existing anonymous 1606 // namespace if we can. 1607 // FIXME: Not testable. 1608 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 1609 MergeWithNamespace = TU->getAnonymousNamespace(); 1610 else 1611 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 1612 } else { 1613 SmallVector<NamedDecl *, 4> ConflictingDecls; 1614 SmallVector<NamedDecl *, 2> FoundDecls; 1615 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1616 for (auto *FoundDecl : FoundDecls) { 1617 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Namespace)) 1618 continue; 1619 1620 if (auto *FoundNS = dyn_cast<NamespaceDecl>(FoundDecl)) { 1621 MergeWithNamespace = FoundNS; 1622 ConflictingDecls.clear(); 1623 break; 1624 } 1625 1626 ConflictingDecls.push_back(FoundDecl); 1627 } 1628 1629 if (!ConflictingDecls.empty()) { 1630 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace, 1631 ConflictingDecls.data(), 1632 ConflictingDecls.size()); 1633 } 1634 } 1635 1636 // Create the "to" namespace, if needed. 1637 NamespaceDecl *ToNamespace = MergeWithNamespace; 1638 if (!ToNamespace) { 1639 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC, 1640 D->isInline(), 1641 Importer.Import(D->getLocStart()), 1642 Loc, Name.getAsIdentifierInfo(), 1643 /*PrevDecl=*/nullptr); 1644 ToNamespace->setLexicalDeclContext(LexicalDC); 1645 LexicalDC->addDeclInternal(ToNamespace); 1646 1647 // If this is an anonymous namespace, register it as the anonymous 1648 // namespace within its context. 1649 if (!Name) { 1650 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC)) 1651 TU->setAnonymousNamespace(ToNamespace); 1652 else 1653 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 1654 } 1655 } 1656 Importer.Imported(D, ToNamespace); 1657 1658 ImportDeclContext(D); 1659 1660 return ToNamespace; 1661 } 1662 1663 Decl *ASTNodeImporter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 1664 // Import the major distinguishing characteristics of this namespace. 1665 DeclContext *DC, *LexicalDC; 1666 DeclarationName Name; 1667 SourceLocation Loc; 1668 NamedDecl *LookupD; 1669 if (ImportDeclParts(D, DC, LexicalDC, Name, LookupD, Loc)) 1670 return nullptr; 1671 if (LookupD) 1672 return LookupD; 1673 1674 // NOTE: No conflict resolution is done for namespace aliases now. 1675 1676 auto *TargetDecl = cast_or_null<NamespaceDecl>( 1677 Importer.Import(D->getNamespace())); 1678 if (!TargetDecl) 1679 return nullptr; 1680 1681 IdentifierInfo *ToII = Importer.Import(D->getIdentifier()); 1682 if (!ToII) 1683 return nullptr; 1684 1685 NestedNameSpecifierLoc ToQLoc = Importer.Import(D->getQualifierLoc()); 1686 if (D->getQualifierLoc() && !ToQLoc) 1687 return nullptr; 1688 1689 NamespaceAliasDecl *ToD = NamespaceAliasDecl::Create( 1690 Importer.getToContext(), DC, Importer.Import(D->getNamespaceLoc()), 1691 Importer.Import(D->getAliasLoc()), ToII, ToQLoc, 1692 Importer.Import(D->getTargetNameLoc()), TargetDecl); 1693 1694 ToD->setLexicalDeclContext(LexicalDC); 1695 Importer.Imported(D, ToD); 1696 LexicalDC->addDeclInternal(ToD); 1697 1698 return ToD; 1699 } 1700 1701 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 1702 // Import the major distinguishing characteristics of this typedef. 1703 DeclContext *DC, *LexicalDC; 1704 DeclarationName Name; 1705 SourceLocation Loc; 1706 NamedDecl *ToD; 1707 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1708 return nullptr; 1709 if (ToD) 1710 return ToD; 1711 1712 // If this typedef is not in block scope, determine whether we've 1713 // seen a typedef with the same name (that we can merge with) or any 1714 // other entity by that name (which name lookup could conflict with). 1715 if (!DC->isFunctionOrMethod()) { 1716 SmallVector<NamedDecl *, 4> ConflictingDecls; 1717 unsigned IDNS = Decl::IDNS_Ordinary; 1718 SmallVector<NamedDecl *, 2> FoundDecls; 1719 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1720 for (auto *FoundDecl : FoundDecls) { 1721 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 1722 continue; 1723 if (auto *FoundTypedef = dyn_cast<TypedefNameDecl>(FoundDecl)) { 1724 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(), 1725 FoundTypedef->getUnderlyingType())) 1726 return Importer.Imported(D, FoundTypedef); 1727 } 1728 1729 ConflictingDecls.push_back(FoundDecl); 1730 } 1731 1732 if (!ConflictingDecls.empty()) { 1733 Name = Importer.HandleNameConflict(Name, DC, IDNS, 1734 ConflictingDecls.data(), 1735 ConflictingDecls.size()); 1736 if (!Name) 1737 return nullptr; 1738 } 1739 } 1740 1741 // Import the underlying type of this typedef; 1742 QualType T = Importer.Import(D->getUnderlyingType()); 1743 if (T.isNull()) 1744 return nullptr; 1745 1746 // Some nodes (like anonymous tags referred by typedefs) are allowed to 1747 // import their enclosing typedef directly. Check if this is the case. 1748 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D)) 1749 return AlreadyImported; 1750 1751 // Create the new typedef node. 1752 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 1753 SourceLocation StartL = Importer.Import(D->getLocStart()); 1754 TypedefNameDecl *ToTypedef; 1755 if (IsAlias) 1756 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC, StartL, Loc, 1757 Name.getAsIdentifierInfo(), TInfo); 1758 else 1759 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC, 1760 StartL, Loc, 1761 Name.getAsIdentifierInfo(), 1762 TInfo); 1763 1764 ToTypedef->setAccess(D->getAccess()); 1765 ToTypedef->setLexicalDeclContext(LexicalDC); 1766 Importer.Imported(D, ToTypedef); 1767 1768 // Templated declarations should not appear in DeclContext. 1769 TypeAliasDecl *FromAlias = IsAlias ? cast<TypeAliasDecl>(D) : nullptr; 1770 if (!FromAlias || !FromAlias->getDescribedAliasTemplate()) 1771 LexicalDC->addDeclInternal(ToTypedef); 1772 1773 return ToTypedef; 1774 } 1775 1776 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 1777 return VisitTypedefNameDecl(D, /*IsAlias=*/false); 1778 } 1779 1780 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 1781 return VisitTypedefNameDecl(D, /*IsAlias=*/true); 1782 } 1783 1784 Decl *ASTNodeImporter::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) { 1785 // Import the major distinguishing characteristics of this typedef. 1786 DeclContext *DC, *LexicalDC; 1787 DeclarationName Name; 1788 SourceLocation Loc; 1789 NamedDecl *FoundD; 1790 if (ImportDeclParts(D, DC, LexicalDC, Name, FoundD, Loc)) 1791 return nullptr; 1792 if (FoundD) 1793 return FoundD; 1794 1795 // If this typedef is not in block scope, determine whether we've 1796 // seen a typedef with the same name (that we can merge with) or any 1797 // other entity by that name (which name lookup could conflict with). 1798 if (!DC->isFunctionOrMethod()) { 1799 SmallVector<NamedDecl *, 4> ConflictingDecls; 1800 unsigned IDNS = Decl::IDNS_Ordinary; 1801 SmallVector<NamedDecl *, 2> FoundDecls; 1802 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 1803 for (auto *FoundDecl : FoundDecls) { 1804 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 1805 continue; 1806 if (auto *FoundAlias = dyn_cast<TypeAliasTemplateDecl>(FoundDecl)) 1807 return Importer.Imported(D, FoundAlias); 1808 ConflictingDecls.push_back(FoundDecl); 1809 } 1810 1811 if (!ConflictingDecls.empty()) { 1812 Name = Importer.HandleNameConflict(Name, DC, IDNS, 1813 ConflictingDecls.data(), 1814 ConflictingDecls.size()); 1815 if (!Name) 1816 return nullptr; 1817 } 1818 } 1819 1820 TemplateParameterList *Params = ImportTemplateParameterList( 1821 D->getTemplateParameters()); 1822 if (!Params) 1823 return nullptr; 1824 1825 auto *TemplDecl = cast_or_null<TypeAliasDecl>( 1826 Importer.Import(D->getTemplatedDecl())); 1827 if (!TemplDecl) 1828 return nullptr; 1829 1830 TypeAliasTemplateDecl *ToAlias = TypeAliasTemplateDecl::Create( 1831 Importer.getToContext(), DC, Loc, Name, Params, TemplDecl); 1832 1833 TemplDecl->setDescribedAliasTemplate(ToAlias); 1834 1835 ToAlias->setAccess(D->getAccess()); 1836 ToAlias->setLexicalDeclContext(LexicalDC); 1837 Importer.Imported(D, ToAlias); 1838 LexicalDC->addDeclInternal(ToAlias); 1839 return ToAlias; 1840 } 1841 1842 Decl *ASTNodeImporter::VisitLabelDecl(LabelDecl *D) { 1843 // Import the major distinguishing characteristics of this label. 1844 DeclContext *DC, *LexicalDC; 1845 DeclarationName Name; 1846 SourceLocation Loc; 1847 NamedDecl *ToD; 1848 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1849 return nullptr; 1850 if (ToD) 1851 return ToD; 1852 1853 assert(LexicalDC->isFunctionOrMethod()); 1854 1855 LabelDecl *ToLabel = D->isGnuLocal() 1856 ? LabelDecl::Create(Importer.getToContext(), 1857 DC, Importer.Import(D->getLocation()), 1858 Name.getAsIdentifierInfo(), 1859 Importer.Import(D->getLocStart())) 1860 : LabelDecl::Create(Importer.getToContext(), 1861 DC, Importer.Import(D->getLocation()), 1862 Name.getAsIdentifierInfo()); 1863 Importer.Imported(D, ToLabel); 1864 1865 auto *Label = cast_or_null<LabelStmt>(Importer.Import(D->getStmt())); 1866 if (!Label) 1867 return nullptr; 1868 1869 ToLabel->setStmt(Label); 1870 ToLabel->setLexicalDeclContext(LexicalDC); 1871 LexicalDC->addDeclInternal(ToLabel); 1872 return ToLabel; 1873 } 1874 1875 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 1876 // Import the major distinguishing characteristics of this enum. 1877 DeclContext *DC, *LexicalDC; 1878 DeclarationName Name; 1879 SourceLocation Loc; 1880 NamedDecl *ToD; 1881 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1882 return nullptr; 1883 if (ToD) 1884 return ToD; 1885 1886 // Figure out what enum name we're looking for. 1887 unsigned IDNS = Decl::IDNS_Tag; 1888 DeclarationName SearchName = Name; 1889 if (!SearchName && D->getTypedefNameForAnonDecl()) { 1890 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1891 IDNS = Decl::IDNS_Ordinary; 1892 } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1893 IDNS |= Decl::IDNS_Ordinary; 1894 1895 // We may already have an enum of the same name; try to find and match it. 1896 if (!DC->isFunctionOrMethod() && SearchName) { 1897 SmallVector<NamedDecl *, 4> ConflictingDecls; 1898 SmallVector<NamedDecl *, 2> FoundDecls; 1899 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1900 for (auto *FoundDecl : FoundDecls) { 1901 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 1902 continue; 1903 1904 Decl *Found = FoundDecl; 1905 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 1906 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 1907 Found = Tag->getDecl(); 1908 } 1909 1910 if (auto *FoundEnum = dyn_cast<EnumDecl>(Found)) { 1911 if (IsStructuralMatch(D, FoundEnum)) 1912 return Importer.Imported(D, FoundEnum); 1913 } 1914 1915 ConflictingDecls.push_back(FoundDecl); 1916 } 1917 1918 if (!ConflictingDecls.empty()) { 1919 Name = Importer.HandleNameConflict(Name, DC, IDNS, 1920 ConflictingDecls.data(), 1921 ConflictingDecls.size()); 1922 } 1923 } 1924 1925 // Create the enum declaration. 1926 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC, 1927 Importer.Import(D->getLocStart()), 1928 Loc, Name.getAsIdentifierInfo(), nullptr, 1929 D->isScoped(), D->isScopedUsingClassTag(), 1930 D->isFixed()); 1931 // Import the qualifier, if any. 1932 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 1933 D2->setAccess(D->getAccess()); 1934 D2->setLexicalDeclContext(LexicalDC); 1935 Importer.Imported(D, D2); 1936 LexicalDC->addDeclInternal(D2); 1937 1938 // Import the integer type. 1939 QualType ToIntegerType = Importer.Import(D->getIntegerType()); 1940 if (ToIntegerType.isNull()) 1941 return nullptr; 1942 D2->setIntegerType(ToIntegerType); 1943 1944 // Import the definition 1945 if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 1946 return nullptr; 1947 1948 return D2; 1949 } 1950 1951 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 1952 // If this record has a definition in the translation unit we're coming from, 1953 // but this particular declaration is not that definition, import the 1954 // definition and map to that. 1955 TagDecl *Definition = D->getDefinition(); 1956 if (Definition && Definition != D) { 1957 Decl *ImportedDef = Importer.Import(Definition); 1958 if (!ImportedDef) 1959 return nullptr; 1960 1961 return Importer.Imported(D, ImportedDef); 1962 } 1963 1964 // Import the major distinguishing characteristics of this record. 1965 DeclContext *DC, *LexicalDC; 1966 DeclarationName Name; 1967 SourceLocation Loc; 1968 NamedDecl *ToD; 1969 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 1970 return nullptr; 1971 if (ToD) 1972 return ToD; 1973 1974 // Figure out what structure name we're looking for. 1975 unsigned IDNS = Decl::IDNS_Tag; 1976 DeclarationName SearchName = Name; 1977 if (!SearchName && D->getTypedefNameForAnonDecl()) { 1978 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 1979 IDNS = Decl::IDNS_Ordinary; 1980 } else if (Importer.getToContext().getLangOpts().CPlusPlus) 1981 IDNS |= Decl::IDNS_Ordinary; 1982 1983 // We may already have a record of the same name; try to find and match it. 1984 RecordDecl *AdoptDecl = nullptr; 1985 RecordDecl *PrevDecl = nullptr; 1986 if (!DC->isFunctionOrMethod()) { 1987 SmallVector<NamedDecl *, 4> ConflictingDecls; 1988 SmallVector<NamedDecl *, 2> FoundDecls; 1989 DC->getRedeclContext()->localUncachedLookup(SearchName, FoundDecls); 1990 1991 if (!FoundDecls.empty()) { 1992 // We're going to have to compare D against potentially conflicting Decls, so complete it. 1993 if (D->hasExternalLexicalStorage() && !D->isCompleteDefinition()) 1994 D->getASTContext().getExternalSource()->CompleteType(D); 1995 } 1996 1997 for (auto *FoundDecl : FoundDecls) { 1998 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 1999 continue; 2000 2001 Decl *Found = FoundDecl; 2002 if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 2003 if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2004 Found = Tag->getDecl(); 2005 } 2006 2007 if (auto *FoundRecord = dyn_cast<RecordDecl>(Found)) { 2008 if (!SearchName) { 2009 // If both unnamed structs/unions are in a record context, make sure 2010 // they occur in the same location in the context records. 2011 if (Optional<unsigned> Index1 = 2012 StructuralEquivalenceContext::findUntaggedStructOrUnionIndex( 2013 D)) { 2014 if (Optional<unsigned> Index2 = StructuralEquivalenceContext:: 2015 findUntaggedStructOrUnionIndex(FoundRecord)) { 2016 if (*Index1 != *Index2) 2017 continue; 2018 } 2019 } 2020 } 2021 2022 PrevDecl = FoundRecord; 2023 2024 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) { 2025 if ((SearchName && !D->isCompleteDefinition()) 2026 || (D->isCompleteDefinition() && 2027 D->isAnonymousStructOrUnion() 2028 == FoundDef->isAnonymousStructOrUnion() && 2029 IsStructuralMatch(D, FoundDef))) { 2030 // The record types structurally match, or the "from" translation 2031 // unit only had a forward declaration anyway; call it the same 2032 // function. 2033 // FIXME: For C++, we should also merge methods here. 2034 return Importer.Imported(D, FoundDef); 2035 } 2036 } else if (!D->isCompleteDefinition()) { 2037 // We have a forward declaration of this type, so adopt that forward 2038 // declaration rather than building a new one. 2039 2040 // If one or both can be completed from external storage then try one 2041 // last time to complete and compare them before doing this. 2042 2043 if (FoundRecord->hasExternalLexicalStorage() && 2044 !FoundRecord->isCompleteDefinition()) 2045 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord); 2046 if (D->hasExternalLexicalStorage()) 2047 D->getASTContext().getExternalSource()->CompleteType(D); 2048 2049 if (FoundRecord->isCompleteDefinition() && 2050 D->isCompleteDefinition() && 2051 !IsStructuralMatch(D, FoundRecord)) 2052 continue; 2053 2054 AdoptDecl = FoundRecord; 2055 continue; 2056 } else if (!SearchName) { 2057 continue; 2058 } 2059 } 2060 2061 ConflictingDecls.push_back(FoundDecl); 2062 } 2063 2064 if (!ConflictingDecls.empty() && SearchName) { 2065 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2066 ConflictingDecls.data(), 2067 ConflictingDecls.size()); 2068 } 2069 } 2070 2071 // Create the record declaration. 2072 RecordDecl *D2 = AdoptDecl; 2073 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 2074 if (!D2) { 2075 CXXRecordDecl *D2CXX = nullptr; 2076 if (auto *DCXX = dyn_cast<CXXRecordDecl>(D)) { 2077 if (DCXX->isLambda()) { 2078 TypeSourceInfo *TInfo = Importer.Import(DCXX->getLambdaTypeInfo()); 2079 D2CXX = CXXRecordDecl::CreateLambda(Importer.getToContext(), 2080 DC, TInfo, Loc, 2081 DCXX->isDependentLambda(), 2082 DCXX->isGenericLambda(), 2083 DCXX->getLambdaCaptureDefault()); 2084 Decl *CDecl = Importer.Import(DCXX->getLambdaContextDecl()); 2085 if (DCXX->getLambdaContextDecl() && !CDecl) 2086 return nullptr; 2087 D2CXX->setLambdaMangling(DCXX->getLambdaManglingNumber(), CDecl); 2088 } else if (DCXX->isInjectedClassName()) { 2089 // We have to be careful to do a similar dance to the one in 2090 // Sema::ActOnStartCXXMemberDeclarations 2091 CXXRecordDecl *const PrevDecl = nullptr; 2092 const bool DelayTypeCreation = true; 2093 D2CXX = CXXRecordDecl::Create( 2094 Importer.getToContext(), D->getTagKind(), DC, StartLoc, Loc, 2095 Name.getAsIdentifierInfo(), PrevDecl, DelayTypeCreation); 2096 Importer.getToContext().getTypeDeclType( 2097 D2CXX, dyn_cast<CXXRecordDecl>(DC)); 2098 } else { 2099 D2CXX = CXXRecordDecl::Create(Importer.getToContext(), 2100 D->getTagKind(), 2101 DC, StartLoc, Loc, 2102 Name.getAsIdentifierInfo()); 2103 } 2104 D2 = D2CXX; 2105 D2->setAccess(D->getAccess()); 2106 D2->setLexicalDeclContext(LexicalDC); 2107 if (!DCXX->getDescribedClassTemplate()) 2108 LexicalDC->addDeclInternal(D2); 2109 2110 Importer.Imported(D, D2); 2111 2112 if (ClassTemplateDecl *FromDescribed = 2113 DCXX->getDescribedClassTemplate()) { 2114 auto *ToDescribed = cast_or_null<ClassTemplateDecl>( 2115 Importer.Import(FromDescribed)); 2116 if (!ToDescribed) 2117 return nullptr; 2118 D2CXX->setDescribedClassTemplate(ToDescribed); 2119 } else if (MemberSpecializationInfo *MemberInfo = 2120 DCXX->getMemberSpecializationInfo()) { 2121 TemplateSpecializationKind SK = 2122 MemberInfo->getTemplateSpecializationKind(); 2123 CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass(); 2124 auto *ToInst = 2125 cast_or_null<CXXRecordDecl>(Importer.Import(FromInst)); 2126 if (FromInst && !ToInst) 2127 return nullptr; 2128 D2CXX->setInstantiationOfMemberClass(ToInst, SK); 2129 D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation( 2130 Importer.Import(MemberInfo->getPointOfInstantiation())); 2131 } 2132 } else { 2133 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(), 2134 DC, StartLoc, Loc, Name.getAsIdentifierInfo()); 2135 D2->setLexicalDeclContext(LexicalDC); 2136 LexicalDC->addDeclInternal(D2); 2137 } 2138 2139 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2140 if (D->isAnonymousStructOrUnion()) 2141 D2->setAnonymousStructOrUnion(true); 2142 if (PrevDecl) { 2143 // FIXME: do this for all Redeclarables, not just RecordDecls. 2144 D2->setPreviousDecl(PrevDecl); 2145 } 2146 } 2147 2148 Importer.Imported(D, D2); 2149 2150 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default)) 2151 return nullptr; 2152 2153 return D2; 2154 } 2155 2156 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 2157 // Import the major distinguishing characteristics of this enumerator. 2158 DeclContext *DC, *LexicalDC; 2159 DeclarationName Name; 2160 SourceLocation Loc; 2161 NamedDecl *ToD; 2162 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2163 return nullptr; 2164 if (ToD) 2165 return ToD; 2166 2167 QualType T = Importer.Import(D->getType()); 2168 if (T.isNull()) 2169 return nullptr; 2170 2171 // Determine whether there are any other declarations with the same name and 2172 // in the same context. 2173 if (!LexicalDC->isFunctionOrMethod()) { 2174 SmallVector<NamedDecl *, 4> ConflictingDecls; 2175 unsigned IDNS = Decl::IDNS_Ordinary; 2176 SmallVector<NamedDecl *, 2> FoundDecls; 2177 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2178 for (auto *FoundDecl : FoundDecls) { 2179 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2180 continue; 2181 2182 if (auto *FoundEnumConstant = dyn_cast<EnumConstantDecl>(FoundDecl)) { 2183 if (IsStructuralMatch(D, FoundEnumConstant)) 2184 return Importer.Imported(D, FoundEnumConstant); 2185 } 2186 2187 ConflictingDecls.push_back(FoundDecl); 2188 } 2189 2190 if (!ConflictingDecls.empty()) { 2191 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2192 ConflictingDecls.data(), 2193 ConflictingDecls.size()); 2194 if (!Name) 2195 return nullptr; 2196 } 2197 } 2198 2199 Expr *Init = Importer.Import(D->getInitExpr()); 2200 if (D->getInitExpr() && !Init) 2201 return nullptr; 2202 2203 EnumConstantDecl *ToEnumerator 2204 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc, 2205 Name.getAsIdentifierInfo(), T, 2206 Init, D->getInitVal()); 2207 ToEnumerator->setAccess(D->getAccess()); 2208 ToEnumerator->setLexicalDeclContext(LexicalDC); 2209 Importer.Imported(D, ToEnumerator); 2210 LexicalDC->addDeclInternal(ToEnumerator); 2211 return ToEnumerator; 2212 } 2213 2214 bool ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD, 2215 FunctionDecl *ToFD) { 2216 switch (FromFD->getTemplatedKind()) { 2217 case FunctionDecl::TK_NonTemplate: 2218 case FunctionDecl::TK_FunctionTemplate: 2219 return false; 2220 2221 case FunctionDecl::TK_MemberSpecialization: { 2222 auto *InstFD = cast_or_null<FunctionDecl>( 2223 Importer.Import(FromFD->getInstantiatedFromMemberFunction())); 2224 if (!InstFD) 2225 return true; 2226 2227 TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind(); 2228 SourceLocation POI = Importer.Import( 2229 FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()); 2230 ToFD->setInstantiationOfMemberFunction(InstFD, TSK); 2231 ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(POI); 2232 return false; 2233 } 2234 2235 case FunctionDecl::TK_FunctionTemplateSpecialization: { 2236 auto *FTSInfo = FromFD->getTemplateSpecializationInfo(); 2237 auto *Template = cast_or_null<FunctionTemplateDecl>( 2238 Importer.Import(FTSInfo->getTemplate())); 2239 if (!Template) 2240 return true; 2241 TemplateSpecializationKind TSK = FTSInfo->getTemplateSpecializationKind(); 2242 2243 // Import template arguments. 2244 auto TemplArgs = FTSInfo->TemplateArguments->asArray(); 2245 SmallVector<TemplateArgument, 8> ToTemplArgs; 2246 if (ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(), 2247 ToTemplArgs)) 2248 return true; 2249 2250 TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy( 2251 Importer.getToContext(), ToTemplArgs); 2252 2253 TemplateArgumentListInfo ToTAInfo; 2254 const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten; 2255 if (FromTAArgsAsWritten) 2256 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo)) 2257 return true; 2258 2259 SourceLocation POI = Importer.Import(FTSInfo->getPointOfInstantiation()); 2260 2261 ToFD->setFunctionTemplateSpecialization( 2262 Template, ToTAList, /* InsertPos= */ nullptr, 2263 TSK, FromTAArgsAsWritten ? &ToTAInfo : nullptr, POI); 2264 return false; 2265 } 2266 2267 case FunctionDecl::TK_DependentFunctionTemplateSpecialization: { 2268 auto *FromInfo = FromFD->getDependentSpecializationInfo(); 2269 UnresolvedSet<8> TemplDecls; 2270 unsigned NumTemplates = FromInfo->getNumTemplates(); 2271 for (unsigned I = 0; I < NumTemplates; I++) { 2272 if (auto *ToFTD = cast_or_null<FunctionTemplateDecl>( 2273 Importer.Import(FromInfo->getTemplate(I)))) 2274 TemplDecls.addDecl(ToFTD); 2275 else 2276 return true; 2277 } 2278 2279 // Import TemplateArgumentListInfo. 2280 TemplateArgumentListInfo ToTAInfo; 2281 if (ImportTemplateArgumentListInfo( 2282 FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(), 2283 llvm::makeArrayRef(FromInfo->getTemplateArgs(), 2284 FromInfo->getNumTemplateArgs()), 2285 ToTAInfo)) 2286 return true; 2287 2288 ToFD->setDependentTemplateSpecialization(Importer.getToContext(), 2289 TemplDecls, ToTAInfo); 2290 return false; 2291 } 2292 } 2293 llvm_unreachable("All cases should be covered!"); 2294 } 2295 2296 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 2297 // Import the major distinguishing characteristics of this function. 2298 DeclContext *DC, *LexicalDC; 2299 DeclarationName Name; 2300 SourceLocation Loc; 2301 NamedDecl *ToD; 2302 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2303 return nullptr; 2304 if (ToD) 2305 return ToD; 2306 2307 const FunctionDecl *FoundWithoutBody = nullptr; 2308 2309 // Try to find a function in our own ("to") context with the same name, same 2310 // type, and in the same context as the function we're importing. 2311 if (!LexicalDC->isFunctionOrMethod()) { 2312 SmallVector<NamedDecl *, 4> ConflictingDecls; 2313 unsigned IDNS = Decl::IDNS_Ordinary; 2314 SmallVector<NamedDecl *, 2> FoundDecls; 2315 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2316 for (auto *FoundDecl : FoundDecls) { 2317 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2318 continue; 2319 2320 if (auto *FoundFunction = dyn_cast<FunctionDecl>(FoundDecl)) { 2321 if (FoundFunction->hasExternalFormalLinkage() && 2322 D->hasExternalFormalLinkage()) { 2323 if (Importer.IsStructurallyEquivalent(D->getType(), 2324 FoundFunction->getType())) { 2325 // FIXME: Actually try to merge the body and other attributes. 2326 const FunctionDecl *FromBodyDecl = nullptr; 2327 D->hasBody(FromBodyDecl); 2328 if (D == FromBodyDecl && !FoundFunction->hasBody()) { 2329 // This function is needed to merge completely. 2330 FoundWithoutBody = FoundFunction; 2331 break; 2332 } 2333 return Importer.Imported(D, FoundFunction); 2334 } 2335 2336 // FIXME: Check for overloading more carefully, e.g., by boosting 2337 // Sema::IsOverload out to the AST library. 2338 2339 // Function overloading is okay in C++. 2340 if (Importer.getToContext().getLangOpts().CPlusPlus) 2341 continue; 2342 2343 // Complain about inconsistent function types. 2344 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent) 2345 << Name << D->getType() << FoundFunction->getType(); 2346 Importer.ToDiag(FoundFunction->getLocation(), 2347 diag::note_odr_value_here) 2348 << FoundFunction->getType(); 2349 } 2350 } 2351 2352 ConflictingDecls.push_back(FoundDecl); 2353 } 2354 2355 if (!ConflictingDecls.empty()) { 2356 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2357 ConflictingDecls.data(), 2358 ConflictingDecls.size()); 2359 if (!Name) 2360 return nullptr; 2361 } 2362 } 2363 2364 DeclarationNameInfo NameInfo(Name, Loc); 2365 // Import additional name location/type info. 2366 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 2367 2368 QualType FromTy = D->getType(); 2369 bool usedDifferentExceptionSpec = false; 2370 2371 if (const auto *FromFPT = D->getType()->getAs<FunctionProtoType>()) { 2372 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 2373 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 2374 // FunctionDecl that we are importing the FunctionProtoType for. 2375 // To avoid an infinite recursion when importing, create the FunctionDecl 2376 // with a simplified function type and update it afterwards. 2377 if (FromEPI.ExceptionSpec.SourceDecl || 2378 FromEPI.ExceptionSpec.SourceTemplate || 2379 FromEPI.ExceptionSpec.NoexceptExpr) { 2380 FunctionProtoType::ExtProtoInfo DefaultEPI; 2381 FromTy = Importer.getFromContext().getFunctionType( 2382 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI); 2383 usedDifferentExceptionSpec = true; 2384 } 2385 } 2386 2387 // Import the type. 2388 QualType T = Importer.Import(FromTy); 2389 if (T.isNull()) 2390 return nullptr; 2391 2392 // Import the function parameters. 2393 SmallVector<ParmVarDecl *, 8> Parameters; 2394 for (auto P : D->parameters()) { 2395 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P)); 2396 if (!ToP) 2397 return nullptr; 2398 2399 Parameters.push_back(ToP); 2400 } 2401 2402 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2403 if (D->getTypeSourceInfo() && !TInfo) 2404 return nullptr; 2405 2406 // Create the imported function. 2407 FunctionDecl *ToFunction = nullptr; 2408 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart()); 2409 if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 2410 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(), 2411 cast<CXXRecordDecl>(DC), 2412 InnerLocStart, 2413 NameInfo, T, TInfo, 2414 FromConstructor->isExplicit(), 2415 D->isInlineSpecified(), 2416 D->isImplicit(), 2417 D->isConstexpr()); 2418 if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) { 2419 SmallVector<CXXCtorInitializer *, 4> CtorInitializers; 2420 for (auto *I : FromConstructor->inits()) { 2421 auto *ToI = cast_or_null<CXXCtorInitializer>(Importer.Import(I)); 2422 if (!ToI && I) 2423 return nullptr; 2424 CtorInitializers.push_back(ToI); 2425 } 2426 auto **Memory = 2427 new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers]; 2428 std::copy(CtorInitializers.begin(), CtorInitializers.end(), Memory); 2429 auto *ToCtor = cast<CXXConstructorDecl>(ToFunction); 2430 ToCtor->setCtorInitializers(Memory); 2431 ToCtor->setNumCtorInitializers(NumInitializers); 2432 } 2433 } else if (isa<CXXDestructorDecl>(D)) { 2434 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(), 2435 cast<CXXRecordDecl>(DC), 2436 InnerLocStart, 2437 NameInfo, T, TInfo, 2438 D->isInlineSpecified(), 2439 D->isImplicit()); 2440 } else if (auto *FromConversion = dyn_cast<CXXConversionDecl>(D)) { 2441 ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 2442 cast<CXXRecordDecl>(DC), 2443 InnerLocStart, 2444 NameInfo, T, TInfo, 2445 D->isInlineSpecified(), 2446 FromConversion->isExplicit(), 2447 D->isConstexpr(), 2448 Importer.Import(D->getLocEnd())); 2449 } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) { 2450 ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 2451 cast<CXXRecordDecl>(DC), 2452 InnerLocStart, 2453 NameInfo, T, TInfo, 2454 Method->getStorageClass(), 2455 Method->isInlineSpecified(), 2456 D->isConstexpr(), 2457 Importer.Import(D->getLocEnd())); 2458 } else { 2459 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC, 2460 InnerLocStart, 2461 NameInfo, T, TInfo, D->getStorageClass(), 2462 D->isInlineSpecified(), 2463 D->hasWrittenPrototype(), 2464 D->isConstexpr()); 2465 } 2466 2467 // Import the qualifier, if any. 2468 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2469 ToFunction->setAccess(D->getAccess()); 2470 ToFunction->setLexicalDeclContext(LexicalDC); 2471 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 2472 ToFunction->setTrivial(D->isTrivial()); 2473 ToFunction->setPure(D->isPure()); 2474 Importer.Imported(D, ToFunction); 2475 2476 // Set the parameters. 2477 for (auto *Param : Parameters) { 2478 Param->setOwningFunction(ToFunction); 2479 ToFunction->addDeclInternal(Param); 2480 } 2481 ToFunction->setParams(Parameters); 2482 2483 if (FoundWithoutBody) { 2484 auto *Recent = const_cast<FunctionDecl *>( 2485 FoundWithoutBody->getMostRecentDecl()); 2486 ToFunction->setPreviousDecl(Recent); 2487 } 2488 2489 // We need to complete creation of FunctionProtoTypeLoc manually with setting 2490 // params it refers to. 2491 if (TInfo) { 2492 if (auto ProtoLoc = 2493 TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) { 2494 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) 2495 ProtoLoc.setParam(I, Parameters[I]); 2496 } 2497 } 2498 2499 if (usedDifferentExceptionSpec) { 2500 // Update FunctionProtoType::ExtProtoInfo. 2501 QualType T = Importer.Import(D->getType()); 2502 if (T.isNull()) 2503 return nullptr; 2504 ToFunction->setType(T); 2505 } 2506 2507 // Import the body, if any. 2508 if (Stmt *FromBody = D->getBody()) { 2509 if (Stmt *ToBody = Importer.Import(FromBody)) { 2510 ToFunction->setBody(ToBody); 2511 } 2512 } 2513 2514 // FIXME: Other bits to merge? 2515 2516 // If it is a template, import all related things. 2517 if (ImportTemplateInformation(D, ToFunction)) 2518 return nullptr; 2519 2520 // Add this function to the lexical context. 2521 // NOTE: If the function is templated declaration, it should be not added into 2522 // LexicalDC. But described template is imported during import of 2523 // FunctionTemplateDecl (it happens later). So, we use source declaration 2524 // to determine if we should add the result function. 2525 if (!D->getDescribedFunctionTemplate()) 2526 LexicalDC->addDeclInternal(ToFunction); 2527 2528 if (auto *FromCXXMethod = dyn_cast<CXXMethodDecl>(D)) 2529 ImportOverrides(cast<CXXMethodDecl>(ToFunction), FromCXXMethod); 2530 2531 return ToFunction; 2532 } 2533 2534 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 2535 return VisitFunctionDecl(D); 2536 } 2537 2538 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 2539 return VisitCXXMethodDecl(D); 2540 } 2541 2542 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 2543 return VisitCXXMethodDecl(D); 2544 } 2545 2546 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 2547 return VisitCXXMethodDecl(D); 2548 } 2549 2550 static unsigned getFieldIndex(Decl *F) { 2551 auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 2552 if (!Owner) 2553 return 0; 2554 2555 unsigned Index = 1; 2556 for (const auto *D : Owner->noload_decls()) { 2557 if (D == F) 2558 return Index; 2559 2560 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 2561 ++Index; 2562 } 2563 2564 return Index; 2565 } 2566 2567 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 2568 // Import the major distinguishing characteristics of a variable. 2569 DeclContext *DC, *LexicalDC; 2570 DeclarationName Name; 2571 SourceLocation Loc; 2572 NamedDecl *ToD; 2573 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2574 return nullptr; 2575 if (ToD) 2576 return ToD; 2577 2578 // Determine whether we've already imported this field. 2579 SmallVector<NamedDecl *, 2> FoundDecls; 2580 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2581 for (auto *FoundDecl : FoundDecls) { 2582 if (auto *FoundField = dyn_cast<FieldDecl>(FoundDecl)) { 2583 // For anonymous fields, match up by index. 2584 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2585 continue; 2586 2587 if (Importer.IsStructurallyEquivalent(D->getType(), 2588 FoundField->getType())) { 2589 Importer.Imported(D, FoundField); 2590 return FoundField; 2591 } 2592 2593 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2594 << Name << D->getType() << FoundField->getType(); 2595 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2596 << FoundField->getType(); 2597 return nullptr; 2598 } 2599 } 2600 2601 // Import the type. 2602 QualType T = Importer.Import(D->getType()); 2603 if (T.isNull()) 2604 return nullptr; 2605 2606 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2607 Expr *BitWidth = Importer.Import(D->getBitWidth()); 2608 if (!BitWidth && D->getBitWidth()) 2609 return nullptr; 2610 2611 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC, 2612 Importer.Import(D->getInnerLocStart()), 2613 Loc, Name.getAsIdentifierInfo(), 2614 T, TInfo, BitWidth, D->isMutable(), 2615 D->getInClassInitStyle()); 2616 ToField->setAccess(D->getAccess()); 2617 ToField->setLexicalDeclContext(LexicalDC); 2618 if (Expr *FromInitializer = D->getInClassInitializer()) { 2619 Expr *ToInitializer = Importer.Import(FromInitializer); 2620 if (ToInitializer) 2621 ToField->setInClassInitializer(ToInitializer); 2622 else 2623 return nullptr; 2624 } 2625 ToField->setImplicit(D->isImplicit()); 2626 Importer.Imported(D, ToField); 2627 LexicalDC->addDeclInternal(ToField); 2628 return ToField; 2629 } 2630 2631 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 2632 // Import the major distinguishing characteristics of a variable. 2633 DeclContext *DC, *LexicalDC; 2634 DeclarationName Name; 2635 SourceLocation Loc; 2636 NamedDecl *ToD; 2637 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2638 return nullptr; 2639 if (ToD) 2640 return ToD; 2641 2642 // Determine whether we've already imported this field. 2643 SmallVector<NamedDecl *, 2> FoundDecls; 2644 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2645 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2646 if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 2647 // For anonymous indirect fields, match up by index. 2648 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2649 continue; 2650 2651 if (Importer.IsStructurallyEquivalent(D->getType(), 2652 FoundField->getType(), 2653 !Name.isEmpty())) { 2654 Importer.Imported(D, FoundField); 2655 return FoundField; 2656 } 2657 2658 // If there are more anonymous fields to check, continue. 2659 if (!Name && I < N-1) 2660 continue; 2661 2662 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2663 << Name << D->getType() << FoundField->getType(); 2664 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2665 << FoundField->getType(); 2666 return nullptr; 2667 } 2668 } 2669 2670 // Import the type. 2671 QualType T = Importer.Import(D->getType()); 2672 if (T.isNull()) 2673 return nullptr; 2674 2675 auto **NamedChain = 2676 new (Importer.getToContext()) NamedDecl*[D->getChainingSize()]; 2677 2678 unsigned i = 0; 2679 for (auto *PI : D->chain()) { 2680 Decl *D = Importer.Import(PI); 2681 if (!D) 2682 return nullptr; 2683 NamedChain[i++] = cast<NamedDecl>(D); 2684 } 2685 2686 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create( 2687 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T, 2688 {NamedChain, D->getChainingSize()}); 2689 2690 for (const auto *A : D->attrs()) 2691 ToIndirectField->addAttr(Importer.Import(A)); 2692 2693 ToIndirectField->setAccess(D->getAccess()); 2694 ToIndirectField->setLexicalDeclContext(LexicalDC); 2695 Importer.Imported(D, ToIndirectField); 2696 LexicalDC->addDeclInternal(ToIndirectField); 2697 return ToIndirectField; 2698 } 2699 2700 Decl *ASTNodeImporter::VisitFriendDecl(FriendDecl *D) { 2701 // Import the major distinguishing characteristics of a declaration. 2702 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 2703 DeclContext *LexicalDC = D->getDeclContext() == D->getLexicalDeclContext() 2704 ? DC : Importer.ImportContext(D->getLexicalDeclContext()); 2705 if (!DC || !LexicalDC) 2706 return nullptr; 2707 2708 // Determine whether we've already imported this decl. 2709 // FriendDecl is not a NamedDecl so we cannot use localUncachedLookup. 2710 auto *RD = cast<CXXRecordDecl>(DC); 2711 FriendDecl *ImportedFriend = RD->getFirstFriend(); 2712 StructuralEquivalenceContext Context( 2713 Importer.getFromContext(), Importer.getToContext(), 2714 Importer.getNonEquivalentDecls(), false, false); 2715 2716 while (ImportedFriend) { 2717 if (D->getFriendDecl() && ImportedFriend->getFriendDecl()) { 2718 if (Context.IsStructurallyEquivalent(D->getFriendDecl(), 2719 ImportedFriend->getFriendDecl())) 2720 return Importer.Imported(D, ImportedFriend); 2721 2722 } else if (D->getFriendType() && ImportedFriend->getFriendType()) { 2723 if (Importer.IsStructurallyEquivalent( 2724 D->getFriendType()->getType(), 2725 ImportedFriend->getFriendType()->getType(), true)) 2726 return Importer.Imported(D, ImportedFriend); 2727 } 2728 ImportedFriend = ImportedFriend->getNextFriend(); 2729 } 2730 2731 // Not found. Create it. 2732 FriendDecl::FriendUnion ToFU; 2733 if (NamedDecl *FriendD = D->getFriendDecl()) { 2734 auto *ToFriendD = cast_or_null<NamedDecl>(Importer.Import(FriendD)); 2735 if (ToFriendD && FriendD->getFriendObjectKind() != Decl::FOK_None && 2736 !(FriendD->isInIdentifierNamespace(Decl::IDNS_NonMemberOperator))) 2737 ToFriendD->setObjectOfFriendDecl(false); 2738 2739 ToFU = ToFriendD; 2740 } else // The friend is a type, not a decl. 2741 ToFU = Importer.Import(D->getFriendType()); 2742 if (!ToFU) 2743 return nullptr; 2744 2745 SmallVector<TemplateParameterList *, 1> ToTPLists(D->NumTPLists); 2746 auto **FromTPLists = D->getTrailingObjects<TemplateParameterList *>(); 2747 for (unsigned I = 0; I < D->NumTPLists; I++) { 2748 TemplateParameterList *List = ImportTemplateParameterList(FromTPLists[I]); 2749 if (!List) 2750 return nullptr; 2751 ToTPLists[I] = List; 2752 } 2753 2754 FriendDecl *FrD = FriendDecl::Create(Importer.getToContext(), DC, 2755 Importer.Import(D->getLocation()), 2756 ToFU, Importer.Import(D->getFriendLoc()), 2757 ToTPLists); 2758 2759 Importer.Imported(D, FrD); 2760 2761 FrD->setAccess(D->getAccess()); 2762 FrD->setLexicalDeclContext(LexicalDC); 2763 LexicalDC->addDeclInternal(FrD); 2764 return FrD; 2765 } 2766 2767 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 2768 // Import the major distinguishing characteristics of an ivar. 2769 DeclContext *DC, *LexicalDC; 2770 DeclarationName Name; 2771 SourceLocation Loc; 2772 NamedDecl *ToD; 2773 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2774 return nullptr; 2775 if (ToD) 2776 return ToD; 2777 2778 // Determine whether we've already imported this ivar 2779 SmallVector<NamedDecl *, 2> FoundDecls; 2780 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2781 for (auto *FoundDecl : FoundDecls) { 2782 if (auto *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecl)) { 2783 if (Importer.IsStructurallyEquivalent(D->getType(), 2784 FoundIvar->getType())) { 2785 Importer.Imported(D, FoundIvar); 2786 return FoundIvar; 2787 } 2788 2789 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent) 2790 << Name << D->getType() << FoundIvar->getType(); 2791 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 2792 << FoundIvar->getType(); 2793 return nullptr; 2794 } 2795 } 2796 2797 // Import the type. 2798 QualType T = Importer.Import(D->getType()); 2799 if (T.isNull()) 2800 return nullptr; 2801 2802 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2803 Expr *BitWidth = Importer.Import(D->getBitWidth()); 2804 if (!BitWidth && D->getBitWidth()) 2805 return nullptr; 2806 2807 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(), 2808 cast<ObjCContainerDecl>(DC), 2809 Importer.Import(D->getInnerLocStart()), 2810 Loc, Name.getAsIdentifierInfo(), 2811 T, TInfo, D->getAccessControl(), 2812 BitWidth, D->getSynthesize()); 2813 ToIvar->setLexicalDeclContext(LexicalDC); 2814 Importer.Imported(D, ToIvar); 2815 LexicalDC->addDeclInternal(ToIvar); 2816 return ToIvar; 2817 } 2818 2819 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) { 2820 // Import the major distinguishing characteristics of a variable. 2821 DeclContext *DC, *LexicalDC; 2822 DeclarationName Name; 2823 SourceLocation Loc; 2824 NamedDecl *ToD; 2825 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2826 return nullptr; 2827 if (ToD) 2828 return ToD; 2829 2830 // Try to find a variable in our own ("to") context with the same name and 2831 // in the same context as the variable we're importing. 2832 if (D->isFileVarDecl()) { 2833 VarDecl *MergeWithVar = nullptr; 2834 SmallVector<NamedDecl *, 4> ConflictingDecls; 2835 unsigned IDNS = Decl::IDNS_Ordinary; 2836 SmallVector<NamedDecl *, 2> FoundDecls; 2837 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2838 for (auto *FoundDecl : FoundDecls) { 2839 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 2840 continue; 2841 2842 if (auto *FoundVar = dyn_cast<VarDecl>(FoundDecl)) { 2843 // We have found a variable that we may need to merge with. Check it. 2844 if (FoundVar->hasExternalFormalLinkage() && 2845 D->hasExternalFormalLinkage()) { 2846 if (Importer.IsStructurallyEquivalent(D->getType(), 2847 FoundVar->getType())) { 2848 MergeWithVar = FoundVar; 2849 break; 2850 } 2851 2852 const ArrayType *FoundArray 2853 = Importer.getToContext().getAsArrayType(FoundVar->getType()); 2854 const ArrayType *TArray 2855 = Importer.getToContext().getAsArrayType(D->getType()); 2856 if (FoundArray && TArray) { 2857 if (isa<IncompleteArrayType>(FoundArray) && 2858 isa<ConstantArrayType>(TArray)) { 2859 // Import the type. 2860 QualType T = Importer.Import(D->getType()); 2861 if (T.isNull()) 2862 return nullptr; 2863 2864 FoundVar->setType(T); 2865 MergeWithVar = FoundVar; 2866 break; 2867 } else if (isa<IncompleteArrayType>(TArray) && 2868 isa<ConstantArrayType>(FoundArray)) { 2869 MergeWithVar = FoundVar; 2870 break; 2871 } 2872 } 2873 2874 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent) 2875 << Name << D->getType() << FoundVar->getType(); 2876 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 2877 << FoundVar->getType(); 2878 } 2879 } 2880 2881 ConflictingDecls.push_back(FoundDecl); 2882 } 2883 2884 if (MergeWithVar) { 2885 // An equivalent variable with external linkage has been found. Link 2886 // the two declarations, then merge them. 2887 Importer.Imported(D, MergeWithVar); 2888 2889 if (VarDecl *DDef = D->getDefinition()) { 2890 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) { 2891 Importer.ToDiag(ExistingDef->getLocation(), 2892 diag::err_odr_variable_multiple_def) 2893 << Name; 2894 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here); 2895 } else { 2896 Expr *Init = Importer.Import(DDef->getInit()); 2897 MergeWithVar->setInit(Init); 2898 if (DDef->isInitKnownICE()) { 2899 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt(); 2900 Eval->CheckedICE = true; 2901 Eval->IsICE = DDef->isInitICE(); 2902 } 2903 } 2904 } 2905 2906 return MergeWithVar; 2907 } 2908 2909 if (!ConflictingDecls.empty()) { 2910 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2911 ConflictingDecls.data(), 2912 ConflictingDecls.size()); 2913 if (!Name) 2914 return nullptr; 2915 } 2916 } 2917 2918 // Import the type. 2919 QualType T = Importer.Import(D->getType()); 2920 if (T.isNull()) 2921 return nullptr; 2922 2923 // Create the imported variable. 2924 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2925 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC, 2926 Importer.Import(D->getInnerLocStart()), 2927 Loc, Name.getAsIdentifierInfo(), 2928 T, TInfo, 2929 D->getStorageClass()); 2930 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2931 ToVar->setAccess(D->getAccess()); 2932 ToVar->setLexicalDeclContext(LexicalDC); 2933 Importer.Imported(D, ToVar); 2934 2935 // Templated declarations should never appear in the enclosing DeclContext. 2936 if (!D->getDescribedVarTemplate()) 2937 LexicalDC->addDeclInternal(ToVar); 2938 2939 if (!D->isFileVarDecl() && 2940 D->isUsed()) 2941 ToVar->setIsUsed(); 2942 2943 // Merge the initializer. 2944 if (ImportDefinition(D, ToVar)) 2945 return nullptr; 2946 2947 if (D->isConstexpr()) 2948 ToVar->setConstexpr(true); 2949 2950 return ToVar; 2951 } 2952 2953 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 2954 // Parameters are created in the translation unit's context, then moved 2955 // into the function declaration's context afterward. 2956 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2957 2958 // Import the name of this declaration. 2959 DeclarationName Name = Importer.Import(D->getDeclName()); 2960 if (D->getDeclName() && !Name) 2961 return nullptr; 2962 2963 // Import the location of this declaration. 2964 SourceLocation Loc = Importer.Import(D->getLocation()); 2965 2966 // Import the parameter's type. 2967 QualType T = Importer.Import(D->getType()); 2968 if (T.isNull()) 2969 return nullptr; 2970 2971 // Create the imported parameter. 2972 auto *ToParm = ImplicitParamDecl::Create(Importer.getToContext(), DC, Loc, 2973 Name.getAsIdentifierInfo(), T, 2974 D->getParameterKind()); 2975 return Importer.Imported(D, ToParm); 2976 } 2977 2978 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 2979 // Parameters are created in the translation unit's context, then moved 2980 // into the function declaration's context afterward. 2981 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 2982 2983 // Import the name of this declaration. 2984 DeclarationName Name = Importer.Import(D->getDeclName()); 2985 if (D->getDeclName() && !Name) 2986 return nullptr; 2987 2988 // Import the location of this declaration. 2989 SourceLocation Loc = Importer.Import(D->getLocation()); 2990 2991 // Import the parameter's type. 2992 QualType T = Importer.Import(D->getType()); 2993 if (T.isNull()) 2994 return nullptr; 2995 2996 // Create the imported parameter. 2997 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2998 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC, 2999 Importer.Import(D->getInnerLocStart()), 3000 Loc, Name.getAsIdentifierInfo(), 3001 T, TInfo, D->getStorageClass(), 3002 /*DefaultArg*/ nullptr); 3003 3004 // Set the default argument. 3005 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg()); 3006 ToParm->setKNRPromoted(D->isKNRPromoted()); 3007 3008 Expr *ToDefArg = nullptr; 3009 Expr *FromDefArg = nullptr; 3010 if (D->hasUninstantiatedDefaultArg()) { 3011 FromDefArg = D->getUninstantiatedDefaultArg(); 3012 ToDefArg = Importer.Import(FromDefArg); 3013 ToParm->setUninstantiatedDefaultArg(ToDefArg); 3014 } else if (D->hasUnparsedDefaultArg()) { 3015 ToParm->setUnparsedDefaultArg(); 3016 } else if (D->hasDefaultArg()) { 3017 FromDefArg = D->getDefaultArg(); 3018 ToDefArg = Importer.Import(FromDefArg); 3019 ToParm->setDefaultArg(ToDefArg); 3020 } 3021 if (FromDefArg && !ToDefArg) 3022 return nullptr; 3023 3024 if (D->isObjCMethodParameter()) { 3025 ToParm->setObjCMethodScopeInfo(D->getFunctionScopeIndex()); 3026 ToParm->setObjCDeclQualifier(D->getObjCDeclQualifier()); 3027 } else { 3028 ToParm->setScopeInfo(D->getFunctionScopeDepth(), 3029 D->getFunctionScopeIndex()); 3030 } 3031 3032 if (D->isUsed()) 3033 ToParm->setIsUsed(); 3034 3035 return Importer.Imported(D, ToParm); 3036 } 3037 3038 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 3039 // Import the major distinguishing characteristics of a method. 3040 DeclContext *DC, *LexicalDC; 3041 DeclarationName Name; 3042 SourceLocation Loc; 3043 NamedDecl *ToD; 3044 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3045 return nullptr; 3046 if (ToD) 3047 return ToD; 3048 3049 SmallVector<NamedDecl *, 2> FoundDecls; 3050 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3051 for (auto *FoundDecl : FoundDecls) { 3052 if (auto *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecl)) { 3053 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 3054 continue; 3055 3056 // Check return types. 3057 if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 3058 FoundMethod->getReturnType())) { 3059 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent) 3060 << D->isInstanceMethod() << Name << D->getReturnType() 3061 << FoundMethod->getReturnType(); 3062 Importer.ToDiag(FoundMethod->getLocation(), 3063 diag::note_odr_objc_method_here) 3064 << D->isInstanceMethod() << Name; 3065 return nullptr; 3066 } 3067 3068 // Check the number of parameters. 3069 if (D->param_size() != FoundMethod->param_size()) { 3070 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent) 3071 << D->isInstanceMethod() << Name 3072 << D->param_size() << FoundMethod->param_size(); 3073 Importer.ToDiag(FoundMethod->getLocation(), 3074 diag::note_odr_objc_method_here) 3075 << D->isInstanceMethod() << Name; 3076 return nullptr; 3077 } 3078 3079 // Check parameter types. 3080 for (ObjCMethodDecl::param_iterator P = D->param_begin(), 3081 PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 3082 P != PEnd; ++P, ++FoundP) { 3083 if (!Importer.IsStructurallyEquivalent((*P)->getType(), 3084 (*FoundP)->getType())) { 3085 Importer.FromDiag((*P)->getLocation(), 3086 diag::err_odr_objc_method_param_type_inconsistent) 3087 << D->isInstanceMethod() << Name 3088 << (*P)->getType() << (*FoundP)->getType(); 3089 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 3090 << (*FoundP)->getType(); 3091 return nullptr; 3092 } 3093 } 3094 3095 // Check variadic/non-variadic. 3096 // Check the number of parameters. 3097 if (D->isVariadic() != FoundMethod->isVariadic()) { 3098 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent) 3099 << D->isInstanceMethod() << Name; 3100 Importer.ToDiag(FoundMethod->getLocation(), 3101 diag::note_odr_objc_method_here) 3102 << D->isInstanceMethod() << Name; 3103 return nullptr; 3104 } 3105 3106 // FIXME: Any other bits we need to merge? 3107 return Importer.Imported(D, FoundMethod); 3108 } 3109 } 3110 3111 // Import the result type. 3112 QualType ResultTy = Importer.Import(D->getReturnType()); 3113 if (ResultTy.isNull()) 3114 return nullptr; 3115 3116 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo()); 3117 3118 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create( 3119 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()), 3120 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(), 3121 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(), 3122 D->getImplementationControl(), D->hasRelatedResultType()); 3123 3124 // FIXME: When we decide to merge method definitions, we'll need to 3125 // deal with implicit parameters. 3126 3127 // Import the parameters 3128 SmallVector<ParmVarDecl *, 5> ToParams; 3129 for (auto *FromP : D->parameters()) { 3130 auto *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP)); 3131 if (!ToP) 3132 return nullptr; 3133 3134 ToParams.push_back(ToP); 3135 } 3136 3137 // Set the parameters. 3138 for (auto *ToParam : ToParams) { 3139 ToParam->setOwningFunction(ToMethod); 3140 ToMethod->addDeclInternal(ToParam); 3141 } 3142 3143 SmallVector<SourceLocation, 12> SelLocs; 3144 D->getSelectorLocs(SelLocs); 3145 for (auto &Loc : SelLocs) 3146 Loc = Importer.Import(Loc); 3147 3148 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs); 3149 3150 ToMethod->setLexicalDeclContext(LexicalDC); 3151 Importer.Imported(D, ToMethod); 3152 LexicalDC->addDeclInternal(ToMethod); 3153 return ToMethod; 3154 } 3155 3156 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 3157 // Import the major distinguishing characteristics of a category. 3158 DeclContext *DC, *LexicalDC; 3159 DeclarationName Name; 3160 SourceLocation Loc; 3161 NamedDecl *ToD; 3162 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3163 return nullptr; 3164 if (ToD) 3165 return ToD; 3166 3167 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo()); 3168 if (!BoundInfo) 3169 return nullptr; 3170 3171 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create( 3172 Importer.getToContext(), DC, 3173 D->getVariance(), 3174 Importer.Import(D->getVarianceLoc()), 3175 D->getIndex(), 3176 Importer.Import(D->getLocation()), 3177 Name.getAsIdentifierInfo(), 3178 Importer.Import(D->getColonLoc()), 3179 BoundInfo); 3180 Importer.Imported(D, Result); 3181 Result->setLexicalDeclContext(LexicalDC); 3182 return Result; 3183 } 3184 3185 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 3186 // Import the major distinguishing characteristics of a category. 3187 DeclContext *DC, *LexicalDC; 3188 DeclarationName Name; 3189 SourceLocation Loc; 3190 NamedDecl *ToD; 3191 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3192 return nullptr; 3193 if (ToD) 3194 return ToD; 3195 3196 auto *ToInterface = 3197 cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface())); 3198 if (!ToInterface) 3199 return nullptr; 3200 3201 // Determine if we've already encountered this category. 3202 ObjCCategoryDecl *MergeWithCategory 3203 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 3204 ObjCCategoryDecl *ToCategory = MergeWithCategory; 3205 if (!ToCategory) { 3206 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC, 3207 Importer.Import(D->getAtStartLoc()), 3208 Loc, 3209 Importer.Import(D->getCategoryNameLoc()), 3210 Name.getAsIdentifierInfo(), 3211 ToInterface, 3212 /*TypeParamList=*/nullptr, 3213 Importer.Import(D->getIvarLBraceLoc()), 3214 Importer.Import(D->getIvarRBraceLoc())); 3215 ToCategory->setLexicalDeclContext(LexicalDC); 3216 LexicalDC->addDeclInternal(ToCategory); 3217 Importer.Imported(D, ToCategory); 3218 // Import the type parameter list after calling Imported, to avoid 3219 // loops when bringing in their DeclContext. 3220 ToCategory->setTypeParamList(ImportObjCTypeParamList( 3221 D->getTypeParamList())); 3222 3223 // Import protocols 3224 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3225 SmallVector<SourceLocation, 4> ProtocolLocs; 3226 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 3227 = D->protocol_loc_begin(); 3228 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 3229 FromProtoEnd = D->protocol_end(); 3230 FromProto != FromProtoEnd; 3231 ++FromProto, ++FromProtoLoc) { 3232 auto *ToProto = 3233 cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3234 if (!ToProto) 3235 return nullptr; 3236 Protocols.push_back(ToProto); 3237 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3238 } 3239 3240 // FIXME: If we're merging, make sure that the protocol list is the same. 3241 ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 3242 ProtocolLocs.data(), Importer.getToContext()); 3243 } else { 3244 Importer.Imported(D, ToCategory); 3245 } 3246 3247 // Import all of the members of this category. 3248 ImportDeclContext(D); 3249 3250 // If we have an implementation, import it as well. 3251 if (D->getImplementation()) { 3252 auto *Impl = 3253 cast_or_null<ObjCCategoryImplDecl>( 3254 Importer.Import(D->getImplementation())); 3255 if (!Impl) 3256 return nullptr; 3257 3258 ToCategory->setImplementation(Impl); 3259 } 3260 3261 return ToCategory; 3262 } 3263 3264 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From, 3265 ObjCProtocolDecl *To, 3266 ImportDefinitionKind Kind) { 3267 if (To->getDefinition()) { 3268 if (shouldForceImportDeclContext(Kind)) 3269 ImportDeclContext(From); 3270 return false; 3271 } 3272 3273 // Start the protocol definition 3274 To->startDefinition(); 3275 3276 // Import protocols 3277 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3278 SmallVector<SourceLocation, 4> ProtocolLocs; 3279 ObjCProtocolDecl::protocol_loc_iterator 3280 FromProtoLoc = From->protocol_loc_begin(); 3281 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 3282 FromProtoEnd = From->protocol_end(); 3283 FromProto != FromProtoEnd; 3284 ++FromProto, ++FromProtoLoc) { 3285 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3286 if (!ToProto) 3287 return true; 3288 Protocols.push_back(ToProto); 3289 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3290 } 3291 3292 // FIXME: If we're merging, make sure that the protocol list is the same. 3293 To->setProtocolList(Protocols.data(), Protocols.size(), 3294 ProtocolLocs.data(), Importer.getToContext()); 3295 3296 if (shouldForceImportDeclContext(Kind)) { 3297 // Import all of the members of this protocol. 3298 ImportDeclContext(From, /*ForceImport=*/true); 3299 } 3300 return false; 3301 } 3302 3303 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 3304 // If this protocol has a definition in the translation unit we're coming 3305 // from, but this particular declaration is not that definition, import the 3306 // definition and map to that. 3307 ObjCProtocolDecl *Definition = D->getDefinition(); 3308 if (Definition && Definition != D) { 3309 Decl *ImportedDef = Importer.Import(Definition); 3310 if (!ImportedDef) 3311 return nullptr; 3312 3313 return Importer.Imported(D, ImportedDef); 3314 } 3315 3316 // Import the major distinguishing characteristics of a protocol. 3317 DeclContext *DC, *LexicalDC; 3318 DeclarationName Name; 3319 SourceLocation Loc; 3320 NamedDecl *ToD; 3321 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3322 return nullptr; 3323 if (ToD) 3324 return ToD; 3325 3326 ObjCProtocolDecl *MergeWithProtocol = nullptr; 3327 SmallVector<NamedDecl *, 2> FoundDecls; 3328 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3329 for (auto *FoundDecl : FoundDecls) { 3330 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 3331 continue; 3332 3333 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecl))) 3334 break; 3335 } 3336 3337 ObjCProtocolDecl *ToProto = MergeWithProtocol; 3338 if (!ToProto) { 3339 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC, 3340 Name.getAsIdentifierInfo(), Loc, 3341 Importer.Import(D->getAtStartLoc()), 3342 /*PrevDecl=*/nullptr); 3343 ToProto->setLexicalDeclContext(LexicalDC); 3344 LexicalDC->addDeclInternal(ToProto); 3345 } 3346 3347 Importer.Imported(D, ToProto); 3348 3349 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto)) 3350 return nullptr; 3351 3352 return ToProto; 3353 } 3354 3355 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 3356 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3357 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3358 3359 SourceLocation ExternLoc = Importer.Import(D->getExternLoc()); 3360 SourceLocation LangLoc = Importer.Import(D->getLocation()); 3361 3362 bool HasBraces = D->hasBraces(); 3363 3364 LinkageSpecDecl *ToLinkageSpec = 3365 LinkageSpecDecl::Create(Importer.getToContext(), 3366 DC, 3367 ExternLoc, 3368 LangLoc, 3369 D->getLanguage(), 3370 HasBraces); 3371 3372 if (HasBraces) { 3373 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc()); 3374 ToLinkageSpec->setRBraceLoc(RBraceLoc); 3375 } 3376 3377 ToLinkageSpec->setLexicalDeclContext(LexicalDC); 3378 LexicalDC->addDeclInternal(ToLinkageSpec); 3379 3380 Importer.Imported(D, ToLinkageSpec); 3381 3382 return ToLinkageSpec; 3383 } 3384 3385 Decl *ASTNodeImporter::VisitUsingDecl(UsingDecl *D) { 3386 DeclContext *DC, *LexicalDC; 3387 DeclarationName Name; 3388 SourceLocation Loc; 3389 NamedDecl *ToD = nullptr; 3390 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3391 return nullptr; 3392 if (ToD) 3393 return ToD; 3394 3395 DeclarationNameInfo NameInfo(Name, 3396 Importer.Import(D->getNameInfo().getLoc())); 3397 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 3398 3399 UsingDecl *ToUsing = UsingDecl::Create(Importer.getToContext(), DC, 3400 Importer.Import(D->getUsingLoc()), 3401 Importer.Import(D->getQualifierLoc()), 3402 NameInfo, D->hasTypename()); 3403 ToUsing->setLexicalDeclContext(LexicalDC); 3404 LexicalDC->addDeclInternal(ToUsing); 3405 Importer.Imported(D, ToUsing); 3406 3407 if (NamedDecl *FromPattern = 3408 Importer.getFromContext().getInstantiatedFromUsingDecl(D)) { 3409 if (auto *ToPattern = 3410 dyn_cast_or_null<NamedDecl>(Importer.Import(FromPattern))) 3411 Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing, ToPattern); 3412 else 3413 return nullptr; 3414 } 3415 3416 for (auto *FromShadow : D->shadows()) { 3417 if (auto *ToShadow = 3418 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromShadow))) 3419 ToUsing->addShadowDecl(ToShadow); 3420 else 3421 // FIXME: We return a nullptr here but the definition is already created 3422 // and available with lookups. How to fix this?.. 3423 return nullptr; 3424 } 3425 return ToUsing; 3426 } 3427 3428 Decl *ASTNodeImporter::VisitUsingShadowDecl(UsingShadowDecl *D) { 3429 DeclContext *DC, *LexicalDC; 3430 DeclarationName Name; 3431 SourceLocation Loc; 3432 NamedDecl *ToD = nullptr; 3433 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3434 return nullptr; 3435 if (ToD) 3436 return ToD; 3437 3438 auto *ToUsing = dyn_cast_or_null<UsingDecl>( 3439 Importer.Import(D->getUsingDecl())); 3440 if (!ToUsing) 3441 return nullptr; 3442 3443 auto *ToTarget = dyn_cast_or_null<NamedDecl>( 3444 Importer.Import(D->getTargetDecl())); 3445 if (!ToTarget) 3446 return nullptr; 3447 3448 UsingShadowDecl *ToShadow = UsingShadowDecl::Create( 3449 Importer.getToContext(), DC, Loc, ToUsing, ToTarget); 3450 3451 ToShadow->setLexicalDeclContext(LexicalDC); 3452 ToShadow->setAccess(D->getAccess()); 3453 Importer.Imported(D, ToShadow); 3454 3455 if (UsingShadowDecl *FromPattern = 3456 Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) { 3457 if (auto *ToPattern = 3458 dyn_cast_or_null<UsingShadowDecl>(Importer.Import(FromPattern))) 3459 Importer.getToContext().setInstantiatedFromUsingShadowDecl(ToShadow, 3460 ToPattern); 3461 else 3462 // FIXME: We return a nullptr here but the definition is already created 3463 // and available with lookups. How to fix this?.. 3464 return nullptr; 3465 } 3466 3467 LexicalDC->addDeclInternal(ToShadow); 3468 3469 return ToShadow; 3470 } 3471 3472 Decl *ASTNodeImporter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 3473 DeclContext *DC, *LexicalDC; 3474 DeclarationName Name; 3475 SourceLocation Loc; 3476 NamedDecl *ToD = nullptr; 3477 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3478 return nullptr; 3479 if (ToD) 3480 return ToD; 3481 3482 DeclContext *ToComAncestor = Importer.ImportContext(D->getCommonAncestor()); 3483 if (!ToComAncestor) 3484 return nullptr; 3485 3486 auto *ToNominated = cast_or_null<NamespaceDecl>( 3487 Importer.Import(D->getNominatedNamespace())); 3488 if (!ToNominated) 3489 return nullptr; 3490 3491 UsingDirectiveDecl *ToUsingDir = UsingDirectiveDecl::Create( 3492 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3493 Importer.Import(D->getNamespaceKeyLocation()), 3494 Importer.Import(D->getQualifierLoc()), 3495 Importer.Import(D->getIdentLocation()), ToNominated, ToComAncestor); 3496 ToUsingDir->setLexicalDeclContext(LexicalDC); 3497 LexicalDC->addDeclInternal(ToUsingDir); 3498 Importer.Imported(D, ToUsingDir); 3499 3500 return ToUsingDir; 3501 } 3502 3503 Decl *ASTNodeImporter::VisitUnresolvedUsingValueDecl( 3504 UnresolvedUsingValueDecl *D) { 3505 DeclContext *DC, *LexicalDC; 3506 DeclarationName Name; 3507 SourceLocation Loc; 3508 NamedDecl *ToD = nullptr; 3509 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3510 return nullptr; 3511 if (ToD) 3512 return ToD; 3513 3514 DeclarationNameInfo NameInfo(Name, Importer.Import(D->getNameInfo().getLoc())); 3515 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 3516 3517 UnresolvedUsingValueDecl *ToUsingValue = UnresolvedUsingValueDecl::Create( 3518 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3519 Importer.Import(D->getQualifierLoc()), NameInfo, 3520 Importer.Import(D->getEllipsisLoc())); 3521 3522 Importer.Imported(D, ToUsingValue); 3523 ToUsingValue->setAccess(D->getAccess()); 3524 ToUsingValue->setLexicalDeclContext(LexicalDC); 3525 LexicalDC->addDeclInternal(ToUsingValue); 3526 3527 return ToUsingValue; 3528 } 3529 3530 Decl *ASTNodeImporter::VisitUnresolvedUsingTypenameDecl( 3531 UnresolvedUsingTypenameDecl *D) { 3532 DeclContext *DC, *LexicalDC; 3533 DeclarationName Name; 3534 SourceLocation Loc; 3535 NamedDecl *ToD = nullptr; 3536 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3537 return nullptr; 3538 if (ToD) 3539 return ToD; 3540 3541 UnresolvedUsingTypenameDecl *ToUsing = UnresolvedUsingTypenameDecl::Create( 3542 Importer.getToContext(), DC, Importer.Import(D->getUsingLoc()), 3543 Importer.Import(D->getTypenameLoc()), 3544 Importer.Import(D->getQualifierLoc()), Loc, Name, 3545 Importer.Import(D->getEllipsisLoc())); 3546 3547 Importer.Imported(D, ToUsing); 3548 ToUsing->setAccess(D->getAccess()); 3549 ToUsing->setLexicalDeclContext(LexicalDC); 3550 LexicalDC->addDeclInternal(ToUsing); 3551 3552 return ToUsing; 3553 } 3554 3555 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 3556 ObjCInterfaceDecl *To, 3557 ImportDefinitionKind Kind) { 3558 if (To->getDefinition()) { 3559 // Check consistency of superclass. 3560 ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 3561 if (FromSuper) { 3562 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper)); 3563 if (!FromSuper) 3564 return true; 3565 } 3566 3567 ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 3568 if ((bool)FromSuper != (bool)ToSuper || 3569 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 3570 Importer.ToDiag(To->getLocation(), 3571 diag::err_odr_objc_superclass_inconsistent) 3572 << To->getDeclName(); 3573 if (ToSuper) 3574 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 3575 << To->getSuperClass()->getDeclName(); 3576 else 3577 Importer.ToDiag(To->getLocation(), 3578 diag::note_odr_objc_missing_superclass); 3579 if (From->getSuperClass()) 3580 Importer.FromDiag(From->getSuperClassLoc(), 3581 diag::note_odr_objc_superclass) 3582 << From->getSuperClass()->getDeclName(); 3583 else 3584 Importer.FromDiag(From->getLocation(), 3585 diag::note_odr_objc_missing_superclass); 3586 } 3587 3588 if (shouldForceImportDeclContext(Kind)) 3589 ImportDeclContext(From); 3590 return false; 3591 } 3592 3593 // Start the definition. 3594 To->startDefinition(); 3595 3596 // If this class has a superclass, import it. 3597 if (From->getSuperClass()) { 3598 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo()); 3599 if (!SuperTInfo) 3600 return true; 3601 3602 To->setSuperClass(SuperTInfo); 3603 } 3604 3605 // Import protocols 3606 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3607 SmallVector<SourceLocation, 4> ProtocolLocs; 3608 ObjCInterfaceDecl::protocol_loc_iterator 3609 FromProtoLoc = From->protocol_loc_begin(); 3610 3611 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 3612 FromProtoEnd = From->protocol_end(); 3613 FromProto != FromProtoEnd; 3614 ++FromProto, ++FromProtoLoc) { 3615 auto *ToProto = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3616 if (!ToProto) 3617 return true; 3618 Protocols.push_back(ToProto); 3619 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3620 } 3621 3622 // FIXME: If we're merging, make sure that the protocol list is the same. 3623 To->setProtocolList(Protocols.data(), Protocols.size(), 3624 ProtocolLocs.data(), Importer.getToContext()); 3625 3626 // Import categories. When the categories themselves are imported, they'll 3627 // hook themselves into this interface. 3628 for (auto *Cat : From->known_categories()) 3629 Importer.Import(Cat); 3630 3631 // If we have an @implementation, import it as well. 3632 if (From->getImplementation()) { 3633 auto *Impl = cast_or_null<ObjCImplementationDecl>( 3634 Importer.Import(From->getImplementation())); 3635 if (!Impl) 3636 return true; 3637 3638 To->setImplementation(Impl); 3639 } 3640 3641 if (shouldForceImportDeclContext(Kind)) { 3642 // Import all of the members of this class. 3643 ImportDeclContext(From, /*ForceImport=*/true); 3644 } 3645 return false; 3646 } 3647 3648 ObjCTypeParamList * 3649 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 3650 if (!list) 3651 return nullptr; 3652 3653 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 3654 for (auto fromTypeParam : *list) { 3655 auto *toTypeParam = cast_or_null<ObjCTypeParamDecl>( 3656 Importer.Import(fromTypeParam)); 3657 if (!toTypeParam) 3658 return nullptr; 3659 3660 toTypeParams.push_back(toTypeParam); 3661 } 3662 3663 return ObjCTypeParamList::create(Importer.getToContext(), 3664 Importer.Import(list->getLAngleLoc()), 3665 toTypeParams, 3666 Importer.Import(list->getRAngleLoc())); 3667 } 3668 3669 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 3670 // If this class has a definition in the translation unit we're coming from, 3671 // but this particular declaration is not that definition, import the 3672 // definition and map to that. 3673 ObjCInterfaceDecl *Definition = D->getDefinition(); 3674 if (Definition && Definition != D) { 3675 Decl *ImportedDef = Importer.Import(Definition); 3676 if (!ImportedDef) 3677 return nullptr; 3678 3679 return Importer.Imported(D, ImportedDef); 3680 } 3681 3682 // Import the major distinguishing characteristics of an @interface. 3683 DeclContext *DC, *LexicalDC; 3684 DeclarationName Name; 3685 SourceLocation Loc; 3686 NamedDecl *ToD; 3687 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3688 return nullptr; 3689 if (ToD) 3690 return ToD; 3691 3692 // Look for an existing interface with the same name. 3693 ObjCInterfaceDecl *MergeWithIface = nullptr; 3694 SmallVector<NamedDecl *, 2> FoundDecls; 3695 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3696 for (auto *FoundDecl : FoundDecls) { 3697 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3698 continue; 3699 3700 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecl))) 3701 break; 3702 } 3703 3704 // Create an interface declaration, if one does not already exist. 3705 ObjCInterfaceDecl *ToIface = MergeWithIface; 3706 if (!ToIface) { 3707 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC, 3708 Importer.Import(D->getAtStartLoc()), 3709 Name.getAsIdentifierInfo(), 3710 /*TypeParamList=*/nullptr, 3711 /*PrevDecl=*/nullptr, Loc, 3712 D->isImplicitInterfaceDecl()); 3713 ToIface->setLexicalDeclContext(LexicalDC); 3714 LexicalDC->addDeclInternal(ToIface); 3715 } 3716 Importer.Imported(D, ToIface); 3717 // Import the type parameter list after calling Imported, to avoid 3718 // loops when bringing in their DeclContext. 3719 ToIface->setTypeParamList(ImportObjCTypeParamList( 3720 D->getTypeParamListAsWritten())); 3721 3722 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface)) 3723 return nullptr; 3724 3725 return ToIface; 3726 } 3727 3728 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 3729 auto *Category = cast_or_null<ObjCCategoryDecl>( 3730 Importer.Import(D->getCategoryDecl())); 3731 if (!Category) 3732 return nullptr; 3733 3734 ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 3735 if (!ToImpl) { 3736 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3737 if (!DC) 3738 return nullptr; 3739 3740 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc()); 3741 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC, 3742 Importer.Import(D->getIdentifier()), 3743 Category->getClassInterface(), 3744 Importer.Import(D->getLocation()), 3745 Importer.Import(D->getAtStartLoc()), 3746 CategoryNameLoc); 3747 3748 DeclContext *LexicalDC = DC; 3749 if (D->getDeclContext() != D->getLexicalDeclContext()) { 3750 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3751 if (!LexicalDC) 3752 return nullptr; 3753 3754 ToImpl->setLexicalDeclContext(LexicalDC); 3755 } 3756 3757 LexicalDC->addDeclInternal(ToImpl); 3758 Category->setImplementation(ToImpl); 3759 } 3760 3761 Importer.Imported(D, ToImpl); 3762 ImportDeclContext(D); 3763 return ToImpl; 3764 } 3765 3766 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 3767 // Find the corresponding interface. 3768 auto *Iface = cast_or_null<ObjCInterfaceDecl>( 3769 Importer.Import(D->getClassInterface())); 3770 if (!Iface) 3771 return nullptr; 3772 3773 // Import the superclass, if any. 3774 ObjCInterfaceDecl *Super = nullptr; 3775 if (D->getSuperClass()) { 3776 Super = cast_or_null<ObjCInterfaceDecl>( 3777 Importer.Import(D->getSuperClass())); 3778 if (!Super) 3779 return nullptr; 3780 } 3781 3782 ObjCImplementationDecl *Impl = Iface->getImplementation(); 3783 if (!Impl) { 3784 // We haven't imported an implementation yet. Create a new @implementation 3785 // now. 3786 Impl = ObjCImplementationDecl::Create(Importer.getToContext(), 3787 Importer.ImportContext(D->getDeclContext()), 3788 Iface, Super, 3789 Importer.Import(D->getLocation()), 3790 Importer.Import(D->getAtStartLoc()), 3791 Importer.Import(D->getSuperClassLoc()), 3792 Importer.Import(D->getIvarLBraceLoc()), 3793 Importer.Import(D->getIvarRBraceLoc())); 3794 3795 if (D->getDeclContext() != D->getLexicalDeclContext()) { 3796 DeclContext *LexicalDC 3797 = Importer.ImportContext(D->getLexicalDeclContext()); 3798 if (!LexicalDC) 3799 return nullptr; 3800 Impl->setLexicalDeclContext(LexicalDC); 3801 } 3802 3803 // Associate the implementation with the class it implements. 3804 Iface->setImplementation(Impl); 3805 Importer.Imported(D, Iface->getImplementation()); 3806 } else { 3807 Importer.Imported(D, Iface->getImplementation()); 3808 3809 // Verify that the existing @implementation has the same superclass. 3810 if ((Super && !Impl->getSuperClass()) || 3811 (!Super && Impl->getSuperClass()) || 3812 (Super && Impl->getSuperClass() && 3813 !declaresSameEntity(Super->getCanonicalDecl(), 3814 Impl->getSuperClass()))) { 3815 Importer.ToDiag(Impl->getLocation(), 3816 diag::err_odr_objc_superclass_inconsistent) 3817 << Iface->getDeclName(); 3818 // FIXME: It would be nice to have the location of the superclass 3819 // below. 3820 if (Impl->getSuperClass()) 3821 Importer.ToDiag(Impl->getLocation(), 3822 diag::note_odr_objc_superclass) 3823 << Impl->getSuperClass()->getDeclName(); 3824 else 3825 Importer.ToDiag(Impl->getLocation(), 3826 diag::note_odr_objc_missing_superclass); 3827 if (D->getSuperClass()) 3828 Importer.FromDiag(D->getLocation(), 3829 diag::note_odr_objc_superclass) 3830 << D->getSuperClass()->getDeclName(); 3831 else 3832 Importer.FromDiag(D->getLocation(), 3833 diag::note_odr_objc_missing_superclass); 3834 return nullptr; 3835 } 3836 } 3837 3838 // Import all of the members of this @implementation. 3839 ImportDeclContext(D); 3840 3841 return Impl; 3842 } 3843 3844 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 3845 // Import the major distinguishing characteristics of an @property. 3846 DeclContext *DC, *LexicalDC; 3847 DeclarationName Name; 3848 SourceLocation Loc; 3849 NamedDecl *ToD; 3850 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3851 return nullptr; 3852 if (ToD) 3853 return ToD; 3854 3855 // Check whether we have already imported this property. 3856 SmallVector<NamedDecl *, 2> FoundDecls; 3857 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3858 for (auto *FoundDecl : FoundDecls) { 3859 if (auto *FoundProp = dyn_cast<ObjCPropertyDecl>(FoundDecl)) { 3860 // Check property types. 3861 if (!Importer.IsStructurallyEquivalent(D->getType(), 3862 FoundProp->getType())) { 3863 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent) 3864 << Name << D->getType() << FoundProp->getType(); 3865 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 3866 << FoundProp->getType(); 3867 return nullptr; 3868 } 3869 3870 // FIXME: Check property attributes, getters, setters, etc.? 3871 3872 // Consider these properties to be equivalent. 3873 Importer.Imported(D, FoundProp); 3874 return FoundProp; 3875 } 3876 } 3877 3878 // Import the type. 3879 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo()); 3880 if (!TSI) 3881 return nullptr; 3882 3883 // Create the new property. 3884 ObjCPropertyDecl *ToProperty 3885 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc, 3886 Name.getAsIdentifierInfo(), 3887 Importer.Import(D->getAtLoc()), 3888 Importer.Import(D->getLParenLoc()), 3889 Importer.Import(D->getType()), 3890 TSI, 3891 D->getPropertyImplementation()); 3892 Importer.Imported(D, ToProperty); 3893 ToProperty->setLexicalDeclContext(LexicalDC); 3894 LexicalDC->addDeclInternal(ToProperty); 3895 3896 ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 3897 ToProperty->setPropertyAttributesAsWritten( 3898 D->getPropertyAttributesAsWritten()); 3899 ToProperty->setGetterName(Importer.Import(D->getGetterName()), 3900 Importer.Import(D->getGetterNameLoc())); 3901 ToProperty->setSetterName(Importer.Import(D->getSetterName()), 3902 Importer.Import(D->getSetterNameLoc())); 3903 ToProperty->setGetterMethodDecl( 3904 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl()))); 3905 ToProperty->setSetterMethodDecl( 3906 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl()))); 3907 ToProperty->setPropertyIvarDecl( 3908 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl()))); 3909 return ToProperty; 3910 } 3911 3912 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 3913 auto *Property = cast_or_null<ObjCPropertyDecl>( 3914 Importer.Import(D->getPropertyDecl())); 3915 if (!Property) 3916 return nullptr; 3917 3918 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3919 if (!DC) 3920 return nullptr; 3921 3922 // Import the lexical declaration context. 3923 DeclContext *LexicalDC = DC; 3924 if (D->getDeclContext() != D->getLexicalDeclContext()) { 3925 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3926 if (!LexicalDC) 3927 return nullptr; 3928 } 3929 3930 auto *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC); 3931 if (!InImpl) 3932 return nullptr; 3933 3934 // Import the ivar (for an @synthesize). 3935 ObjCIvarDecl *Ivar = nullptr; 3936 if (D->getPropertyIvarDecl()) { 3937 Ivar = cast_or_null<ObjCIvarDecl>( 3938 Importer.Import(D->getPropertyIvarDecl())); 3939 if (!Ivar) 3940 return nullptr; 3941 } 3942 3943 ObjCPropertyImplDecl *ToImpl 3944 = InImpl->FindPropertyImplDecl(Property->getIdentifier(), 3945 Property->getQueryKind()); 3946 if (!ToImpl) { 3947 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC, 3948 Importer.Import(D->getLocStart()), 3949 Importer.Import(D->getLocation()), 3950 Property, 3951 D->getPropertyImplementation(), 3952 Ivar, 3953 Importer.Import(D->getPropertyIvarDeclLoc())); 3954 ToImpl->setLexicalDeclContext(LexicalDC); 3955 Importer.Imported(D, ToImpl); 3956 LexicalDC->addDeclInternal(ToImpl); 3957 } else { 3958 // Check that we have the same kind of property implementation (@synthesize 3959 // vs. @dynamic). 3960 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 3961 Importer.ToDiag(ToImpl->getLocation(), 3962 diag::err_odr_objc_property_impl_kind_inconsistent) 3963 << Property->getDeclName() 3964 << (ToImpl->getPropertyImplementation() 3965 == ObjCPropertyImplDecl::Dynamic); 3966 Importer.FromDiag(D->getLocation(), 3967 diag::note_odr_objc_property_impl_kind) 3968 << D->getPropertyDecl()->getDeclName() 3969 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 3970 return nullptr; 3971 } 3972 3973 // For @synthesize, check that we have the same 3974 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 3975 Ivar != ToImpl->getPropertyIvarDecl()) { 3976 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 3977 diag::err_odr_objc_synthesize_ivar_inconsistent) 3978 << Property->getDeclName() 3979 << ToImpl->getPropertyIvarDecl()->getDeclName() 3980 << Ivar->getDeclName(); 3981 Importer.FromDiag(D->getPropertyIvarDeclLoc(), 3982 diag::note_odr_objc_synthesize_ivar_here) 3983 << D->getPropertyIvarDecl()->getDeclName(); 3984 return nullptr; 3985 } 3986 3987 // Merge the existing implementation with the new implementation. 3988 Importer.Imported(D, ToImpl); 3989 } 3990 3991 return ToImpl; 3992 } 3993 3994 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 3995 // For template arguments, we adopt the translation unit as our declaration 3996 // context. This context will be fixed when the actual template declaration 3997 // is created. 3998 3999 // FIXME: Import default argument. 4000 return TemplateTypeParmDecl::Create(Importer.getToContext(), 4001 Importer.getToContext().getTranslationUnitDecl(), 4002 Importer.Import(D->getLocStart()), 4003 Importer.Import(D->getLocation()), 4004 D->getDepth(), 4005 D->getIndex(), 4006 Importer.Import(D->getIdentifier()), 4007 D->wasDeclaredWithTypename(), 4008 D->isParameterPack()); 4009 } 4010 4011 Decl * 4012 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 4013 // Import the name of this declaration. 4014 DeclarationName Name = Importer.Import(D->getDeclName()); 4015 if (D->getDeclName() && !Name) 4016 return nullptr; 4017 4018 // Import the location of this declaration. 4019 SourceLocation Loc = Importer.Import(D->getLocation()); 4020 4021 // Import the type of this declaration. 4022 QualType T = Importer.Import(D->getType()); 4023 if (T.isNull()) 4024 return nullptr; 4025 4026 // Import type-source information. 4027 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 4028 if (D->getTypeSourceInfo() && !TInfo) 4029 return nullptr; 4030 4031 // FIXME: Import default argument. 4032 4033 return NonTypeTemplateParmDecl::Create(Importer.getToContext(), 4034 Importer.getToContext().getTranslationUnitDecl(), 4035 Importer.Import(D->getInnerLocStart()), 4036 Loc, D->getDepth(), D->getPosition(), 4037 Name.getAsIdentifierInfo(), 4038 T, D->isParameterPack(), TInfo); 4039 } 4040 4041 Decl * 4042 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 4043 // Import the name of this declaration. 4044 DeclarationName Name = Importer.Import(D->getDeclName()); 4045 if (D->getDeclName() && !Name) 4046 return nullptr; 4047 4048 // Import the location of this declaration. 4049 SourceLocation Loc = Importer.Import(D->getLocation()); 4050 4051 // Import template parameters. 4052 TemplateParameterList *TemplateParams 4053 = ImportTemplateParameterList(D->getTemplateParameters()); 4054 if (!TemplateParams) 4055 return nullptr; 4056 4057 // FIXME: Import default argument. 4058 4059 return TemplateTemplateParmDecl::Create(Importer.getToContext(), 4060 Importer.getToContext().getTranslationUnitDecl(), 4061 Loc, D->getDepth(), D->getPosition(), 4062 D->isParameterPack(), 4063 Name.getAsIdentifierInfo(), 4064 TemplateParams); 4065 } 4066 4067 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 4068 // If this record has a definition in the translation unit we're coming from, 4069 // but this particular declaration is not that definition, import the 4070 // definition and map to that. 4071 auto *Definition = 4072 cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition()); 4073 if (Definition && Definition != D->getTemplatedDecl()) { 4074 Decl *ImportedDef 4075 = Importer.Import(Definition->getDescribedClassTemplate()); 4076 if (!ImportedDef) 4077 return nullptr; 4078 4079 return Importer.Imported(D, ImportedDef); 4080 } 4081 4082 // Import the major distinguishing characteristics of this class template. 4083 DeclContext *DC, *LexicalDC; 4084 DeclarationName Name; 4085 SourceLocation Loc; 4086 NamedDecl *ToD; 4087 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4088 return nullptr; 4089 if (ToD) 4090 return ToD; 4091 4092 // We may already have a template of the same name; try to find and match it. 4093 if (!DC->isFunctionOrMethod()) { 4094 SmallVector<NamedDecl *, 4> ConflictingDecls; 4095 SmallVector<NamedDecl *, 2> FoundDecls; 4096 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4097 for (auto *FoundDecl : FoundDecls) { 4098 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4099 continue; 4100 4101 Decl *Found = FoundDecl; 4102 if (auto *FoundTemplate = dyn_cast<ClassTemplateDecl>(Found)) { 4103 if (IsStructuralMatch(D, FoundTemplate)) { 4104 // The class templates structurally match; call it the same template. 4105 // FIXME: We may be filling in a forward declaration here. Handle 4106 // this case! 4107 Importer.Imported(D->getTemplatedDecl(), 4108 FoundTemplate->getTemplatedDecl()); 4109 return Importer.Imported(D, FoundTemplate); 4110 } 4111 } 4112 4113 ConflictingDecls.push_back(FoundDecl); 4114 } 4115 4116 if (!ConflictingDecls.empty()) { 4117 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 4118 ConflictingDecls.data(), 4119 ConflictingDecls.size()); 4120 } 4121 4122 if (!Name) 4123 return nullptr; 4124 } 4125 4126 CXXRecordDecl *FromTemplated = D->getTemplatedDecl(); 4127 4128 // Create the declaration that is being templated. 4129 auto *ToTemplated = cast_or_null<CXXRecordDecl>( 4130 Importer.Import(FromTemplated)); 4131 if (!ToTemplated) 4132 return nullptr; 4133 4134 // Resolve possible cyclic import. 4135 if (Decl *AlreadyImported = Importer.GetAlreadyImportedOrNull(D)) 4136 return AlreadyImported; 4137 4138 // Create the class template declaration itself. 4139 TemplateParameterList *TemplateParams = 4140 ImportTemplateParameterList(D->getTemplateParameters()); 4141 if (!TemplateParams) 4142 return nullptr; 4143 4144 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC, 4145 Loc, Name, TemplateParams, 4146 ToTemplated); 4147 ToTemplated->setDescribedClassTemplate(D2); 4148 4149 D2->setAccess(D->getAccess()); 4150 D2->setLexicalDeclContext(LexicalDC); 4151 LexicalDC->addDeclInternal(D2); 4152 4153 // Note the relationship between the class templates. 4154 Importer.Imported(D, D2); 4155 Importer.Imported(FromTemplated, ToTemplated); 4156 4157 if (FromTemplated->isCompleteDefinition() && 4158 !ToTemplated->isCompleteDefinition()) { 4159 // FIXME: Import definition! 4160 } 4161 4162 return D2; 4163 } 4164 4165 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl( 4166 ClassTemplateSpecializationDecl *D) { 4167 // If this record has a definition in the translation unit we're coming from, 4168 // but this particular declaration is not that definition, import the 4169 // definition and map to that. 4170 TagDecl *Definition = D->getDefinition(); 4171 if (Definition && Definition != D) { 4172 Decl *ImportedDef = Importer.Import(Definition); 4173 if (!ImportedDef) 4174 return nullptr; 4175 4176 return Importer.Imported(D, ImportedDef); 4177 } 4178 4179 auto *ClassTemplate = 4180 cast_or_null<ClassTemplateDecl>(Importer.Import( 4181 D->getSpecializedTemplate())); 4182 if (!ClassTemplate) 4183 return nullptr; 4184 4185 // Import the context of this declaration. 4186 DeclContext *DC = ClassTemplate->getDeclContext(); 4187 if (!DC) 4188 return nullptr; 4189 4190 DeclContext *LexicalDC = DC; 4191 if (D->getDeclContext() != D->getLexicalDeclContext()) { 4192 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4193 if (!LexicalDC) 4194 return nullptr; 4195 } 4196 4197 // Import the location of this declaration. 4198 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 4199 SourceLocation IdLoc = Importer.Import(D->getLocation()); 4200 4201 // Import template arguments. 4202 SmallVector<TemplateArgument, 2> TemplateArgs; 4203 if (ImportTemplateArguments(D->getTemplateArgs().data(), 4204 D->getTemplateArgs().size(), 4205 TemplateArgs)) 4206 return nullptr; 4207 4208 // Try to find an existing specialization with these template arguments. 4209 void *InsertPos = nullptr; 4210 ClassTemplateSpecializationDecl *D2 4211 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 4212 if (D2) { 4213 // We already have a class template specialization with these template 4214 // arguments. 4215 4216 // FIXME: Check for specialization vs. instantiation errors. 4217 4218 if (RecordDecl *FoundDef = D2->getDefinition()) { 4219 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) { 4220 // The record types structurally match, or the "from" translation 4221 // unit only had a forward declaration anyway; call it the same 4222 // function. 4223 return Importer.Imported(D, FoundDef); 4224 } 4225 } 4226 } else { 4227 // Create a new specialization. 4228 if (auto *PartialSpec = 4229 dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) { 4230 // Import TemplateArgumentListInfo 4231 TemplateArgumentListInfo ToTAInfo; 4232 const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten(); 4233 if (ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo)) 4234 return nullptr; 4235 4236 QualType CanonInjType = Importer.Import( 4237 PartialSpec->getInjectedSpecializationType()); 4238 if (CanonInjType.isNull()) 4239 return nullptr; 4240 CanonInjType = CanonInjType.getCanonicalType(); 4241 4242 TemplateParameterList *ToTPList = ImportTemplateParameterList( 4243 PartialSpec->getTemplateParameters()); 4244 if (!ToTPList && PartialSpec->getTemplateParameters()) 4245 return nullptr; 4246 4247 D2 = ClassTemplatePartialSpecializationDecl::Create( 4248 Importer.getToContext(), D->getTagKind(), DC, StartLoc, IdLoc, 4249 ToTPList, ClassTemplate, 4250 llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()), 4251 ToTAInfo, CanonInjType, nullptr); 4252 4253 } else { 4254 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(), 4255 D->getTagKind(), DC, 4256 StartLoc, IdLoc, 4257 ClassTemplate, 4258 TemplateArgs, 4259 /*PrevDecl=*/nullptr); 4260 } 4261 4262 D2->setSpecializationKind(D->getSpecializationKind()); 4263 4264 // Add this specialization to the class template. 4265 ClassTemplate->AddSpecialization(D2, InsertPos); 4266 4267 // Import the qualifier, if any. 4268 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 4269 4270 Importer.Imported(D, D2); 4271 4272 if (auto *TSI = D->getTypeAsWritten()) { 4273 TypeSourceInfo *TInfo = Importer.Import(TSI); 4274 if (!TInfo) 4275 return nullptr; 4276 D2->setTypeAsWritten(TInfo); 4277 D2->setTemplateKeywordLoc(Importer.Import(D->getTemplateKeywordLoc())); 4278 D2->setExternLoc(Importer.Import(D->getExternLoc())); 4279 } 4280 4281 SourceLocation POI = Importer.Import(D->getPointOfInstantiation()); 4282 if (POI.isValid()) 4283 D2->setPointOfInstantiation(POI); 4284 else if (D->getPointOfInstantiation().isValid()) 4285 return nullptr; 4286 4287 D2->setTemplateSpecializationKind(D->getTemplateSpecializationKind()); 4288 4289 // Add the specialization to this context. 4290 D2->setLexicalDeclContext(LexicalDC); 4291 LexicalDC->addDeclInternal(D2); 4292 } 4293 Importer.Imported(D, D2); 4294 if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 4295 return nullptr; 4296 4297 return D2; 4298 } 4299 4300 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 4301 // If this variable has a definition in the translation unit we're coming 4302 // from, 4303 // but this particular declaration is not that definition, import the 4304 // definition and map to that. 4305 auto *Definition = 4306 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 4307 if (Definition && Definition != D->getTemplatedDecl()) { 4308 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate()); 4309 if (!ImportedDef) 4310 return nullptr; 4311 4312 return Importer.Imported(D, ImportedDef); 4313 } 4314 4315 // Import the major distinguishing characteristics of this variable template. 4316 DeclContext *DC, *LexicalDC; 4317 DeclarationName Name; 4318 SourceLocation Loc; 4319 NamedDecl *ToD; 4320 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4321 return nullptr; 4322 if (ToD) 4323 return ToD; 4324 4325 // We may already have a template of the same name; try to find and match it. 4326 assert(!DC->isFunctionOrMethod() && 4327 "Variable templates cannot be declared at function scope"); 4328 SmallVector<NamedDecl *, 4> ConflictingDecls; 4329 SmallVector<NamedDecl *, 2> FoundDecls; 4330 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4331 for (auto *FoundDecl : FoundDecls) { 4332 if (!FoundDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4333 continue; 4334 4335 Decl *Found = FoundDecl; 4336 if (auto *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 4337 if (IsStructuralMatch(D, FoundTemplate)) { 4338 // The variable templates structurally match; call it the same template. 4339 Importer.Imported(D->getTemplatedDecl(), 4340 FoundTemplate->getTemplatedDecl()); 4341 return Importer.Imported(D, FoundTemplate); 4342 } 4343 } 4344 4345 ConflictingDecls.push_back(FoundDecl); 4346 } 4347 4348 if (!ConflictingDecls.empty()) { 4349 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 4350 ConflictingDecls.data(), 4351 ConflictingDecls.size()); 4352 } 4353 4354 if (!Name) 4355 return nullptr; 4356 4357 VarDecl *DTemplated = D->getTemplatedDecl(); 4358 4359 // Import the type. 4360 QualType T = Importer.Import(DTemplated->getType()); 4361 if (T.isNull()) 4362 return nullptr; 4363 4364 // Create the declaration that is being templated. 4365 auto *ToTemplated = dyn_cast_or_null<VarDecl>(Importer.Import(DTemplated)); 4366 if (!ToTemplated) 4367 return nullptr; 4368 4369 // Create the variable template declaration itself. 4370 TemplateParameterList *TemplateParams = 4371 ImportTemplateParameterList(D->getTemplateParameters()); 4372 if (!TemplateParams) 4373 return nullptr; 4374 4375 VarTemplateDecl *ToVarTD = VarTemplateDecl::Create( 4376 Importer.getToContext(), DC, Loc, Name, TemplateParams, ToTemplated); 4377 ToTemplated->setDescribedVarTemplate(ToVarTD); 4378 4379 ToVarTD->setAccess(D->getAccess()); 4380 ToVarTD->setLexicalDeclContext(LexicalDC); 4381 LexicalDC->addDeclInternal(ToVarTD); 4382 4383 // Note the relationship between the variable templates. 4384 Importer.Imported(D, ToVarTD); 4385 Importer.Imported(DTemplated, ToTemplated); 4386 4387 if (DTemplated->isThisDeclarationADefinition() && 4388 !ToTemplated->isThisDeclarationADefinition()) { 4389 // FIXME: Import definition! 4390 } 4391 4392 return ToVarTD; 4393 } 4394 4395 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl( 4396 VarTemplateSpecializationDecl *D) { 4397 // If this record has a definition in the translation unit we're coming from, 4398 // but this particular declaration is not that definition, import the 4399 // definition and map to that. 4400 VarDecl *Definition = D->getDefinition(); 4401 if (Definition && Definition != D) { 4402 Decl *ImportedDef = Importer.Import(Definition); 4403 if (!ImportedDef) 4404 return nullptr; 4405 4406 return Importer.Imported(D, ImportedDef); 4407 } 4408 4409 auto *VarTemplate = cast_or_null<VarTemplateDecl>( 4410 Importer.Import(D->getSpecializedTemplate())); 4411 if (!VarTemplate) 4412 return nullptr; 4413 4414 // Import the context of this declaration. 4415 DeclContext *DC = VarTemplate->getDeclContext(); 4416 if (!DC) 4417 return nullptr; 4418 4419 DeclContext *LexicalDC = DC; 4420 if (D->getDeclContext() != D->getLexicalDeclContext()) { 4421 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4422 if (!LexicalDC) 4423 return nullptr; 4424 } 4425 4426 // Import the location of this declaration. 4427 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 4428 SourceLocation IdLoc = Importer.Import(D->getLocation()); 4429 4430 // Import template arguments. 4431 SmallVector<TemplateArgument, 2> TemplateArgs; 4432 if (ImportTemplateArguments(D->getTemplateArgs().data(), 4433 D->getTemplateArgs().size(), TemplateArgs)) 4434 return nullptr; 4435 4436 // Try to find an existing specialization with these template arguments. 4437 void *InsertPos = nullptr; 4438 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 4439 TemplateArgs, InsertPos); 4440 if (D2) { 4441 // We already have a variable template specialization with these template 4442 // arguments. 4443 4444 // FIXME: Check for specialization vs. instantiation errors. 4445 4446 if (VarDecl *FoundDef = D2->getDefinition()) { 4447 if (!D->isThisDeclarationADefinition() || 4448 IsStructuralMatch(D, FoundDef)) { 4449 // The record types structurally match, or the "from" translation 4450 // unit only had a forward declaration anyway; call it the same 4451 // variable. 4452 return Importer.Imported(D, FoundDef); 4453 } 4454 } 4455 } else { 4456 // Import the type. 4457 QualType T = Importer.Import(D->getType()); 4458 if (T.isNull()) 4459 return nullptr; 4460 4461 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 4462 if (D->getTypeSourceInfo() && !TInfo) 4463 return nullptr; 4464 4465 TemplateArgumentListInfo ToTAInfo; 4466 if (ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo)) 4467 return nullptr; 4468 4469 using PartVarSpecDecl = VarTemplatePartialSpecializationDecl; 4470 // Create a new specialization. 4471 if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) { 4472 // Import TemplateArgumentListInfo 4473 TemplateArgumentListInfo ArgInfos; 4474 const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten(); 4475 // NOTE: FromTAArgsAsWritten and template parameter list are non-null. 4476 if (ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos)) 4477 return nullptr; 4478 4479 TemplateParameterList *ToTPList = ImportTemplateParameterList( 4480 FromPartial->getTemplateParameters()); 4481 if (!ToTPList) 4482 return nullptr; 4483 4484 auto *ToPartial = PartVarSpecDecl::Create( 4485 Importer.getToContext(), DC, StartLoc, IdLoc, ToTPList, VarTemplate, 4486 T, TInfo, D->getStorageClass(), TemplateArgs, ArgInfos); 4487 4488 auto *FromInst = FromPartial->getInstantiatedFromMember(); 4489 auto *ToInst = cast_or_null<PartVarSpecDecl>(Importer.Import(FromInst)); 4490 if (FromInst && !ToInst) 4491 return nullptr; 4492 4493 ToPartial->setInstantiatedFromMember(ToInst); 4494 if (FromPartial->isMemberSpecialization()) 4495 ToPartial->setMemberSpecialization(); 4496 4497 D2 = ToPartial; 4498 } else { // Full specialization 4499 D2 = VarTemplateSpecializationDecl::Create( 4500 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo, 4501 D->getStorageClass(), TemplateArgs); 4502 } 4503 4504 SourceLocation POI = D->getPointOfInstantiation(); 4505 if (POI.isValid()) 4506 D2->setPointOfInstantiation(Importer.Import(POI)); 4507 4508 D2->setSpecializationKind(D->getSpecializationKind()); 4509 D2->setTemplateArgsInfo(ToTAInfo); 4510 4511 // Add this specialization to the class template. 4512 VarTemplate->AddSpecialization(D2, InsertPos); 4513 4514 // Import the qualifier, if any. 4515 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 4516 4517 if (D->isConstexpr()) 4518 D2->setConstexpr(true); 4519 4520 // Add the specialization to this context. 4521 D2->setLexicalDeclContext(LexicalDC); 4522 LexicalDC->addDeclInternal(D2); 4523 4524 D2->setAccess(D->getAccess()); 4525 } 4526 4527 Importer.Imported(D, D2); 4528 4529 // NOTE: isThisDeclarationADefinition() can return DeclarationOnly even if 4530 // declaration has initializer. Should this be fixed in the AST?.. Anyway, 4531 // we have to check the declaration for initializer - otherwise, it won't be 4532 // imported. 4533 if ((D->isThisDeclarationADefinition() || D->hasInit()) && 4534 ImportDefinition(D, D2)) 4535 return nullptr; 4536 4537 return D2; 4538 } 4539 4540 Decl *ASTNodeImporter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 4541 DeclContext *DC, *LexicalDC; 4542 DeclarationName Name; 4543 SourceLocation Loc; 4544 NamedDecl *ToD; 4545 4546 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4547 return nullptr; 4548 4549 if (ToD) 4550 return ToD; 4551 4552 // Try to find a function in our own ("to") context with the same name, same 4553 // type, and in the same context as the function we're importing. 4554 if (!LexicalDC->isFunctionOrMethod()) { 4555 unsigned IDNS = Decl::IDNS_Ordinary; 4556 SmallVector<NamedDecl *, 2> FoundDecls; 4557 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4558 for (auto *FoundDecl : FoundDecls) { 4559 if (!FoundDecl->isInIdentifierNamespace(IDNS)) 4560 continue; 4561 4562 if (auto *FoundFunction = dyn_cast<FunctionTemplateDecl>(FoundDecl)) { 4563 if (FoundFunction->hasExternalFormalLinkage() && 4564 D->hasExternalFormalLinkage()) { 4565 if (IsStructuralMatch(D, FoundFunction)) { 4566 Importer.Imported(D, FoundFunction); 4567 // FIXME: Actually try to merge the body and other attributes. 4568 return FoundFunction; 4569 } 4570 } 4571 } 4572 } 4573 } 4574 4575 TemplateParameterList *Params = 4576 ImportTemplateParameterList(D->getTemplateParameters()); 4577 if (!Params) 4578 return nullptr; 4579 4580 auto *TemplatedFD = 4581 cast_or_null<FunctionDecl>(Importer.Import(D->getTemplatedDecl())); 4582 if (!TemplatedFD) 4583 return nullptr; 4584 4585 FunctionTemplateDecl *ToFunc = FunctionTemplateDecl::Create( 4586 Importer.getToContext(), DC, Loc, Name, Params, TemplatedFD); 4587 4588 TemplatedFD->setDescribedFunctionTemplate(ToFunc); 4589 ToFunc->setAccess(D->getAccess()); 4590 ToFunc->setLexicalDeclContext(LexicalDC); 4591 Importer.Imported(D, ToFunc); 4592 4593 LexicalDC->addDeclInternal(ToFunc); 4594 return ToFunc; 4595 } 4596 4597 //---------------------------------------------------------------------------- 4598 // Import Statements 4599 //---------------------------------------------------------------------------- 4600 4601 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) { 4602 if (DG.isNull()) 4603 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 4604 size_t NumDecls = DG.end() - DG.begin(); 4605 SmallVector<Decl *, 1> ToDecls(NumDecls); 4606 auto &_Importer = this->Importer; 4607 std::transform(DG.begin(), DG.end(), ToDecls.begin(), 4608 [&_Importer](Decl *D) -> Decl * { 4609 return _Importer.Import(D); 4610 }); 4611 return DeclGroupRef::Create(Importer.getToContext(), 4612 ToDecls.begin(), 4613 NumDecls); 4614 } 4615 4616 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) { 4617 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node) 4618 << S->getStmtClassName(); 4619 return nullptr; 4620 } 4621 4622 Stmt *ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) { 4623 SmallVector<IdentifierInfo *, 4> Names; 4624 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 4625 IdentifierInfo *ToII = Importer.Import(S->getOutputIdentifier(I)); 4626 // ToII is nullptr when no symbolic name is given for output operand 4627 // see ParseStmtAsm::ParseAsmOperandsOpt 4628 if (!ToII && S->getOutputIdentifier(I)) 4629 return nullptr; 4630 Names.push_back(ToII); 4631 } 4632 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 4633 IdentifierInfo *ToII = Importer.Import(S->getInputIdentifier(I)); 4634 // ToII is nullptr when no symbolic name is given for input operand 4635 // see ParseStmtAsm::ParseAsmOperandsOpt 4636 if (!ToII && S->getInputIdentifier(I)) 4637 return nullptr; 4638 Names.push_back(ToII); 4639 } 4640 4641 SmallVector<StringLiteral *, 4> Clobbers; 4642 for (unsigned I = 0, E = S->getNumClobbers(); I != E; I++) { 4643 auto *Clobber = cast_or_null<StringLiteral>( 4644 Importer.Import(S->getClobberStringLiteral(I))); 4645 if (!Clobber) 4646 return nullptr; 4647 Clobbers.push_back(Clobber); 4648 } 4649 4650 SmallVector<StringLiteral *, 4> Constraints; 4651 for (unsigned I = 0, E = S->getNumOutputs(); I != E; I++) { 4652 auto *Output = cast_or_null<StringLiteral>( 4653 Importer.Import(S->getOutputConstraintLiteral(I))); 4654 if (!Output) 4655 return nullptr; 4656 Constraints.push_back(Output); 4657 } 4658 4659 for (unsigned I = 0, E = S->getNumInputs(); I != E; I++) { 4660 auto *Input = cast_or_null<StringLiteral>( 4661 Importer.Import(S->getInputConstraintLiteral(I))); 4662 if (!Input) 4663 return nullptr; 4664 Constraints.push_back(Input); 4665 } 4666 4667 SmallVector<Expr *, 4> Exprs(S->getNumOutputs() + S->getNumInputs()); 4668 if (ImportContainerChecked(S->outputs(), Exprs)) 4669 return nullptr; 4670 4671 if (ImportArrayChecked(S->inputs(), Exprs.begin() + S->getNumOutputs())) 4672 return nullptr; 4673 4674 auto *AsmStr = cast_or_null<StringLiteral>( 4675 Importer.Import(S->getAsmString())); 4676 if (!AsmStr) 4677 return nullptr; 4678 4679 return new (Importer.getToContext()) GCCAsmStmt( 4680 Importer.getToContext(), 4681 Importer.Import(S->getAsmLoc()), 4682 S->isSimple(), 4683 S->isVolatile(), 4684 S->getNumOutputs(), 4685 S->getNumInputs(), 4686 Names.data(), 4687 Constraints.data(), 4688 Exprs.data(), 4689 AsmStr, 4690 S->getNumClobbers(), 4691 Clobbers.data(), 4692 Importer.Import(S->getRParenLoc())); 4693 } 4694 4695 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 4696 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup()); 4697 for (auto *ToD : ToDG) { 4698 if (!ToD) 4699 return nullptr; 4700 } 4701 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc()); 4702 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc()); 4703 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc); 4704 } 4705 4706 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) { 4707 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc()); 4708 return new (Importer.getToContext()) NullStmt(ToSemiLoc, 4709 S->hasLeadingEmptyMacro()); 4710 } 4711 4712 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 4713 SmallVector<Stmt *, 8> ToStmts(S->size()); 4714 4715 if (ImportContainerChecked(S->body(), ToStmts)) 4716 return nullptr; 4717 4718 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc()); 4719 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc()); 4720 return CompoundStmt::Create(Importer.getToContext(), ToStmts, ToLBraceLoc, 4721 ToRBraceLoc); 4722 } 4723 4724 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 4725 Expr *ToLHS = Importer.Import(S->getLHS()); 4726 if (!ToLHS) 4727 return nullptr; 4728 Expr *ToRHS = Importer.Import(S->getRHS()); 4729 if (!ToRHS && S->getRHS()) 4730 return nullptr; 4731 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4732 if (!ToSubStmt && S->getSubStmt()) 4733 return nullptr; 4734 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc()); 4735 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc()); 4736 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4737 auto *ToStmt = new (Importer.getToContext()) 4738 CaseStmt(ToLHS, ToRHS, ToCaseLoc, ToEllipsisLoc, ToColonLoc); 4739 ToStmt->setSubStmt(ToSubStmt); 4740 return ToStmt; 4741 } 4742 4743 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 4744 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc()); 4745 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4746 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4747 if (!ToSubStmt && S->getSubStmt()) 4748 return nullptr; 4749 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc, 4750 ToSubStmt); 4751 } 4752 4753 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 4754 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc()); 4755 auto *ToLabelDecl = cast_or_null<LabelDecl>(Importer.Import(S->getDecl())); 4756 if (!ToLabelDecl && S->getDecl()) 4757 return nullptr; 4758 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4759 if (!ToSubStmt && S->getSubStmt()) 4760 return nullptr; 4761 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl, 4762 ToSubStmt); 4763 } 4764 4765 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 4766 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc()); 4767 ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 4768 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 4769 if (ImportContainerChecked(FromAttrs, ToAttrs)) 4770 return nullptr; 4771 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4772 if (!ToSubStmt && S->getSubStmt()) 4773 return nullptr; 4774 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc, 4775 ToAttrs, ToSubStmt); 4776 } 4777 4778 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) { 4779 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc()); 4780 Stmt *ToInit = Importer.Import(S->getInit()); 4781 if (!ToInit && S->getInit()) 4782 return nullptr; 4783 VarDecl *ToConditionVariable = nullptr; 4784 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4785 ToConditionVariable = 4786 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4787 if (!ToConditionVariable) 4788 return nullptr; 4789 } 4790 Expr *ToCondition = Importer.Import(S->getCond()); 4791 if (!ToCondition && S->getCond()) 4792 return nullptr; 4793 Stmt *ToThenStmt = Importer.Import(S->getThen()); 4794 if (!ToThenStmt && S->getThen()) 4795 return nullptr; 4796 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc()); 4797 Stmt *ToElseStmt = Importer.Import(S->getElse()); 4798 if (!ToElseStmt && S->getElse()) 4799 return nullptr; 4800 return new (Importer.getToContext()) IfStmt(Importer.getToContext(), 4801 ToIfLoc, S->isConstexpr(), 4802 ToInit, 4803 ToConditionVariable, 4804 ToCondition, ToThenStmt, 4805 ToElseLoc, ToElseStmt); 4806 } 4807 4808 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 4809 Stmt *ToInit = Importer.Import(S->getInit()); 4810 if (!ToInit && S->getInit()) 4811 return nullptr; 4812 VarDecl *ToConditionVariable = nullptr; 4813 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4814 ToConditionVariable = 4815 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4816 if (!ToConditionVariable) 4817 return nullptr; 4818 } 4819 Expr *ToCondition = Importer.Import(S->getCond()); 4820 if (!ToCondition && S->getCond()) 4821 return nullptr; 4822 auto *ToStmt = new (Importer.getToContext()) SwitchStmt( 4823 Importer.getToContext(), ToInit, 4824 ToConditionVariable, ToCondition); 4825 Stmt *ToBody = Importer.Import(S->getBody()); 4826 if (!ToBody && S->getBody()) 4827 return nullptr; 4828 ToStmt->setBody(ToBody); 4829 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc())); 4830 // Now we have to re-chain the cases. 4831 SwitchCase *LastChainedSwitchCase = nullptr; 4832 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 4833 SC = SC->getNextSwitchCase()) { 4834 auto *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC)); 4835 if (!ToSC) 4836 return nullptr; 4837 if (LastChainedSwitchCase) 4838 LastChainedSwitchCase->setNextSwitchCase(ToSC); 4839 else 4840 ToStmt->setSwitchCaseList(ToSC); 4841 LastChainedSwitchCase = ToSC; 4842 } 4843 return ToStmt; 4844 } 4845 4846 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 4847 VarDecl *ToConditionVariable = nullptr; 4848 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4849 ToConditionVariable = 4850 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4851 if (!ToConditionVariable) 4852 return nullptr; 4853 } 4854 Expr *ToCondition = Importer.Import(S->getCond()); 4855 if (!ToCondition && S->getCond()) 4856 return nullptr; 4857 Stmt *ToBody = Importer.Import(S->getBody()); 4858 if (!ToBody && S->getBody()) 4859 return nullptr; 4860 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4861 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(), 4862 ToConditionVariable, 4863 ToCondition, ToBody, 4864 ToWhileLoc); 4865 } 4866 4867 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) { 4868 Stmt *ToBody = Importer.Import(S->getBody()); 4869 if (!ToBody && S->getBody()) 4870 return nullptr; 4871 Expr *ToCondition = Importer.Import(S->getCond()); 4872 if (!ToCondition && S->getCond()) 4873 return nullptr; 4874 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc()); 4875 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4876 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4877 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition, 4878 ToDoLoc, ToWhileLoc, 4879 ToRParenLoc); 4880 } 4881 4882 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) { 4883 Stmt *ToInit = Importer.Import(S->getInit()); 4884 if (!ToInit && S->getInit()) 4885 return nullptr; 4886 Expr *ToCondition = Importer.Import(S->getCond()); 4887 if (!ToCondition && S->getCond()) 4888 return nullptr; 4889 VarDecl *ToConditionVariable = nullptr; 4890 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4891 ToConditionVariable = 4892 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4893 if (!ToConditionVariable) 4894 return nullptr; 4895 } 4896 Expr *ToInc = Importer.Import(S->getInc()); 4897 if (!ToInc && S->getInc()) 4898 return nullptr; 4899 Stmt *ToBody = Importer.Import(S->getBody()); 4900 if (!ToBody && S->getBody()) 4901 return nullptr; 4902 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4903 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc()); 4904 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4905 return new (Importer.getToContext()) ForStmt(Importer.getToContext(), 4906 ToInit, ToCondition, 4907 ToConditionVariable, 4908 ToInc, ToBody, 4909 ToForLoc, ToLParenLoc, 4910 ToRParenLoc); 4911 } 4912 4913 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 4914 LabelDecl *ToLabel = nullptr; 4915 if (LabelDecl *FromLabel = S->getLabel()) { 4916 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel)); 4917 if (!ToLabel) 4918 return nullptr; 4919 } 4920 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4921 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc()); 4922 return new (Importer.getToContext()) GotoStmt(ToLabel, 4923 ToGotoLoc, ToLabelLoc); 4924 } 4925 4926 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 4927 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4928 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc()); 4929 Expr *ToTarget = Importer.Import(S->getTarget()); 4930 if (!ToTarget && S->getTarget()) 4931 return nullptr; 4932 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc, 4933 ToTarget); 4934 } 4935 4936 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 4937 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc()); 4938 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc); 4939 } 4940 4941 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 4942 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc()); 4943 return new (Importer.getToContext()) BreakStmt(ToBreakLoc); 4944 } 4945 4946 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 4947 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc()); 4948 Expr *ToRetExpr = Importer.Import(S->getRetValue()); 4949 if (!ToRetExpr && S->getRetValue()) 4950 return nullptr; 4951 auto *NRVOCandidate = const_cast<VarDecl *>(S->getNRVOCandidate()); 4952 auto *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate)); 4953 if (!ToNRVOCandidate && NRVOCandidate) 4954 return nullptr; 4955 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr, 4956 ToNRVOCandidate); 4957 } 4958 4959 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 4960 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc()); 4961 VarDecl *ToExceptionDecl = nullptr; 4962 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) { 4963 ToExceptionDecl = 4964 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4965 if (!ToExceptionDecl) 4966 return nullptr; 4967 } 4968 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock()); 4969 if (!ToHandlerBlock && S->getHandlerBlock()) 4970 return nullptr; 4971 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc, 4972 ToExceptionDecl, 4973 ToHandlerBlock); 4974 } 4975 4976 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 4977 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc()); 4978 Stmt *ToTryBlock = Importer.Import(S->getTryBlock()); 4979 if (!ToTryBlock && S->getTryBlock()) 4980 return nullptr; 4981 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 4982 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 4983 CXXCatchStmt *FromHandler = S->getHandler(HI); 4984 if (Stmt *ToHandler = Importer.Import(FromHandler)) 4985 ToHandlers[HI] = ToHandler; 4986 else 4987 return nullptr; 4988 } 4989 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock, 4990 ToHandlers); 4991 } 4992 4993 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 4994 auto *ToRange = 4995 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt())); 4996 if (!ToRange && S->getRangeStmt()) 4997 return nullptr; 4998 auto *ToBegin = 4999 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginStmt())); 5000 if (!ToBegin && S->getBeginStmt()) 5001 return nullptr; 5002 auto *ToEnd = 5003 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getEndStmt())); 5004 if (!ToEnd && S->getEndStmt()) 5005 return nullptr; 5006 Expr *ToCond = Importer.Import(S->getCond()); 5007 if (!ToCond && S->getCond()) 5008 return nullptr; 5009 Expr *ToInc = Importer.Import(S->getInc()); 5010 if (!ToInc && S->getInc()) 5011 return nullptr; 5012 auto *ToLoopVar = 5013 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt())); 5014 if (!ToLoopVar && S->getLoopVarStmt()) 5015 return nullptr; 5016 Stmt *ToBody = Importer.Import(S->getBody()); 5017 if (!ToBody && S->getBody()) 5018 return nullptr; 5019 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 5020 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc()); 5021 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 5022 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 5023 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBegin, ToEnd, 5024 ToCond, ToInc, 5025 ToLoopVar, ToBody, 5026 ToForLoc, ToCoawaitLoc, 5027 ToColonLoc, ToRParenLoc); 5028 } 5029 5030 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 5031 Stmt *ToElem = Importer.Import(S->getElement()); 5032 if (!ToElem && S->getElement()) 5033 return nullptr; 5034 Expr *ToCollect = Importer.Import(S->getCollection()); 5035 if (!ToCollect && S->getCollection()) 5036 return nullptr; 5037 Stmt *ToBody = Importer.Import(S->getBody()); 5038 if (!ToBody && S->getBody()) 5039 return nullptr; 5040 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 5041 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 5042 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem, 5043 ToCollect, 5044 ToBody, ToForLoc, 5045 ToRParenLoc); 5046 } 5047 5048 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 5049 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc()); 5050 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 5051 VarDecl *ToExceptionDecl = nullptr; 5052 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) { 5053 ToExceptionDecl = 5054 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 5055 if (!ToExceptionDecl) 5056 return nullptr; 5057 } 5058 Stmt *ToBody = Importer.Import(S->getCatchBody()); 5059 if (!ToBody && S->getCatchBody()) 5060 return nullptr; 5061 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc, 5062 ToRParenLoc, 5063 ToExceptionDecl, 5064 ToBody); 5065 } 5066 5067 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 5068 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc()); 5069 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody()); 5070 if (!ToAtFinallyStmt && S->getFinallyBody()) 5071 return nullptr; 5072 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc, 5073 ToAtFinallyStmt); 5074 } 5075 5076 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 5077 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc()); 5078 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody()); 5079 if (!ToAtTryStmt && S->getTryBody()) 5080 return nullptr; 5081 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 5082 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 5083 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 5084 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt)) 5085 ToCatchStmts[CI] = ToCatchStmt; 5086 else 5087 return nullptr; 5088 } 5089 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt()); 5090 if (!ToAtFinallyStmt && S->getFinallyStmt()) 5091 return nullptr; 5092 return ObjCAtTryStmt::Create(Importer.getToContext(), 5093 ToAtTryLoc, ToAtTryStmt, 5094 ToCatchStmts.begin(), ToCatchStmts.size(), 5095 ToAtFinallyStmt); 5096 } 5097 5098 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt 5099 (ObjCAtSynchronizedStmt *S) { 5100 SourceLocation ToAtSynchronizedLoc = 5101 Importer.Import(S->getAtSynchronizedLoc()); 5102 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr()); 5103 if (!ToSynchExpr && S->getSynchExpr()) 5104 return nullptr; 5105 Stmt *ToSynchBody = Importer.Import(S->getSynchBody()); 5106 if (!ToSynchBody && S->getSynchBody()) 5107 return nullptr; 5108 return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 5109 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 5110 } 5111 5112 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5113 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc()); 5114 Expr *ToThrow = Importer.Import(S->getThrowExpr()); 5115 if (!ToThrow && S->getThrowExpr()) 5116 return nullptr; 5117 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow); 5118 } 5119 5120 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt 5121 (ObjCAutoreleasePoolStmt *S) { 5122 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc()); 5123 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 5124 if (!ToSubStmt && S->getSubStmt()) 5125 return nullptr; 5126 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc, 5127 ToSubStmt); 5128 } 5129 5130 //---------------------------------------------------------------------------- 5131 // Import Expressions 5132 //---------------------------------------------------------------------------- 5133 Expr *ASTNodeImporter::VisitExpr(Expr *E) { 5134 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node) 5135 << E->getStmtClassName(); 5136 return nullptr; 5137 } 5138 5139 Expr *ASTNodeImporter::VisitVAArgExpr(VAArgExpr *E) { 5140 QualType T = Importer.Import(E->getType()); 5141 if (T.isNull()) 5142 return nullptr; 5143 5144 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5145 if (!SubExpr && E->getSubExpr()) 5146 return nullptr; 5147 5148 TypeSourceInfo *TInfo = Importer.Import(E->getWrittenTypeInfo()); 5149 if (!TInfo) 5150 return nullptr; 5151 5152 return new (Importer.getToContext()) VAArgExpr( 5153 Importer.Import(E->getBuiltinLoc()), SubExpr, TInfo, 5154 Importer.Import(E->getRParenLoc()), T, E->isMicrosoftABI()); 5155 } 5156 5157 Expr *ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) { 5158 QualType T = Importer.Import(E->getType()); 5159 if (T.isNull()) 5160 return nullptr; 5161 5162 return new (Importer.getToContext()) GNUNullExpr( 5163 T, Importer.Import(E->getLocStart())); 5164 } 5165 5166 Expr *ASTNodeImporter::VisitPredefinedExpr(PredefinedExpr *E) { 5167 QualType T = Importer.Import(E->getType()); 5168 if (T.isNull()) 5169 return nullptr; 5170 5171 auto *SL = cast_or_null<StringLiteral>(Importer.Import(E->getFunctionName())); 5172 if (!SL && E->getFunctionName()) 5173 return nullptr; 5174 5175 return new (Importer.getToContext()) PredefinedExpr( 5176 Importer.Import(E->getLocStart()), T, E->getIdentType(), SL); 5177 } 5178 5179 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 5180 auto *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl())); 5181 if (!ToD) 5182 return nullptr; 5183 5184 NamedDecl *FoundD = nullptr; 5185 if (E->getDecl() != E->getFoundDecl()) { 5186 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl())); 5187 if (!FoundD) 5188 return nullptr; 5189 } 5190 5191 QualType T = Importer.Import(E->getType()); 5192 if (T.isNull()) 5193 return nullptr; 5194 5195 TemplateArgumentListInfo ToTAInfo; 5196 TemplateArgumentListInfo *ResInfo = nullptr; 5197 if (E->hasExplicitTemplateArgs()) { 5198 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 5199 return nullptr; 5200 ResInfo = &ToTAInfo; 5201 } 5202 5203 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(), 5204 Importer.Import(E->getQualifierLoc()), 5205 Importer.Import(E->getTemplateKeywordLoc()), 5206 ToD, 5207 E->refersToEnclosingVariableOrCapture(), 5208 Importer.Import(E->getLocation()), 5209 T, E->getValueKind(), 5210 FoundD, ResInfo); 5211 if (E->hadMultipleCandidates()) 5212 DRE->setHadMultipleCandidates(true); 5213 return DRE; 5214 } 5215 5216 Expr *ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 5217 QualType T = Importer.Import(E->getType()); 5218 if (T.isNull()) 5219 return nullptr; 5220 5221 return new (Importer.getToContext()) ImplicitValueInitExpr(T); 5222 } 5223 5224 ASTNodeImporter::Designator 5225 ASTNodeImporter::ImportDesignator(const Designator &D) { 5226 if (D.isFieldDesignator()) { 5227 IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName()); 5228 // Caller checks for import error 5229 return Designator(ToFieldName, Importer.Import(D.getDotLoc()), 5230 Importer.Import(D.getFieldLoc())); 5231 } 5232 if (D.isArrayDesignator()) 5233 return Designator(D.getFirstExprIndex(), 5234 Importer.Import(D.getLBracketLoc()), 5235 Importer.Import(D.getRBracketLoc())); 5236 5237 assert(D.isArrayRangeDesignator()); 5238 return Designator(D.getFirstExprIndex(), 5239 Importer.Import(D.getLBracketLoc()), 5240 Importer.Import(D.getEllipsisLoc()), 5241 Importer.Import(D.getRBracketLoc())); 5242 } 5243 5244 5245 Expr *ASTNodeImporter::VisitDesignatedInitExpr(DesignatedInitExpr *DIE) { 5246 auto *Init = cast_or_null<Expr>(Importer.Import(DIE->getInit())); 5247 if (!Init) 5248 return nullptr; 5249 5250 SmallVector<Expr *, 4> IndexExprs(DIE->getNumSubExprs() - 1); 5251 // List elements from the second, the first is Init itself 5252 for (unsigned I = 1, E = DIE->getNumSubExprs(); I < E; I++) { 5253 if (auto *Arg = cast_or_null<Expr>(Importer.Import(DIE->getSubExpr(I)))) 5254 IndexExprs[I - 1] = Arg; 5255 else 5256 return nullptr; 5257 } 5258 5259 SmallVector<Designator, 4> Designators(DIE->size()); 5260 llvm::transform(DIE->designators(), Designators.begin(), 5261 [this](const Designator &D) -> Designator { 5262 return ImportDesignator(D); 5263 }); 5264 5265 for (const auto &D : DIE->designators()) 5266 if (D.isFieldDesignator() && !D.getFieldName()) 5267 return nullptr; 5268 5269 return DesignatedInitExpr::Create( 5270 Importer.getToContext(), Designators, 5271 IndexExprs, Importer.Import(DIE->getEqualOrColonLoc()), 5272 DIE->usesGNUSyntax(), Init); 5273 } 5274 5275 Expr *ASTNodeImporter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) { 5276 QualType T = Importer.Import(E->getType()); 5277 if (T.isNull()) 5278 return nullptr; 5279 5280 return new (Importer.getToContext()) 5281 CXXNullPtrLiteralExpr(T, Importer.Import(E->getLocation())); 5282 } 5283 5284 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 5285 QualType T = Importer.Import(E->getType()); 5286 if (T.isNull()) 5287 return nullptr; 5288 5289 return IntegerLiteral::Create(Importer.getToContext(), 5290 E->getValue(), T, 5291 Importer.Import(E->getLocation())); 5292 } 5293 5294 Expr *ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) { 5295 QualType T = Importer.Import(E->getType()); 5296 if (T.isNull()) 5297 return nullptr; 5298 5299 return FloatingLiteral::Create(Importer.getToContext(), 5300 E->getValue(), E->isExact(), T, 5301 Importer.Import(E->getLocation())); 5302 } 5303 5304 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 5305 QualType T = Importer.Import(E->getType()); 5306 if (T.isNull()) 5307 return nullptr; 5308 5309 return new (Importer.getToContext()) CharacterLiteral(E->getValue(), 5310 E->getKind(), T, 5311 Importer.Import(E->getLocation())); 5312 } 5313 5314 Expr *ASTNodeImporter::VisitStringLiteral(StringLiteral *E) { 5315 QualType T = Importer.Import(E->getType()); 5316 if (T.isNull()) 5317 return nullptr; 5318 5319 SmallVector<SourceLocation, 4> Locations(E->getNumConcatenated()); 5320 ImportArray(E->tokloc_begin(), E->tokloc_end(), Locations.begin()); 5321 5322 return StringLiteral::Create(Importer.getToContext(), E->getBytes(), 5323 E->getKind(), E->isPascal(), T, 5324 Locations.data(), Locations.size()); 5325 } 5326 5327 Expr *ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 5328 QualType T = Importer.Import(E->getType()); 5329 if (T.isNull()) 5330 return nullptr; 5331 5332 TypeSourceInfo *TInfo = Importer.Import(E->getTypeSourceInfo()); 5333 if (!TInfo) 5334 return nullptr; 5335 5336 Expr *Init = Importer.Import(E->getInitializer()); 5337 if (!Init) 5338 return nullptr; 5339 5340 return new (Importer.getToContext()) CompoundLiteralExpr( 5341 Importer.Import(E->getLParenLoc()), TInfo, T, E->getValueKind(), 5342 Init, E->isFileScope()); 5343 } 5344 5345 Expr *ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) { 5346 QualType T = Importer.Import(E->getType()); 5347 if (T.isNull()) 5348 return nullptr; 5349 5350 SmallVector<Expr *, 6> Exprs(E->getNumSubExprs()); 5351 if (ImportArrayChecked( 5352 E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(), 5353 Exprs.begin())) 5354 return nullptr; 5355 5356 return new (Importer.getToContext()) AtomicExpr( 5357 Importer.Import(E->getBuiltinLoc()), Exprs, T, E->getOp(), 5358 Importer.Import(E->getRParenLoc())); 5359 } 5360 5361 Expr *ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) { 5362 QualType T = Importer.Import(E->getType()); 5363 if (T.isNull()) 5364 return nullptr; 5365 5366 auto *ToLabel = cast_or_null<LabelDecl>(Importer.Import(E->getLabel())); 5367 if (!ToLabel) 5368 return nullptr; 5369 5370 return new (Importer.getToContext()) AddrLabelExpr( 5371 Importer.Import(E->getAmpAmpLoc()), Importer.Import(E->getLabelLoc()), 5372 ToLabel, T); 5373 } 5374 5375 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 5376 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5377 if (!SubExpr) 5378 return nullptr; 5379 5380 return new (Importer.getToContext()) 5381 ParenExpr(Importer.Import(E->getLParen()), 5382 Importer.Import(E->getRParen()), 5383 SubExpr); 5384 } 5385 5386 Expr *ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) { 5387 SmallVector<Expr *, 4> Exprs(E->getNumExprs()); 5388 if (ImportContainerChecked(E->exprs(), Exprs)) 5389 return nullptr; 5390 5391 return new (Importer.getToContext()) ParenListExpr( 5392 Importer.getToContext(), Importer.Import(E->getLParenLoc()), 5393 Exprs, Importer.Import(E->getLParenLoc())); 5394 } 5395 5396 Expr *ASTNodeImporter::VisitStmtExpr(StmtExpr *E) { 5397 QualType T = Importer.Import(E->getType()); 5398 if (T.isNull()) 5399 return nullptr; 5400 5401 auto *ToSubStmt = cast_or_null<CompoundStmt>( 5402 Importer.Import(E->getSubStmt())); 5403 if (!ToSubStmt && E->getSubStmt()) 5404 return nullptr; 5405 5406 return new (Importer.getToContext()) StmtExpr(ToSubStmt, T, 5407 Importer.Import(E->getLParenLoc()), Importer.Import(E->getRParenLoc())); 5408 } 5409 5410 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 5411 QualType T = Importer.Import(E->getType()); 5412 if (T.isNull()) 5413 return nullptr; 5414 5415 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5416 if (!SubExpr) 5417 return nullptr; 5418 5419 return new (Importer.getToContext()) UnaryOperator( 5420 SubExpr, E->getOpcode(), T, E->getValueKind(), E->getObjectKind(), 5421 Importer.Import(E->getOperatorLoc()), E->canOverflow()); 5422 } 5423 5424 Expr * 5425 ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { 5426 QualType ResultType = Importer.Import(E->getType()); 5427 5428 if (E->isArgumentType()) { 5429 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo()); 5430 if (!TInfo) 5431 return nullptr; 5432 5433 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5434 TInfo, ResultType, 5435 Importer.Import(E->getOperatorLoc()), 5436 Importer.Import(E->getRParenLoc())); 5437 } 5438 5439 Expr *SubExpr = Importer.Import(E->getArgumentExpr()); 5440 if (!SubExpr) 5441 return nullptr; 5442 5443 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5444 SubExpr, ResultType, 5445 Importer.Import(E->getOperatorLoc()), 5446 Importer.Import(E->getRParenLoc())); 5447 } 5448 5449 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 5450 QualType T = Importer.Import(E->getType()); 5451 if (T.isNull()) 5452 return nullptr; 5453 5454 Expr *LHS = Importer.Import(E->getLHS()); 5455 if (!LHS) 5456 return nullptr; 5457 5458 Expr *RHS = Importer.Import(E->getRHS()); 5459 if (!RHS) 5460 return nullptr; 5461 5462 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(), 5463 T, E->getValueKind(), 5464 E->getObjectKind(), 5465 Importer.Import(E->getOperatorLoc()), 5466 E->getFPFeatures()); 5467 } 5468 5469 Expr *ASTNodeImporter::VisitConditionalOperator(ConditionalOperator *E) { 5470 QualType T = Importer.Import(E->getType()); 5471 if (T.isNull()) 5472 return nullptr; 5473 5474 Expr *ToLHS = Importer.Import(E->getLHS()); 5475 if (!ToLHS) 5476 return nullptr; 5477 5478 Expr *ToRHS = Importer.Import(E->getRHS()); 5479 if (!ToRHS) 5480 return nullptr; 5481 5482 Expr *ToCond = Importer.Import(E->getCond()); 5483 if (!ToCond) 5484 return nullptr; 5485 5486 return new (Importer.getToContext()) ConditionalOperator( 5487 ToCond, Importer.Import(E->getQuestionLoc()), 5488 ToLHS, Importer.Import(E->getColonLoc()), 5489 ToRHS, T, E->getValueKind(), E->getObjectKind()); 5490 } 5491 5492 Expr *ASTNodeImporter::VisitBinaryConditionalOperator( 5493 BinaryConditionalOperator *E) { 5494 QualType T = Importer.Import(E->getType()); 5495 if (T.isNull()) 5496 return nullptr; 5497 5498 Expr *Common = Importer.Import(E->getCommon()); 5499 if (!Common) 5500 return nullptr; 5501 5502 Expr *Cond = Importer.Import(E->getCond()); 5503 if (!Cond) 5504 return nullptr; 5505 5506 auto *OpaqueValue = cast_or_null<OpaqueValueExpr>( 5507 Importer.Import(E->getOpaqueValue())); 5508 if (!OpaqueValue) 5509 return nullptr; 5510 5511 Expr *TrueExpr = Importer.Import(E->getTrueExpr()); 5512 if (!TrueExpr) 5513 return nullptr; 5514 5515 Expr *FalseExpr = Importer.Import(E->getFalseExpr()); 5516 if (!FalseExpr) 5517 return nullptr; 5518 5519 return new (Importer.getToContext()) BinaryConditionalOperator( 5520 Common, OpaqueValue, Cond, TrueExpr, FalseExpr, 5521 Importer.Import(E->getQuestionLoc()), Importer.Import(E->getColonLoc()), 5522 T, E->getValueKind(), E->getObjectKind()); 5523 } 5524 5525 Expr *ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 5526 QualType T = Importer.Import(E->getType()); 5527 if (T.isNull()) 5528 return nullptr; 5529 5530 TypeSourceInfo *ToQueried = Importer.Import(E->getQueriedTypeSourceInfo()); 5531 if (!ToQueried) 5532 return nullptr; 5533 5534 Expr *Dim = Importer.Import(E->getDimensionExpression()); 5535 if (!Dim && E->getDimensionExpression()) 5536 return nullptr; 5537 5538 return new (Importer.getToContext()) ArrayTypeTraitExpr( 5539 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 5540 E->getValue(), Dim, Importer.Import(E->getLocEnd()), T); 5541 } 5542 5543 Expr *ASTNodeImporter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 5544 QualType T = Importer.Import(E->getType()); 5545 if (T.isNull()) 5546 return nullptr; 5547 5548 Expr *ToQueried = Importer.Import(E->getQueriedExpression()); 5549 if (!ToQueried) 5550 return nullptr; 5551 5552 return new (Importer.getToContext()) ExpressionTraitExpr( 5553 Importer.Import(E->getLocStart()), E->getTrait(), ToQueried, 5554 E->getValue(), Importer.Import(E->getLocEnd()), T); 5555 } 5556 5557 Expr *ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) { 5558 QualType T = Importer.Import(E->getType()); 5559 if (T.isNull()) 5560 return nullptr; 5561 5562 Expr *SourceExpr = Importer.Import(E->getSourceExpr()); 5563 if (!SourceExpr && E->getSourceExpr()) 5564 return nullptr; 5565 5566 return new (Importer.getToContext()) OpaqueValueExpr( 5567 Importer.Import(E->getLocation()), T, E->getValueKind(), 5568 E->getObjectKind(), SourceExpr); 5569 } 5570 5571 Expr *ASTNodeImporter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 5572 QualType T = Importer.Import(E->getType()); 5573 if (T.isNull()) 5574 return nullptr; 5575 5576 Expr *ToLHS = Importer.Import(E->getLHS()); 5577 if (!ToLHS) 5578 return nullptr; 5579 5580 Expr *ToRHS = Importer.Import(E->getRHS()); 5581 if (!ToRHS) 5582 return nullptr; 5583 5584 return new (Importer.getToContext()) ArraySubscriptExpr( 5585 ToLHS, ToRHS, T, E->getValueKind(), E->getObjectKind(), 5586 Importer.Import(E->getRBracketLoc())); 5587 } 5588 5589 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 5590 QualType T = Importer.Import(E->getType()); 5591 if (T.isNull()) 5592 return nullptr; 5593 5594 QualType CompLHSType = Importer.Import(E->getComputationLHSType()); 5595 if (CompLHSType.isNull()) 5596 return nullptr; 5597 5598 QualType CompResultType = Importer.Import(E->getComputationResultType()); 5599 if (CompResultType.isNull()) 5600 return nullptr; 5601 5602 Expr *LHS = Importer.Import(E->getLHS()); 5603 if (!LHS) 5604 return nullptr; 5605 5606 Expr *RHS = Importer.Import(E->getRHS()); 5607 if (!RHS) 5608 return nullptr; 5609 5610 return new (Importer.getToContext()) 5611 CompoundAssignOperator(LHS, RHS, E->getOpcode(), 5612 T, E->getValueKind(), 5613 E->getObjectKind(), 5614 CompLHSType, CompResultType, 5615 Importer.Import(E->getOperatorLoc()), 5616 E->getFPFeatures()); 5617 } 5618 5619 bool ASTNodeImporter::ImportCastPath(CastExpr *CE, CXXCastPath &Path) { 5620 for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) { 5621 if (CXXBaseSpecifier *Spec = Importer.Import(*I)) 5622 Path.push_back(Spec); 5623 else 5624 return true; 5625 } 5626 return false; 5627 } 5628 5629 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 5630 QualType T = Importer.Import(E->getType()); 5631 if (T.isNull()) 5632 return nullptr; 5633 5634 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5635 if (!SubExpr) 5636 return nullptr; 5637 5638 CXXCastPath BasePath; 5639 if (ImportCastPath(E, BasePath)) 5640 return nullptr; 5641 5642 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(), 5643 SubExpr, &BasePath, E->getValueKind()); 5644 } 5645 5646 Expr *ASTNodeImporter::VisitExplicitCastExpr(ExplicitCastExpr *E) { 5647 QualType T = Importer.Import(E->getType()); 5648 if (T.isNull()) 5649 return nullptr; 5650 5651 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5652 if (!SubExpr) 5653 return nullptr; 5654 5655 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten()); 5656 if (!TInfo && E->getTypeInfoAsWritten()) 5657 return nullptr; 5658 5659 CXXCastPath BasePath; 5660 if (ImportCastPath(E, BasePath)) 5661 return nullptr; 5662 5663 switch (E->getStmtClass()) { 5664 case Stmt::CStyleCastExprClass: { 5665 auto *CCE = cast<CStyleCastExpr>(E); 5666 return CStyleCastExpr::Create(Importer.getToContext(), T, 5667 E->getValueKind(), E->getCastKind(), 5668 SubExpr, &BasePath, TInfo, 5669 Importer.Import(CCE->getLParenLoc()), 5670 Importer.Import(CCE->getRParenLoc())); 5671 } 5672 5673 case Stmt::CXXFunctionalCastExprClass: { 5674 auto *FCE = cast<CXXFunctionalCastExpr>(E); 5675 return CXXFunctionalCastExpr::Create(Importer.getToContext(), T, 5676 E->getValueKind(), TInfo, 5677 E->getCastKind(), SubExpr, &BasePath, 5678 Importer.Import(FCE->getLParenLoc()), 5679 Importer.Import(FCE->getRParenLoc())); 5680 } 5681 5682 case Stmt::ObjCBridgedCastExprClass: { 5683 auto *OCE = cast<ObjCBridgedCastExpr>(E); 5684 return new (Importer.getToContext()) ObjCBridgedCastExpr( 5685 Importer.Import(OCE->getLParenLoc()), OCE->getBridgeKind(), 5686 E->getCastKind(), Importer.Import(OCE->getBridgeKeywordLoc()), 5687 TInfo, SubExpr); 5688 } 5689 default: 5690 break; // just fall through 5691 } 5692 5693 auto *Named = cast<CXXNamedCastExpr>(E); 5694 SourceLocation ExprLoc = Importer.Import(Named->getOperatorLoc()), 5695 RParenLoc = Importer.Import(Named->getRParenLoc()); 5696 SourceRange Brackets = Importer.Import(Named->getAngleBrackets()); 5697 5698 switch (E->getStmtClass()) { 5699 case Stmt::CXXStaticCastExprClass: 5700 return CXXStaticCastExpr::Create(Importer.getToContext(), T, 5701 E->getValueKind(), E->getCastKind(), 5702 SubExpr, &BasePath, TInfo, 5703 ExprLoc, RParenLoc, Brackets); 5704 5705 case Stmt::CXXDynamicCastExprClass: 5706 return CXXDynamicCastExpr::Create(Importer.getToContext(), T, 5707 E->getValueKind(), E->getCastKind(), 5708 SubExpr, &BasePath, TInfo, 5709 ExprLoc, RParenLoc, Brackets); 5710 5711 case Stmt::CXXReinterpretCastExprClass: 5712 return CXXReinterpretCastExpr::Create(Importer.getToContext(), T, 5713 E->getValueKind(), E->getCastKind(), 5714 SubExpr, &BasePath, TInfo, 5715 ExprLoc, RParenLoc, Brackets); 5716 5717 case Stmt::CXXConstCastExprClass: 5718 return CXXConstCastExpr::Create(Importer.getToContext(), T, 5719 E->getValueKind(), SubExpr, TInfo, ExprLoc, 5720 RParenLoc, Brackets); 5721 default: 5722 llvm_unreachable("Cast expression of unsupported type!"); 5723 return nullptr; 5724 } 5725 } 5726 5727 Expr *ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *OE) { 5728 QualType T = Importer.Import(OE->getType()); 5729 if (T.isNull()) 5730 return nullptr; 5731 5732 SmallVector<OffsetOfNode, 4> Nodes; 5733 for (int I = 0, E = OE->getNumComponents(); I < E; ++I) { 5734 const OffsetOfNode &Node = OE->getComponent(I); 5735 5736 switch (Node.getKind()) { 5737 case OffsetOfNode::Array: 5738 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), 5739 Node.getArrayExprIndex(), 5740 Importer.Import(Node.getLocEnd()))); 5741 break; 5742 5743 case OffsetOfNode::Base: { 5744 CXXBaseSpecifier *BS = Importer.Import(Node.getBase()); 5745 if (!BS && Node.getBase()) 5746 return nullptr; 5747 Nodes.push_back(OffsetOfNode(BS)); 5748 break; 5749 } 5750 case OffsetOfNode::Field: { 5751 auto *FD = cast_or_null<FieldDecl>(Importer.Import(Node.getField())); 5752 if (!FD) 5753 return nullptr; 5754 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), FD, 5755 Importer.Import(Node.getLocEnd()))); 5756 break; 5757 } 5758 case OffsetOfNode::Identifier: { 5759 IdentifierInfo *ToII = Importer.Import(Node.getFieldName()); 5760 if (!ToII) 5761 return nullptr; 5762 Nodes.push_back(OffsetOfNode(Importer.Import(Node.getLocStart()), ToII, 5763 Importer.Import(Node.getLocEnd()))); 5764 break; 5765 } 5766 } 5767 } 5768 5769 SmallVector<Expr *, 4> Exprs(OE->getNumExpressions()); 5770 for (int I = 0, E = OE->getNumExpressions(); I < E; ++I) { 5771 Expr *ToIndexExpr = Importer.Import(OE->getIndexExpr(I)); 5772 if (!ToIndexExpr) 5773 return nullptr; 5774 Exprs[I] = ToIndexExpr; 5775 } 5776 5777 TypeSourceInfo *TInfo = Importer.Import(OE->getTypeSourceInfo()); 5778 if (!TInfo && OE->getTypeSourceInfo()) 5779 return nullptr; 5780 5781 return OffsetOfExpr::Create(Importer.getToContext(), T, 5782 Importer.Import(OE->getOperatorLoc()), 5783 TInfo, Nodes, Exprs, 5784 Importer.Import(OE->getRParenLoc())); 5785 } 5786 5787 Expr *ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 5788 QualType T = Importer.Import(E->getType()); 5789 if (T.isNull()) 5790 return nullptr; 5791 5792 Expr *Operand = Importer.Import(E->getOperand()); 5793 if (!Operand) 5794 return nullptr; 5795 5796 CanThrowResult CanThrow; 5797 if (E->isValueDependent()) 5798 CanThrow = CT_Dependent; 5799 else 5800 CanThrow = E->getValue() ? CT_Can : CT_Cannot; 5801 5802 return new (Importer.getToContext()) CXXNoexceptExpr( 5803 T, Operand, CanThrow, 5804 Importer.Import(E->getLocStart()), Importer.Import(E->getLocEnd())); 5805 } 5806 5807 Expr *ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) { 5808 QualType T = Importer.Import(E->getType()); 5809 if (T.isNull()) 5810 return nullptr; 5811 5812 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5813 if (!SubExpr && E->getSubExpr()) 5814 return nullptr; 5815 5816 return new (Importer.getToContext()) CXXThrowExpr( 5817 SubExpr, T, Importer.Import(E->getThrowLoc()), 5818 E->isThrownVariableInScope()); 5819 } 5820 5821 Expr *ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 5822 auto *Param = cast_or_null<ParmVarDecl>(Importer.Import(E->getParam())); 5823 if (!Param) 5824 return nullptr; 5825 5826 return CXXDefaultArgExpr::Create( 5827 Importer.getToContext(), Importer.Import(E->getUsedLocation()), Param); 5828 } 5829 5830 Expr *ASTNodeImporter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 5831 QualType T = Importer.Import(E->getType()); 5832 if (T.isNull()) 5833 return nullptr; 5834 5835 TypeSourceInfo *TypeInfo = Importer.Import(E->getTypeSourceInfo()); 5836 if (!TypeInfo) 5837 return nullptr; 5838 5839 return new (Importer.getToContext()) CXXScalarValueInitExpr( 5840 T, TypeInfo, Importer.Import(E->getRParenLoc())); 5841 } 5842 5843 Expr *ASTNodeImporter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 5844 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5845 if (!SubExpr) 5846 return nullptr; 5847 5848 auto *Dtor = cast_or_null<CXXDestructorDecl>( 5849 Importer.Import(const_cast<CXXDestructorDecl *>( 5850 E->getTemporary()->getDestructor()))); 5851 if (!Dtor) 5852 return nullptr; 5853 5854 ASTContext &ToCtx = Importer.getToContext(); 5855 CXXTemporary *Temp = CXXTemporary::Create(ToCtx, Dtor); 5856 return CXXBindTemporaryExpr::Create(ToCtx, Temp, SubExpr); 5857 } 5858 5859 Expr *ASTNodeImporter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *CE) { 5860 QualType T = Importer.Import(CE->getType()); 5861 if (T.isNull()) 5862 return nullptr; 5863 5864 TypeSourceInfo *TInfo = Importer.Import(CE->getTypeSourceInfo()); 5865 if (!TInfo) 5866 return nullptr; 5867 5868 SmallVector<Expr *, 8> Args(CE->getNumArgs()); 5869 if (ImportContainerChecked(CE->arguments(), Args)) 5870 return nullptr; 5871 5872 auto *Ctor = cast_or_null<CXXConstructorDecl>( 5873 Importer.Import(CE->getConstructor())); 5874 if (!Ctor) 5875 return nullptr; 5876 5877 return new (Importer.getToContext()) CXXTemporaryObjectExpr( 5878 Importer.getToContext(), Ctor, T, TInfo, Args, 5879 Importer.Import(CE->getParenOrBraceRange()), CE->hadMultipleCandidates(), 5880 CE->isListInitialization(), CE->isStdInitListInitialization(), 5881 CE->requiresZeroInitialization()); 5882 } 5883 5884 Expr * 5885 ASTNodeImporter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) { 5886 QualType T = Importer.Import(E->getType()); 5887 if (T.isNull()) 5888 return nullptr; 5889 5890 Expr *TempE = Importer.Import(E->GetTemporaryExpr()); 5891 if (!TempE) 5892 return nullptr; 5893 5894 auto *ExtendedBy = cast_or_null<ValueDecl>( 5895 Importer.Import(const_cast<ValueDecl *>(E->getExtendingDecl()))); 5896 if (!ExtendedBy && E->getExtendingDecl()) 5897 return nullptr; 5898 5899 auto *ToMTE = new (Importer.getToContext()) MaterializeTemporaryExpr( 5900 T, TempE, E->isBoundToLvalueReference()); 5901 5902 // FIXME: Should ManglingNumber get numbers associated with 'to' context? 5903 ToMTE->setExtendingDecl(ExtendedBy, E->getManglingNumber()); 5904 return ToMTE; 5905 } 5906 5907 Expr *ASTNodeImporter::VisitPackExpansionExpr(PackExpansionExpr *E) { 5908 QualType T = Importer.Import(E->getType()); 5909 if (T.isNull()) 5910 return nullptr; 5911 5912 Expr *Pattern = Importer.Import(E->getPattern()); 5913 if (!Pattern) 5914 return nullptr; 5915 5916 return new (Importer.getToContext()) PackExpansionExpr( 5917 T, Pattern, Importer.Import(E->getEllipsisLoc()), 5918 E->getNumExpansions()); 5919 } 5920 5921 Expr *ASTNodeImporter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 5922 auto *Pack = cast_or_null<NamedDecl>(Importer.Import(E->getPack())); 5923 if (!Pack) 5924 return nullptr; 5925 5926 Optional<unsigned> Length; 5927 5928 if (!E->isValueDependent()) 5929 Length = E->getPackLength(); 5930 5931 SmallVector<TemplateArgument, 8> PartialArguments; 5932 if (E->isPartiallySubstituted()) { 5933 if (ImportTemplateArguments(E->getPartialArguments().data(), 5934 E->getPartialArguments().size(), 5935 PartialArguments)) 5936 return nullptr; 5937 } 5938 5939 return SizeOfPackExpr::Create( 5940 Importer.getToContext(), Importer.Import(E->getOperatorLoc()), Pack, 5941 Importer.Import(E->getPackLoc()), Importer.Import(E->getRParenLoc()), 5942 Length, PartialArguments); 5943 } 5944 5945 Expr *ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *CE) { 5946 QualType T = Importer.Import(CE->getType()); 5947 if (T.isNull()) 5948 return nullptr; 5949 5950 SmallVector<Expr *, 4> PlacementArgs(CE->getNumPlacementArgs()); 5951 if (ImportContainerChecked(CE->placement_arguments(), PlacementArgs)) 5952 return nullptr; 5953 5954 auto *OperatorNewDecl = cast_or_null<FunctionDecl>( 5955 Importer.Import(CE->getOperatorNew())); 5956 if (!OperatorNewDecl && CE->getOperatorNew()) 5957 return nullptr; 5958 5959 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5960 Importer.Import(CE->getOperatorDelete())); 5961 if (!OperatorDeleteDecl && CE->getOperatorDelete()) 5962 return nullptr; 5963 5964 Expr *ToInit = Importer.Import(CE->getInitializer()); 5965 if (!ToInit && CE->getInitializer()) 5966 return nullptr; 5967 5968 TypeSourceInfo *TInfo = Importer.Import(CE->getAllocatedTypeSourceInfo()); 5969 if (!TInfo) 5970 return nullptr; 5971 5972 Expr *ToArrSize = Importer.Import(CE->getArraySize()); 5973 if (!ToArrSize && CE->getArraySize()) 5974 return nullptr; 5975 5976 return new (Importer.getToContext()) CXXNewExpr( 5977 Importer.getToContext(), 5978 CE->isGlobalNew(), 5979 OperatorNewDecl, OperatorDeleteDecl, 5980 CE->passAlignment(), 5981 CE->doesUsualArrayDeleteWantSize(), 5982 PlacementArgs, 5983 Importer.Import(CE->getTypeIdParens()), 5984 ToArrSize, CE->getInitializationStyle(), ToInit, T, TInfo, 5985 Importer.Import(CE->getSourceRange()), 5986 Importer.Import(CE->getDirectInitRange())); 5987 } 5988 5989 Expr *ASTNodeImporter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 5990 QualType T = Importer.Import(E->getType()); 5991 if (T.isNull()) 5992 return nullptr; 5993 5994 auto *OperatorDeleteDecl = cast_or_null<FunctionDecl>( 5995 Importer.Import(E->getOperatorDelete())); 5996 if (!OperatorDeleteDecl && E->getOperatorDelete()) 5997 return nullptr; 5998 5999 Expr *ToArg = Importer.Import(E->getArgument()); 6000 if (!ToArg && E->getArgument()) 6001 return nullptr; 6002 6003 return new (Importer.getToContext()) CXXDeleteExpr( 6004 T, E->isGlobalDelete(), 6005 E->isArrayForm(), 6006 E->isArrayFormAsWritten(), 6007 E->doesUsualArrayDeleteWantSize(), 6008 OperatorDeleteDecl, 6009 ToArg, 6010 Importer.Import(E->getLocStart())); 6011 } 6012 6013 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 6014 QualType T = Importer.Import(E->getType()); 6015 if (T.isNull()) 6016 return nullptr; 6017 6018 auto *ToCCD = 6019 dyn_cast_or_null<CXXConstructorDecl>(Importer.Import(E->getConstructor())); 6020 if (!ToCCD) 6021 return nullptr; 6022 6023 SmallVector<Expr *, 6> ToArgs(E->getNumArgs()); 6024 if (ImportContainerChecked(E->arguments(), ToArgs)) 6025 return nullptr; 6026 6027 return CXXConstructExpr::Create(Importer.getToContext(), T, 6028 Importer.Import(E->getLocation()), 6029 ToCCD, E->isElidable(), 6030 ToArgs, E->hadMultipleCandidates(), 6031 E->isListInitialization(), 6032 E->isStdInitListInitialization(), 6033 E->requiresZeroInitialization(), 6034 E->getConstructionKind(), 6035 Importer.Import(E->getParenOrBraceRange())); 6036 } 6037 6038 Expr *ASTNodeImporter::VisitExprWithCleanups(ExprWithCleanups *EWC) { 6039 Expr *SubExpr = Importer.Import(EWC->getSubExpr()); 6040 if (!SubExpr && EWC->getSubExpr()) 6041 return nullptr; 6042 6043 SmallVector<ExprWithCleanups::CleanupObject, 8> Objs(EWC->getNumObjects()); 6044 for (unsigned I = 0, E = EWC->getNumObjects(); I < E; I++) 6045 if (ExprWithCleanups::CleanupObject Obj = 6046 cast_or_null<BlockDecl>(Importer.Import(EWC->getObject(I)))) 6047 Objs[I] = Obj; 6048 else 6049 return nullptr; 6050 6051 return ExprWithCleanups::Create(Importer.getToContext(), 6052 SubExpr, EWC->cleanupsHaveSideEffects(), 6053 Objs); 6054 } 6055 6056 Expr *ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) { 6057 QualType T = Importer.Import(E->getType()); 6058 if (T.isNull()) 6059 return nullptr; 6060 6061 Expr *ToFn = Importer.Import(E->getCallee()); 6062 if (!ToFn) 6063 return nullptr; 6064 6065 SmallVector<Expr *, 4> ToArgs(E->getNumArgs()); 6066 if (ImportContainerChecked(E->arguments(), ToArgs)) 6067 return nullptr; 6068 6069 return new (Importer.getToContext()) CXXMemberCallExpr( 6070 Importer.getToContext(), ToFn, ToArgs, T, E->getValueKind(), 6071 Importer.Import(E->getRParenLoc())); 6072 } 6073 6074 Expr *ASTNodeImporter::VisitCXXThisExpr(CXXThisExpr *E) { 6075 QualType T = Importer.Import(E->getType()); 6076 if (T.isNull()) 6077 return nullptr; 6078 6079 return new (Importer.getToContext()) 6080 CXXThisExpr(Importer.Import(E->getLocation()), T, E->isImplicit()); 6081 } 6082 6083 Expr *ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { 6084 QualType T = Importer.Import(E->getType()); 6085 if (T.isNull()) 6086 return nullptr; 6087 6088 return new (Importer.getToContext()) 6089 CXXBoolLiteralExpr(E->getValue(), T, Importer.Import(E->getLocation())); 6090 } 6091 6092 6093 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 6094 QualType T = Importer.Import(E->getType()); 6095 if (T.isNull()) 6096 return nullptr; 6097 6098 Expr *ToBase = Importer.Import(E->getBase()); 6099 if (!ToBase && E->getBase()) 6100 return nullptr; 6101 6102 auto *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl())); 6103 if (!ToMember && E->getMemberDecl()) 6104 return nullptr; 6105 6106 auto *ToDecl = 6107 dyn_cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())); 6108 if (!ToDecl && E->getFoundDecl().getDecl()) 6109 return nullptr; 6110 6111 DeclAccessPair ToFoundDecl = 6112 DeclAccessPair::make(ToDecl, E->getFoundDecl().getAccess()); 6113 6114 DeclarationNameInfo ToMemberNameInfo( 6115 Importer.Import(E->getMemberNameInfo().getName()), 6116 Importer.Import(E->getMemberNameInfo().getLoc())); 6117 6118 if (E->hasExplicitTemplateArgs()) { 6119 return nullptr; // FIXME: handle template arguments 6120 } 6121 6122 return MemberExpr::Create(Importer.getToContext(), ToBase, 6123 E->isArrow(), 6124 Importer.Import(E->getOperatorLoc()), 6125 Importer.Import(E->getQualifierLoc()), 6126 Importer.Import(E->getTemplateKeywordLoc()), 6127 ToMember, ToFoundDecl, ToMemberNameInfo, 6128 nullptr, T, E->getValueKind(), 6129 E->getObjectKind()); 6130 } 6131 6132 Expr *ASTNodeImporter::VisitCXXPseudoDestructorExpr( 6133 CXXPseudoDestructorExpr *E) { 6134 Expr *BaseE = Importer.Import(E->getBase()); 6135 if (!BaseE) 6136 return nullptr; 6137 6138 TypeSourceInfo *ScopeInfo = Importer.Import(E->getScopeTypeInfo()); 6139 if (!ScopeInfo && E->getScopeTypeInfo()) 6140 return nullptr; 6141 6142 PseudoDestructorTypeStorage Storage; 6143 if (IdentifierInfo *FromII = E->getDestroyedTypeIdentifier()) { 6144 IdentifierInfo *ToII = Importer.Import(FromII); 6145 if (!ToII) 6146 return nullptr; 6147 Storage = PseudoDestructorTypeStorage( 6148 ToII, Importer.Import(E->getDestroyedTypeLoc())); 6149 } else { 6150 TypeSourceInfo *TI = Importer.Import(E->getDestroyedTypeInfo()); 6151 if (!TI) 6152 return nullptr; 6153 Storage = PseudoDestructorTypeStorage(TI); 6154 } 6155 6156 return new (Importer.getToContext()) CXXPseudoDestructorExpr( 6157 Importer.getToContext(), BaseE, E->isArrow(), 6158 Importer.Import(E->getOperatorLoc()), 6159 Importer.Import(E->getQualifierLoc()), 6160 ScopeInfo, Importer.Import(E->getColonColonLoc()), 6161 Importer.Import(E->getTildeLoc()), Storage); 6162 } 6163 6164 Expr *ASTNodeImporter::VisitCXXDependentScopeMemberExpr( 6165 CXXDependentScopeMemberExpr *E) { 6166 Expr *Base = nullptr; 6167 if (!E->isImplicitAccess()) { 6168 Base = Importer.Import(E->getBase()); 6169 if (!Base) 6170 return nullptr; 6171 } 6172 6173 QualType BaseType = Importer.Import(E->getBaseType()); 6174 if (BaseType.isNull()) 6175 return nullptr; 6176 6177 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 6178 if (E->hasExplicitTemplateArgs()) { 6179 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(), 6180 E->template_arguments(), ToTAInfo)) 6181 return nullptr; 6182 ResInfo = &ToTAInfo; 6183 } 6184 6185 DeclarationName Name = Importer.Import(E->getMember()); 6186 if (!E->getMember().isEmpty() && Name.isEmpty()) 6187 return nullptr; 6188 6189 DeclarationNameInfo MemberNameInfo(Name, Importer.Import(E->getMemberLoc())); 6190 // Import additional name location/type info. 6191 ImportDeclarationNameLoc(E->getMemberNameInfo(), MemberNameInfo); 6192 auto ToFQ = Importer.Import(E->getFirstQualifierFoundInScope()); 6193 if (!ToFQ && E->getFirstQualifierFoundInScope()) 6194 return nullptr; 6195 6196 return CXXDependentScopeMemberExpr::Create( 6197 Importer.getToContext(), Base, BaseType, E->isArrow(), 6198 Importer.Import(E->getOperatorLoc()), 6199 Importer.Import(E->getQualifierLoc()), 6200 Importer.Import(E->getTemplateKeywordLoc()), 6201 cast_or_null<NamedDecl>(ToFQ), MemberNameInfo, ResInfo); 6202 } 6203 6204 Expr * 6205 ASTNodeImporter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 6206 DeclarationName Name = Importer.Import(E->getDeclName()); 6207 if (!E->getDeclName().isEmpty() && Name.isEmpty()) 6208 return nullptr; 6209 6210 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getExprLoc())); 6211 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo); 6212 6213 TemplateArgumentListInfo ToTAInfo(Importer.Import(E->getLAngleLoc()), 6214 Importer.Import(E->getRAngleLoc())); 6215 TemplateArgumentListInfo *ResInfo = nullptr; 6216 if (E->hasExplicitTemplateArgs()) { 6217 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 6218 return nullptr; 6219 ResInfo = &ToTAInfo; 6220 } 6221 6222 return DependentScopeDeclRefExpr::Create( 6223 Importer.getToContext(), Importer.Import(E->getQualifierLoc()), 6224 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo); 6225 } 6226 6227 Expr *ASTNodeImporter::VisitCXXUnresolvedConstructExpr( 6228 CXXUnresolvedConstructExpr *CE) { 6229 unsigned NumArgs = CE->arg_size(); 6230 6231 SmallVector<Expr *, 8> ToArgs(NumArgs); 6232 if (ImportArrayChecked(CE->arg_begin(), CE->arg_end(), ToArgs.begin())) 6233 return nullptr; 6234 6235 return CXXUnresolvedConstructExpr::Create( 6236 Importer.getToContext(), Importer.Import(CE->getTypeSourceInfo()), 6237 Importer.Import(CE->getLParenLoc()), llvm::makeArrayRef(ToArgs), 6238 Importer.Import(CE->getRParenLoc())); 6239 } 6240 6241 Expr *ASTNodeImporter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) { 6242 auto *NamingClass = 6243 cast_or_null<CXXRecordDecl>(Importer.Import(E->getNamingClass())); 6244 if (E->getNamingClass() && !NamingClass) 6245 return nullptr; 6246 6247 DeclarationName Name = Importer.Import(E->getName()); 6248 if (E->getName() && !Name) 6249 return nullptr; 6250 6251 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc())); 6252 // Import additional name location/type info. 6253 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo); 6254 6255 UnresolvedSet<8> ToDecls; 6256 for (auto *D : E->decls()) { 6257 if (auto *To = cast_or_null<NamedDecl>(Importer.Import(D))) 6258 ToDecls.addDecl(To); 6259 else 6260 return nullptr; 6261 } 6262 6263 TemplateArgumentListInfo ToTAInfo, *ResInfo = nullptr; 6264 if (E->hasExplicitTemplateArgs()) { 6265 if (ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(), 6266 E->template_arguments(), ToTAInfo)) 6267 return nullptr; 6268 ResInfo = &ToTAInfo; 6269 } 6270 6271 if (ResInfo || E->getTemplateKeywordLoc().isValid()) 6272 return UnresolvedLookupExpr::Create( 6273 Importer.getToContext(), NamingClass, 6274 Importer.Import(E->getQualifierLoc()), 6275 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, E->requiresADL(), 6276 ResInfo, ToDecls.begin(), ToDecls.end()); 6277 6278 return UnresolvedLookupExpr::Create( 6279 Importer.getToContext(), NamingClass, 6280 Importer.Import(E->getQualifierLoc()), NameInfo, E->requiresADL(), 6281 E->isOverloaded(), ToDecls.begin(), ToDecls.end()); 6282 } 6283 6284 Expr *ASTNodeImporter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) { 6285 DeclarationName Name = Importer.Import(E->getName()); 6286 if (!E->getName().isEmpty() && Name.isEmpty()) 6287 return nullptr; 6288 DeclarationNameInfo NameInfo(Name, Importer.Import(E->getNameLoc())); 6289 // Import additional name location/type info. 6290 ImportDeclarationNameLoc(E->getNameInfo(), NameInfo); 6291 6292 QualType BaseType = Importer.Import(E->getType()); 6293 if (!E->getType().isNull() && BaseType.isNull()) 6294 return nullptr; 6295 6296 UnresolvedSet<8> ToDecls; 6297 for (Decl *D : E->decls()) { 6298 if (NamedDecl *To = cast_or_null<NamedDecl>(Importer.Import(D))) 6299 ToDecls.addDecl(To); 6300 else 6301 return nullptr; 6302 } 6303 6304 TemplateArgumentListInfo ToTAInfo; 6305 TemplateArgumentListInfo *ResInfo = nullptr; 6306 if (E->hasExplicitTemplateArgs()) { 6307 if (ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo)) 6308 return nullptr; 6309 ResInfo = &ToTAInfo; 6310 } 6311 6312 Expr *BaseE = E->isImplicitAccess() ? nullptr : Importer.Import(E->getBase()); 6313 if (!BaseE && !E->isImplicitAccess() && E->getBase()) { 6314 return nullptr; 6315 } 6316 6317 return UnresolvedMemberExpr::Create( 6318 Importer.getToContext(), E->hasUnresolvedUsing(), BaseE, BaseType, 6319 E->isArrow(), Importer.Import(E->getOperatorLoc()), 6320 Importer.Import(E->getQualifierLoc()), 6321 Importer.Import(E->getTemplateKeywordLoc()), NameInfo, ResInfo, 6322 ToDecls.begin(), ToDecls.end()); 6323 } 6324 6325 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) { 6326 QualType T = Importer.Import(E->getType()); 6327 if (T.isNull()) 6328 return nullptr; 6329 6330 Expr *ToCallee = Importer.Import(E->getCallee()); 6331 if (!ToCallee && E->getCallee()) 6332 return nullptr; 6333 6334 unsigned NumArgs = E->getNumArgs(); 6335 SmallVector<Expr *, 2> ToArgs(NumArgs); 6336 if (ImportContainerChecked(E->arguments(), ToArgs)) 6337 return nullptr; 6338 6339 auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs]; 6340 6341 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) 6342 ToArgs_Copied[ai] = ToArgs[ai]; 6343 6344 if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) { 6345 return new (Importer.getToContext()) CXXOperatorCallExpr( 6346 Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, T, 6347 OCE->getValueKind(), Importer.Import(OCE->getRParenLoc()), 6348 OCE->getFPFeatures()); 6349 } 6350 6351 return new (Importer.getToContext()) 6352 CallExpr(Importer.getToContext(), ToCallee, 6353 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(), 6354 Importer.Import(E->getRParenLoc())); 6355 } 6356 6357 Optional<LambdaCapture> 6358 ASTNodeImporter::ImportLambdaCapture(const LambdaCapture &From) { 6359 VarDecl *Var = nullptr; 6360 if (From.capturesVariable()) { 6361 Var = cast_or_null<VarDecl>(Importer.Import(From.getCapturedVar())); 6362 if (!Var) 6363 return None; 6364 } 6365 6366 return LambdaCapture(Importer.Import(From.getLocation()), From.isImplicit(), 6367 From.getCaptureKind(), Var, 6368 From.isPackExpansion() 6369 ? Importer.Import(From.getEllipsisLoc()) 6370 : SourceLocation()); 6371 } 6372 6373 Expr *ASTNodeImporter::VisitLambdaExpr(LambdaExpr *LE) { 6374 CXXRecordDecl *FromClass = LE->getLambdaClass(); 6375 auto *ToClass = dyn_cast_or_null<CXXRecordDecl>(Importer.Import(FromClass)); 6376 if (!ToClass) 6377 return nullptr; 6378 6379 // NOTE: lambda classes are created with BeingDefined flag set up. 6380 // It means that ImportDefinition doesn't work for them and we should fill it 6381 // manually. 6382 if (ToClass->isBeingDefined()) { 6383 for (auto FromField : FromClass->fields()) { 6384 auto *ToField = cast_or_null<FieldDecl>(Importer.Import(FromField)); 6385 if (!ToField) 6386 return nullptr; 6387 } 6388 } 6389 6390 auto *ToCallOp = dyn_cast_or_null<CXXMethodDecl>( 6391 Importer.Import(LE->getCallOperator())); 6392 if (!ToCallOp) 6393 return nullptr; 6394 6395 ToClass->completeDefinition(); 6396 6397 unsigned NumCaptures = LE->capture_size(); 6398 SmallVector<LambdaCapture, 8> Captures; 6399 Captures.reserve(NumCaptures); 6400 for (const auto &FromCapture : LE->captures()) { 6401 if (auto ToCapture = ImportLambdaCapture(FromCapture)) 6402 Captures.push_back(*ToCapture); 6403 else 6404 return nullptr; 6405 } 6406 6407 SmallVector<Expr *, 8> InitCaptures(NumCaptures); 6408 if (ImportContainerChecked(LE->capture_inits(), InitCaptures)) 6409 return nullptr; 6410 6411 return LambdaExpr::Create(Importer.getToContext(), ToClass, 6412 Importer.Import(LE->getIntroducerRange()), 6413 LE->getCaptureDefault(), 6414 Importer.Import(LE->getCaptureDefaultLoc()), 6415 Captures, 6416 LE->hasExplicitParameters(), 6417 LE->hasExplicitResultType(), 6418 InitCaptures, 6419 Importer.Import(LE->getLocEnd()), 6420 LE->containsUnexpandedParameterPack()); 6421 } 6422 6423 Expr *ASTNodeImporter::VisitInitListExpr(InitListExpr *ILE) { 6424 QualType T = Importer.Import(ILE->getType()); 6425 if (T.isNull()) 6426 return nullptr; 6427 6428 SmallVector<Expr *, 4> Exprs(ILE->getNumInits()); 6429 if (ImportContainerChecked(ILE->inits(), Exprs)) 6430 return nullptr; 6431 6432 ASTContext &ToCtx = Importer.getToContext(); 6433 InitListExpr *To = new (ToCtx) InitListExpr( 6434 ToCtx, Importer.Import(ILE->getLBraceLoc()), 6435 Exprs, Importer.Import(ILE->getLBraceLoc())); 6436 To->setType(T); 6437 6438 if (ILE->hasArrayFiller()) { 6439 Expr *Filler = Importer.Import(ILE->getArrayFiller()); 6440 if (!Filler) 6441 return nullptr; 6442 To->setArrayFiller(Filler); 6443 } 6444 6445 if (FieldDecl *FromFD = ILE->getInitializedFieldInUnion()) { 6446 auto *ToFD = cast_or_null<FieldDecl>(Importer.Import(FromFD)); 6447 if (!ToFD) 6448 return nullptr; 6449 To->setInitializedFieldInUnion(ToFD); 6450 } 6451 6452 if (InitListExpr *SyntForm = ILE->getSyntacticForm()) { 6453 auto *ToSyntForm = cast_or_null<InitListExpr>(Importer.Import(SyntForm)); 6454 if (!ToSyntForm) 6455 return nullptr; 6456 To->setSyntacticForm(ToSyntForm); 6457 } 6458 6459 To->sawArrayRangeDesignator(ILE->hadArrayRangeDesignator()); 6460 To->setValueDependent(ILE->isValueDependent()); 6461 To->setInstantiationDependent(ILE->isInstantiationDependent()); 6462 6463 return To; 6464 } 6465 6466 Expr *ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) { 6467 QualType ToType = Importer.Import(E->getType()); 6468 if (ToType.isNull()) 6469 return nullptr; 6470 6471 Expr *ToCommon = Importer.Import(E->getCommonExpr()); 6472 if (!ToCommon && E->getCommonExpr()) 6473 return nullptr; 6474 6475 Expr *ToSubExpr = Importer.Import(E->getSubExpr()); 6476 if (!ToSubExpr && E->getSubExpr()) 6477 return nullptr; 6478 6479 return new (Importer.getToContext()) 6480 ArrayInitLoopExpr(ToType, ToCommon, ToSubExpr); 6481 } 6482 6483 Expr *ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) { 6484 QualType ToType = Importer.Import(E->getType()); 6485 if (ToType.isNull()) 6486 return nullptr; 6487 return new (Importer.getToContext()) ArrayInitIndexExpr(ToType); 6488 } 6489 6490 Expr *ASTNodeImporter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 6491 auto *ToField = dyn_cast_or_null<FieldDecl>(Importer.Import(DIE->getField())); 6492 if (!ToField && DIE->getField()) 6493 return nullptr; 6494 6495 return CXXDefaultInitExpr::Create( 6496 Importer.getToContext(), Importer.Import(DIE->getLocStart()), ToField); 6497 } 6498 6499 Expr *ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) { 6500 QualType ToType = Importer.Import(E->getType()); 6501 if (ToType.isNull() && !E->getType().isNull()) 6502 return nullptr; 6503 ExprValueKind VK = E->getValueKind(); 6504 CastKind CK = E->getCastKind(); 6505 Expr *ToOp = Importer.Import(E->getSubExpr()); 6506 if (!ToOp && E->getSubExpr()) 6507 return nullptr; 6508 CXXCastPath BasePath; 6509 if (ImportCastPath(E, BasePath)) 6510 return nullptr; 6511 TypeSourceInfo *ToWritten = Importer.Import(E->getTypeInfoAsWritten()); 6512 SourceLocation ToOperatorLoc = Importer.Import(E->getOperatorLoc()); 6513 SourceLocation ToRParenLoc = Importer.Import(E->getRParenLoc()); 6514 SourceRange ToAngleBrackets = Importer.Import(E->getAngleBrackets()); 6515 6516 if (isa<CXXStaticCastExpr>(E)) { 6517 return CXXStaticCastExpr::Create( 6518 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6519 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6520 } else if (isa<CXXDynamicCastExpr>(E)) { 6521 return CXXDynamicCastExpr::Create( 6522 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6523 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6524 } else if (isa<CXXReinterpretCastExpr>(E)) { 6525 return CXXReinterpretCastExpr::Create( 6526 Importer.getToContext(), ToType, VK, CK, ToOp, &BasePath, 6527 ToWritten, ToOperatorLoc, ToRParenLoc, ToAngleBrackets); 6528 } else { 6529 return nullptr; 6530 } 6531 } 6532 6533 Expr *ASTNodeImporter::VisitSubstNonTypeTemplateParmExpr( 6534 SubstNonTypeTemplateParmExpr *E) { 6535 QualType T = Importer.Import(E->getType()); 6536 if (T.isNull()) 6537 return nullptr; 6538 6539 auto *Param = cast_or_null<NonTypeTemplateParmDecl>( 6540 Importer.Import(E->getParameter())); 6541 if (!Param) 6542 return nullptr; 6543 6544 Expr *Replacement = Importer.Import(E->getReplacement()); 6545 if (!Replacement) 6546 return nullptr; 6547 6548 return new (Importer.getToContext()) SubstNonTypeTemplateParmExpr( 6549 T, E->getValueKind(), Importer.Import(E->getExprLoc()), Param, 6550 Replacement); 6551 } 6552 6553 Expr *ASTNodeImporter::VisitTypeTraitExpr(TypeTraitExpr *E) { 6554 QualType ToType = Importer.Import(E->getType()); 6555 if (ToType.isNull()) 6556 return nullptr; 6557 6558 SmallVector<TypeSourceInfo *, 4> ToArgs(E->getNumArgs()); 6559 if (ImportContainerChecked(E->getArgs(), ToArgs)) 6560 return nullptr; 6561 6562 // According to Sema::BuildTypeTrait(), if E is value-dependent, 6563 // Value is always false. 6564 bool ToValue = false; 6565 if (!E->isValueDependent()) 6566 ToValue = E->getValue(); 6567 6568 return TypeTraitExpr::Create( 6569 Importer.getToContext(), ToType, Importer.Import(E->getLocStart()), 6570 E->getTrait(), ToArgs, Importer.Import(E->getLocEnd()), ToValue); 6571 } 6572 6573 Expr *ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) { 6574 QualType ToType = Importer.Import(E->getType()); 6575 if (ToType.isNull()) 6576 return nullptr; 6577 6578 if (E->isTypeOperand()) { 6579 TypeSourceInfo *TSI = Importer.Import(E->getTypeOperandSourceInfo()); 6580 if (!TSI) 6581 return nullptr; 6582 6583 return new (Importer.getToContext()) 6584 CXXTypeidExpr(ToType, TSI, Importer.Import(E->getSourceRange())); 6585 } 6586 6587 Expr *Op = Importer.Import(E->getExprOperand()); 6588 if (!Op) 6589 return nullptr; 6590 6591 return new (Importer.getToContext()) 6592 CXXTypeidExpr(ToType, Op, Importer.Import(E->getSourceRange())); 6593 } 6594 6595 void ASTNodeImporter::ImportOverrides(CXXMethodDecl *ToMethod, 6596 CXXMethodDecl *FromMethod) { 6597 for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) 6598 ToMethod->addOverriddenMethod( 6599 cast<CXXMethodDecl>(Importer.Import(const_cast<CXXMethodDecl*>( 6600 FromOverriddenMethod)))); 6601 } 6602 6603 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 6604 ASTContext &FromContext, FileManager &FromFileManager, 6605 bool MinimalImport) 6606 : ToContext(ToContext), FromContext(FromContext), 6607 ToFileManager(ToFileManager), FromFileManager(FromFileManager), 6608 Minimal(MinimalImport) { 6609 ImportedDecls[FromContext.getTranslationUnitDecl()] 6610 = ToContext.getTranslationUnitDecl(); 6611 } 6612 6613 ASTImporter::~ASTImporter() = default; 6614 6615 QualType ASTImporter::Import(QualType FromT) { 6616 if (FromT.isNull()) 6617 return {}; 6618 6619 const Type *fromTy = FromT.getTypePtr(); 6620 6621 // Check whether we've already imported this type. 6622 llvm::DenseMap<const Type *, const Type *>::iterator Pos 6623 = ImportedTypes.find(fromTy); 6624 if (Pos != ImportedTypes.end()) 6625 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 6626 6627 // Import the type 6628 ASTNodeImporter Importer(*this); 6629 QualType ToT = Importer.Visit(fromTy); 6630 if (ToT.isNull()) 6631 return ToT; 6632 6633 // Record the imported type. 6634 ImportedTypes[fromTy] = ToT.getTypePtr(); 6635 6636 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers()); 6637 } 6638 6639 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) { 6640 if (!FromTSI) 6641 return FromTSI; 6642 6643 // FIXME: For now we just create a "trivial" type source info based 6644 // on the type and a single location. Implement a real version of this. 6645 QualType T = Import(FromTSI->getType()); 6646 if (T.isNull()) 6647 return nullptr; 6648 6649 return ToContext.getTrivialTypeSourceInfo(T, 6650 Import(FromTSI->getTypeLoc().getLocStart())); 6651 } 6652 6653 Attr *ASTImporter::Import(const Attr *FromAttr) { 6654 Attr *ToAttr = FromAttr->clone(ToContext); 6655 ToAttr->setRange(Import(FromAttr->getRange())); 6656 return ToAttr; 6657 } 6658 6659 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) { 6660 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 6661 if (Pos != ImportedDecls.end()) { 6662 Decl *ToD = Pos->second; 6663 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD); 6664 return ToD; 6665 } else { 6666 return nullptr; 6667 } 6668 } 6669 6670 Decl *ASTImporter::Import(Decl *FromD) { 6671 if (!FromD) 6672 return nullptr; 6673 6674 ASTNodeImporter Importer(*this); 6675 6676 // Check whether we've already imported this declaration. 6677 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 6678 if (Pos != ImportedDecls.end()) { 6679 Decl *ToD = Pos->second; 6680 Importer.ImportDefinitionIfNeeded(FromD, ToD); 6681 return ToD; 6682 } 6683 6684 // Import the type 6685 Decl *ToD = Importer.Visit(FromD); 6686 if (!ToD) 6687 return nullptr; 6688 6689 // Record the imported declaration. 6690 ImportedDecls[FromD] = ToD; 6691 ToD->IdentifierNamespace = FromD->IdentifierNamespace; 6692 return ToD; 6693 } 6694 6695 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) { 6696 if (!FromDC) 6697 return FromDC; 6698 6699 auto *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC))); 6700 if (!ToDC) 6701 return nullptr; 6702 6703 // When we're using a record/enum/Objective-C class/protocol as a context, we 6704 // need it to have a definition. 6705 if (auto *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 6706 auto *FromRecord = cast<RecordDecl>(FromDC); 6707 if (ToRecord->isCompleteDefinition()) { 6708 // Do nothing. 6709 } else if (FromRecord->isCompleteDefinition()) { 6710 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord, 6711 ASTNodeImporter::IDK_Basic); 6712 } else { 6713 CompleteDecl(ToRecord); 6714 } 6715 } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 6716 auto *FromEnum = cast<EnumDecl>(FromDC); 6717 if (ToEnum->isCompleteDefinition()) { 6718 // Do nothing. 6719 } else if (FromEnum->isCompleteDefinition()) { 6720 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum, 6721 ASTNodeImporter::IDK_Basic); 6722 } else { 6723 CompleteDecl(ToEnum); 6724 } 6725 } else if (auto *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 6726 auto *FromClass = cast<ObjCInterfaceDecl>(FromDC); 6727 if (ToClass->getDefinition()) { 6728 // Do nothing. 6729 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 6730 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass, 6731 ASTNodeImporter::IDK_Basic); 6732 } else { 6733 CompleteDecl(ToClass); 6734 } 6735 } else if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 6736 auto *FromProto = cast<ObjCProtocolDecl>(FromDC); 6737 if (ToProto->getDefinition()) { 6738 // Do nothing. 6739 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 6740 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto, 6741 ASTNodeImporter::IDK_Basic); 6742 } else { 6743 CompleteDecl(ToProto); 6744 } 6745 } 6746 6747 return ToDC; 6748 } 6749 6750 Expr *ASTImporter::Import(Expr *FromE) { 6751 if (!FromE) 6752 return nullptr; 6753 6754 return cast_or_null<Expr>(Import(cast<Stmt>(FromE))); 6755 } 6756 6757 Stmt *ASTImporter::Import(Stmt *FromS) { 6758 if (!FromS) 6759 return nullptr; 6760 6761 // Check whether we've already imported this declaration. 6762 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 6763 if (Pos != ImportedStmts.end()) 6764 return Pos->second; 6765 6766 // Import the type 6767 ASTNodeImporter Importer(*this); 6768 Stmt *ToS = Importer.Visit(FromS); 6769 if (!ToS) 6770 return nullptr; 6771 6772 // Record the imported declaration. 6773 ImportedStmts[FromS] = ToS; 6774 return ToS; 6775 } 6776 6777 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) { 6778 if (!FromNNS) 6779 return nullptr; 6780 6781 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix()); 6782 6783 switch (FromNNS->getKind()) { 6784 case NestedNameSpecifier::Identifier: 6785 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) { 6786 return NestedNameSpecifier::Create(ToContext, prefix, II); 6787 } 6788 return nullptr; 6789 6790 case NestedNameSpecifier::Namespace: 6791 if (auto *NS = 6792 cast_or_null<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) { 6793 return NestedNameSpecifier::Create(ToContext, prefix, NS); 6794 } 6795 return nullptr; 6796 6797 case NestedNameSpecifier::NamespaceAlias: 6798 if (auto *NSAD = 6799 cast_or_null<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) { 6800 return NestedNameSpecifier::Create(ToContext, prefix, NSAD); 6801 } 6802 return nullptr; 6803 6804 case NestedNameSpecifier::Global: 6805 return NestedNameSpecifier::GlobalSpecifier(ToContext); 6806 6807 case NestedNameSpecifier::Super: 6808 if (auto *RD = 6809 cast_or_null<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) { 6810 return NestedNameSpecifier::SuperSpecifier(ToContext, RD); 6811 } 6812 return nullptr; 6813 6814 case NestedNameSpecifier::TypeSpec: 6815 case NestedNameSpecifier::TypeSpecWithTemplate: { 6816 QualType T = Import(QualType(FromNNS->getAsType(), 0u)); 6817 if (!T.isNull()) { 6818 bool bTemplate = FromNNS->getKind() == 6819 NestedNameSpecifier::TypeSpecWithTemplate; 6820 return NestedNameSpecifier::Create(ToContext, prefix, 6821 bTemplate, T.getTypePtr()); 6822 } 6823 } 6824 return nullptr; 6825 } 6826 6827 llvm_unreachable("Invalid nested name specifier kind"); 6828 } 6829 6830 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 6831 // Copied from NestedNameSpecifier mostly. 6832 SmallVector<NestedNameSpecifierLoc , 8> NestedNames; 6833 NestedNameSpecifierLoc NNS = FromNNS; 6834 6835 // Push each of the nested-name-specifiers's onto a stack for 6836 // serialization in reverse order. 6837 while (NNS) { 6838 NestedNames.push_back(NNS); 6839 NNS = NNS.getPrefix(); 6840 } 6841 6842 NestedNameSpecifierLocBuilder Builder; 6843 6844 while (!NestedNames.empty()) { 6845 NNS = NestedNames.pop_back_val(); 6846 NestedNameSpecifier *Spec = Import(NNS.getNestedNameSpecifier()); 6847 if (!Spec) 6848 return NestedNameSpecifierLoc(); 6849 6850 NestedNameSpecifier::SpecifierKind Kind = Spec->getKind(); 6851 switch (Kind) { 6852 case NestedNameSpecifier::Identifier: 6853 Builder.Extend(getToContext(), 6854 Spec->getAsIdentifier(), 6855 Import(NNS.getLocalBeginLoc()), 6856 Import(NNS.getLocalEndLoc())); 6857 break; 6858 6859 case NestedNameSpecifier::Namespace: 6860 Builder.Extend(getToContext(), 6861 Spec->getAsNamespace(), 6862 Import(NNS.getLocalBeginLoc()), 6863 Import(NNS.getLocalEndLoc())); 6864 break; 6865 6866 case NestedNameSpecifier::NamespaceAlias: 6867 Builder.Extend(getToContext(), 6868 Spec->getAsNamespaceAlias(), 6869 Import(NNS.getLocalBeginLoc()), 6870 Import(NNS.getLocalEndLoc())); 6871 break; 6872 6873 case NestedNameSpecifier::TypeSpec: 6874 case NestedNameSpecifier::TypeSpecWithTemplate: { 6875 TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo( 6876 QualType(Spec->getAsType(), 0)); 6877 Builder.Extend(getToContext(), 6878 Import(NNS.getLocalBeginLoc()), 6879 TSI->getTypeLoc(), 6880 Import(NNS.getLocalEndLoc())); 6881 break; 6882 } 6883 6884 case NestedNameSpecifier::Global: 6885 Builder.MakeGlobal(getToContext(), Import(NNS.getLocalBeginLoc())); 6886 break; 6887 6888 case NestedNameSpecifier::Super: { 6889 SourceRange ToRange = Import(NNS.getSourceRange()); 6890 Builder.MakeSuper(getToContext(), 6891 Spec->getAsRecordDecl(), 6892 ToRange.getBegin(), 6893 ToRange.getEnd()); 6894 } 6895 } 6896 } 6897 6898 return Builder.getWithLocInContext(getToContext()); 6899 } 6900 6901 TemplateName ASTImporter::Import(TemplateName From) { 6902 switch (From.getKind()) { 6903 case TemplateName::Template: 6904 if (auto *ToTemplate = 6905 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 6906 return TemplateName(ToTemplate); 6907 6908 return {}; 6909 6910 case TemplateName::OverloadedTemplate: { 6911 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 6912 UnresolvedSet<2> ToTemplates; 6913 for (auto *I : *FromStorage) { 6914 if (auto *To = cast_or_null<NamedDecl>(Import(I))) 6915 ToTemplates.addDecl(To); 6916 else 6917 return {}; 6918 } 6919 return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 6920 ToTemplates.end()); 6921 } 6922 6923 case TemplateName::QualifiedTemplate: { 6924 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 6925 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier()); 6926 if (!Qualifier) 6927 return {}; 6928 6929 if (auto *ToTemplate = 6930 cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 6931 return ToContext.getQualifiedTemplateName(Qualifier, 6932 QTN->hasTemplateKeyword(), 6933 ToTemplate); 6934 6935 return {}; 6936 } 6937 6938 case TemplateName::DependentTemplate: { 6939 DependentTemplateName *DTN = From.getAsDependentTemplateName(); 6940 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier()); 6941 if (!Qualifier) 6942 return {}; 6943 6944 if (DTN->isIdentifier()) { 6945 return ToContext.getDependentTemplateName(Qualifier, 6946 Import(DTN->getIdentifier())); 6947 } 6948 6949 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator()); 6950 } 6951 6952 case TemplateName::SubstTemplateTemplateParm: { 6953 SubstTemplateTemplateParmStorage *subst 6954 = From.getAsSubstTemplateTemplateParm(); 6955 auto *param = 6956 cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter())); 6957 if (!param) 6958 return {}; 6959 6960 TemplateName replacement = Import(subst->getReplacement()); 6961 if (replacement.isNull()) 6962 return {}; 6963 6964 return ToContext.getSubstTemplateTemplateParm(param, replacement); 6965 } 6966 6967 case TemplateName::SubstTemplateTemplateParmPack: { 6968 SubstTemplateTemplateParmPackStorage *SubstPack 6969 = From.getAsSubstTemplateTemplateParmPack(); 6970 auto *Param = 6971 cast_or_null<TemplateTemplateParmDecl>( 6972 Import(SubstPack->getParameterPack())); 6973 if (!Param) 6974 return {}; 6975 6976 ASTNodeImporter Importer(*this); 6977 TemplateArgument ArgPack 6978 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 6979 if (ArgPack.isNull()) 6980 return {}; 6981 6982 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack); 6983 } 6984 } 6985 6986 llvm_unreachable("Invalid template name kind"); 6987 } 6988 6989 SourceLocation ASTImporter::Import(SourceLocation FromLoc) { 6990 if (FromLoc.isInvalid()) 6991 return {}; 6992 6993 SourceManager &FromSM = FromContext.getSourceManager(); 6994 6995 // For now, map everything down to its file location, so that we 6996 // don't have to import macro expansions. 6997 // FIXME: Import macro expansions! 6998 FromLoc = FromSM.getFileLoc(FromLoc); 6999 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 7000 SourceManager &ToSM = ToContext.getSourceManager(); 7001 FileID ToFileID = Import(Decomposed.first); 7002 if (ToFileID.isInvalid()) 7003 return {}; 7004 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID) 7005 .getLocWithOffset(Decomposed.second); 7006 return ret; 7007 } 7008 7009 SourceRange ASTImporter::Import(SourceRange FromRange) { 7010 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd())); 7011 } 7012 7013 FileID ASTImporter::Import(FileID FromID) { 7014 llvm::DenseMap<FileID, FileID>::iterator Pos 7015 = ImportedFileIDs.find(FromID); 7016 if (Pos != ImportedFileIDs.end()) 7017 return Pos->second; 7018 7019 SourceManager &FromSM = FromContext.getSourceManager(); 7020 SourceManager &ToSM = ToContext.getSourceManager(); 7021 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 7022 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet"); 7023 7024 // Include location of this file. 7025 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 7026 7027 // Map the FileID for to the "to" source manager. 7028 FileID ToID; 7029 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 7030 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 7031 // FIXME: We probably want to use getVirtualFile(), so we don't hit the 7032 // disk again 7033 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 7034 // than mmap the files several times. 7035 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName()); 7036 if (!Entry) 7037 return {}; 7038 ToID = ToSM.createFileID(Entry, ToIncludeLoc, 7039 FromSLoc.getFile().getFileCharacteristic()); 7040 } else { 7041 // FIXME: We want to re-use the existing MemoryBuffer! 7042 const llvm::MemoryBuffer * 7043 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM); 7044 std::unique_ptr<llvm::MemoryBuffer> ToBuf 7045 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 7046 FromBuf->getBufferIdentifier()); 7047 ToID = ToSM.createFileID(std::move(ToBuf), 7048 FromSLoc.getFile().getFileCharacteristic()); 7049 } 7050 7051 ImportedFileIDs[FromID] = ToID; 7052 return ToID; 7053 } 7054 7055 CXXCtorInitializer *ASTImporter::Import(CXXCtorInitializer *From) { 7056 Expr *ToExpr = Import(From->getInit()); 7057 if (!ToExpr && From->getInit()) 7058 return nullptr; 7059 7060 if (From->isBaseInitializer()) { 7061 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 7062 if (!ToTInfo && From->getTypeSourceInfo()) 7063 return nullptr; 7064 7065 return new (ToContext) CXXCtorInitializer( 7066 ToContext, ToTInfo, From->isBaseVirtual(), Import(From->getLParenLoc()), 7067 ToExpr, Import(From->getRParenLoc()), 7068 From->isPackExpansion() ? Import(From->getEllipsisLoc()) 7069 : SourceLocation()); 7070 } else if (From->isMemberInitializer()) { 7071 auto *ToField = cast_or_null<FieldDecl>(Import(From->getMember())); 7072 if (!ToField && From->getMember()) 7073 return nullptr; 7074 7075 return new (ToContext) CXXCtorInitializer( 7076 ToContext, ToField, Import(From->getMemberLocation()), 7077 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 7078 } else if (From->isIndirectMemberInitializer()) { 7079 auto *ToIField = cast_or_null<IndirectFieldDecl>( 7080 Import(From->getIndirectMember())); 7081 if (!ToIField && From->getIndirectMember()) 7082 return nullptr; 7083 7084 return new (ToContext) CXXCtorInitializer( 7085 ToContext, ToIField, Import(From->getMemberLocation()), 7086 Import(From->getLParenLoc()), ToExpr, Import(From->getRParenLoc())); 7087 } else if (From->isDelegatingInitializer()) { 7088 TypeSourceInfo *ToTInfo = Import(From->getTypeSourceInfo()); 7089 if (!ToTInfo && From->getTypeSourceInfo()) 7090 return nullptr; 7091 7092 return new (ToContext) 7093 CXXCtorInitializer(ToContext, ToTInfo, Import(From->getLParenLoc()), 7094 ToExpr, Import(From->getRParenLoc())); 7095 } else { 7096 return nullptr; 7097 } 7098 } 7099 7100 CXXBaseSpecifier *ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) { 7101 auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec); 7102 if (Pos != ImportedCXXBaseSpecifiers.end()) 7103 return Pos->second; 7104 7105 CXXBaseSpecifier *Imported = new (ToContext) CXXBaseSpecifier( 7106 Import(BaseSpec->getSourceRange()), 7107 BaseSpec->isVirtual(), BaseSpec->isBaseOfClass(), 7108 BaseSpec->getAccessSpecifierAsWritten(), 7109 Import(BaseSpec->getTypeSourceInfo()), 7110 Import(BaseSpec->getEllipsisLoc())); 7111 ImportedCXXBaseSpecifiers[BaseSpec] = Imported; 7112 return Imported; 7113 } 7114 7115 void ASTImporter::ImportDefinition(Decl *From) { 7116 Decl *To = Import(From); 7117 if (!To) 7118 return; 7119 7120 if (auto *FromDC = cast<DeclContext>(From)) { 7121 ASTNodeImporter Importer(*this); 7122 7123 if (auto *ToRecord = dyn_cast<RecordDecl>(To)) { 7124 if (!ToRecord->getDefinition()) { 7125 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 7126 ASTNodeImporter::IDK_Everything); 7127 return; 7128 } 7129 } 7130 7131 if (auto *ToEnum = dyn_cast<EnumDecl>(To)) { 7132 if (!ToEnum->getDefinition()) { 7133 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 7134 ASTNodeImporter::IDK_Everything); 7135 return; 7136 } 7137 } 7138 7139 if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 7140 if (!ToIFace->getDefinition()) { 7141 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace, 7142 ASTNodeImporter::IDK_Everything); 7143 return; 7144 } 7145 } 7146 7147 if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 7148 if (!ToProto->getDefinition()) { 7149 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto, 7150 ASTNodeImporter::IDK_Everything); 7151 return; 7152 } 7153 } 7154 7155 Importer.ImportDeclContext(FromDC, true); 7156 } 7157 } 7158 7159 DeclarationName ASTImporter::Import(DeclarationName FromName) { 7160 if (!FromName) 7161 return {}; 7162 7163 switch (FromName.getNameKind()) { 7164 case DeclarationName::Identifier: 7165 return Import(FromName.getAsIdentifierInfo()); 7166 7167 case DeclarationName::ObjCZeroArgSelector: 7168 case DeclarationName::ObjCOneArgSelector: 7169 case DeclarationName::ObjCMultiArgSelector: 7170 return Import(FromName.getObjCSelector()); 7171 7172 case DeclarationName::CXXConstructorName: { 7173 QualType T = Import(FromName.getCXXNameType()); 7174 if (T.isNull()) 7175 return {}; 7176 7177 return ToContext.DeclarationNames.getCXXConstructorName( 7178 ToContext.getCanonicalType(T)); 7179 } 7180 7181 case DeclarationName::CXXDestructorName: { 7182 QualType T = Import(FromName.getCXXNameType()); 7183 if (T.isNull()) 7184 return {}; 7185 7186 return ToContext.DeclarationNames.getCXXDestructorName( 7187 ToContext.getCanonicalType(T)); 7188 } 7189 7190 case DeclarationName::CXXDeductionGuideName: { 7191 auto *Template = cast_or_null<TemplateDecl>( 7192 Import(FromName.getCXXDeductionGuideTemplate())); 7193 if (!Template) 7194 return {}; 7195 return ToContext.DeclarationNames.getCXXDeductionGuideName(Template); 7196 } 7197 7198 case DeclarationName::CXXConversionFunctionName: { 7199 QualType T = Import(FromName.getCXXNameType()); 7200 if (T.isNull()) 7201 return {}; 7202 7203 return ToContext.DeclarationNames.getCXXConversionFunctionName( 7204 ToContext.getCanonicalType(T)); 7205 } 7206 7207 case DeclarationName::CXXOperatorName: 7208 return ToContext.DeclarationNames.getCXXOperatorName( 7209 FromName.getCXXOverloadedOperator()); 7210 7211 case DeclarationName::CXXLiteralOperatorName: 7212 return ToContext.DeclarationNames.getCXXLiteralOperatorName( 7213 Import(FromName.getCXXLiteralIdentifier())); 7214 7215 case DeclarationName::CXXUsingDirective: 7216 // FIXME: STATICS! 7217 return DeclarationName::getUsingDirectiveName(); 7218 } 7219 7220 llvm_unreachable("Invalid DeclarationName Kind!"); 7221 } 7222 7223 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 7224 if (!FromId) 7225 return nullptr; 7226 7227 IdentifierInfo *ToId = &ToContext.Idents.get(FromId->getName()); 7228 7229 if (!ToId->getBuiltinID() && FromId->getBuiltinID()) 7230 ToId->setBuiltinID(FromId->getBuiltinID()); 7231 7232 return ToId; 7233 } 7234 7235 Selector ASTImporter::Import(Selector FromSel) { 7236 if (FromSel.isNull()) 7237 return {}; 7238 7239 SmallVector<IdentifierInfo *, 4> Idents; 7240 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 7241 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 7242 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 7243 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 7244 } 7245 7246 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name, 7247 DeclContext *DC, 7248 unsigned IDNS, 7249 NamedDecl **Decls, 7250 unsigned NumDecls) { 7251 return Name; 7252 } 7253 7254 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 7255 if (LastDiagFromFrom) 7256 ToContext.getDiagnostics().notePriorDiagnosticFrom( 7257 FromContext.getDiagnostics()); 7258 LastDiagFromFrom = false; 7259 return ToContext.getDiagnostics().Report(Loc, DiagID); 7260 } 7261 7262 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 7263 if (!LastDiagFromFrom) 7264 FromContext.getDiagnostics().notePriorDiagnosticFrom( 7265 ToContext.getDiagnostics()); 7266 LastDiagFromFrom = true; 7267 return FromContext.getDiagnostics().Report(Loc, DiagID); 7268 } 7269 7270 void ASTImporter::CompleteDecl (Decl *D) { 7271 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 7272 if (!ID->getDefinition()) 7273 ID->startDefinition(); 7274 } 7275 else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) { 7276 if (!PD->getDefinition()) 7277 PD->startDefinition(); 7278 } 7279 else if (auto *TD = dyn_cast<TagDecl>(D)) { 7280 if (!TD->getDefinition() && !TD->isBeingDefined()) { 7281 TD->startDefinition(); 7282 TD->setCompleteDefinition(true); 7283 } 7284 } 7285 else { 7286 assert(0 && "CompleteDecl called on a Decl that can't be completed"); 7287 } 7288 } 7289 7290 Decl *ASTImporter::Imported(Decl *From, Decl *To) { 7291 if (From->hasAttrs()) { 7292 for (const auto *FromAttr : From->getAttrs()) 7293 To->addAttr(Import(FromAttr)); 7294 } 7295 if (From->isUsed()) { 7296 To->setIsUsed(); 7297 } 7298 if (From->isImplicit()) { 7299 To->setImplicit(); 7300 } 7301 ImportedDecls[From] = To; 7302 return To; 7303 } 7304 7305 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 7306 bool Complain) { 7307 llvm::DenseMap<const Type *, const Type *>::iterator Pos 7308 = ImportedTypes.find(From.getTypePtr()); 7309 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To)) 7310 return true; 7311 7312 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 7313 false, Complain); 7314 return Ctx.IsStructurallyEquivalent(From, To); 7315 } 7316