1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// 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 implements the actions class which performs semantic analysis and 11 // builds an AST out of a parse stream. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/Sema/SemaInternal.h" 16 #include "clang/Sema/DelayedDiagnostic.h" 17 #include "TargetAttributesSema.h" 18 #include "llvm/ADT/DenseMap.h" 19 #include "llvm/ADT/SmallSet.h" 20 #include "llvm/ADT/APFloat.h" 21 #include "llvm/Support/CrashRecoveryContext.h" 22 #include "clang/Sema/CXXFieldCollector.h" 23 #include "clang/Sema/TemplateDeduction.h" 24 #include "clang/Sema/ExternalSemaSource.h" 25 #include "clang/Sema/ObjCMethodList.h" 26 #include "clang/Sema/PrettyDeclStackTrace.h" 27 #include "clang/Sema/Scope.h" 28 #include "clang/Sema/ScopeInfo.h" 29 #include "clang/Sema/SemaConsumer.h" 30 #include "clang/AST/ASTContext.h" 31 #include "clang/AST/ASTDiagnostic.h" 32 #include "clang/AST/DeclCXX.h" 33 #include "clang/AST/DeclFriend.h" 34 #include "clang/AST/DeclObjC.h" 35 #include "clang/AST/Expr.h" 36 #include "clang/AST/ExprCXX.h" 37 #include "clang/AST/StmtCXX.h" 38 #include "clang/Lex/HeaderSearch.h" 39 #include "clang/Lex/Preprocessor.h" 40 #include "clang/Basic/FileManager.h" 41 #include "clang/Basic/PartialDiagnostic.h" 42 #include "clang/Basic/TargetInfo.h" 43 using namespace clang; 44 using namespace sema; 45 46 FunctionScopeInfo::~FunctionScopeInfo() { } 47 48 void FunctionScopeInfo::Clear() { 49 HasBranchProtectedScope = false; 50 HasBranchIntoScope = false; 51 HasIndirectGoto = false; 52 53 SwitchStack.clear(); 54 Returns.clear(); 55 ErrorTrap.reset(); 56 PossiblyUnreachableDiags.clear(); 57 } 58 59 BlockScopeInfo::~BlockScopeInfo() { } 60 LambdaScopeInfo::~LambdaScopeInfo() { } 61 62 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, 63 const Preprocessor &PP) { 64 PrintingPolicy Policy = Context.getPrintingPolicy(); 65 Policy.Bool = Context.getLangOpts().Bool; 66 if (!Policy.Bool) { 67 if (MacroInfo *BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) { 68 Policy.Bool = BoolMacro->isObjectLike() && 69 BoolMacro->getNumTokens() == 1 && 70 BoolMacro->getReplacementToken(0).is(tok::kw__Bool); 71 } 72 } 73 74 return Policy; 75 } 76 77 void Sema::ActOnTranslationUnitScope(Scope *S) { 78 TUScope = S; 79 PushDeclContext(S, Context.getTranslationUnitDecl()); 80 81 VAListTagName = PP.getIdentifierInfo("__va_list_tag"); 82 } 83 84 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 85 TranslationUnitKind TUKind, 86 CodeCompleteConsumer *CodeCompleter) 87 : TheTargetAttributesSema(0), FPFeatures(pp.getLangOpts()), 88 LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer), 89 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), 90 CollectStats(false), ExternalSource(0), CodeCompleter(CodeCompleter), 91 CurContext(0), OriginalLexicalContext(0), 92 PackContext(0), MSStructPragmaOn(false), VisContext(0), 93 ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0), 94 IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0), 95 NSNumberDecl(0), 96 NSStringDecl(0), StringWithUTF8StringMethod(0), 97 NSArrayDecl(0), ArrayWithObjectsMethod(0), 98 NSDictionaryDecl(0), DictionaryWithObjectsMethod(0), 99 GlobalNewDeleteDeclared(false), 100 TUKind(TUKind), 101 NumSFINAEErrors(0), InFunctionDeclarator(0), 102 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false), 103 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1), 104 CurrentInstantiationScope(0), TyposCorrected(0), 105 AnalysisWarnings(*this) 106 { 107 TUScope = 0; 108 109 LoadedExternalKnownNamespaces = false; 110 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) 111 NSNumberLiteralMethods[I] = 0; 112 113 if (getLangOpts().ObjC1) 114 NSAPIObj.reset(new NSAPI(Context)); 115 116 if (getLangOpts().CPlusPlus) 117 FieldCollector.reset(new CXXFieldCollector()); 118 119 // Tell diagnostics how to render things from the AST library. 120 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, 121 &Context); 122 123 ExprEvalContexts.push_back( 124 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, 125 false, 0, false)); 126 127 FunctionScopes.push_back(new FunctionScopeInfo(Diags)); 128 } 129 130 void Sema::Initialize() { 131 // Tell the AST consumer about this Sema object. 132 Consumer.Initialize(Context); 133 134 // FIXME: Isn't this redundant with the initialization above? 135 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 136 SC->InitializeSema(*this); 137 138 // Tell the external Sema source about this Sema object. 139 if (ExternalSemaSource *ExternalSema 140 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 141 ExternalSema->InitializeSema(*this); 142 143 // Initialize predefined 128-bit integer types, if needed. 144 if (PP.getTargetInfo().getPointerWidth(0) >= 64) { 145 // If either of the 128-bit integer types are unavailable to name lookup, 146 // define them now. 147 DeclarationName Int128 = &Context.Idents.get("__int128_t"); 148 if (IdResolver.begin(Int128) == IdResolver.end()) 149 PushOnScopeChains(Context.getInt128Decl(), TUScope); 150 151 DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); 152 if (IdResolver.begin(UInt128) == IdResolver.end()) 153 PushOnScopeChains(Context.getUInt128Decl(), TUScope); 154 } 155 156 157 // Initialize predefined Objective-C types: 158 if (PP.getLangOpts().ObjC1) { 159 // If 'SEL' does not yet refer to any declarations, make it refer to the 160 // predefined 'SEL'. 161 DeclarationName SEL = &Context.Idents.get("SEL"); 162 if (IdResolver.begin(SEL) == IdResolver.end()) 163 PushOnScopeChains(Context.getObjCSelDecl(), TUScope); 164 165 // If 'id' does not yet refer to any declarations, make it refer to the 166 // predefined 'id'. 167 DeclarationName Id = &Context.Idents.get("id"); 168 if (IdResolver.begin(Id) == IdResolver.end()) 169 PushOnScopeChains(Context.getObjCIdDecl(), TUScope); 170 171 // Create the built-in typedef for 'Class'. 172 DeclarationName Class = &Context.Idents.get("Class"); 173 if (IdResolver.begin(Class) == IdResolver.end()) 174 PushOnScopeChains(Context.getObjCClassDecl(), TUScope); 175 176 // Create the built-in forward declaratino for 'Protocol'. 177 DeclarationName Protocol = &Context.Idents.get("Protocol"); 178 if (IdResolver.begin(Protocol) == IdResolver.end()) 179 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); 180 } 181 182 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); 183 if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) 184 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); 185 } 186 187 Sema::~Sema() { 188 if (PackContext) FreePackedContext(); 189 if (VisContext) FreeVisContext(); 190 delete TheTargetAttributesSema; 191 MSStructPragmaOn = false; 192 // Kill all the active scopes. 193 for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I) 194 delete FunctionScopes[I]; 195 if (FunctionScopes.size() == 1) 196 delete FunctionScopes[0]; 197 198 // Tell the SemaConsumer to forget about us; we're going out of scope. 199 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 200 SC->ForgetSema(); 201 202 // Detach from the external Sema source. 203 if (ExternalSemaSource *ExternalSema 204 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 205 ExternalSema->ForgetSema(); 206 } 207 208 /// makeUnavailableInSystemHeader - There is an error in the current 209 /// context. If we're still in a system header, and we can plausibly 210 /// make the relevant declaration unavailable instead of erroring, do 211 /// so and return true. 212 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, 213 StringRef msg) { 214 // If we're not in a function, it's an error. 215 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext); 216 if (!fn) return false; 217 218 // If we're in template instantiation, it's an error. 219 if (!ActiveTemplateInstantiations.empty()) 220 return false; 221 222 // If that function's not in a system header, it's an error. 223 if (!Context.getSourceManager().isInSystemHeader(loc)) 224 return false; 225 226 // If the function is already unavailable, it's not an error. 227 if (fn->hasAttr<UnavailableAttr>()) return true; 228 229 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg)); 230 return true; 231 } 232 233 ASTMutationListener *Sema::getASTMutationListener() const { 234 return getASTConsumer().GetASTMutationListener(); 235 } 236 237 /// \brief Print out statistics about the semantic analysis. 238 void Sema::PrintStats() const { 239 llvm::errs() << "\n*** Semantic Analysis Stats:\n"; 240 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; 241 242 BumpAlloc.PrintStats(); 243 AnalysisWarnings.PrintStats(); 244 } 245 246 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. 247 /// If there is already an implicit cast, merge into the existing one. 248 /// The result is of the given category. 249 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, 250 CastKind Kind, ExprValueKind VK, 251 const CXXCastPath *BasePath, 252 CheckedConversionKind CCK) { 253 #ifndef NDEBUG 254 if (VK == VK_RValue && !E->isRValue()) { 255 switch (Kind) { 256 default: 257 assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind"); 258 case CK_LValueToRValue: 259 case CK_ArrayToPointerDecay: 260 case CK_FunctionToPointerDecay: 261 case CK_ToVoid: 262 break; 263 } 264 } 265 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue"); 266 #endif 267 268 QualType ExprTy = Context.getCanonicalType(E->getType()); 269 QualType TypeTy = Context.getCanonicalType(Ty); 270 271 if (ExprTy == TypeTy) 272 return Owned(E); 273 274 if (getLangOpts().ObjCAutoRefCount) 275 CheckObjCARCConversion(SourceRange(), Ty, E, CCK); 276 277 // If this is a derived-to-base cast to a through a virtual base, we 278 // need a vtable. 279 if (Kind == CK_DerivedToBase && 280 BasePathInvolvesVirtualBase(*BasePath)) { 281 QualType T = E->getType(); 282 if (const PointerType *Pointer = T->getAs<PointerType>()) 283 T = Pointer->getPointeeType(); 284 if (const RecordType *RecordTy = T->getAs<RecordType>()) 285 MarkVTableUsed(E->getLocStart(), 286 cast<CXXRecordDecl>(RecordTy->getDecl())); 287 } 288 289 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) { 290 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { 291 ImpCast->setType(Ty); 292 ImpCast->setValueKind(VK); 293 return Owned(E); 294 } 295 } 296 297 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK)); 298 } 299 300 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding 301 /// to the conversion from scalar type ScalarTy to the Boolean type. 302 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { 303 switch (ScalarTy->getScalarTypeKind()) { 304 case Type::STK_Bool: return CK_NoOp; 305 case Type::STK_CPointer: return CK_PointerToBoolean; 306 case Type::STK_BlockPointer: return CK_PointerToBoolean; 307 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; 308 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; 309 case Type::STK_Integral: return CK_IntegralToBoolean; 310 case Type::STK_Floating: return CK_FloatingToBoolean; 311 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; 312 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; 313 } 314 return CK_Invalid; 315 } 316 317 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector. 318 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { 319 if (D->isUsed()) 320 return true; 321 322 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 323 // UnusedFileScopedDecls stores the first declaration. 324 // The declaration may have become definition so check again. 325 const FunctionDecl *DeclToCheck; 326 if (FD->hasBody(DeclToCheck)) 327 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 328 329 // Later redecls may add new information resulting in not having to warn, 330 // so check again. 331 DeclToCheck = FD->getMostRecentDecl(); 332 if (DeclToCheck != FD) 333 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 334 } 335 336 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 337 // UnusedFileScopedDecls stores the first declaration. 338 // The declaration may have become definition so check again. 339 const VarDecl *DeclToCheck = VD->getDefinition(); 340 if (DeclToCheck) 341 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 342 343 // Later redecls may add new information resulting in not having to warn, 344 // so check again. 345 DeclToCheck = VD->getMostRecentDecl(); 346 if (DeclToCheck != VD) 347 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 348 } 349 350 return false; 351 } 352 353 namespace { 354 struct UndefinedInternal { 355 NamedDecl *decl; 356 FullSourceLoc useLoc; 357 358 UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc) 359 : decl(decl), useLoc(useLoc) {} 360 }; 361 362 bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) { 363 return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc); 364 } 365 } 366 367 /// checkUndefinedInternals - Check for undefined objects with internal linkage. 368 static void checkUndefinedInternals(Sema &S) { 369 if (S.UndefinedInternals.empty()) return; 370 371 // Collect all the still-undefined entities with internal linkage. 372 SmallVector<UndefinedInternal, 16> undefined; 373 for (llvm::DenseMap<NamedDecl*,SourceLocation>::iterator 374 i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end(); 375 i != e; ++i) { 376 NamedDecl *decl = i->first; 377 378 // Ignore attributes that have become invalid. 379 if (decl->isInvalidDecl()) continue; 380 381 // __attribute__((weakref)) is basically a definition. 382 if (decl->hasAttr<WeakRefAttr>()) continue; 383 384 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) { 385 if (fn->isPure() || fn->hasBody()) 386 continue; 387 } else { 388 if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly) 389 continue; 390 } 391 392 // We build a FullSourceLoc so that we can sort with array_pod_sort. 393 FullSourceLoc loc(i->second, S.Context.getSourceManager()); 394 undefined.push_back(UndefinedInternal(decl, loc)); 395 } 396 397 if (undefined.empty()) return; 398 399 // Sort (in order of use site) so that we're not (as) dependent on 400 // the iteration order through an llvm::DenseMap. 401 llvm::array_pod_sort(undefined.begin(), undefined.end()); 402 403 for (SmallVectorImpl<UndefinedInternal>::iterator 404 i = undefined.begin(), e = undefined.end(); i != e; ++i) { 405 NamedDecl *decl = i->decl; 406 S.Diag(decl->getLocation(), diag::warn_undefined_internal) 407 << isa<VarDecl>(decl) << decl; 408 S.Diag(i->useLoc, diag::note_used_here); 409 } 410 } 411 412 void Sema::LoadExternalWeakUndeclaredIdentifiers() { 413 if (!ExternalSource) 414 return; 415 416 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs; 417 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); 418 for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) { 419 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos 420 = WeakUndeclaredIdentifiers.find(WeakIDs[I].first); 421 if (Pos != WeakUndeclaredIdentifiers.end()) 422 continue; 423 424 WeakUndeclaredIdentifiers.insert(WeakIDs[I]); 425 } 426 } 427 428 429 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap; 430 431 /// \brief Returns true, if all methods and nested classes of the given 432 /// CXXRecordDecl are defined in this translation unit. 433 /// 434 /// Should only be called from ActOnEndOfTranslationUnit so that all 435 /// definitions are actually read. 436 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, 437 RecordCompleteMap &MNCComplete) { 438 RecordCompleteMap::iterator Cache = MNCComplete.find(RD); 439 if (Cache != MNCComplete.end()) 440 return Cache->second; 441 if (!RD->isCompleteDefinition()) 442 return false; 443 bool Complete = true; 444 for (DeclContext::decl_iterator I = RD->decls_begin(), 445 E = RD->decls_end(); 446 I != E && Complete; ++I) { 447 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I)) 448 Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M)); 449 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I)) 450 Complete = F->getTemplatedDecl()->isDefined(); 451 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) { 452 if (R->isInjectedClassName()) 453 continue; 454 if (R->hasDefinition()) 455 Complete = MethodsAndNestedClassesComplete(R->getDefinition(), 456 MNCComplete); 457 else 458 Complete = false; 459 } 460 } 461 MNCComplete[RD] = Complete; 462 return Complete; 463 } 464 465 /// \brief Returns true, if the given CXXRecordDecl is fully defined in this 466 /// translation unit, i.e. all methods are defined or pure virtual and all 467 /// friends, friend functions and nested classes are fully defined in this 468 /// translation unit. 469 /// 470 /// Should only be called from ActOnEndOfTranslationUnit so that all 471 /// definitions are actually read. 472 static bool IsRecordFullyDefined(const CXXRecordDecl *RD, 473 RecordCompleteMap &RecordsComplete, 474 RecordCompleteMap &MNCComplete) { 475 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); 476 if (Cache != RecordsComplete.end()) 477 return Cache->second; 478 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); 479 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), 480 E = RD->friend_end(); 481 I != E && Complete; ++I) { 482 // Check if friend classes and methods are complete. 483 if (TypeSourceInfo *TSI = (*I)->getFriendType()) { 484 // Friend classes are available as the TypeSourceInfo of the FriendDecl. 485 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) 486 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); 487 else 488 Complete = false; 489 } else { 490 // Friend functions are available through the NamedDecl of FriendDecl. 491 if (const FunctionDecl *FD = 492 dyn_cast<FunctionDecl>((*I)->getFriendDecl())) 493 Complete = FD->isDefined(); 494 else 495 // This is a template friend, give up. 496 Complete = false; 497 } 498 } 499 RecordsComplete[RD] = Complete; 500 return Complete; 501 } 502 503 /// ActOnEndOfTranslationUnit - This is called at the very end of the 504 /// translation unit when EOF is reached and all but the top-level scope is 505 /// popped. 506 void Sema::ActOnEndOfTranslationUnit() { 507 assert(DelayedDiagnostics.getCurrentPool() == NULL 508 && "reached end of translation unit with a pool attached?"); 509 510 // If code completion is enabled, don't perform any end-of-translation-unit 511 // work. 512 if (PP.isCodeCompletionEnabled()) 513 return; 514 515 // Only complete translation units define vtables and perform implicit 516 // instantiations. 517 if (TUKind == TU_Complete) { 518 DiagnoseUseOfUnimplementedSelectors(); 519 520 // If any dynamic classes have their key function defined within 521 // this translation unit, then those vtables are considered "used" and must 522 // be emitted. 523 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource), 524 E = DynamicClasses.end(); 525 I != E; ++I) { 526 assert(!(*I)->isDependentType() && 527 "Should not see dependent types here!"); 528 if (const CXXMethodDecl *KeyFunction = Context.getKeyFunction(*I)) { 529 const FunctionDecl *Definition = 0; 530 if (KeyFunction->hasBody(Definition)) 531 MarkVTableUsed(Definition->getLocation(), *I, true); 532 } 533 } 534 535 // If DefinedUsedVTables ends up marking any virtual member functions it 536 // might lead to more pending template instantiations, which we then need 537 // to instantiate. 538 DefineUsedVTables(); 539 540 // C++: Perform implicit template instantiations. 541 // 542 // FIXME: When we perform these implicit instantiations, we do not 543 // carefully keep track of the point of instantiation (C++ [temp.point]). 544 // This means that name lookup that occurs within the template 545 // instantiation will always happen at the end of the translation unit, 546 // so it will find some names that should not be found. Although this is 547 // common behavior for C++ compilers, it is technically wrong. In the 548 // future, we either need to be able to filter the results of name lookup 549 // or we need to perform template instantiations earlier. 550 PerformPendingInstantiations(); 551 } 552 553 // Remove file scoped decls that turned out to be used. 554 UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(0, 555 true), 556 UnusedFileScopedDecls.end(), 557 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), 558 this)), 559 UnusedFileScopedDecls.end()); 560 561 if (TUKind == TU_Prefix) { 562 // Translation unit prefixes don't need any of the checking below. 563 TUScope = 0; 564 return; 565 } 566 567 // Check for #pragma weak identifiers that were never declared 568 // FIXME: This will cause diagnostics to be emitted in a non-determinstic 569 // order! Iterating over a densemap like this is bad. 570 LoadExternalWeakUndeclaredIdentifiers(); 571 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 572 I = WeakUndeclaredIdentifiers.begin(), 573 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { 574 if (I->second.getUsed()) continue; 575 576 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) 577 << I->first; 578 } 579 580 if (TUKind == TU_Module) { 581 // If we are building a module, resolve all of the exported declarations 582 // now. 583 if (Module *CurrentModule = PP.getCurrentModule()) { 584 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 585 586 llvm::SmallVector<Module *, 2> Stack; 587 Stack.push_back(CurrentModule); 588 while (!Stack.empty()) { 589 Module *Mod = Stack.back(); 590 Stack.pop_back(); 591 592 // Resolve the exported declarations. 593 // FIXME: Actually complain, once we figure out how to teach the 594 // diagnostic client to deal with complains in the module map at this 595 // point. 596 ModMap.resolveExports(Mod, /*Complain=*/false); 597 598 // Queue the submodules, so their exports will also be resolved. 599 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 600 SubEnd = Mod->submodule_end(); 601 Sub != SubEnd; ++Sub) { 602 Stack.push_back(*Sub); 603 } 604 } 605 } 606 607 // Modules don't need any of the checking below. 608 TUScope = 0; 609 return; 610 } 611 612 // C99 6.9.2p2: 613 // A declaration of an identifier for an object that has file 614 // scope without an initializer, and without a storage-class 615 // specifier or with the storage-class specifier static, 616 // constitutes a tentative definition. If a translation unit 617 // contains one or more tentative definitions for an identifier, 618 // and the translation unit contains no external definition for 619 // that identifier, then the behavior is exactly as if the 620 // translation unit contains a file scope declaration of that 621 // identifier, with the composite type as of the end of the 622 // translation unit, with an initializer equal to 0. 623 llvm::SmallSet<VarDecl *, 32> Seen; 624 for (TentativeDefinitionsType::iterator 625 T = TentativeDefinitions.begin(ExternalSource), 626 TEnd = TentativeDefinitions.end(); 627 T != TEnd; ++T) 628 { 629 VarDecl *VD = (*T)->getActingDefinition(); 630 631 // If the tentative definition was completed, getActingDefinition() returns 632 // null. If we've already seen this variable before, insert()'s second 633 // return value is false. 634 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) 635 continue; 636 637 if (const IncompleteArrayType *ArrayT 638 = Context.getAsIncompleteArrayType(VD->getType())) { 639 if (RequireCompleteType(VD->getLocation(), 640 ArrayT->getElementType(), 641 diag::err_tentative_def_incomplete_type_arr)) { 642 VD->setInvalidDecl(); 643 continue; 644 } 645 646 // Set the length of the array to 1 (C99 6.9.2p5). 647 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 648 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 649 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), 650 One, ArrayType::Normal, 0); 651 VD->setType(T); 652 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 653 diag::err_tentative_def_incomplete_type)) 654 VD->setInvalidDecl(); 655 656 // Notify the consumer that we've completed a tentative definition. 657 if (!VD->isInvalidDecl()) 658 Consumer.CompleteTentativeDefinition(VD); 659 660 } 661 662 if (LangOpts.CPlusPlus0x && 663 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle, 664 SourceLocation()) 665 != DiagnosticsEngine::Ignored) 666 CheckDelegatingCtorCycles(); 667 668 // If there were errors, disable 'unused' warnings since they will mostly be 669 // noise. 670 if (!Diags.hasErrorOccurred()) { 671 // Output warning for unused file scoped decls. 672 for (UnusedFileScopedDeclsType::iterator 673 I = UnusedFileScopedDecls.begin(ExternalSource), 674 E = UnusedFileScopedDecls.end(); I != E; ++I) { 675 if (ShouldRemoveFromUnused(this, *I)) 676 continue; 677 678 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 679 const FunctionDecl *DiagD; 680 if (!FD->hasBody(DiagD)) 681 DiagD = FD; 682 if (DiagD->isDeleted()) 683 continue; // Deleted functions are supposed to be unused. 684 if (DiagD->isReferenced()) { 685 if (isa<CXXMethodDecl>(DiagD)) 686 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) 687 << DiagD->getDeclName(); 688 else { 689 if (FD->getStorageClassAsWritten() == SC_Static && 690 !FD->isInlineSpecified() && 691 !SourceMgr.isFromMainFile( 692 SourceMgr.getExpansionLoc(FD->getLocation()))) 693 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) 694 << DiagD->getDeclName(); 695 else 696 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 697 << /*function*/0 << DiagD->getDeclName(); 698 } 699 } else { 700 Diag(DiagD->getLocation(), 701 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function 702 : diag::warn_unused_function) 703 << DiagD->getDeclName(); 704 } 705 } else { 706 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition(); 707 if (!DiagD) 708 DiagD = cast<VarDecl>(*I); 709 if (DiagD->isReferenced()) { 710 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 711 << /*variable*/1 << DiagD->getDeclName(); 712 } else { 713 Diag(DiagD->getLocation(), diag::warn_unused_variable) 714 << DiagD->getDeclName(); 715 } 716 } 717 } 718 719 checkUndefinedInternals(*this); 720 } 721 722 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, 723 SourceLocation()) 724 != DiagnosticsEngine::Ignored) { 725 RecordCompleteMap RecordsComplete; 726 RecordCompleteMap MNCComplete; 727 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), 728 E = UnusedPrivateFields.end(); I != E; ++I) { 729 const NamedDecl *D = *I; 730 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); 731 if (RD && !RD->isUnion() && 732 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { 733 Diag(D->getLocation(), diag::warn_unused_private_field) 734 << D->getDeclName(); 735 } 736 } 737 } 738 739 // Check we've noticed that we're no longer parsing the initializer for every 740 // variable. If we miss cases, then at best we have a performance issue and 741 // at worst a rejects-valid bug. 742 assert(ParsingInitForAutoVars.empty() && 743 "Didn't unmark var as having its initializer parsed"); 744 745 TUScope = 0; 746 } 747 748 749 //===----------------------------------------------------------------------===// 750 // Helper functions. 751 //===----------------------------------------------------------------------===// 752 753 DeclContext *Sema::getFunctionLevelDeclContext() { 754 DeclContext *DC = CurContext; 755 756 while (true) { 757 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) { 758 DC = DC->getParent(); 759 } else if (isa<CXXMethodDecl>(DC) && 760 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && 761 cast<CXXRecordDecl>(DC->getParent())->isLambda()) { 762 DC = DC->getParent()->getParent(); 763 } 764 else break; 765 } 766 767 return DC; 768 } 769 770 /// getCurFunctionDecl - If inside of a function body, this returns a pointer 771 /// to the function decl for the function being parsed. If we're currently 772 /// in a 'block', this returns the containing context. 773 FunctionDecl *Sema::getCurFunctionDecl() { 774 DeclContext *DC = getFunctionLevelDeclContext(); 775 return dyn_cast<FunctionDecl>(DC); 776 } 777 778 ObjCMethodDecl *Sema::getCurMethodDecl() { 779 DeclContext *DC = getFunctionLevelDeclContext(); 780 return dyn_cast<ObjCMethodDecl>(DC); 781 } 782 783 NamedDecl *Sema::getCurFunctionOrMethodDecl() { 784 DeclContext *DC = getFunctionLevelDeclContext(); 785 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 786 return cast<NamedDecl>(DC); 787 return 0; 788 } 789 790 void Sema::EmitCurrentDiagnostic(unsigned DiagID) { 791 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here 792 // and yet we also use the current diag ID on the DiagnosticsEngine. This has 793 // been made more painfully obvious by the refactor that introduced this 794 // function, but it is possible that the incoming argument can be 795 // eliminnated. If it truly cannot be (for example, there is some reentrancy 796 // issue I am not seeing yet), then there should at least be a clarifying 797 // comment somewhere. 798 if (llvm::Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { 799 switch (DiagnosticIDs::getDiagnosticSFINAEResponse( 800 Diags.getCurrentDiagID())) { 801 case DiagnosticIDs::SFINAE_Report: 802 // We'll report the diagnostic below. 803 break; 804 805 case DiagnosticIDs::SFINAE_SubstitutionFailure: 806 // Count this failure so that we know that template argument deduction 807 // has failed. 808 ++NumSFINAEErrors; 809 810 // Make a copy of this suppressed diagnostic and store it with the 811 // template-deduction information. 812 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 813 Diagnostic DiagInfo(&Diags); 814 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 815 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 816 } 817 818 Diags.setLastDiagnosticIgnored(); 819 Diags.Clear(); 820 return; 821 822 case DiagnosticIDs::SFINAE_AccessControl: { 823 // Per C++ Core Issue 1170, access control is part of SFINAE. 824 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily 825 // make access control a part of SFINAE for the purposes of checking 826 // type traits. 827 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus0x) 828 break; 829 830 SourceLocation Loc = Diags.getCurrentDiagLoc(); 831 832 // Suppress this diagnostic. 833 ++NumSFINAEErrors; 834 835 // Make a copy of this suppressed diagnostic and store it with the 836 // template-deduction information. 837 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 838 Diagnostic DiagInfo(&Diags); 839 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 840 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 841 } 842 843 Diags.setLastDiagnosticIgnored(); 844 Diags.Clear(); 845 846 // Now the diagnostic state is clear, produce a C++98 compatibility 847 // warning. 848 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); 849 850 // The last diagnostic which Sema produced was ignored. Suppress any 851 // notes attached to it. 852 Diags.setLastDiagnosticIgnored(); 853 return; 854 } 855 856 case DiagnosticIDs::SFINAE_Suppress: 857 // Make a copy of this suppressed diagnostic and store it with the 858 // template-deduction information; 859 if (*Info) { 860 Diagnostic DiagInfo(&Diags); 861 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), 862 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 863 } 864 865 // Suppress this diagnostic. 866 Diags.setLastDiagnosticIgnored(); 867 Diags.Clear(); 868 return; 869 } 870 } 871 872 // Set up the context's printing policy based on our current state. 873 Context.setPrintingPolicy(getPrintingPolicy()); 874 875 // Emit the diagnostic. 876 if (!Diags.EmitCurrentDiagnostic()) 877 return; 878 879 // If this is not a note, and we're in a template instantiation 880 // that is different from the last template instantiation where 881 // we emitted an error, print a template instantiation 882 // backtrace. 883 if (!DiagnosticIDs::isBuiltinNote(DiagID) && 884 !ActiveTemplateInstantiations.empty() && 885 ActiveTemplateInstantiations.back() 886 != LastTemplateInstantiationErrorContext) { 887 PrintInstantiationStack(); 888 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); 889 } 890 } 891 892 Sema::SemaDiagnosticBuilder 893 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 894 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 895 PD.Emit(Builder); 896 897 return Builder; 898 } 899 900 /// \brief Looks through the macro-expansion chain for the given 901 /// location, looking for a macro expansion with the given name. 902 /// If one is found, returns true and sets the location to that 903 /// expansion loc. 904 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { 905 SourceLocation loc = locref; 906 if (!loc.isMacroID()) return false; 907 908 // There's no good way right now to look at the intermediate 909 // expansions, so just jump to the expansion location. 910 loc = getSourceManager().getExpansionLoc(loc); 911 912 // If that's written with the name, stop here. 913 SmallVector<char, 16> buffer; 914 if (getPreprocessor().getSpelling(loc, buffer) == name) { 915 locref = loc; 916 return true; 917 } 918 return false; 919 } 920 921 /// \brief Determines the active Scope associated with the given declaration 922 /// context. 923 /// 924 /// This routine maps a declaration context to the active Scope object that 925 /// represents that declaration context in the parser. It is typically used 926 /// from "scope-less" code (e.g., template instantiation, lazy creation of 927 /// declarations) that injects a name for name-lookup purposes and, therefore, 928 /// must update the Scope. 929 /// 930 /// \returns The scope corresponding to the given declaraion context, or NULL 931 /// if no such scope is open. 932 Scope *Sema::getScopeForContext(DeclContext *Ctx) { 933 934 if (!Ctx) 935 return 0; 936 937 Ctx = Ctx->getPrimaryContext(); 938 for (Scope *S = getCurScope(); S; S = S->getParent()) { 939 // Ignore scopes that cannot have declarations. This is important for 940 // out-of-line definitions of static class members. 941 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) 942 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity())) 943 if (Ctx == Entity->getPrimaryContext()) 944 return S; 945 } 946 947 return 0; 948 } 949 950 /// \brief Enter a new function scope 951 void Sema::PushFunctionScope() { 952 if (FunctionScopes.size() == 1) { 953 // Use the "top" function scope rather than having to allocate 954 // memory for a new scope. 955 FunctionScopes.back()->Clear(); 956 FunctionScopes.push_back(FunctionScopes.back()); 957 return; 958 } 959 960 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); 961 } 962 963 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { 964 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), 965 BlockScope, Block)); 966 } 967 968 void Sema::PushLambdaScope(CXXRecordDecl *Lambda, 969 CXXMethodDecl *CallOperator) { 970 FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda, 971 CallOperator)); 972 } 973 974 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, 975 const Decl *D, const BlockExpr *blkExpr) { 976 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); 977 assert(!FunctionScopes.empty() && "mismatched push/pop!"); 978 979 // Issue any analysis-based warnings. 980 if (WP && D) 981 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); 982 else { 983 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator 984 i = Scope->PossiblyUnreachableDiags.begin(), 985 e = Scope->PossiblyUnreachableDiags.end(); 986 i != e; ++i) { 987 const sema::PossiblyUnreachableDiag &D = *i; 988 Diag(D.Loc, D.PD); 989 } 990 } 991 992 if (FunctionScopes.back() != Scope) { 993 delete Scope; 994 } 995 } 996 997 void Sema::PushCompoundScope() { 998 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); 999 } 1000 1001 void Sema::PopCompoundScope() { 1002 FunctionScopeInfo *CurFunction = getCurFunction(); 1003 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); 1004 1005 CurFunction->CompoundScopes.pop_back(); 1006 } 1007 1008 /// \brief Determine whether any errors occurred within this function/method/ 1009 /// block. 1010 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { 1011 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); 1012 } 1013 1014 BlockScopeInfo *Sema::getCurBlock() { 1015 if (FunctionScopes.empty()) 1016 return 0; 1017 1018 return dyn_cast<BlockScopeInfo>(FunctionScopes.back()); 1019 } 1020 1021 LambdaScopeInfo *Sema::getCurLambda() { 1022 if (FunctionScopes.empty()) 1023 return 0; 1024 1025 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back()); 1026 } 1027 1028 void Sema::ActOnComment(SourceRange Comment) { 1029 RawComment RC(SourceMgr, Comment); 1030 if (RC.isAlmostTrailingComment()) { 1031 SourceRange MagicMarkerRange(Comment.getBegin(), 1032 Comment.getBegin().getLocWithOffset(3)); 1033 StringRef MagicMarkerText; 1034 switch (RC.getKind()) { 1035 case RawComment::RCK_OrdinaryBCPL: 1036 MagicMarkerText = "///<"; 1037 break; 1038 case RawComment::RCK_OrdinaryC: 1039 MagicMarkerText = "/**<"; 1040 break; 1041 default: 1042 llvm_unreachable("if this is an almost Doxygen comment, " 1043 "it should be ordinary"); 1044 } 1045 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << 1046 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); 1047 } 1048 Context.addComment(RC); 1049 } 1050 1051 // Pin this vtable to this file. 1052 ExternalSemaSource::~ExternalSemaSource() {} 1053 1054 void ExternalSemaSource::ReadMethodPool(Selector Sel) { } 1055 1056 void ExternalSemaSource::ReadKnownNamespaces( 1057 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 1058 } 1059 1060 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { 1061 SourceLocation Loc = this->Loc; 1062 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); 1063 if (Loc.isValid()) { 1064 Loc.print(OS, S.getSourceManager()); 1065 OS << ": "; 1066 } 1067 OS << Message; 1068 1069 if (TheDecl && isa<NamedDecl>(TheDecl)) { 1070 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString(); 1071 if (!Name.empty()) 1072 OS << " '" << Name << '\''; 1073 } 1074 1075 OS << '\n'; 1076 } 1077 1078 /// \brief Figure out if an expression could be turned into a call. 1079 /// 1080 /// Use this when trying to recover from an error where the programmer may have 1081 /// written just the name of a function instead of actually calling it. 1082 /// 1083 /// \param E - The expression to examine. 1084 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call 1085 /// with no arguments, this parameter is set to the type returned by such a 1086 /// call; otherwise, it is set to an empty QualType. 1087 /// \param OverloadSet - If the expression is an overloaded function 1088 /// name, this parameter is populated with the decls of the various overloads. 1089 bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy, 1090 UnresolvedSetImpl &OverloadSet) { 1091 ZeroArgCallReturnTy = QualType(); 1092 OverloadSet.clear(); 1093 1094 if (E.getType() == Context.OverloadTy) { 1095 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E)); 1096 const OverloadExpr *Overloads = FR.Expression; 1097 1098 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), 1099 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { 1100 OverloadSet.addDecl(*it); 1101 1102 // Check whether the function is a non-template which takes no 1103 // arguments. 1104 if (const FunctionDecl *OverloadDecl 1105 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) { 1106 if (OverloadDecl->getMinRequiredArguments() == 0) 1107 ZeroArgCallReturnTy = OverloadDecl->getResultType(); 1108 } 1109 } 1110 1111 // Ignore overloads that are pointer-to-member constants. 1112 if (FR.HasFormOfMemberPointer) 1113 return false; 1114 1115 return true; 1116 } 1117 1118 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) { 1119 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) { 1120 if (Fun->getMinRequiredArguments() == 0) 1121 ZeroArgCallReturnTy = Fun->getResultType(); 1122 return true; 1123 } 1124 } 1125 1126 // We don't have an expression that's convenient to get a FunctionDecl from, 1127 // but we can at least check if the type is "function of 0 arguments". 1128 QualType ExprTy = E.getType(); 1129 const FunctionType *FunTy = NULL; 1130 QualType PointeeTy = ExprTy->getPointeeType(); 1131 if (!PointeeTy.isNull()) 1132 FunTy = PointeeTy->getAs<FunctionType>(); 1133 if (!FunTy) 1134 FunTy = ExprTy->getAs<FunctionType>(); 1135 if (!FunTy && ExprTy == Context.BoundMemberTy) { 1136 // Look for the bound-member type. If it's still overloaded, give up, 1137 // although we probably should have fallen into the OverloadExpr case above 1138 // if we actually have an overloaded bound member. 1139 QualType BoundMemberTy = Expr::findBoundMemberType(&E); 1140 if (!BoundMemberTy.isNull()) 1141 FunTy = BoundMemberTy->castAs<FunctionType>(); 1142 } 1143 1144 if (const FunctionProtoType *FPT = 1145 dyn_cast_or_null<FunctionProtoType>(FunTy)) { 1146 if (FPT->getNumArgs() == 0) 1147 ZeroArgCallReturnTy = FunTy->getResultType(); 1148 return true; 1149 } 1150 return false; 1151 } 1152 1153 /// \brief Give notes for a set of overloads. 1154 /// 1155 /// A companion to isExprCallable. In cases when the name that the programmer 1156 /// wrote was an overloaded function, we may be able to make some guesses about 1157 /// plausible overloads based on their return types; such guesses can be handed 1158 /// off to this method to be emitted as notes. 1159 /// 1160 /// \param Overloads - The overloads to note. 1161 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to 1162 /// -fshow-overloads=best, this is the location to attach to the note about too 1163 /// many candidates. Typically this will be the location of the original 1164 /// ill-formed expression. 1165 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, 1166 const SourceLocation FinalNoteLoc) { 1167 int ShownOverloads = 0; 1168 int SuppressedOverloads = 0; 1169 for (UnresolvedSetImpl::iterator It = Overloads.begin(), 1170 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 1171 // FIXME: Magic number for max shown overloads stolen from 1172 // OverloadCandidateSet::NoteCandidates. 1173 if (ShownOverloads >= 4 && 1174 S.Diags.getShowOverloads() == DiagnosticsEngine::Ovl_Best) { 1175 ++SuppressedOverloads; 1176 continue; 1177 } 1178 1179 NamedDecl *Fn = (*It)->getUnderlyingDecl(); 1180 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); 1181 ++ShownOverloads; 1182 } 1183 1184 if (SuppressedOverloads) 1185 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) 1186 << SuppressedOverloads; 1187 } 1188 1189 static void notePlausibleOverloads(Sema &S, SourceLocation Loc, 1190 const UnresolvedSetImpl &Overloads, 1191 bool (*IsPlausibleResult)(QualType)) { 1192 if (!IsPlausibleResult) 1193 return noteOverloads(S, Overloads, Loc); 1194 1195 UnresolvedSet<2> PlausibleOverloads; 1196 for (OverloadExpr::decls_iterator It = Overloads.begin(), 1197 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 1198 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It); 1199 QualType OverloadResultTy = OverloadDecl->getResultType(); 1200 if (IsPlausibleResult(OverloadResultTy)) 1201 PlausibleOverloads.addDecl(It.getDecl()); 1202 } 1203 noteOverloads(S, PlausibleOverloads, Loc); 1204 } 1205 1206 /// Determine whether the given expression can be called by just 1207 /// putting parentheses after it. Notably, expressions with unary 1208 /// operators can't be because the unary operator will start parsing 1209 /// outside the call. 1210 static bool IsCallableWithAppend(Expr *E) { 1211 E = E->IgnoreImplicit(); 1212 return (!isa<CStyleCastExpr>(E) && 1213 !isa<UnaryOperator>(E) && 1214 !isa<BinaryOperator>(E) && 1215 !isa<CXXOperatorCallExpr>(E)); 1216 } 1217 1218 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, 1219 bool ForceComplain, 1220 bool (*IsPlausibleResult)(QualType)) { 1221 SourceLocation Loc = E.get()->getExprLoc(); 1222 SourceRange Range = E.get()->getSourceRange(); 1223 1224 QualType ZeroArgCallTy; 1225 UnresolvedSet<4> Overloads; 1226 if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) && 1227 !ZeroArgCallTy.isNull() && 1228 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { 1229 // At this point, we know E is potentially callable with 0 1230 // arguments and that it returns something of a reasonable type, 1231 // so we can emit a fixit and carry on pretending that E was 1232 // actually a CallExpr. 1233 SourceLocation ParenInsertionLoc = 1234 PP.getLocForEndOfToken(Range.getEnd()); 1235 Diag(Loc, PD) 1236 << /*zero-arg*/ 1 << Range 1237 << (IsCallableWithAppend(E.get()) 1238 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") 1239 : FixItHint()); 1240 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 1241 1242 // FIXME: Try this before emitting the fixit, and suppress diagnostics 1243 // while doing so. 1244 E = ActOnCallExpr(0, E.take(), ParenInsertionLoc, 1245 MultiExprArg(), ParenInsertionLoc.getLocWithOffset(1)); 1246 return true; 1247 } 1248 1249 if (!ForceComplain) return false; 1250 1251 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; 1252 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 1253 E = ExprError(); 1254 return true; 1255 } 1256