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