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