blob: c0482767cafa4ec9f8da3c655c64c3eddd0a4f20 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
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
John McCall9c3087b2010-08-26 02:13:20 +000015#include "clang/Sema/SemaInternal.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000016#include "TargetAttributesSema.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000017#include "clang/AST/ASTContext.h"
Douglas Gregor79a9a342010-02-09 22:26:47 +000018#include "clang/AST/ASTDiagnostic.h"
John McCall384aff82010-08-25 07:42:41 +000019#include "clang/AST/DeclCXX.h"
Daniel Jasperf8cc02e2012-06-06 08:32:04 +000020#include "clang/AST/DeclFriend.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000021#include "clang/AST/DeclObjC.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000022#include "clang/AST/Expr.h"
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +000023#include "clang/AST/ExprCXX.h"
Chris Lattnerad8dcf42011-02-17 07:39:24 +000024#include "clang/AST/StmtCXX.h"
Douglas Gregorf7572a62011-09-20 18:13:03 +000025#include "clang/Basic/FileManager.h"
Anders Carlsson91a0cc92009-08-26 22:33:56 +000026#include "clang/Basic/PartialDiagnostic.h"
Chris Lattner4d150c82009-04-30 06:18:40 +000027#include "clang/Basic/TargetInfo.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000028#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"
Reid Spencer5f016e22007-07-11 17:01:13 +000044using namespace clang;
John McCall781472f2010-08-25 08:40:02 +000045using namespace sema;
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +000046
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +000047PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
48 const Preprocessor &PP) {
Douglas Gregor8987b232011-09-27 23:30:47 +000049 PrintingPolicy Policy = Context.getPrintingPolicy();
David Blaikie4e4d0842012-03-11 07:00:24 +000050 Policy.Bool = Context.getLangOpts().Bool;
Douglas Gregor8987b232011-09-27 23:30:47 +000051 if (!Policy.Bool) {
52 if (MacroInfo *BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) {
Michael Gottesman0116a402013-01-20 01:04:14 +000053 Policy.Bool = BoolMacro->isObjectLike() &&
Douglas Gregor8987b232011-09-27 23:30:47 +000054 BoolMacro->getNumTokens() == 1 &&
55 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
56 }
57 }
Michael Gottesman0116a402013-01-20 01:04:14 +000058
Douglas Gregor8987b232011-09-27 23:30:47 +000059 return Policy;
60}
61
Douglas Gregorc1a3e5e2010-08-25 18:07:12 +000062void Sema::ActOnTranslationUnitScope(Scope *S) {
Steve Naroffb216c882007-10-09 22:01:59 +000063 TUScope = S;
Douglas Gregor44b43212008-12-11 16:49:14 +000064 PushDeclContext(S, Context.getTranslationUnitDecl());
Mike Stump1eb44332009-09-09 15:08:12 +000065
John McCallc7e04da2010-05-28 18:45:08 +000066 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
Steve Naroff3b950172007-10-10 21:53:07 +000067}
68
Douglas Gregorf807fe02009-04-14 16:27:31 +000069Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Douglas Gregor467dc882011-08-25 22:30:56 +000070 TranslationUnitKind TUKind,
Daniel Dunbar3a2838d2009-11-13 08:58:20 +000071 CodeCompleteConsumer *CodeCompleter)
Michael Gottesman0116a402013-01-20 01:04:14 +000072 : TheTargetAttributesSema(0), ExternalSource(0),
Axel Naumann0ec56b72012-10-18 19:05:02 +000073 isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()),
David Blaikie4e4d0842012-03-11 07:00:24 +000074 LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
Mike Stump1eb44332009-09-09 15:08:12 +000075 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
Axel Naumann0ec56b72012-10-18 19:05:02 +000076 CollectStats(false), CodeCompleter(CodeCompleter),
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +000077 CurContext(0), OriginalLexicalContext(0),
78 PackContext(0), MSStructPragmaOn(false), VisContext(0),
Richard Smithe49ff3e2012-09-25 04:46:05 +000079 IsBuildingRecoveryCallExpr(false),
John McCall80ee6e82011-11-10 05:35:25 +000080 ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
Sebastian Redl395e04d2012-01-17 22:49:33 +000081 IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
Benjamin Kramer471131a2012-04-22 20:43:35 +000082 NSNumberDecl(0),
83 NSStringDecl(0), StringWithUTF8StringMethod(0),
84 NSArrayDecl(0), ArrayWithObjectsMethod(0),
Ted Kremenekebcb57a2012-03-06 20:05:56 +000085 NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
Michael Gottesman0116a402013-01-20 01:04:14 +000086 GlobalNewDeleteDeclared(false),
Douglas Gregor467dc882011-08-25 22:30:56 +000087 TUKind(TUKind),
John McCall13489672012-05-07 06:16:58 +000088 NumSFINAEErrors(0), InFunctionDeclarator(0),
Douglas Gregor1eee5dc2011-01-27 22:31:44 +000089 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
Douglas Gregor8491ffe2010-12-20 22:05:00 +000090 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
91 CurrentInstantiationScope(0), TyposCorrected(0),
Bill Wendlingb7566d82010-09-08 21:30:16 +000092 AnalysisWarnings(*this)
Douglas Gregorf35f8282009-11-11 21:54:23 +000093{
Steve Naroff3b950172007-10-10 21:53:07 +000094 TUScope = 0;
Michael Gottesman0116a402013-01-20 01:04:14 +000095
Douglas Gregord8bba9c2011-06-28 16:20:02 +000096 LoadedExternalKnownNamespaces = false;
Ted Kremenekebcb57a2012-03-06 20:05:56 +000097 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
98 NSNumberLiteralMethods[I] = 0;
99
David Blaikie4e4d0842012-03-11 07:00:24 +0000100 if (getLangOpts().ObjC1)
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000101 NSAPIObj.reset(new NSAPI(Context));
102
David Blaikie4e4d0842012-03-11 07:00:24 +0000103 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000104 FieldCollector.reset(new CXXFieldCollector());
Mike Stump1eb44332009-09-09 15:08:12 +0000105
Chris Lattner22caddc2008-11-23 09:13:29 +0000106 // Tell diagnostics how to render things from the AST library.
Michael Gottesman0116a402013-01-20 01:04:14 +0000107 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
Douglas Gregor79a9a342010-02-09 22:26:47 +0000108 &Context);
Douglas Gregor2afce722009-11-26 00:44:06 +0000109
110 ExprEvalContexts.push_back(
Richard Smith76f3f692012-02-22 02:04:18 +0000111 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
112 false, 0, false));
John McCall781472f2010-08-25 08:40:02 +0000113
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000114 FunctionScopes.push_back(new FunctionScopeInfo(Diags));
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000115}
116
117void Sema::Initialize() {
118 // Tell the AST consumer about this Sema object.
119 Consumer.Initialize(Context);
Michael Gottesman0116a402013-01-20 01:04:14 +0000120
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000121 // FIXME: Isn't this redundant with the initialization above?
122 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
123 SC->InitializeSema(*this);
Michael Gottesman0116a402013-01-20 01:04:14 +0000124
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000125 // Tell the external Sema source about this Sema object.
126 if (ExternalSemaSource *ExternalSema
127 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
128 ExternalSema->InitializeSema(*this);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000129
Douglas Gregor772eeae2011-08-12 06:49:56 +0000130 // Initialize predefined 128-bit integer types, if needed.
Richard Smith84268902012-11-29 05:41:51 +0000131 if (PP.getTargetInfo().hasInt128Type()) {
Douglas Gregor772eeae2011-08-12 06:49:56 +0000132 // If either of the 128-bit integer types are unavailable to name lookup,
133 // define them now.
134 DeclarationName Int128 = &Context.Idents.get("__int128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000135 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000136 PushOnScopeChains(Context.getInt128Decl(), TUScope);
137
138 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000139 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000140 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
141 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000142
Douglas Gregor772eeae2011-08-12 06:49:56 +0000143
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000144 // Initialize predefined Objective-C types:
David Blaikie4e4d0842012-03-11 07:00:24 +0000145 if (PP.getLangOpts().ObjC1) {
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000146 // If 'SEL' does not yet refer to any declarations, make it refer to the
147 // predefined 'SEL'.
148 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000149 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000150 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
151
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000152 // If 'id' does not yet refer to any declarations, make it refer to the
153 // predefined 'id'.
154 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000155 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000156 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesman0116a402013-01-20 01:04:14 +0000157
Douglas Gregor79d67262011-08-12 05:59:41 +0000158 // Create the built-in typedef for 'Class'.
159 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000160 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor79d67262011-08-12 05:59:41 +0000161 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregora6ea10e2012-01-17 18:09:05 +0000162
163 // Create the built-in forward declaratino for 'Protocol'.
164 DeclarationName Protocol = &Context.Idents.get("Protocol");
165 if (IdResolver.begin(Protocol) == IdResolver.end())
166 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000167 }
Meador Ingec5613b22012-06-16 03:34:49 +0000168
169 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
170 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
171 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Reid Spencer5f016e22007-07-11 17:01:13 +0000172}
173
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000174Sema::~Sema() {
175 if (PackContext) FreePackedContext();
Eli Friedmanaa8b0d12010-08-05 06:57:20 +0000176 if (VisContext) FreeVisContext();
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000177 delete TheTargetAttributesSema;
Fariborz Jahanian62c92582011-04-25 18:49:15 +0000178 MSStructPragmaOn = false;
John McCall781472f2010-08-25 08:40:02 +0000179 // Kill all the active scopes.
180 for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
181 delete FunctionScopes[I];
182 if (FunctionScopes.size() == 1)
183 delete FunctionScopes[0];
Michael Gottesman0116a402013-01-20 01:04:14 +0000184
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000185 // Tell the SemaConsumer to forget about us; we're going out of scope.
186 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
187 SC->ForgetSema();
188
189 // Detach from the external Sema source.
190 if (ExternalSemaSource *ExternalSema
Douglas Gregor914ed9d2010-08-13 03:15:25 +0000191 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000192 ExternalSema->ForgetSema();
Axel Naumann0ec56b72012-10-18 19:05:02 +0000193
194 // If Sema's ExternalSource is the multiplexer - we own it.
195 if (isMultiplexExternalSource)
196 delete ExternalSource;
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000197}
198
John McCallf85e1932011-06-15 23:02:42 +0000199/// makeUnavailableInSystemHeader - There is an error in the current
200/// context. If we're still in a system header, and we can plausibly
201/// make the relevant declaration unavailable instead of erroring, do
202/// so and return true.
203bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000204 StringRef msg) {
John McCallf85e1932011-06-15 23:02:42 +0000205 // If we're not in a function, it's an error.
206 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
207 if (!fn) return false;
208
209 // If we're in template instantiation, it's an error.
210 if (!ActiveTemplateInstantiations.empty())
211 return false;
Michael Gottesman0116a402013-01-20 01:04:14 +0000212
John McCallf85e1932011-06-15 23:02:42 +0000213 // If that function's not in a system header, it's an error.
214 if (!Context.getSourceManager().isInSystemHeader(loc))
215 return false;
216
217 // If the function is already unavailable, it's not an error.
218 if (fn->hasAttr<UnavailableAttr>()) return true;
219
220 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
221 return true;
222}
223
Sebastian Redl58a2cd82011-04-24 16:28:06 +0000224ASTMutationListener *Sema::getASTMutationListener() const {
225 return getASTConsumer().GetASTMutationListener();
226}
227
Axel Naumann0ec56b72012-10-18 19:05:02 +0000228///\brief Registers an external source. If an external source already exists,
229/// creates a multiplex external source and appends to it.
230///
231///\param[in] E - A non-null external sema source.
232///
233void Sema::addExternalSource(ExternalSemaSource *E) {
234 assert(E && "Cannot use with NULL ptr");
235
236 if (!ExternalSource) {
237 ExternalSource = E;
238 return;
239 }
240
241 if (isMultiplexExternalSource)
242 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
243 else {
244 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
245 isMultiplexExternalSource = true;
246 }
247}
248
Chandler Carruth5d989942011-07-06 16:21:37 +0000249/// \brief Print out statistics about the semantic analysis.
250void Sema::PrintStats() const {
251 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
252 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
253
254 BumpAlloc.PrintStats();
255 AnalysisWarnings.PrintStats();
256}
257
Richard Smithc8d7f582011-11-29 22:48:16 +0000258/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
259/// If there is already an implicit cast, merge into the existing one.
260/// The result is of the given category.
261ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
262 CastKind Kind, ExprValueKind VK,
263 const CXXCastPath *BasePath,
264 CheckedConversionKind CCK) {
Richard Smith9c129f82011-10-28 03:31:48 +0000265#ifndef NDEBUG
266 if (VK == VK_RValue && !E->isRValue()) {
267 switch (Kind) {
268 default:
269 assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
270 case CK_LValueToRValue:
271 case CK_ArrayToPointerDecay:
272 case CK_FunctionToPointerDecay:
273 case CK_ToVoid:
274 break;
275 }
276 }
Richard Smithacdfa4d2011-11-10 23:32:36 +0000277 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
Richard Smith9c129f82011-10-28 03:31:48 +0000278#endif
279
John Wiegley429bb272011-04-08 18:41:53 +0000280 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang3a2c7442008-09-04 08:38:01 +0000281 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000282
Mon P Wang3a2c7442008-09-04 08:38:01 +0000283 if (ExprTy == TypeTy)
John Wiegley429bb272011-04-08 18:41:53 +0000284 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000285
David Blaikie4e4d0842012-03-11 07:00:24 +0000286 if (getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +0000287 CheckObjCARCConversion(SourceRange(), Ty, E, CCK);
288
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000289 // If this is a derived-to-base cast to a through a virtual base, we
290 // need a vtable.
Michael Gottesman0116a402013-01-20 01:04:14 +0000291 if (Kind == CK_DerivedToBase &&
John McCallf871d0c2010-08-07 06:22:56 +0000292 BasePathInvolvesVirtualBase(*BasePath)) {
John Wiegley429bb272011-04-08 18:41:53 +0000293 QualType T = E->getType();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000294 if (const PointerType *Pointer = T->getAs<PointerType>())
295 T = Pointer->getPointeeType();
296 if (const RecordType *RecordTy = T->getAs<RecordType>())
Michael Gottesman0116a402013-01-20 01:04:14 +0000297 MarkVTableUsed(E->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000298 cast<CXXRecordDecl>(RecordTy->getDecl()));
299 }
Anders Carlsson4c5fad32009-09-15 05:28:24 +0000300
Richard Smithc8d7f582011-11-29 22:48:16 +0000301 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
302 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
303 ImpCast->setType(Ty);
304 ImpCast->setValueKind(VK);
305 return Owned(E);
306 }
307 }
308
309 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
Sebastian Redl906082e2010-07-20 04:20:21 +0000310}
311
Abramo Bagnara737d5442011-04-07 09:26:19 +0000312/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
313/// to the conversion from scalar type ScalarTy to the Boolean type.
314CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
315 switch (ScalarTy->getScalarTypeKind()) {
316 case Type::STK_Bool: return CK_NoOp;
John McCall1d9b3b22011-09-09 05:25:32 +0000317 case Type::STK_CPointer: return CK_PointerToBoolean;
318 case Type::STK_BlockPointer: return CK_PointerToBoolean;
319 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara737d5442011-04-07 09:26:19 +0000320 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
321 case Type::STK_Integral: return CK_IntegralToBoolean;
322 case Type::STK_Floating: return CK_FloatingToBoolean;
323 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
324 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
325 }
326 return CK_Invalid;
327}
328
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000329/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
330static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindolab9725cf2013-01-08 19:43:34 +0000331 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000332 return true;
333
334 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
335 // UnusedFileScopedDecls stores the first declaration.
336 // The declaration may have become definition so check again.
337 const FunctionDecl *DeclToCheck;
338 if (FD->hasBody(DeclToCheck))
339 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
340
341 // Later redecls may add new information resulting in not having to warn,
342 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000343 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000344 if (DeclToCheck != FD)
345 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
346 }
347
348 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
349 // UnusedFileScopedDecls stores the first declaration.
350 // The declaration may have become definition so check again.
Michael Gottesman0116a402013-01-20 01:04:14 +0000351 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000352 if (DeclToCheck)
353 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
354
355 // Later redecls may add new information resulting in not having to warn,
356 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000357 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000358 if (DeclToCheck != VD)
359 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
360 }
361
Rafael Espindola87b81272012-12-30 21:42:26 +0000362 if (D->getLinkage() == ExternalLinkage)
363 return true;
364
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000365 return false;
366}
367
John McCall15e310a2011-02-19 02:53:41 +0000368namespace {
369 struct UndefinedInternal {
370 NamedDecl *decl;
371 FullSourceLoc useLoc;
372
373 UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
374 : decl(decl), useLoc(useLoc) {}
375 };
376
377 bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) {
378 return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc);
379 }
380}
381
382/// checkUndefinedInternals - Check for undefined objects with internal linkage.
383static void checkUndefinedInternals(Sema &S) {
384 if (S.UndefinedInternals.empty()) return;
385
386 // Collect all the still-undefined entities with internal linkage.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000387 SmallVector<UndefinedInternal, 16> undefined;
Nick Lewycky01a41142013-01-26 00:35:08 +0000388 for (llvm::MapVector<NamedDecl*,SourceLocation>::iterator
John McCall15e310a2011-02-19 02:53:41 +0000389 i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end();
390 i != e; ++i) {
391 NamedDecl *decl = i->first;
392
393 // Ignore attributes that have become invalid.
394 if (decl->isInvalidDecl()) continue;
395
Rafael Espindola9f409542012-12-29 23:43:00 +0000396 // If we found out that the decl is external, don't warn.
397 if (decl->getLinkage() == ExternalLinkage) continue;
398
John McCall15e310a2011-02-19 02:53:41 +0000399 // __attribute__((weakref)) is basically a definition.
400 if (decl->hasAttr<WeakRefAttr>()) continue;
401
402 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
403 if (fn->isPure() || fn->hasBody())
404 continue;
405 } else {
406 if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly)
407 continue;
408 }
409
John McCall15e310a2011-02-19 02:53:41 +0000410 S.Diag(decl->getLocation(), diag::warn_undefined_internal)
411 << isa<VarDecl>(decl) << decl;
Nick Lewycky01a41142013-01-26 00:35:08 +0000412 S.Diag(i->second, diag::note_used_here);
John McCall15e310a2011-02-19 02:53:41 +0000413 }
414}
415
Douglas Gregor31e37b22011-07-28 18:09:57 +0000416void Sema::LoadExternalWeakUndeclaredIdentifiers() {
417 if (!ExternalSource)
418 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000419
Douglas Gregor31e37b22011-07-28 18:09:57 +0000420 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
421 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
422 for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
423 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
424 = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
425 if (Pos != WeakUndeclaredIdentifiers.end())
426 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000427
Douglas Gregor31e37b22011-07-28 18:09:57 +0000428 WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
429 }
430}
431
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000432
433typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
434
435/// \brief Returns true, if all methods and nested classes of the given
436/// CXXRecordDecl are defined in this translation unit.
437///
438/// Should only be called from ActOnEndOfTranslationUnit so that all
439/// definitions are actually read.
440static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
441 RecordCompleteMap &MNCComplete) {
442 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
443 if (Cache != MNCComplete.end())
444 return Cache->second;
445 if (!RD->isCompleteDefinition())
446 return false;
447 bool Complete = true;
448 for (DeclContext::decl_iterator I = RD->decls_begin(),
449 E = RD->decls_end();
450 I != E && Complete; ++I) {
451 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
452 Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jasper0e9e9f82012-06-14 20:56:06 +0000453 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
454 Complete = F->getTemplatedDecl()->isDefined();
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000455 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
456 if (R->isInjectedClassName())
457 continue;
458 if (R->hasDefinition())
459 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
460 MNCComplete);
461 else
462 Complete = false;
463 }
464 }
465 MNCComplete[RD] = Complete;
466 return Complete;
467}
468
469/// \brief Returns true, if the given CXXRecordDecl is fully defined in this
470/// translation unit, i.e. all methods are defined or pure virtual and all
471/// friends, friend functions and nested classes are fully defined in this
472/// translation unit.
473///
474/// Should only be called from ActOnEndOfTranslationUnit so that all
475/// definitions are actually read.
476static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
477 RecordCompleteMap &RecordsComplete,
478 RecordCompleteMap &MNCComplete) {
479 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
480 if (Cache != RecordsComplete.end())
481 return Cache->second;
482 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
483 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
484 E = RD->friend_end();
485 I != E && Complete; ++I) {
486 // Check if friend classes and methods are complete.
487 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
488 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
489 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
490 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
491 else
492 Complete = false;
493 } else {
494 // Friend functions are available through the NamedDecl of FriendDecl.
495 if (const FunctionDecl *FD =
496 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
497 Complete = FD->isDefined();
498 else
499 // This is a template friend, give up.
500 Complete = false;
501 }
502 }
503 RecordsComplete[RD] = Complete;
504 return Complete;
505}
506
Chris Lattner9299f3f2008-08-23 03:19:52 +0000507/// ActOnEndOfTranslationUnit - This is called at the very end of the
508/// translation unit when EOF is reached and all but the top-level scope is
509/// popped.
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000510void Sema::ActOnEndOfTranslationUnit() {
John McCall92576642012-05-07 06:16:41 +0000511 assert(DelayedDiagnostics.getCurrentPool() == NULL
512 && "reached end of translation unit with a pool attached?");
513
Douglas Gregord82f5eb2012-08-17 22:17:36 +0000514 // If code completion is enabled, don't perform any end-of-translation-unit
515 // work.
516 if (PP.isCodeCompletionEnabled())
517 return;
518
Douglas Gregor467dc882011-08-25 22:30:56 +0000519 // Only complete translation units define vtables and perform implicit
520 // instantiations.
521 if (TUKind == TU_Complete) {
Argyrios Kyrtzidis849639d2012-02-07 16:50:53 +0000522 DiagnoseUseOfUnimplementedSelectors();
523
Chandler Carruthaee543a2010-12-12 21:36:11 +0000524 // If any dynamic classes have their key function defined within
525 // this translation unit, then those vtables are considered "used" and must
526 // be emitted.
Douglas Gregora126f172011-07-28 00:53:40 +0000527 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
528 E = DynamicClasses.end();
529 I != E; ++I) {
530 assert(!(*I)->isDependentType() &&
Anders Carlssona5c6c2a2011-01-25 18:08:22 +0000531 "Should not see dependent types here!");
John McCalld5617ee2013-01-25 22:31:03 +0000532 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) {
Chandler Carruthaee543a2010-12-12 21:36:11 +0000533 const FunctionDecl *Definition = 0;
534 if (KeyFunction->hasBody(Definition))
Douglas Gregora126f172011-07-28 00:53:40 +0000535 MarkVTableUsed(Definition->getLocation(), *I, true);
Chandler Carruthaee543a2010-12-12 21:36:11 +0000536 }
537 }
538
Nick Lewycky81559102011-05-31 07:58:42 +0000539 // If DefinedUsedVTables ends up marking any virtual member functions it
540 // might lead to more pending template instantiations, which we then need
541 // to instantiate.
542 DefineUsedVTables();
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000543
Nick Lewycky81559102011-05-31 07:58:42 +0000544 // C++: Perform implicit template instantiations.
545 //
546 // FIXME: When we perform these implicit instantiations, we do not
547 // carefully keep track of the point of instantiation (C++ [temp.point]).
548 // This means that name lookup that occurs within the template
549 // instantiation will always happen at the end of the translation unit,
550 // so it will find some names that should not be found. Although this is
551 // common behavior for C++ compilers, it is technically wrong. In the
552 // future, we either need to be able to filter the results of name lookup
553 // or we need to perform template instantiations earlier.
554 PerformPendingInstantiations();
Nick Lewycky2a5f99e2010-11-25 00:35:20 +0000555 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000556
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000557 // Remove file scoped decls that turned out to be used.
Michael Gottesman0116a402013-01-20 01:04:14 +0000558 UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(0,
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000559 true),
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000560 UnusedFileScopedDecls.end(),
561 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
562 this)),
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000563 UnusedFileScopedDecls.end());
Douglas Gregor47268a32010-04-09 17:41:13 +0000564
Douglas Gregor467dc882011-08-25 22:30:56 +0000565 if (TUKind == TU_Prefix) {
566 // Translation unit prefixes don't need any of the checking below.
Douglas Gregor87c08a52010-08-13 22:48:40 +0000567 TUScope = 0;
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000568 return;
Douglas Gregor87c08a52010-08-13 22:48:40 +0000569 }
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000570
Chris Lattner63d65f82009-09-08 18:19:27 +0000571 // Check for #pragma weak identifiers that were never declared
572 // FIXME: This will cause diagnostics to be emitted in a non-determinstic
573 // order! Iterating over a densemap like this is bad.
Douglas Gregor31e37b22011-07-28 18:09:57 +0000574 LoadExternalWeakUndeclaredIdentifiers();
Ryan Flynne25ff832009-07-30 03:15:39 +0000575 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Chris Lattner63d65f82009-09-08 18:19:27 +0000576 I = WeakUndeclaredIdentifiers.begin(),
577 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
578 if (I->second.getUsed()) continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000579
Chris Lattner63d65f82009-09-08 18:19:27 +0000580 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
581 << I->first;
Ryan Flynne25ff832009-07-30 03:15:39 +0000582 }
583
Douglas Gregor467dc882011-08-25 22:30:56 +0000584 if (TUKind == TU_Module) {
Douglas Gregor90db2602011-12-02 01:47:07 +0000585 // If we are building a module, resolve all of the exported declarations
586 // now.
587 if (Module *CurrentModule = PP.getCurrentModule()) {
588 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesman0116a402013-01-20 01:04:14 +0000589
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000590 SmallVector<Module *, 2> Stack;
Douglas Gregor90db2602011-12-02 01:47:07 +0000591 Stack.push_back(CurrentModule);
592 while (!Stack.empty()) {
593 Module *Mod = Stack.back();
594 Stack.pop_back();
Michael Gottesman0116a402013-01-20 01:04:14 +0000595
Douglas Gregor90db2602011-12-02 01:47:07 +0000596 // Resolve the exported declarations.
597 // FIXME: Actually complain, once we figure out how to teach the
598 // diagnostic client to deal with complains in the module map at this
599 // point.
600 ModMap.resolveExports(Mod, /*Complain=*/false);
Michael Gottesman0116a402013-01-20 01:04:14 +0000601
Douglas Gregor90db2602011-12-02 01:47:07 +0000602 // Queue the submodules, so their exports will also be resolved.
Douglas Gregorb7a78192012-01-04 23:32:19 +0000603 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
604 SubEnd = Mod->submodule_end();
Douglas Gregor90db2602011-12-02 01:47:07 +0000605 Sub != SubEnd; ++Sub) {
Douglas Gregorb7a78192012-01-04 23:32:19 +0000606 Stack.push_back(*Sub);
Douglas Gregor90db2602011-12-02 01:47:07 +0000607 }
608 }
609 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000610
Douglas Gregor467dc882011-08-25 22:30:56 +0000611 // Modules don't need any of the checking below.
612 TUScope = 0;
613 return;
614 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000615
Douglas Gregor275a3692009-03-10 23:43:53 +0000616 // C99 6.9.2p2:
617 // A declaration of an identifier for an object that has file
618 // scope without an initializer, and without a storage-class
619 // specifier or with the storage-class specifier static,
620 // constitutes a tentative definition. If a translation unit
621 // contains one or more tentative definitions for an identifier,
622 // and the translation unit contains no external definition for
623 // that identifier, then the behavior is exactly as if the
624 // translation unit contains a file scope declaration of that
625 // identifier, with the composite type as of the end of the
626 // translation unit, with an initializer equal to 0.
Sebastian Redle9d12b62010-01-31 22:27:38 +0000627 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesman0116a402013-01-20 01:04:14 +0000628 for (TentativeDefinitionsType::iterator
Douglas Gregora8623202011-07-27 20:58:46 +0000629 T = TentativeDefinitions.begin(ExternalSource),
630 TEnd = TentativeDefinitions.end();
Michael Gottesman0116a402013-01-20 01:04:14 +0000631 T != TEnd; ++T)
Douglas Gregora8623202011-07-27 20:58:46 +0000632 {
633 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump1eb44332009-09-09 15:08:12 +0000634
Sebastian Redle9d12b62010-01-31 22:27:38 +0000635 // If the tentative definition was completed, getActingDefinition() returns
636 // null. If we've already seen this variable before, insert()'s second
637 // return value is false.
638 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000639 continue;
640
Mike Stump1eb44332009-09-09 15:08:12 +0000641 if (const IncompleteArrayType *ArrayT
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000642 = Context.getAsIncompleteArrayType(VD->getType())) {
Mike Stump1eb44332009-09-09 15:08:12 +0000643 if (RequireCompleteType(VD->getLocation(),
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000644 ArrayT->getElementType(),
Chris Lattner63d65f82009-09-08 18:19:27 +0000645 diag::err_tentative_def_incomplete_type_arr)) {
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000646 VD->setInvalidDecl();
Chris Lattner63d65f82009-09-08 18:19:27 +0000647 continue;
Douglas Gregor275a3692009-03-10 23:43:53 +0000648 }
Mike Stump1eb44332009-09-09 15:08:12 +0000649
Chris Lattner63d65f82009-09-08 18:19:27 +0000650 // Set the length of the array to 1 (C99 6.9.2p5).
651 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
652 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
John McCall46a617a2009-10-16 00:14:28 +0000653 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
654 One, ArrayType::Normal, 0);
Chris Lattner63d65f82009-09-08 18:19:27 +0000655 VD->setType(T);
Mike Stump1eb44332009-09-09 15:08:12 +0000656 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000657 diag::err_tentative_def_incomplete_type))
658 VD->setInvalidDecl();
659
Eli Friedmane4851f22012-10-23 20:19:32 +0000660 CheckCompleteVariableDeclaration(VD);
661
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000662 // Notify the consumer that we've completed a tentative definition.
663 if (!VD->isInvalidDecl())
664 Consumer.CompleteTentativeDefinition(VD);
665
Douglas Gregor275a3692009-03-10 23:43:53 +0000666 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000667
Richard Smith80ad52f2013-01-02 11:42:31 +0000668 if (LangOpts.CPlusPlus11 &&
Sean Huntc1598702011-05-05 00:05:47 +0000669 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
670 SourceLocation())
David Blaikied6471f72011-09-25 23:23:43 +0000671 != DiagnosticsEngine::Ignored)
Sean Huntfe57eef2011-05-04 05:57:24 +0000672 CheckDelegatingCtorCycles();
673
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000674 // If there were errors, disable 'unused' warnings since they will mostly be
675 // noise.
676 if (!Diags.hasErrorOccurred()) {
677 // Output warning for unused file scoped decls.
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000678 for (UnusedFileScopedDeclsType::iterator
679 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000680 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000681 if (ShouldRemoveFromUnused(this, *I))
682 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000683
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000684 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
685 const FunctionDecl *DiagD;
686 if (!FD->hasBody(DiagD))
687 DiagD = FD;
Argyrios Kyrtzidis48b89592011-03-03 17:47:42 +0000688 if (DiagD->isDeleted())
689 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000690 if (DiagD->isReferenced()) {
691 if (isa<CXXMethodDecl>(DiagD))
692 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
693 << DiagD->getDeclName();
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000694 else {
695 if (FD->getStorageClassAsWritten() == SC_Static &&
696 !FD->isInlineSpecified() &&
697 !SourceMgr.isFromMainFile(
698 SourceMgr.getExpansionLoc(FD->getLocation())))
699 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
700 << DiagD->getDeclName();
701 else
702 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
703 << /*function*/0 << DiagD->getDeclName();
704 }
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000705 } else {
706 Diag(DiagD->getLocation(),
707 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
708 : diag::warn_unused_function)
709 << DiagD->getDeclName();
710 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000711 } else {
712 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
713 if (!DiagD)
714 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000715 if (DiagD->isReferenced()) {
716 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
717 << /*variable*/1 << DiagD->getDeclName();
718 } else {
719 Diag(DiagD->getLocation(), diag::warn_unused_variable)
720 << DiagD->getDeclName();
721 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000722 }
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000723 }
John McCall15e310a2011-02-19 02:53:41 +0000724
Nick Lewycky01a41142013-01-26 00:35:08 +0000725 if (ExternalSource)
726 ExternalSource->ReadUndefinedInternals(UndefinedInternals);
John McCall15e310a2011-02-19 02:53:41 +0000727 checkUndefinedInternals(*this);
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000728 }
Douglas Gregor87c08a52010-08-13 22:48:40 +0000729
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000730 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
731 SourceLocation())
732 != DiagnosticsEngine::Ignored) {
733 RecordCompleteMap RecordsComplete;
734 RecordCompleteMap MNCComplete;
735 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
736 E = UnusedPrivateFields.end(); I != E; ++I) {
737 const NamedDecl *D = *I;
738 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
739 if (RD && !RD->isUnion() &&
740 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
741 Diag(D->getLocation(), diag::warn_unused_private_field)
742 << D->getDeclName();
743 }
744 }
745 }
746
Richard Smith483b9f32011-02-21 20:05:19 +0000747 // Check we've noticed that we're no longer parsing the initializer for every
748 // variable. If we miss cases, then at best we have a performance issue and
749 // at worst a rejects-valid bug.
750 assert(ParsingInitForAutoVars.empty() &&
751 "Didn't unmark var as having its initializer parsed");
752
Douglas Gregor87c08a52010-08-13 22:48:40 +0000753 TUScope = 0;
Chris Lattner9299f3f2008-08-23 03:19:52 +0000754}
755
756
Reid Spencer5f016e22007-07-11 17:01:13 +0000757//===----------------------------------------------------------------------===//
758// Helper functions.
759//===----------------------------------------------------------------------===//
760
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000761DeclContext *Sema::getFunctionLevelDeclContext() {
John McCalldb0ee1d2009-12-19 10:53:49 +0000762 DeclContext *DC = CurContext;
Mike Stump1eb44332009-09-09 15:08:12 +0000763
Eli Friedman72899c32012-01-07 04:59:52 +0000764 while (true) {
765 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) {
766 DC = DC->getParent();
767 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor215e4e12012-02-12 17:34:23 +0000768 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman72899c32012-01-07 04:59:52 +0000769 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
770 DC = DC->getParent()->getParent();
771 }
772 else break;
773 }
Mike Stump1eb44332009-09-09 15:08:12 +0000774
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000775 return DC;
776}
777
Chris Lattner371f2582008-12-04 23:50:19 +0000778/// getCurFunctionDecl - If inside of a function body, this returns a pointer
779/// to the function decl for the function being parsed. If we're currently
780/// in a 'block', this returns the containing context.
781FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000782 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000783 return dyn_cast<FunctionDecl>(DC);
784}
785
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000786ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000787 DeclContext *DC = getFunctionLevelDeclContext();
Steve Naroffd7612e12008-11-17 16:28:52 +0000788 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000789}
Chris Lattner371f2582008-12-04 23:50:19 +0000790
791NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000792 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000793 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000794 return cast<NamedDecl>(DC);
Chris Lattner371f2582008-12-04 23:50:19 +0000795 return 0;
796}
797
Daniel Dunbar393eed72012-03-14 09:49:32 +0000798void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
799 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
800 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
801 // been made more painfully obvious by the refactor that introduced this
802 // function, but it is possible that the incoming argument can be
803 // eliminnated. If it truly cannot be (for example, there is some reentrancy
804 // issue I am not seeing yet), then there should at least be a clarifying
805 // comment somewhere.
806 if (llvm::Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
807 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
808 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000809 case DiagnosticIDs::SFINAE_Report:
Richard Smith77faa362011-10-19 00:07:01 +0000810 // We'll report the diagnostic below.
Douglas Gregor9b623632010-10-12 23:32:35 +0000811 break;
Michael Gottesman0116a402013-01-20 01:04:14 +0000812
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000813 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor9b623632010-10-12 23:32:35 +0000814 // Count this failure so that we know that template argument deduction
815 // has failed.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000816 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000817
818 // Make a copy of this suppressed diagnostic and store it with the
819 // template-deduction information.
820 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
821 Diagnostic DiagInfo(&Diags);
822 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
823 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
824 }
825
Daniel Dunbar393eed72012-03-14 09:49:32 +0000826 Diags.setLastDiagnosticIgnored();
827 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000828 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000829
Richard Smith77faa362011-10-19 00:07:01 +0000830 case DiagnosticIDs::SFINAE_AccessControl: {
831 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbar00b43842012-03-13 18:30:54 +0000832 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith77faa362011-10-19 00:07:01 +0000833 // make access control a part of SFINAE for the purposes of checking
834 // type traits.
Richard Smith80ad52f2013-01-02 11:42:31 +0000835 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith77faa362011-10-19 00:07:01 +0000836 break;
837
Daniel Dunbar393eed72012-03-14 09:49:32 +0000838 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith77faa362011-10-19 00:07:01 +0000839
840 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000841 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000842
843 // Make a copy of this suppressed diagnostic and store it with the
844 // template-deduction information.
845 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
846 Diagnostic DiagInfo(&Diags);
847 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
848 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
849 }
850
Daniel Dunbar393eed72012-03-14 09:49:32 +0000851 Diags.setLastDiagnosticIgnored();
852 Diags.Clear();
Richard Smith77faa362011-10-19 00:07:01 +0000853
854 // Now the diagnostic state is clear, produce a C++98 compatibility
855 // warning.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000856 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith77faa362011-10-19 00:07:01 +0000857
858 // The last diagnostic which Sema produced was ignored. Suppress any
859 // notes attached to it.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000860 Diags.setLastDiagnosticIgnored();
Richard Smith77faa362011-10-19 00:07:01 +0000861 return;
862 }
863
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000864 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor9b623632010-10-12 23:32:35 +0000865 // Make a copy of this suppressed diagnostic and store it with the
866 // template-deduction information;
Richard Smithb8590f32012-05-07 09:03:25 +0000867 if (*Info) {
868 Diagnostic DiagInfo(&Diags);
Douglas Gregor1eee5dc2011-01-27 22:31:44 +0000869 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smithb8590f32012-05-07 09:03:25 +0000870 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
871 }
872
873 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000874 Diags.setLastDiagnosticIgnored();
875 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000876 return;
877 }
878 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000879
Douglas Gregor8987b232011-09-27 23:30:47 +0000880 // Set up the context's printing policy based on our current state.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000881 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesman0116a402013-01-20 01:04:14 +0000882
Douglas Gregor9b623632010-10-12 23:32:35 +0000883 // Emit the diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000884 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000885 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000886
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000887 // If this is not a note, and we're in a template instantiation
888 // that is different from the last template instantiation where
889 // we emitted an error, print a template instantiation
890 // backtrace.
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000891 if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
Daniel Dunbar393eed72012-03-14 09:49:32 +0000892 !ActiveTemplateInstantiations.empty() &&
893 ActiveTemplateInstantiations.back()
894 != LastTemplateInstantiationErrorContext) {
895 PrintInstantiationStack();
896 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000897 }
898}
Douglas Gregor2e222532009-07-02 17:08:52 +0000899
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000900Sema::SemaDiagnosticBuilder
901Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
902 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
903 PD.Emit(Builder);
Mike Stump1eb44332009-09-09 15:08:12 +0000904
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000905 return Builder;
906}
907
Chandler Carruth108f7562011-07-26 05:40:03 +0000908/// \brief Looks through the macro-expansion chain for the given
909/// location, looking for a macro expansion with the given name.
John McCall834e3f62011-03-08 07:59:04 +0000910/// If one is found, returns true and sets the location to that
Chandler Carruth108f7562011-07-26 05:40:03 +0000911/// expansion loc.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000912bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall834e3f62011-03-08 07:59:04 +0000913 SourceLocation loc = locref;
914 if (!loc.isMacroID()) return false;
915
916 // There's no good way right now to look at the intermediate
Chandler Carruth108f7562011-07-26 05:40:03 +0000917 // expansions, so just jump to the expansion location.
Chandler Carruth40278532011-07-25 16:49:02 +0000918 loc = getSourceManager().getExpansionLoc(loc);
John McCall834e3f62011-03-08 07:59:04 +0000919
920 // If that's written with the name, stop here.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000921 SmallVector<char, 16> buffer;
John McCall834e3f62011-03-08 07:59:04 +0000922 if (getPreprocessor().getSpelling(loc, buffer) == name) {
923 locref = loc;
924 return true;
925 }
926 return false;
927}
928
Douglas Gregor23c94db2010-07-02 17:43:08 +0000929/// \brief Determines the active Scope associated with the given declaration
930/// context.
931///
932/// This routine maps a declaration context to the active Scope object that
933/// represents that declaration context in the parser. It is typically used
934/// from "scope-less" code (e.g., template instantiation, lazy creation of
935/// declarations) that injects a name for name-lookup purposes and, therefore,
936/// must update the Scope.
937///
938/// \returns The scope corresponding to the given declaraion context, or NULL
939/// if no such scope is open.
940Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesman0116a402013-01-20 01:04:14 +0000941
Douglas Gregor23c94db2010-07-02 17:43:08 +0000942 if (!Ctx)
943 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +0000944
Douglas Gregor23c94db2010-07-02 17:43:08 +0000945 Ctx = Ctx->getPrimaryContext();
946 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcddc69f2010-07-08 23:07:34 +0000947 // Ignore scopes that cannot have declarations. This is important for
948 // out-of-line definitions of static class members.
949 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
950 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
951 if (Ctx == Entity->getPrimaryContext())
952 return S;
Douglas Gregor23c94db2010-07-02 17:43:08 +0000953 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000954
Douglas Gregor23c94db2010-07-02 17:43:08 +0000955 return 0;
956}
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000957
958/// \brief Enter a new function scope
959void Sema::PushFunctionScope() {
John McCall781472f2010-08-25 08:40:02 +0000960 if (FunctionScopes.size() == 1) {
961 // Use the "top" function scope rather than having to allocate
962 // memory for a new scope.
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000963 FunctionScopes.back()->Clear();
John McCall781472f2010-08-25 08:40:02 +0000964 FunctionScopes.push_back(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000965 return;
966 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000967
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000968 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000969}
970
971void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000972 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000973 BlockScope, Block));
974}
975
Michael Gottesman0116a402013-01-20 01:04:14 +0000976void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
Douglas Gregor76e3da52012-02-08 20:17:14 +0000977 CXXMethodDecl *CallOperator) {
978 FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
979 CallOperator));
Eli Friedmanec9ea722012-01-05 03:35:19 +0000980}
981
982void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
983 const Decl *D, const BlockExpr *blkExpr) {
Michael Gottesman0116a402013-01-20 01:04:14 +0000984 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
John McCall781472f2010-08-25 08:40:02 +0000985 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Michael Gottesman0116a402013-01-20 01:04:14 +0000986
Ted Kremenek3ed6fc02011-02-23 01:51:48 +0000987 // Issue any analysis-based warnings.
988 if (WP && D)
Ted Kremenek283a3582011-02-23 01:51:53 +0000989 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
Ted Kremenek351ba912011-02-23 01:52:04 +0000990 else {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000991 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
Ted Kremenek351ba912011-02-23 01:52:04 +0000992 i = Scope->PossiblyUnreachableDiags.begin(),
993 e = Scope->PossiblyUnreachableDiags.end();
994 i != e; ++i) {
995 const sema::PossiblyUnreachableDiag &D = *i;
996 Diag(D.Loc, D.PD);
997 }
998 }
Ted Kremenek3ed6fc02011-02-23 01:51:48 +0000999
Ted Kremenek351ba912011-02-23 01:52:04 +00001000 if (FunctionScopes.back() != Scope) {
John McCall781472f2010-08-25 08:40:02 +00001001 delete Scope;
Ted Kremenek351ba912011-02-23 01:52:04 +00001002 }
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001003}
1004
Dmitri Gribenko625bb562012-02-14 22:14:32 +00001005void Sema::PushCompoundScope() {
1006 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1007}
1008
1009void Sema::PopCompoundScope() {
1010 FunctionScopeInfo *CurFunction = getCurFunction();
1011 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1012
1013 CurFunction->CompoundScopes.pop_back();
1014}
1015
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001016/// \brief Determine whether any errors occurred within this function/method/
1017/// block.
John McCallf85e1932011-06-15 23:02:42 +00001018bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1019 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001020}
1021
1022BlockScopeInfo *Sema::getCurBlock() {
1023 if (FunctionScopes.empty())
1024 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001025
1026 return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001027}
John McCall76bd1f32010-06-01 09:23:16 +00001028
Eli Friedman906a7e12012-01-06 03:05:34 +00001029LambdaScopeInfo *Sema::getCurLambda() {
1030 if (FunctionScopes.empty())
1031 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001032
1033 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
Eli Friedman906a7e12012-01-06 03:05:34 +00001034}
1035
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001036void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenek127ff2e2012-09-13 06:41:18 +00001037 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1038 SourceMgr.isInSystemHeader(Comment.getBegin()))
1039 return;
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001040 RawComment RC(SourceMgr, Comment);
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001041 if (RC.isAlmostTrailingComment()) {
1042 SourceRange MagicMarkerRange(Comment.getBegin(),
1043 Comment.getBegin().getLocWithOffset(3));
1044 StringRef MagicMarkerText;
1045 switch (RC.getKind()) {
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001046 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001047 MagicMarkerText = "///<";
1048 break;
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001049 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001050 MagicMarkerText = "/**<";
1051 break;
1052 default:
1053 llvm_unreachable("if this is an almost Doxygen comment, "
1054 "it should be ordinary");
1055 }
1056 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1057 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1058 }
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001059 Context.addComment(RC);
1060}
1061
John McCall76bd1f32010-06-01 09:23:16 +00001062// Pin this vtable to this file.
1063ExternalSemaSource::~ExternalSemaSource() {}
John McCallf312b1e2010-08-26 23:41:50 +00001064
Douglas Gregor5ac4b692012-01-25 00:49:42 +00001065void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Sebastian Redl8c845712010-09-28 20:23:00 +00001066
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001067void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesman0116a402013-01-20 01:04:14 +00001068 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001069}
1070
Nick Lewycky01a41142013-01-26 00:35:08 +00001071void ExternalSemaSource::ReadUndefinedInternals(
1072 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
1073}
1074
Chris Lattner5f9e2722011-07-23 10:55:15 +00001075void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
John McCallf312b1e2010-08-26 23:41:50 +00001076 SourceLocation Loc = this->Loc;
1077 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1078 if (Loc.isValid()) {
1079 Loc.print(OS, S.getSourceManager());
1080 OS << ": ";
1081 }
1082 OS << Message;
1083
1084 if (TheDecl && isa<NamedDecl>(TheDecl)) {
1085 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1086 if (!Name.empty())
1087 OS << " '" << Name << '\'';
1088 }
1089
1090 OS << '\n';
1091}
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001092
1093/// \brief Figure out if an expression could be turned into a call.
1094///
1095/// Use this when trying to recover from an error where the programmer may have
1096/// written just the name of a function instead of actually calling it.
1097///
1098/// \param E - The expression to examine.
1099/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1100/// with no arguments, this parameter is set to the type returned by such a
1101/// call; otherwise, it is set to an empty QualType.
John McCall6dbba4f2011-10-11 23:14:30 +00001102/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001103/// name, this parameter is populated with the decls of the various overloads.
1104bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
John McCall6dbba4f2011-10-11 23:14:30 +00001105 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001106 ZeroArgCallReturnTy = QualType();
John McCall6dbba4f2011-10-11 23:14:30 +00001107 OverloadSet.clear();
1108
1109 if (E.getType() == Context.OverloadTy) {
1110 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1111 const OverloadExpr *Overloads = FR.Expression;
1112
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001113 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1114 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall6dbba4f2011-10-11 23:14:30 +00001115 OverloadSet.addDecl(*it);
1116
1117 // Check whether the function is a non-template which takes no
1118 // arguments.
1119 if (const FunctionDecl *OverloadDecl
1120 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001121 if (OverloadDecl->getMinRequiredArguments() == 0)
1122 ZeroArgCallReturnTy = OverloadDecl->getResultType();
1123 }
1124 }
John McCall6dbba4f2011-10-11 23:14:30 +00001125
Douglas Gregor64a371f2011-10-13 18:26:27 +00001126 // Ignore overloads that are pointer-to-member constants.
1127 if (FR.HasFormOfMemberPointer)
John McCall6dbba4f2011-10-11 23:14:30 +00001128 return false;
1129
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001130 return true;
1131 }
1132
John McCall6dbba4f2011-10-11 23:14:30 +00001133 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001134 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1135 if (Fun->getMinRequiredArguments() == 0)
1136 ZeroArgCallReturnTy = Fun->getResultType();
1137 return true;
1138 }
1139 }
1140
1141 // We don't have an expression that's convenient to get a FunctionDecl from,
1142 // but we can at least check if the type is "function of 0 arguments".
1143 QualType ExprTy = E.getType();
1144 const FunctionType *FunTy = NULL;
Matt Beaumont-Gay9389ddc2011-05-05 00:59:35 +00001145 QualType PointeeTy = ExprTy->getPointeeType();
1146 if (!PointeeTy.isNull())
1147 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001148 if (!FunTy)
1149 FunTy = ExprTy->getAs<FunctionType>();
1150 if (!FunTy && ExprTy == Context.BoundMemberTy) {
1151 // Look for the bound-member type. If it's still overloaded, give up,
1152 // although we probably should have fallen into the OverloadExpr case above
1153 // if we actually have an overloaded bound member.
1154 QualType BoundMemberTy = Expr::findBoundMemberType(&E);
1155 if (!BoundMemberTy.isNull())
1156 FunTy = BoundMemberTy->castAs<FunctionType>();
1157 }
1158
1159 if (const FunctionProtoType *FPT =
1160 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1161 if (FPT->getNumArgs() == 0)
1162 ZeroArgCallReturnTy = FunTy->getResultType();
1163 return true;
1164 }
1165 return false;
1166}
1167
1168/// \brief Give notes for a set of overloads.
1169///
1170/// A companion to isExprCallable. In cases when the name that the programmer
1171/// wrote was an overloaded function, we may be able to make some guesses about
1172/// plausible overloads based on their return types; such guesses can be handed
1173/// off to this method to be emitted as notes.
1174///
1175/// \param Overloads - The overloads to note.
1176/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1177/// -fshow-overloads=best, this is the location to attach to the note about too
1178/// many candidates. Typically this will be the location of the original
1179/// ill-formed expression.
John McCall6dbba4f2011-10-11 23:14:30 +00001180static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1181 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001182 int ShownOverloads = 0;
1183 int SuppressedOverloads = 0;
1184 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1185 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1186 // FIXME: Magic number for max shown overloads stolen from
1187 // OverloadCandidateSet::NoteCandidates.
Douglas Gregordc7b6412012-10-23 23:11:23 +00001188 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001189 ++SuppressedOverloads;
1190 continue;
1191 }
John McCall6dbba4f2011-10-11 23:14:30 +00001192
1193 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Abramo Bagnara9c0e1ec2011-11-15 21:43:28 +00001194 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001195 ++ShownOverloads;
1196 }
John McCall6dbba4f2011-10-11 23:14:30 +00001197
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001198 if (SuppressedOverloads)
John McCall6dbba4f2011-10-11 23:14:30 +00001199 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1200 << SuppressedOverloads;
1201}
1202
1203static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1204 const UnresolvedSetImpl &Overloads,
1205 bool (*IsPlausibleResult)(QualType)) {
1206 if (!IsPlausibleResult)
1207 return noteOverloads(S, Overloads, Loc);
1208
1209 UnresolvedSet<2> PlausibleOverloads;
1210 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1211 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1212 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1213 QualType OverloadResultTy = OverloadDecl->getResultType();
1214 if (IsPlausibleResult(OverloadResultTy))
1215 PlausibleOverloads.addDecl(It.getDecl());
1216 }
1217 noteOverloads(S, PlausibleOverloads, Loc);
1218}
1219
1220/// Determine whether the given expression can be called by just
1221/// putting parentheses after it. Notably, expressions with unary
1222/// operators can't be because the unary operator will start parsing
1223/// outside the call.
1224static bool IsCallableWithAppend(Expr *E) {
1225 E = E->IgnoreImplicit();
1226 return (!isa<CStyleCastExpr>(E) &&
1227 !isa<UnaryOperator>(E) &&
1228 !isa<BinaryOperator>(E) &&
1229 !isa<CXXOperatorCallExpr>(E));
1230}
1231
1232bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1233 bool ForceComplain,
1234 bool (*IsPlausibleResult)(QualType)) {
1235 SourceLocation Loc = E.get()->getExprLoc();
1236 SourceRange Range = E.get()->getSourceRange();
1237
1238 QualType ZeroArgCallTy;
1239 UnresolvedSet<4> Overloads;
1240 if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
1241 !ZeroArgCallTy.isNull() &&
1242 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1243 // At this point, we know E is potentially callable with 0
1244 // arguments and that it returns something of a reasonable type,
1245 // so we can emit a fixit and carry on pretending that E was
1246 // actually a CallExpr.
1247 SourceLocation ParenInsertionLoc =
1248 PP.getLocForEndOfToken(Range.getEnd());
Michael Gottesman0116a402013-01-20 01:04:14 +00001249 Diag(Loc, PD)
John McCall6dbba4f2011-10-11 23:14:30 +00001250 << /*zero-arg*/ 1 << Range
1251 << (IsCallableWithAppend(E.get())
1252 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1253 : FixItHint());
1254 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1255
1256 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1257 // while doing so.
1258 E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
Benjamin Kramer5354e772012-08-23 23:38:35 +00001259 MultiExprArg(), ParenInsertionLoc.getLocWithOffset(1));
John McCall6dbba4f2011-10-11 23:14:30 +00001260 return true;
1261 }
1262
1263 if (!ForceComplain) return false;
1264
1265 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1266 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1267 E = ExprError();
1268 return true;
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001269}