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