1 //===--- ASTImporter.cpp - Importing ASTs from other Contexts ---*- C++ -*-===// 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 #include "clang/AST/ASTImporter.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/ASTDiagnostic.h" 17 #include "clang/AST/DeclCXX.h" 18 #include "clang/AST/DeclObjC.h" 19 #include "clang/AST/DeclVisitor.h" 20 #include "clang/AST/StmtVisitor.h" 21 #include "clang/AST/TypeVisitor.h" 22 #include "clang/Basic/FileManager.h" 23 #include "clang/Basic/SourceManager.h" 24 #include "llvm/Support/MemoryBuffer.h" 25 #include <deque> 26 27 namespace clang { 28 class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, QualType>, 29 public DeclVisitor<ASTNodeImporter, Decl *>, 30 public StmtVisitor<ASTNodeImporter, Stmt *> { 31 ASTImporter &Importer; 32 33 public: 34 explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) { } 35 36 using TypeVisitor<ASTNodeImporter, QualType>::Visit; 37 using DeclVisitor<ASTNodeImporter, Decl *>::Visit; 38 using StmtVisitor<ASTNodeImporter, Stmt *>::Visit; 39 40 // Importing types 41 QualType VisitType(const Type *T); 42 QualType VisitBuiltinType(const BuiltinType *T); 43 QualType VisitComplexType(const ComplexType *T); 44 QualType VisitPointerType(const PointerType *T); 45 QualType VisitBlockPointerType(const BlockPointerType *T); 46 QualType VisitLValueReferenceType(const LValueReferenceType *T); 47 QualType VisitRValueReferenceType(const RValueReferenceType *T); 48 QualType VisitMemberPointerType(const MemberPointerType *T); 49 QualType VisitConstantArrayType(const ConstantArrayType *T); 50 QualType VisitIncompleteArrayType(const IncompleteArrayType *T); 51 QualType VisitVariableArrayType(const VariableArrayType *T); 52 // FIXME: DependentSizedArrayType 53 // FIXME: DependentSizedExtVectorType 54 QualType VisitVectorType(const VectorType *T); 55 QualType VisitExtVectorType(const ExtVectorType *T); 56 QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T); 57 QualType VisitFunctionProtoType(const FunctionProtoType *T); 58 // FIXME: UnresolvedUsingType 59 QualType VisitParenType(const ParenType *T); 60 QualType VisitTypedefType(const TypedefType *T); 61 QualType VisitTypeOfExprType(const TypeOfExprType *T); 62 // FIXME: DependentTypeOfExprType 63 QualType VisitTypeOfType(const TypeOfType *T); 64 QualType VisitDecltypeType(const DecltypeType *T); 65 QualType VisitUnaryTransformType(const UnaryTransformType *T); 66 QualType VisitAutoType(const AutoType *T); 67 // FIXME: DependentDecltypeType 68 QualType VisitRecordType(const RecordType *T); 69 QualType VisitEnumType(const EnumType *T); 70 QualType VisitAttributedType(const AttributedType *T); 71 // FIXME: TemplateTypeParmType 72 // FIXME: SubstTemplateTypeParmType 73 QualType VisitTemplateSpecializationType(const TemplateSpecializationType *T); 74 QualType VisitElaboratedType(const ElaboratedType *T); 75 // FIXME: DependentNameType 76 // FIXME: DependentTemplateSpecializationType 77 QualType VisitObjCInterfaceType(const ObjCInterfaceType *T); 78 QualType VisitObjCObjectType(const ObjCObjectType *T); 79 QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T); 80 81 // Importing declarations 82 bool ImportDeclParts(NamedDecl *D, DeclContext *&DC, 83 DeclContext *&LexicalDC, DeclarationName &Name, 84 NamedDecl *&ToD, SourceLocation &Loc); 85 void ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr); 86 void ImportDeclarationNameLoc(const DeclarationNameInfo &From, 87 DeclarationNameInfo& To); 88 void ImportDeclContext(DeclContext *FromDC, bool ForceImport = false); 89 90 /// \brief What we should import from the definition. 91 enum ImportDefinitionKind { 92 /// \brief Import the default subset of the definition, which might be 93 /// nothing (if minimal import is set) or might be everything (if minimal 94 /// import is not set). 95 IDK_Default, 96 /// \brief Import everything. 97 IDK_Everything, 98 /// \brief Import only the bare bones needed to establish a valid 99 /// DeclContext. 100 IDK_Basic 101 }; 102 103 bool shouldForceImportDeclContext(ImportDefinitionKind IDK) { 104 return IDK == IDK_Everything || 105 (IDK == IDK_Default && !Importer.isMinimalImport()); 106 } 107 108 bool ImportDefinition(RecordDecl *From, RecordDecl *To, 109 ImportDefinitionKind Kind = IDK_Default); 110 bool ImportDefinition(VarDecl *From, VarDecl *To, 111 ImportDefinitionKind Kind = IDK_Default); 112 bool ImportDefinition(EnumDecl *From, EnumDecl *To, 113 ImportDefinitionKind Kind = IDK_Default); 114 bool ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, 115 ImportDefinitionKind Kind = IDK_Default); 116 bool ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To, 117 ImportDefinitionKind Kind = IDK_Default); 118 TemplateParameterList *ImportTemplateParameterList( 119 TemplateParameterList *Params); 120 TemplateArgument ImportTemplateArgument(const TemplateArgument &From); 121 bool ImportTemplateArguments(const TemplateArgument *FromArgs, 122 unsigned NumFromArgs, 123 SmallVectorImpl<TemplateArgument> &ToArgs); 124 bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord, 125 bool Complain = true); 126 bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 127 bool Complain = true); 128 bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord); 129 bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC); 130 bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To); 131 bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To); 132 Decl *VisitDecl(Decl *D); 133 Decl *VisitTranslationUnitDecl(TranslationUnitDecl *D); 134 Decl *VisitNamespaceDecl(NamespaceDecl *D); 135 Decl *VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias); 136 Decl *VisitTypedefDecl(TypedefDecl *D); 137 Decl *VisitTypeAliasDecl(TypeAliasDecl *D); 138 Decl *VisitEnumDecl(EnumDecl *D); 139 Decl *VisitRecordDecl(RecordDecl *D); 140 Decl *VisitEnumConstantDecl(EnumConstantDecl *D); 141 Decl *VisitFunctionDecl(FunctionDecl *D); 142 Decl *VisitCXXMethodDecl(CXXMethodDecl *D); 143 Decl *VisitCXXConstructorDecl(CXXConstructorDecl *D); 144 Decl *VisitCXXDestructorDecl(CXXDestructorDecl *D); 145 Decl *VisitCXXConversionDecl(CXXConversionDecl *D); 146 Decl *VisitFieldDecl(FieldDecl *D); 147 Decl *VisitIndirectFieldDecl(IndirectFieldDecl *D); 148 Decl *VisitObjCIvarDecl(ObjCIvarDecl *D); 149 Decl *VisitVarDecl(VarDecl *D); 150 Decl *VisitImplicitParamDecl(ImplicitParamDecl *D); 151 Decl *VisitParmVarDecl(ParmVarDecl *D); 152 Decl *VisitObjCMethodDecl(ObjCMethodDecl *D); 153 Decl *VisitObjCTypeParamDecl(ObjCTypeParamDecl *D); 154 Decl *VisitObjCCategoryDecl(ObjCCategoryDecl *D); 155 Decl *VisitObjCProtocolDecl(ObjCProtocolDecl *D); 156 Decl *VisitLinkageSpecDecl(LinkageSpecDecl *D); 157 158 ObjCTypeParamList *ImportObjCTypeParamList(ObjCTypeParamList *list); 159 Decl *VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 160 Decl *VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 161 Decl *VisitObjCImplementationDecl(ObjCImplementationDecl *D); 162 Decl *VisitObjCPropertyDecl(ObjCPropertyDecl *D); 163 Decl *VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 164 Decl *VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); 165 Decl *VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); 166 Decl *VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); 167 Decl *VisitClassTemplateDecl(ClassTemplateDecl *D); 168 Decl *VisitClassTemplateSpecializationDecl( 169 ClassTemplateSpecializationDecl *D); 170 Decl *VisitVarTemplateDecl(VarTemplateDecl *D); 171 Decl *VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D); 172 173 // Importing statements 174 DeclGroupRef ImportDeclGroup(DeclGroupRef DG); 175 176 Stmt *VisitStmt(Stmt *S); 177 Stmt *VisitDeclStmt(DeclStmt *S); 178 Stmt *VisitNullStmt(NullStmt *S); 179 Stmt *VisitCompoundStmt(CompoundStmt *S); 180 Stmt *VisitCaseStmt(CaseStmt *S); 181 Stmt *VisitDefaultStmt(DefaultStmt *S); 182 Stmt *VisitLabelStmt(LabelStmt *S); 183 Stmt *VisitAttributedStmt(AttributedStmt *S); 184 Stmt *VisitIfStmt(IfStmt *S); 185 Stmt *VisitSwitchStmt(SwitchStmt *S); 186 Stmt *VisitWhileStmt(WhileStmt *S); 187 Stmt *VisitDoStmt(DoStmt *S); 188 Stmt *VisitForStmt(ForStmt *S); 189 Stmt *VisitGotoStmt(GotoStmt *S); 190 Stmt *VisitIndirectGotoStmt(IndirectGotoStmt *S); 191 Stmt *VisitContinueStmt(ContinueStmt *S); 192 Stmt *VisitBreakStmt(BreakStmt *S); 193 Stmt *VisitReturnStmt(ReturnStmt *S); 194 // FIXME: GCCAsmStmt 195 // FIXME: MSAsmStmt 196 // FIXME: SEHExceptStmt 197 // FIXME: SEHFinallyStmt 198 // FIXME: SEHTryStmt 199 // FIXME: SEHLeaveStmt 200 // FIXME: CapturedStmt 201 Stmt *VisitCXXCatchStmt(CXXCatchStmt *S); 202 Stmt *VisitCXXTryStmt(CXXTryStmt *S); 203 Stmt *VisitCXXForRangeStmt(CXXForRangeStmt *S); 204 // FIXME: MSDependentExistsStmt 205 Stmt *VisitObjCForCollectionStmt(ObjCForCollectionStmt *S); 206 Stmt *VisitObjCAtCatchStmt(ObjCAtCatchStmt *S); 207 Stmt *VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S); 208 Stmt *VisitObjCAtTryStmt(ObjCAtTryStmt *S); 209 Stmt *VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S); 210 Stmt *VisitObjCAtThrowStmt(ObjCAtThrowStmt *S); 211 Stmt *VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); 212 213 // Importing expressions 214 Expr *VisitExpr(Expr *E); 215 Expr *VisitDeclRefExpr(DeclRefExpr *E); 216 Expr *VisitIntegerLiteral(IntegerLiteral *E); 217 Expr *VisitCharacterLiteral(CharacterLiteral *E); 218 Expr *VisitParenExpr(ParenExpr *E); 219 Expr *VisitUnaryOperator(UnaryOperator *E); 220 Expr *VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E); 221 Expr *VisitBinaryOperator(BinaryOperator *E); 222 Expr *VisitCompoundAssignOperator(CompoundAssignOperator *E); 223 Expr *VisitImplicitCastExpr(ImplicitCastExpr *E); 224 Expr *VisitCStyleCastExpr(CStyleCastExpr *E); 225 Expr *VisitCXXConstructExpr(CXXConstructExpr *E); 226 Expr *VisitMemberExpr(MemberExpr *E); 227 Expr *VisitCallExpr(CallExpr *E); 228 }; 229 } 230 using namespace clang; 231 232 //---------------------------------------------------------------------------- 233 // Structural Equivalence 234 //---------------------------------------------------------------------------- 235 236 namespace { 237 struct StructuralEquivalenceContext { 238 /// \brief AST contexts for which we are checking structural equivalence. 239 ASTContext &C1, &C2; 240 241 /// \brief The set of "tentative" equivalences between two canonical 242 /// declarations, mapping from a declaration in the first context to the 243 /// declaration in the second context that we believe to be equivalent. 244 llvm::DenseMap<Decl *, Decl *> TentativeEquivalences; 245 246 /// \brief Queue of declarations in the first context whose equivalence 247 /// with a declaration in the second context still needs to be verified. 248 std::deque<Decl *> DeclsToCheck; 249 250 /// \brief Declaration (from, to) pairs that are known not to be equivalent 251 /// (which we have already complained about). 252 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls; 253 254 /// \brief Whether we're being strict about the spelling of types when 255 /// unifying two types. 256 bool StrictTypeSpelling; 257 258 /// \brief Whether to complain about failures. 259 bool Complain; 260 261 /// \brief \c true if the last diagnostic came from C2. 262 bool LastDiagFromC2; 263 264 StructuralEquivalenceContext(ASTContext &C1, ASTContext &C2, 265 llvm::DenseSet<std::pair<Decl *, Decl *> > &NonEquivalentDecls, 266 bool StrictTypeSpelling = false, 267 bool Complain = true) 268 : C1(C1), C2(C2), NonEquivalentDecls(NonEquivalentDecls), 269 StrictTypeSpelling(StrictTypeSpelling), Complain(Complain), 270 LastDiagFromC2(false) {} 271 272 /// \brief Determine whether the two declarations are structurally 273 /// equivalent. 274 bool IsStructurallyEquivalent(Decl *D1, Decl *D2); 275 276 /// \brief Determine whether the two types are structurally equivalent. 277 bool IsStructurallyEquivalent(QualType T1, QualType T2); 278 279 private: 280 /// \brief Finish checking all of the structural equivalences. 281 /// 282 /// \returns true if an error occurred, false otherwise. 283 bool Finish(); 284 285 public: 286 DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID) { 287 assert(Complain && "Not allowed to complain"); 288 if (LastDiagFromC2) 289 C1.getDiagnostics().notePriorDiagnosticFrom(C2.getDiagnostics()); 290 LastDiagFromC2 = false; 291 return C1.getDiagnostics().Report(Loc, DiagID); 292 } 293 294 DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID) { 295 assert(Complain && "Not allowed to complain"); 296 if (!LastDiagFromC2) 297 C2.getDiagnostics().notePriorDiagnosticFrom(C1.getDiagnostics()); 298 LastDiagFromC2 = true; 299 return C2.getDiagnostics().Report(Loc, DiagID); 300 } 301 }; 302 } 303 304 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 305 QualType T1, QualType T2); 306 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 307 Decl *D1, Decl *D2); 308 309 /// \brief Determine structural equivalence of two expressions. 310 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 311 Expr *E1, Expr *E2) { 312 if (!E1 || !E2) 313 return E1 == E2; 314 315 // FIXME: Actually perform a structural comparison! 316 return true; 317 } 318 319 /// \brief Determine whether two identifiers are equivalent. 320 static bool IsStructurallyEquivalent(const IdentifierInfo *Name1, 321 const IdentifierInfo *Name2) { 322 if (!Name1 || !Name2) 323 return Name1 == Name2; 324 325 return Name1->getName() == Name2->getName(); 326 } 327 328 /// \brief Determine whether two nested-name-specifiers are equivalent. 329 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 330 NestedNameSpecifier *NNS1, 331 NestedNameSpecifier *NNS2) { 332 // FIXME: Implement! 333 return true; 334 } 335 336 /// \brief Determine whether two template arguments are equivalent. 337 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 338 const TemplateArgument &Arg1, 339 const TemplateArgument &Arg2) { 340 if (Arg1.getKind() != Arg2.getKind()) 341 return false; 342 343 switch (Arg1.getKind()) { 344 case TemplateArgument::Null: 345 return true; 346 347 case TemplateArgument::Type: 348 return Context.IsStructurallyEquivalent(Arg1.getAsType(), Arg2.getAsType()); 349 350 case TemplateArgument::Integral: 351 if (!Context.IsStructurallyEquivalent(Arg1.getIntegralType(), 352 Arg2.getIntegralType())) 353 return false; 354 355 return llvm::APSInt::isSameValue(Arg1.getAsIntegral(), Arg2.getAsIntegral()); 356 357 case TemplateArgument::Declaration: 358 return Context.IsStructurallyEquivalent(Arg1.getAsDecl(), Arg2.getAsDecl()); 359 360 case TemplateArgument::NullPtr: 361 return true; // FIXME: Is this correct? 362 363 case TemplateArgument::Template: 364 return IsStructurallyEquivalent(Context, 365 Arg1.getAsTemplate(), 366 Arg2.getAsTemplate()); 367 368 case TemplateArgument::TemplateExpansion: 369 return IsStructurallyEquivalent(Context, 370 Arg1.getAsTemplateOrTemplatePattern(), 371 Arg2.getAsTemplateOrTemplatePattern()); 372 373 case TemplateArgument::Expression: 374 return IsStructurallyEquivalent(Context, 375 Arg1.getAsExpr(), Arg2.getAsExpr()); 376 377 case TemplateArgument::Pack: 378 if (Arg1.pack_size() != Arg2.pack_size()) 379 return false; 380 381 for (unsigned I = 0, N = Arg1.pack_size(); I != N; ++I) 382 if (!IsStructurallyEquivalent(Context, 383 Arg1.pack_begin()[I], 384 Arg2.pack_begin()[I])) 385 return false; 386 387 return true; 388 } 389 390 llvm_unreachable("Invalid template argument kind"); 391 } 392 393 /// \brief Determine structural equivalence for the common part of array 394 /// types. 395 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context, 396 const ArrayType *Array1, 397 const ArrayType *Array2) { 398 if (!IsStructurallyEquivalent(Context, 399 Array1->getElementType(), 400 Array2->getElementType())) 401 return false; 402 if (Array1->getSizeModifier() != Array2->getSizeModifier()) 403 return false; 404 if (Array1->getIndexTypeQualifiers() != Array2->getIndexTypeQualifiers()) 405 return false; 406 407 return true; 408 } 409 410 /// \brief Determine structural equivalence of two types. 411 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 412 QualType T1, QualType T2) { 413 if (T1.isNull() || T2.isNull()) 414 return T1.isNull() && T2.isNull(); 415 416 if (!Context.StrictTypeSpelling) { 417 // We aren't being strict about token-to-token equivalence of types, 418 // so map down to the canonical type. 419 T1 = Context.C1.getCanonicalType(T1); 420 T2 = Context.C2.getCanonicalType(T2); 421 } 422 423 if (T1.getQualifiers() != T2.getQualifiers()) 424 return false; 425 426 Type::TypeClass TC = T1->getTypeClass(); 427 428 if (T1->getTypeClass() != T2->getTypeClass()) { 429 // Compare function types with prototypes vs. without prototypes as if 430 // both did not have prototypes. 431 if (T1->getTypeClass() == Type::FunctionProto && 432 T2->getTypeClass() == Type::FunctionNoProto) 433 TC = Type::FunctionNoProto; 434 else if (T1->getTypeClass() == Type::FunctionNoProto && 435 T2->getTypeClass() == Type::FunctionProto) 436 TC = Type::FunctionNoProto; 437 else 438 return false; 439 } 440 441 switch (TC) { 442 case Type::Builtin: 443 // FIXME: Deal with Char_S/Char_U. 444 if (cast<BuiltinType>(T1)->getKind() != cast<BuiltinType>(T2)->getKind()) 445 return false; 446 break; 447 448 case Type::Complex: 449 if (!IsStructurallyEquivalent(Context, 450 cast<ComplexType>(T1)->getElementType(), 451 cast<ComplexType>(T2)->getElementType())) 452 return false; 453 break; 454 455 case Type::Adjusted: 456 case Type::Decayed: 457 if (!IsStructurallyEquivalent(Context, 458 cast<AdjustedType>(T1)->getOriginalType(), 459 cast<AdjustedType>(T2)->getOriginalType())) 460 return false; 461 break; 462 463 case Type::Pointer: 464 if (!IsStructurallyEquivalent(Context, 465 cast<PointerType>(T1)->getPointeeType(), 466 cast<PointerType>(T2)->getPointeeType())) 467 return false; 468 break; 469 470 case Type::BlockPointer: 471 if (!IsStructurallyEquivalent(Context, 472 cast<BlockPointerType>(T1)->getPointeeType(), 473 cast<BlockPointerType>(T2)->getPointeeType())) 474 return false; 475 break; 476 477 case Type::LValueReference: 478 case Type::RValueReference: { 479 const ReferenceType *Ref1 = cast<ReferenceType>(T1); 480 const ReferenceType *Ref2 = cast<ReferenceType>(T2); 481 if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue()) 482 return false; 483 if (Ref1->isInnerRef() != Ref2->isInnerRef()) 484 return false; 485 if (!IsStructurallyEquivalent(Context, 486 Ref1->getPointeeTypeAsWritten(), 487 Ref2->getPointeeTypeAsWritten())) 488 return false; 489 break; 490 } 491 492 case Type::MemberPointer: { 493 const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1); 494 const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2); 495 if (!IsStructurallyEquivalent(Context, 496 MemPtr1->getPointeeType(), 497 MemPtr2->getPointeeType())) 498 return false; 499 if (!IsStructurallyEquivalent(Context, 500 QualType(MemPtr1->getClass(), 0), 501 QualType(MemPtr2->getClass(), 0))) 502 return false; 503 break; 504 } 505 506 case Type::ConstantArray: { 507 const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1); 508 const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2); 509 if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize())) 510 return false; 511 512 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2)) 513 return false; 514 break; 515 } 516 517 case Type::IncompleteArray: 518 if (!IsArrayStructurallyEquivalent(Context, 519 cast<ArrayType>(T1), 520 cast<ArrayType>(T2))) 521 return false; 522 break; 523 524 case Type::VariableArray: { 525 const VariableArrayType *Array1 = cast<VariableArrayType>(T1); 526 const VariableArrayType *Array2 = cast<VariableArrayType>(T2); 527 if (!IsStructurallyEquivalent(Context, 528 Array1->getSizeExpr(), Array2->getSizeExpr())) 529 return false; 530 531 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2)) 532 return false; 533 534 break; 535 } 536 537 case Type::DependentSizedArray: { 538 const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1); 539 const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2); 540 if (!IsStructurallyEquivalent(Context, 541 Array1->getSizeExpr(), Array2->getSizeExpr())) 542 return false; 543 544 if (!IsArrayStructurallyEquivalent(Context, Array1, Array2)) 545 return false; 546 547 break; 548 } 549 550 case Type::DependentSizedExtVector: { 551 const DependentSizedExtVectorType *Vec1 552 = cast<DependentSizedExtVectorType>(T1); 553 const DependentSizedExtVectorType *Vec2 554 = cast<DependentSizedExtVectorType>(T2); 555 if (!IsStructurallyEquivalent(Context, 556 Vec1->getSizeExpr(), Vec2->getSizeExpr())) 557 return false; 558 if (!IsStructurallyEquivalent(Context, 559 Vec1->getElementType(), 560 Vec2->getElementType())) 561 return false; 562 break; 563 } 564 565 case Type::Vector: 566 case Type::ExtVector: { 567 const VectorType *Vec1 = cast<VectorType>(T1); 568 const VectorType *Vec2 = cast<VectorType>(T2); 569 if (!IsStructurallyEquivalent(Context, 570 Vec1->getElementType(), 571 Vec2->getElementType())) 572 return false; 573 if (Vec1->getNumElements() != Vec2->getNumElements()) 574 return false; 575 if (Vec1->getVectorKind() != Vec2->getVectorKind()) 576 return false; 577 break; 578 } 579 580 case Type::FunctionProto: { 581 const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1); 582 const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2); 583 if (Proto1->getNumParams() != Proto2->getNumParams()) 584 return false; 585 for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) { 586 if (!IsStructurallyEquivalent(Context, Proto1->getParamType(I), 587 Proto2->getParamType(I))) 588 return false; 589 } 590 if (Proto1->isVariadic() != Proto2->isVariadic()) 591 return false; 592 if (Proto1->getExceptionSpecType() != Proto2->getExceptionSpecType()) 593 return false; 594 if (Proto1->getExceptionSpecType() == EST_Dynamic) { 595 if (Proto1->getNumExceptions() != Proto2->getNumExceptions()) 596 return false; 597 for (unsigned I = 0, N = Proto1->getNumExceptions(); I != N; ++I) { 598 if (!IsStructurallyEquivalent(Context, 599 Proto1->getExceptionType(I), 600 Proto2->getExceptionType(I))) 601 return false; 602 } 603 } else if (Proto1->getExceptionSpecType() == EST_ComputedNoexcept) { 604 if (!IsStructurallyEquivalent(Context, 605 Proto1->getNoexceptExpr(), 606 Proto2->getNoexceptExpr())) 607 return false; 608 } 609 if (Proto1->getTypeQuals() != Proto2->getTypeQuals()) 610 return false; 611 612 // Fall through to check the bits common with FunctionNoProtoType. 613 } 614 615 case Type::FunctionNoProto: { 616 const FunctionType *Function1 = cast<FunctionType>(T1); 617 const FunctionType *Function2 = cast<FunctionType>(T2); 618 if (!IsStructurallyEquivalent(Context, Function1->getReturnType(), 619 Function2->getReturnType())) 620 return false; 621 if (Function1->getExtInfo() != Function2->getExtInfo()) 622 return false; 623 break; 624 } 625 626 case Type::UnresolvedUsing: 627 if (!IsStructurallyEquivalent(Context, 628 cast<UnresolvedUsingType>(T1)->getDecl(), 629 cast<UnresolvedUsingType>(T2)->getDecl())) 630 return false; 631 632 break; 633 634 case Type::Attributed: 635 if (!IsStructurallyEquivalent(Context, 636 cast<AttributedType>(T1)->getModifiedType(), 637 cast<AttributedType>(T2)->getModifiedType())) 638 return false; 639 if (!IsStructurallyEquivalent(Context, 640 cast<AttributedType>(T1)->getEquivalentType(), 641 cast<AttributedType>(T2)->getEquivalentType())) 642 return false; 643 break; 644 645 case Type::Paren: 646 if (!IsStructurallyEquivalent(Context, 647 cast<ParenType>(T1)->getInnerType(), 648 cast<ParenType>(T2)->getInnerType())) 649 return false; 650 break; 651 652 case Type::Typedef: 653 if (!IsStructurallyEquivalent(Context, 654 cast<TypedefType>(T1)->getDecl(), 655 cast<TypedefType>(T2)->getDecl())) 656 return false; 657 break; 658 659 case Type::TypeOfExpr: 660 if (!IsStructurallyEquivalent(Context, 661 cast<TypeOfExprType>(T1)->getUnderlyingExpr(), 662 cast<TypeOfExprType>(T2)->getUnderlyingExpr())) 663 return false; 664 break; 665 666 case Type::TypeOf: 667 if (!IsStructurallyEquivalent(Context, 668 cast<TypeOfType>(T1)->getUnderlyingType(), 669 cast<TypeOfType>(T2)->getUnderlyingType())) 670 return false; 671 break; 672 673 case Type::UnaryTransform: 674 if (!IsStructurallyEquivalent(Context, 675 cast<UnaryTransformType>(T1)->getUnderlyingType(), 676 cast<UnaryTransformType>(T1)->getUnderlyingType())) 677 return false; 678 break; 679 680 case Type::Decltype: 681 if (!IsStructurallyEquivalent(Context, 682 cast<DecltypeType>(T1)->getUnderlyingExpr(), 683 cast<DecltypeType>(T2)->getUnderlyingExpr())) 684 return false; 685 break; 686 687 case Type::Auto: 688 if (!IsStructurallyEquivalent(Context, 689 cast<AutoType>(T1)->getDeducedType(), 690 cast<AutoType>(T2)->getDeducedType())) 691 return false; 692 break; 693 694 case Type::Record: 695 case Type::Enum: 696 if (!IsStructurallyEquivalent(Context, 697 cast<TagType>(T1)->getDecl(), 698 cast<TagType>(T2)->getDecl())) 699 return false; 700 break; 701 702 case Type::TemplateTypeParm: { 703 const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1); 704 const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2); 705 if (Parm1->getDepth() != Parm2->getDepth()) 706 return false; 707 if (Parm1->getIndex() != Parm2->getIndex()) 708 return false; 709 if (Parm1->isParameterPack() != Parm2->isParameterPack()) 710 return false; 711 712 // Names of template type parameters are never significant. 713 break; 714 } 715 716 case Type::SubstTemplateTypeParm: { 717 const SubstTemplateTypeParmType *Subst1 718 = cast<SubstTemplateTypeParmType>(T1); 719 const SubstTemplateTypeParmType *Subst2 720 = cast<SubstTemplateTypeParmType>(T2); 721 if (!IsStructurallyEquivalent(Context, 722 QualType(Subst1->getReplacedParameter(), 0), 723 QualType(Subst2->getReplacedParameter(), 0))) 724 return false; 725 if (!IsStructurallyEquivalent(Context, 726 Subst1->getReplacementType(), 727 Subst2->getReplacementType())) 728 return false; 729 break; 730 } 731 732 case Type::SubstTemplateTypeParmPack: { 733 const SubstTemplateTypeParmPackType *Subst1 734 = cast<SubstTemplateTypeParmPackType>(T1); 735 const SubstTemplateTypeParmPackType *Subst2 736 = cast<SubstTemplateTypeParmPackType>(T2); 737 if (!IsStructurallyEquivalent(Context, 738 QualType(Subst1->getReplacedParameter(), 0), 739 QualType(Subst2->getReplacedParameter(), 0))) 740 return false; 741 if (!IsStructurallyEquivalent(Context, 742 Subst1->getArgumentPack(), 743 Subst2->getArgumentPack())) 744 return false; 745 break; 746 } 747 case Type::TemplateSpecialization: { 748 const TemplateSpecializationType *Spec1 749 = cast<TemplateSpecializationType>(T1); 750 const TemplateSpecializationType *Spec2 751 = cast<TemplateSpecializationType>(T2); 752 if (!IsStructurallyEquivalent(Context, 753 Spec1->getTemplateName(), 754 Spec2->getTemplateName())) 755 return false; 756 if (Spec1->getNumArgs() != Spec2->getNumArgs()) 757 return false; 758 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) { 759 if (!IsStructurallyEquivalent(Context, 760 Spec1->getArg(I), Spec2->getArg(I))) 761 return false; 762 } 763 break; 764 } 765 766 case Type::Elaborated: { 767 const ElaboratedType *Elab1 = cast<ElaboratedType>(T1); 768 const ElaboratedType *Elab2 = cast<ElaboratedType>(T2); 769 // CHECKME: what if a keyword is ETK_None or ETK_typename ? 770 if (Elab1->getKeyword() != Elab2->getKeyword()) 771 return false; 772 if (!IsStructurallyEquivalent(Context, 773 Elab1->getQualifier(), 774 Elab2->getQualifier())) 775 return false; 776 if (!IsStructurallyEquivalent(Context, 777 Elab1->getNamedType(), 778 Elab2->getNamedType())) 779 return false; 780 break; 781 } 782 783 case Type::InjectedClassName: { 784 const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1); 785 const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2); 786 if (!IsStructurallyEquivalent(Context, 787 Inj1->getInjectedSpecializationType(), 788 Inj2->getInjectedSpecializationType())) 789 return false; 790 break; 791 } 792 793 case Type::DependentName: { 794 const DependentNameType *Typename1 = cast<DependentNameType>(T1); 795 const DependentNameType *Typename2 = cast<DependentNameType>(T2); 796 if (!IsStructurallyEquivalent(Context, 797 Typename1->getQualifier(), 798 Typename2->getQualifier())) 799 return false; 800 if (!IsStructurallyEquivalent(Typename1->getIdentifier(), 801 Typename2->getIdentifier())) 802 return false; 803 804 break; 805 } 806 807 case Type::DependentTemplateSpecialization: { 808 const DependentTemplateSpecializationType *Spec1 = 809 cast<DependentTemplateSpecializationType>(T1); 810 const DependentTemplateSpecializationType *Spec2 = 811 cast<DependentTemplateSpecializationType>(T2); 812 if (!IsStructurallyEquivalent(Context, 813 Spec1->getQualifier(), 814 Spec2->getQualifier())) 815 return false; 816 if (!IsStructurallyEquivalent(Spec1->getIdentifier(), 817 Spec2->getIdentifier())) 818 return false; 819 if (Spec1->getNumArgs() != Spec2->getNumArgs()) 820 return false; 821 for (unsigned I = 0, N = Spec1->getNumArgs(); I != N; ++I) { 822 if (!IsStructurallyEquivalent(Context, 823 Spec1->getArg(I), Spec2->getArg(I))) 824 return false; 825 } 826 break; 827 } 828 829 case Type::PackExpansion: 830 if (!IsStructurallyEquivalent(Context, 831 cast<PackExpansionType>(T1)->getPattern(), 832 cast<PackExpansionType>(T2)->getPattern())) 833 return false; 834 break; 835 836 case Type::ObjCInterface: { 837 const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1); 838 const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2); 839 if (!IsStructurallyEquivalent(Context, 840 Iface1->getDecl(), Iface2->getDecl())) 841 return false; 842 break; 843 } 844 845 case Type::ObjCObject: { 846 const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1); 847 const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2); 848 if (!IsStructurallyEquivalent(Context, 849 Obj1->getBaseType(), 850 Obj2->getBaseType())) 851 return false; 852 if (Obj1->getNumProtocols() != Obj2->getNumProtocols()) 853 return false; 854 for (unsigned I = 0, N = Obj1->getNumProtocols(); I != N; ++I) { 855 if (!IsStructurallyEquivalent(Context, 856 Obj1->getProtocol(I), 857 Obj2->getProtocol(I))) 858 return false; 859 } 860 break; 861 } 862 863 case Type::ObjCObjectPointer: { 864 const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1); 865 const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2); 866 if (!IsStructurallyEquivalent(Context, 867 Ptr1->getPointeeType(), 868 Ptr2->getPointeeType())) 869 return false; 870 break; 871 } 872 873 case Type::Atomic: { 874 if (!IsStructurallyEquivalent(Context, 875 cast<AtomicType>(T1)->getValueType(), 876 cast<AtomicType>(T2)->getValueType())) 877 return false; 878 break; 879 } 880 881 } // end switch 882 883 return true; 884 } 885 886 /// \brief Determine structural equivalence of two fields. 887 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 888 FieldDecl *Field1, FieldDecl *Field2) { 889 RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext()); 890 891 // For anonymous structs/unions, match up the anonymous struct/union type 892 // declarations directly, so that we don't go off searching for anonymous 893 // types 894 if (Field1->isAnonymousStructOrUnion() && 895 Field2->isAnonymousStructOrUnion()) { 896 RecordDecl *D1 = Field1->getType()->castAs<RecordType>()->getDecl(); 897 RecordDecl *D2 = Field2->getType()->castAs<RecordType>()->getDecl(); 898 return IsStructurallyEquivalent(Context, D1, D2); 899 } 900 901 // Check for equivalent field names. 902 IdentifierInfo *Name1 = Field1->getIdentifier(); 903 IdentifierInfo *Name2 = Field2->getIdentifier(); 904 if (!::IsStructurallyEquivalent(Name1, Name2)) 905 return false; 906 907 if (!IsStructurallyEquivalent(Context, 908 Field1->getType(), Field2->getType())) { 909 if (Context.Complain) { 910 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent) 911 << Context.C2.getTypeDeclType(Owner2); 912 Context.Diag2(Field2->getLocation(), diag::note_odr_field) 913 << Field2->getDeclName() << Field2->getType(); 914 Context.Diag1(Field1->getLocation(), diag::note_odr_field) 915 << Field1->getDeclName() << Field1->getType(); 916 } 917 return false; 918 } 919 920 if (Field1->isBitField() != Field2->isBitField()) { 921 if (Context.Complain) { 922 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent) 923 << Context.C2.getTypeDeclType(Owner2); 924 if (Field1->isBitField()) { 925 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field) 926 << Field1->getDeclName() << Field1->getType() 927 << Field1->getBitWidthValue(Context.C1); 928 Context.Diag2(Field2->getLocation(), diag::note_odr_not_bit_field) 929 << Field2->getDeclName(); 930 } else { 931 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field) 932 << Field2->getDeclName() << Field2->getType() 933 << Field2->getBitWidthValue(Context.C2); 934 Context.Diag1(Field1->getLocation(), diag::note_odr_not_bit_field) 935 << Field1->getDeclName(); 936 } 937 } 938 return false; 939 } 940 941 if (Field1->isBitField()) { 942 // Make sure that the bit-fields are the same length. 943 unsigned Bits1 = Field1->getBitWidthValue(Context.C1); 944 unsigned Bits2 = Field2->getBitWidthValue(Context.C2); 945 946 if (Bits1 != Bits2) { 947 if (Context.Complain) { 948 Context.Diag2(Owner2->getLocation(), diag::warn_odr_tag_type_inconsistent) 949 << Context.C2.getTypeDeclType(Owner2); 950 Context.Diag2(Field2->getLocation(), diag::note_odr_bit_field) 951 << Field2->getDeclName() << Field2->getType() << Bits2; 952 Context.Diag1(Field1->getLocation(), diag::note_odr_bit_field) 953 << Field1->getDeclName() << Field1->getType() << Bits1; 954 } 955 return false; 956 } 957 } 958 959 return true; 960 } 961 962 /// \brief Find the index of the given anonymous struct/union within its 963 /// context. 964 /// 965 /// \returns Returns the index of this anonymous struct/union in its context, 966 /// including the next assigned index (if none of them match). Returns an 967 /// empty option if the context is not a record, i.e.. if the anonymous 968 /// struct/union is at namespace or block scope. 969 static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) { 970 ASTContext &Context = Anon->getASTContext(); 971 QualType AnonTy = Context.getRecordType(Anon); 972 973 RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext()); 974 if (!Owner) 975 return None; 976 977 unsigned Index = 0; 978 for (const auto *D : Owner->noload_decls()) { 979 const auto *F = dyn_cast<FieldDecl>(D); 980 if (!F || !F->isAnonymousStructOrUnion()) 981 continue; 982 983 if (Context.hasSameType(F->getType(), AnonTy)) 984 break; 985 986 ++Index; 987 } 988 989 return Index; 990 } 991 992 /// \brief Determine structural equivalence of two records. 993 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 994 RecordDecl *D1, RecordDecl *D2) { 995 if (D1->isUnion() != D2->isUnion()) { 996 if (Context.Complain) { 997 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 998 << Context.C2.getTypeDeclType(D2); 999 Context.Diag1(D1->getLocation(), diag::note_odr_tag_kind_here) 1000 << D1->getDeclName() << (unsigned)D1->getTagKind(); 1001 } 1002 return false; 1003 } 1004 1005 if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) { 1006 // If both anonymous structs/unions are in a record context, make sure 1007 // they occur in the same location in the context records. 1008 if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) { 1009 if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) { 1010 if (*Index1 != *Index2) 1011 return false; 1012 } 1013 } 1014 } 1015 1016 // If both declarations are class template specializations, we know 1017 // the ODR applies, so check the template and template arguments. 1018 ClassTemplateSpecializationDecl *Spec1 1019 = dyn_cast<ClassTemplateSpecializationDecl>(D1); 1020 ClassTemplateSpecializationDecl *Spec2 1021 = dyn_cast<ClassTemplateSpecializationDecl>(D2); 1022 if (Spec1 && Spec2) { 1023 // Check that the specialized templates are the same. 1024 if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(), 1025 Spec2->getSpecializedTemplate())) 1026 return false; 1027 1028 // Check that the template arguments are the same. 1029 if (Spec1->getTemplateArgs().size() != Spec2->getTemplateArgs().size()) 1030 return false; 1031 1032 for (unsigned I = 0, N = Spec1->getTemplateArgs().size(); I != N; ++I) 1033 if (!IsStructurallyEquivalent(Context, 1034 Spec1->getTemplateArgs().get(I), 1035 Spec2->getTemplateArgs().get(I))) 1036 return false; 1037 } 1038 // If one is a class template specialization and the other is not, these 1039 // structures are different. 1040 else if (Spec1 || Spec2) 1041 return false; 1042 1043 // Compare the definitions of these two records. If either or both are 1044 // incomplete, we assume that they are equivalent. 1045 D1 = D1->getDefinition(); 1046 D2 = D2->getDefinition(); 1047 if (!D1 || !D2) 1048 return true; 1049 1050 if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) { 1051 if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) { 1052 if (D1CXX->getNumBases() != D2CXX->getNumBases()) { 1053 if (Context.Complain) { 1054 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1055 << Context.C2.getTypeDeclType(D2); 1056 Context.Diag2(D2->getLocation(), diag::note_odr_number_of_bases) 1057 << D2CXX->getNumBases(); 1058 Context.Diag1(D1->getLocation(), diag::note_odr_number_of_bases) 1059 << D1CXX->getNumBases(); 1060 } 1061 return false; 1062 } 1063 1064 // Check the base classes. 1065 for (CXXRecordDecl::base_class_iterator Base1 = D1CXX->bases_begin(), 1066 BaseEnd1 = D1CXX->bases_end(), 1067 Base2 = D2CXX->bases_begin(); 1068 Base1 != BaseEnd1; 1069 ++Base1, ++Base2) { 1070 if (!IsStructurallyEquivalent(Context, 1071 Base1->getType(), Base2->getType())) { 1072 if (Context.Complain) { 1073 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1074 << Context.C2.getTypeDeclType(D2); 1075 Context.Diag2(Base2->getLocStart(), diag::note_odr_base) 1076 << Base2->getType() 1077 << Base2->getSourceRange(); 1078 Context.Diag1(Base1->getLocStart(), diag::note_odr_base) 1079 << Base1->getType() 1080 << Base1->getSourceRange(); 1081 } 1082 return false; 1083 } 1084 1085 // Check virtual vs. non-virtual inheritance mismatch. 1086 if (Base1->isVirtual() != Base2->isVirtual()) { 1087 if (Context.Complain) { 1088 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1089 << Context.C2.getTypeDeclType(D2); 1090 Context.Diag2(Base2->getLocStart(), 1091 diag::note_odr_virtual_base) 1092 << Base2->isVirtual() << Base2->getSourceRange(); 1093 Context.Diag1(Base1->getLocStart(), diag::note_odr_base) 1094 << Base1->isVirtual() 1095 << Base1->getSourceRange(); 1096 } 1097 return false; 1098 } 1099 } 1100 } else if (D1CXX->getNumBases() > 0) { 1101 if (Context.Complain) { 1102 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1103 << Context.C2.getTypeDeclType(D2); 1104 const CXXBaseSpecifier *Base1 = D1CXX->bases_begin(); 1105 Context.Diag1(Base1->getLocStart(), diag::note_odr_base) 1106 << Base1->getType() 1107 << Base1->getSourceRange(); 1108 Context.Diag2(D2->getLocation(), diag::note_odr_missing_base); 1109 } 1110 return false; 1111 } 1112 } 1113 1114 // Check the fields for consistency. 1115 RecordDecl::field_iterator Field2 = D2->field_begin(), 1116 Field2End = D2->field_end(); 1117 for (RecordDecl::field_iterator Field1 = D1->field_begin(), 1118 Field1End = D1->field_end(); 1119 Field1 != Field1End; 1120 ++Field1, ++Field2) { 1121 if (Field2 == Field2End) { 1122 if (Context.Complain) { 1123 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1124 << Context.C2.getTypeDeclType(D2); 1125 Context.Diag1(Field1->getLocation(), diag::note_odr_field) 1126 << Field1->getDeclName() << Field1->getType(); 1127 Context.Diag2(D2->getLocation(), diag::note_odr_missing_field); 1128 } 1129 return false; 1130 } 1131 1132 if (!IsStructurallyEquivalent(Context, *Field1, *Field2)) 1133 return false; 1134 } 1135 1136 if (Field2 != Field2End) { 1137 if (Context.Complain) { 1138 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1139 << Context.C2.getTypeDeclType(D2); 1140 Context.Diag2(Field2->getLocation(), diag::note_odr_field) 1141 << Field2->getDeclName() << Field2->getType(); 1142 Context.Diag1(D1->getLocation(), diag::note_odr_missing_field); 1143 } 1144 return false; 1145 } 1146 1147 return true; 1148 } 1149 1150 /// \brief Determine structural equivalence of two enums. 1151 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1152 EnumDecl *D1, EnumDecl *D2) { 1153 EnumDecl::enumerator_iterator EC2 = D2->enumerator_begin(), 1154 EC2End = D2->enumerator_end(); 1155 for (EnumDecl::enumerator_iterator EC1 = D1->enumerator_begin(), 1156 EC1End = D1->enumerator_end(); 1157 EC1 != EC1End; ++EC1, ++EC2) { 1158 if (EC2 == EC2End) { 1159 if (Context.Complain) { 1160 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1161 << Context.C2.getTypeDeclType(D2); 1162 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator) 1163 << EC1->getDeclName() 1164 << EC1->getInitVal().toString(10); 1165 Context.Diag2(D2->getLocation(), diag::note_odr_missing_enumerator); 1166 } 1167 return false; 1168 } 1169 1170 llvm::APSInt Val1 = EC1->getInitVal(); 1171 llvm::APSInt Val2 = EC2->getInitVal(); 1172 if (!llvm::APSInt::isSameValue(Val1, Val2) || 1173 !IsStructurallyEquivalent(EC1->getIdentifier(), EC2->getIdentifier())) { 1174 if (Context.Complain) { 1175 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1176 << Context.C2.getTypeDeclType(D2); 1177 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator) 1178 << EC2->getDeclName() 1179 << EC2->getInitVal().toString(10); 1180 Context.Diag1(EC1->getLocation(), diag::note_odr_enumerator) 1181 << EC1->getDeclName() 1182 << EC1->getInitVal().toString(10); 1183 } 1184 return false; 1185 } 1186 } 1187 1188 if (EC2 != EC2End) { 1189 if (Context.Complain) { 1190 Context.Diag2(D2->getLocation(), diag::warn_odr_tag_type_inconsistent) 1191 << Context.C2.getTypeDeclType(D2); 1192 Context.Diag2(EC2->getLocation(), diag::note_odr_enumerator) 1193 << EC2->getDeclName() 1194 << EC2->getInitVal().toString(10); 1195 Context.Diag1(D1->getLocation(), diag::note_odr_missing_enumerator); 1196 } 1197 return false; 1198 } 1199 1200 return true; 1201 } 1202 1203 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1204 TemplateParameterList *Params1, 1205 TemplateParameterList *Params2) { 1206 if (Params1->size() != Params2->size()) { 1207 if (Context.Complain) { 1208 Context.Diag2(Params2->getTemplateLoc(), 1209 diag::err_odr_different_num_template_parameters) 1210 << Params1->size() << Params2->size(); 1211 Context.Diag1(Params1->getTemplateLoc(), 1212 diag::note_odr_template_parameter_list); 1213 } 1214 return false; 1215 } 1216 1217 for (unsigned I = 0, N = Params1->size(); I != N; ++I) { 1218 if (Params1->getParam(I)->getKind() != Params2->getParam(I)->getKind()) { 1219 if (Context.Complain) { 1220 Context.Diag2(Params2->getParam(I)->getLocation(), 1221 diag::err_odr_different_template_parameter_kind); 1222 Context.Diag1(Params1->getParam(I)->getLocation(), 1223 diag::note_odr_template_parameter_here); 1224 } 1225 return false; 1226 } 1227 1228 if (!Context.IsStructurallyEquivalent(Params1->getParam(I), 1229 Params2->getParam(I))) { 1230 1231 return false; 1232 } 1233 } 1234 1235 return true; 1236 } 1237 1238 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1239 TemplateTypeParmDecl *D1, 1240 TemplateTypeParmDecl *D2) { 1241 if (D1->isParameterPack() != D2->isParameterPack()) { 1242 if (Context.Complain) { 1243 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack) 1244 << D2->isParameterPack(); 1245 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack) 1246 << D1->isParameterPack(); 1247 } 1248 return false; 1249 } 1250 1251 return true; 1252 } 1253 1254 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1255 NonTypeTemplateParmDecl *D1, 1256 NonTypeTemplateParmDecl *D2) { 1257 if (D1->isParameterPack() != D2->isParameterPack()) { 1258 if (Context.Complain) { 1259 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack) 1260 << D2->isParameterPack(); 1261 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack) 1262 << D1->isParameterPack(); 1263 } 1264 return false; 1265 } 1266 1267 // Check types. 1268 if (!Context.IsStructurallyEquivalent(D1->getType(), D2->getType())) { 1269 if (Context.Complain) { 1270 Context.Diag2(D2->getLocation(), 1271 diag::err_odr_non_type_parameter_type_inconsistent) 1272 << D2->getType() << D1->getType(); 1273 Context.Diag1(D1->getLocation(), diag::note_odr_value_here) 1274 << D1->getType(); 1275 } 1276 return false; 1277 } 1278 1279 return true; 1280 } 1281 1282 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1283 TemplateTemplateParmDecl *D1, 1284 TemplateTemplateParmDecl *D2) { 1285 if (D1->isParameterPack() != D2->isParameterPack()) { 1286 if (Context.Complain) { 1287 Context.Diag2(D2->getLocation(), diag::err_odr_parameter_pack_non_pack) 1288 << D2->isParameterPack(); 1289 Context.Diag1(D1->getLocation(), diag::note_odr_parameter_pack_non_pack) 1290 << D1->isParameterPack(); 1291 } 1292 return false; 1293 } 1294 1295 // Check template parameter lists. 1296 return IsStructurallyEquivalent(Context, D1->getTemplateParameters(), 1297 D2->getTemplateParameters()); 1298 } 1299 1300 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1301 ClassTemplateDecl *D1, 1302 ClassTemplateDecl *D2) { 1303 // Check template parameters. 1304 if (!IsStructurallyEquivalent(Context, 1305 D1->getTemplateParameters(), 1306 D2->getTemplateParameters())) 1307 return false; 1308 1309 // Check the templated declaration. 1310 return Context.IsStructurallyEquivalent(D1->getTemplatedDecl(), 1311 D2->getTemplatedDecl()); 1312 } 1313 1314 /// \brief Determine structural equivalence of two declarations. 1315 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, 1316 Decl *D1, Decl *D2) { 1317 // FIXME: Check for known structural equivalences via a callback of some sort. 1318 1319 // Check whether we already know that these two declarations are not 1320 // structurally equivalent. 1321 if (Context.NonEquivalentDecls.count(std::make_pair(D1->getCanonicalDecl(), 1322 D2->getCanonicalDecl()))) 1323 return false; 1324 1325 // Determine whether we've already produced a tentative equivalence for D1. 1326 Decl *&EquivToD1 = Context.TentativeEquivalences[D1->getCanonicalDecl()]; 1327 if (EquivToD1) 1328 return EquivToD1 == D2->getCanonicalDecl(); 1329 1330 // Produce a tentative equivalence D1 <-> D2, which will be checked later. 1331 EquivToD1 = D2->getCanonicalDecl(); 1332 Context.DeclsToCheck.push_back(D1->getCanonicalDecl()); 1333 return true; 1334 } 1335 1336 bool StructuralEquivalenceContext::IsStructurallyEquivalent(Decl *D1, 1337 Decl *D2) { 1338 if (!::IsStructurallyEquivalent(*this, D1, D2)) 1339 return false; 1340 1341 return !Finish(); 1342 } 1343 1344 bool StructuralEquivalenceContext::IsStructurallyEquivalent(QualType T1, 1345 QualType T2) { 1346 if (!::IsStructurallyEquivalent(*this, T1, T2)) 1347 return false; 1348 1349 return !Finish(); 1350 } 1351 1352 bool StructuralEquivalenceContext::Finish() { 1353 while (!DeclsToCheck.empty()) { 1354 // Check the next declaration. 1355 Decl *D1 = DeclsToCheck.front(); 1356 DeclsToCheck.pop_front(); 1357 1358 Decl *D2 = TentativeEquivalences[D1]; 1359 assert(D2 && "Unrecorded tentative equivalence?"); 1360 1361 bool Equivalent = true; 1362 1363 // FIXME: Switch on all declaration kinds. For now, we're just going to 1364 // check the obvious ones. 1365 if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) { 1366 if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) { 1367 // Check for equivalent structure names. 1368 IdentifierInfo *Name1 = Record1->getIdentifier(); 1369 if (!Name1 && Record1->getTypedefNameForAnonDecl()) 1370 Name1 = Record1->getTypedefNameForAnonDecl()->getIdentifier(); 1371 IdentifierInfo *Name2 = Record2->getIdentifier(); 1372 if (!Name2 && Record2->getTypedefNameForAnonDecl()) 1373 Name2 = Record2->getTypedefNameForAnonDecl()->getIdentifier(); 1374 if (!::IsStructurallyEquivalent(Name1, Name2) || 1375 !::IsStructurallyEquivalent(*this, Record1, Record2)) 1376 Equivalent = false; 1377 } else { 1378 // Record/non-record mismatch. 1379 Equivalent = false; 1380 } 1381 } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) { 1382 if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) { 1383 // Check for equivalent enum names. 1384 IdentifierInfo *Name1 = Enum1->getIdentifier(); 1385 if (!Name1 && Enum1->getTypedefNameForAnonDecl()) 1386 Name1 = Enum1->getTypedefNameForAnonDecl()->getIdentifier(); 1387 IdentifierInfo *Name2 = Enum2->getIdentifier(); 1388 if (!Name2 && Enum2->getTypedefNameForAnonDecl()) 1389 Name2 = Enum2->getTypedefNameForAnonDecl()->getIdentifier(); 1390 if (!::IsStructurallyEquivalent(Name1, Name2) || 1391 !::IsStructurallyEquivalent(*this, Enum1, Enum2)) 1392 Equivalent = false; 1393 } else { 1394 // Enum/non-enum mismatch 1395 Equivalent = false; 1396 } 1397 } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) { 1398 if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) { 1399 if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(), 1400 Typedef2->getIdentifier()) || 1401 !::IsStructurallyEquivalent(*this, 1402 Typedef1->getUnderlyingType(), 1403 Typedef2->getUnderlyingType())) 1404 Equivalent = false; 1405 } else { 1406 // Typedef/non-typedef mismatch. 1407 Equivalent = false; 1408 } 1409 } else if (ClassTemplateDecl *ClassTemplate1 1410 = dyn_cast<ClassTemplateDecl>(D1)) { 1411 if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) { 1412 if (!::IsStructurallyEquivalent(ClassTemplate1->getIdentifier(), 1413 ClassTemplate2->getIdentifier()) || 1414 !::IsStructurallyEquivalent(*this, ClassTemplate1, ClassTemplate2)) 1415 Equivalent = false; 1416 } else { 1417 // Class template/non-class-template mismatch. 1418 Equivalent = false; 1419 } 1420 } else if (TemplateTypeParmDecl *TTP1= dyn_cast<TemplateTypeParmDecl>(D1)) { 1421 if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) { 1422 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2)) 1423 Equivalent = false; 1424 } else { 1425 // Kind mismatch. 1426 Equivalent = false; 1427 } 1428 } else if (NonTypeTemplateParmDecl *NTTP1 1429 = dyn_cast<NonTypeTemplateParmDecl>(D1)) { 1430 if (NonTypeTemplateParmDecl *NTTP2 1431 = dyn_cast<NonTypeTemplateParmDecl>(D2)) { 1432 if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2)) 1433 Equivalent = false; 1434 } else { 1435 // Kind mismatch. 1436 Equivalent = false; 1437 } 1438 } else if (TemplateTemplateParmDecl *TTP1 1439 = dyn_cast<TemplateTemplateParmDecl>(D1)) { 1440 if (TemplateTemplateParmDecl *TTP2 1441 = dyn_cast<TemplateTemplateParmDecl>(D2)) { 1442 if (!::IsStructurallyEquivalent(*this, TTP1, TTP2)) 1443 Equivalent = false; 1444 } else { 1445 // Kind mismatch. 1446 Equivalent = false; 1447 } 1448 } 1449 1450 if (!Equivalent) { 1451 // Note that these two declarations are not equivalent (and we already 1452 // know about it). 1453 NonEquivalentDecls.insert(std::make_pair(D1->getCanonicalDecl(), 1454 D2->getCanonicalDecl())); 1455 return true; 1456 } 1457 // FIXME: Check other declaration kinds! 1458 } 1459 1460 return false; 1461 } 1462 1463 //---------------------------------------------------------------------------- 1464 // Import Types 1465 //---------------------------------------------------------------------------- 1466 1467 QualType ASTNodeImporter::VisitType(const Type *T) { 1468 Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) 1469 << T->getTypeClassName(); 1470 return QualType(); 1471 } 1472 1473 QualType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) { 1474 switch (T->getKind()) { 1475 #define SHARED_SINGLETON_TYPE(Expansion) 1476 #define BUILTIN_TYPE(Id, SingletonId) \ 1477 case BuiltinType::Id: return Importer.getToContext().SingletonId; 1478 #include "clang/AST/BuiltinTypes.def" 1479 1480 // FIXME: for Char16, Char32, and NullPtr, make sure that the "to" 1481 // context supports C++. 1482 1483 // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to" 1484 // context supports ObjC. 1485 1486 case BuiltinType::Char_U: 1487 // The context we're importing from has an unsigned 'char'. If we're 1488 // importing into a context with a signed 'char', translate to 1489 // 'unsigned char' instead. 1490 if (Importer.getToContext().getLangOpts().CharIsSigned) 1491 return Importer.getToContext().UnsignedCharTy; 1492 1493 return Importer.getToContext().CharTy; 1494 1495 case BuiltinType::Char_S: 1496 // The context we're importing from has an unsigned 'char'. If we're 1497 // importing into a context with a signed 'char', translate to 1498 // 'unsigned char' instead. 1499 if (!Importer.getToContext().getLangOpts().CharIsSigned) 1500 return Importer.getToContext().SignedCharTy; 1501 1502 return Importer.getToContext().CharTy; 1503 1504 case BuiltinType::WChar_S: 1505 case BuiltinType::WChar_U: 1506 // FIXME: If not in C++, shall we translate to the C equivalent of 1507 // wchar_t? 1508 return Importer.getToContext().WCharTy; 1509 } 1510 1511 llvm_unreachable("Invalid BuiltinType Kind!"); 1512 } 1513 1514 QualType ASTNodeImporter::VisitComplexType(const ComplexType *T) { 1515 QualType ToElementType = Importer.Import(T->getElementType()); 1516 if (ToElementType.isNull()) 1517 return QualType(); 1518 1519 return Importer.getToContext().getComplexType(ToElementType); 1520 } 1521 1522 QualType ASTNodeImporter::VisitPointerType(const PointerType *T) { 1523 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 1524 if (ToPointeeType.isNull()) 1525 return QualType(); 1526 1527 return Importer.getToContext().getPointerType(ToPointeeType); 1528 } 1529 1530 QualType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) { 1531 // FIXME: Check for blocks support in "to" context. 1532 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 1533 if (ToPointeeType.isNull()) 1534 return QualType(); 1535 1536 return Importer.getToContext().getBlockPointerType(ToPointeeType); 1537 } 1538 1539 QualType 1540 ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) { 1541 // FIXME: Check for C++ support in "to" context. 1542 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 1543 if (ToPointeeType.isNull()) 1544 return QualType(); 1545 1546 return Importer.getToContext().getLValueReferenceType(ToPointeeType); 1547 } 1548 1549 QualType 1550 ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) { 1551 // FIXME: Check for C++0x support in "to" context. 1552 QualType ToPointeeType = Importer.Import(T->getPointeeTypeAsWritten()); 1553 if (ToPointeeType.isNull()) 1554 return QualType(); 1555 1556 return Importer.getToContext().getRValueReferenceType(ToPointeeType); 1557 } 1558 1559 QualType ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) { 1560 // FIXME: Check for C++ support in "to" context. 1561 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 1562 if (ToPointeeType.isNull()) 1563 return QualType(); 1564 1565 QualType ClassType = Importer.Import(QualType(T->getClass(), 0)); 1566 return Importer.getToContext().getMemberPointerType(ToPointeeType, 1567 ClassType.getTypePtr()); 1568 } 1569 1570 QualType ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) { 1571 QualType ToElementType = Importer.Import(T->getElementType()); 1572 if (ToElementType.isNull()) 1573 return QualType(); 1574 1575 return Importer.getToContext().getConstantArrayType(ToElementType, 1576 T->getSize(), 1577 T->getSizeModifier(), 1578 T->getIndexTypeCVRQualifiers()); 1579 } 1580 1581 QualType 1582 ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) { 1583 QualType ToElementType = Importer.Import(T->getElementType()); 1584 if (ToElementType.isNull()) 1585 return QualType(); 1586 1587 return Importer.getToContext().getIncompleteArrayType(ToElementType, 1588 T->getSizeModifier(), 1589 T->getIndexTypeCVRQualifiers()); 1590 } 1591 1592 QualType ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) { 1593 QualType ToElementType = Importer.Import(T->getElementType()); 1594 if (ToElementType.isNull()) 1595 return QualType(); 1596 1597 Expr *Size = Importer.Import(T->getSizeExpr()); 1598 if (!Size) 1599 return QualType(); 1600 1601 SourceRange Brackets = Importer.Import(T->getBracketsRange()); 1602 return Importer.getToContext().getVariableArrayType(ToElementType, Size, 1603 T->getSizeModifier(), 1604 T->getIndexTypeCVRQualifiers(), 1605 Brackets); 1606 } 1607 1608 QualType ASTNodeImporter::VisitVectorType(const VectorType *T) { 1609 QualType ToElementType = Importer.Import(T->getElementType()); 1610 if (ToElementType.isNull()) 1611 return QualType(); 1612 1613 return Importer.getToContext().getVectorType(ToElementType, 1614 T->getNumElements(), 1615 T->getVectorKind()); 1616 } 1617 1618 QualType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) { 1619 QualType ToElementType = Importer.Import(T->getElementType()); 1620 if (ToElementType.isNull()) 1621 return QualType(); 1622 1623 return Importer.getToContext().getExtVectorType(ToElementType, 1624 T->getNumElements()); 1625 } 1626 1627 QualType 1628 ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) { 1629 // FIXME: What happens if we're importing a function without a prototype 1630 // into C++? Should we make it variadic? 1631 QualType ToResultType = Importer.Import(T->getReturnType()); 1632 if (ToResultType.isNull()) 1633 return QualType(); 1634 1635 return Importer.getToContext().getFunctionNoProtoType(ToResultType, 1636 T->getExtInfo()); 1637 } 1638 1639 QualType ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) { 1640 QualType ToResultType = Importer.Import(T->getReturnType()); 1641 if (ToResultType.isNull()) 1642 return QualType(); 1643 1644 // Import argument types 1645 SmallVector<QualType, 4> ArgTypes; 1646 for (const auto &A : T->param_types()) { 1647 QualType ArgType = Importer.Import(A); 1648 if (ArgType.isNull()) 1649 return QualType(); 1650 ArgTypes.push_back(ArgType); 1651 } 1652 1653 // Import exception types 1654 SmallVector<QualType, 4> ExceptionTypes; 1655 for (const auto &E : T->exceptions()) { 1656 QualType ExceptionType = Importer.Import(E); 1657 if (ExceptionType.isNull()) 1658 return QualType(); 1659 ExceptionTypes.push_back(ExceptionType); 1660 } 1661 1662 FunctionProtoType::ExtProtoInfo FromEPI = T->getExtProtoInfo(); 1663 FunctionProtoType::ExtProtoInfo ToEPI; 1664 1665 ToEPI.ExtInfo = FromEPI.ExtInfo; 1666 ToEPI.Variadic = FromEPI.Variadic; 1667 ToEPI.HasTrailingReturn = FromEPI.HasTrailingReturn; 1668 ToEPI.TypeQuals = FromEPI.TypeQuals; 1669 ToEPI.RefQualifier = FromEPI.RefQualifier; 1670 ToEPI.ExceptionSpec.Type = FromEPI.ExceptionSpec.Type; 1671 ToEPI.ExceptionSpec.Exceptions = ExceptionTypes; 1672 ToEPI.ExceptionSpec.NoexceptExpr = 1673 Importer.Import(FromEPI.ExceptionSpec.NoexceptExpr); 1674 ToEPI.ExceptionSpec.SourceDecl = cast_or_null<FunctionDecl>( 1675 Importer.Import(FromEPI.ExceptionSpec.SourceDecl)); 1676 ToEPI.ExceptionSpec.SourceTemplate = cast_or_null<FunctionDecl>( 1677 Importer.Import(FromEPI.ExceptionSpec.SourceTemplate)); 1678 1679 return Importer.getToContext().getFunctionType(ToResultType, ArgTypes, ToEPI); 1680 } 1681 1682 QualType ASTNodeImporter::VisitParenType(const ParenType *T) { 1683 QualType ToInnerType = Importer.Import(T->getInnerType()); 1684 if (ToInnerType.isNull()) 1685 return QualType(); 1686 1687 return Importer.getToContext().getParenType(ToInnerType); 1688 } 1689 1690 QualType ASTNodeImporter::VisitTypedefType(const TypedefType *T) { 1691 TypedefNameDecl *ToDecl 1692 = dyn_cast_or_null<TypedefNameDecl>(Importer.Import(T->getDecl())); 1693 if (!ToDecl) 1694 return QualType(); 1695 1696 return Importer.getToContext().getTypeDeclType(ToDecl); 1697 } 1698 1699 QualType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) { 1700 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 1701 if (!ToExpr) 1702 return QualType(); 1703 1704 return Importer.getToContext().getTypeOfExprType(ToExpr); 1705 } 1706 1707 QualType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) { 1708 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 1709 if (ToUnderlyingType.isNull()) 1710 return QualType(); 1711 1712 return Importer.getToContext().getTypeOfType(ToUnderlyingType); 1713 } 1714 1715 QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) { 1716 // FIXME: Make sure that the "to" context supports C++0x! 1717 Expr *ToExpr = Importer.Import(T->getUnderlyingExpr()); 1718 if (!ToExpr) 1719 return QualType(); 1720 1721 QualType UnderlyingType = Importer.Import(T->getUnderlyingType()); 1722 if (UnderlyingType.isNull()) 1723 return QualType(); 1724 1725 return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType); 1726 } 1727 1728 QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) { 1729 QualType ToBaseType = Importer.Import(T->getBaseType()); 1730 QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType()); 1731 if (ToBaseType.isNull() || ToUnderlyingType.isNull()) 1732 return QualType(); 1733 1734 return Importer.getToContext().getUnaryTransformType(ToBaseType, 1735 ToUnderlyingType, 1736 T->getUTTKind()); 1737 } 1738 1739 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) { 1740 // FIXME: Make sure that the "to" context supports C++11! 1741 QualType FromDeduced = T->getDeducedType(); 1742 QualType ToDeduced; 1743 if (!FromDeduced.isNull()) { 1744 ToDeduced = Importer.Import(FromDeduced); 1745 if (ToDeduced.isNull()) 1746 return QualType(); 1747 } 1748 1749 return Importer.getToContext().getAutoType(ToDeduced, T->getKeyword(), 1750 /*IsDependent*/false); 1751 } 1752 1753 QualType ASTNodeImporter::VisitRecordType(const RecordType *T) { 1754 RecordDecl *ToDecl 1755 = dyn_cast_or_null<RecordDecl>(Importer.Import(T->getDecl())); 1756 if (!ToDecl) 1757 return QualType(); 1758 1759 return Importer.getToContext().getTagDeclType(ToDecl); 1760 } 1761 1762 QualType ASTNodeImporter::VisitEnumType(const EnumType *T) { 1763 EnumDecl *ToDecl 1764 = dyn_cast_or_null<EnumDecl>(Importer.Import(T->getDecl())); 1765 if (!ToDecl) 1766 return QualType(); 1767 1768 return Importer.getToContext().getTagDeclType(ToDecl); 1769 } 1770 1771 QualType ASTNodeImporter::VisitAttributedType(const AttributedType *T) { 1772 QualType FromModifiedType = T->getModifiedType(); 1773 QualType FromEquivalentType = T->getEquivalentType(); 1774 QualType ToModifiedType; 1775 QualType ToEquivalentType; 1776 1777 if (!FromModifiedType.isNull()) { 1778 ToModifiedType = Importer.Import(FromModifiedType); 1779 if (ToModifiedType.isNull()) 1780 return QualType(); 1781 } 1782 if (!FromEquivalentType.isNull()) { 1783 ToEquivalentType = Importer.Import(FromEquivalentType); 1784 if (ToEquivalentType.isNull()) 1785 return QualType(); 1786 } 1787 1788 return Importer.getToContext().getAttributedType(T->getAttrKind(), 1789 ToModifiedType, ToEquivalentType); 1790 } 1791 1792 QualType ASTNodeImporter::VisitTemplateSpecializationType( 1793 const TemplateSpecializationType *T) { 1794 TemplateName ToTemplate = Importer.Import(T->getTemplateName()); 1795 if (ToTemplate.isNull()) 1796 return QualType(); 1797 1798 SmallVector<TemplateArgument, 2> ToTemplateArgs; 1799 if (ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToTemplateArgs)) 1800 return QualType(); 1801 1802 QualType ToCanonType; 1803 if (!QualType(T, 0).isCanonical()) { 1804 QualType FromCanonType 1805 = Importer.getFromContext().getCanonicalType(QualType(T, 0)); 1806 ToCanonType =Importer.Import(FromCanonType); 1807 if (ToCanonType.isNull()) 1808 return QualType(); 1809 } 1810 return Importer.getToContext().getTemplateSpecializationType(ToTemplate, 1811 ToTemplateArgs.data(), 1812 ToTemplateArgs.size(), 1813 ToCanonType); 1814 } 1815 1816 QualType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) { 1817 NestedNameSpecifier *ToQualifier = nullptr; 1818 // Note: the qualifier in an ElaboratedType is optional. 1819 if (T->getQualifier()) { 1820 ToQualifier = Importer.Import(T->getQualifier()); 1821 if (!ToQualifier) 1822 return QualType(); 1823 } 1824 1825 QualType ToNamedType = Importer.Import(T->getNamedType()); 1826 if (ToNamedType.isNull()) 1827 return QualType(); 1828 1829 return Importer.getToContext().getElaboratedType(T->getKeyword(), 1830 ToQualifier, ToNamedType); 1831 } 1832 1833 QualType ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { 1834 ObjCInterfaceDecl *Class 1835 = dyn_cast_or_null<ObjCInterfaceDecl>(Importer.Import(T->getDecl())); 1836 if (!Class) 1837 return QualType(); 1838 1839 return Importer.getToContext().getObjCInterfaceType(Class); 1840 } 1841 1842 QualType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) { 1843 QualType ToBaseType = Importer.Import(T->getBaseType()); 1844 if (ToBaseType.isNull()) 1845 return QualType(); 1846 1847 SmallVector<QualType, 4> TypeArgs; 1848 for (auto TypeArg : T->getTypeArgsAsWritten()) { 1849 QualType ImportedTypeArg = Importer.Import(TypeArg); 1850 if (ImportedTypeArg.isNull()) 1851 return QualType(); 1852 1853 TypeArgs.push_back(ImportedTypeArg); 1854 } 1855 1856 SmallVector<ObjCProtocolDecl *, 4> Protocols; 1857 for (auto *P : T->quals()) { 1858 ObjCProtocolDecl *Protocol 1859 = dyn_cast_or_null<ObjCProtocolDecl>(Importer.Import(P)); 1860 if (!Protocol) 1861 return QualType(); 1862 Protocols.push_back(Protocol); 1863 } 1864 1865 return Importer.getToContext().getObjCObjectType(ToBaseType, TypeArgs, 1866 Protocols, 1867 T->isKindOfTypeAsWritten()); 1868 } 1869 1870 QualType 1871 ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { 1872 QualType ToPointeeType = Importer.Import(T->getPointeeType()); 1873 if (ToPointeeType.isNull()) 1874 return QualType(); 1875 1876 return Importer.getToContext().getObjCObjectPointerType(ToPointeeType); 1877 } 1878 1879 //---------------------------------------------------------------------------- 1880 // Import Declarations 1881 //---------------------------------------------------------------------------- 1882 bool ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, 1883 DeclContext *&LexicalDC, 1884 DeclarationName &Name, 1885 NamedDecl *&ToD, 1886 SourceLocation &Loc) { 1887 // Import the context of this declaration. 1888 DC = Importer.ImportContext(D->getDeclContext()); 1889 if (!DC) 1890 return true; 1891 1892 LexicalDC = DC; 1893 if (D->getDeclContext() != D->getLexicalDeclContext()) { 1894 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 1895 if (!LexicalDC) 1896 return true; 1897 } 1898 1899 // Import the name of this declaration. 1900 Name = Importer.Import(D->getDeclName()); 1901 if (D->getDeclName() && !Name) 1902 return true; 1903 1904 // Import the location of this declaration. 1905 Loc = Importer.Import(D->getLocation()); 1906 ToD = cast_or_null<NamedDecl>(Importer.GetAlreadyImportedOrNull(D)); 1907 return false; 1908 } 1909 1910 void ASTNodeImporter::ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD) { 1911 if (!FromD) 1912 return; 1913 1914 if (!ToD) { 1915 ToD = Importer.Import(FromD); 1916 if (!ToD) 1917 return; 1918 } 1919 1920 if (RecordDecl *FromRecord = dyn_cast<RecordDecl>(FromD)) { 1921 if (RecordDecl *ToRecord = cast_or_null<RecordDecl>(ToD)) { 1922 if (FromRecord->getDefinition() && FromRecord->isCompleteDefinition() && !ToRecord->getDefinition()) { 1923 ImportDefinition(FromRecord, ToRecord); 1924 } 1925 } 1926 return; 1927 } 1928 1929 if (EnumDecl *FromEnum = dyn_cast<EnumDecl>(FromD)) { 1930 if (EnumDecl *ToEnum = cast_or_null<EnumDecl>(ToD)) { 1931 if (FromEnum->getDefinition() && !ToEnum->getDefinition()) { 1932 ImportDefinition(FromEnum, ToEnum); 1933 } 1934 } 1935 return; 1936 } 1937 } 1938 1939 void 1940 ASTNodeImporter::ImportDeclarationNameLoc(const DeclarationNameInfo &From, 1941 DeclarationNameInfo& To) { 1942 // NOTE: To.Name and To.Loc are already imported. 1943 // We only have to import To.LocInfo. 1944 switch (To.getName().getNameKind()) { 1945 case DeclarationName::Identifier: 1946 case DeclarationName::ObjCZeroArgSelector: 1947 case DeclarationName::ObjCOneArgSelector: 1948 case DeclarationName::ObjCMultiArgSelector: 1949 case DeclarationName::CXXUsingDirective: 1950 return; 1951 1952 case DeclarationName::CXXOperatorName: { 1953 SourceRange Range = From.getCXXOperatorNameRange(); 1954 To.setCXXOperatorNameRange(Importer.Import(Range)); 1955 return; 1956 } 1957 case DeclarationName::CXXLiteralOperatorName: { 1958 SourceLocation Loc = From.getCXXLiteralOperatorNameLoc(); 1959 To.setCXXLiteralOperatorNameLoc(Importer.Import(Loc)); 1960 return; 1961 } 1962 case DeclarationName::CXXConstructorName: 1963 case DeclarationName::CXXDestructorName: 1964 case DeclarationName::CXXConversionFunctionName: { 1965 TypeSourceInfo *FromTInfo = From.getNamedTypeInfo(); 1966 To.setNamedTypeInfo(Importer.Import(FromTInfo)); 1967 return; 1968 } 1969 } 1970 llvm_unreachable("Unknown name kind."); 1971 } 1972 1973 void ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) { 1974 if (Importer.isMinimalImport() && !ForceImport) { 1975 Importer.ImportContext(FromDC); 1976 return; 1977 } 1978 1979 for (auto *From : FromDC->decls()) 1980 Importer.Import(From); 1981 } 1982 1983 bool ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To, 1984 ImportDefinitionKind Kind) { 1985 if (To->getDefinition() || To->isBeingDefined()) { 1986 if (Kind == IDK_Everything) 1987 ImportDeclContext(From, /*ForceImport=*/true); 1988 1989 return false; 1990 } 1991 1992 To->startDefinition(); 1993 1994 // Add base classes. 1995 if (CXXRecordDecl *ToCXX = dyn_cast<CXXRecordDecl>(To)) { 1996 CXXRecordDecl *FromCXX = cast<CXXRecordDecl>(From); 1997 1998 struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data(); 1999 struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data(); 2000 ToData.UserDeclaredConstructor = FromData.UserDeclaredConstructor; 2001 ToData.UserDeclaredSpecialMembers = FromData.UserDeclaredSpecialMembers; 2002 ToData.Aggregate = FromData.Aggregate; 2003 ToData.PlainOldData = FromData.PlainOldData; 2004 ToData.Empty = FromData.Empty; 2005 ToData.Polymorphic = FromData.Polymorphic; 2006 ToData.Abstract = FromData.Abstract; 2007 ToData.IsStandardLayout = FromData.IsStandardLayout; 2008 ToData.HasNoNonEmptyBases = FromData.HasNoNonEmptyBases; 2009 ToData.HasPrivateFields = FromData.HasPrivateFields; 2010 ToData.HasProtectedFields = FromData.HasProtectedFields; 2011 ToData.HasPublicFields = FromData.HasPublicFields; 2012 ToData.HasMutableFields = FromData.HasMutableFields; 2013 ToData.HasVariantMembers = FromData.HasVariantMembers; 2014 ToData.HasOnlyCMembers = FromData.HasOnlyCMembers; 2015 ToData.HasInClassInitializer = FromData.HasInClassInitializer; 2016 ToData.HasUninitializedReferenceMember 2017 = FromData.HasUninitializedReferenceMember; 2018 ToData.NeedOverloadResolutionForMoveConstructor 2019 = FromData.NeedOverloadResolutionForMoveConstructor; 2020 ToData.NeedOverloadResolutionForMoveAssignment 2021 = FromData.NeedOverloadResolutionForMoveAssignment; 2022 ToData.NeedOverloadResolutionForDestructor 2023 = FromData.NeedOverloadResolutionForDestructor; 2024 ToData.DefaultedMoveConstructorIsDeleted 2025 = FromData.DefaultedMoveConstructorIsDeleted; 2026 ToData.DefaultedMoveAssignmentIsDeleted 2027 = FromData.DefaultedMoveAssignmentIsDeleted; 2028 ToData.DefaultedDestructorIsDeleted = FromData.DefaultedDestructorIsDeleted; 2029 ToData.HasTrivialSpecialMembers = FromData.HasTrivialSpecialMembers; 2030 ToData.HasIrrelevantDestructor = FromData.HasIrrelevantDestructor; 2031 ToData.HasConstexprNonCopyMoveConstructor 2032 = FromData.HasConstexprNonCopyMoveConstructor; 2033 ToData.DefaultedDefaultConstructorIsConstexpr 2034 = FromData.DefaultedDefaultConstructorIsConstexpr; 2035 ToData.HasConstexprDefaultConstructor 2036 = FromData.HasConstexprDefaultConstructor; 2037 ToData.HasNonLiteralTypeFieldsOrBases 2038 = FromData.HasNonLiteralTypeFieldsOrBases; 2039 // ComputedVisibleConversions not imported. 2040 ToData.UserProvidedDefaultConstructor 2041 = FromData.UserProvidedDefaultConstructor; 2042 ToData.DeclaredSpecialMembers = FromData.DeclaredSpecialMembers; 2043 ToData.ImplicitCopyConstructorHasConstParam 2044 = FromData.ImplicitCopyConstructorHasConstParam; 2045 ToData.ImplicitCopyAssignmentHasConstParam 2046 = FromData.ImplicitCopyAssignmentHasConstParam; 2047 ToData.HasDeclaredCopyConstructorWithConstParam 2048 = FromData.HasDeclaredCopyConstructorWithConstParam; 2049 ToData.HasDeclaredCopyAssignmentWithConstParam 2050 = FromData.HasDeclaredCopyAssignmentWithConstParam; 2051 ToData.IsLambda = FromData.IsLambda; 2052 2053 SmallVector<CXXBaseSpecifier *, 4> Bases; 2054 for (const auto &Base1 : FromCXX->bases()) { 2055 QualType T = Importer.Import(Base1.getType()); 2056 if (T.isNull()) 2057 return true; 2058 2059 SourceLocation EllipsisLoc; 2060 if (Base1.isPackExpansion()) 2061 EllipsisLoc = Importer.Import(Base1.getEllipsisLoc()); 2062 2063 // Ensure that we have a definition for the base. 2064 ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()); 2065 2066 Bases.push_back( 2067 new (Importer.getToContext()) 2068 CXXBaseSpecifier(Importer.Import(Base1.getSourceRange()), 2069 Base1.isVirtual(), 2070 Base1.isBaseOfClass(), 2071 Base1.getAccessSpecifierAsWritten(), 2072 Importer.Import(Base1.getTypeSourceInfo()), 2073 EllipsisLoc)); 2074 } 2075 if (!Bases.empty()) 2076 ToCXX->setBases(Bases.data(), Bases.size()); 2077 } 2078 2079 if (shouldForceImportDeclContext(Kind)) 2080 ImportDeclContext(From, /*ForceImport=*/true); 2081 2082 To->completeDefinition(); 2083 return false; 2084 } 2085 2086 bool ASTNodeImporter::ImportDefinition(VarDecl *From, VarDecl *To, 2087 ImportDefinitionKind Kind) { 2088 if (To->getAnyInitializer()) 2089 return false; 2090 2091 // FIXME: Can we really import any initializer? Alternatively, we could force 2092 // ourselves to import every declaration of a variable and then only use 2093 // getInit() here. 2094 To->setInit(Importer.Import(const_cast<Expr *>(From->getAnyInitializer()))); 2095 2096 // FIXME: Other bits to merge? 2097 2098 return false; 2099 } 2100 2101 bool ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To, 2102 ImportDefinitionKind Kind) { 2103 if (To->getDefinition() || To->isBeingDefined()) { 2104 if (Kind == IDK_Everything) 2105 ImportDeclContext(From, /*ForceImport=*/true); 2106 return false; 2107 } 2108 2109 To->startDefinition(); 2110 2111 QualType T = Importer.Import(Importer.getFromContext().getTypeDeclType(From)); 2112 if (T.isNull()) 2113 return true; 2114 2115 QualType ToPromotionType = Importer.Import(From->getPromotionType()); 2116 if (ToPromotionType.isNull()) 2117 return true; 2118 2119 if (shouldForceImportDeclContext(Kind)) 2120 ImportDeclContext(From, /*ForceImport=*/true); 2121 2122 // FIXME: we might need to merge the number of positive or negative bits 2123 // if the enumerator lists don't match. 2124 To->completeDefinition(T, ToPromotionType, 2125 From->getNumPositiveBits(), 2126 From->getNumNegativeBits()); 2127 return false; 2128 } 2129 2130 TemplateParameterList *ASTNodeImporter::ImportTemplateParameterList( 2131 TemplateParameterList *Params) { 2132 SmallVector<NamedDecl *, 4> ToParams; 2133 ToParams.reserve(Params->size()); 2134 for (TemplateParameterList::iterator P = Params->begin(), 2135 PEnd = Params->end(); 2136 P != PEnd; ++P) { 2137 Decl *To = Importer.Import(*P); 2138 if (!To) 2139 return nullptr; 2140 2141 ToParams.push_back(cast<NamedDecl>(To)); 2142 } 2143 2144 return TemplateParameterList::Create(Importer.getToContext(), 2145 Importer.Import(Params->getTemplateLoc()), 2146 Importer.Import(Params->getLAngleLoc()), 2147 ToParams.data(), ToParams.size(), 2148 Importer.Import(Params->getRAngleLoc())); 2149 } 2150 2151 TemplateArgument 2152 ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) { 2153 switch (From.getKind()) { 2154 case TemplateArgument::Null: 2155 return TemplateArgument(); 2156 2157 case TemplateArgument::Type: { 2158 QualType ToType = Importer.Import(From.getAsType()); 2159 if (ToType.isNull()) 2160 return TemplateArgument(); 2161 return TemplateArgument(ToType); 2162 } 2163 2164 case TemplateArgument::Integral: { 2165 QualType ToType = Importer.Import(From.getIntegralType()); 2166 if (ToType.isNull()) 2167 return TemplateArgument(); 2168 return TemplateArgument(From, ToType); 2169 } 2170 2171 case TemplateArgument::Declaration: { 2172 ValueDecl *To = cast_or_null<ValueDecl>(Importer.Import(From.getAsDecl())); 2173 QualType ToType = Importer.Import(From.getParamTypeForDecl()); 2174 if (!To || ToType.isNull()) 2175 return TemplateArgument(); 2176 return TemplateArgument(To, ToType); 2177 } 2178 2179 case TemplateArgument::NullPtr: { 2180 QualType ToType = Importer.Import(From.getNullPtrType()); 2181 if (ToType.isNull()) 2182 return TemplateArgument(); 2183 return TemplateArgument(ToType, /*isNullPtr*/true); 2184 } 2185 2186 case TemplateArgument::Template: { 2187 TemplateName ToTemplate = Importer.Import(From.getAsTemplate()); 2188 if (ToTemplate.isNull()) 2189 return TemplateArgument(); 2190 2191 return TemplateArgument(ToTemplate); 2192 } 2193 2194 case TemplateArgument::TemplateExpansion: { 2195 TemplateName ToTemplate 2196 = Importer.Import(From.getAsTemplateOrTemplatePattern()); 2197 if (ToTemplate.isNull()) 2198 return TemplateArgument(); 2199 2200 return TemplateArgument(ToTemplate, From.getNumTemplateExpansions()); 2201 } 2202 2203 case TemplateArgument::Expression: 2204 if (Expr *ToExpr = Importer.Import(From.getAsExpr())) 2205 return TemplateArgument(ToExpr); 2206 return TemplateArgument(); 2207 2208 case TemplateArgument::Pack: { 2209 SmallVector<TemplateArgument, 2> ToPack; 2210 ToPack.reserve(From.pack_size()); 2211 if (ImportTemplateArguments(From.pack_begin(), From.pack_size(), ToPack)) 2212 return TemplateArgument(); 2213 2214 return TemplateArgument( 2215 llvm::makeArrayRef(ToPack).copy(Importer.getToContext())); 2216 } 2217 } 2218 2219 llvm_unreachable("Invalid template argument kind"); 2220 } 2221 2222 bool ASTNodeImporter::ImportTemplateArguments(const TemplateArgument *FromArgs, 2223 unsigned NumFromArgs, 2224 SmallVectorImpl<TemplateArgument> &ToArgs) { 2225 for (unsigned I = 0; I != NumFromArgs; ++I) { 2226 TemplateArgument To = ImportTemplateArgument(FromArgs[I]); 2227 if (To.isNull() && !FromArgs[I].isNull()) 2228 return true; 2229 2230 ToArgs.push_back(To); 2231 } 2232 2233 return false; 2234 } 2235 2236 bool ASTNodeImporter::IsStructuralMatch(RecordDecl *FromRecord, 2237 RecordDecl *ToRecord, bool Complain) { 2238 // Eliminate a potential failure point where we attempt to re-import 2239 // something we're trying to import while completing ToRecord. 2240 Decl *ToOrigin = Importer.GetOriginalDecl(ToRecord); 2241 if (ToOrigin) { 2242 RecordDecl *ToOriginRecord = dyn_cast<RecordDecl>(ToOrigin); 2243 if (ToOriginRecord) 2244 ToRecord = ToOriginRecord; 2245 } 2246 2247 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2248 ToRecord->getASTContext(), 2249 Importer.getNonEquivalentDecls(), 2250 false, Complain); 2251 return Ctx.IsStructurallyEquivalent(FromRecord, ToRecord); 2252 } 2253 2254 bool ASTNodeImporter::IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar, 2255 bool Complain) { 2256 StructuralEquivalenceContext Ctx( 2257 Importer.getFromContext(), Importer.getToContext(), 2258 Importer.getNonEquivalentDecls(), false, Complain); 2259 return Ctx.IsStructurallyEquivalent(FromVar, ToVar); 2260 } 2261 2262 bool ASTNodeImporter::IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToEnum) { 2263 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2264 Importer.getToContext(), 2265 Importer.getNonEquivalentDecls()); 2266 return Ctx.IsStructurallyEquivalent(FromEnum, ToEnum); 2267 } 2268 2269 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC, 2270 EnumConstantDecl *ToEC) 2271 { 2272 const llvm::APSInt &FromVal = FromEC->getInitVal(); 2273 const llvm::APSInt &ToVal = ToEC->getInitVal(); 2274 2275 return FromVal.isSigned() == ToVal.isSigned() && 2276 FromVal.getBitWidth() == ToVal.getBitWidth() && 2277 FromVal == ToVal; 2278 } 2279 2280 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From, 2281 ClassTemplateDecl *To) { 2282 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2283 Importer.getToContext(), 2284 Importer.getNonEquivalentDecls()); 2285 return Ctx.IsStructurallyEquivalent(From, To); 2286 } 2287 2288 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From, 2289 VarTemplateDecl *To) { 2290 StructuralEquivalenceContext Ctx(Importer.getFromContext(), 2291 Importer.getToContext(), 2292 Importer.getNonEquivalentDecls()); 2293 return Ctx.IsStructurallyEquivalent(From, To); 2294 } 2295 2296 Decl *ASTNodeImporter::VisitDecl(Decl *D) { 2297 Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) 2298 << D->getDeclKindName(); 2299 return nullptr; 2300 } 2301 2302 Decl *ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 2303 TranslationUnitDecl *ToD = 2304 Importer.getToContext().getTranslationUnitDecl(); 2305 2306 Importer.Imported(D, ToD); 2307 2308 return ToD; 2309 } 2310 2311 Decl *ASTNodeImporter::VisitNamespaceDecl(NamespaceDecl *D) { 2312 // Import the major distinguishing characteristics of this namespace. 2313 DeclContext *DC, *LexicalDC; 2314 DeclarationName Name; 2315 SourceLocation Loc; 2316 NamedDecl *ToD; 2317 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2318 return nullptr; 2319 if (ToD) 2320 return ToD; 2321 2322 NamespaceDecl *MergeWithNamespace = nullptr; 2323 if (!Name) { 2324 // This is an anonymous namespace. Adopt an existing anonymous 2325 // namespace if we can. 2326 // FIXME: Not testable. 2327 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 2328 MergeWithNamespace = TU->getAnonymousNamespace(); 2329 else 2330 MergeWithNamespace = cast<NamespaceDecl>(DC)->getAnonymousNamespace(); 2331 } else { 2332 SmallVector<NamedDecl *, 4> ConflictingDecls; 2333 SmallVector<NamedDecl *, 2> FoundDecls; 2334 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2335 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2336 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Namespace)) 2337 continue; 2338 2339 if (NamespaceDecl *FoundNS = dyn_cast<NamespaceDecl>(FoundDecls[I])) { 2340 MergeWithNamespace = FoundNS; 2341 ConflictingDecls.clear(); 2342 break; 2343 } 2344 2345 ConflictingDecls.push_back(FoundDecls[I]); 2346 } 2347 2348 if (!ConflictingDecls.empty()) { 2349 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Namespace, 2350 ConflictingDecls.data(), 2351 ConflictingDecls.size()); 2352 } 2353 } 2354 2355 // Create the "to" namespace, if needed. 2356 NamespaceDecl *ToNamespace = MergeWithNamespace; 2357 if (!ToNamespace) { 2358 ToNamespace = NamespaceDecl::Create(Importer.getToContext(), DC, 2359 D->isInline(), 2360 Importer.Import(D->getLocStart()), 2361 Loc, Name.getAsIdentifierInfo(), 2362 /*PrevDecl=*/nullptr); 2363 ToNamespace->setLexicalDeclContext(LexicalDC); 2364 LexicalDC->addDeclInternal(ToNamespace); 2365 2366 // If this is an anonymous namespace, register it as the anonymous 2367 // namespace within its context. 2368 if (!Name) { 2369 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(DC)) 2370 TU->setAnonymousNamespace(ToNamespace); 2371 else 2372 cast<NamespaceDecl>(DC)->setAnonymousNamespace(ToNamespace); 2373 } 2374 } 2375 Importer.Imported(D, ToNamespace); 2376 2377 ImportDeclContext(D); 2378 2379 return ToNamespace; 2380 } 2381 2382 Decl *ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) { 2383 // Import the major distinguishing characteristics of this typedef. 2384 DeclContext *DC, *LexicalDC; 2385 DeclarationName Name; 2386 SourceLocation Loc; 2387 NamedDecl *ToD; 2388 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2389 return nullptr; 2390 if (ToD) 2391 return ToD; 2392 2393 // If this typedef is not in block scope, determine whether we've 2394 // seen a typedef with the same name (that we can merge with) or any 2395 // other entity by that name (which name lookup could conflict with). 2396 if (!DC->isFunctionOrMethod()) { 2397 SmallVector<NamedDecl *, 4> ConflictingDecls; 2398 unsigned IDNS = Decl::IDNS_Ordinary; 2399 SmallVector<NamedDecl *, 2> FoundDecls; 2400 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2401 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2402 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2403 continue; 2404 if (TypedefNameDecl *FoundTypedef = 2405 dyn_cast<TypedefNameDecl>(FoundDecls[I])) { 2406 if (Importer.IsStructurallyEquivalent(D->getUnderlyingType(), 2407 FoundTypedef->getUnderlyingType())) 2408 return Importer.Imported(D, FoundTypedef); 2409 } 2410 2411 ConflictingDecls.push_back(FoundDecls[I]); 2412 } 2413 2414 if (!ConflictingDecls.empty()) { 2415 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2416 ConflictingDecls.data(), 2417 ConflictingDecls.size()); 2418 if (!Name) 2419 return nullptr; 2420 } 2421 } 2422 2423 // Import the underlying type of this typedef; 2424 QualType T = Importer.Import(D->getUnderlyingType()); 2425 if (T.isNull()) 2426 return nullptr; 2427 2428 // Create the new typedef node. 2429 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2430 SourceLocation StartL = Importer.Import(D->getLocStart()); 2431 TypedefNameDecl *ToTypedef; 2432 if (IsAlias) 2433 ToTypedef = TypeAliasDecl::Create(Importer.getToContext(), DC, 2434 StartL, Loc, 2435 Name.getAsIdentifierInfo(), 2436 TInfo); 2437 else 2438 ToTypedef = TypedefDecl::Create(Importer.getToContext(), DC, 2439 StartL, Loc, 2440 Name.getAsIdentifierInfo(), 2441 TInfo); 2442 2443 ToTypedef->setAccess(D->getAccess()); 2444 ToTypedef->setLexicalDeclContext(LexicalDC); 2445 Importer.Imported(D, ToTypedef); 2446 LexicalDC->addDeclInternal(ToTypedef); 2447 2448 return ToTypedef; 2449 } 2450 2451 Decl *ASTNodeImporter::VisitTypedefDecl(TypedefDecl *D) { 2452 return VisitTypedefNameDecl(D, /*IsAlias=*/false); 2453 } 2454 2455 Decl *ASTNodeImporter::VisitTypeAliasDecl(TypeAliasDecl *D) { 2456 return VisitTypedefNameDecl(D, /*IsAlias=*/true); 2457 } 2458 2459 Decl *ASTNodeImporter::VisitEnumDecl(EnumDecl *D) { 2460 // Import the major distinguishing characteristics of this enum. 2461 DeclContext *DC, *LexicalDC; 2462 DeclarationName Name; 2463 SourceLocation Loc; 2464 NamedDecl *ToD; 2465 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2466 return nullptr; 2467 if (ToD) 2468 return ToD; 2469 2470 // Figure out what enum name we're looking for. 2471 unsigned IDNS = Decl::IDNS_Tag; 2472 DeclarationName SearchName = Name; 2473 if (!SearchName && D->getTypedefNameForAnonDecl()) { 2474 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 2475 IDNS = Decl::IDNS_Ordinary; 2476 } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2477 IDNS |= Decl::IDNS_Ordinary; 2478 2479 // We may already have an enum of the same name; try to find and match it. 2480 if (!DC->isFunctionOrMethod() && SearchName) { 2481 SmallVector<NamedDecl *, 4> ConflictingDecls; 2482 SmallVector<NamedDecl *, 2> FoundDecls; 2483 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2484 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2485 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2486 continue; 2487 2488 Decl *Found = FoundDecls[I]; 2489 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 2490 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2491 Found = Tag->getDecl(); 2492 } 2493 2494 if (EnumDecl *FoundEnum = dyn_cast<EnumDecl>(Found)) { 2495 if (IsStructuralMatch(D, FoundEnum)) 2496 return Importer.Imported(D, FoundEnum); 2497 } 2498 2499 ConflictingDecls.push_back(FoundDecls[I]); 2500 } 2501 2502 if (!ConflictingDecls.empty()) { 2503 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2504 ConflictingDecls.data(), 2505 ConflictingDecls.size()); 2506 } 2507 } 2508 2509 // Create the enum declaration. 2510 EnumDecl *D2 = EnumDecl::Create(Importer.getToContext(), DC, 2511 Importer.Import(D->getLocStart()), 2512 Loc, Name.getAsIdentifierInfo(), nullptr, 2513 D->isScoped(), D->isScopedUsingClassTag(), 2514 D->isFixed()); 2515 // Import the qualifier, if any. 2516 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2517 D2->setAccess(D->getAccess()); 2518 D2->setLexicalDeclContext(LexicalDC); 2519 Importer.Imported(D, D2); 2520 LexicalDC->addDeclInternal(D2); 2521 2522 // Import the integer type. 2523 QualType ToIntegerType = Importer.Import(D->getIntegerType()); 2524 if (ToIntegerType.isNull()) 2525 return nullptr; 2526 D2->setIntegerType(ToIntegerType); 2527 2528 // Import the definition 2529 if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 2530 return nullptr; 2531 2532 return D2; 2533 } 2534 2535 Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { 2536 // If this record has a definition in the translation unit we're coming from, 2537 // but this particular declaration is not that definition, import the 2538 // definition and map to that. 2539 TagDecl *Definition = D->getDefinition(); 2540 if (Definition && Definition != D) { 2541 Decl *ImportedDef = Importer.Import(Definition); 2542 if (!ImportedDef) 2543 return nullptr; 2544 2545 return Importer.Imported(D, ImportedDef); 2546 } 2547 2548 // Import the major distinguishing characteristics of this record. 2549 DeclContext *DC, *LexicalDC; 2550 DeclarationName Name; 2551 SourceLocation Loc; 2552 NamedDecl *ToD; 2553 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2554 return nullptr; 2555 if (ToD) 2556 return ToD; 2557 2558 // Figure out what structure name we're looking for. 2559 unsigned IDNS = Decl::IDNS_Tag; 2560 DeclarationName SearchName = Name; 2561 if (!SearchName && D->getTypedefNameForAnonDecl()) { 2562 SearchName = Importer.Import(D->getTypedefNameForAnonDecl()->getDeclName()); 2563 IDNS = Decl::IDNS_Ordinary; 2564 } else if (Importer.getToContext().getLangOpts().CPlusPlus) 2565 IDNS |= Decl::IDNS_Ordinary; 2566 2567 // We may already have a record of the same name; try to find and match it. 2568 RecordDecl *AdoptDecl = nullptr; 2569 if (!DC->isFunctionOrMethod()) { 2570 SmallVector<NamedDecl *, 4> ConflictingDecls; 2571 SmallVector<NamedDecl *, 2> FoundDecls; 2572 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2573 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2574 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2575 continue; 2576 2577 Decl *Found = FoundDecls[I]; 2578 if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Found)) { 2579 if (const TagType *Tag = Typedef->getUnderlyingType()->getAs<TagType>()) 2580 Found = Tag->getDecl(); 2581 } 2582 2583 if (RecordDecl *FoundRecord = dyn_cast<RecordDecl>(Found)) { 2584 if (D->isAnonymousStructOrUnion() && 2585 FoundRecord->isAnonymousStructOrUnion()) { 2586 // If both anonymous structs/unions are in a record context, make sure 2587 // they occur in the same location in the context records. 2588 if (Optional<unsigned> Index1 2589 = findAnonymousStructOrUnionIndex(D)) { 2590 if (Optional<unsigned> Index2 = 2591 findAnonymousStructOrUnionIndex(FoundRecord)) { 2592 if (*Index1 != *Index2) 2593 continue; 2594 } 2595 } 2596 } 2597 2598 if (RecordDecl *FoundDef = FoundRecord->getDefinition()) { 2599 if ((SearchName && !D->isCompleteDefinition()) 2600 || (D->isCompleteDefinition() && 2601 D->isAnonymousStructOrUnion() 2602 == FoundDef->isAnonymousStructOrUnion() && 2603 IsStructuralMatch(D, FoundDef))) { 2604 // The record types structurally match, or the "from" translation 2605 // unit only had a forward declaration anyway; call it the same 2606 // function. 2607 // FIXME: For C++, we should also merge methods here. 2608 return Importer.Imported(D, FoundDef); 2609 } 2610 } else if (!D->isCompleteDefinition()) { 2611 // We have a forward declaration of this type, so adopt that forward 2612 // declaration rather than building a new one. 2613 2614 // If one or both can be completed from external storage then try one 2615 // last time to complete and compare them before doing this. 2616 2617 if (FoundRecord->hasExternalLexicalStorage() && 2618 !FoundRecord->isCompleteDefinition()) 2619 FoundRecord->getASTContext().getExternalSource()->CompleteType(FoundRecord); 2620 if (D->hasExternalLexicalStorage()) 2621 D->getASTContext().getExternalSource()->CompleteType(D); 2622 2623 if (FoundRecord->isCompleteDefinition() && 2624 D->isCompleteDefinition() && 2625 !IsStructuralMatch(D, FoundRecord)) 2626 continue; 2627 2628 AdoptDecl = FoundRecord; 2629 continue; 2630 } else if (!SearchName) { 2631 continue; 2632 } 2633 } 2634 2635 ConflictingDecls.push_back(FoundDecls[I]); 2636 } 2637 2638 if (!ConflictingDecls.empty() && SearchName) { 2639 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2640 ConflictingDecls.data(), 2641 ConflictingDecls.size()); 2642 } 2643 } 2644 2645 // Create the record declaration. 2646 RecordDecl *D2 = AdoptDecl; 2647 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 2648 if (!D2) { 2649 if (isa<CXXRecordDecl>(D)) { 2650 CXXRecordDecl *D2CXX = CXXRecordDecl::Create(Importer.getToContext(), 2651 D->getTagKind(), 2652 DC, StartLoc, Loc, 2653 Name.getAsIdentifierInfo()); 2654 D2 = D2CXX; 2655 D2->setAccess(D->getAccess()); 2656 } else { 2657 D2 = RecordDecl::Create(Importer.getToContext(), D->getTagKind(), 2658 DC, StartLoc, Loc, Name.getAsIdentifierInfo()); 2659 } 2660 2661 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2662 D2->setLexicalDeclContext(LexicalDC); 2663 LexicalDC->addDeclInternal(D2); 2664 if (D->isAnonymousStructOrUnion()) 2665 D2->setAnonymousStructOrUnion(true); 2666 } 2667 2668 Importer.Imported(D, D2); 2669 2670 if (D->isCompleteDefinition() && ImportDefinition(D, D2, IDK_Default)) 2671 return nullptr; 2672 2673 return D2; 2674 } 2675 2676 Decl *ASTNodeImporter::VisitEnumConstantDecl(EnumConstantDecl *D) { 2677 // Import the major distinguishing characteristics of this enumerator. 2678 DeclContext *DC, *LexicalDC; 2679 DeclarationName Name; 2680 SourceLocation Loc; 2681 NamedDecl *ToD; 2682 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2683 return nullptr; 2684 if (ToD) 2685 return ToD; 2686 2687 QualType T = Importer.Import(D->getType()); 2688 if (T.isNull()) 2689 return nullptr; 2690 2691 // Determine whether there are any other declarations with the same name and 2692 // in the same context. 2693 if (!LexicalDC->isFunctionOrMethod()) { 2694 SmallVector<NamedDecl *, 4> ConflictingDecls; 2695 unsigned IDNS = Decl::IDNS_Ordinary; 2696 SmallVector<NamedDecl *, 2> FoundDecls; 2697 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2698 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2699 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2700 continue; 2701 2702 if (EnumConstantDecl *FoundEnumConstant 2703 = dyn_cast<EnumConstantDecl>(FoundDecls[I])) { 2704 if (IsStructuralMatch(D, FoundEnumConstant)) 2705 return Importer.Imported(D, FoundEnumConstant); 2706 } 2707 2708 ConflictingDecls.push_back(FoundDecls[I]); 2709 } 2710 2711 if (!ConflictingDecls.empty()) { 2712 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2713 ConflictingDecls.data(), 2714 ConflictingDecls.size()); 2715 if (!Name) 2716 return nullptr; 2717 } 2718 } 2719 2720 Expr *Init = Importer.Import(D->getInitExpr()); 2721 if (D->getInitExpr() && !Init) 2722 return nullptr; 2723 2724 EnumConstantDecl *ToEnumerator 2725 = EnumConstantDecl::Create(Importer.getToContext(), cast<EnumDecl>(DC), Loc, 2726 Name.getAsIdentifierInfo(), T, 2727 Init, D->getInitVal()); 2728 ToEnumerator->setAccess(D->getAccess()); 2729 ToEnumerator->setLexicalDeclContext(LexicalDC); 2730 Importer.Imported(D, ToEnumerator); 2731 LexicalDC->addDeclInternal(ToEnumerator); 2732 return ToEnumerator; 2733 } 2734 2735 Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) { 2736 // Import the major distinguishing characteristics of this function. 2737 DeclContext *DC, *LexicalDC; 2738 DeclarationName Name; 2739 SourceLocation Loc; 2740 NamedDecl *ToD; 2741 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2742 return nullptr; 2743 if (ToD) 2744 return ToD; 2745 2746 // Try to find a function in our own ("to") context with the same name, same 2747 // type, and in the same context as the function we're importing. 2748 if (!LexicalDC->isFunctionOrMethod()) { 2749 SmallVector<NamedDecl *, 4> ConflictingDecls; 2750 unsigned IDNS = Decl::IDNS_Ordinary; 2751 SmallVector<NamedDecl *, 2> FoundDecls; 2752 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2753 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2754 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 2755 continue; 2756 2757 if (FunctionDecl *FoundFunction = dyn_cast<FunctionDecl>(FoundDecls[I])) { 2758 if (FoundFunction->hasExternalFormalLinkage() && 2759 D->hasExternalFormalLinkage()) { 2760 if (Importer.IsStructurallyEquivalent(D->getType(), 2761 FoundFunction->getType())) { 2762 // FIXME: Actually try to merge the body and other attributes. 2763 return Importer.Imported(D, FoundFunction); 2764 } 2765 2766 // FIXME: Check for overloading more carefully, e.g., by boosting 2767 // Sema::IsOverload out to the AST library. 2768 2769 // Function overloading is okay in C++. 2770 if (Importer.getToContext().getLangOpts().CPlusPlus) 2771 continue; 2772 2773 // Complain about inconsistent function types. 2774 Importer.ToDiag(Loc, diag::err_odr_function_type_inconsistent) 2775 << Name << D->getType() << FoundFunction->getType(); 2776 Importer.ToDiag(FoundFunction->getLocation(), 2777 diag::note_odr_value_here) 2778 << FoundFunction->getType(); 2779 } 2780 } 2781 2782 ConflictingDecls.push_back(FoundDecls[I]); 2783 } 2784 2785 if (!ConflictingDecls.empty()) { 2786 Name = Importer.HandleNameConflict(Name, DC, IDNS, 2787 ConflictingDecls.data(), 2788 ConflictingDecls.size()); 2789 if (!Name) 2790 return nullptr; 2791 } 2792 } 2793 2794 DeclarationNameInfo NameInfo(Name, Loc); 2795 // Import additional name location/type info. 2796 ImportDeclarationNameLoc(D->getNameInfo(), NameInfo); 2797 2798 QualType FromTy = D->getType(); 2799 bool usedDifferentExceptionSpec = false; 2800 2801 if (const FunctionProtoType * 2802 FromFPT = D->getType()->getAs<FunctionProtoType>()) { 2803 FunctionProtoType::ExtProtoInfo FromEPI = FromFPT->getExtProtoInfo(); 2804 // FunctionProtoType::ExtProtoInfo's ExceptionSpecDecl can point to the 2805 // FunctionDecl that we are importing the FunctionProtoType for. 2806 // To avoid an infinite recursion when importing, create the FunctionDecl 2807 // with a simplified function type and update it afterwards. 2808 if (FromEPI.ExceptionSpec.SourceDecl || 2809 FromEPI.ExceptionSpec.SourceTemplate || 2810 FromEPI.ExceptionSpec.NoexceptExpr) { 2811 FunctionProtoType::ExtProtoInfo DefaultEPI; 2812 FromTy = Importer.getFromContext().getFunctionType( 2813 FromFPT->getReturnType(), FromFPT->getParamTypes(), DefaultEPI); 2814 usedDifferentExceptionSpec = true; 2815 } 2816 } 2817 2818 // Import the type. 2819 QualType T = Importer.Import(FromTy); 2820 if (T.isNull()) 2821 return nullptr; 2822 2823 // Import the function parameters. 2824 SmallVector<ParmVarDecl *, 8> Parameters; 2825 for (auto P : D->params()) { 2826 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(P)); 2827 if (!ToP) 2828 return nullptr; 2829 2830 Parameters.push_back(ToP); 2831 } 2832 2833 // Create the imported function. 2834 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2835 FunctionDecl *ToFunction = nullptr; 2836 SourceLocation InnerLocStart = Importer.Import(D->getInnerLocStart()); 2837 if (CXXConstructorDecl *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) { 2838 ToFunction = CXXConstructorDecl::Create(Importer.getToContext(), 2839 cast<CXXRecordDecl>(DC), 2840 InnerLocStart, 2841 NameInfo, T, TInfo, 2842 FromConstructor->isExplicit(), 2843 D->isInlineSpecified(), 2844 D->isImplicit(), 2845 D->isConstexpr()); 2846 } else if (isa<CXXDestructorDecl>(D)) { 2847 ToFunction = CXXDestructorDecl::Create(Importer.getToContext(), 2848 cast<CXXRecordDecl>(DC), 2849 InnerLocStart, 2850 NameInfo, T, TInfo, 2851 D->isInlineSpecified(), 2852 D->isImplicit()); 2853 } else if (CXXConversionDecl *FromConversion 2854 = dyn_cast<CXXConversionDecl>(D)) { 2855 ToFunction = CXXConversionDecl::Create(Importer.getToContext(), 2856 cast<CXXRecordDecl>(DC), 2857 InnerLocStart, 2858 NameInfo, T, TInfo, 2859 D->isInlineSpecified(), 2860 FromConversion->isExplicit(), 2861 D->isConstexpr(), 2862 Importer.Import(D->getLocEnd())); 2863 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 2864 ToFunction = CXXMethodDecl::Create(Importer.getToContext(), 2865 cast<CXXRecordDecl>(DC), 2866 InnerLocStart, 2867 NameInfo, T, TInfo, 2868 Method->getStorageClass(), 2869 Method->isInlineSpecified(), 2870 D->isConstexpr(), 2871 Importer.Import(D->getLocEnd())); 2872 } else { 2873 ToFunction = FunctionDecl::Create(Importer.getToContext(), DC, 2874 InnerLocStart, 2875 NameInfo, T, TInfo, D->getStorageClass(), 2876 D->isInlineSpecified(), 2877 D->hasWrittenPrototype(), 2878 D->isConstexpr()); 2879 } 2880 2881 // Import the qualifier, if any. 2882 ToFunction->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 2883 ToFunction->setAccess(D->getAccess()); 2884 ToFunction->setLexicalDeclContext(LexicalDC); 2885 ToFunction->setVirtualAsWritten(D->isVirtualAsWritten()); 2886 ToFunction->setTrivial(D->isTrivial()); 2887 ToFunction->setPure(D->isPure()); 2888 Importer.Imported(D, ToFunction); 2889 2890 // Set the parameters. 2891 for (unsigned I = 0, N = Parameters.size(); I != N; ++I) { 2892 Parameters[I]->setOwningFunction(ToFunction); 2893 ToFunction->addDeclInternal(Parameters[I]); 2894 } 2895 ToFunction->setParams(Parameters); 2896 2897 if (usedDifferentExceptionSpec) { 2898 // Update FunctionProtoType::ExtProtoInfo. 2899 QualType T = Importer.Import(D->getType()); 2900 if (T.isNull()) 2901 return nullptr; 2902 ToFunction->setType(T); 2903 } 2904 2905 // Import the body, if any. 2906 if (Stmt *FromBody = D->getBody()) { 2907 if (Stmt *ToBody = Importer.Import(FromBody)) { 2908 ToFunction->setBody(ToBody); 2909 } 2910 } 2911 2912 // FIXME: Other bits to merge? 2913 2914 // Add this function to the lexical context. 2915 LexicalDC->addDeclInternal(ToFunction); 2916 2917 return ToFunction; 2918 } 2919 2920 Decl *ASTNodeImporter::VisitCXXMethodDecl(CXXMethodDecl *D) { 2921 return VisitFunctionDecl(D); 2922 } 2923 2924 Decl *ASTNodeImporter::VisitCXXConstructorDecl(CXXConstructorDecl *D) { 2925 return VisitCXXMethodDecl(D); 2926 } 2927 2928 Decl *ASTNodeImporter::VisitCXXDestructorDecl(CXXDestructorDecl *D) { 2929 return VisitCXXMethodDecl(D); 2930 } 2931 2932 Decl *ASTNodeImporter::VisitCXXConversionDecl(CXXConversionDecl *D) { 2933 return VisitCXXMethodDecl(D); 2934 } 2935 2936 static unsigned getFieldIndex(Decl *F) { 2937 RecordDecl *Owner = dyn_cast<RecordDecl>(F->getDeclContext()); 2938 if (!Owner) 2939 return 0; 2940 2941 unsigned Index = 1; 2942 for (const auto *D : Owner->noload_decls()) { 2943 if (D == F) 2944 return Index; 2945 2946 if (isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) 2947 ++Index; 2948 } 2949 2950 return Index; 2951 } 2952 2953 Decl *ASTNodeImporter::VisitFieldDecl(FieldDecl *D) { 2954 // Import the major distinguishing characteristics of a variable. 2955 DeclContext *DC, *LexicalDC; 2956 DeclarationName Name; 2957 SourceLocation Loc; 2958 NamedDecl *ToD; 2959 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 2960 return nullptr; 2961 if (ToD) 2962 return ToD; 2963 2964 // Determine whether we've already imported this field. 2965 SmallVector<NamedDecl *, 2> FoundDecls; 2966 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 2967 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 2968 if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecls[I])) { 2969 // For anonymous fields, match up by index. 2970 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 2971 continue; 2972 2973 if (Importer.IsStructurallyEquivalent(D->getType(), 2974 FoundField->getType())) { 2975 Importer.Imported(D, FoundField); 2976 return FoundField; 2977 } 2978 2979 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 2980 << Name << D->getType() << FoundField->getType(); 2981 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 2982 << FoundField->getType(); 2983 return nullptr; 2984 } 2985 } 2986 2987 // Import the type. 2988 QualType T = Importer.Import(D->getType()); 2989 if (T.isNull()) 2990 return nullptr; 2991 2992 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 2993 Expr *BitWidth = Importer.Import(D->getBitWidth()); 2994 if (!BitWidth && D->getBitWidth()) 2995 return nullptr; 2996 2997 FieldDecl *ToField = FieldDecl::Create(Importer.getToContext(), DC, 2998 Importer.Import(D->getInnerLocStart()), 2999 Loc, Name.getAsIdentifierInfo(), 3000 T, TInfo, BitWidth, D->isMutable(), 3001 D->getInClassInitStyle()); 3002 ToField->setAccess(D->getAccess()); 3003 ToField->setLexicalDeclContext(LexicalDC); 3004 if (ToField->hasInClassInitializer()) 3005 ToField->setInClassInitializer(D->getInClassInitializer()); 3006 ToField->setImplicit(D->isImplicit()); 3007 Importer.Imported(D, ToField); 3008 LexicalDC->addDeclInternal(ToField); 3009 return ToField; 3010 } 3011 3012 Decl *ASTNodeImporter::VisitIndirectFieldDecl(IndirectFieldDecl *D) { 3013 // Import the major distinguishing characteristics of a variable. 3014 DeclContext *DC, *LexicalDC; 3015 DeclarationName Name; 3016 SourceLocation Loc; 3017 NamedDecl *ToD; 3018 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3019 return nullptr; 3020 if (ToD) 3021 return ToD; 3022 3023 // Determine whether we've already imported this field. 3024 SmallVector<NamedDecl *, 2> FoundDecls; 3025 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3026 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3027 if (IndirectFieldDecl *FoundField 3028 = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) { 3029 // For anonymous indirect fields, match up by index. 3030 if (!Name && getFieldIndex(D) != getFieldIndex(FoundField)) 3031 continue; 3032 3033 if (Importer.IsStructurallyEquivalent(D->getType(), 3034 FoundField->getType(), 3035 !Name.isEmpty())) { 3036 Importer.Imported(D, FoundField); 3037 return FoundField; 3038 } 3039 3040 // If there are more anonymous fields to check, continue. 3041 if (!Name && I < N-1) 3042 continue; 3043 3044 Importer.ToDiag(Loc, diag::err_odr_field_type_inconsistent) 3045 << Name << D->getType() << FoundField->getType(); 3046 Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here) 3047 << FoundField->getType(); 3048 return nullptr; 3049 } 3050 } 3051 3052 // Import the type. 3053 QualType T = Importer.Import(D->getType()); 3054 if (T.isNull()) 3055 return nullptr; 3056 3057 NamedDecl **NamedChain = 3058 new (Importer.getToContext())NamedDecl*[D->getChainingSize()]; 3059 3060 unsigned i = 0; 3061 for (auto *PI : D->chain()) { 3062 Decl *D = Importer.Import(PI); 3063 if (!D) 3064 return nullptr; 3065 NamedChain[i++] = cast<NamedDecl>(D); 3066 } 3067 3068 IndirectFieldDecl *ToIndirectField = IndirectFieldDecl::Create( 3069 Importer.getToContext(), DC, Loc, Name.getAsIdentifierInfo(), T, 3070 NamedChain, D->getChainingSize()); 3071 3072 for (const auto *Attr : D->attrs()) 3073 ToIndirectField->addAttr(Attr->clone(Importer.getToContext())); 3074 3075 ToIndirectField->setAccess(D->getAccess()); 3076 ToIndirectField->setLexicalDeclContext(LexicalDC); 3077 Importer.Imported(D, ToIndirectField); 3078 LexicalDC->addDeclInternal(ToIndirectField); 3079 return ToIndirectField; 3080 } 3081 3082 Decl *ASTNodeImporter::VisitObjCIvarDecl(ObjCIvarDecl *D) { 3083 // Import the major distinguishing characteristics of an ivar. 3084 DeclContext *DC, *LexicalDC; 3085 DeclarationName Name; 3086 SourceLocation Loc; 3087 NamedDecl *ToD; 3088 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3089 return nullptr; 3090 if (ToD) 3091 return ToD; 3092 3093 // Determine whether we've already imported this ivar 3094 SmallVector<NamedDecl *, 2> FoundDecls; 3095 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3096 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3097 if (ObjCIvarDecl *FoundIvar = dyn_cast<ObjCIvarDecl>(FoundDecls[I])) { 3098 if (Importer.IsStructurallyEquivalent(D->getType(), 3099 FoundIvar->getType())) { 3100 Importer.Imported(D, FoundIvar); 3101 return FoundIvar; 3102 } 3103 3104 Importer.ToDiag(Loc, diag::err_odr_ivar_type_inconsistent) 3105 << Name << D->getType() << FoundIvar->getType(); 3106 Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here) 3107 << FoundIvar->getType(); 3108 return nullptr; 3109 } 3110 } 3111 3112 // Import the type. 3113 QualType T = Importer.Import(D->getType()); 3114 if (T.isNull()) 3115 return nullptr; 3116 3117 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3118 Expr *BitWidth = Importer.Import(D->getBitWidth()); 3119 if (!BitWidth && D->getBitWidth()) 3120 return nullptr; 3121 3122 ObjCIvarDecl *ToIvar = ObjCIvarDecl::Create(Importer.getToContext(), 3123 cast<ObjCContainerDecl>(DC), 3124 Importer.Import(D->getInnerLocStart()), 3125 Loc, Name.getAsIdentifierInfo(), 3126 T, TInfo, D->getAccessControl(), 3127 BitWidth, D->getSynthesize()); 3128 ToIvar->setLexicalDeclContext(LexicalDC); 3129 Importer.Imported(D, ToIvar); 3130 LexicalDC->addDeclInternal(ToIvar); 3131 return ToIvar; 3132 3133 } 3134 3135 Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) { 3136 // Import the major distinguishing characteristics of a variable. 3137 DeclContext *DC, *LexicalDC; 3138 DeclarationName Name; 3139 SourceLocation Loc; 3140 NamedDecl *ToD; 3141 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3142 return nullptr; 3143 if (ToD) 3144 return ToD; 3145 3146 // Try to find a variable in our own ("to") context with the same name and 3147 // in the same context as the variable we're importing. 3148 if (D->isFileVarDecl()) { 3149 VarDecl *MergeWithVar = nullptr; 3150 SmallVector<NamedDecl *, 4> ConflictingDecls; 3151 unsigned IDNS = Decl::IDNS_Ordinary; 3152 SmallVector<NamedDecl *, 2> FoundDecls; 3153 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3154 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3155 if (!FoundDecls[I]->isInIdentifierNamespace(IDNS)) 3156 continue; 3157 3158 if (VarDecl *FoundVar = dyn_cast<VarDecl>(FoundDecls[I])) { 3159 // We have found a variable that we may need to merge with. Check it. 3160 if (FoundVar->hasExternalFormalLinkage() && 3161 D->hasExternalFormalLinkage()) { 3162 if (Importer.IsStructurallyEquivalent(D->getType(), 3163 FoundVar->getType())) { 3164 MergeWithVar = FoundVar; 3165 break; 3166 } 3167 3168 const ArrayType *FoundArray 3169 = Importer.getToContext().getAsArrayType(FoundVar->getType()); 3170 const ArrayType *TArray 3171 = Importer.getToContext().getAsArrayType(D->getType()); 3172 if (FoundArray && TArray) { 3173 if (isa<IncompleteArrayType>(FoundArray) && 3174 isa<ConstantArrayType>(TArray)) { 3175 // Import the type. 3176 QualType T = Importer.Import(D->getType()); 3177 if (T.isNull()) 3178 return nullptr; 3179 3180 FoundVar->setType(T); 3181 MergeWithVar = FoundVar; 3182 break; 3183 } else if (isa<IncompleteArrayType>(TArray) && 3184 isa<ConstantArrayType>(FoundArray)) { 3185 MergeWithVar = FoundVar; 3186 break; 3187 } 3188 } 3189 3190 Importer.ToDiag(Loc, diag::err_odr_variable_type_inconsistent) 3191 << Name << D->getType() << FoundVar->getType(); 3192 Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here) 3193 << FoundVar->getType(); 3194 } 3195 } 3196 3197 ConflictingDecls.push_back(FoundDecls[I]); 3198 } 3199 3200 if (MergeWithVar) { 3201 // An equivalent variable with external linkage has been found. Link 3202 // the two declarations, then merge them. 3203 Importer.Imported(D, MergeWithVar); 3204 3205 if (VarDecl *DDef = D->getDefinition()) { 3206 if (VarDecl *ExistingDef = MergeWithVar->getDefinition()) { 3207 Importer.ToDiag(ExistingDef->getLocation(), 3208 diag::err_odr_variable_multiple_def) 3209 << Name; 3210 Importer.FromDiag(DDef->getLocation(), diag::note_odr_defined_here); 3211 } else { 3212 Expr *Init = Importer.Import(DDef->getInit()); 3213 MergeWithVar->setInit(Init); 3214 if (DDef->isInitKnownICE()) { 3215 EvaluatedStmt *Eval = MergeWithVar->ensureEvaluatedStmt(); 3216 Eval->CheckedICE = true; 3217 Eval->IsICE = DDef->isInitICE(); 3218 } 3219 } 3220 } 3221 3222 return MergeWithVar; 3223 } 3224 3225 if (!ConflictingDecls.empty()) { 3226 Name = Importer.HandleNameConflict(Name, DC, IDNS, 3227 ConflictingDecls.data(), 3228 ConflictingDecls.size()); 3229 if (!Name) 3230 return nullptr; 3231 } 3232 } 3233 3234 // Import the type. 3235 QualType T = Importer.Import(D->getType()); 3236 if (T.isNull()) 3237 return nullptr; 3238 3239 // Create the imported variable. 3240 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3241 VarDecl *ToVar = VarDecl::Create(Importer.getToContext(), DC, 3242 Importer.Import(D->getInnerLocStart()), 3243 Loc, Name.getAsIdentifierInfo(), 3244 T, TInfo, 3245 D->getStorageClass()); 3246 ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 3247 ToVar->setAccess(D->getAccess()); 3248 ToVar->setLexicalDeclContext(LexicalDC); 3249 Importer.Imported(D, ToVar); 3250 LexicalDC->addDeclInternal(ToVar); 3251 3252 if (!D->isFileVarDecl() && 3253 D->isUsed()) 3254 ToVar->setIsUsed(); 3255 3256 // Merge the initializer. 3257 if (ImportDefinition(D, ToVar)) 3258 return nullptr; 3259 3260 return ToVar; 3261 } 3262 3263 Decl *ASTNodeImporter::VisitImplicitParamDecl(ImplicitParamDecl *D) { 3264 // Parameters are created in the translation unit's context, then moved 3265 // into the function declaration's context afterward. 3266 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3267 3268 // Import the name of this declaration. 3269 DeclarationName Name = Importer.Import(D->getDeclName()); 3270 if (D->getDeclName() && !Name) 3271 return nullptr; 3272 3273 // Import the location of this declaration. 3274 SourceLocation Loc = Importer.Import(D->getLocation()); 3275 3276 // Import the parameter's type. 3277 QualType T = Importer.Import(D->getType()); 3278 if (T.isNull()) 3279 return nullptr; 3280 3281 // Create the imported parameter. 3282 ImplicitParamDecl *ToParm 3283 = ImplicitParamDecl::Create(Importer.getToContext(), DC, 3284 Loc, Name.getAsIdentifierInfo(), 3285 T); 3286 return Importer.Imported(D, ToParm); 3287 } 3288 3289 Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) { 3290 // Parameters are created in the translation unit's context, then moved 3291 // into the function declaration's context afterward. 3292 DeclContext *DC = Importer.getToContext().getTranslationUnitDecl(); 3293 3294 // Import the name of this declaration. 3295 DeclarationName Name = Importer.Import(D->getDeclName()); 3296 if (D->getDeclName() && !Name) 3297 return nullptr; 3298 3299 // Import the location of this declaration. 3300 SourceLocation Loc = Importer.Import(D->getLocation()); 3301 3302 // Import the parameter's type. 3303 QualType T = Importer.Import(D->getType()); 3304 if (T.isNull()) 3305 return nullptr; 3306 3307 // Create the imported parameter. 3308 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 3309 ParmVarDecl *ToParm = ParmVarDecl::Create(Importer.getToContext(), DC, 3310 Importer.Import(D->getInnerLocStart()), 3311 Loc, Name.getAsIdentifierInfo(), 3312 T, TInfo, D->getStorageClass(), 3313 /*FIXME: Default argument*/nullptr); 3314 ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg()); 3315 3316 if (D->isUsed()) 3317 ToParm->setIsUsed(); 3318 3319 return Importer.Imported(D, ToParm); 3320 } 3321 3322 Decl *ASTNodeImporter::VisitObjCMethodDecl(ObjCMethodDecl *D) { 3323 // Import the major distinguishing characteristics of a method. 3324 DeclContext *DC, *LexicalDC; 3325 DeclarationName Name; 3326 SourceLocation Loc; 3327 NamedDecl *ToD; 3328 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3329 return nullptr; 3330 if (ToD) 3331 return ToD; 3332 3333 SmallVector<NamedDecl *, 2> FoundDecls; 3334 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3335 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3336 if (ObjCMethodDecl *FoundMethod = dyn_cast<ObjCMethodDecl>(FoundDecls[I])) { 3337 if (FoundMethod->isInstanceMethod() != D->isInstanceMethod()) 3338 continue; 3339 3340 // Check return types. 3341 if (!Importer.IsStructurallyEquivalent(D->getReturnType(), 3342 FoundMethod->getReturnType())) { 3343 Importer.ToDiag(Loc, diag::err_odr_objc_method_result_type_inconsistent) 3344 << D->isInstanceMethod() << Name << D->getReturnType() 3345 << FoundMethod->getReturnType(); 3346 Importer.ToDiag(FoundMethod->getLocation(), 3347 diag::note_odr_objc_method_here) 3348 << D->isInstanceMethod() << Name; 3349 return nullptr; 3350 } 3351 3352 // Check the number of parameters. 3353 if (D->param_size() != FoundMethod->param_size()) { 3354 Importer.ToDiag(Loc, diag::err_odr_objc_method_num_params_inconsistent) 3355 << D->isInstanceMethod() << Name 3356 << D->param_size() << FoundMethod->param_size(); 3357 Importer.ToDiag(FoundMethod->getLocation(), 3358 diag::note_odr_objc_method_here) 3359 << D->isInstanceMethod() << Name; 3360 return nullptr; 3361 } 3362 3363 // Check parameter types. 3364 for (ObjCMethodDecl::param_iterator P = D->param_begin(), 3365 PEnd = D->param_end(), FoundP = FoundMethod->param_begin(); 3366 P != PEnd; ++P, ++FoundP) { 3367 if (!Importer.IsStructurallyEquivalent((*P)->getType(), 3368 (*FoundP)->getType())) { 3369 Importer.FromDiag((*P)->getLocation(), 3370 diag::err_odr_objc_method_param_type_inconsistent) 3371 << D->isInstanceMethod() << Name 3372 << (*P)->getType() << (*FoundP)->getType(); 3373 Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here) 3374 << (*FoundP)->getType(); 3375 return nullptr; 3376 } 3377 } 3378 3379 // Check variadic/non-variadic. 3380 // Check the number of parameters. 3381 if (D->isVariadic() != FoundMethod->isVariadic()) { 3382 Importer.ToDiag(Loc, diag::err_odr_objc_method_variadic_inconsistent) 3383 << D->isInstanceMethod() << Name; 3384 Importer.ToDiag(FoundMethod->getLocation(), 3385 diag::note_odr_objc_method_here) 3386 << D->isInstanceMethod() << Name; 3387 return nullptr; 3388 } 3389 3390 // FIXME: Any other bits we need to merge? 3391 return Importer.Imported(D, FoundMethod); 3392 } 3393 } 3394 3395 // Import the result type. 3396 QualType ResultTy = Importer.Import(D->getReturnType()); 3397 if (ResultTy.isNull()) 3398 return nullptr; 3399 3400 TypeSourceInfo *ReturnTInfo = Importer.Import(D->getReturnTypeSourceInfo()); 3401 3402 ObjCMethodDecl *ToMethod = ObjCMethodDecl::Create( 3403 Importer.getToContext(), Loc, Importer.Import(D->getLocEnd()), 3404 Name.getObjCSelector(), ResultTy, ReturnTInfo, DC, D->isInstanceMethod(), 3405 D->isVariadic(), D->isPropertyAccessor(), D->isImplicit(), D->isDefined(), 3406 D->getImplementationControl(), D->hasRelatedResultType()); 3407 3408 // FIXME: When we decide to merge method definitions, we'll need to 3409 // deal with implicit parameters. 3410 3411 // Import the parameters 3412 SmallVector<ParmVarDecl *, 5> ToParams; 3413 for (auto *FromP : D->params()) { 3414 ParmVarDecl *ToP = cast_or_null<ParmVarDecl>(Importer.Import(FromP)); 3415 if (!ToP) 3416 return nullptr; 3417 3418 ToParams.push_back(ToP); 3419 } 3420 3421 // Set the parameters. 3422 for (unsigned I = 0, N = ToParams.size(); I != N; ++I) { 3423 ToParams[I]->setOwningFunction(ToMethod); 3424 ToMethod->addDeclInternal(ToParams[I]); 3425 } 3426 SmallVector<SourceLocation, 12> SelLocs; 3427 D->getSelectorLocs(SelLocs); 3428 ToMethod->setMethodParams(Importer.getToContext(), ToParams, SelLocs); 3429 3430 ToMethod->setLexicalDeclContext(LexicalDC); 3431 Importer.Imported(D, ToMethod); 3432 LexicalDC->addDeclInternal(ToMethod); 3433 return ToMethod; 3434 } 3435 3436 Decl *ASTNodeImporter::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) { 3437 // Import the major distinguishing characteristics of a category. 3438 DeclContext *DC, *LexicalDC; 3439 DeclarationName Name; 3440 SourceLocation Loc; 3441 NamedDecl *ToD; 3442 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3443 return nullptr; 3444 if (ToD) 3445 return ToD; 3446 3447 TypeSourceInfo *BoundInfo = Importer.Import(D->getTypeSourceInfo()); 3448 if (!BoundInfo) 3449 return nullptr; 3450 3451 ObjCTypeParamDecl *Result = ObjCTypeParamDecl::Create( 3452 Importer.getToContext(), DC, 3453 D->getVariance(), 3454 Importer.Import(D->getVarianceLoc()), 3455 D->getIndex(), 3456 Importer.Import(D->getLocation()), 3457 Name.getAsIdentifierInfo(), 3458 Importer.Import(D->getColonLoc()), 3459 BoundInfo); 3460 Importer.Imported(D, Result); 3461 Result->setLexicalDeclContext(LexicalDC); 3462 return Result; 3463 } 3464 3465 Decl *ASTNodeImporter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { 3466 // Import the major distinguishing characteristics of a category. 3467 DeclContext *DC, *LexicalDC; 3468 DeclarationName Name; 3469 SourceLocation Loc; 3470 NamedDecl *ToD; 3471 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3472 return nullptr; 3473 if (ToD) 3474 return ToD; 3475 3476 ObjCInterfaceDecl *ToInterface 3477 = cast_or_null<ObjCInterfaceDecl>(Importer.Import(D->getClassInterface())); 3478 if (!ToInterface) 3479 return nullptr; 3480 3481 // Determine if we've already encountered this category. 3482 ObjCCategoryDecl *MergeWithCategory 3483 = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo()); 3484 ObjCCategoryDecl *ToCategory = MergeWithCategory; 3485 if (!ToCategory) { 3486 ToCategory = ObjCCategoryDecl::Create(Importer.getToContext(), DC, 3487 Importer.Import(D->getAtStartLoc()), 3488 Loc, 3489 Importer.Import(D->getCategoryNameLoc()), 3490 Name.getAsIdentifierInfo(), 3491 ToInterface, 3492 /*TypeParamList=*/nullptr, 3493 Importer.Import(D->getIvarLBraceLoc()), 3494 Importer.Import(D->getIvarRBraceLoc())); 3495 ToCategory->setLexicalDeclContext(LexicalDC); 3496 LexicalDC->addDeclInternal(ToCategory); 3497 Importer.Imported(D, ToCategory); 3498 // Import the type parameter list after calling Imported, to avoid 3499 // loops when bringing in their DeclContext. 3500 ToCategory->setTypeParamList(ImportObjCTypeParamList( 3501 D->getTypeParamList())); 3502 3503 // Import protocols 3504 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3505 SmallVector<SourceLocation, 4> ProtocolLocs; 3506 ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc 3507 = D->protocol_loc_begin(); 3508 for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(), 3509 FromProtoEnd = D->protocol_end(); 3510 FromProto != FromProtoEnd; 3511 ++FromProto, ++FromProtoLoc) { 3512 ObjCProtocolDecl *ToProto 3513 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3514 if (!ToProto) 3515 return nullptr; 3516 Protocols.push_back(ToProto); 3517 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3518 } 3519 3520 // FIXME: If we're merging, make sure that the protocol list is the same. 3521 ToCategory->setProtocolList(Protocols.data(), Protocols.size(), 3522 ProtocolLocs.data(), Importer.getToContext()); 3523 3524 } else { 3525 Importer.Imported(D, ToCategory); 3526 } 3527 3528 // Import all of the members of this category. 3529 ImportDeclContext(D); 3530 3531 // If we have an implementation, import it as well. 3532 if (D->getImplementation()) { 3533 ObjCCategoryImplDecl *Impl 3534 = cast_or_null<ObjCCategoryImplDecl>( 3535 Importer.Import(D->getImplementation())); 3536 if (!Impl) 3537 return nullptr; 3538 3539 ToCategory->setImplementation(Impl); 3540 } 3541 3542 return ToCategory; 3543 } 3544 3545 bool ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From, 3546 ObjCProtocolDecl *To, 3547 ImportDefinitionKind Kind) { 3548 if (To->getDefinition()) { 3549 if (shouldForceImportDeclContext(Kind)) 3550 ImportDeclContext(From); 3551 return false; 3552 } 3553 3554 // Start the protocol definition 3555 To->startDefinition(); 3556 3557 // Import protocols 3558 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3559 SmallVector<SourceLocation, 4> ProtocolLocs; 3560 ObjCProtocolDecl::protocol_loc_iterator 3561 FromProtoLoc = From->protocol_loc_begin(); 3562 for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(), 3563 FromProtoEnd = From->protocol_end(); 3564 FromProto != FromProtoEnd; 3565 ++FromProto, ++FromProtoLoc) { 3566 ObjCProtocolDecl *ToProto 3567 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3568 if (!ToProto) 3569 return true; 3570 Protocols.push_back(ToProto); 3571 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3572 } 3573 3574 // FIXME: If we're merging, make sure that the protocol list is the same. 3575 To->setProtocolList(Protocols.data(), Protocols.size(), 3576 ProtocolLocs.data(), Importer.getToContext()); 3577 3578 if (shouldForceImportDeclContext(Kind)) { 3579 // Import all of the members of this protocol. 3580 ImportDeclContext(From, /*ForceImport=*/true); 3581 } 3582 return false; 3583 } 3584 3585 Decl *ASTNodeImporter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { 3586 // If this protocol has a definition in the translation unit we're coming 3587 // from, but this particular declaration is not that definition, import the 3588 // definition and map to that. 3589 ObjCProtocolDecl *Definition = D->getDefinition(); 3590 if (Definition && Definition != D) { 3591 Decl *ImportedDef = Importer.Import(Definition); 3592 if (!ImportedDef) 3593 return nullptr; 3594 3595 return Importer.Imported(D, ImportedDef); 3596 } 3597 3598 // Import the major distinguishing characteristics of a protocol. 3599 DeclContext *DC, *LexicalDC; 3600 DeclarationName Name; 3601 SourceLocation Loc; 3602 NamedDecl *ToD; 3603 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3604 return nullptr; 3605 if (ToD) 3606 return ToD; 3607 3608 ObjCProtocolDecl *MergeWithProtocol = nullptr; 3609 SmallVector<NamedDecl *, 2> FoundDecls; 3610 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3611 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3612 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_ObjCProtocol)) 3613 continue; 3614 3615 if ((MergeWithProtocol = dyn_cast<ObjCProtocolDecl>(FoundDecls[I]))) 3616 break; 3617 } 3618 3619 ObjCProtocolDecl *ToProto = MergeWithProtocol; 3620 if (!ToProto) { 3621 ToProto = ObjCProtocolDecl::Create(Importer.getToContext(), DC, 3622 Name.getAsIdentifierInfo(), Loc, 3623 Importer.Import(D->getAtStartLoc()), 3624 /*PrevDecl=*/nullptr); 3625 ToProto->setLexicalDeclContext(LexicalDC); 3626 LexicalDC->addDeclInternal(ToProto); 3627 } 3628 3629 Importer.Imported(D, ToProto); 3630 3631 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToProto)) 3632 return nullptr; 3633 3634 return ToProto; 3635 } 3636 3637 Decl *ASTNodeImporter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 3638 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3639 DeclContext *LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3640 3641 SourceLocation ExternLoc = Importer.Import(D->getExternLoc()); 3642 SourceLocation LangLoc = Importer.Import(D->getLocation()); 3643 3644 bool HasBraces = D->hasBraces(); 3645 3646 LinkageSpecDecl *ToLinkageSpec = 3647 LinkageSpecDecl::Create(Importer.getToContext(), 3648 DC, 3649 ExternLoc, 3650 LangLoc, 3651 D->getLanguage(), 3652 HasBraces); 3653 3654 if (HasBraces) { 3655 SourceLocation RBraceLoc = Importer.Import(D->getRBraceLoc()); 3656 ToLinkageSpec->setRBraceLoc(RBraceLoc); 3657 } 3658 3659 ToLinkageSpec->setLexicalDeclContext(LexicalDC); 3660 LexicalDC->addDeclInternal(ToLinkageSpec); 3661 3662 Importer.Imported(D, ToLinkageSpec); 3663 3664 return ToLinkageSpec; 3665 } 3666 3667 bool ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From, 3668 ObjCInterfaceDecl *To, 3669 ImportDefinitionKind Kind) { 3670 if (To->getDefinition()) { 3671 // Check consistency of superclass. 3672 ObjCInterfaceDecl *FromSuper = From->getSuperClass(); 3673 if (FromSuper) { 3674 FromSuper = cast_or_null<ObjCInterfaceDecl>(Importer.Import(FromSuper)); 3675 if (!FromSuper) 3676 return true; 3677 } 3678 3679 ObjCInterfaceDecl *ToSuper = To->getSuperClass(); 3680 if ((bool)FromSuper != (bool)ToSuper || 3681 (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) { 3682 Importer.ToDiag(To->getLocation(), 3683 diag::err_odr_objc_superclass_inconsistent) 3684 << To->getDeclName(); 3685 if (ToSuper) 3686 Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass) 3687 << To->getSuperClass()->getDeclName(); 3688 else 3689 Importer.ToDiag(To->getLocation(), 3690 diag::note_odr_objc_missing_superclass); 3691 if (From->getSuperClass()) 3692 Importer.FromDiag(From->getSuperClassLoc(), 3693 diag::note_odr_objc_superclass) 3694 << From->getSuperClass()->getDeclName(); 3695 else 3696 Importer.FromDiag(From->getLocation(), 3697 diag::note_odr_objc_missing_superclass); 3698 } 3699 3700 if (shouldForceImportDeclContext(Kind)) 3701 ImportDeclContext(From); 3702 return false; 3703 } 3704 3705 // Start the definition. 3706 To->startDefinition(); 3707 3708 // If this class has a superclass, import it. 3709 if (From->getSuperClass()) { 3710 TypeSourceInfo *SuperTInfo = Importer.Import(From->getSuperClassTInfo()); 3711 if (!SuperTInfo) 3712 return true; 3713 3714 To->setSuperClass(SuperTInfo); 3715 } 3716 3717 // Import protocols 3718 SmallVector<ObjCProtocolDecl *, 4> Protocols; 3719 SmallVector<SourceLocation, 4> ProtocolLocs; 3720 ObjCInterfaceDecl::protocol_loc_iterator 3721 FromProtoLoc = From->protocol_loc_begin(); 3722 3723 for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(), 3724 FromProtoEnd = From->protocol_end(); 3725 FromProto != FromProtoEnd; 3726 ++FromProto, ++FromProtoLoc) { 3727 ObjCProtocolDecl *ToProto 3728 = cast_or_null<ObjCProtocolDecl>(Importer.Import(*FromProto)); 3729 if (!ToProto) 3730 return true; 3731 Protocols.push_back(ToProto); 3732 ProtocolLocs.push_back(Importer.Import(*FromProtoLoc)); 3733 } 3734 3735 // FIXME: If we're merging, make sure that the protocol list is the same. 3736 To->setProtocolList(Protocols.data(), Protocols.size(), 3737 ProtocolLocs.data(), Importer.getToContext()); 3738 3739 // Import categories. When the categories themselves are imported, they'll 3740 // hook themselves into this interface. 3741 for (auto *Cat : From->known_categories()) 3742 Importer.Import(Cat); 3743 3744 // If we have an @implementation, import it as well. 3745 if (From->getImplementation()) { 3746 ObjCImplementationDecl *Impl = cast_or_null<ObjCImplementationDecl>( 3747 Importer.Import(From->getImplementation())); 3748 if (!Impl) 3749 return true; 3750 3751 To->setImplementation(Impl); 3752 } 3753 3754 if (shouldForceImportDeclContext(Kind)) { 3755 // Import all of the members of this class. 3756 ImportDeclContext(From, /*ForceImport=*/true); 3757 } 3758 return false; 3759 } 3760 3761 ObjCTypeParamList * 3762 ASTNodeImporter::ImportObjCTypeParamList(ObjCTypeParamList *list) { 3763 if (!list) 3764 return nullptr; 3765 3766 SmallVector<ObjCTypeParamDecl *, 4> toTypeParams; 3767 for (auto fromTypeParam : *list) { 3768 auto toTypeParam = cast_or_null<ObjCTypeParamDecl>( 3769 Importer.Import(fromTypeParam)); 3770 if (!toTypeParam) 3771 return nullptr; 3772 3773 toTypeParams.push_back(toTypeParam); 3774 } 3775 3776 return ObjCTypeParamList::create(Importer.getToContext(), 3777 Importer.Import(list->getLAngleLoc()), 3778 toTypeParams, 3779 Importer.Import(list->getRAngleLoc())); 3780 } 3781 3782 Decl *ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { 3783 // If this class has a definition in the translation unit we're coming from, 3784 // but this particular declaration is not that definition, import the 3785 // definition and map to that. 3786 ObjCInterfaceDecl *Definition = D->getDefinition(); 3787 if (Definition && Definition != D) { 3788 Decl *ImportedDef = Importer.Import(Definition); 3789 if (!ImportedDef) 3790 return nullptr; 3791 3792 return Importer.Imported(D, ImportedDef); 3793 } 3794 3795 // Import the major distinguishing characteristics of an @interface. 3796 DeclContext *DC, *LexicalDC; 3797 DeclarationName Name; 3798 SourceLocation Loc; 3799 NamedDecl *ToD; 3800 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3801 return nullptr; 3802 if (ToD) 3803 return ToD; 3804 3805 // Look for an existing interface with the same name. 3806 ObjCInterfaceDecl *MergeWithIface = nullptr; 3807 SmallVector<NamedDecl *, 2> FoundDecls; 3808 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3809 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3810 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 3811 continue; 3812 3813 if ((MergeWithIface = dyn_cast<ObjCInterfaceDecl>(FoundDecls[I]))) 3814 break; 3815 } 3816 3817 // Create an interface declaration, if one does not already exist. 3818 ObjCInterfaceDecl *ToIface = MergeWithIface; 3819 if (!ToIface) { 3820 ToIface = ObjCInterfaceDecl::Create(Importer.getToContext(), DC, 3821 Importer.Import(D->getAtStartLoc()), 3822 Name.getAsIdentifierInfo(), 3823 /*TypeParamList=*/nullptr, 3824 /*PrevDecl=*/nullptr, Loc, 3825 D->isImplicitInterfaceDecl()); 3826 ToIface->setLexicalDeclContext(LexicalDC); 3827 LexicalDC->addDeclInternal(ToIface); 3828 } 3829 Importer.Imported(D, ToIface); 3830 // Import the type parameter list after calling Imported, to avoid 3831 // loops when bringing in their DeclContext. 3832 ToIface->setTypeParamList(ImportObjCTypeParamList( 3833 D->getTypeParamListAsWritten())); 3834 3835 if (D->isThisDeclarationADefinition() && ImportDefinition(D, ToIface)) 3836 return nullptr; 3837 3838 return ToIface; 3839 } 3840 3841 Decl *ASTNodeImporter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) { 3842 ObjCCategoryDecl *Category = cast_or_null<ObjCCategoryDecl>( 3843 Importer.Import(D->getCategoryDecl())); 3844 if (!Category) 3845 return nullptr; 3846 3847 ObjCCategoryImplDecl *ToImpl = Category->getImplementation(); 3848 if (!ToImpl) { 3849 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 3850 if (!DC) 3851 return nullptr; 3852 3853 SourceLocation CategoryNameLoc = Importer.Import(D->getCategoryNameLoc()); 3854 ToImpl = ObjCCategoryImplDecl::Create(Importer.getToContext(), DC, 3855 Importer.Import(D->getIdentifier()), 3856 Category->getClassInterface(), 3857 Importer.Import(D->getLocation()), 3858 Importer.Import(D->getAtStartLoc()), 3859 CategoryNameLoc); 3860 3861 DeclContext *LexicalDC = DC; 3862 if (D->getDeclContext() != D->getLexicalDeclContext()) { 3863 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 3864 if (!LexicalDC) 3865 return nullptr; 3866 3867 ToImpl->setLexicalDeclContext(LexicalDC); 3868 } 3869 3870 LexicalDC->addDeclInternal(ToImpl); 3871 Category->setImplementation(ToImpl); 3872 } 3873 3874 Importer.Imported(D, ToImpl); 3875 ImportDeclContext(D); 3876 return ToImpl; 3877 } 3878 3879 Decl *ASTNodeImporter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) { 3880 // Find the corresponding interface. 3881 ObjCInterfaceDecl *Iface = cast_or_null<ObjCInterfaceDecl>( 3882 Importer.Import(D->getClassInterface())); 3883 if (!Iface) 3884 return nullptr; 3885 3886 // Import the superclass, if any. 3887 ObjCInterfaceDecl *Super = nullptr; 3888 if (D->getSuperClass()) { 3889 Super = cast_or_null<ObjCInterfaceDecl>( 3890 Importer.Import(D->getSuperClass())); 3891 if (!Super) 3892 return nullptr; 3893 } 3894 3895 ObjCImplementationDecl *Impl = Iface->getImplementation(); 3896 if (!Impl) { 3897 // We haven't imported an implementation yet. Create a new @implementation 3898 // now. 3899 Impl = ObjCImplementationDecl::Create(Importer.getToContext(), 3900 Importer.ImportContext(D->getDeclContext()), 3901 Iface, Super, 3902 Importer.Import(D->getLocation()), 3903 Importer.Import(D->getAtStartLoc()), 3904 Importer.Import(D->getSuperClassLoc()), 3905 Importer.Import(D->getIvarLBraceLoc()), 3906 Importer.Import(D->getIvarRBraceLoc())); 3907 3908 if (D->getDeclContext() != D->getLexicalDeclContext()) { 3909 DeclContext *LexicalDC 3910 = Importer.ImportContext(D->getLexicalDeclContext()); 3911 if (!LexicalDC) 3912 return nullptr; 3913 Impl->setLexicalDeclContext(LexicalDC); 3914 } 3915 3916 // Associate the implementation with the class it implements. 3917 Iface->setImplementation(Impl); 3918 Importer.Imported(D, Iface->getImplementation()); 3919 } else { 3920 Importer.Imported(D, Iface->getImplementation()); 3921 3922 // Verify that the existing @implementation has the same superclass. 3923 if ((Super && !Impl->getSuperClass()) || 3924 (!Super && Impl->getSuperClass()) || 3925 (Super && Impl->getSuperClass() && 3926 !declaresSameEntity(Super->getCanonicalDecl(), 3927 Impl->getSuperClass()))) { 3928 Importer.ToDiag(Impl->getLocation(), 3929 diag::err_odr_objc_superclass_inconsistent) 3930 << Iface->getDeclName(); 3931 // FIXME: It would be nice to have the location of the superclass 3932 // below. 3933 if (Impl->getSuperClass()) 3934 Importer.ToDiag(Impl->getLocation(), 3935 diag::note_odr_objc_superclass) 3936 << Impl->getSuperClass()->getDeclName(); 3937 else 3938 Importer.ToDiag(Impl->getLocation(), 3939 diag::note_odr_objc_missing_superclass); 3940 if (D->getSuperClass()) 3941 Importer.FromDiag(D->getLocation(), 3942 diag::note_odr_objc_superclass) 3943 << D->getSuperClass()->getDeclName(); 3944 else 3945 Importer.FromDiag(D->getLocation(), 3946 diag::note_odr_objc_missing_superclass); 3947 return nullptr; 3948 } 3949 } 3950 3951 // Import all of the members of this @implementation. 3952 ImportDeclContext(D); 3953 3954 return Impl; 3955 } 3956 3957 Decl *ASTNodeImporter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { 3958 // Import the major distinguishing characteristics of an @property. 3959 DeclContext *DC, *LexicalDC; 3960 DeclarationName Name; 3961 SourceLocation Loc; 3962 NamedDecl *ToD; 3963 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 3964 return nullptr; 3965 if (ToD) 3966 return ToD; 3967 3968 // Check whether we have already imported this property. 3969 SmallVector<NamedDecl *, 2> FoundDecls; 3970 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 3971 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 3972 if (ObjCPropertyDecl *FoundProp 3973 = dyn_cast<ObjCPropertyDecl>(FoundDecls[I])) { 3974 // Check property types. 3975 if (!Importer.IsStructurallyEquivalent(D->getType(), 3976 FoundProp->getType())) { 3977 Importer.ToDiag(Loc, diag::err_odr_objc_property_type_inconsistent) 3978 << Name << D->getType() << FoundProp->getType(); 3979 Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here) 3980 << FoundProp->getType(); 3981 return nullptr; 3982 } 3983 3984 // FIXME: Check property attributes, getters, setters, etc.? 3985 3986 // Consider these properties to be equivalent. 3987 Importer.Imported(D, FoundProp); 3988 return FoundProp; 3989 } 3990 } 3991 3992 // Import the type. 3993 TypeSourceInfo *TSI = Importer.Import(D->getTypeSourceInfo()); 3994 if (!TSI) 3995 return nullptr; 3996 3997 // Create the new property. 3998 ObjCPropertyDecl *ToProperty 3999 = ObjCPropertyDecl::Create(Importer.getToContext(), DC, Loc, 4000 Name.getAsIdentifierInfo(), 4001 Importer.Import(D->getAtLoc()), 4002 Importer.Import(D->getLParenLoc()), 4003 Importer.Import(D->getType()), 4004 TSI, 4005 D->getPropertyImplementation()); 4006 Importer.Imported(D, ToProperty); 4007 ToProperty->setLexicalDeclContext(LexicalDC); 4008 LexicalDC->addDeclInternal(ToProperty); 4009 4010 ToProperty->setPropertyAttributes(D->getPropertyAttributes()); 4011 ToProperty->setPropertyAttributesAsWritten( 4012 D->getPropertyAttributesAsWritten()); 4013 ToProperty->setGetterName(Importer.Import(D->getGetterName())); 4014 ToProperty->setSetterName(Importer.Import(D->getSetterName())); 4015 ToProperty->setGetterMethodDecl( 4016 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getGetterMethodDecl()))); 4017 ToProperty->setSetterMethodDecl( 4018 cast_or_null<ObjCMethodDecl>(Importer.Import(D->getSetterMethodDecl()))); 4019 ToProperty->setPropertyIvarDecl( 4020 cast_or_null<ObjCIvarDecl>(Importer.Import(D->getPropertyIvarDecl()))); 4021 return ToProperty; 4022 } 4023 4024 Decl *ASTNodeImporter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { 4025 ObjCPropertyDecl *Property = cast_or_null<ObjCPropertyDecl>( 4026 Importer.Import(D->getPropertyDecl())); 4027 if (!Property) 4028 return nullptr; 4029 4030 DeclContext *DC = Importer.ImportContext(D->getDeclContext()); 4031 if (!DC) 4032 return nullptr; 4033 4034 // Import the lexical declaration context. 4035 DeclContext *LexicalDC = DC; 4036 if (D->getDeclContext() != D->getLexicalDeclContext()) { 4037 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4038 if (!LexicalDC) 4039 return nullptr; 4040 } 4041 4042 ObjCImplDecl *InImpl = dyn_cast<ObjCImplDecl>(LexicalDC); 4043 if (!InImpl) 4044 return nullptr; 4045 4046 // Import the ivar (for an @synthesize). 4047 ObjCIvarDecl *Ivar = nullptr; 4048 if (D->getPropertyIvarDecl()) { 4049 Ivar = cast_or_null<ObjCIvarDecl>( 4050 Importer.Import(D->getPropertyIvarDecl())); 4051 if (!Ivar) 4052 return nullptr; 4053 } 4054 4055 ObjCPropertyImplDecl *ToImpl 4056 = InImpl->FindPropertyImplDecl(Property->getIdentifier()); 4057 if (!ToImpl) { 4058 ToImpl = ObjCPropertyImplDecl::Create(Importer.getToContext(), DC, 4059 Importer.Import(D->getLocStart()), 4060 Importer.Import(D->getLocation()), 4061 Property, 4062 D->getPropertyImplementation(), 4063 Ivar, 4064 Importer.Import(D->getPropertyIvarDeclLoc())); 4065 ToImpl->setLexicalDeclContext(LexicalDC); 4066 Importer.Imported(D, ToImpl); 4067 LexicalDC->addDeclInternal(ToImpl); 4068 } else { 4069 // Check that we have the same kind of property implementation (@synthesize 4070 // vs. @dynamic). 4071 if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) { 4072 Importer.ToDiag(ToImpl->getLocation(), 4073 diag::err_odr_objc_property_impl_kind_inconsistent) 4074 << Property->getDeclName() 4075 << (ToImpl->getPropertyImplementation() 4076 == ObjCPropertyImplDecl::Dynamic); 4077 Importer.FromDiag(D->getLocation(), 4078 diag::note_odr_objc_property_impl_kind) 4079 << D->getPropertyDecl()->getDeclName() 4080 << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic); 4081 return nullptr; 4082 } 4083 4084 // For @synthesize, check that we have the same 4085 if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize && 4086 Ivar != ToImpl->getPropertyIvarDecl()) { 4087 Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(), 4088 diag::err_odr_objc_synthesize_ivar_inconsistent) 4089 << Property->getDeclName() 4090 << ToImpl->getPropertyIvarDecl()->getDeclName() 4091 << Ivar->getDeclName(); 4092 Importer.FromDiag(D->getPropertyIvarDeclLoc(), 4093 diag::note_odr_objc_synthesize_ivar_here) 4094 << D->getPropertyIvarDecl()->getDeclName(); 4095 return nullptr; 4096 } 4097 4098 // Merge the existing implementation with the new implementation. 4099 Importer.Imported(D, ToImpl); 4100 } 4101 4102 return ToImpl; 4103 } 4104 4105 Decl *ASTNodeImporter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { 4106 // For template arguments, we adopt the translation unit as our declaration 4107 // context. This context will be fixed when the actual template declaration 4108 // is created. 4109 4110 // FIXME: Import default argument. 4111 return TemplateTypeParmDecl::Create(Importer.getToContext(), 4112 Importer.getToContext().getTranslationUnitDecl(), 4113 Importer.Import(D->getLocStart()), 4114 Importer.Import(D->getLocation()), 4115 D->getDepth(), 4116 D->getIndex(), 4117 Importer.Import(D->getIdentifier()), 4118 D->wasDeclaredWithTypename(), 4119 D->isParameterPack()); 4120 } 4121 4122 Decl * 4123 ASTNodeImporter::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { 4124 // Import the name of this declaration. 4125 DeclarationName Name = Importer.Import(D->getDeclName()); 4126 if (D->getDeclName() && !Name) 4127 return nullptr; 4128 4129 // Import the location of this declaration. 4130 SourceLocation Loc = Importer.Import(D->getLocation()); 4131 4132 // Import the type of this declaration. 4133 QualType T = Importer.Import(D->getType()); 4134 if (T.isNull()) 4135 return nullptr; 4136 4137 // Import type-source information. 4138 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 4139 if (D->getTypeSourceInfo() && !TInfo) 4140 return nullptr; 4141 4142 // FIXME: Import default argument. 4143 4144 return NonTypeTemplateParmDecl::Create(Importer.getToContext(), 4145 Importer.getToContext().getTranslationUnitDecl(), 4146 Importer.Import(D->getInnerLocStart()), 4147 Loc, D->getDepth(), D->getPosition(), 4148 Name.getAsIdentifierInfo(), 4149 T, D->isParameterPack(), TInfo); 4150 } 4151 4152 Decl * 4153 ASTNodeImporter::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { 4154 // Import the name of this declaration. 4155 DeclarationName Name = Importer.Import(D->getDeclName()); 4156 if (D->getDeclName() && !Name) 4157 return nullptr; 4158 4159 // Import the location of this declaration. 4160 SourceLocation Loc = Importer.Import(D->getLocation()); 4161 4162 // Import template parameters. 4163 TemplateParameterList *TemplateParams 4164 = ImportTemplateParameterList(D->getTemplateParameters()); 4165 if (!TemplateParams) 4166 return nullptr; 4167 4168 // FIXME: Import default argument. 4169 4170 return TemplateTemplateParmDecl::Create(Importer.getToContext(), 4171 Importer.getToContext().getTranslationUnitDecl(), 4172 Loc, D->getDepth(), D->getPosition(), 4173 D->isParameterPack(), 4174 Name.getAsIdentifierInfo(), 4175 TemplateParams); 4176 } 4177 4178 Decl *ASTNodeImporter::VisitClassTemplateDecl(ClassTemplateDecl *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 CXXRecordDecl *Definition 4183 = cast_or_null<CXXRecordDecl>(D->getTemplatedDecl()->getDefinition()); 4184 if (Definition && Definition != D->getTemplatedDecl()) { 4185 Decl *ImportedDef 4186 = Importer.Import(Definition->getDescribedClassTemplate()); 4187 if (!ImportedDef) 4188 return nullptr; 4189 4190 return Importer.Imported(D, ImportedDef); 4191 } 4192 4193 // Import the major distinguishing characteristics of this class template. 4194 DeclContext *DC, *LexicalDC; 4195 DeclarationName Name; 4196 SourceLocation Loc; 4197 NamedDecl *ToD; 4198 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4199 return nullptr; 4200 if (ToD) 4201 return ToD; 4202 4203 // We may already have a template of the same name; try to find and match it. 4204 if (!DC->isFunctionOrMethod()) { 4205 SmallVector<NamedDecl *, 4> ConflictingDecls; 4206 SmallVector<NamedDecl *, 2> FoundDecls; 4207 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4208 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 4209 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4210 continue; 4211 4212 Decl *Found = FoundDecls[I]; 4213 if (ClassTemplateDecl *FoundTemplate 4214 = dyn_cast<ClassTemplateDecl>(Found)) { 4215 if (IsStructuralMatch(D, FoundTemplate)) { 4216 // The class templates structurally match; call it the same template. 4217 // FIXME: We may be filling in a forward declaration here. Handle 4218 // this case! 4219 Importer.Imported(D->getTemplatedDecl(), 4220 FoundTemplate->getTemplatedDecl()); 4221 return Importer.Imported(D, FoundTemplate); 4222 } 4223 } 4224 4225 ConflictingDecls.push_back(FoundDecls[I]); 4226 } 4227 4228 if (!ConflictingDecls.empty()) { 4229 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 4230 ConflictingDecls.data(), 4231 ConflictingDecls.size()); 4232 } 4233 4234 if (!Name) 4235 return nullptr; 4236 } 4237 4238 CXXRecordDecl *DTemplated = D->getTemplatedDecl(); 4239 4240 // Create the declaration that is being templated. 4241 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart()); 4242 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation()); 4243 CXXRecordDecl *D2Templated = CXXRecordDecl::Create(Importer.getToContext(), 4244 DTemplated->getTagKind(), 4245 DC, StartLoc, IdLoc, 4246 Name.getAsIdentifierInfo()); 4247 D2Templated->setAccess(DTemplated->getAccess()); 4248 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc())); 4249 D2Templated->setLexicalDeclContext(LexicalDC); 4250 4251 // Create the class template declaration itself. 4252 TemplateParameterList *TemplateParams 4253 = ImportTemplateParameterList(D->getTemplateParameters()); 4254 if (!TemplateParams) 4255 return nullptr; 4256 4257 ClassTemplateDecl *D2 = ClassTemplateDecl::Create(Importer.getToContext(), DC, 4258 Loc, Name, TemplateParams, 4259 D2Templated, 4260 /*PrevDecl=*/nullptr); 4261 D2Templated->setDescribedClassTemplate(D2); 4262 4263 D2->setAccess(D->getAccess()); 4264 D2->setLexicalDeclContext(LexicalDC); 4265 LexicalDC->addDeclInternal(D2); 4266 4267 // Note the relationship between the class templates. 4268 Importer.Imported(D, D2); 4269 Importer.Imported(DTemplated, D2Templated); 4270 4271 if (DTemplated->isCompleteDefinition() && 4272 !D2Templated->isCompleteDefinition()) { 4273 // FIXME: Import definition! 4274 } 4275 4276 return D2; 4277 } 4278 4279 Decl *ASTNodeImporter::VisitClassTemplateSpecializationDecl( 4280 ClassTemplateSpecializationDecl *D) { 4281 // If this record has a definition in the translation unit we're coming from, 4282 // but this particular declaration is not that definition, import the 4283 // definition and map to that. 4284 TagDecl *Definition = D->getDefinition(); 4285 if (Definition && Definition != D) { 4286 Decl *ImportedDef = Importer.Import(Definition); 4287 if (!ImportedDef) 4288 return nullptr; 4289 4290 return Importer.Imported(D, ImportedDef); 4291 } 4292 4293 ClassTemplateDecl *ClassTemplate 4294 = cast_or_null<ClassTemplateDecl>(Importer.Import( 4295 D->getSpecializedTemplate())); 4296 if (!ClassTemplate) 4297 return nullptr; 4298 4299 // Import the context of this declaration. 4300 DeclContext *DC = ClassTemplate->getDeclContext(); 4301 if (!DC) 4302 return nullptr; 4303 4304 DeclContext *LexicalDC = DC; 4305 if (D->getDeclContext() != D->getLexicalDeclContext()) { 4306 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4307 if (!LexicalDC) 4308 return nullptr; 4309 } 4310 4311 // Import the location of this declaration. 4312 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 4313 SourceLocation IdLoc = Importer.Import(D->getLocation()); 4314 4315 // Import template arguments. 4316 SmallVector<TemplateArgument, 2> TemplateArgs; 4317 if (ImportTemplateArguments(D->getTemplateArgs().data(), 4318 D->getTemplateArgs().size(), 4319 TemplateArgs)) 4320 return nullptr; 4321 4322 // Try to find an existing specialization with these template arguments. 4323 void *InsertPos = nullptr; 4324 ClassTemplateSpecializationDecl *D2 4325 = ClassTemplate->findSpecialization(TemplateArgs, InsertPos); 4326 if (D2) { 4327 // We already have a class template specialization with these template 4328 // arguments. 4329 4330 // FIXME: Check for specialization vs. instantiation errors. 4331 4332 if (RecordDecl *FoundDef = D2->getDefinition()) { 4333 if (!D->isCompleteDefinition() || IsStructuralMatch(D, FoundDef)) { 4334 // The record types structurally match, or the "from" translation 4335 // unit only had a forward declaration anyway; call it the same 4336 // function. 4337 return Importer.Imported(D, FoundDef); 4338 } 4339 } 4340 } else { 4341 // Create a new specialization. 4342 D2 = ClassTemplateSpecializationDecl::Create(Importer.getToContext(), 4343 D->getTagKind(), DC, 4344 StartLoc, IdLoc, 4345 ClassTemplate, 4346 TemplateArgs.data(), 4347 TemplateArgs.size(), 4348 /*PrevDecl=*/nullptr); 4349 D2->setSpecializationKind(D->getSpecializationKind()); 4350 4351 // Add this specialization to the class template. 4352 ClassTemplate->AddSpecialization(D2, InsertPos); 4353 4354 // Import the qualifier, if any. 4355 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 4356 4357 // Add the specialization to this context. 4358 D2->setLexicalDeclContext(LexicalDC); 4359 LexicalDC->addDeclInternal(D2); 4360 } 4361 Importer.Imported(D, D2); 4362 4363 if (D->isCompleteDefinition() && ImportDefinition(D, D2)) 4364 return nullptr; 4365 4366 return D2; 4367 } 4368 4369 Decl *ASTNodeImporter::VisitVarTemplateDecl(VarTemplateDecl *D) { 4370 // If this variable has a definition in the translation unit we're coming 4371 // from, 4372 // but this particular declaration is not that definition, import the 4373 // definition and map to that. 4374 VarDecl *Definition = 4375 cast_or_null<VarDecl>(D->getTemplatedDecl()->getDefinition()); 4376 if (Definition && Definition != D->getTemplatedDecl()) { 4377 Decl *ImportedDef = Importer.Import(Definition->getDescribedVarTemplate()); 4378 if (!ImportedDef) 4379 return nullptr; 4380 4381 return Importer.Imported(D, ImportedDef); 4382 } 4383 4384 // Import the major distinguishing characteristics of this variable template. 4385 DeclContext *DC, *LexicalDC; 4386 DeclarationName Name; 4387 SourceLocation Loc; 4388 NamedDecl *ToD; 4389 if (ImportDeclParts(D, DC, LexicalDC, Name, ToD, Loc)) 4390 return nullptr; 4391 if (ToD) 4392 return ToD; 4393 4394 // We may already have a template of the same name; try to find and match it. 4395 assert(!DC->isFunctionOrMethod() && 4396 "Variable templates cannot be declared at function scope"); 4397 SmallVector<NamedDecl *, 4> ConflictingDecls; 4398 SmallVector<NamedDecl *, 2> FoundDecls; 4399 DC->getRedeclContext()->localUncachedLookup(Name, FoundDecls); 4400 for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) { 4401 if (!FoundDecls[I]->isInIdentifierNamespace(Decl::IDNS_Ordinary)) 4402 continue; 4403 4404 Decl *Found = FoundDecls[I]; 4405 if (VarTemplateDecl *FoundTemplate = dyn_cast<VarTemplateDecl>(Found)) { 4406 if (IsStructuralMatch(D, FoundTemplate)) { 4407 // The variable templates structurally match; call it the same template. 4408 Importer.Imported(D->getTemplatedDecl(), 4409 FoundTemplate->getTemplatedDecl()); 4410 return Importer.Imported(D, FoundTemplate); 4411 } 4412 } 4413 4414 ConflictingDecls.push_back(FoundDecls[I]); 4415 } 4416 4417 if (!ConflictingDecls.empty()) { 4418 Name = Importer.HandleNameConflict(Name, DC, Decl::IDNS_Ordinary, 4419 ConflictingDecls.data(), 4420 ConflictingDecls.size()); 4421 } 4422 4423 if (!Name) 4424 return nullptr; 4425 4426 VarDecl *DTemplated = D->getTemplatedDecl(); 4427 4428 // Import the type. 4429 QualType T = Importer.Import(DTemplated->getType()); 4430 if (T.isNull()) 4431 return nullptr; 4432 4433 // Create the declaration that is being templated. 4434 SourceLocation StartLoc = Importer.Import(DTemplated->getLocStart()); 4435 SourceLocation IdLoc = Importer.Import(DTemplated->getLocation()); 4436 TypeSourceInfo *TInfo = Importer.Import(DTemplated->getTypeSourceInfo()); 4437 VarDecl *D2Templated = VarDecl::Create(Importer.getToContext(), DC, StartLoc, 4438 IdLoc, Name.getAsIdentifierInfo(), T, 4439 TInfo, DTemplated->getStorageClass()); 4440 D2Templated->setAccess(DTemplated->getAccess()); 4441 D2Templated->setQualifierInfo(Importer.Import(DTemplated->getQualifierLoc())); 4442 D2Templated->setLexicalDeclContext(LexicalDC); 4443 4444 // Importer.Imported(DTemplated, D2Templated); 4445 // LexicalDC->addDeclInternal(D2Templated); 4446 4447 // Merge the initializer. 4448 if (ImportDefinition(DTemplated, D2Templated)) 4449 return nullptr; 4450 4451 // Create the variable template declaration itself. 4452 TemplateParameterList *TemplateParams = 4453 ImportTemplateParameterList(D->getTemplateParameters()); 4454 if (!TemplateParams) 4455 return nullptr; 4456 4457 VarTemplateDecl *D2 = VarTemplateDecl::Create( 4458 Importer.getToContext(), DC, Loc, Name, TemplateParams, D2Templated); 4459 D2Templated->setDescribedVarTemplate(D2); 4460 4461 D2->setAccess(D->getAccess()); 4462 D2->setLexicalDeclContext(LexicalDC); 4463 LexicalDC->addDeclInternal(D2); 4464 4465 // Note the relationship between the variable templates. 4466 Importer.Imported(D, D2); 4467 Importer.Imported(DTemplated, D2Templated); 4468 4469 if (DTemplated->isThisDeclarationADefinition() && 4470 !D2Templated->isThisDeclarationADefinition()) { 4471 // FIXME: Import definition! 4472 } 4473 4474 return D2; 4475 } 4476 4477 Decl *ASTNodeImporter::VisitVarTemplateSpecializationDecl( 4478 VarTemplateSpecializationDecl *D) { 4479 // If this record has a definition in the translation unit we're coming from, 4480 // but this particular declaration is not that definition, import the 4481 // definition and map to that. 4482 VarDecl *Definition = D->getDefinition(); 4483 if (Definition && Definition != D) { 4484 Decl *ImportedDef = Importer.Import(Definition); 4485 if (!ImportedDef) 4486 return nullptr; 4487 4488 return Importer.Imported(D, ImportedDef); 4489 } 4490 4491 VarTemplateDecl *VarTemplate = cast_or_null<VarTemplateDecl>( 4492 Importer.Import(D->getSpecializedTemplate())); 4493 if (!VarTemplate) 4494 return nullptr; 4495 4496 // Import the context of this declaration. 4497 DeclContext *DC = VarTemplate->getDeclContext(); 4498 if (!DC) 4499 return nullptr; 4500 4501 DeclContext *LexicalDC = DC; 4502 if (D->getDeclContext() != D->getLexicalDeclContext()) { 4503 LexicalDC = Importer.ImportContext(D->getLexicalDeclContext()); 4504 if (!LexicalDC) 4505 return nullptr; 4506 } 4507 4508 // Import the location of this declaration. 4509 SourceLocation StartLoc = Importer.Import(D->getLocStart()); 4510 SourceLocation IdLoc = Importer.Import(D->getLocation()); 4511 4512 // Import template arguments. 4513 SmallVector<TemplateArgument, 2> TemplateArgs; 4514 if (ImportTemplateArguments(D->getTemplateArgs().data(), 4515 D->getTemplateArgs().size(), TemplateArgs)) 4516 return nullptr; 4517 4518 // Try to find an existing specialization with these template arguments. 4519 void *InsertPos = nullptr; 4520 VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization( 4521 TemplateArgs, InsertPos); 4522 if (D2) { 4523 // We already have a variable template specialization with these template 4524 // arguments. 4525 4526 // FIXME: Check for specialization vs. instantiation errors. 4527 4528 if (VarDecl *FoundDef = D2->getDefinition()) { 4529 if (!D->isThisDeclarationADefinition() || 4530 IsStructuralMatch(D, FoundDef)) { 4531 // The record types structurally match, or the "from" translation 4532 // unit only had a forward declaration anyway; call it the same 4533 // variable. 4534 return Importer.Imported(D, FoundDef); 4535 } 4536 } 4537 } else { 4538 4539 // Import the type. 4540 QualType T = Importer.Import(D->getType()); 4541 if (T.isNull()) 4542 return nullptr; 4543 TypeSourceInfo *TInfo = Importer.Import(D->getTypeSourceInfo()); 4544 4545 // Create a new specialization. 4546 D2 = VarTemplateSpecializationDecl::Create( 4547 Importer.getToContext(), DC, StartLoc, IdLoc, VarTemplate, T, TInfo, 4548 D->getStorageClass(), TemplateArgs.data(), TemplateArgs.size()); 4549 D2->setSpecializationKind(D->getSpecializationKind()); 4550 D2->setTemplateArgsInfo(D->getTemplateArgsInfo()); 4551 4552 // Add this specialization to the class template. 4553 VarTemplate->AddSpecialization(D2, InsertPos); 4554 4555 // Import the qualifier, if any. 4556 D2->setQualifierInfo(Importer.Import(D->getQualifierLoc())); 4557 4558 // Add the specialization to this context. 4559 D2->setLexicalDeclContext(LexicalDC); 4560 LexicalDC->addDeclInternal(D2); 4561 } 4562 Importer.Imported(D, D2); 4563 4564 if (D->isThisDeclarationADefinition() && ImportDefinition(D, D2)) 4565 return nullptr; 4566 4567 return D2; 4568 } 4569 4570 //---------------------------------------------------------------------------- 4571 // Import Statements 4572 //---------------------------------------------------------------------------- 4573 4574 DeclGroupRef ASTNodeImporter::ImportDeclGroup(DeclGroupRef DG) { 4575 if (DG.isNull()) 4576 return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0); 4577 size_t NumDecls = DG.end() - DG.begin(); 4578 SmallVector<Decl *, 1> ToDecls(NumDecls); 4579 auto &_Importer = this->Importer; 4580 std::transform(DG.begin(), DG.end(), ToDecls.begin(), 4581 [&_Importer](Decl *D) -> Decl * { 4582 return _Importer.Import(D); 4583 }); 4584 return DeclGroupRef::Create(Importer.getToContext(), 4585 ToDecls.begin(), 4586 NumDecls); 4587 } 4588 4589 Stmt *ASTNodeImporter::VisitStmt(Stmt *S) { 4590 Importer.FromDiag(S->getLocStart(), diag::err_unsupported_ast_node) 4591 << S->getStmtClassName(); 4592 return nullptr; 4593 } 4594 4595 Stmt *ASTNodeImporter::VisitDeclStmt(DeclStmt *S) { 4596 DeclGroupRef ToDG = ImportDeclGroup(S->getDeclGroup()); 4597 for (Decl *ToD : ToDG) { 4598 if (!ToD) 4599 return nullptr; 4600 } 4601 SourceLocation ToStartLoc = Importer.Import(S->getStartLoc()); 4602 SourceLocation ToEndLoc = Importer.Import(S->getEndLoc()); 4603 return new (Importer.getToContext()) DeclStmt(ToDG, ToStartLoc, ToEndLoc); 4604 } 4605 4606 Stmt *ASTNodeImporter::VisitNullStmt(NullStmt *S) { 4607 SourceLocation ToSemiLoc = Importer.Import(S->getSemiLoc()); 4608 return new (Importer.getToContext()) NullStmt(ToSemiLoc, 4609 S->hasLeadingEmptyMacro()); 4610 } 4611 4612 Stmt *ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) { 4613 SmallVector<Stmt *, 4> ToStmts(S->size()); 4614 auto &_Importer = this->Importer; 4615 std::transform(S->body_begin(), S->body_end(), ToStmts.begin(), 4616 [&_Importer](Stmt *CS) -> Stmt * { 4617 return _Importer.Import(CS); 4618 }); 4619 for (Stmt *ToS : ToStmts) { 4620 if (!ToS) 4621 return nullptr; 4622 } 4623 SourceLocation ToLBraceLoc = Importer.Import(S->getLBracLoc()); 4624 SourceLocation ToRBraceLoc = Importer.Import(S->getRBracLoc()); 4625 return new (Importer.getToContext()) CompoundStmt(Importer.getToContext(), 4626 ToStmts, 4627 ToLBraceLoc, ToRBraceLoc); 4628 } 4629 4630 Stmt *ASTNodeImporter::VisitCaseStmt(CaseStmt *S) { 4631 Expr *ToLHS = Importer.Import(S->getLHS()); 4632 if (!ToLHS) 4633 return nullptr; 4634 Expr *ToRHS = Importer.Import(S->getRHS()); 4635 if (!ToRHS && S->getRHS()) 4636 return nullptr; 4637 SourceLocation ToCaseLoc = Importer.Import(S->getCaseLoc()); 4638 SourceLocation ToEllipsisLoc = Importer.Import(S->getEllipsisLoc()); 4639 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4640 return new (Importer.getToContext()) CaseStmt(ToLHS, ToRHS, 4641 ToCaseLoc, ToEllipsisLoc, 4642 ToColonLoc); 4643 } 4644 4645 Stmt *ASTNodeImporter::VisitDefaultStmt(DefaultStmt *S) { 4646 SourceLocation ToDefaultLoc = Importer.Import(S->getDefaultLoc()); 4647 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4648 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4649 if (!ToSubStmt && S->getSubStmt()) 4650 return nullptr; 4651 return new (Importer.getToContext()) DefaultStmt(ToDefaultLoc, ToColonLoc, 4652 ToSubStmt); 4653 } 4654 4655 Stmt *ASTNodeImporter::VisitLabelStmt(LabelStmt *S) { 4656 SourceLocation ToIdentLoc = Importer.Import(S->getIdentLoc()); 4657 LabelDecl *ToLabelDecl = 4658 cast_or_null<LabelDecl>(Importer.Import(S->getDecl())); 4659 if (!ToLabelDecl && S->getDecl()) 4660 return nullptr; 4661 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4662 if (!ToSubStmt && S->getSubStmt()) 4663 return nullptr; 4664 return new (Importer.getToContext()) LabelStmt(ToIdentLoc, ToLabelDecl, 4665 ToSubStmt); 4666 } 4667 4668 Stmt *ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) { 4669 SourceLocation ToAttrLoc = Importer.Import(S->getAttrLoc()); 4670 ArrayRef<const Attr*> FromAttrs(S->getAttrs()); 4671 SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size()); 4672 ASTContext &_ToContext = Importer.getToContext(); 4673 std::transform(FromAttrs.begin(), FromAttrs.end(), ToAttrs.begin(), 4674 [&_ToContext](const Attr *A) -> const Attr * { 4675 return A->clone(_ToContext); 4676 }); 4677 for (const Attr *ToA : ToAttrs) { 4678 if (!ToA) 4679 return nullptr; 4680 } 4681 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 4682 if (!ToSubStmt && S->getSubStmt()) 4683 return nullptr; 4684 return AttributedStmt::Create(Importer.getToContext(), ToAttrLoc, 4685 ToAttrs, ToSubStmt); 4686 } 4687 4688 Stmt *ASTNodeImporter::VisitIfStmt(IfStmt *S) { 4689 SourceLocation ToIfLoc = Importer.Import(S->getIfLoc()); 4690 VarDecl *ToConditionVariable = nullptr; 4691 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4692 ToConditionVariable = 4693 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4694 if (!ToConditionVariable) 4695 return nullptr; 4696 } 4697 Expr *ToCondition = Importer.Import(S->getCond()); 4698 if (!ToCondition && S->getCond()) 4699 return nullptr; 4700 Stmt *ToThenStmt = Importer.Import(S->getThen()); 4701 if (!ToThenStmt && S->getThen()) 4702 return nullptr; 4703 SourceLocation ToElseLoc = Importer.Import(S->getElseLoc()); 4704 Stmt *ToElseStmt = Importer.Import(S->getElse()); 4705 if (!ToElseStmt && S->getElse()) 4706 return nullptr; 4707 return new (Importer.getToContext()) IfStmt(Importer.getToContext(), 4708 ToIfLoc, ToConditionVariable, 4709 ToCondition, ToThenStmt, 4710 ToElseLoc, ToElseStmt); 4711 } 4712 4713 Stmt *ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) { 4714 VarDecl *ToConditionVariable = nullptr; 4715 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4716 ToConditionVariable = 4717 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4718 if (!ToConditionVariable) 4719 return nullptr; 4720 } 4721 Expr *ToCondition = Importer.Import(S->getCond()); 4722 if (!ToCondition && S->getCond()) 4723 return nullptr; 4724 SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt( 4725 Importer.getToContext(), ToConditionVariable, 4726 ToCondition); 4727 Stmt *ToBody = Importer.Import(S->getBody()); 4728 if (!ToBody && S->getBody()) 4729 return nullptr; 4730 ToStmt->setBody(ToBody); 4731 ToStmt->setSwitchLoc(Importer.Import(S->getSwitchLoc())); 4732 // Now we have to re-chain the cases. 4733 SwitchCase *LastChainedSwitchCase = nullptr; 4734 for (SwitchCase *SC = S->getSwitchCaseList(); SC != nullptr; 4735 SC = SC->getNextSwitchCase()) { 4736 SwitchCase *ToSC = dyn_cast_or_null<SwitchCase>(Importer.Import(SC)); 4737 if (!ToSC) 4738 return nullptr; 4739 if (LastChainedSwitchCase) 4740 LastChainedSwitchCase->setNextSwitchCase(ToSC); 4741 else 4742 ToStmt->setSwitchCaseList(ToSC); 4743 LastChainedSwitchCase = ToSC; 4744 } 4745 return ToStmt; 4746 } 4747 4748 Stmt *ASTNodeImporter::VisitWhileStmt(WhileStmt *S) { 4749 VarDecl *ToConditionVariable = nullptr; 4750 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4751 ToConditionVariable = 4752 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4753 if (!ToConditionVariable) 4754 return nullptr; 4755 } 4756 Expr *ToCondition = Importer.Import(S->getCond()); 4757 if (!ToCondition && S->getCond()) 4758 return nullptr; 4759 Stmt *ToBody = Importer.Import(S->getBody()); 4760 if (!ToBody && S->getBody()) 4761 return nullptr; 4762 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4763 return new (Importer.getToContext()) WhileStmt(Importer.getToContext(), 4764 ToConditionVariable, 4765 ToCondition, ToBody, 4766 ToWhileLoc); 4767 } 4768 4769 Stmt *ASTNodeImporter::VisitDoStmt(DoStmt *S) { 4770 Stmt *ToBody = Importer.Import(S->getBody()); 4771 if (!ToBody && S->getBody()) 4772 return nullptr; 4773 Expr *ToCondition = Importer.Import(S->getCond()); 4774 if (!ToCondition && S->getCond()) 4775 return nullptr; 4776 SourceLocation ToDoLoc = Importer.Import(S->getDoLoc()); 4777 SourceLocation ToWhileLoc = Importer.Import(S->getWhileLoc()); 4778 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4779 return new (Importer.getToContext()) DoStmt(ToBody, ToCondition, 4780 ToDoLoc, ToWhileLoc, 4781 ToRParenLoc); 4782 } 4783 4784 Stmt *ASTNodeImporter::VisitForStmt(ForStmt *S) { 4785 Stmt *ToInit = Importer.Import(S->getInit()); 4786 if (!ToInit && S->getInit()) 4787 return nullptr; 4788 Expr *ToCondition = Importer.Import(S->getCond()); 4789 if (!ToCondition && S->getCond()) 4790 return nullptr; 4791 VarDecl *ToConditionVariable = nullptr; 4792 if (VarDecl *FromConditionVariable = S->getConditionVariable()) { 4793 ToConditionVariable = 4794 dyn_cast_or_null<VarDecl>(Importer.Import(FromConditionVariable)); 4795 if (!ToConditionVariable) 4796 return nullptr; 4797 } 4798 Expr *ToInc = Importer.Import(S->getInc()); 4799 if (!ToInc && S->getInc()) 4800 return nullptr; 4801 Stmt *ToBody = Importer.Import(S->getBody()); 4802 if (!ToBody && S->getBody()) 4803 return nullptr; 4804 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4805 SourceLocation ToLParenLoc = Importer.Import(S->getLParenLoc()); 4806 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4807 return new (Importer.getToContext()) ForStmt(Importer.getToContext(), 4808 ToInit, ToCondition, 4809 ToConditionVariable, 4810 ToInc, ToBody, 4811 ToForLoc, ToLParenLoc, 4812 ToRParenLoc); 4813 } 4814 4815 Stmt *ASTNodeImporter::VisitGotoStmt(GotoStmt *S) { 4816 LabelDecl *ToLabel = nullptr; 4817 if (LabelDecl *FromLabel = S->getLabel()) { 4818 ToLabel = dyn_cast_or_null<LabelDecl>(Importer.Import(FromLabel)); 4819 if (!ToLabel) 4820 return nullptr; 4821 } 4822 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4823 SourceLocation ToLabelLoc = Importer.Import(S->getLabelLoc()); 4824 return new (Importer.getToContext()) GotoStmt(ToLabel, 4825 ToGotoLoc, ToLabelLoc); 4826 } 4827 4828 Stmt *ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) { 4829 SourceLocation ToGotoLoc = Importer.Import(S->getGotoLoc()); 4830 SourceLocation ToStarLoc = Importer.Import(S->getStarLoc()); 4831 Expr *ToTarget = Importer.Import(S->getTarget()); 4832 if (!ToTarget && S->getTarget()) 4833 return nullptr; 4834 return new (Importer.getToContext()) IndirectGotoStmt(ToGotoLoc, ToStarLoc, 4835 ToTarget); 4836 } 4837 4838 Stmt *ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) { 4839 SourceLocation ToContinueLoc = Importer.Import(S->getContinueLoc()); 4840 return new (Importer.getToContext()) ContinueStmt(ToContinueLoc); 4841 } 4842 4843 Stmt *ASTNodeImporter::VisitBreakStmt(BreakStmt *S) { 4844 SourceLocation ToBreakLoc = Importer.Import(S->getBreakLoc()); 4845 return new (Importer.getToContext()) BreakStmt(ToBreakLoc); 4846 } 4847 4848 Stmt *ASTNodeImporter::VisitReturnStmt(ReturnStmt *S) { 4849 SourceLocation ToRetLoc = Importer.Import(S->getReturnLoc()); 4850 Expr *ToRetExpr = Importer.Import(S->getRetValue()); 4851 if (!ToRetExpr && S->getRetValue()) 4852 return nullptr; 4853 VarDecl *NRVOCandidate = const_cast<VarDecl*>(S->getNRVOCandidate()); 4854 VarDecl *ToNRVOCandidate = cast_or_null<VarDecl>(Importer.Import(NRVOCandidate)); 4855 if (!ToNRVOCandidate && NRVOCandidate) 4856 return nullptr; 4857 return new (Importer.getToContext()) ReturnStmt(ToRetLoc, ToRetExpr, 4858 ToNRVOCandidate); 4859 } 4860 4861 Stmt *ASTNodeImporter::VisitCXXCatchStmt(CXXCatchStmt *S) { 4862 SourceLocation ToCatchLoc = Importer.Import(S->getCatchLoc()); 4863 VarDecl *ToExceptionDecl = nullptr; 4864 if (VarDecl *FromExceptionDecl = S->getExceptionDecl()) { 4865 ToExceptionDecl = 4866 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4867 if (!ToExceptionDecl) 4868 return nullptr; 4869 } 4870 Stmt *ToHandlerBlock = Importer.Import(S->getHandlerBlock()); 4871 if (!ToHandlerBlock && S->getHandlerBlock()) 4872 return nullptr; 4873 return new (Importer.getToContext()) CXXCatchStmt(ToCatchLoc, 4874 ToExceptionDecl, 4875 ToHandlerBlock); 4876 } 4877 4878 Stmt *ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) { 4879 SourceLocation ToTryLoc = Importer.Import(S->getTryLoc()); 4880 Stmt *ToTryBlock = Importer.Import(S->getTryBlock()); 4881 if (!ToTryBlock && S->getTryBlock()) 4882 return nullptr; 4883 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers()); 4884 for (unsigned HI = 0, HE = S->getNumHandlers(); HI != HE; ++HI) { 4885 CXXCatchStmt *FromHandler = S->getHandler(HI); 4886 if (Stmt *ToHandler = Importer.Import(FromHandler)) 4887 ToHandlers[HI] = ToHandler; 4888 else 4889 return nullptr; 4890 } 4891 return CXXTryStmt::Create(Importer.getToContext(), ToTryLoc, ToTryBlock, 4892 ToHandlers); 4893 } 4894 4895 Stmt *ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) { 4896 DeclStmt *ToRange = 4897 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getRangeStmt())); 4898 if (!ToRange && S->getRangeStmt()) 4899 return nullptr; 4900 DeclStmt *ToBeginEnd = 4901 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getBeginEndStmt())); 4902 if (!ToBeginEnd && S->getBeginEndStmt()) 4903 return nullptr; 4904 Expr *ToCond = Importer.Import(S->getCond()); 4905 if (!ToCond && S->getCond()) 4906 return nullptr; 4907 Expr *ToInc = Importer.Import(S->getInc()); 4908 if (!ToInc && S->getInc()) 4909 return nullptr; 4910 DeclStmt *ToLoopVar = 4911 dyn_cast_or_null<DeclStmt>(Importer.Import(S->getLoopVarStmt())); 4912 if (!ToLoopVar && S->getLoopVarStmt()) 4913 return nullptr; 4914 Stmt *ToBody = Importer.Import(S->getBody()); 4915 if (!ToBody && S->getBody()) 4916 return nullptr; 4917 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4918 SourceLocation ToCoawaitLoc = Importer.Import(S->getCoawaitLoc()); 4919 SourceLocation ToColonLoc = Importer.Import(S->getColonLoc()); 4920 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4921 return new (Importer.getToContext()) CXXForRangeStmt(ToRange, ToBeginEnd, 4922 ToCond, ToInc, 4923 ToLoopVar, ToBody, 4924 ToForLoc, ToCoawaitLoc, 4925 ToColonLoc, ToRParenLoc); 4926 } 4927 4928 Stmt *ASTNodeImporter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) { 4929 Stmt *ToElem = Importer.Import(S->getElement()); 4930 if (!ToElem && S->getElement()) 4931 return nullptr; 4932 Expr *ToCollect = Importer.Import(S->getCollection()); 4933 if (!ToCollect && S->getCollection()) 4934 return nullptr; 4935 Stmt *ToBody = Importer.Import(S->getBody()); 4936 if (!ToBody && S->getBody()) 4937 return nullptr; 4938 SourceLocation ToForLoc = Importer.Import(S->getForLoc()); 4939 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4940 return new (Importer.getToContext()) ObjCForCollectionStmt(ToElem, 4941 ToCollect, 4942 ToBody, ToForLoc, 4943 ToRParenLoc); 4944 } 4945 4946 Stmt *ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) { 4947 SourceLocation ToAtCatchLoc = Importer.Import(S->getAtCatchLoc()); 4948 SourceLocation ToRParenLoc = Importer.Import(S->getRParenLoc()); 4949 VarDecl *ToExceptionDecl = nullptr; 4950 if (VarDecl *FromExceptionDecl = S->getCatchParamDecl()) { 4951 ToExceptionDecl = 4952 dyn_cast_or_null<VarDecl>(Importer.Import(FromExceptionDecl)); 4953 if (!ToExceptionDecl) 4954 return nullptr; 4955 } 4956 Stmt *ToBody = Importer.Import(S->getCatchBody()); 4957 if (!ToBody && S->getCatchBody()) 4958 return nullptr; 4959 return new (Importer.getToContext()) ObjCAtCatchStmt(ToAtCatchLoc, 4960 ToRParenLoc, 4961 ToExceptionDecl, 4962 ToBody); 4963 } 4964 4965 Stmt *ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) { 4966 SourceLocation ToAtFinallyLoc = Importer.Import(S->getAtFinallyLoc()); 4967 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyBody()); 4968 if (!ToAtFinallyStmt && S->getFinallyBody()) 4969 return nullptr; 4970 return new (Importer.getToContext()) ObjCAtFinallyStmt(ToAtFinallyLoc, 4971 ToAtFinallyStmt); 4972 } 4973 4974 Stmt *ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) { 4975 SourceLocation ToAtTryLoc = Importer.Import(S->getAtTryLoc()); 4976 Stmt *ToAtTryStmt = Importer.Import(S->getTryBody()); 4977 if (!ToAtTryStmt && S->getTryBody()) 4978 return nullptr; 4979 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts()); 4980 for (unsigned CI = 0, CE = S->getNumCatchStmts(); CI != CE; ++CI) { 4981 ObjCAtCatchStmt *FromCatchStmt = S->getCatchStmt(CI); 4982 if (Stmt *ToCatchStmt = Importer.Import(FromCatchStmt)) 4983 ToCatchStmts[CI] = ToCatchStmt; 4984 else 4985 return nullptr; 4986 } 4987 Stmt *ToAtFinallyStmt = Importer.Import(S->getFinallyStmt()); 4988 if (!ToAtFinallyStmt && S->getFinallyStmt()) 4989 return nullptr; 4990 return ObjCAtTryStmt::Create(Importer.getToContext(), 4991 ToAtTryLoc, ToAtTryStmt, 4992 ToCatchStmts.begin(), ToCatchStmts.size(), 4993 ToAtFinallyStmt); 4994 } 4995 4996 Stmt *ASTNodeImporter::VisitObjCAtSynchronizedStmt 4997 (ObjCAtSynchronizedStmt *S) { 4998 SourceLocation ToAtSynchronizedLoc = 4999 Importer.Import(S->getAtSynchronizedLoc()); 5000 Expr *ToSynchExpr = Importer.Import(S->getSynchExpr()); 5001 if (!ToSynchExpr && S->getSynchExpr()) 5002 return nullptr; 5003 Stmt *ToSynchBody = Importer.Import(S->getSynchBody()); 5004 if (!ToSynchBody && S->getSynchBody()) 5005 return nullptr; 5006 return new (Importer.getToContext()) ObjCAtSynchronizedStmt( 5007 ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody); 5008 } 5009 5010 Stmt *ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) { 5011 SourceLocation ToAtThrowLoc = Importer.Import(S->getThrowLoc()); 5012 Expr *ToThrow = Importer.Import(S->getThrowExpr()); 5013 if (!ToThrow && S->getThrowExpr()) 5014 return nullptr; 5015 return new (Importer.getToContext()) ObjCAtThrowStmt(ToAtThrowLoc, ToThrow); 5016 } 5017 5018 Stmt *ASTNodeImporter::VisitObjCAutoreleasePoolStmt 5019 (ObjCAutoreleasePoolStmt *S) { 5020 SourceLocation ToAtLoc = Importer.Import(S->getAtLoc()); 5021 Stmt *ToSubStmt = Importer.Import(S->getSubStmt()); 5022 if (!ToSubStmt && S->getSubStmt()) 5023 return nullptr; 5024 return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(ToAtLoc, 5025 ToSubStmt); 5026 } 5027 5028 //---------------------------------------------------------------------------- 5029 // Import Expressions 5030 //---------------------------------------------------------------------------- 5031 Expr *ASTNodeImporter::VisitExpr(Expr *E) { 5032 Importer.FromDiag(E->getLocStart(), diag::err_unsupported_ast_node) 5033 << E->getStmtClassName(); 5034 return nullptr; 5035 } 5036 5037 Expr *ASTNodeImporter::VisitDeclRefExpr(DeclRefExpr *E) { 5038 ValueDecl *ToD = cast_or_null<ValueDecl>(Importer.Import(E->getDecl())); 5039 if (!ToD) 5040 return nullptr; 5041 5042 NamedDecl *FoundD = nullptr; 5043 if (E->getDecl() != E->getFoundDecl()) { 5044 FoundD = cast_or_null<NamedDecl>(Importer.Import(E->getFoundDecl())); 5045 if (!FoundD) 5046 return nullptr; 5047 } 5048 5049 QualType T = Importer.Import(E->getType()); 5050 if (T.isNull()) 5051 return nullptr; 5052 5053 DeclRefExpr *DRE = DeclRefExpr::Create(Importer.getToContext(), 5054 Importer.Import(E->getQualifierLoc()), 5055 Importer.Import(E->getTemplateKeywordLoc()), 5056 ToD, 5057 E->refersToEnclosingVariableOrCapture(), 5058 Importer.Import(E->getLocation()), 5059 T, E->getValueKind(), 5060 FoundD, 5061 /*FIXME:TemplateArgs=*/nullptr); 5062 if (E->hadMultipleCandidates()) 5063 DRE->setHadMultipleCandidates(true); 5064 return DRE; 5065 } 5066 5067 Expr *ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) { 5068 QualType T = Importer.Import(E->getType()); 5069 if (T.isNull()) 5070 return nullptr; 5071 5072 return IntegerLiteral::Create(Importer.getToContext(), 5073 E->getValue(), T, 5074 Importer.Import(E->getLocation())); 5075 } 5076 5077 Expr *ASTNodeImporter::VisitCharacterLiteral(CharacterLiteral *E) { 5078 QualType T = Importer.Import(E->getType()); 5079 if (T.isNull()) 5080 return nullptr; 5081 5082 return new (Importer.getToContext()) CharacterLiteral(E->getValue(), 5083 E->getKind(), T, 5084 Importer.Import(E->getLocation())); 5085 } 5086 5087 Expr *ASTNodeImporter::VisitParenExpr(ParenExpr *E) { 5088 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5089 if (!SubExpr) 5090 return nullptr; 5091 5092 return new (Importer.getToContext()) 5093 ParenExpr(Importer.Import(E->getLParen()), 5094 Importer.Import(E->getRParen()), 5095 SubExpr); 5096 } 5097 5098 Expr *ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) { 5099 QualType T = Importer.Import(E->getType()); 5100 if (T.isNull()) 5101 return nullptr; 5102 5103 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5104 if (!SubExpr) 5105 return nullptr; 5106 5107 return new (Importer.getToContext()) UnaryOperator(SubExpr, E->getOpcode(), 5108 T, E->getValueKind(), 5109 E->getObjectKind(), 5110 Importer.Import(E->getOperatorLoc())); 5111 } 5112 5113 Expr *ASTNodeImporter::VisitUnaryExprOrTypeTraitExpr( 5114 UnaryExprOrTypeTraitExpr *E) { 5115 QualType ResultType = Importer.Import(E->getType()); 5116 5117 if (E->isArgumentType()) { 5118 TypeSourceInfo *TInfo = Importer.Import(E->getArgumentTypeInfo()); 5119 if (!TInfo) 5120 return nullptr; 5121 5122 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5123 TInfo, ResultType, 5124 Importer.Import(E->getOperatorLoc()), 5125 Importer.Import(E->getRParenLoc())); 5126 } 5127 5128 Expr *SubExpr = Importer.Import(E->getArgumentExpr()); 5129 if (!SubExpr) 5130 return nullptr; 5131 5132 return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(E->getKind(), 5133 SubExpr, ResultType, 5134 Importer.Import(E->getOperatorLoc()), 5135 Importer.Import(E->getRParenLoc())); 5136 } 5137 5138 Expr *ASTNodeImporter::VisitBinaryOperator(BinaryOperator *E) { 5139 QualType T = Importer.Import(E->getType()); 5140 if (T.isNull()) 5141 return nullptr; 5142 5143 Expr *LHS = Importer.Import(E->getLHS()); 5144 if (!LHS) 5145 return nullptr; 5146 5147 Expr *RHS = Importer.Import(E->getRHS()); 5148 if (!RHS) 5149 return nullptr; 5150 5151 return new (Importer.getToContext()) BinaryOperator(LHS, RHS, E->getOpcode(), 5152 T, E->getValueKind(), 5153 E->getObjectKind(), 5154 Importer.Import(E->getOperatorLoc()), 5155 E->isFPContractable()); 5156 } 5157 5158 Expr *ASTNodeImporter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { 5159 QualType T = Importer.Import(E->getType()); 5160 if (T.isNull()) 5161 return nullptr; 5162 5163 QualType CompLHSType = Importer.Import(E->getComputationLHSType()); 5164 if (CompLHSType.isNull()) 5165 return nullptr; 5166 5167 QualType CompResultType = Importer.Import(E->getComputationResultType()); 5168 if (CompResultType.isNull()) 5169 return nullptr; 5170 5171 Expr *LHS = Importer.Import(E->getLHS()); 5172 if (!LHS) 5173 return nullptr; 5174 5175 Expr *RHS = Importer.Import(E->getRHS()); 5176 if (!RHS) 5177 return nullptr; 5178 5179 return new (Importer.getToContext()) 5180 CompoundAssignOperator(LHS, RHS, E->getOpcode(), 5181 T, E->getValueKind(), 5182 E->getObjectKind(), 5183 CompLHSType, CompResultType, 5184 Importer.Import(E->getOperatorLoc()), 5185 E->isFPContractable()); 5186 } 5187 5188 static bool ImportCastPath(CastExpr *E, CXXCastPath &Path) { 5189 if (E->path_empty()) return false; 5190 5191 // TODO: import cast paths 5192 return true; 5193 } 5194 5195 Expr *ASTNodeImporter::VisitImplicitCastExpr(ImplicitCastExpr *E) { 5196 QualType T = Importer.Import(E->getType()); 5197 if (T.isNull()) 5198 return nullptr; 5199 5200 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5201 if (!SubExpr) 5202 return nullptr; 5203 5204 CXXCastPath BasePath; 5205 if (ImportCastPath(E, BasePath)) 5206 return nullptr; 5207 5208 return ImplicitCastExpr::Create(Importer.getToContext(), T, E->getCastKind(), 5209 SubExpr, &BasePath, E->getValueKind()); 5210 } 5211 5212 Expr *ASTNodeImporter::VisitCStyleCastExpr(CStyleCastExpr *E) { 5213 QualType T = Importer.Import(E->getType()); 5214 if (T.isNull()) 5215 return nullptr; 5216 5217 Expr *SubExpr = Importer.Import(E->getSubExpr()); 5218 if (!SubExpr) 5219 return nullptr; 5220 5221 TypeSourceInfo *TInfo = Importer.Import(E->getTypeInfoAsWritten()); 5222 if (!TInfo && E->getTypeInfoAsWritten()) 5223 return nullptr; 5224 5225 CXXCastPath BasePath; 5226 if (ImportCastPath(E, BasePath)) 5227 return nullptr; 5228 5229 return CStyleCastExpr::Create(Importer.getToContext(), T, 5230 E->getValueKind(), E->getCastKind(), 5231 SubExpr, &BasePath, TInfo, 5232 Importer.Import(E->getLParenLoc()), 5233 Importer.Import(E->getRParenLoc())); 5234 } 5235 5236 Expr *ASTNodeImporter::VisitCXXConstructExpr(CXXConstructExpr *E) { 5237 QualType T = Importer.Import(E->getType()); 5238 if (T.isNull()) 5239 return nullptr; 5240 5241 CXXConstructorDecl *ToCCD = 5242 dyn_cast<CXXConstructorDecl>(Importer.Import(E->getConstructor())); 5243 if (!ToCCD && E->getConstructor()) 5244 return nullptr; 5245 5246 size_t NumArgs = E->getNumArgs(); 5247 SmallVector<Expr *, 1> ToArgs(NumArgs); 5248 ASTImporter &_Importer = Importer; 5249 std::transform(E->arg_begin(), E->arg_end(), ToArgs.begin(), 5250 [&_Importer](Expr *AE) -> Expr * { 5251 return _Importer.Import(AE); 5252 }); 5253 for (Expr *ToA : ToArgs) { 5254 if (!ToA) 5255 return nullptr; 5256 } 5257 5258 return CXXConstructExpr::Create(Importer.getToContext(), T, 5259 Importer.Import(E->getLocation()), 5260 ToCCD, E->isElidable(), 5261 ToArgs, E->hadMultipleCandidates(), 5262 E->isListInitialization(), 5263 E->isStdInitListInitialization(), 5264 E->requiresZeroInitialization(), 5265 E->getConstructionKind(), 5266 Importer.Import(E->getParenOrBraceRange())); 5267 } 5268 5269 Expr *ASTNodeImporter::VisitMemberExpr(MemberExpr *E) { 5270 QualType T = Importer.Import(E->getType()); 5271 if (T.isNull()) 5272 return nullptr; 5273 5274 Expr *ToBase = Importer.Import(E->getBase()); 5275 if (!ToBase && E->getBase()) 5276 return nullptr; 5277 5278 ValueDecl *ToMember = dyn_cast<ValueDecl>(Importer.Import(E->getMemberDecl())); 5279 if (!ToMember && E->getMemberDecl()) 5280 return nullptr; 5281 5282 DeclAccessPair ToFoundDecl = DeclAccessPair::make( 5283 dyn_cast<NamedDecl>(Importer.Import(E->getFoundDecl().getDecl())), 5284 E->getFoundDecl().getAccess()); 5285 5286 DeclarationNameInfo ToMemberNameInfo( 5287 Importer.Import(E->getMemberNameInfo().getName()), 5288 Importer.Import(E->getMemberNameInfo().getLoc())); 5289 5290 if (E->hasExplicitTemplateArgs()) { 5291 return nullptr; // FIXME: handle template arguments 5292 } 5293 5294 return MemberExpr::Create(Importer.getToContext(), ToBase, 5295 E->isArrow(), 5296 Importer.Import(E->getOperatorLoc()), 5297 Importer.Import(E->getQualifierLoc()), 5298 Importer.Import(E->getTemplateKeywordLoc()), 5299 ToMember, ToFoundDecl, ToMemberNameInfo, 5300 nullptr, T, E->getValueKind(), 5301 E->getObjectKind()); 5302 } 5303 5304 Expr *ASTNodeImporter::VisitCallExpr(CallExpr *E) { 5305 QualType T = Importer.Import(E->getType()); 5306 if (T.isNull()) 5307 return nullptr; 5308 5309 Expr *ToCallee = Importer.Import(E->getCallee()); 5310 if (!ToCallee && E->getCallee()) 5311 return nullptr; 5312 5313 unsigned NumArgs = E->getNumArgs(); 5314 5315 llvm::SmallVector<Expr *, 2> ToArgs(NumArgs); 5316 5317 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) { 5318 Expr *FromArg = E->getArg(ai); 5319 Expr *ToArg = Importer.Import(FromArg); 5320 if (!ToArg) 5321 return nullptr; 5322 ToArgs[ai] = ToArg; 5323 } 5324 5325 Expr **ToArgs_Copied = new (Importer.getToContext()) 5326 Expr*[NumArgs]; 5327 5328 for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai) 5329 ToArgs_Copied[ai] = ToArgs[ai]; 5330 5331 return new (Importer.getToContext()) 5332 CallExpr(Importer.getToContext(), ToCallee, 5333 llvm::makeArrayRef(ToArgs_Copied, NumArgs), T, E->getValueKind(), 5334 Importer.Import(E->getRParenLoc())); 5335 } 5336 5337 ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager, 5338 ASTContext &FromContext, FileManager &FromFileManager, 5339 bool MinimalImport) 5340 : ToContext(ToContext), FromContext(FromContext), 5341 ToFileManager(ToFileManager), FromFileManager(FromFileManager), 5342 Minimal(MinimalImport), LastDiagFromFrom(false) 5343 { 5344 ImportedDecls[FromContext.getTranslationUnitDecl()] 5345 = ToContext.getTranslationUnitDecl(); 5346 } 5347 5348 ASTImporter::~ASTImporter() { } 5349 5350 QualType ASTImporter::Import(QualType FromT) { 5351 if (FromT.isNull()) 5352 return QualType(); 5353 5354 const Type *fromTy = FromT.getTypePtr(); 5355 5356 // Check whether we've already imported this type. 5357 llvm::DenseMap<const Type *, const Type *>::iterator Pos 5358 = ImportedTypes.find(fromTy); 5359 if (Pos != ImportedTypes.end()) 5360 return ToContext.getQualifiedType(Pos->second, FromT.getLocalQualifiers()); 5361 5362 // Import the type 5363 ASTNodeImporter Importer(*this); 5364 QualType ToT = Importer.Visit(fromTy); 5365 if (ToT.isNull()) 5366 return ToT; 5367 5368 // Record the imported type. 5369 ImportedTypes[fromTy] = ToT.getTypePtr(); 5370 5371 return ToContext.getQualifiedType(ToT, FromT.getLocalQualifiers()); 5372 } 5373 5374 TypeSourceInfo *ASTImporter::Import(TypeSourceInfo *FromTSI) { 5375 if (!FromTSI) 5376 return FromTSI; 5377 5378 // FIXME: For now we just create a "trivial" type source info based 5379 // on the type and a single location. Implement a real version of this. 5380 QualType T = Import(FromTSI->getType()); 5381 if (T.isNull()) 5382 return nullptr; 5383 5384 return ToContext.getTrivialTypeSourceInfo(T, 5385 Import(FromTSI->getTypeLoc().getLocStart())); 5386 } 5387 5388 Decl *ASTImporter::GetAlreadyImportedOrNull(Decl *FromD) { 5389 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 5390 if (Pos != ImportedDecls.end()) { 5391 Decl *ToD = Pos->second; 5392 ASTNodeImporter(*this).ImportDefinitionIfNeeded(FromD, ToD); 5393 return ToD; 5394 } else { 5395 return nullptr; 5396 } 5397 } 5398 5399 Decl *ASTImporter::Import(Decl *FromD) { 5400 if (!FromD) 5401 return nullptr; 5402 5403 ASTNodeImporter Importer(*this); 5404 5405 // Check whether we've already imported this declaration. 5406 llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(FromD); 5407 if (Pos != ImportedDecls.end()) { 5408 Decl *ToD = Pos->second; 5409 Importer.ImportDefinitionIfNeeded(FromD, ToD); 5410 return ToD; 5411 } 5412 5413 // Import the type 5414 Decl *ToD = Importer.Visit(FromD); 5415 if (!ToD) 5416 return nullptr; 5417 5418 // Record the imported declaration. 5419 ImportedDecls[FromD] = ToD; 5420 5421 if (TagDecl *FromTag = dyn_cast<TagDecl>(FromD)) { 5422 // Keep track of anonymous tags that have an associated typedef. 5423 if (FromTag->getTypedefNameForAnonDecl()) 5424 AnonTagsWithPendingTypedefs.push_back(FromTag); 5425 } else if (TypedefNameDecl *FromTypedef = dyn_cast<TypedefNameDecl>(FromD)) { 5426 // When we've finished transforming a typedef, see whether it was the 5427 // typedef for an anonymous tag. 5428 for (SmallVectorImpl<TagDecl *>::iterator 5429 FromTag = AnonTagsWithPendingTypedefs.begin(), 5430 FromTagEnd = AnonTagsWithPendingTypedefs.end(); 5431 FromTag != FromTagEnd; ++FromTag) { 5432 if ((*FromTag)->getTypedefNameForAnonDecl() == FromTypedef) { 5433 if (TagDecl *ToTag = cast_or_null<TagDecl>(Import(*FromTag))) { 5434 // We found the typedef for an anonymous tag; link them. 5435 ToTag->setTypedefNameForAnonDecl(cast<TypedefNameDecl>(ToD)); 5436 AnonTagsWithPendingTypedefs.erase(FromTag); 5437 break; 5438 } 5439 } 5440 } 5441 } 5442 5443 return ToD; 5444 } 5445 5446 DeclContext *ASTImporter::ImportContext(DeclContext *FromDC) { 5447 if (!FromDC) 5448 return FromDC; 5449 5450 DeclContext *ToDC = cast_or_null<DeclContext>(Import(cast<Decl>(FromDC))); 5451 if (!ToDC) 5452 return nullptr; 5453 5454 // When we're using a record/enum/Objective-C class/protocol as a context, we 5455 // need it to have a definition. 5456 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(ToDC)) { 5457 RecordDecl *FromRecord = cast<RecordDecl>(FromDC); 5458 if (ToRecord->isCompleteDefinition()) { 5459 // Do nothing. 5460 } else if (FromRecord->isCompleteDefinition()) { 5461 ASTNodeImporter(*this).ImportDefinition(FromRecord, ToRecord, 5462 ASTNodeImporter::IDK_Basic); 5463 } else { 5464 CompleteDecl(ToRecord); 5465 } 5466 } else if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(ToDC)) { 5467 EnumDecl *FromEnum = cast<EnumDecl>(FromDC); 5468 if (ToEnum->isCompleteDefinition()) { 5469 // Do nothing. 5470 } else if (FromEnum->isCompleteDefinition()) { 5471 ASTNodeImporter(*this).ImportDefinition(FromEnum, ToEnum, 5472 ASTNodeImporter::IDK_Basic); 5473 } else { 5474 CompleteDecl(ToEnum); 5475 } 5476 } else if (ObjCInterfaceDecl *ToClass = dyn_cast<ObjCInterfaceDecl>(ToDC)) { 5477 ObjCInterfaceDecl *FromClass = cast<ObjCInterfaceDecl>(FromDC); 5478 if (ToClass->getDefinition()) { 5479 // Do nothing. 5480 } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) { 5481 ASTNodeImporter(*this).ImportDefinition(FromDef, ToClass, 5482 ASTNodeImporter::IDK_Basic); 5483 } else { 5484 CompleteDecl(ToClass); 5485 } 5486 } else if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(ToDC)) { 5487 ObjCProtocolDecl *FromProto = cast<ObjCProtocolDecl>(FromDC); 5488 if (ToProto->getDefinition()) { 5489 // Do nothing. 5490 } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) { 5491 ASTNodeImporter(*this).ImportDefinition(FromDef, ToProto, 5492 ASTNodeImporter::IDK_Basic); 5493 } else { 5494 CompleteDecl(ToProto); 5495 } 5496 } 5497 5498 return ToDC; 5499 } 5500 5501 Expr *ASTImporter::Import(Expr *FromE) { 5502 if (!FromE) 5503 return nullptr; 5504 5505 return cast_or_null<Expr>(Import(cast<Stmt>(FromE))); 5506 } 5507 5508 Stmt *ASTImporter::Import(Stmt *FromS) { 5509 if (!FromS) 5510 return nullptr; 5511 5512 // Check whether we've already imported this declaration. 5513 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS); 5514 if (Pos != ImportedStmts.end()) 5515 return Pos->second; 5516 5517 // Import the type 5518 ASTNodeImporter Importer(*this); 5519 Stmt *ToS = Importer.Visit(FromS); 5520 if (!ToS) 5521 return nullptr; 5522 5523 // Record the imported declaration. 5524 ImportedStmts[FromS] = ToS; 5525 return ToS; 5526 } 5527 5528 NestedNameSpecifier *ASTImporter::Import(NestedNameSpecifier *FromNNS) { 5529 if (!FromNNS) 5530 return nullptr; 5531 5532 NestedNameSpecifier *prefix = Import(FromNNS->getPrefix()); 5533 5534 switch (FromNNS->getKind()) { 5535 case NestedNameSpecifier::Identifier: 5536 if (IdentifierInfo *II = Import(FromNNS->getAsIdentifier())) { 5537 return NestedNameSpecifier::Create(ToContext, prefix, II); 5538 } 5539 return nullptr; 5540 5541 case NestedNameSpecifier::Namespace: 5542 if (NamespaceDecl *NS = 5543 cast<NamespaceDecl>(Import(FromNNS->getAsNamespace()))) { 5544 return NestedNameSpecifier::Create(ToContext, prefix, NS); 5545 } 5546 return nullptr; 5547 5548 case NestedNameSpecifier::NamespaceAlias: 5549 if (NamespaceAliasDecl *NSAD = 5550 cast<NamespaceAliasDecl>(Import(FromNNS->getAsNamespaceAlias()))) { 5551 return NestedNameSpecifier::Create(ToContext, prefix, NSAD); 5552 } 5553 return nullptr; 5554 5555 case NestedNameSpecifier::Global: 5556 return NestedNameSpecifier::GlobalSpecifier(ToContext); 5557 5558 case NestedNameSpecifier::Super: 5559 if (CXXRecordDecl *RD = 5560 cast<CXXRecordDecl>(Import(FromNNS->getAsRecordDecl()))) { 5561 return NestedNameSpecifier::SuperSpecifier(ToContext, RD); 5562 } 5563 return nullptr; 5564 5565 case NestedNameSpecifier::TypeSpec: 5566 case NestedNameSpecifier::TypeSpecWithTemplate: { 5567 QualType T = Import(QualType(FromNNS->getAsType(), 0u)); 5568 if (!T.isNull()) { 5569 bool bTemplate = FromNNS->getKind() == 5570 NestedNameSpecifier::TypeSpecWithTemplate; 5571 return NestedNameSpecifier::Create(ToContext, prefix, 5572 bTemplate, T.getTypePtr()); 5573 } 5574 } 5575 return nullptr; 5576 } 5577 5578 llvm_unreachable("Invalid nested name specifier kind"); 5579 } 5580 5581 NestedNameSpecifierLoc ASTImporter::Import(NestedNameSpecifierLoc FromNNS) { 5582 // FIXME: Implement! 5583 return NestedNameSpecifierLoc(); 5584 } 5585 5586 TemplateName ASTImporter::Import(TemplateName From) { 5587 switch (From.getKind()) { 5588 case TemplateName::Template: 5589 if (TemplateDecl *ToTemplate 5590 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 5591 return TemplateName(ToTemplate); 5592 5593 return TemplateName(); 5594 5595 case TemplateName::OverloadedTemplate: { 5596 OverloadedTemplateStorage *FromStorage = From.getAsOverloadedTemplate(); 5597 UnresolvedSet<2> ToTemplates; 5598 for (OverloadedTemplateStorage::iterator I = FromStorage->begin(), 5599 E = FromStorage->end(); 5600 I != E; ++I) { 5601 if (NamedDecl *To = cast_or_null<NamedDecl>(Import(*I))) 5602 ToTemplates.addDecl(To); 5603 else 5604 return TemplateName(); 5605 } 5606 return ToContext.getOverloadedTemplateName(ToTemplates.begin(), 5607 ToTemplates.end()); 5608 } 5609 5610 case TemplateName::QualifiedTemplate: { 5611 QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName(); 5612 NestedNameSpecifier *Qualifier = Import(QTN->getQualifier()); 5613 if (!Qualifier) 5614 return TemplateName(); 5615 5616 if (TemplateDecl *ToTemplate 5617 = cast_or_null<TemplateDecl>(Import(From.getAsTemplateDecl()))) 5618 return ToContext.getQualifiedTemplateName(Qualifier, 5619 QTN->hasTemplateKeyword(), 5620 ToTemplate); 5621 5622 return TemplateName(); 5623 } 5624 5625 case TemplateName::DependentTemplate: { 5626 DependentTemplateName *DTN = From.getAsDependentTemplateName(); 5627 NestedNameSpecifier *Qualifier = Import(DTN->getQualifier()); 5628 if (!Qualifier) 5629 return TemplateName(); 5630 5631 if (DTN->isIdentifier()) { 5632 return ToContext.getDependentTemplateName(Qualifier, 5633 Import(DTN->getIdentifier())); 5634 } 5635 5636 return ToContext.getDependentTemplateName(Qualifier, DTN->getOperator()); 5637 } 5638 5639 case TemplateName::SubstTemplateTemplateParm: { 5640 SubstTemplateTemplateParmStorage *subst 5641 = From.getAsSubstTemplateTemplateParm(); 5642 TemplateTemplateParmDecl *param 5643 = cast_or_null<TemplateTemplateParmDecl>(Import(subst->getParameter())); 5644 if (!param) 5645 return TemplateName(); 5646 5647 TemplateName replacement = Import(subst->getReplacement()); 5648 if (replacement.isNull()) return TemplateName(); 5649 5650 return ToContext.getSubstTemplateTemplateParm(param, replacement); 5651 } 5652 5653 case TemplateName::SubstTemplateTemplateParmPack: { 5654 SubstTemplateTemplateParmPackStorage *SubstPack 5655 = From.getAsSubstTemplateTemplateParmPack(); 5656 TemplateTemplateParmDecl *Param 5657 = cast_or_null<TemplateTemplateParmDecl>( 5658 Import(SubstPack->getParameterPack())); 5659 if (!Param) 5660 return TemplateName(); 5661 5662 ASTNodeImporter Importer(*this); 5663 TemplateArgument ArgPack 5664 = Importer.ImportTemplateArgument(SubstPack->getArgumentPack()); 5665 if (ArgPack.isNull()) 5666 return TemplateName(); 5667 5668 return ToContext.getSubstTemplateTemplateParmPack(Param, ArgPack); 5669 } 5670 } 5671 5672 llvm_unreachable("Invalid template name kind"); 5673 } 5674 5675 SourceLocation ASTImporter::Import(SourceLocation FromLoc) { 5676 if (FromLoc.isInvalid()) 5677 return SourceLocation(); 5678 5679 SourceManager &FromSM = FromContext.getSourceManager(); 5680 5681 // For now, map everything down to its spelling location, so that we 5682 // don't have to import macro expansions. 5683 // FIXME: Import macro expansions! 5684 FromLoc = FromSM.getSpellingLoc(FromLoc); 5685 std::pair<FileID, unsigned> Decomposed = FromSM.getDecomposedLoc(FromLoc); 5686 SourceManager &ToSM = ToContext.getSourceManager(); 5687 FileID ToFileID = Import(Decomposed.first); 5688 if (ToFileID.isInvalid()) 5689 return SourceLocation(); 5690 SourceLocation ret = ToSM.getLocForStartOfFile(ToFileID) 5691 .getLocWithOffset(Decomposed.second); 5692 return ret; 5693 } 5694 5695 SourceRange ASTImporter::Import(SourceRange FromRange) { 5696 return SourceRange(Import(FromRange.getBegin()), Import(FromRange.getEnd())); 5697 } 5698 5699 FileID ASTImporter::Import(FileID FromID) { 5700 llvm::DenseMap<FileID, FileID>::iterator Pos 5701 = ImportedFileIDs.find(FromID); 5702 if (Pos != ImportedFileIDs.end()) 5703 return Pos->second; 5704 5705 SourceManager &FromSM = FromContext.getSourceManager(); 5706 SourceManager &ToSM = ToContext.getSourceManager(); 5707 const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID); 5708 assert(FromSLoc.isFile() && "Cannot handle macro expansions yet"); 5709 5710 // Include location of this file. 5711 SourceLocation ToIncludeLoc = Import(FromSLoc.getFile().getIncludeLoc()); 5712 5713 // Map the FileID for to the "to" source manager. 5714 FileID ToID; 5715 const SrcMgr::ContentCache *Cache = FromSLoc.getFile().getContentCache(); 5716 if (Cache->OrigEntry && Cache->OrigEntry->getDir()) { 5717 // FIXME: We probably want to use getVirtualFile(), so we don't hit the 5718 // disk again 5719 // FIXME: We definitely want to re-use the existing MemoryBuffer, rather 5720 // than mmap the files several times. 5721 const FileEntry *Entry = ToFileManager.getFile(Cache->OrigEntry->getName()); 5722 if (!Entry) 5723 return FileID(); 5724 ToID = ToSM.createFileID(Entry, ToIncludeLoc, 5725 FromSLoc.getFile().getFileCharacteristic()); 5726 } else { 5727 // FIXME: We want to re-use the existing MemoryBuffer! 5728 const llvm::MemoryBuffer * 5729 FromBuf = Cache->getBuffer(FromContext.getDiagnostics(), FromSM); 5730 std::unique_ptr<llvm::MemoryBuffer> ToBuf 5731 = llvm::MemoryBuffer::getMemBufferCopy(FromBuf->getBuffer(), 5732 FromBuf->getBufferIdentifier()); 5733 ToID = ToSM.createFileID(std::move(ToBuf), 5734 FromSLoc.getFile().getFileCharacteristic()); 5735 } 5736 5737 5738 ImportedFileIDs[FromID] = ToID; 5739 return ToID; 5740 } 5741 5742 void ASTImporter::ImportDefinition(Decl *From) { 5743 Decl *To = Import(From); 5744 if (!To) 5745 return; 5746 5747 if (DeclContext *FromDC = cast<DeclContext>(From)) { 5748 ASTNodeImporter Importer(*this); 5749 5750 if (RecordDecl *ToRecord = dyn_cast<RecordDecl>(To)) { 5751 if (!ToRecord->getDefinition()) { 5752 Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord, 5753 ASTNodeImporter::IDK_Everything); 5754 return; 5755 } 5756 } 5757 5758 if (EnumDecl *ToEnum = dyn_cast<EnumDecl>(To)) { 5759 if (!ToEnum->getDefinition()) { 5760 Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum, 5761 ASTNodeImporter::IDK_Everything); 5762 return; 5763 } 5764 } 5765 5766 if (ObjCInterfaceDecl *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) { 5767 if (!ToIFace->getDefinition()) { 5768 Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace, 5769 ASTNodeImporter::IDK_Everything); 5770 return; 5771 } 5772 } 5773 5774 if (ObjCProtocolDecl *ToProto = dyn_cast<ObjCProtocolDecl>(To)) { 5775 if (!ToProto->getDefinition()) { 5776 Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto, 5777 ASTNodeImporter::IDK_Everything); 5778 return; 5779 } 5780 } 5781 5782 Importer.ImportDeclContext(FromDC, true); 5783 } 5784 } 5785 5786 DeclarationName ASTImporter::Import(DeclarationName FromName) { 5787 if (!FromName) 5788 return DeclarationName(); 5789 5790 switch (FromName.getNameKind()) { 5791 case DeclarationName::Identifier: 5792 return Import(FromName.getAsIdentifierInfo()); 5793 5794 case DeclarationName::ObjCZeroArgSelector: 5795 case DeclarationName::ObjCOneArgSelector: 5796 case DeclarationName::ObjCMultiArgSelector: 5797 return Import(FromName.getObjCSelector()); 5798 5799 case DeclarationName::CXXConstructorName: { 5800 QualType T = Import(FromName.getCXXNameType()); 5801 if (T.isNull()) 5802 return DeclarationName(); 5803 5804 return ToContext.DeclarationNames.getCXXConstructorName( 5805 ToContext.getCanonicalType(T)); 5806 } 5807 5808 case DeclarationName::CXXDestructorName: { 5809 QualType T = Import(FromName.getCXXNameType()); 5810 if (T.isNull()) 5811 return DeclarationName(); 5812 5813 return ToContext.DeclarationNames.getCXXDestructorName( 5814 ToContext.getCanonicalType(T)); 5815 } 5816 5817 case DeclarationName::CXXConversionFunctionName: { 5818 QualType T = Import(FromName.getCXXNameType()); 5819 if (T.isNull()) 5820 return DeclarationName(); 5821 5822 return ToContext.DeclarationNames.getCXXConversionFunctionName( 5823 ToContext.getCanonicalType(T)); 5824 } 5825 5826 case DeclarationName::CXXOperatorName: 5827 return ToContext.DeclarationNames.getCXXOperatorName( 5828 FromName.getCXXOverloadedOperator()); 5829 5830 case DeclarationName::CXXLiteralOperatorName: 5831 return ToContext.DeclarationNames.getCXXLiteralOperatorName( 5832 Import(FromName.getCXXLiteralIdentifier())); 5833 5834 case DeclarationName::CXXUsingDirective: 5835 // FIXME: STATICS! 5836 return DeclarationName::getUsingDirectiveName(); 5837 } 5838 5839 llvm_unreachable("Invalid DeclarationName Kind!"); 5840 } 5841 5842 IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) { 5843 if (!FromId) 5844 return nullptr; 5845 5846 return &ToContext.Idents.get(FromId->getName()); 5847 } 5848 5849 Selector ASTImporter::Import(Selector FromSel) { 5850 if (FromSel.isNull()) 5851 return Selector(); 5852 5853 SmallVector<IdentifierInfo *, 4> Idents; 5854 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(0))); 5855 for (unsigned I = 1, N = FromSel.getNumArgs(); I < N; ++I) 5856 Idents.push_back(Import(FromSel.getIdentifierInfoForSlot(I))); 5857 return ToContext.Selectors.getSelector(FromSel.getNumArgs(), Idents.data()); 5858 } 5859 5860 DeclarationName ASTImporter::HandleNameConflict(DeclarationName Name, 5861 DeclContext *DC, 5862 unsigned IDNS, 5863 NamedDecl **Decls, 5864 unsigned NumDecls) { 5865 return Name; 5866 } 5867 5868 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) { 5869 if (LastDiagFromFrom) 5870 ToContext.getDiagnostics().notePriorDiagnosticFrom( 5871 FromContext.getDiagnostics()); 5872 LastDiagFromFrom = false; 5873 return ToContext.getDiagnostics().Report(Loc, DiagID); 5874 } 5875 5876 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) { 5877 if (!LastDiagFromFrom) 5878 FromContext.getDiagnostics().notePriorDiagnosticFrom( 5879 ToContext.getDiagnostics()); 5880 LastDiagFromFrom = true; 5881 return FromContext.getDiagnostics().Report(Loc, DiagID); 5882 } 5883 5884 void ASTImporter::CompleteDecl (Decl *D) { 5885 if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) { 5886 if (!ID->getDefinition()) 5887 ID->startDefinition(); 5888 } 5889 else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { 5890 if (!PD->getDefinition()) 5891 PD->startDefinition(); 5892 } 5893 else if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 5894 if (!TD->getDefinition() && !TD->isBeingDefined()) { 5895 TD->startDefinition(); 5896 TD->setCompleteDefinition(true); 5897 } 5898 } 5899 else { 5900 assert (0 && "CompleteDecl called on a Decl that can't be completed"); 5901 } 5902 } 5903 5904 Decl *ASTImporter::Imported(Decl *From, Decl *To) { 5905 ImportedDecls[From] = To; 5906 return To; 5907 } 5908 5909 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To, 5910 bool Complain) { 5911 llvm::DenseMap<const Type *, const Type *>::iterator Pos 5912 = ImportedTypes.find(From.getTypePtr()); 5913 if (Pos != ImportedTypes.end() && ToContext.hasSameType(Import(From), To)) 5914 return true; 5915 5916 StructuralEquivalenceContext Ctx(FromContext, ToContext, NonEquivalentDecls, 5917 false, Complain); 5918 return Ctx.IsStructurallyEquivalent(From, To); 5919 } 5920
