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