1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the actions class which performs semantic analysis and
11 // builds an AST out of a parse stream.
13 //===----------------------------------------------------------------------===//
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"
44 using namespace clang;
47 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
48 const Preprocessor &PP) {
49 PrintingPolicy Policy = Context.getPrintingPolicy();
50 Policy.Bool = Context.getLangOpts().Bool;
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);
63 void Sema::ActOnTranslationUnitScope(Scope *S) {
65 PushDeclContext(S, Context.getTranslationUnitDecl());
67 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
70 Sema::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),
84 NSStringDecl(0), StringWithUTF8StringMethod(0),
85 NSArrayDecl(0), ArrayWithObjectsMethod(0),
86 NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
87 GlobalNewDeleteDeclared(false),
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)
99 LoadedExternalKnownNamespaces = false;
100 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
101 NSNumberLiteralMethods[I] = 0;
103 if (getLangOpts().ObjC1)
104 NSAPIObj.reset(new NSAPI(Context));
106 if (getLangOpts().CPlusPlus)
107 FieldCollector.reset(new CXXFieldCollector());
109 // Tell diagnostics how to render things from the AST library.
110 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
113 ExprEvalContexts.push_back(
114 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
117 FunctionScopes.push_back(new FunctionScopeInfo(Diags));
119 // Initilization of data sharing attributes stack for OpenMP
120 InitDataSharingAttributesStack();
123 void Sema::Initialize() {
124 // Tell the AST consumer about this Sema object.
125 Consumer.Initialize(Context);
127 // FIXME: Isn't this redundant with the initialization above?
128 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
129 SC->InitializeSema(*this);
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);
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,
140 DeclarationName Int128 = &Context.Idents.get("__int128_t");
141 if (IdResolver.begin(Int128) == IdResolver.end())
142 PushOnScopeChains(Context.getInt128Decl(), TUScope);
144 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
145 if (IdResolver.begin(UInt128) == IdResolver.end())
146 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
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
154 DeclarationName SEL = &Context.Idents.get("SEL");
155 if (IdResolver.begin(SEL) == IdResolver.end())
156 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
158 // If 'id' does not yet refer to any declarations, make it refer to the
160 DeclarationName Id = &Context.Idents.get("id");
161 if (IdResolver.begin(Id) == IdResolver.end())
162 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
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);
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);
175 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
176 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
177 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
181 for (LateParsedTemplateMapT::iterator I = LateParsedTemplateMap.begin(),
182 E = LateParsedTemplateMap.end();
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];
195 // Tell the SemaConsumer to forget about us; we're going out of scope.
196 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
199 // Detach from the external Sema source.
200 if (ExternalSemaSource *ExternalSema
201 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
202 ExternalSema->ForgetSema();
204 // If Sema's ExternalSource is the multiplexer - we own it.
205 if (isMultiplexExternalSource)
206 delete ExternalSource;
208 // Destroys data sharing attributes stack for OpenMP
209 DestroyDataSharingAttributesStack();
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.
216 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
218 // If we're not in a function, it's an error.
219 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
220 if (!fn) return false;
222 // If we're in template instantiation, it's an error.
223 if (!ActiveTemplateInstantiations.empty())
226 // If that function's not in a system header, it's an error.
227 if (!Context.getSourceManager().isInSystemHeader(loc))
230 // If the function is already unavailable, it's not an error.
231 if (fn->hasAttr<UnavailableAttr>()) return true;
233 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
237 ASTMutationListener *Sema::getASTMutationListener() const {
238 return getASTConsumer().GetASTMutationListener();
241 ///\brief Registers an external source. If an external source already exists,
242 /// creates a multiplex external source and appends to it.
244 ///\param[in] E - A non-null external sema source.
246 void Sema::addExternalSource(ExternalSemaSource *E) {
247 assert(E && "Cannot use with NULL ptr");
249 if (!ExternalSource) {
254 if (isMultiplexExternalSource)
255 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
257 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
258 isMultiplexExternalSource = true;
262 /// \brief Print out statistics about the semantic analysis.
263 void Sema::PrintStats() const {
264 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
265 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
267 BumpAlloc.PrintStats();
268 AnalysisWarnings.PrintStats();
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.
274 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
275 CastKind Kind, ExprValueKind VK,
276 const CXXCastPath *BasePath,
277 CheckedConversionKind CCK) {
279 if (VK == VK_RValue && !E->isRValue()) {
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:
290 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
293 QualType ExprTy = Context.getCanonicalType(E->getType());
294 QualType TypeTy = Context.getCanonicalType(Ty);
296 if (ExprTy == TypeTy)
299 // If this is a derived-to-base cast to a through a virtual base, we
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()));
311 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
312 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
313 ImpCast->setType(Ty);
314 ImpCast->setValueKind(VK);
319 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
322 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
323 /// to the conversion from scalar type ScalarTy to the Boolean type.
324 CastKind 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;
339 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
340 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
341 if (D->getMostRecentDecl()->isUsed())
344 if (D->isExternallyVisible())
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);
354 // Later redecls may add new information resulting in not having to warn,
356 DeclToCheck = FD->getMostRecentDecl();
357 if (DeclToCheck != FD)
358 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
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))
371 // UnusedFileScopedDecls stores the first declaration.
372 // The declaration may have become definition so check again.
373 const VarDecl *DeclToCheck = VD->getDefinition();
375 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
377 // Later redecls may add new information resulting in not having to warn,
379 DeclToCheck = VD->getMostRecentDecl();
380 if (DeclToCheck != VD)
381 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
388 struct SortUndefinedButUsed {
389 const SourceManager &SM;
390 explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {}
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())
396 if (!l.second.isValid() && r.second.isValid())
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());
406 /// Obtains a sorted list of functions that are undefined but ODR-used.
407 void Sema::getUndefinedButUsed(
408 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
409 for (llvm::DenseMap<NamedDecl *, SourceLocation>::iterator
410 I = UndefinedButUsed.begin(), E = UndefinedButUsed.end();
412 NamedDecl *ND = I->first;
414 // Ignore attributes that have become invalid.
415 if (ND->isInvalidDecl()) continue;
417 // __attribute__((weakref)) is basically a definition.
418 if (ND->hasAttr<WeakRefAttr>()) continue;
420 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
423 if (FD->isExternallyVisible() &&
424 !FD->getMostRecentDecl()->isInlined())
427 if (cast<VarDecl>(ND)->hasDefinition() != VarDecl::DeclarationOnly)
429 if (ND->isExternallyVisible())
433 Undefined.push_back(std::make_pair(ND, I->second));
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()));
442 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
443 /// or that are inline.
444 static void checkUndefinedButUsed(Sema &S) {
445 if (S.UndefinedButUsed.empty()) return;
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;
452 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
453 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
454 NamedDecl *ND = I->first;
456 if (!ND->isExternallyVisible()) {
457 S.Diag(ND->getLocation(), diag::warn_undefined_internal)
458 << isa<VarDecl>(ND) << ND;
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;
464 if (I->second.isValid())
465 S.Diag(I->second, diag::note_used_here);
469 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
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())
481 WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
486 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
488 /// \brief Returns true, if all methods and nested classes of the given
489 /// CXXRecordDecl are defined in this translation unit.
491 /// Should only be called from ActOnEndOfTranslationUnit so that all
492 /// definitions are actually read.
493 static 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())
500 bool Complete = true;
501 for (DeclContext::decl_iterator I = RD->decls_begin(),
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())
511 if (R->hasDefinition())
512 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
518 MNCComplete[RD] = Complete;
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.
527 /// Should only be called from ActOnEndOfTranslationUnit so that all
528 /// definitions are actually read.
529 static 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);
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();
552 // This is a template friend, give up.
556 RecordsComplete[RD] = Complete;
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
563 void Sema::ActOnEndOfTranslationUnit() {
564 assert(DelayedDiagnostics.getCurrentPool() == NULL
565 && "reached end of translation unit with a pool attached?");
567 // If code completion is enabled, don't perform any end-of-translation-unit
569 if (PP.isCodeCompletionEnabled())
572 // Complete translation units and modules define vtables and perform implicit
573 // instantiations. PCH files do not.
574 if (TUKind != TU_Prefix) {
575 DiagnoseUseOfUnimplementedSelectors();
577 // If any dynamic classes have their key function defined within
578 // this translation unit, then those vtables are considered "used" and must
580 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
581 E = DynamicClasses.end();
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);
592 // If DefinedUsedVTables ends up marking any virtual member functions it
593 // might lead to more pending template instantiations, which we then need
597 // C++: Perform implicit template instantiations.
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();
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());
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());
622 if (TUKind == TU_Prefix) {
623 // Translation unit prefixes don't need any of the checking below.
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;
637 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
641 if (LangOpts.CPlusPlus11 &&
642 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
644 != DiagnosticsEngine::Ignored)
645 CheckDelegatingCtorCycles();
647 if (TUKind == TU_Module) {
648 // If we are building a module, resolve all of the exported declarations
650 if (Module *CurrentModule = PP.getCurrentModule()) {
651 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
653 SmallVector<Module *, 2> Stack;
654 Stack.push_back(CurrentModule);
655 while (!Stack.empty()) {
656 Module *Mod = Stack.pop_back_val();
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
662 ModMap.resolveExports(Mod, /*Complain=*/false);
663 ModMap.resolveUses(Mod, /*Complain=*/false);
664 ModMap.resolveConflicts(Mod, /*Complain=*/false);
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);
675 // Modules don't need any of the checking below.
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();
697 VarDecl *VD = (*T)->getActingDefinition();
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))
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);
713 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
714 diag::err_tentative_def_incomplete_type))
715 VD->setInvalidDecl();
717 CheckCompleteVariableDeclaration(VD);
719 // Notify the consumer that we've completed a tentative definition.
720 if (!VD->isInvalidDecl())
721 Consumer.CompleteTentativeDefinition(VD);
725 // If there were errors, disable 'unused' warnings since they will mostly be
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))
735 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
736 const FunctionDecl *DiagD;
737 if (!FD->hasBody(DiagD))
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();
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();
753 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
754 << /*function*/0 << DiagD->getDeclName();
757 Diag(DiagD->getLocation(),
758 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
759 : diag::warn_unused_function)
760 << DiagD->getDeclName();
763 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
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();
773 Diag(DiagD->getLocation(), diag::warn_unused_variable)
774 << DiagD->getDeclName();
780 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
781 checkUndefinedButUsed(*this);
784 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
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)
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");
811 //===----------------------------------------------------------------------===//
813 //===----------------------------------------------------------------------===//
815 DeclContext *Sema::getFunctionLevelDeclContext() {
816 DeclContext *DC = CurContext;
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();
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.
835 FunctionDecl *Sema::getCurFunctionDecl() {
836 DeclContext *DC = getFunctionLevelDeclContext();
837 return dyn_cast<FunctionDecl>(DC);
840 ObjCMethodDecl *Sema::getCurMethodDecl() {
841 DeclContext *DC = getFunctionLevelDeclContext();
842 while (isa<RecordDecl>(DC))
843 DC = DC->getParent();
844 return dyn_cast<ObjCMethodDecl>(DC);
847 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
848 DeclContext *DC = getFunctionLevelDeclContext();
849 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
850 return cast<NamedDecl>(DC);
854 void 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.
869 case DiagnosticIDs::SFINAE_SubstitutionFailure:
870 // Count this failure so that we know that template argument deduction
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()));
882 Diags.setLastDiagnosticIgnored();
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
891 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
894 SourceLocation Loc = Diags.getCurrentDiagLoc();
896 // Suppress this diagnostic.
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()));
907 Diags.setLastDiagnosticIgnored();
910 // Now the diagnostic state is clear, produce a C++98 compatibility
912 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
914 // The last diagnostic which Sema produced was ignored. Suppress any
915 // notes attached to it.
916 Diags.setLastDiagnosticIgnored();
920 case DiagnosticIDs::SFINAE_Suppress:
921 // Make a copy of this suppressed diagnostic and store it with the
922 // template-deduction information;
924 Diagnostic DiagInfo(&Diags);
925 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
926 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
929 // Suppress this diagnostic.
930 Diags.setLastDiagnosticIgnored();
936 // Set up the context's printing policy based on our current state.
937 Context.setPrintingPolicy(getPrintingPolicy());
939 // Emit the diagnostic.
940 if (!Diags.EmitCurrentDiagnostic())
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
947 if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
948 !ActiveTemplateInstantiations.empty() &&
949 ActiveTemplateInstantiations.back()
950 != LastTemplateInstantiationErrorContext) {
951 PrintInstantiationStack();
952 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
956 Sema::SemaDiagnosticBuilder
957 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
958 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
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
968 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
969 SourceLocation loc = locref;
970 if (!loc.isMacroID()) return false;
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);
976 // If that's written with the name, stop here.
977 SmallVector<char, 16> buffer;
978 if (getPreprocessor().getSpelling(loc, buffer) == name) {
985 /// \brief Determines the active Scope associated with the given declaration
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.
994 /// \returns The scope corresponding to the given declaraion context, or NULL
995 /// if no such scope is open.
996 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
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())
1014 /// \brief Enter a new function scope
1015 void 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());
1024 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1027 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1028 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1029 BlockScope, Block));
1032 LambdaScopeInfo *Sema::PushLambdaScope() {
1033 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1034 FunctionScopes.push_back(LSI);
1038 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1039 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1040 LSI->AutoTemplateParameterDepth = Depth;
1044 "Remove assertion if intentionally called in a non-lambda context.");
1047 void 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!");
1052 // Issue any analysis-based warnings.
1054 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1056 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
1057 i = Scope->PossiblyUnreachableDiags.begin(),
1058 e = Scope->PossiblyUnreachableDiags.end();
1060 const sema::PossiblyUnreachableDiag &D = *i;
1065 if (FunctionScopes.back() != Scope) {
1070 void Sema::PushCompoundScope() {
1071 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1074 void Sema::PopCompoundScope() {
1075 FunctionScopeInfo *CurFunction = getCurFunction();
1076 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1078 CurFunction->CompoundScopes.pop_back();
1081 /// \brief Determine whether any errors occurred within this function/method/
1083 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1084 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1087 BlockScopeInfo *Sema::getCurBlock() {
1088 if (FunctionScopes.empty())
1091 return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1094 LambdaScopeInfo *Sema::getCurLambda() {
1095 if (FunctionScopes.empty())
1098 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
1100 // We have a generic lambda if we parsed auto parameters, or we have
1101 // an associated template parameter list.
1102 LambdaScopeInfo *Sema::getCurGenericLambda() {
1103 if (LambdaScopeInfo *LSI = getCurLambda()) {
1104 return (LSI->AutoTemplateParams.size() ||
1105 LSI->GLTemplateParameterList) ? LSI : 0;
1111 void Sema::ActOnComment(SourceRange Comment) {
1112 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1113 SourceMgr.isInSystemHeader(Comment.getBegin()))
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 = "///<";
1125 case RawComment::RCK_OrdinaryC:
1126 MagicMarkerText = "/**<";
1129 llvm_unreachable("if this is an almost Doxygen comment, "
1130 "it should be ordinary");
1132 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1133 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1135 Context.addComment(RC);
1138 // Pin this vtable to this file.
1139 ExternalSemaSource::~ExternalSemaSource() {}
1141 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1143 void ExternalSemaSource::ReadKnownNamespaces(
1144 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1147 void ExternalSemaSource::ReadUndefinedButUsed(
1148 llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) {
1151 void 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());
1160 if (TheDecl && isa<NamedDecl>(TheDecl)) {
1161 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1163 OS << " '" << Name << '\'';
1169 /// \brief Figure out if an expression could be turned into a call.
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.
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.
1180 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1181 UnresolvedSetImpl &OverloadSet) {
1182 ZeroArgCallReturnTy = QualType();
1183 OverloadSet.clear();
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));
1190 // Ignore overloads that are pointer-to-member constants.
1191 if (FR.HasFormOfMemberPointer)
1194 Overloads = FR.Expression;
1195 } else if (E.getType() == Context.BoundMemberTy) {
1196 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1200 bool Ambiguous = false;
1203 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1204 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1205 OverloadSet.addDecl(*it);
1207 // Check whether the function is a non-template, non-member which takes no
1211 if (const FunctionDecl *OverloadDecl
1212 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1213 if (OverloadDecl->getMinRequiredArguments() == 0) {
1214 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) {
1215 ZeroArgCallReturnTy = QualType();
1218 ZeroArgCallReturnTy = OverloadDecl->getResultType();
1223 // If it's not a member, use better machinery to try to resolve the call
1225 return !ZeroArgCallReturnTy.isNull();
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,
1236 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1238 ZeroArgCallReturnTy = R.get()->getType();
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();
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>();
1260 FunTy = ExprTy->getAs<FunctionType>();
1262 if (const FunctionProtoType *FPT =
1263 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1264 if (FPT->getNumArgs() == 0)
1265 ZeroArgCallReturnTy = FunTy->getResultType();
1271 /// \brief Give notes for a set of overloads.
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.
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.
1283 static 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;
1296 NamedDecl *Fn = (*It)->getUnderlyingDecl();
1297 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1301 if (SuppressedOverloads)
1302 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1303 << SuppressedOverloads;
1306 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1307 const UnresolvedSetImpl &Overloads,
1308 bool (*IsPlausibleResult)(QualType)) {
1309 if (!IsPlausibleResult)
1310 return noteOverloads(S, Overloads, Loc);
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());
1320 noteOverloads(S, PlausibleOverloads, Loc);
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.
1327 static 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));
1335 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1337 bool (*IsPlausibleResult)(QualType)) {
1338 SourceLocation Loc = E.get()->getExprLoc();
1339 SourceRange Range = E.get()->getSourceRange();
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());
1352 << /*zero-arg*/ 1 << Range
1353 << (IsCallableWithAppend(E.get())
1354 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1356 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1358 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1360 E = ActOnCallExpr(0, E.take(), Range.getEnd(), None,
1361 Range.getEnd().getLocWithOffset(1));
1365 if (!ForceComplain) return false;
1367 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1368 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1373 IdentifierInfo *Sema::getSuperIdentifier() const {
1375 Ident_super = &Context.Idents.get("super");
1379 IdentifierInfo *Sema::getFloat128Identifier() const {
1380 if (!Ident___float128)
1381 Ident___float128 = &Context.Idents.get("__float128");
1382 return Ident___float128;
1385 void 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);
1393 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1394 if (FunctionScopes.empty())
1397 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());