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