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 CheckDelayedMemberExceptionSpecs(); 608 } 609 610 // All delayed member exception specs should be checked or we end up accepting 611 // incompatible declarations. 612 assert(DelayedDefaultedMemberExceptionSpecs.empty()); 613 assert(DelayedDestructorExceptionSpecChecks.empty()); 614 615 // Remove file scoped decls that turned out to be used. 616 UnusedFileScopedDecls.erase( 617 std::remove_if(UnusedFileScopedDecls.begin(0, true), 618 UnusedFileScopedDecls.end(), 619 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)), 620 UnusedFileScopedDecls.end()); 621 622 if (TUKind == TU_Prefix) { 623 // Translation unit prefixes don't need any of the checking below. 624 TUScope = 0; 625 return; 626 } 627 628 // Check for #pragma weak identifiers that were never declared 629 // FIXME: This will cause diagnostics to be emitted in a non-determinstic 630 // order! Iterating over a densemap like this is bad. 631 LoadExternalWeakUndeclaredIdentifiers(); 632 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 633 I = WeakUndeclaredIdentifiers.begin(), 634 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { 635 if (I->second.getUsed()) continue; 636 637 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) 638 << I->first; 639 } 640 641 if (LangOpts.CPlusPlus11 && 642 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle, 643 SourceLocation()) 644 != DiagnosticsEngine::Ignored) 645 CheckDelegatingCtorCycles(); 646 647 if (TUKind == TU_Module) { 648 // If we are building a module, resolve all of the exported declarations 649 // now. 650 if (Module *CurrentModule = PP.getCurrentModule()) { 651 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 652 653 SmallVector<Module *, 2> Stack; 654 Stack.push_back(CurrentModule); 655 while (!Stack.empty()) { 656 Module *Mod = Stack.pop_back_val(); 657 658 // Resolve the exported declarations and conflicts. 659 // FIXME: Actually complain, once we figure out how to teach the 660 // diagnostic client to deal with complaints in the module map at this 661 // point. 662 ModMap.resolveExports(Mod, /*Complain=*/false); 663 ModMap.resolveUses(Mod, /*Complain=*/false); 664 ModMap.resolveConflicts(Mod, /*Complain=*/false); 665 666 // Queue the submodules, so their exports will also be resolved. 667 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 668 SubEnd = Mod->submodule_end(); 669 Sub != SubEnd; ++Sub) { 670 Stack.push_back(*Sub); 671 } 672 } 673 } 674 675 // Modules don't need any of the checking below. 676 TUScope = 0; 677 return; 678 } 679 680 // C99 6.9.2p2: 681 // A declaration of an identifier for an object that has file 682 // scope without an initializer, and without a storage-class 683 // specifier or with the storage-class specifier static, 684 // constitutes a tentative definition. If a translation unit 685 // contains one or more tentative definitions for an identifier, 686 // and the translation unit contains no external definition for 687 // that identifier, then the behavior is exactly as if the 688 // translation unit contains a file scope declaration of that 689 // identifier, with the composite type as of the end of the 690 // translation unit, with an initializer equal to 0. 691 llvm::SmallSet<VarDecl *, 32> Seen; 692 for (TentativeDefinitionsType::iterator 693 T = TentativeDefinitions.begin(ExternalSource), 694 TEnd = TentativeDefinitions.end(); 695 T != TEnd; ++T) 696 { 697 VarDecl *VD = (*T)->getActingDefinition(); 698 699 // If the tentative definition was completed, getActingDefinition() returns 700 // null. If we've already seen this variable before, insert()'s second 701 // return value is false. 702 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) 703 continue; 704 705 if (const IncompleteArrayType *ArrayT 706 = Context.getAsIncompleteArrayType(VD->getType())) { 707 // Set the length of the array to 1 (C99 6.9.2p5). 708 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 709 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 710 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), 711 One, ArrayType::Normal, 0); 712 VD->setType(T); 713 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 714 diag::err_tentative_def_incomplete_type)) 715 VD->setInvalidDecl(); 716 717 CheckCompleteVariableDeclaration(VD); 718 719 // Notify the consumer that we've completed a tentative definition. 720 if (!VD->isInvalidDecl()) 721 Consumer.CompleteTentativeDefinition(VD); 722 723 } 724 725 // If there were errors, disable 'unused' warnings since they will mostly be 726 // noise. 727 if (!Diags.hasErrorOccurred()) { 728 // Output warning for unused file scoped decls. 729 for (UnusedFileScopedDeclsType::iterator 730 I = UnusedFileScopedDecls.begin(ExternalSource), 731 E = UnusedFileScopedDecls.end(); I != E; ++I) { 732 if (ShouldRemoveFromUnused(this, *I)) 733 continue; 734 735 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 736 const FunctionDecl *DiagD; 737 if (!FD->hasBody(DiagD)) 738 DiagD = FD; 739 if (DiagD->isDeleted()) 740 continue; // Deleted functions are supposed to be unused. 741 if (DiagD->isReferenced()) { 742 if (isa<CXXMethodDecl>(DiagD)) 743 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) 744 << DiagD->getDeclName(); 745 else { 746 if (FD->getStorageClass() == SC_Static && 747 !FD->isInlineSpecified() && 748 !SourceMgr.isInMainFile( 749 SourceMgr.getExpansionLoc(FD->getLocation()))) 750 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl) 751 << DiagD->getDeclName(); 752 else 753 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 754 << /*function*/0 << DiagD->getDeclName(); 755 } 756 } else { 757 Diag(DiagD->getLocation(), 758 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function 759 : diag::warn_unused_function) 760 << DiagD->getDeclName(); 761 } 762 } else { 763 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition(); 764 if (!DiagD) 765 DiagD = cast<VarDecl>(*I); 766 if (DiagD->isReferenced()) { 767 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 768 << /*variable*/1 << DiagD->getDeclName(); 769 } else if (DiagD->getType().isConstQualified()) { 770 Diag(DiagD->getLocation(), diag::warn_unused_const_variable) 771 << DiagD->getDeclName(); 772 } else { 773 Diag(DiagD->getLocation(), diag::warn_unused_variable) 774 << DiagD->getDeclName(); 775 } 776 } 777 } 778 779 if (ExternalSource) 780 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); 781 checkUndefinedButUsed(*this); 782 } 783 784 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field, 785 SourceLocation()) 786 != DiagnosticsEngine::Ignored) { 787 RecordCompleteMap RecordsComplete; 788 RecordCompleteMap MNCComplete; 789 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), 790 E = UnusedPrivateFields.end(); I != E; ++I) { 791 const NamedDecl *D = *I; 792 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); 793 if (RD && !RD->isUnion() && 794 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { 795 Diag(D->getLocation(), diag::warn_unused_private_field) 796 << D->getDeclName(); 797 } 798 } 799 } 800 801 // Check we've noticed that we're no longer parsing the initializer for every 802 // variable. If we miss cases, then at best we have a performance issue and 803 // at worst a rejects-valid bug. 804 assert(ParsingInitForAutoVars.empty() && 805 "Didn't unmark var as having its initializer parsed"); 806 807 TUScope = 0; 808} 809 810 811//===----------------------------------------------------------------------===// 812// Helper functions. 813//===----------------------------------------------------------------------===// 814 815DeclContext *Sema::getFunctionLevelDeclContext() { 816 DeclContext *DC = CurContext; 817 818 while (true) { 819 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) { 820 DC = DC->getParent(); 821 } else if (isa<CXXMethodDecl>(DC) && 822 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && 823 cast<CXXRecordDecl>(DC->getParent())->isLambda()) { 824 DC = DC->getParent()->getParent(); 825 } 826 else break; 827 } 828 829 return DC; 830} 831 832/// getCurFunctionDecl - If inside of a function body, this returns a pointer 833/// to the function decl for the function being parsed. If we're currently 834/// in a 'block', this returns the containing context. 835FunctionDecl *Sema::getCurFunctionDecl() { 836 DeclContext *DC = getFunctionLevelDeclContext(); 837 return dyn_cast<FunctionDecl>(DC); 838} 839 840ObjCMethodDecl *Sema::getCurMethodDecl() { 841 DeclContext *DC = getFunctionLevelDeclContext(); 842 while (isa<RecordDecl>(DC)) 843 DC = DC->getParent(); 844 return dyn_cast<ObjCMethodDecl>(DC); 845} 846 847NamedDecl *Sema::getCurFunctionOrMethodDecl() { 848 DeclContext *DC = getFunctionLevelDeclContext(); 849 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 850 return cast<NamedDecl>(DC); 851 return 0; 852} 853 854void Sema::EmitCurrentDiagnostic(unsigned DiagID) { 855 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here 856 // and yet we also use the current diag ID on the DiagnosticsEngine. This has 857 // been made more painfully obvious by the refactor that introduced this 858 // function, but it is possible that the incoming argument can be 859 // eliminnated. If it truly cannot be (for example, there is some reentrancy 860 // issue I am not seeing yet), then there should at least be a clarifying 861 // comment somewhere. 862 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { 863 switch (DiagnosticIDs::getDiagnosticSFINAEResponse( 864 Diags.getCurrentDiagID())) { 865 case DiagnosticIDs::SFINAE_Report: 866 // We'll report the diagnostic below. 867 break; 868 869 case DiagnosticIDs::SFINAE_SubstitutionFailure: 870 // Count this failure so that we know that template argument deduction 871 // has failed. 872 ++NumSFINAEErrors; 873 874 // Make a copy of this suppressed diagnostic and store it with the 875 // template-deduction information. 876 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 877 Diagnostic DiagInfo(&Diags); 878 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 879 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 880 } 881 882 Diags.setLastDiagnosticIgnored(); 883 Diags.Clear(); 884 return; 885 886 case DiagnosticIDs::SFINAE_AccessControl: { 887 // Per C++ Core Issue 1170, access control is part of SFINAE. 888 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily 889 // make access control a part of SFINAE for the purposes of checking 890 // type traits. 891 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) 892 break; 893 894 SourceLocation Loc = Diags.getCurrentDiagLoc(); 895 896 // Suppress this diagnostic. 897 ++NumSFINAEErrors; 898 899 // Make a copy of this suppressed diagnostic and store it with the 900 // template-deduction information. 901 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 902 Diagnostic DiagInfo(&Diags); 903 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 904 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 905 } 906 907 Diags.setLastDiagnosticIgnored(); 908 Diags.Clear(); 909 910 // Now the diagnostic state is clear, produce a C++98 compatibility 911 // warning. 912 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); 913 914 // The last diagnostic which Sema produced was ignored. Suppress any 915 // notes attached to it. 916 Diags.setLastDiagnosticIgnored(); 917 return; 918 } 919 920 case DiagnosticIDs::SFINAE_Suppress: 921 // Make a copy of this suppressed diagnostic and store it with the 922 // template-deduction information; 923 if (*Info) { 924 Diagnostic DiagInfo(&Diags); 925 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), 926 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 927 } 928 929 // Suppress this diagnostic. 930 Diags.setLastDiagnosticIgnored(); 931 Diags.Clear(); 932 return; 933 } 934 } 935 936 // Set up the context's printing policy based on our current state. 937 Context.setPrintingPolicy(getPrintingPolicy()); 938 939 // Emit the diagnostic. 940 if (!Diags.EmitCurrentDiagnostic()) 941 return; 942 943 // If this is not a note, and we're in a template instantiation 944 // that is different from the last template instantiation where 945 // we emitted an error, print a template instantiation 946 // backtrace. 947 if (!DiagnosticIDs::isBuiltinNote(DiagID) && 948 !ActiveTemplateInstantiations.empty() && 949 ActiveTemplateInstantiations.back() 950 != LastTemplateInstantiationErrorContext) { 951 PrintInstantiationStack(); 952 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back(); 953 } 954} 955 956Sema::SemaDiagnosticBuilder 957Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 958 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 959 PD.Emit(Builder); 960 961 return Builder; 962} 963 964/// \brief Looks through the macro-expansion chain for the given 965/// location, looking for a macro expansion with the given name. 966/// If one is found, returns true and sets the location to that 967/// expansion loc. 968bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { 969 SourceLocation loc = locref; 970 if (!loc.isMacroID()) return false; 971 972 // There's no good way right now to look at the intermediate 973 // expansions, so just jump to the expansion location. 974 loc = getSourceManager().getExpansionLoc(loc); 975 976 // If that's written with the name, stop here. 977 SmallVector<char, 16> buffer; 978 if (getPreprocessor().getSpelling(loc, buffer) == name) { 979 locref = loc; 980 return true; 981 } 982 return false; 983} 984 985/// \brief Determines the active Scope associated with the given declaration 986/// context. 987/// 988/// This routine maps a declaration context to the active Scope object that 989/// represents that declaration context in the parser. It is typically used 990/// from "scope-less" code (e.g., template instantiation, lazy creation of 991/// declarations) that injects a name for name-lookup purposes and, therefore, 992/// must update the Scope. 993/// 994/// \returns The scope corresponding to the given declaraion context, or NULL 995/// if no such scope is open. 996Scope *Sema::getScopeForContext(DeclContext *Ctx) { 997 998 if (!Ctx) 999 return 0; 1000 1001 Ctx = Ctx->getPrimaryContext(); 1002 for (Scope *S = getCurScope(); S; S = S->getParent()) { 1003 // Ignore scopes that cannot have declarations. This is important for 1004 // out-of-line definitions of static class members. 1005 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) 1006 if (DeclContext *Entity = S->getEntity()) 1007 if (Ctx == Entity->getPrimaryContext()) 1008 return S; 1009 } 1010 1011 return 0; 1012} 1013 1014/// \brief Enter a new function scope 1015void Sema::PushFunctionScope() { 1016 if (FunctionScopes.size() == 1) { 1017 // Use the "top" function scope rather than having to allocate 1018 // memory for a new scope. 1019 FunctionScopes.back()->Clear(); 1020 FunctionScopes.push_back(FunctionScopes.back()); 1021 return; 1022 } 1023 1024 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); 1025} 1026 1027void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { 1028 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), 1029 BlockScope, Block)); 1030} 1031 1032LambdaScopeInfo *Sema::PushLambdaScope() { 1033 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); 1034 FunctionScopes.push_back(LSI); 1035 return LSI; 1036} 1037 1038void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { 1039 if (LambdaScopeInfo *const LSI = getCurLambda()) { 1040 LSI->AutoTemplateParameterDepth = Depth; 1041 return; 1042 } 1043 llvm_unreachable( 1044 "Remove assertion if intentionally called in a non-lambda context."); 1045} 1046 1047void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, 1048 const Decl *D, const BlockExpr *blkExpr) { 1049 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val(); 1050 assert(!FunctionScopes.empty() && "mismatched push/pop!"); 1051 1052 // Issue any analysis-based warnings. 1053 if (WP && D) 1054 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr); 1055 else { 1056 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator 1057 i = Scope->PossiblyUnreachableDiags.begin(), 1058 e = Scope->PossiblyUnreachableDiags.end(); 1059 i != e; ++i) { 1060 const sema::PossiblyUnreachableDiag &D = *i; 1061 Diag(D.Loc, D.PD); 1062 } 1063 } 1064 1065 if (FunctionScopes.back() != Scope) { 1066 delete Scope; 1067 } 1068} 1069 1070void Sema::PushCompoundScope() { 1071 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo()); 1072} 1073 1074void Sema::PopCompoundScope() { 1075 FunctionScopeInfo *CurFunction = getCurFunction(); 1076 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); 1077 1078 CurFunction->CompoundScopes.pop_back(); 1079} 1080 1081/// \brief Determine whether any errors occurred within this function/method/ 1082/// block. 1083bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { 1084 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred(); 1085} 1086 1087BlockScopeInfo *Sema::getCurBlock() { 1088 if (FunctionScopes.empty()) 1089 return 0; 1090 1091 return dyn_cast<BlockScopeInfo>(FunctionScopes.back()); 1092} 1093 1094LambdaScopeInfo *Sema::getCurLambda() { 1095 if (FunctionScopes.empty()) 1096 return 0; 1097 1098 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back()); 1099} 1100// We have a generic lambda if we parsed auto parameters, or we have 1101// an associated template parameter list. 1102LambdaScopeInfo *Sema::getCurGenericLambda() { 1103 if (LambdaScopeInfo *LSI = getCurLambda()) { 1104 return (LSI->AutoTemplateParams.size() || 1105 LSI->GLTemplateParameterList) ? LSI : 0; 1106 } 1107 return 0; 1108} 1109 1110 1111void Sema::ActOnComment(SourceRange Comment) { 1112 if (!LangOpts.RetainCommentsFromSystemHeaders && 1113 SourceMgr.isInSystemHeader(Comment.getBegin())) 1114 return; 1115 RawComment RC(SourceMgr, Comment, false, 1116 LangOpts.CommentOpts.ParseAllComments); 1117 if (RC.isAlmostTrailingComment()) { 1118 SourceRange MagicMarkerRange(Comment.getBegin(), 1119 Comment.getBegin().getLocWithOffset(3)); 1120 StringRef MagicMarkerText; 1121 switch (RC.getKind()) { 1122 case RawComment::RCK_OrdinaryBCPL: 1123 MagicMarkerText = "///<"; 1124 break; 1125 case RawComment::RCK_OrdinaryC: 1126 MagicMarkerText = "/**<"; 1127 break; 1128 default: 1129 llvm_unreachable("if this is an almost Doxygen comment, " 1130 "it should be ordinary"); 1131 } 1132 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << 1133 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); 1134 } 1135 Context.addComment(RC); 1136} 1137 1138// Pin this vtable to this file. 1139ExternalSemaSource::~ExternalSemaSource() {} 1140 1141void ExternalSemaSource::ReadMethodPool(Selector Sel) { } 1142 1143void ExternalSemaSource::ReadKnownNamespaces( 1144 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 1145} 1146 1147void ExternalSemaSource::ReadUndefinedButUsed( 1148 llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) { 1149} 1150 1151void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const { 1152 SourceLocation Loc = this->Loc; 1153 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation(); 1154 if (Loc.isValid()) { 1155 Loc.print(OS, S.getSourceManager()); 1156 OS << ": "; 1157 } 1158 OS << Message; 1159 1160 if (TheDecl && isa<NamedDecl>(TheDecl)) { 1161 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString(); 1162 if (!Name.empty()) 1163 OS << " '" << Name << '\''; 1164 } 1165 1166 OS << '\n'; 1167} 1168 1169/// \brief Figure out if an expression could be turned into a call. 1170/// 1171/// Use this when trying to recover from an error where the programmer may have 1172/// written just the name of a function instead of actually calling it. 1173/// 1174/// \param E - The expression to examine. 1175/// \param ZeroArgCallReturnTy - If the expression can be turned into a call 1176/// with no arguments, this parameter is set to the type returned by such a 1177/// call; otherwise, it is set to an empty QualType. 1178/// \param OverloadSet - If the expression is an overloaded function 1179/// name, this parameter is populated with the decls of the various overloads. 1180bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, 1181 UnresolvedSetImpl &OverloadSet) { 1182 ZeroArgCallReturnTy = QualType(); 1183 OverloadSet.clear(); 1184 1185 const OverloadExpr *Overloads = NULL; 1186 bool IsMemExpr = false; 1187 if (E.getType() == Context.OverloadTy) { 1188 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E)); 1189 1190 // Ignore overloads that are pointer-to-member constants. 1191 if (FR.HasFormOfMemberPointer) 1192 return false; 1193 1194 Overloads = FR.Expression; 1195 } else if (E.getType() == Context.BoundMemberTy) { 1196 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens()); 1197 IsMemExpr = true; 1198 } 1199 1200 bool Ambiguous = false; 1201 1202 if (Overloads) { 1203 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), 1204 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { 1205 OverloadSet.addDecl(*it); 1206 1207 // Check whether the function is a non-template, non-member which takes no 1208 // arguments. 1209 if (IsMemExpr) 1210 continue; 1211 if (const FunctionDecl *OverloadDecl 1212 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) { 1213 if (OverloadDecl->getMinRequiredArguments() == 0) { 1214 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) { 1215 ZeroArgCallReturnTy = QualType(); 1216 Ambiguous = true; 1217 } else 1218 ZeroArgCallReturnTy = OverloadDecl->getResultType(); 1219 } 1220 } 1221 } 1222 1223 // If it's not a member, use better machinery to try to resolve the call 1224 if (!IsMemExpr) 1225 return !ZeroArgCallReturnTy.isNull(); 1226 } 1227 1228 // Attempt to call the member with no arguments - this will correctly handle 1229 // member templates with defaults/deduction of template arguments, overloads 1230 // with default arguments, etc. 1231 if (IsMemExpr && !E.isTypeDependent()) { 1232 bool Suppress = getDiagnostics().getSuppressAllDiagnostics(); 1233 getDiagnostics().setSuppressAllDiagnostics(true); 1234 ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None, 1235 SourceLocation()); 1236 getDiagnostics().setSuppressAllDiagnostics(Suppress); 1237 if (R.isUsable()) { 1238 ZeroArgCallReturnTy = R.get()->getType(); 1239 return true; 1240 } 1241 return false; 1242 } 1243 1244 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) { 1245 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) { 1246 if (Fun->getMinRequiredArguments() == 0) 1247 ZeroArgCallReturnTy = Fun->getResultType(); 1248 return true; 1249 } 1250 } 1251 1252 // We don't have an expression that's convenient to get a FunctionDecl from, 1253 // but we can at least check if the type is "function of 0 arguments". 1254 QualType ExprTy = E.getType(); 1255 const FunctionType *FunTy = NULL; 1256 QualType PointeeTy = ExprTy->getPointeeType(); 1257 if (!PointeeTy.isNull()) 1258 FunTy = PointeeTy->getAs<FunctionType>(); 1259 if (!FunTy) 1260 FunTy = ExprTy->getAs<FunctionType>(); 1261 1262 if (const FunctionProtoType *FPT = 1263 dyn_cast_or_null<FunctionProtoType>(FunTy)) { 1264 if (FPT->getNumArgs() == 0) 1265 ZeroArgCallReturnTy = FunTy->getResultType(); 1266 return true; 1267 } 1268 return false; 1269} 1270 1271/// \brief Give notes for a set of overloads. 1272/// 1273/// A companion to tryExprAsCall. In cases when the name that the programmer 1274/// wrote was an overloaded function, we may be able to make some guesses about 1275/// plausible overloads based on their return types; such guesses can be handed 1276/// off to this method to be emitted as notes. 1277/// 1278/// \param Overloads - The overloads to note. 1279/// \param FinalNoteLoc - If we've suppressed printing some overloads due to 1280/// -fshow-overloads=best, this is the location to attach to the note about too 1281/// many candidates. Typically this will be the location of the original 1282/// ill-formed expression. 1283static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, 1284 const SourceLocation FinalNoteLoc) { 1285 int ShownOverloads = 0; 1286 int SuppressedOverloads = 0; 1287 for (UnresolvedSetImpl::iterator It = Overloads.begin(), 1288 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 1289 // FIXME: Magic number for max shown overloads stolen from 1290 // OverloadCandidateSet::NoteCandidates. 1291 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { 1292 ++SuppressedOverloads; 1293 continue; 1294 } 1295 1296 NamedDecl *Fn = (*It)->getUnderlyingDecl(); 1297 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); 1298 ++ShownOverloads; 1299 } 1300 1301 if (SuppressedOverloads) 1302 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) 1303 << SuppressedOverloads; 1304} 1305 1306static void notePlausibleOverloads(Sema &S, SourceLocation Loc, 1307 const UnresolvedSetImpl &Overloads, 1308 bool (*IsPlausibleResult)(QualType)) { 1309 if (!IsPlausibleResult) 1310 return noteOverloads(S, Overloads, Loc); 1311 1312 UnresolvedSet<2> PlausibleOverloads; 1313 for (OverloadExpr::decls_iterator It = Overloads.begin(), 1314 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 1315 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It); 1316 QualType OverloadResultTy = OverloadDecl->getResultType(); 1317 if (IsPlausibleResult(OverloadResultTy)) 1318 PlausibleOverloads.addDecl(It.getDecl()); 1319 } 1320 noteOverloads(S, PlausibleOverloads, Loc); 1321} 1322 1323/// Determine whether the given expression can be called by just 1324/// putting parentheses after it. Notably, expressions with unary 1325/// operators can't be because the unary operator will start parsing 1326/// outside the call. 1327static bool IsCallableWithAppend(Expr *E) { 1328 E = E->IgnoreImplicit(); 1329 return (!isa<CStyleCastExpr>(E) && 1330 !isa<UnaryOperator>(E) && 1331 !isa<BinaryOperator>(E) && 1332 !isa<CXXOperatorCallExpr>(E)); 1333} 1334 1335bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, 1336 bool ForceComplain, 1337 bool (*IsPlausibleResult)(QualType)) { 1338 SourceLocation Loc = E.get()->getExprLoc(); 1339 SourceRange Range = E.get()->getSourceRange(); 1340 1341 QualType ZeroArgCallTy; 1342 UnresolvedSet<4> Overloads; 1343 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && 1344 !ZeroArgCallTy.isNull() && 1345 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { 1346 // At this point, we know E is potentially callable with 0 1347 // arguments and that it returns something of a reasonable type, 1348 // so we can emit a fixit and carry on pretending that E was 1349 // actually a CallExpr. 1350 SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd()); 1351 Diag(Loc, PD) 1352 << /*zero-arg*/ 1 << Range 1353 << (IsCallableWithAppend(E.get()) 1354 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") 1355 : FixItHint()); 1356 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 1357 1358 // FIXME: Try this before emitting the fixit, and suppress diagnostics 1359 // while doing so. 1360 E = ActOnCallExpr(0, E.take(), Range.getEnd(), None, 1361 Range.getEnd().getLocWithOffset(1)); 1362 return true; 1363 } 1364 1365 if (!ForceComplain) return false; 1366 1367 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range; 1368 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 1369 E = ExprError(); 1370 return true; 1371} 1372 1373IdentifierInfo *Sema::getSuperIdentifier() const { 1374 if (!Ident_super) 1375 Ident_super = &Context.Idents.get("super"); 1376 return Ident_super; 1377} 1378 1379IdentifierInfo *Sema::getFloat128Identifier() const { 1380 if (!Ident___float128) 1381 Ident___float128 = &Context.Idents.get("__float128"); 1382 return Ident___float128; 1383} 1384 1385void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, 1386 CapturedRegionKind K) { 1387 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD, 1388 CD->getContextParam(), K); 1389 CSI->ReturnType = Context.VoidTy; 1390 FunctionScopes.push_back(CSI); 1391} 1392 1393CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { 1394 if (FunctionScopes.empty()) 1395 return 0; 1396 1397 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back()); 1398} 1399