blob: 91f6d5f7c21346e12d3ff2e635a0b2daee4c3ba9 [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) {
Argyrios Kyrtzidis9818a1d2013-02-20 00:54:57 +000052 if (const MacroInfo *
53 BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) {
Michael Gottesman0116a402013-01-20 01:04:14 +000054 Policy.Bool = BoolMacro->isObjectLike() &&
Douglas Gregor8987b232011-09-27 23:30:47 +000055 BoolMacro->getNumTokens() == 1 &&
56 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
57 }
58 }
Michael Gottesman0116a402013-01-20 01:04:14 +000059
Douglas Gregor8987b232011-09-27 23:30:47 +000060 return Policy;
61}
62
Douglas Gregorc1a3e5e2010-08-25 18:07:12 +000063void Sema::ActOnTranslationUnitScope(Scope *S) {
Steve Naroffb216c882007-10-09 22:01:59 +000064 TUScope = S;
Douglas Gregor44b43212008-12-11 16:49:14 +000065 PushDeclContext(S, Context.getTranslationUnitDecl());
Mike Stump1eb44332009-09-09 15:08:12 +000066
John McCallc7e04da2010-05-28 18:45:08 +000067 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
Steve Naroff3b950172007-10-10 21:53:07 +000068}
69
Douglas Gregorf807fe02009-04-14 16:27:31 +000070Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Douglas Gregor467dc882011-08-25 22:30:56 +000071 TranslationUnitKind TUKind,
Daniel Dunbar3a2838d2009-11-13 08:58:20 +000072 CodeCompleteConsumer *CodeCompleter)
Michael Gottesman0116a402013-01-20 01:04:14 +000073 : TheTargetAttributesSema(0), ExternalSource(0),
Axel Naumann0ec56b72012-10-18 19:05:02 +000074 isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()),
David Blaikie4e4d0842012-03-11 07:00:24 +000075 LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
Mike Stump1eb44332009-09-09 15:08:12 +000076 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
Axel Naumann0ec56b72012-10-18 19:05:02 +000077 CollectStats(false), CodeCompleter(CodeCompleter),
Argyrios Kyrtzidis3a387442011-10-06 23:23:20 +000078 CurContext(0), OriginalLexicalContext(0),
79 PackContext(0), MSStructPragmaOn(false), VisContext(0),
Richard Smithe49ff3e2012-09-25 04:46:05 +000080 IsBuildingRecoveryCallExpr(false),
John McCall80ee6e82011-11-10 05:35:25 +000081 ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
Sebastian Redl395e04d2012-01-17 22:49:33 +000082 IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
Benjamin Kramer471131a2012-04-22 20:43:35 +000083 NSNumberDecl(0),
84 NSStringDecl(0), StringWithUTF8StringMethod(0),
85 NSArrayDecl(0), ArrayWithObjectsMethod(0),
Ted Kremenekebcb57a2012-03-06 20:05:56 +000086 NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
Michael Gottesman0116a402013-01-20 01:04:14 +000087 GlobalNewDeleteDeclared(false),
Douglas Gregor467dc882011-08-25 22:30:56 +000088 TUKind(TUKind),
John McCall13489672012-05-07 06:16:58 +000089 NumSFINAEErrors(0), InFunctionDeclarator(0),
Douglas Gregor1eee5dc2011-01-27 22:31:44 +000090 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
Douglas Gregor8491ffe2010-12-20 22:05:00 +000091 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
92 CurrentInstantiationScope(0), TyposCorrected(0),
Alexey Bataev0c018352013-09-06 18:03:48 +000093 AnalysisWarnings(*this), VarDataSharingAttributesStack(0), CurScope(0),
94 Ident_super(0), Ident___float128(0)
Douglas Gregorf35f8282009-11-11 21:54:23 +000095{
Steve Naroff3b950172007-10-10 21:53:07 +000096 TUScope = 0;
Michael Gottesman0116a402013-01-20 01:04:14 +000097
Douglas Gregord8bba9c2011-06-28 16:20:02 +000098 LoadedExternalKnownNamespaces = false;
Ted Kremenekebcb57a2012-03-06 20:05:56 +000099 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
100 NSNumberLiteralMethods[I] = 0;
101
David Blaikie4e4d0842012-03-11 07:00:24 +0000102 if (getLangOpts().ObjC1)
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000103 NSAPIObj.reset(new NSAPI(Context));
104
David Blaikie4e4d0842012-03-11 07:00:24 +0000105 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000106 FieldCollector.reset(new CXXFieldCollector());
Mike Stump1eb44332009-09-09 15:08:12 +0000107
Chris Lattner22caddc2008-11-23 09:13:29 +0000108 // Tell diagnostics how to render things from the AST library.
Michael Gottesman0116a402013-01-20 01:04:14 +0000109 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
Douglas Gregor79a9a342010-02-09 22:26:47 +0000110 &Context);
Douglas Gregor2afce722009-11-26 00:44:06 +0000111
112 ExprEvalContexts.push_back(
Richard Smith76f3f692012-02-22 02:04:18 +0000113 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
114 false, 0, false));
John McCall781472f2010-08-25 08:40:02 +0000115
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000116 FunctionScopes.push_back(new FunctionScopeInfo(Diags));
Alexey Bataev0c018352013-09-06 18:03:48 +0000117
118 // Initilization of data sharing attributes stack for OpenMP
119 InitDataSharingAttributesStack();
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000120}
121
122void Sema::Initialize() {
123 // Tell the AST consumer about this Sema object.
124 Consumer.Initialize(Context);
Michael Gottesman0116a402013-01-20 01:04:14 +0000125
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000126 // FIXME: Isn't this redundant with the initialization above?
127 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
128 SC->InitializeSema(*this);
Michael Gottesman0116a402013-01-20 01:04:14 +0000129
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000130 // Tell the external Sema source about this Sema object.
131 if (ExternalSemaSource *ExternalSema
132 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
133 ExternalSema->InitializeSema(*this);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000134
Douglas Gregor772eeae2011-08-12 06:49:56 +0000135 // Initialize predefined 128-bit integer types, if needed.
Richard Smith84268902012-11-29 05:41:51 +0000136 if (PP.getTargetInfo().hasInt128Type()) {
Douglas Gregor772eeae2011-08-12 06:49:56 +0000137 // If either of the 128-bit integer types are unavailable to name lookup,
138 // define them now.
139 DeclarationName Int128 = &Context.Idents.get("__int128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000140 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000141 PushOnScopeChains(Context.getInt128Decl(), TUScope);
142
143 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000144 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000145 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
146 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000147
Douglas Gregor772eeae2011-08-12 06:49:56 +0000148
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000149 // Initialize predefined Objective-C types:
David Blaikie4e4d0842012-03-11 07:00:24 +0000150 if (PP.getLangOpts().ObjC1) {
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000151 // If 'SEL' does not yet refer to any declarations, make it refer to the
152 // predefined 'SEL'.
153 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000154 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000155 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
156
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000157 // If 'id' does not yet refer to any declarations, make it refer to the
158 // predefined 'id'.
159 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000160 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000161 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesman0116a402013-01-20 01:04:14 +0000162
Douglas Gregor79d67262011-08-12 05:59:41 +0000163 // Create the built-in typedef for 'Class'.
164 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000165 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor79d67262011-08-12 05:59:41 +0000166 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregora6ea10e2012-01-17 18:09:05 +0000167
168 // Create the built-in forward declaratino for 'Protocol'.
169 DeclarationName Protocol = &Context.Idents.get("Protocol");
170 if (IdResolver.begin(Protocol) == IdResolver.end())
171 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000172 }
Meador Ingec5613b22012-06-16 03:34:49 +0000173
174 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
175 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
176 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Reid Spencer5f016e22007-07-11 17:01:13 +0000177}
178
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000179Sema::~Sema() {
Richard Smithac32d902013-08-07 21:41:30 +0000180 for (LateParsedTemplateMapT::iterator I = LateParsedTemplateMap.begin(),
181 E = LateParsedTemplateMap.end();
182 I != E; ++I)
183 delete I->second;
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000184 if (PackContext) FreePackedContext();
Eli Friedmanaa8b0d12010-08-05 06:57:20 +0000185 if (VisContext) FreeVisContext();
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000186 delete TheTargetAttributesSema;
Fariborz Jahanian62c92582011-04-25 18:49:15 +0000187 MSStructPragmaOn = false;
John McCall781472f2010-08-25 08:40:02 +0000188 // Kill all the active scopes.
189 for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
190 delete FunctionScopes[I];
191 if (FunctionScopes.size() == 1)
192 delete FunctionScopes[0];
Michael Gottesman0116a402013-01-20 01:04:14 +0000193
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000194 // Tell the SemaConsumer to forget about us; we're going out of scope.
195 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
196 SC->ForgetSema();
197
198 // Detach from the external Sema source.
199 if (ExternalSemaSource *ExternalSema
Douglas Gregor914ed9d2010-08-13 03:15:25 +0000200 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000201 ExternalSema->ForgetSema();
Axel Naumann0ec56b72012-10-18 19:05:02 +0000202
203 // If Sema's ExternalSource is the multiplexer - we own it.
204 if (isMultiplexExternalSource)
205 delete ExternalSource;
Alexey Bataev0c018352013-09-06 18:03:48 +0000206
207 // Destroys data sharing attributes stack for OpenMP
208 DestroyDataSharingAttributesStack();
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000209}
210
John McCallf85e1932011-06-15 23:02:42 +0000211/// makeUnavailableInSystemHeader - There is an error in the current
212/// context. If we're still in a system header, and we can plausibly
213/// make the relevant declaration unavailable instead of erroring, do
214/// so and return true.
215bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000216 StringRef msg) {
John McCallf85e1932011-06-15 23:02:42 +0000217 // If we're not in a function, it's an error.
218 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
219 if (!fn) return false;
220
221 // If we're in template instantiation, it's an error.
222 if (!ActiveTemplateInstantiations.empty())
223 return false;
Michael Gottesman0116a402013-01-20 01:04:14 +0000224
John McCallf85e1932011-06-15 23:02:42 +0000225 // If that function's not in a system header, it's an error.
226 if (!Context.getSourceManager().isInSystemHeader(loc))
227 return false;
228
229 // If the function is already unavailable, it's not an error.
230 if (fn->hasAttr<UnavailableAttr>()) return true;
231
232 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
233 return true;
234}
235
Sebastian Redl58a2cd82011-04-24 16:28:06 +0000236ASTMutationListener *Sema::getASTMutationListener() const {
237 return getASTConsumer().GetASTMutationListener();
238}
239
Axel Naumann0ec56b72012-10-18 19:05:02 +0000240///\brief Registers an external source. If an external source already exists,
241/// creates a multiplex external source and appends to it.
242///
243///\param[in] E - A non-null external sema source.
244///
245void Sema::addExternalSource(ExternalSemaSource *E) {
246 assert(E && "Cannot use with NULL ptr");
247
248 if (!ExternalSource) {
249 ExternalSource = E;
250 return;
251 }
252
253 if (isMultiplexExternalSource)
254 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
255 else {
256 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
257 isMultiplexExternalSource = true;
258 }
259}
260
Chandler Carruth5d989942011-07-06 16:21:37 +0000261/// \brief Print out statistics about the semantic analysis.
262void Sema::PrintStats() const {
263 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
264 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
265
266 BumpAlloc.PrintStats();
267 AnalysisWarnings.PrintStats();
268}
269
Richard Smithc8d7f582011-11-29 22:48:16 +0000270/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
271/// If there is already an implicit cast, merge into the existing one.
272/// The result is of the given category.
273ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
274 CastKind Kind, ExprValueKind VK,
275 const CXXCastPath *BasePath,
276 CheckedConversionKind CCK) {
Richard Smith9c129f82011-10-28 03:31:48 +0000277#ifndef NDEBUG
278 if (VK == VK_RValue && !E->isRValue()) {
279 switch (Kind) {
280 default:
281 assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
282 case CK_LValueToRValue:
283 case CK_ArrayToPointerDecay:
284 case CK_FunctionToPointerDecay:
285 case CK_ToVoid:
286 break;
287 }
288 }
Richard Smithacdfa4d2011-11-10 23:32:36 +0000289 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
Richard Smith9c129f82011-10-28 03:31:48 +0000290#endif
291
John Wiegley429bb272011-04-08 18:41:53 +0000292 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang3a2c7442008-09-04 08:38:01 +0000293 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000294
Mon P Wang3a2c7442008-09-04 08:38:01 +0000295 if (ExprTy == TypeTy)
John Wiegley429bb272011-04-08 18:41:53 +0000296 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000297
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000298 // If this is a derived-to-base cast to a through a virtual base, we
299 // need a vtable.
Michael Gottesman0116a402013-01-20 01:04:14 +0000300 if (Kind == CK_DerivedToBase &&
John McCallf871d0c2010-08-07 06:22:56 +0000301 BasePathInvolvesVirtualBase(*BasePath)) {
John Wiegley429bb272011-04-08 18:41:53 +0000302 QualType T = E->getType();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000303 if (const PointerType *Pointer = T->getAs<PointerType>())
304 T = Pointer->getPointeeType();
305 if (const RecordType *RecordTy = T->getAs<RecordType>())
Michael Gottesman0116a402013-01-20 01:04:14 +0000306 MarkVTableUsed(E->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000307 cast<CXXRecordDecl>(RecordTy->getDecl()));
308 }
Anders Carlsson4c5fad32009-09-15 05:28:24 +0000309
Richard Smithc8d7f582011-11-29 22:48:16 +0000310 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
311 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
312 ImpCast->setType(Ty);
313 ImpCast->setValueKind(VK);
314 return Owned(E);
315 }
316 }
317
318 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
Sebastian Redl906082e2010-07-20 04:20:21 +0000319}
320
Abramo Bagnara737d5442011-04-07 09:26:19 +0000321/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
322/// to the conversion from scalar type ScalarTy to the Boolean type.
323CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
324 switch (ScalarTy->getScalarTypeKind()) {
325 case Type::STK_Bool: return CK_NoOp;
John McCall1d9b3b22011-09-09 05:25:32 +0000326 case Type::STK_CPointer: return CK_PointerToBoolean;
327 case Type::STK_BlockPointer: return CK_PointerToBoolean;
328 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara737d5442011-04-07 09:26:19 +0000329 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
330 case Type::STK_Integral: return CK_IntegralToBoolean;
331 case Type::STK_Floating: return CK_FloatingToBoolean;
332 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
333 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
334 }
335 return CK_Invalid;
336}
337
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000338/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
339static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindolab9725cf2013-01-08 19:43:34 +0000340 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000341 return true;
342
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000343 if (D->isExternallyVisible())
Rafael Espindola2d1b0962013-03-14 03:07:35 +0000344 return true;
345
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000346 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
347 // UnusedFileScopedDecls stores the first declaration.
348 // The declaration may have become definition so check again.
349 const FunctionDecl *DeclToCheck;
350 if (FD->hasBody(DeclToCheck))
351 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
352
353 // Later redecls may add new information resulting in not having to warn,
354 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000355 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000356 if (DeclToCheck != FD)
357 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
358 }
359
360 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedman1507bf52013-09-10 21:10:25 +0000361 // If a variable usable in constant expressions is referenced,
362 // don't warn if it isn't used: if the value of a variable is required
363 // for the computation of a constant expression, it doesn't make sense to
364 // warn even if the variable isn't odr-used. (isReferenced doesn't
365 // precisely reflect that, but it's a decent approximation.)
366 if (VD->isReferenced() &&
367 VD->isUsableInConstantExpressions(SemaRef->Context))
368 return true;
369
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000370 // UnusedFileScopedDecls stores the first declaration.
371 // The declaration may have become definition so check again.
Michael Gottesman0116a402013-01-20 01:04:14 +0000372 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000373 if (DeclToCheck)
374 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
375
376 // Later redecls may add new information resulting in not having to warn,
377 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000378 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000379 if (DeclToCheck != VD)
380 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
381 }
382
383 return false;
384}
385
John McCall15e310a2011-02-19 02:53:41 +0000386namespace {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000387 struct SortUndefinedButUsed {
Nick Lewycky995e26b2013-01-31 03:23:57 +0000388 const SourceManager &SM;
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000389 explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {}
John McCall15e310a2011-02-19 02:53:41 +0000390
Nick Lewycky995e26b2013-01-31 03:23:57 +0000391 bool operator()(const std::pair<NamedDecl *, SourceLocation> &l,
392 const std::pair<NamedDecl *, SourceLocation> &r) const {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000393 if (l.second.isValid() && !r.second.isValid())
394 return true;
395 if (!l.second.isValid() && r.second.isValid())
396 return false;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000397 if (l.second != r.second)
398 return SM.isBeforeInTranslationUnit(l.second, r.second);
399 return SM.isBeforeInTranslationUnit(l.first->getLocation(),
400 r.first->getLocation());
401 }
John McCall15e310a2011-02-19 02:53:41 +0000402 };
John McCall15e310a2011-02-19 02:53:41 +0000403}
404
Nick Lewycky995e26b2013-01-31 03:23:57 +0000405/// Obtains a sorted list of functions that are undefined but ODR-used.
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000406void Sema::getUndefinedButUsed(
Nick Lewycky995e26b2013-01-31 03:23:57 +0000407 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
408 for (llvm::DenseMap<NamedDecl *, SourceLocation>::iterator
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000409 I = UndefinedButUsed.begin(), E = UndefinedButUsed.end();
Nick Lewycky995e26b2013-01-31 03:23:57 +0000410 I != E; ++I) {
411 NamedDecl *ND = I->first;
412
413 // Ignore attributes that have become invalid.
414 if (ND->isInvalidDecl()) continue;
415
Nick Lewycky995e26b2013-01-31 03:23:57 +0000416 // __attribute__((weakref)) is basically a definition.
417 if (ND->hasAttr<WeakRefAttr>()) continue;
418
419 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
420 if (FD->isDefined())
421 continue;
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000422 if (FD->isExternallyVisible() &&
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000423 !FD->getMostRecentDecl()->isInlined())
424 continue;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000425 } else {
426 if (cast<VarDecl>(ND)->hasDefinition() != VarDecl::DeclarationOnly)
427 continue;
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000428 if (ND->isExternallyVisible())
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000429 continue;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000430 }
431
432 Undefined.push_back(std::make_pair(ND, I->second));
433 }
434
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000435 // Sort (in order of use site) so that we're not dependent on the iteration
436 // order through an llvm::DenseMap.
Nick Lewycky995e26b2013-01-31 03:23:57 +0000437 std::sort(Undefined.begin(), Undefined.end(),
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000438 SortUndefinedButUsed(Context.getSourceManager()));
Nick Lewycky995e26b2013-01-31 03:23:57 +0000439}
440
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000441/// checkUndefinedButUsed - Check for undefined objects with internal linkage
442/// or that are inline.
443static void checkUndefinedButUsed(Sema &S) {
444 if (S.UndefinedButUsed.empty()) return;
John McCall15e310a2011-02-19 02:53:41 +0000445
446 // Collect all the still-undefined entities with internal linkage.
Nick Lewycky995e26b2013-01-31 03:23:57 +0000447 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000448 S.getUndefinedButUsed(Undefined);
Nick Lewycky995e26b2013-01-31 03:23:57 +0000449 if (Undefined.empty()) return;
John McCall15e310a2011-02-19 02:53:41 +0000450
Nick Lewycky995e26b2013-01-31 03:23:57 +0000451 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
452 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
453 NamedDecl *ND = I->first;
John McCall15e310a2011-02-19 02:53:41 +0000454
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000455 if (!ND->isExternallyVisible()) {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000456 S.Diag(ND->getLocation(), diag::warn_undefined_internal)
457 << isa<VarDecl>(ND) << ND;
458 } else {
459 assert(cast<FunctionDecl>(ND)->getMostRecentDecl()->isInlined() &&
460 "used object requires definition but isn't inline or internal?");
461 S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND;
462 }
463 if (I->second.isValid())
464 S.Diag(I->second, diag::note_used_here);
John McCall15e310a2011-02-19 02:53:41 +0000465 }
466}
467
Douglas Gregor31e37b22011-07-28 18:09:57 +0000468void Sema::LoadExternalWeakUndeclaredIdentifiers() {
469 if (!ExternalSource)
470 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000471
Douglas Gregor31e37b22011-07-28 18:09:57 +0000472 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
473 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
474 for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
475 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
476 = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
477 if (Pos != WeakUndeclaredIdentifiers.end())
478 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000479
Douglas Gregor31e37b22011-07-28 18:09:57 +0000480 WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
481 }
482}
483
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000484
485typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
486
487/// \brief Returns true, if all methods and nested classes of the given
488/// CXXRecordDecl are defined in this translation unit.
489///
490/// Should only be called from ActOnEndOfTranslationUnit so that all
491/// definitions are actually read.
492static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
493 RecordCompleteMap &MNCComplete) {
494 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
495 if (Cache != MNCComplete.end())
496 return Cache->second;
497 if (!RD->isCompleteDefinition())
498 return false;
499 bool Complete = true;
500 for (DeclContext::decl_iterator I = RD->decls_begin(),
501 E = RD->decls_end();
502 I != E && Complete; ++I) {
503 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
504 Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jasper0e9e9f82012-06-14 20:56:06 +0000505 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
506 Complete = F->getTemplatedDecl()->isDefined();
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000507 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
508 if (R->isInjectedClassName())
509 continue;
510 if (R->hasDefinition())
511 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
512 MNCComplete);
513 else
514 Complete = false;
515 }
516 }
517 MNCComplete[RD] = Complete;
518 return Complete;
519}
520
521/// \brief Returns true, if the given CXXRecordDecl is fully defined in this
522/// translation unit, i.e. all methods are defined or pure virtual and all
523/// friends, friend functions and nested classes are fully defined in this
524/// translation unit.
525///
526/// Should only be called from ActOnEndOfTranslationUnit so that all
527/// definitions are actually read.
528static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
529 RecordCompleteMap &RecordsComplete,
530 RecordCompleteMap &MNCComplete) {
531 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
532 if (Cache != RecordsComplete.end())
533 return Cache->second;
534 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
535 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
536 E = RD->friend_end();
537 I != E && Complete; ++I) {
538 // Check if friend classes and methods are complete.
539 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
540 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
541 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
542 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
543 else
544 Complete = false;
545 } else {
546 // Friend functions are available through the NamedDecl of FriendDecl.
547 if (const FunctionDecl *FD =
548 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
549 Complete = FD->isDefined();
550 else
551 // This is a template friend, give up.
552 Complete = false;
553 }
554 }
555 RecordsComplete[RD] = Complete;
556 return Complete;
557}
558
Chris Lattner9299f3f2008-08-23 03:19:52 +0000559/// ActOnEndOfTranslationUnit - This is called at the very end of the
560/// translation unit when EOF is reached and all but the top-level scope is
561/// popped.
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000562void Sema::ActOnEndOfTranslationUnit() {
John McCall92576642012-05-07 06:16:41 +0000563 assert(DelayedDiagnostics.getCurrentPool() == NULL
564 && "reached end of translation unit with a pool attached?");
565
Douglas Gregord82f5eb2012-08-17 22:17:36 +0000566 // If code completion is enabled, don't perform any end-of-translation-unit
567 // work.
568 if (PP.isCodeCompletionEnabled())
569 return;
570
Richard Smithb7751002013-07-25 23:08:39 +0000571 // Complete translation units and modules define vtables and perform implicit
572 // instantiations. PCH files do not.
573 if (TUKind != TU_Prefix) {
Argyrios Kyrtzidis849639d2012-02-07 16:50:53 +0000574 DiagnoseUseOfUnimplementedSelectors();
575
Chandler Carruthaee543a2010-12-12 21:36:11 +0000576 // If any dynamic classes have their key function defined within
577 // this translation unit, then those vtables are considered "used" and must
578 // be emitted.
Douglas Gregora126f172011-07-28 00:53:40 +0000579 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
580 E = DynamicClasses.end();
581 I != E; ++I) {
582 assert(!(*I)->isDependentType() &&
Anders Carlssona5c6c2a2011-01-25 18:08:22 +0000583 "Should not see dependent types here!");
John McCalld5617ee2013-01-25 22:31:03 +0000584 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) {
Chandler Carruthaee543a2010-12-12 21:36:11 +0000585 const FunctionDecl *Definition = 0;
586 if (KeyFunction->hasBody(Definition))
Douglas Gregora126f172011-07-28 00:53:40 +0000587 MarkVTableUsed(Definition->getLocation(), *I, true);
Chandler Carruthaee543a2010-12-12 21:36:11 +0000588 }
589 }
590
Nick Lewycky81559102011-05-31 07:58:42 +0000591 // If DefinedUsedVTables ends up marking any virtual member functions it
592 // might lead to more pending template instantiations, which we then need
593 // to instantiate.
594 DefineUsedVTables();
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000595
Nick Lewycky81559102011-05-31 07:58:42 +0000596 // C++: Perform implicit template instantiations.
597 //
598 // FIXME: When we perform these implicit instantiations, we do not
599 // carefully keep track of the point of instantiation (C++ [temp.point]).
600 // This means that name lookup that occurs within the template
601 // instantiation will always happen at the end of the translation unit,
Richard Smithb7751002013-07-25 23:08:39 +0000602 // so it will find some names that are not required to be found. This is
603 // valid, but we could do better by diagnosing if an instantiation uses a
604 // name that was not visible at its first point of instantiation.
Nick Lewycky81559102011-05-31 07:58:42 +0000605 PerformPendingInstantiations();
Nick Lewycky2a5f99e2010-11-25 00:35:20 +0000606 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000607
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000608 // Remove file scoped decls that turned out to be used.
Daniel Jasper676ea9d2013-04-30 06:43:16 +0000609 UnusedFileScopedDecls.erase(
610 std::remove_if(UnusedFileScopedDecls.begin(0, true),
611 UnusedFileScopedDecls.end(),
612 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)),
613 UnusedFileScopedDecls.end());
Douglas Gregor47268a32010-04-09 17:41:13 +0000614
Douglas Gregor467dc882011-08-25 22:30:56 +0000615 if (TUKind == TU_Prefix) {
616 // Translation unit prefixes don't need any of the checking below.
Douglas Gregor87c08a52010-08-13 22:48:40 +0000617 TUScope = 0;
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000618 return;
Douglas Gregor87c08a52010-08-13 22:48:40 +0000619 }
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000620
Chris Lattner63d65f82009-09-08 18:19:27 +0000621 // Check for #pragma weak identifiers that were never declared
622 // FIXME: This will cause diagnostics to be emitted in a non-determinstic
623 // order! Iterating over a densemap like this is bad.
Douglas Gregor31e37b22011-07-28 18:09:57 +0000624 LoadExternalWeakUndeclaredIdentifiers();
Ryan Flynne25ff832009-07-30 03:15:39 +0000625 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Chris Lattner63d65f82009-09-08 18:19:27 +0000626 I = WeakUndeclaredIdentifiers.begin(),
627 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
628 if (I->second.getUsed()) continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000629
Chris Lattner63d65f82009-09-08 18:19:27 +0000630 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
631 << I->first;
Ryan Flynne25ff832009-07-30 03:15:39 +0000632 }
633
Argyrios Kyrtzidis975d3532013-03-14 04:44:56 +0000634 if (LangOpts.CPlusPlus11 &&
635 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
636 SourceLocation())
637 != DiagnosticsEngine::Ignored)
638 CheckDelegatingCtorCycles();
639
Douglas Gregor467dc882011-08-25 22:30:56 +0000640 if (TUKind == TU_Module) {
Douglas Gregor90db2602011-12-02 01:47:07 +0000641 // If we are building a module, resolve all of the exported declarations
642 // now.
643 if (Module *CurrentModule = PP.getCurrentModule()) {
644 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesman0116a402013-01-20 01:04:14 +0000645
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000646 SmallVector<Module *, 2> Stack;
Douglas Gregor90db2602011-12-02 01:47:07 +0000647 Stack.push_back(CurrentModule);
648 while (!Stack.empty()) {
Robert Wilhelm344472e2013-08-23 16:11:15 +0000649 Module *Mod = Stack.pop_back_val();
Michael Gottesman0116a402013-01-20 01:04:14 +0000650
Douglas Gregor906d66a2013-03-20 21:10:35 +0000651 // Resolve the exported declarations and conflicts.
Douglas Gregor90db2602011-12-02 01:47:07 +0000652 // FIXME: Actually complain, once we figure out how to teach the
Douglas Gregor906d66a2013-03-20 21:10:35 +0000653 // diagnostic client to deal with complaints in the module map at this
Douglas Gregor90db2602011-12-02 01:47:07 +0000654 // point.
655 ModMap.resolveExports(Mod, /*Complain=*/false);
Douglas Gregor906d66a2013-03-20 21:10:35 +0000656 ModMap.resolveConflicts(Mod, /*Complain=*/false);
Michael Gottesman0116a402013-01-20 01:04:14 +0000657
Douglas Gregor90db2602011-12-02 01:47:07 +0000658 // Queue the submodules, so their exports will also be resolved.
Douglas Gregorb7a78192012-01-04 23:32:19 +0000659 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
660 SubEnd = Mod->submodule_end();
Douglas Gregor90db2602011-12-02 01:47:07 +0000661 Sub != SubEnd; ++Sub) {
Douglas Gregorb7a78192012-01-04 23:32:19 +0000662 Stack.push_back(*Sub);
Douglas Gregor90db2602011-12-02 01:47:07 +0000663 }
664 }
665 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000666
Douglas Gregor467dc882011-08-25 22:30:56 +0000667 // Modules don't need any of the checking below.
668 TUScope = 0;
669 return;
670 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000671
Douglas Gregor275a3692009-03-10 23:43:53 +0000672 // C99 6.9.2p2:
673 // A declaration of an identifier for an object that has file
674 // scope without an initializer, and without a storage-class
675 // specifier or with the storage-class specifier static,
676 // constitutes a tentative definition. If a translation unit
677 // contains one or more tentative definitions for an identifier,
678 // and the translation unit contains no external definition for
679 // that identifier, then the behavior is exactly as if the
680 // translation unit contains a file scope declaration of that
681 // identifier, with the composite type as of the end of the
682 // translation unit, with an initializer equal to 0.
Sebastian Redle9d12b62010-01-31 22:27:38 +0000683 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesman0116a402013-01-20 01:04:14 +0000684 for (TentativeDefinitionsType::iterator
Douglas Gregora8623202011-07-27 20:58:46 +0000685 T = TentativeDefinitions.begin(ExternalSource),
686 TEnd = TentativeDefinitions.end();
Michael Gottesman0116a402013-01-20 01:04:14 +0000687 T != TEnd; ++T)
Douglas Gregora8623202011-07-27 20:58:46 +0000688 {
689 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump1eb44332009-09-09 15:08:12 +0000690
Sebastian Redle9d12b62010-01-31 22:27:38 +0000691 // If the tentative definition was completed, getActingDefinition() returns
692 // null. If we've already seen this variable before, insert()'s second
693 // return value is false.
694 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000695 continue;
696
Mike Stump1eb44332009-09-09 15:08:12 +0000697 if (const IncompleteArrayType *ArrayT
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000698 = Context.getAsIncompleteArrayType(VD->getType())) {
Chris Lattner63d65f82009-09-08 18:19:27 +0000699 // Set the length of the array to 1 (C99 6.9.2p5).
700 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
701 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
John McCall46a617a2009-10-16 00:14:28 +0000702 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
703 One, ArrayType::Normal, 0);
Chris Lattner63d65f82009-09-08 18:19:27 +0000704 VD->setType(T);
Mike Stump1eb44332009-09-09 15:08:12 +0000705 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000706 diag::err_tentative_def_incomplete_type))
707 VD->setInvalidDecl();
708
Eli Friedmane4851f22012-10-23 20:19:32 +0000709 CheckCompleteVariableDeclaration(VD);
710
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000711 // Notify the consumer that we've completed a tentative definition.
712 if (!VD->isInvalidDecl())
713 Consumer.CompleteTentativeDefinition(VD);
714
Douglas Gregor275a3692009-03-10 23:43:53 +0000715 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000716
717 // If there were errors, disable 'unused' warnings since they will mostly be
718 // noise.
719 if (!Diags.hasErrorOccurred()) {
720 // Output warning for unused file scoped decls.
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000721 for (UnusedFileScopedDeclsType::iterator
722 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000723 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000724 if (ShouldRemoveFromUnused(this, *I))
725 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000726
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000727 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
728 const FunctionDecl *DiagD;
729 if (!FD->hasBody(DiagD))
730 DiagD = FD;
Argyrios Kyrtzidis48b89592011-03-03 17:47:42 +0000731 if (DiagD->isDeleted())
732 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000733 if (DiagD->isReferenced()) {
734 if (isa<CXXMethodDecl>(DiagD))
735 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
736 << DiagD->getDeclName();
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000737 else {
Rafael Espindolad2615cc2013-04-03 19:27:57 +0000738 if (FD->getStorageClass() == SC_Static &&
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000739 !FD->isInlineSpecified() &&
Eli Friedman24146972013-08-22 00:27:10 +0000740 !SourceMgr.isInMainFile(
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000741 SourceMgr.getExpansionLoc(FD->getLocation())))
742 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
743 << DiagD->getDeclName();
744 else
745 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
746 << /*function*/0 << DiagD->getDeclName();
747 }
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000748 } else {
749 Diag(DiagD->getLocation(),
750 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
751 : diag::warn_unused_function)
752 << DiagD->getDeclName();
753 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000754 } else {
755 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
756 if (!DiagD)
757 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000758 if (DiagD->isReferenced()) {
759 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
760 << /*variable*/1 << DiagD->getDeclName();
Eli Friedman39bd3712013-09-10 03:05:56 +0000761 } else {
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000762 Diag(DiagD->getLocation(), diag::warn_unused_variable)
Matt Beaumont-Gay19b6a702013-04-10 00:47:10 +0000763 << DiagD->getDeclName();
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000764 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000765 }
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000766 }
John McCall15e310a2011-02-19 02:53:41 +0000767
Nick Lewycky01a41142013-01-26 00:35:08 +0000768 if (ExternalSource)
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000769 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
770 checkUndefinedButUsed(*this);
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000771 }
Douglas Gregor87c08a52010-08-13 22:48:40 +0000772
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000773 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
774 SourceLocation())
775 != DiagnosticsEngine::Ignored) {
776 RecordCompleteMap RecordsComplete;
777 RecordCompleteMap MNCComplete;
778 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
779 E = UnusedPrivateFields.end(); I != E; ++I) {
780 const NamedDecl *D = *I;
781 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
782 if (RD && !RD->isUnion() &&
783 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
784 Diag(D->getLocation(), diag::warn_unused_private_field)
785 << D->getDeclName();
786 }
787 }
788 }
789
Richard Smith483b9f32011-02-21 20:05:19 +0000790 // Check we've noticed that we're no longer parsing the initializer for every
791 // variable. If we miss cases, then at best we have a performance issue and
792 // at worst a rejects-valid bug.
793 assert(ParsingInitForAutoVars.empty() &&
794 "Didn't unmark var as having its initializer parsed");
795
Douglas Gregor87c08a52010-08-13 22:48:40 +0000796 TUScope = 0;
Chris Lattner9299f3f2008-08-23 03:19:52 +0000797}
798
799
Reid Spencer5f016e22007-07-11 17:01:13 +0000800//===----------------------------------------------------------------------===//
801// Helper functions.
802//===----------------------------------------------------------------------===//
803
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000804DeclContext *Sema::getFunctionLevelDeclContext() {
John McCalldb0ee1d2009-12-19 10:53:49 +0000805 DeclContext *DC = CurContext;
Mike Stump1eb44332009-09-09 15:08:12 +0000806
Eli Friedman72899c32012-01-07 04:59:52 +0000807 while (true) {
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000808 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
Eli Friedman72899c32012-01-07 04:59:52 +0000809 DC = DC->getParent();
810 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor215e4e12012-02-12 17:34:23 +0000811 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman72899c32012-01-07 04:59:52 +0000812 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
813 DC = DC->getParent()->getParent();
814 }
815 else break;
816 }
Mike Stump1eb44332009-09-09 15:08:12 +0000817
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000818 return DC;
819}
820
Chris Lattner371f2582008-12-04 23:50:19 +0000821/// getCurFunctionDecl - If inside of a function body, this returns a pointer
822/// to the function decl for the function being parsed. If we're currently
823/// in a 'block', this returns the containing context.
824FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000825 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000826 return dyn_cast<FunctionDecl>(DC);
827}
828
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000829ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000830 DeclContext *DC = getFunctionLevelDeclContext();
Fariborz Jahanian69f86d92013-05-31 21:51:12 +0000831 while (isa<RecordDecl>(DC))
832 DC = DC->getParent();
Steve Naroffd7612e12008-11-17 16:28:52 +0000833 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000834}
Chris Lattner371f2582008-12-04 23:50:19 +0000835
836NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000837 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000838 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000839 return cast<NamedDecl>(DC);
Chris Lattner371f2582008-12-04 23:50:19 +0000840 return 0;
841}
842
Daniel Dunbar393eed72012-03-14 09:49:32 +0000843void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
844 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
845 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
846 // been made more painfully obvious by the refactor that introduced this
847 // function, but it is possible that the incoming argument can be
848 // eliminnated. If it truly cannot be (for example, there is some reentrancy
849 // issue I am not seeing yet), then there should at least be a clarifying
850 // comment somewhere.
David Blaikiedc84cd52013-02-20 22:23:23 +0000851 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
Daniel Dunbar393eed72012-03-14 09:49:32 +0000852 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
853 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000854 case DiagnosticIDs::SFINAE_Report:
Richard Smith77faa362011-10-19 00:07:01 +0000855 // We'll report the diagnostic below.
Douglas Gregor9b623632010-10-12 23:32:35 +0000856 break;
Michael Gottesman0116a402013-01-20 01:04:14 +0000857
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000858 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor9b623632010-10-12 23:32:35 +0000859 // Count this failure so that we know that template argument deduction
860 // has failed.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000861 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000862
863 // Make a copy of this suppressed diagnostic and store it with the
864 // template-deduction information.
865 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
866 Diagnostic DiagInfo(&Diags);
867 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
868 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
869 }
870
Daniel Dunbar393eed72012-03-14 09:49:32 +0000871 Diags.setLastDiagnosticIgnored();
872 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000873 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000874
Richard Smith77faa362011-10-19 00:07:01 +0000875 case DiagnosticIDs::SFINAE_AccessControl: {
876 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbar00b43842012-03-13 18:30:54 +0000877 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith77faa362011-10-19 00:07:01 +0000878 // make access control a part of SFINAE for the purposes of checking
879 // type traits.
Richard Smith80ad52f2013-01-02 11:42:31 +0000880 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith77faa362011-10-19 00:07:01 +0000881 break;
882
Daniel Dunbar393eed72012-03-14 09:49:32 +0000883 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith77faa362011-10-19 00:07:01 +0000884
885 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000886 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000887
888 // Make a copy of this suppressed diagnostic and store it with the
889 // template-deduction information.
890 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
891 Diagnostic DiagInfo(&Diags);
892 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
893 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
894 }
895
Daniel Dunbar393eed72012-03-14 09:49:32 +0000896 Diags.setLastDiagnosticIgnored();
897 Diags.Clear();
Richard Smith77faa362011-10-19 00:07:01 +0000898
899 // Now the diagnostic state is clear, produce a C++98 compatibility
900 // warning.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000901 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith77faa362011-10-19 00:07:01 +0000902
903 // The last diagnostic which Sema produced was ignored. Suppress any
904 // notes attached to it.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000905 Diags.setLastDiagnosticIgnored();
Richard Smith77faa362011-10-19 00:07:01 +0000906 return;
907 }
908
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000909 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor9b623632010-10-12 23:32:35 +0000910 // Make a copy of this suppressed diagnostic and store it with the
911 // template-deduction information;
Richard Smithb8590f32012-05-07 09:03:25 +0000912 if (*Info) {
913 Diagnostic DiagInfo(&Diags);
Douglas Gregor1eee5dc2011-01-27 22:31:44 +0000914 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smithb8590f32012-05-07 09:03:25 +0000915 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
916 }
917
918 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000919 Diags.setLastDiagnosticIgnored();
920 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000921 return;
922 }
923 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000924
Douglas Gregor8987b232011-09-27 23:30:47 +0000925 // Set up the context's printing policy based on our current state.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000926 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesman0116a402013-01-20 01:04:14 +0000927
Douglas Gregor9b623632010-10-12 23:32:35 +0000928 // Emit the diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000929 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000930 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000931
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000932 // If this is not a note, and we're in a template instantiation
933 // that is different from the last template instantiation where
934 // we emitted an error, print a template instantiation
935 // backtrace.
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000936 if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
Daniel Dunbar393eed72012-03-14 09:49:32 +0000937 !ActiveTemplateInstantiations.empty() &&
938 ActiveTemplateInstantiations.back()
939 != LastTemplateInstantiationErrorContext) {
940 PrintInstantiationStack();
941 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000942 }
943}
Douglas Gregor2e222532009-07-02 17:08:52 +0000944
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000945Sema::SemaDiagnosticBuilder
946Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
947 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
948 PD.Emit(Builder);
Mike Stump1eb44332009-09-09 15:08:12 +0000949
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000950 return Builder;
951}
952
Chandler Carruth108f7562011-07-26 05:40:03 +0000953/// \brief Looks through the macro-expansion chain for the given
954/// location, looking for a macro expansion with the given name.
John McCall834e3f62011-03-08 07:59:04 +0000955/// If one is found, returns true and sets the location to that
Chandler Carruth108f7562011-07-26 05:40:03 +0000956/// expansion loc.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000957bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall834e3f62011-03-08 07:59:04 +0000958 SourceLocation loc = locref;
959 if (!loc.isMacroID()) return false;
960
961 // There's no good way right now to look at the intermediate
Chandler Carruth108f7562011-07-26 05:40:03 +0000962 // expansions, so just jump to the expansion location.
Chandler Carruth40278532011-07-25 16:49:02 +0000963 loc = getSourceManager().getExpansionLoc(loc);
John McCall834e3f62011-03-08 07:59:04 +0000964
965 // If that's written with the name, stop here.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000966 SmallVector<char, 16> buffer;
John McCall834e3f62011-03-08 07:59:04 +0000967 if (getPreprocessor().getSpelling(loc, buffer) == name) {
968 locref = loc;
969 return true;
970 }
971 return false;
972}
973
Douglas Gregor23c94db2010-07-02 17:43:08 +0000974/// \brief Determines the active Scope associated with the given declaration
975/// context.
976///
977/// This routine maps a declaration context to the active Scope object that
978/// represents that declaration context in the parser. It is typically used
979/// from "scope-less" code (e.g., template instantiation, lazy creation of
980/// declarations) that injects a name for name-lookup purposes and, therefore,
981/// must update the Scope.
982///
983/// \returns The scope corresponding to the given declaraion context, or NULL
984/// if no such scope is open.
985Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesman0116a402013-01-20 01:04:14 +0000986
Douglas Gregor23c94db2010-07-02 17:43:08 +0000987 if (!Ctx)
988 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +0000989
Douglas Gregor23c94db2010-07-02 17:43:08 +0000990 Ctx = Ctx->getPrimaryContext();
991 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcddc69f2010-07-08 23:07:34 +0000992 // Ignore scopes that cannot have declarations. This is important for
993 // out-of-line definitions of static class members.
994 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
995 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
996 if (Ctx == Entity->getPrimaryContext())
997 return S;
Douglas Gregor23c94db2010-07-02 17:43:08 +0000998 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000999
Douglas Gregor23c94db2010-07-02 17:43:08 +00001000 return 0;
1001}
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001002
1003/// \brief Enter a new function scope
1004void Sema::PushFunctionScope() {
John McCall781472f2010-08-25 08:40:02 +00001005 if (FunctionScopes.size() == 1) {
1006 // Use the "top" function scope rather than having to allocate
1007 // memory for a new scope.
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001008 FunctionScopes.back()->Clear();
John McCall781472f2010-08-25 08:40:02 +00001009 FunctionScopes.push_back(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001010 return;
1011 }
Michael Gottesman0116a402013-01-20 01:04:14 +00001012
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001013 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001014}
1015
1016void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001017 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001018 BlockScope, Block));
1019}
1020
Manuel Klimek152b4e42013-08-22 12:12:24 +00001021void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
1022 CXXMethodDecl *CallOperator) {
1023 FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
1024 CallOperator));
Eli Friedmanec9ea722012-01-05 03:35:19 +00001025}
1026
1027void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1028 const Decl *D, const BlockExpr *blkExpr) {
Michael Gottesman0116a402013-01-20 01:04:14 +00001029 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
John McCall781472f2010-08-25 08:40:02 +00001030 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Michael Gottesman0116a402013-01-20 01:04:14 +00001031
Ted Kremenek3ed6fc02011-02-23 01:51:48 +00001032 // Issue any analysis-based warnings.
1033 if (WP && D)
Ted Kremenek283a3582011-02-23 01:51:53 +00001034 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
Ted Kremenek351ba912011-02-23 01:52:04 +00001035 else {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001036 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
Ted Kremenek351ba912011-02-23 01:52:04 +00001037 i = Scope->PossiblyUnreachableDiags.begin(),
1038 e = Scope->PossiblyUnreachableDiags.end();
1039 i != e; ++i) {
1040 const sema::PossiblyUnreachableDiag &D = *i;
1041 Diag(D.Loc, D.PD);
1042 }
1043 }
Ted Kremenek3ed6fc02011-02-23 01:51:48 +00001044
Ted Kremenek351ba912011-02-23 01:52:04 +00001045 if (FunctionScopes.back() != Scope) {
John McCall781472f2010-08-25 08:40:02 +00001046 delete Scope;
Ted Kremenek351ba912011-02-23 01:52:04 +00001047 }
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001048}
1049
Dmitri Gribenko625bb562012-02-14 22:14:32 +00001050void Sema::PushCompoundScope() {
1051 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1052}
1053
1054void Sema::PopCompoundScope() {
1055 FunctionScopeInfo *CurFunction = getCurFunction();
1056 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1057
1058 CurFunction->CompoundScopes.pop_back();
1059}
1060
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001061/// \brief Determine whether any errors occurred within this function/method/
1062/// block.
John McCallf85e1932011-06-15 23:02:42 +00001063bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1064 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001065}
1066
1067BlockScopeInfo *Sema::getCurBlock() {
1068 if (FunctionScopes.empty())
1069 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001070
1071 return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001072}
John McCall76bd1f32010-06-01 09:23:16 +00001073
Eli Friedman906a7e12012-01-06 03:05:34 +00001074LambdaScopeInfo *Sema::getCurLambda() {
1075 if (FunctionScopes.empty())
1076 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001077
1078 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
Eli Friedman906a7e12012-01-06 03:05:34 +00001079}
1080
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001081void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenek127ff2e2012-09-13 06:41:18 +00001082 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1083 SourceMgr.isInSystemHeader(Comment.getBegin()))
1084 return;
Dmitri Gribenko6fd7d302013-04-10 15:35:17 +00001085 RawComment RC(SourceMgr, Comment, false,
1086 LangOpts.CommentOpts.ParseAllComments);
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001087 if (RC.isAlmostTrailingComment()) {
1088 SourceRange MagicMarkerRange(Comment.getBegin(),
1089 Comment.getBegin().getLocWithOffset(3));
1090 StringRef MagicMarkerText;
1091 switch (RC.getKind()) {
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001092 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001093 MagicMarkerText = "///<";
1094 break;
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001095 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001096 MagicMarkerText = "/**<";
1097 break;
1098 default:
1099 llvm_unreachable("if this is an almost Doxygen comment, "
1100 "it should be ordinary");
1101 }
1102 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1103 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1104 }
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001105 Context.addComment(RC);
1106}
1107
John McCall76bd1f32010-06-01 09:23:16 +00001108// Pin this vtable to this file.
1109ExternalSemaSource::~ExternalSemaSource() {}
John McCallf312b1e2010-08-26 23:41:50 +00001110
Douglas Gregor5ac4b692012-01-25 00:49:42 +00001111void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Sebastian Redl8c845712010-09-28 20:23:00 +00001112
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001113void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesman0116a402013-01-20 01:04:14 +00001114 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001115}
1116
Nick Lewyckycd0655b2013-02-01 08:13:20 +00001117void ExternalSemaSource::ReadUndefinedButUsed(
Nick Lewycky995e26b2013-01-31 03:23:57 +00001118 llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) {
Nick Lewycky01a41142013-01-26 00:35:08 +00001119}
1120
Chris Lattner5f9e2722011-07-23 10:55:15 +00001121void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
John McCallf312b1e2010-08-26 23:41:50 +00001122 SourceLocation Loc = this->Loc;
1123 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1124 if (Loc.isValid()) {
1125 Loc.print(OS, S.getSourceManager());
1126 OS << ": ";
1127 }
1128 OS << Message;
1129
1130 if (TheDecl && isa<NamedDecl>(TheDecl)) {
1131 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1132 if (!Name.empty())
1133 OS << " '" << Name << '\'';
1134 }
1135
1136 OS << '\n';
1137}
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001138
1139/// \brief Figure out if an expression could be turned into a call.
1140///
1141/// Use this when trying to recover from an error where the programmer may have
1142/// written just the name of a function instead of actually calling it.
1143///
1144/// \param E - The expression to examine.
1145/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1146/// with no arguments, this parameter is set to the type returned by such a
1147/// call; otherwise, it is set to an empty QualType.
John McCall6dbba4f2011-10-11 23:14:30 +00001148/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001149/// name, this parameter is populated with the decls of the various overloads.
David Blaikiec8fa5252013-06-21 23:54:45 +00001150bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1151 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001152 ZeroArgCallReturnTy = QualType();
John McCall6dbba4f2011-10-11 23:14:30 +00001153 OverloadSet.clear();
1154
David Blaikiec2fe8182013-06-04 00:28:46 +00001155 const OverloadExpr *Overloads = NULL;
David Blaikiec8fa5252013-06-21 23:54:45 +00001156 bool IsMemExpr = false;
John McCall6dbba4f2011-10-11 23:14:30 +00001157 if (E.getType() == Context.OverloadTy) {
1158 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
John McCall6dbba4f2011-10-11 23:14:30 +00001159
David Blaikiec2fe8182013-06-04 00:28:46 +00001160 // Ignore overloads that are pointer-to-member constants.
1161 if (FR.HasFormOfMemberPointer)
1162 return false;
1163
1164 Overloads = FR.Expression;
1165 } else if (E.getType() == Context.BoundMemberTy) {
1166 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
David Blaikiec8fa5252013-06-21 23:54:45 +00001167 IsMemExpr = true;
David Blaikiec2fe8182013-06-04 00:28:46 +00001168 }
David Blaikiec8fa5252013-06-21 23:54:45 +00001169
1170 bool Ambiguous = false;
1171
David Blaikiec2fe8182013-06-04 00:28:46 +00001172 if (Overloads) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001173 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1174 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall6dbba4f2011-10-11 23:14:30 +00001175 OverloadSet.addDecl(*it);
1176
David Blaikiec8fa5252013-06-21 23:54:45 +00001177 // Check whether the function is a non-template, non-member which takes no
John McCall6dbba4f2011-10-11 23:14:30 +00001178 // arguments.
David Blaikiec8fa5252013-06-21 23:54:45 +00001179 if (IsMemExpr)
1180 continue;
John McCall6dbba4f2011-10-11 23:14:30 +00001181 if (const FunctionDecl *OverloadDecl
1182 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
David Blaikiec2fe8182013-06-04 00:28:46 +00001183 if (OverloadDecl->getMinRequiredArguments() == 0) {
1184 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) {
1185 ZeroArgCallReturnTy = QualType();
1186 Ambiguous = true;
1187 } else
1188 ZeroArgCallReturnTy = OverloadDecl->getResultType();
1189 }
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001190 }
1191 }
John McCall6dbba4f2011-10-11 23:14:30 +00001192
David Blaikiec8fa5252013-06-21 23:54:45 +00001193 // If it's not a member, use better machinery to try to resolve the call
1194 if (!IsMemExpr)
1195 return !ZeroArgCallReturnTy.isNull();
1196 }
1197
1198 // Attempt to call the member with no arguments - this will correctly handle
1199 // member templates with defaults/deduction of template arguments, overloads
1200 // with default arguments, etc.
Eli Friedmand739c4e2013-07-08 23:35:04 +00001201 if (IsMemExpr && !E.isTypeDependent()) {
David Blaikiec8fa5252013-06-21 23:54:45 +00001202 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1203 getDiagnostics().setSuppressAllDiagnostics(true);
1204 ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None,
1205 SourceLocation());
1206 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1207 if (R.isUsable()) {
1208 ZeroArgCallReturnTy = R.get()->getType();
1209 return true;
1210 }
1211 return false;
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001212 }
1213
John McCall6dbba4f2011-10-11 23:14:30 +00001214 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001215 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1216 if (Fun->getMinRequiredArguments() == 0)
1217 ZeroArgCallReturnTy = Fun->getResultType();
1218 return true;
1219 }
1220 }
1221
1222 // We don't have an expression that's convenient to get a FunctionDecl from,
1223 // but we can at least check if the type is "function of 0 arguments".
1224 QualType ExprTy = E.getType();
1225 const FunctionType *FunTy = NULL;
Matt Beaumont-Gay9389ddc2011-05-05 00:59:35 +00001226 QualType PointeeTy = ExprTy->getPointeeType();
1227 if (!PointeeTy.isNull())
1228 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001229 if (!FunTy)
1230 FunTy = ExprTy->getAs<FunctionType>();
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001231
1232 if (const FunctionProtoType *FPT =
1233 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1234 if (FPT->getNumArgs() == 0)
1235 ZeroArgCallReturnTy = FunTy->getResultType();
1236 return true;
1237 }
1238 return false;
1239}
1240
1241/// \brief Give notes for a set of overloads.
1242///
David Blaikiec8fa5252013-06-21 23:54:45 +00001243/// A companion to tryExprAsCall. In cases when the name that the programmer
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001244/// wrote was an overloaded function, we may be able to make some guesses about
1245/// plausible overloads based on their return types; such guesses can be handed
1246/// off to this method to be emitted as notes.
1247///
1248/// \param Overloads - The overloads to note.
1249/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1250/// -fshow-overloads=best, this is the location to attach to the note about too
1251/// many candidates. Typically this will be the location of the original
1252/// ill-formed expression.
John McCall6dbba4f2011-10-11 23:14:30 +00001253static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1254 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001255 int ShownOverloads = 0;
1256 int SuppressedOverloads = 0;
1257 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1258 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1259 // FIXME: Magic number for max shown overloads stolen from
1260 // OverloadCandidateSet::NoteCandidates.
Douglas Gregordc7b6412012-10-23 23:11:23 +00001261 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001262 ++SuppressedOverloads;
1263 continue;
1264 }
John McCall6dbba4f2011-10-11 23:14:30 +00001265
1266 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Abramo Bagnara9c0e1ec2011-11-15 21:43:28 +00001267 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001268 ++ShownOverloads;
1269 }
John McCall6dbba4f2011-10-11 23:14:30 +00001270
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001271 if (SuppressedOverloads)
John McCall6dbba4f2011-10-11 23:14:30 +00001272 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1273 << SuppressedOverloads;
1274}
1275
1276static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1277 const UnresolvedSetImpl &Overloads,
1278 bool (*IsPlausibleResult)(QualType)) {
1279 if (!IsPlausibleResult)
1280 return noteOverloads(S, Overloads, Loc);
1281
1282 UnresolvedSet<2> PlausibleOverloads;
1283 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1284 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1285 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1286 QualType OverloadResultTy = OverloadDecl->getResultType();
1287 if (IsPlausibleResult(OverloadResultTy))
1288 PlausibleOverloads.addDecl(It.getDecl());
1289 }
1290 noteOverloads(S, PlausibleOverloads, Loc);
1291}
1292
1293/// Determine whether the given expression can be called by just
1294/// putting parentheses after it. Notably, expressions with unary
1295/// operators can't be because the unary operator will start parsing
1296/// outside the call.
1297static bool IsCallableWithAppend(Expr *E) {
1298 E = E->IgnoreImplicit();
1299 return (!isa<CStyleCastExpr>(E) &&
1300 !isa<UnaryOperator>(E) &&
1301 !isa<BinaryOperator>(E) &&
1302 !isa<CXXOperatorCallExpr>(E));
1303}
1304
1305bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1306 bool ForceComplain,
1307 bool (*IsPlausibleResult)(QualType)) {
1308 SourceLocation Loc = E.get()->getExprLoc();
1309 SourceRange Range = E.get()->getSourceRange();
1310
1311 QualType ZeroArgCallTy;
1312 UnresolvedSet<4> Overloads;
David Blaikiec8fa5252013-06-21 23:54:45 +00001313 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
John McCall6dbba4f2011-10-11 23:14:30 +00001314 !ZeroArgCallTy.isNull() &&
1315 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1316 // At this point, we know E is potentially callable with 0
1317 // arguments and that it returns something of a reasonable type,
1318 // so we can emit a fixit and carry on pretending that E was
1319 // actually a CallExpr.
Nick Lewyckyf96df622013-08-21 19:09:44 +00001320 SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd());
Michael Gottesman0116a402013-01-20 01:04:14 +00001321 Diag(Loc, PD)
John McCall6dbba4f2011-10-11 23:14:30 +00001322 << /*zero-arg*/ 1 << Range
1323 << (IsCallableWithAppend(E.get())
1324 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1325 : FixItHint());
1326 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1327
1328 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1329 // while doing so.
Nick Lewyckyf96df622013-08-21 19:09:44 +00001330 E = ActOnCallExpr(0, E.take(), Range.getEnd(), None,
1331 Range.getEnd().getLocWithOffset(1));
John McCall6dbba4f2011-10-11 23:14:30 +00001332 return true;
1333 }
1334
1335 if (!ForceComplain) return false;
1336
1337 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1338 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1339 E = ExprError();
1340 return true;
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001341}
Argyrios Kyrtzidis57f8da52013-03-14 22:56:43 +00001342
1343IdentifierInfo *Sema::getSuperIdentifier() const {
1344 if (!Ident_super)
1345 Ident_super = &Context.Idents.get("super");
1346 return Ident_super;
1347}
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001348
Nico Webercac18ad2013-06-20 21:44:55 +00001349IdentifierInfo *Sema::getFloat128Identifier() const {
1350 if (!Ident___float128)
1351 Ident___float128 = &Context.Idents.get("__float128");
1352 return Ident___float128;
1353}
1354
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001355void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
Ben Langmuir3a2f9122013-04-29 13:32:41 +00001356 CapturedRegionKind K) {
Ben Langmuir8c045ac2013-05-03 19:00:33 +00001357 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD,
1358 CD->getContextParam(), K);
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001359 CSI->ReturnType = Context.VoidTy;
1360 FunctionScopes.push_back(CSI);
1361}
1362
1363CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1364 if (FunctionScopes.empty())
1365 return 0;
1366
1367 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1368}