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), TyposCorrected(0),
93 AnalysisWarnings(*this), CurScope(0), Ident_super(0)
97 LoadedExternalKnownNamespaces = false;
98 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
99 NSNumberLiteralMethods[I] = 0;
101 if (getLangOpts().ObjC1)
102 NSAPIObj.reset(new NSAPI(Context));
104 if (getLangOpts().CPlusPlus)
105 FieldCollector.reset(new CXXFieldCollector());
107 // Tell diagnostics how to render things from the AST library.
108 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
111 ExprEvalContexts.push_back(
112 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
115 FunctionScopes.push_back(new FunctionScopeInfo(Diags));
118 void Sema::Initialize() {
119 // Tell the AST consumer about this Sema object.
120 Consumer.Initialize(Context);
122 // FIXME: Isn't this redundant with the initialization above?
123 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
124 SC->InitializeSema(*this);
126 // Tell the external Sema source about this Sema object.
127 if (ExternalSemaSource *ExternalSema
128 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
129 ExternalSema->InitializeSema(*this);
131 // Initialize predefined 128-bit integer types, if needed.
132 if (PP.getTargetInfo().hasInt128Type()) {
133 // If either of the 128-bit integer types are unavailable to name lookup,
135 DeclarationName Int128 = &Context.Idents.get("__int128_t");
136 if (IdResolver.begin(Int128) == IdResolver.end())
137 PushOnScopeChains(Context.getInt128Decl(), TUScope);
139 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
140 if (IdResolver.begin(UInt128) == IdResolver.end())
141 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
145 // Initialize predefined Objective-C types:
146 if (PP.getLangOpts().ObjC1) {
147 // If 'SEL' does not yet refer to any declarations, make it refer to the
149 DeclarationName SEL = &Context.Idents.get("SEL");
150 if (IdResolver.begin(SEL) == IdResolver.end())
151 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
153 // If 'id' does not yet refer to any declarations, make it refer to the
155 DeclarationName Id = &Context.Idents.get("id");
156 if (IdResolver.begin(Id) == IdResolver.end())
157 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
159 // Create the built-in typedef for 'Class'.
160 DeclarationName Class = &Context.Idents.get("Class");
161 if (IdResolver.begin(Class) == IdResolver.end())
162 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
164 // Create the built-in forward declaratino for 'Protocol'.
165 DeclarationName Protocol = &Context.Idents.get("Protocol");
166 if (IdResolver.begin(Protocol) == IdResolver.end())
167 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
170 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
171 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
172 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
176 if (PackContext) FreePackedContext();
177 if (VisContext) FreeVisContext();
178 delete TheTargetAttributesSema;
179 MSStructPragmaOn = false;
180 // Kill all the active scopes.
181 for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
182 delete FunctionScopes[I];
183 if (FunctionScopes.size() == 1)
184 delete FunctionScopes[0];
186 // Tell the SemaConsumer to forget about us; we're going out of scope.
187 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
190 // Detach from the external Sema source.
191 if (ExternalSemaSource *ExternalSema
192 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
193 ExternalSema->ForgetSema();
195 // If Sema's ExternalSource is the multiplexer - we own it.
196 if (isMultiplexExternalSource)
197 delete ExternalSource;
200 /// makeUnavailableInSystemHeader - There is an error in the current
201 /// context. If we're still in a system header, and we can plausibly
202 /// make the relevant declaration unavailable instead of erroring, do
203 /// so and return true.
204 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
206 // If we're not in a function, it's an error.
207 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
208 if (!fn) return false;
210 // If we're in template instantiation, it's an error.
211 if (!ActiveTemplateInstantiations.empty())
214 // If that function's not in a system header, it's an error.
215 if (!Context.getSourceManager().isInSystemHeader(loc))
218 // If the function is already unavailable, it's not an error.
219 if (fn->hasAttr<UnavailableAttr>()) return true;
221 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
225 ASTMutationListener *Sema::getASTMutationListener() const {
226 return getASTConsumer().GetASTMutationListener();
229 ///\brief Registers an external source. If an external source already exists,
230 /// creates a multiplex external source and appends to it.
232 ///\param[in] E - A non-null external sema source.
234 void Sema::addExternalSource(ExternalSemaSource *E) {
235 assert(E && "Cannot use with NULL ptr");
237 if (!ExternalSource) {
242 if (isMultiplexExternalSource)
243 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
245 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
246 isMultiplexExternalSource = true;
250 /// \brief Print out statistics about the semantic analysis.
251 void Sema::PrintStats() const {
252 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
253 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
255 BumpAlloc.PrintStats();
256 AnalysisWarnings.PrintStats();
259 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
260 /// If there is already an implicit cast, merge into the existing one.
261 /// The result is of the given category.
262 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
263 CastKind Kind, ExprValueKind VK,
264 const CXXCastPath *BasePath,
265 CheckedConversionKind CCK) {
267 if (VK == VK_RValue && !E->isRValue()) {
270 assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
271 case CK_LValueToRValue:
272 case CK_ArrayToPointerDecay:
273 case CK_FunctionToPointerDecay:
278 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
281 QualType ExprTy = Context.getCanonicalType(E->getType());
282 QualType TypeTy = Context.getCanonicalType(Ty);
284 if (ExprTy == TypeTy)
287 if (getLangOpts().ObjCAutoRefCount)
288 CheckObjCARCConversion(SourceRange(), Ty, E, CCK);
290 // If this is a derived-to-base cast to a through a virtual base, we
292 if (Kind == CK_DerivedToBase &&
293 BasePathInvolvesVirtualBase(*BasePath)) {
294 QualType T = E->getType();
295 if (const PointerType *Pointer = T->getAs<PointerType>())
296 T = Pointer->getPointeeType();
297 if (const RecordType *RecordTy = T->getAs<RecordType>())
298 MarkVTableUsed(E->getLocStart(),
299 cast<CXXRecordDecl>(RecordTy->getDecl()));
302 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
303 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
304 ImpCast->setType(Ty);
305 ImpCast->setValueKind(VK);
310 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
313 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
314 /// to the conversion from scalar type ScalarTy to the Boolean type.
315 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
316 switch (ScalarTy->getScalarTypeKind()) {
317 case Type::STK_Bool: return CK_NoOp;
318 case Type::STK_CPointer: return CK_PointerToBoolean;
319 case Type::STK_BlockPointer: return CK_PointerToBoolean;
320 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
321 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
322 case Type::STK_Integral: return CK_IntegralToBoolean;
323 case Type::STK_Floating: return CK_FloatingToBoolean;
324 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
325 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
330 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
331 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
332 if (D->getMostRecentDecl()->isUsed())
335 if (D->hasExternalLinkage())
338 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
339 // UnusedFileScopedDecls stores the first declaration.
340 // The declaration may have become definition so check again.
341 const FunctionDecl *DeclToCheck;
342 if (FD->hasBody(DeclToCheck))
343 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
345 // Later redecls may add new information resulting in not having to warn,
347 DeclToCheck = FD->getMostRecentDecl();
348 if (DeclToCheck != FD)
349 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
352 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
353 // UnusedFileScopedDecls stores the first declaration.
354 // The declaration may have become definition so check again.
355 const VarDecl *DeclToCheck = VD->getDefinition();
357 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
359 // Later redecls may add new information resulting in not having to warn,
361 DeclToCheck = VD->getMostRecentDecl();
362 if (DeclToCheck != VD)
363 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
370 struct SortUndefinedButUsed {
371 const SourceManager &SM;
372 explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {}
374 bool operator()(const std::pair<NamedDecl *, SourceLocation> &l,
375 const std::pair<NamedDecl *, SourceLocation> &r) const {
376 if (l.second.isValid() && !r.second.isValid())
378 if (!l.second.isValid() && r.second.isValid())
380 if (l.second != r.second)
381 return SM.isBeforeInTranslationUnit(l.second, r.second);
382 return SM.isBeforeInTranslationUnit(l.first->getLocation(),
383 r.first->getLocation());
388 /// Obtains a sorted list of functions that are undefined but ODR-used.
389 void Sema::getUndefinedButUsed(
390 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
391 for (llvm::DenseMap<NamedDecl *, SourceLocation>::iterator
392 I = UndefinedButUsed.begin(), E = UndefinedButUsed.end();
394 NamedDecl *ND = I->first;
396 // Ignore attributes that have become invalid.
397 if (ND->isInvalidDecl()) continue;
399 // __attribute__((weakref)) is basically a definition.
400 if (ND->hasAttr<WeakRefAttr>()) continue;
402 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
405 if (FD->hasExternalLinkage() &&
406 !FD->getMostRecentDecl()->isInlined())
409 if (cast<VarDecl>(ND)->hasDefinition() != VarDecl::DeclarationOnly)
411 if (ND->hasExternalLinkage())
415 Undefined.push_back(std::make_pair(ND, I->second));
418 // Sort (in order of use site) so that we're not dependent on the iteration
419 // order through an llvm::DenseMap.
420 std::sort(Undefined.begin(), Undefined.end(),
421 SortUndefinedButUsed(Context.getSourceManager()));
424 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
425 /// or that are inline.
426 static void checkUndefinedButUsed(Sema &S) {
427 if (S.UndefinedButUsed.empty()) return;
429 // Collect all the still-undefined entities with internal linkage.
430 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
431 S.getUndefinedButUsed(Undefined);
432 if (Undefined.empty()) return;
434 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
435 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
436 NamedDecl *ND = I->first;
438 if (ND->getLinkage() != ExternalLinkage) {
439 S.Diag(ND->getLocation(), diag::warn_undefined_internal)
440 << isa<VarDecl>(ND) << ND;
442 assert(cast<FunctionDecl>(ND)->getMostRecentDecl()->isInlined() &&
443 "used object requires definition but isn't inline or internal?");
444 S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND;
446 if (I->second.isValid())
447 S.Diag(I->second, diag::note_used_here);
451 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
455 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
456 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
457 for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
458 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
459 = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
460 if (Pos != WeakUndeclaredIdentifiers.end())
463 WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
468 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
470 /// \brief Returns true, if all methods and nested classes of the given
471 /// CXXRecordDecl are defined in this translation unit.
473 /// Should only be called from ActOnEndOfTranslationUnit so that all
474 /// definitions are actually read.
475 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
476 RecordCompleteMap &MNCComplete) {
477 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
478 if (Cache != MNCComplete.end())
479 return Cache->second;
480 if (!RD->isCompleteDefinition())
482 bool Complete = true;
483 for (DeclContext::decl_iterator I = RD->decls_begin(),
485 I != E && Complete; ++I) {
486 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
487 Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
488 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
489 Complete = F->getTemplatedDecl()->isDefined();
490 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
491 if (R->isInjectedClassName())
493 if (R->hasDefinition())
494 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
500 MNCComplete[RD] = Complete;
504 /// \brief Returns true, if the given CXXRecordDecl is fully defined in this
505 /// translation unit, i.e. all methods are defined or pure virtual and all
506 /// friends, friend functions and nested classes are fully defined in this
507 /// translation unit.
509 /// Should only be called from ActOnEndOfTranslationUnit so that all
510 /// definitions are actually read.
511 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
512 RecordCompleteMap &RecordsComplete,
513 RecordCompleteMap &MNCComplete) {
514 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
515 if (Cache != RecordsComplete.end())
516 return Cache->second;
517 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
518 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
519 E = RD->friend_end();
520 I != E && Complete; ++I) {
521 // Check if friend classes and methods are complete.
522 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
523 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
524 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
525 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
529 // Friend functions are available through the NamedDecl of FriendDecl.
530 if (const FunctionDecl *FD =
531 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
532 Complete = FD->isDefined();
534 // This is a template friend, give up.
538 RecordsComplete[RD] = Complete;
542 /// ActOnEndOfTranslationUnit - This is called at the very end of the
543 /// translation unit when EOF is reached and all but the top-level scope is
545 void Sema::ActOnEndOfTranslationUnit() {
546 assert(DelayedDiagnostics.getCurrentPool() == NULL
547 && "reached end of translation unit with a pool attached?");
549 // If code completion is enabled, don't perform any end-of-translation-unit
551 if (PP.isCodeCompletionEnabled())
554 // Only complete translation units define vtables and perform implicit
556 if (TUKind == TU_Complete) {
557 DiagnoseUseOfUnimplementedSelectors();
559 // If any dynamic classes have their key function defined within
560 // this translation unit, then those vtables are considered "used" and must
562 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
563 E = DynamicClasses.end();
565 assert(!(*I)->isDependentType() &&
566 "Should not see dependent types here!");
567 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) {
568 const FunctionDecl *Definition = 0;
569 if (KeyFunction->hasBody(Definition))
570 MarkVTableUsed(Definition->getLocation(), *I, true);
574 // If DefinedUsedVTables ends up marking any virtual member functions it
575 // might lead to more pending template instantiations, which we then need
579 // C++: Perform implicit template instantiations.
581 // FIXME: When we perform these implicit instantiations, we do not
582 // carefully keep track of the point of instantiation (C++ [temp.point]).
583 // This means that name lookup that occurs within the template
584 // instantiation will always happen at the end of the translation unit,
585 // so it will find some names that should not be found. Although this is
586 // common behavior for C++ compilers, it is technically wrong. In the
587 // future, we either need to be able to filter the results of name lookup
588 // or we need to perform template instantiations earlier.
589 PerformPendingInstantiations();
592 // Remove file scoped decls that turned out to be used.
593 UnusedFileScopedDecls.erase(
594 std::remove_if(UnusedFileScopedDecls.begin(0, true),
595 UnusedFileScopedDecls.end(),
596 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)),
597 UnusedFileScopedDecls.end());
599 if (TUKind == TU_Prefix) {
600 // Translation unit prefixes don't need any of the checking below.
605 // Check for #pragma weak identifiers that were never declared
606 // FIXME: This will cause diagnostics to be emitted in a non-determinstic
607 // order! Iterating over a densemap like this is bad.
608 LoadExternalWeakUndeclaredIdentifiers();
609 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
610 I = WeakUndeclaredIdentifiers.begin(),
611 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
612 if (I->second.getUsed()) continue;
614 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
618 if (LangOpts.CPlusPlus11 &&
619 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
621 != DiagnosticsEngine::Ignored)
622 CheckDelegatingCtorCycles();
624 if (TUKind == TU_Module) {
625 // If we are building a module, resolve all of the exported declarations
627 if (Module *CurrentModule = PP.getCurrentModule()) {
628 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
630 SmallVector<Module *, 2> Stack;
631 Stack.push_back(CurrentModule);
632 while (!Stack.empty()) {
633 Module *Mod = Stack.back();
636 // Resolve the exported declarations and conflicts.
637 // FIXME: Actually complain, once we figure out how to teach the
638 // diagnostic client to deal with complaints in the module map at this
640 ModMap.resolveExports(Mod, /*Complain=*/false);
641 ModMap.resolveConflicts(Mod, /*Complain=*/false);
643 // Queue the submodules, so their exports will also be resolved.
644 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
645 SubEnd = Mod->submodule_end();
646 Sub != SubEnd; ++Sub) {
647 Stack.push_back(*Sub);
652 // Modules don't need any of the checking below.
658 // A declaration of an identifier for an object that has file
659 // scope without an initializer, and without a storage-class
660 // specifier or with the storage-class specifier static,
661 // constitutes a tentative definition. If a translation unit
662 // contains one or more tentative definitions for an identifier,
663 // and the translation unit contains no external definition for
664 // that identifier, then the behavior is exactly as if the
665 // translation unit contains a file scope declaration of that
666 // identifier, with the composite type as of the end of the
667 // translation unit, with an initializer equal to 0.
668 llvm::SmallSet<VarDecl *, 32> Seen;
669 for (TentativeDefinitionsType::iterator
670 T = TentativeDefinitions.begin(ExternalSource),
671 TEnd = TentativeDefinitions.end();
674 VarDecl *VD = (*T)->getActingDefinition();
676 // If the tentative definition was completed, getActingDefinition() returns
677 // null. If we've already seen this variable before, insert()'s second
678 // return value is false.
679 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
682 if (const IncompleteArrayType *ArrayT
683 = Context.getAsIncompleteArrayType(VD->getType())) {
684 if (RequireCompleteType(VD->getLocation(),
685 ArrayT->getElementType(),
686 diag::err_tentative_def_incomplete_type_arr)) {
687 VD->setInvalidDecl();
691 // Set the length of the array to 1 (C99 6.9.2p5).
692 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
693 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
694 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
695 One, ArrayType::Normal, 0);
697 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
698 diag::err_tentative_def_incomplete_type))
699 VD->setInvalidDecl();
701 CheckCompleteVariableDeclaration(VD);
703 // Notify the consumer that we've completed a tentative definition.
704 if (!VD->isInvalidDecl())
705 Consumer.CompleteTentativeDefinition(VD);
709 // If there were errors, disable 'unused' warnings since they will mostly be
711 if (!Diags.hasErrorOccurred()) {
712 // Output warning for unused file scoped decls.
713 for (UnusedFileScopedDeclsType::iterator
714 I = UnusedFileScopedDecls.begin(ExternalSource),
715 E = UnusedFileScopedDecls.end(); I != E; ++I) {
716 if (ShouldRemoveFromUnused(this, *I))
719 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
720 const FunctionDecl *DiagD;
721 if (!FD->hasBody(DiagD))
723 if (DiagD->isDeleted())
724 continue; // Deleted functions are supposed to be unused.
725 if (DiagD->isReferenced()) {
726 if (isa<CXXMethodDecl>(DiagD))
727 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
728 << DiagD->getDeclName();
730 if (FD->getStorageClass() == SC_Static &&
731 !FD->isInlineSpecified() &&
732 !SourceMgr.isFromMainFile(
733 SourceMgr.getExpansionLoc(FD->getLocation())))
734 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
735 << DiagD->getDeclName();
737 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
738 << /*function*/0 << DiagD->getDeclName();
741 Diag(DiagD->getLocation(),
742 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
743 : diag::warn_unused_function)
744 << DiagD->getDeclName();
747 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
749 DiagD = cast<VarDecl>(*I);
750 if (DiagD->isReferenced()) {
751 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
752 << /*variable*/1 << DiagD->getDeclName();
753 } else if (getSourceManager().isFromMainFile(DiagD->getLocation())) {
754 // If the declaration is in a header which is included into multiple
755 // TUs, it will declare one variable per TU, and one of the other
756 // variables may be used. So, only warn if the declaration is in the
758 Diag(DiagD->getLocation(), diag::warn_unused_variable)
759 << DiagD->getDeclName();
765 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
766 checkUndefinedButUsed(*this);
769 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
771 != DiagnosticsEngine::Ignored) {
772 RecordCompleteMap RecordsComplete;
773 RecordCompleteMap MNCComplete;
774 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
775 E = UnusedPrivateFields.end(); I != E; ++I) {
776 const NamedDecl *D = *I;
777 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
778 if (RD && !RD->isUnion() &&
779 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
780 Diag(D->getLocation(), diag::warn_unused_private_field)
786 // Check we've noticed that we're no longer parsing the initializer for every
787 // variable. If we miss cases, then at best we have a performance issue and
788 // at worst a rejects-valid bug.
789 assert(ParsingInitForAutoVars.empty() &&
790 "Didn't unmark var as having its initializer parsed");
796 //===----------------------------------------------------------------------===//
798 //===----------------------------------------------------------------------===//
800 DeclContext *Sema::getFunctionLevelDeclContext() {
801 DeclContext *DC = CurContext;
804 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
805 DC = DC->getParent();
806 } else if (isa<CXXMethodDecl>(DC) &&
807 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
808 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
809 DC = DC->getParent()->getParent();
817 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
818 /// to the function decl for the function being parsed. If we're currently
819 /// in a 'block', this returns the containing context.
820 FunctionDecl *Sema::getCurFunctionDecl() {
821 DeclContext *DC = getFunctionLevelDeclContext();
822 return dyn_cast<FunctionDecl>(DC);
825 ObjCMethodDecl *Sema::getCurMethodDecl() {
826 DeclContext *DC = getFunctionLevelDeclContext();
827 return dyn_cast<ObjCMethodDecl>(DC);
830 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
831 DeclContext *DC = getFunctionLevelDeclContext();
832 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
833 return cast<NamedDecl>(DC);
837 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
838 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
839 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
840 // been made more painfully obvious by the refactor that introduced this
841 // function, but it is possible that the incoming argument can be
842 // eliminnated. If it truly cannot be (for example, there is some reentrancy
843 // issue I am not seeing yet), then there should at least be a clarifying
844 // comment somewhere.
845 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
846 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
847 Diags.getCurrentDiagID())) {
848 case DiagnosticIDs::SFINAE_Report:
849 // We'll report the diagnostic below.
852 case DiagnosticIDs::SFINAE_SubstitutionFailure:
853 // Count this failure so that we know that template argument deduction
857 // Make a copy of this suppressed diagnostic and store it with the
858 // template-deduction information.
859 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
860 Diagnostic DiagInfo(&Diags);
861 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
862 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
865 Diags.setLastDiagnosticIgnored();
869 case DiagnosticIDs::SFINAE_AccessControl: {
870 // Per C++ Core Issue 1170, access control is part of SFINAE.
871 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
872 // make access control a part of SFINAE for the purposes of checking
874 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
877 SourceLocation Loc = Diags.getCurrentDiagLoc();
879 // Suppress this diagnostic.
882 // Make a copy of this suppressed diagnostic and store it with the
883 // template-deduction information.
884 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
885 Diagnostic DiagInfo(&Diags);
886 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
887 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
890 Diags.setLastDiagnosticIgnored();
893 // Now the diagnostic state is clear, produce a C++98 compatibility
895 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
897 // The last diagnostic which Sema produced was ignored. Suppress any
898 // notes attached to it.
899 Diags.setLastDiagnosticIgnored();
903 case DiagnosticIDs::SFINAE_Suppress:
904 // Make a copy of this suppressed diagnostic and store it with the
905 // template-deduction information;
907 Diagnostic DiagInfo(&Diags);
908 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
909 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
912 // Suppress this diagnostic.
913 Diags.setLastDiagnosticIgnored();
919 // Set up the context's printing policy based on our current state.
920 Context.setPrintingPolicy(getPrintingPolicy());
922 // Emit the diagnostic.
923 if (!Diags.EmitCurrentDiagnostic())
926 // If this is not a note, and we're in a template instantiation
927 // that is different from the last template instantiation where
928 // we emitted an error, print a template instantiation
930 if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
931 !ActiveTemplateInstantiations.empty() &&
932 ActiveTemplateInstantiations.back()
933 != LastTemplateInstantiationErrorContext) {
934 PrintInstantiationStack();
935 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
939 Sema::SemaDiagnosticBuilder
940 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
941 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
947 /// \brief Looks through the macro-expansion chain for the given
948 /// location, looking for a macro expansion with the given name.
949 /// If one is found, returns true and sets the location to that
951 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
952 SourceLocation loc = locref;
953 if (!loc.isMacroID()) return false;
955 // There's no good way right now to look at the intermediate
956 // expansions, so just jump to the expansion location.
957 loc = getSourceManager().getExpansionLoc(loc);
959 // If that's written with the name, stop here.
960 SmallVector<char, 16> buffer;
961 if (getPreprocessor().getSpelling(loc, buffer) == name) {
968 /// \brief Determines the active Scope associated with the given declaration
971 /// This routine maps a declaration context to the active Scope object that
972 /// represents that declaration context in the parser. It is typically used
973 /// from "scope-less" code (e.g., template instantiation, lazy creation of
974 /// declarations) that injects a name for name-lookup purposes and, therefore,
975 /// must update the Scope.
977 /// \returns The scope corresponding to the given declaraion context, or NULL
978 /// if no such scope is open.
979 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
984 Ctx = Ctx->getPrimaryContext();
985 for (Scope *S = getCurScope(); S; S = S->getParent()) {
986 // Ignore scopes that cannot have declarations. This is important for
987 // out-of-line definitions of static class members.
988 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
989 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
990 if (Ctx == Entity->getPrimaryContext())
997 /// \brief Enter a new function scope
998 void Sema::PushFunctionScope() {
999 if (FunctionScopes.size() == 1) {
1000 // Use the "top" function scope rather than having to allocate
1001 // memory for a new scope.
1002 FunctionScopes.back()->Clear();
1003 FunctionScopes.push_back(FunctionScopes.back());
1007 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1010 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1011 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1012 BlockScope, Block));
1015 void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
1016 CXXMethodDecl *CallOperator) {
1017 FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
1021 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1022 const Decl *D, const BlockExpr *blkExpr) {
1023 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1024 assert(!FunctionScopes.empty() && "mismatched push/pop!");
1026 // Issue any analysis-based warnings.
1028 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1030 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
1031 i = Scope->PossiblyUnreachableDiags.begin(),
1032 e = Scope->PossiblyUnreachableDiags.end();
1034 const sema::PossiblyUnreachableDiag &D = *i;
1039 if (FunctionScopes.back() != Scope) {
1044 void Sema::PushCompoundScope() {
1045 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1048 void Sema::PopCompoundScope() {
1049 FunctionScopeInfo *CurFunction = getCurFunction();
1050 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1052 CurFunction->CompoundScopes.pop_back();
1055 /// \brief Determine whether any errors occurred within this function/method/
1057 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1058 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1061 BlockScopeInfo *Sema::getCurBlock() {
1062 if (FunctionScopes.empty())
1065 return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1068 LambdaScopeInfo *Sema::getCurLambda() {
1069 if (FunctionScopes.empty())
1072 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
1075 void Sema::ActOnComment(SourceRange Comment) {
1076 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1077 SourceMgr.isInSystemHeader(Comment.getBegin()))
1079 RawComment RC(SourceMgr, Comment, false,
1080 LangOpts.CommentOpts.ParseAllComments);
1081 if (RC.isAlmostTrailingComment()) {
1082 SourceRange MagicMarkerRange(Comment.getBegin(),
1083 Comment.getBegin().getLocWithOffset(3));
1084 StringRef MagicMarkerText;
1085 switch (RC.getKind()) {
1086 case RawComment::RCK_OrdinaryBCPL:
1087 MagicMarkerText = "///<";
1089 case RawComment::RCK_OrdinaryC:
1090 MagicMarkerText = "/**<";
1093 llvm_unreachable("if this is an almost Doxygen comment, "
1094 "it should be ordinary");
1096 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1097 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1099 Context.addComment(RC);
1102 // Pin this vtable to this file.
1103 ExternalSemaSource::~ExternalSemaSource() {}
1105 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1107 void ExternalSemaSource::ReadKnownNamespaces(
1108 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1111 void ExternalSemaSource::ReadUndefinedButUsed(
1112 llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) {
1115 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
1116 SourceLocation Loc = this->Loc;
1117 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1118 if (Loc.isValid()) {
1119 Loc.print(OS, S.getSourceManager());
1124 if (TheDecl && isa<NamedDecl>(TheDecl)) {
1125 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1127 OS << " '" << Name << '\'';
1133 /// \brief Figure out if an expression could be turned into a call.
1135 /// Use this when trying to recover from an error where the programmer may have
1136 /// written just the name of a function instead of actually calling it.
1138 /// \param E - The expression to examine.
1139 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1140 /// with no arguments, this parameter is set to the type returned by such a
1141 /// call; otherwise, it is set to an empty QualType.
1142 /// \param OverloadSet - If the expression is an overloaded function
1143 /// name, this parameter is populated with the decls of the various overloads.
1144 bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
1145 UnresolvedSetImpl &OverloadSet) {
1146 ZeroArgCallReturnTy = QualType();
1147 OverloadSet.clear();
1149 if (E.getType() == Context.OverloadTy) {
1150 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1151 const OverloadExpr *Overloads = FR.Expression;
1153 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1154 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1155 OverloadSet.addDecl(*it);
1157 // Check whether the function is a non-template which takes no
1159 if (const FunctionDecl *OverloadDecl
1160 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1161 if (OverloadDecl->getMinRequiredArguments() == 0)
1162 ZeroArgCallReturnTy = OverloadDecl->getResultType();
1166 // Ignore overloads that are pointer-to-member constants.
1167 if (FR.HasFormOfMemberPointer)
1173 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1174 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1175 if (Fun->getMinRequiredArguments() == 0)
1176 ZeroArgCallReturnTy = Fun->getResultType();
1181 // We don't have an expression that's convenient to get a FunctionDecl from,
1182 // but we can at least check if the type is "function of 0 arguments".
1183 QualType ExprTy = E.getType();
1184 const FunctionType *FunTy = NULL;
1185 QualType PointeeTy = ExprTy->getPointeeType();
1186 if (!PointeeTy.isNull())
1187 FunTy = PointeeTy->getAs<FunctionType>();
1189 FunTy = ExprTy->getAs<FunctionType>();
1190 if (!FunTy && ExprTy == Context.BoundMemberTy) {
1191 // Look for the bound-member type. If it's still overloaded, give up,
1192 // although we probably should have fallen into the OverloadExpr case above
1193 // if we actually have an overloaded bound member.
1194 QualType BoundMemberTy = Expr::findBoundMemberType(&E);
1195 if (!BoundMemberTy.isNull())
1196 FunTy = BoundMemberTy->castAs<FunctionType>();
1199 if (const FunctionProtoType *FPT =
1200 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1201 if (FPT->getNumArgs() == 0)
1202 ZeroArgCallReturnTy = FunTy->getResultType();
1208 /// \brief Give notes for a set of overloads.
1210 /// A companion to isExprCallable. In cases when the name that the programmer
1211 /// wrote was an overloaded function, we may be able to make some guesses about
1212 /// plausible overloads based on their return types; such guesses can be handed
1213 /// off to this method to be emitted as notes.
1215 /// \param Overloads - The overloads to note.
1216 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1217 /// -fshow-overloads=best, this is the location to attach to the note about too
1218 /// many candidates. Typically this will be the location of the original
1219 /// ill-formed expression.
1220 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1221 const SourceLocation FinalNoteLoc) {
1222 int ShownOverloads = 0;
1223 int SuppressedOverloads = 0;
1224 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1225 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1226 // FIXME: Magic number for max shown overloads stolen from
1227 // OverloadCandidateSet::NoteCandidates.
1228 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1229 ++SuppressedOverloads;
1233 NamedDecl *Fn = (*It)->getUnderlyingDecl();
1234 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1238 if (SuppressedOverloads)
1239 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1240 << SuppressedOverloads;
1243 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1244 const UnresolvedSetImpl &Overloads,
1245 bool (*IsPlausibleResult)(QualType)) {
1246 if (!IsPlausibleResult)
1247 return noteOverloads(S, Overloads, Loc);
1249 UnresolvedSet<2> PlausibleOverloads;
1250 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1251 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1252 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1253 QualType OverloadResultTy = OverloadDecl->getResultType();
1254 if (IsPlausibleResult(OverloadResultTy))
1255 PlausibleOverloads.addDecl(It.getDecl());
1257 noteOverloads(S, PlausibleOverloads, Loc);
1260 /// Determine whether the given expression can be called by just
1261 /// putting parentheses after it. Notably, expressions with unary
1262 /// operators can't be because the unary operator will start parsing
1263 /// outside the call.
1264 static bool IsCallableWithAppend(Expr *E) {
1265 E = E->IgnoreImplicit();
1266 return (!isa<CStyleCastExpr>(E) &&
1267 !isa<UnaryOperator>(E) &&
1268 !isa<BinaryOperator>(E) &&
1269 !isa<CXXOperatorCallExpr>(E));
1272 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1274 bool (*IsPlausibleResult)(QualType)) {
1275 SourceLocation Loc = E.get()->getExprLoc();
1276 SourceRange Range = E.get()->getSourceRange();
1278 QualType ZeroArgCallTy;
1279 UnresolvedSet<4> Overloads;
1280 if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
1281 !ZeroArgCallTy.isNull() &&
1282 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1283 // At this point, we know E is potentially callable with 0
1284 // arguments and that it returns something of a reasonable type,
1285 // so we can emit a fixit and carry on pretending that E was
1286 // actually a CallExpr.
1287 SourceLocation ParenInsertionLoc =
1288 PP.getLocForEndOfToken(Range.getEnd());
1290 << /*zero-arg*/ 1 << Range
1291 << (IsCallableWithAppend(E.get())
1292 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1294 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1296 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1298 E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
1299 None, ParenInsertionLoc.getLocWithOffset(1));
1303 if (!ForceComplain) return false;
1305 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1306 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1311 IdentifierInfo *Sema::getSuperIdentifier() const {
1313 Ident_super = &Context.Idents.get("super");
1317 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
1318 CapturedRegionKind K) {
1319 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD,
1320 CD->getContextParam(), K);
1321 CSI->ReturnType = Context.VoidTy;
1322 FunctionScopes.push_back(CSI);
1325 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1326 if (FunctionScopes.empty())
1329 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());