blob: 00f38bfa8c6b70f577aab193a01d7d8da6ccd903 [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),
Richard Smith9bd3cdc2013-09-12 23:28:08 +000092 CurrentInstantiationScope(0), DisableTypoCorrection(false),
93 TyposCorrected(0), AnalysisWarnings(*this),
94 VarDataSharingAttributesStack(0), CurScope(0),
Alexey Bataev0c018352013-09-06 18:03:48 +000095 Ident_super(0), Ident___float128(0)
Douglas Gregorf35f8282009-11-11 21:54:23 +000096{
Steve Naroff3b950172007-10-10 21:53:07 +000097 TUScope = 0;
Michael Gottesman0116a402013-01-20 01:04:14 +000098
Douglas Gregord8bba9c2011-06-28 16:20:02 +000099 LoadedExternalKnownNamespaces = false;
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000100 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
101 NSNumberLiteralMethods[I] = 0;
102
David Blaikie4e4d0842012-03-11 07:00:24 +0000103 if (getLangOpts().ObjC1)
Ted Kremenekebcb57a2012-03-06 20:05:56 +0000104 NSAPIObj.reset(new NSAPI(Context));
105
David Blaikie4e4d0842012-03-11 07:00:24 +0000106 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000107 FieldCollector.reset(new CXXFieldCollector());
Mike Stump1eb44332009-09-09 15:08:12 +0000108
Chris Lattner22caddc2008-11-23 09:13:29 +0000109 // Tell diagnostics how to render things from the AST library.
Michael Gottesman0116a402013-01-20 01:04:14 +0000110 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
Douglas Gregor79a9a342010-02-09 22:26:47 +0000111 &Context);
Douglas Gregor2afce722009-11-26 00:44:06 +0000112
113 ExprEvalContexts.push_back(
Richard Smith76f3f692012-02-22 02:04:18 +0000114 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
115 false, 0, false));
John McCall781472f2010-08-25 08:40:02 +0000116
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +0000117 FunctionScopes.push_back(new FunctionScopeInfo(Diags));
Alexey Bataev0c018352013-09-06 18:03:48 +0000118
119 // Initilization of data sharing attributes stack for OpenMP
120 InitDataSharingAttributesStack();
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000121}
122
123void Sema::Initialize() {
124 // Tell the AST consumer about this Sema object.
125 Consumer.Initialize(Context);
Michael Gottesman0116a402013-01-20 01:04:14 +0000126
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000127 // FIXME: Isn't this redundant with the initialization above?
128 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
129 SC->InitializeSema(*this);
Michael Gottesman0116a402013-01-20 01:04:14 +0000130
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000131 // Tell the external Sema source about this Sema object.
132 if (ExternalSemaSource *ExternalSema
133 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
134 ExternalSema->InitializeSema(*this);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000135
Douglas Gregor772eeae2011-08-12 06:49:56 +0000136 // Initialize predefined 128-bit integer types, if needed.
Richard Smith84268902012-11-29 05:41:51 +0000137 if (PP.getTargetInfo().hasInt128Type()) {
Douglas Gregor772eeae2011-08-12 06:49:56 +0000138 // If either of the 128-bit integer types are unavailable to name lookup,
139 // define them now.
140 DeclarationName Int128 = &Context.Idents.get("__int128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000141 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000142 PushOnScopeChains(Context.getInt128Decl(), TUScope);
143
144 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000145 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor772eeae2011-08-12 06:49:56 +0000146 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
147 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000148
Douglas Gregor772eeae2011-08-12 06:49:56 +0000149
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000150 // Initialize predefined Objective-C types:
David Blaikie4e4d0842012-03-11 07:00:24 +0000151 if (PP.getLangOpts().ObjC1) {
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000152 // If 'SEL' does not yet refer to any declarations, make it refer to the
153 // predefined 'SEL'.
154 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000155 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor7a27ea52011-08-12 06:17:30 +0000156 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
157
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000158 // If 'id' does not yet refer to any declarations, make it refer to the
159 // predefined 'id'.
160 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000161 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000162 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesman0116a402013-01-20 01:04:14 +0000163
Douglas Gregor79d67262011-08-12 05:59:41 +0000164 // Create the built-in typedef for 'Class'.
165 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregoreee242f2011-10-27 09:33:13 +0000166 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor79d67262011-08-12 05:59:41 +0000167 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregora6ea10e2012-01-17 18:09:05 +0000168
169 // Create the built-in forward declaratino for 'Protocol'.
170 DeclarationName Protocol = &Context.Idents.get("Protocol");
171 if (IdResolver.begin(Protocol) == IdResolver.end())
172 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
Douglas Gregor4dfd02a2011-08-12 05:46:01 +0000173 }
Meador Ingec5613b22012-06-16 03:34:49 +0000174
175 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
176 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
177 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Reid Spencer5f016e22007-07-11 17:01:13 +0000178}
179
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000180Sema::~Sema() {
Richard Smithac32d902013-08-07 21:41:30 +0000181 for (LateParsedTemplateMapT::iterator I = LateParsedTemplateMap.begin(),
182 E = LateParsedTemplateMap.end();
183 I != E; ++I)
184 delete I->second;
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000185 if (PackContext) FreePackedContext();
Eli Friedmanaa8b0d12010-08-05 06:57:20 +0000186 if (VisContext) FreeVisContext();
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000187 delete TheTargetAttributesSema;
Fariborz Jahanian62c92582011-04-25 18:49:15 +0000188 MSStructPragmaOn = false;
John McCall781472f2010-08-25 08:40:02 +0000189 // Kill all the active scopes.
190 for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
191 delete FunctionScopes[I];
192 if (FunctionScopes.size() == 1)
193 delete FunctionScopes[0];
Michael Gottesman0116a402013-01-20 01:04:14 +0000194
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000195 // Tell the SemaConsumer to forget about us; we're going out of scope.
196 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
197 SC->ForgetSema();
198
199 // Detach from the external Sema source.
200 if (ExternalSemaSource *ExternalSema
Douglas Gregor914ed9d2010-08-13 03:15:25 +0000201 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor46ea32a2010-08-12 22:51:45 +0000202 ExternalSema->ForgetSema();
Axel Naumann0ec56b72012-10-18 19:05:02 +0000203
204 // If Sema's ExternalSource is the multiplexer - we own it.
205 if (isMultiplexExternalSource)
206 delete ExternalSource;
Alexey Bataev0c018352013-09-06 18:03:48 +0000207
208 // Destroys data sharing attributes stack for OpenMP
209 DestroyDataSharingAttributesStack();
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000210}
211
John McCallf85e1932011-06-15 23:02:42 +0000212/// makeUnavailableInSystemHeader - There is an error in the current
213/// context. If we're still in a system header, and we can plausibly
214/// make the relevant declaration unavailable instead of erroring, do
215/// so and return true.
216bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000217 StringRef msg) {
John McCallf85e1932011-06-15 23:02:42 +0000218 // If we're not in a function, it's an error.
219 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
220 if (!fn) return false;
221
222 // If we're in template instantiation, it's an error.
223 if (!ActiveTemplateInstantiations.empty())
224 return false;
Michael Gottesman0116a402013-01-20 01:04:14 +0000225
John McCallf85e1932011-06-15 23:02:42 +0000226 // If that function's not in a system header, it's an error.
227 if (!Context.getSourceManager().isInSystemHeader(loc))
228 return false;
229
230 // If the function is already unavailable, it's not an error.
231 if (fn->hasAttr<UnavailableAttr>()) return true;
232
233 fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
234 return true;
235}
236
Sebastian Redl58a2cd82011-04-24 16:28:06 +0000237ASTMutationListener *Sema::getASTMutationListener() const {
238 return getASTConsumer().GetASTMutationListener();
239}
240
Axel Naumann0ec56b72012-10-18 19:05:02 +0000241///\brief Registers an external source. If an external source already exists,
242/// creates a multiplex external source and appends to it.
243///
244///\param[in] E - A non-null external sema source.
245///
246void Sema::addExternalSource(ExternalSemaSource *E) {
247 assert(E && "Cannot use with NULL ptr");
248
249 if (!ExternalSource) {
250 ExternalSource = E;
251 return;
252 }
253
254 if (isMultiplexExternalSource)
255 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
256 else {
257 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
258 isMultiplexExternalSource = true;
259 }
260}
261
Chandler Carruth5d989942011-07-06 16:21:37 +0000262/// \brief Print out statistics about the semantic analysis.
263void Sema::PrintStats() const {
264 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
265 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
266
267 BumpAlloc.PrintStats();
268 AnalysisWarnings.PrintStats();
269}
270
Richard Smithc8d7f582011-11-29 22:48:16 +0000271/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
272/// If there is already an implicit cast, merge into the existing one.
273/// The result is of the given category.
274ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
275 CastKind Kind, ExprValueKind VK,
276 const CXXCastPath *BasePath,
277 CheckedConversionKind CCK) {
Richard Smith9c129f82011-10-28 03:31:48 +0000278#ifndef NDEBUG
279 if (VK == VK_RValue && !E->isRValue()) {
280 switch (Kind) {
281 default:
282 assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
283 case CK_LValueToRValue:
284 case CK_ArrayToPointerDecay:
285 case CK_FunctionToPointerDecay:
286 case CK_ToVoid:
287 break;
288 }
289 }
Richard Smithacdfa4d2011-11-10 23:32:36 +0000290 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
Richard Smith9c129f82011-10-28 03:31:48 +0000291#endif
292
John Wiegley429bb272011-04-08 18:41:53 +0000293 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang3a2c7442008-09-04 08:38:01 +0000294 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000295
Mon P Wang3a2c7442008-09-04 08:38:01 +0000296 if (ExprTy == TypeTy)
John Wiegley429bb272011-04-08 18:41:53 +0000297 return Owned(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000298
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000299 // If this is a derived-to-base cast to a through a virtual base, we
300 // need a vtable.
Michael Gottesman0116a402013-01-20 01:04:14 +0000301 if (Kind == CK_DerivedToBase &&
John McCallf871d0c2010-08-07 06:22:56 +0000302 BasePathInvolvesVirtualBase(*BasePath)) {
John Wiegley429bb272011-04-08 18:41:53 +0000303 QualType T = E->getType();
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000304 if (const PointerType *Pointer = T->getAs<PointerType>())
305 T = Pointer->getPointeeType();
306 if (const RecordType *RecordTy = T->getAs<RecordType>())
Michael Gottesman0116a402013-01-20 01:04:14 +0000307 MarkVTableUsed(E->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +0000308 cast<CXXRecordDecl>(RecordTy->getDecl()));
309 }
Anders Carlsson4c5fad32009-09-15 05:28:24 +0000310
Richard Smithc8d7f582011-11-29 22:48:16 +0000311 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
312 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
313 ImpCast->setType(Ty);
314 ImpCast->setValueKind(VK);
315 return Owned(E);
316 }
317 }
318
319 return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
Sebastian Redl906082e2010-07-20 04:20:21 +0000320}
321
Abramo Bagnara737d5442011-04-07 09:26:19 +0000322/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
323/// to the conversion from scalar type ScalarTy to the Boolean type.
324CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
325 switch (ScalarTy->getScalarTypeKind()) {
326 case Type::STK_Bool: return CK_NoOp;
John McCall1d9b3b22011-09-09 05:25:32 +0000327 case Type::STK_CPointer: return CK_PointerToBoolean;
328 case Type::STK_BlockPointer: return CK_PointerToBoolean;
329 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara737d5442011-04-07 09:26:19 +0000330 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
331 case Type::STK_Integral: return CK_IntegralToBoolean;
332 case Type::STK_Floating: return CK_FloatingToBoolean;
333 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
334 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
335 }
336 return CK_Invalid;
337}
338
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000339/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
340static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindolab9725cf2013-01-08 19:43:34 +0000341 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000342 return true;
343
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000344 if (D->isExternallyVisible())
Rafael Espindola2d1b0962013-03-14 03:07:35 +0000345 return true;
346
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000347 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
348 // UnusedFileScopedDecls stores the first declaration.
349 // The declaration may have become definition so check again.
350 const FunctionDecl *DeclToCheck;
351 if (FD->hasBody(DeclToCheck))
352 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
353
354 // Later redecls may add new information resulting in not having to warn,
355 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000356 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000357 if (DeclToCheck != FD)
358 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
359 }
360
361 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedman1507bf52013-09-10 21:10:25 +0000362 // If a variable usable in constant expressions is referenced,
363 // don't warn if it isn't used: if the value of a variable is required
364 // for the computation of a constant expression, it doesn't make sense to
365 // warn even if the variable isn't odr-used. (isReferenced doesn't
366 // precisely reflect that, but it's a decent approximation.)
367 if (VD->isReferenced() &&
368 VD->isUsableInConstantExpressions(SemaRef->Context))
369 return true;
370
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000371 // UnusedFileScopedDecls stores the first declaration.
372 // The declaration may have become definition so check again.
Michael Gottesman0116a402013-01-20 01:04:14 +0000373 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000374 if (DeclToCheck)
375 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
376
377 // Later redecls may add new information resulting in not having to warn,
378 // so check again.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000379 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000380 if (DeclToCheck != VD)
381 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
382 }
383
384 return false;
385}
386
John McCall15e310a2011-02-19 02:53:41 +0000387namespace {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000388 struct SortUndefinedButUsed {
Nick Lewycky995e26b2013-01-31 03:23:57 +0000389 const SourceManager &SM;
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000390 explicit SortUndefinedButUsed(SourceManager &SM) : SM(SM) {}
John McCall15e310a2011-02-19 02:53:41 +0000391
Nick Lewycky995e26b2013-01-31 03:23:57 +0000392 bool operator()(const std::pair<NamedDecl *, SourceLocation> &l,
393 const std::pair<NamedDecl *, SourceLocation> &r) const {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000394 if (l.second.isValid() && !r.second.isValid())
395 return true;
396 if (!l.second.isValid() && r.second.isValid())
397 return false;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000398 if (l.second != r.second)
399 return SM.isBeforeInTranslationUnit(l.second, r.second);
400 return SM.isBeforeInTranslationUnit(l.first->getLocation(),
401 r.first->getLocation());
402 }
John McCall15e310a2011-02-19 02:53:41 +0000403 };
John McCall15e310a2011-02-19 02:53:41 +0000404}
405
Nick Lewycky995e26b2013-01-31 03:23:57 +0000406/// Obtains a sorted list of functions that are undefined but ODR-used.
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000407void Sema::getUndefinedButUsed(
Nick Lewycky995e26b2013-01-31 03:23:57 +0000408 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
409 for (llvm::DenseMap<NamedDecl *, SourceLocation>::iterator
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000410 I = UndefinedButUsed.begin(), E = UndefinedButUsed.end();
Nick Lewycky995e26b2013-01-31 03:23:57 +0000411 I != E; ++I) {
412 NamedDecl *ND = I->first;
413
414 // Ignore attributes that have become invalid.
415 if (ND->isInvalidDecl()) continue;
416
Nick Lewycky995e26b2013-01-31 03:23:57 +0000417 // __attribute__((weakref)) is basically a definition.
418 if (ND->hasAttr<WeakRefAttr>()) continue;
419
420 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
421 if (FD->isDefined())
422 continue;
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000423 if (FD->isExternallyVisible() &&
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000424 !FD->getMostRecentDecl()->isInlined())
425 continue;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000426 } else {
427 if (cast<VarDecl>(ND)->hasDefinition() != VarDecl::DeclarationOnly)
428 continue;
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000429 if (ND->isExternallyVisible())
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000430 continue;
Nick Lewycky995e26b2013-01-31 03:23:57 +0000431 }
432
433 Undefined.push_back(std::make_pair(ND, I->second));
434 }
435
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000436 // Sort (in order of use site) so that we're not dependent on the iteration
437 // order through an llvm::DenseMap.
Nick Lewycky995e26b2013-01-31 03:23:57 +0000438 std::sort(Undefined.begin(), Undefined.end(),
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000439 SortUndefinedButUsed(Context.getSourceManager()));
Nick Lewycky995e26b2013-01-31 03:23:57 +0000440}
441
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000442/// checkUndefinedButUsed - Check for undefined objects with internal linkage
443/// or that are inline.
444static void checkUndefinedButUsed(Sema &S) {
445 if (S.UndefinedButUsed.empty()) return;
John McCall15e310a2011-02-19 02:53:41 +0000446
447 // Collect all the still-undefined entities with internal linkage.
Nick Lewycky995e26b2013-01-31 03:23:57 +0000448 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000449 S.getUndefinedButUsed(Undefined);
Nick Lewycky995e26b2013-01-31 03:23:57 +0000450 if (Undefined.empty()) return;
John McCall15e310a2011-02-19 02:53:41 +0000451
Nick Lewycky995e26b2013-01-31 03:23:57 +0000452 for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
453 I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
454 NamedDecl *ND = I->first;
John McCall15e310a2011-02-19 02:53:41 +0000455
Rafael Espindola181e3ec2013-05-13 00:12:11 +0000456 if (!ND->isExternallyVisible()) {
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000457 S.Diag(ND->getLocation(), diag::warn_undefined_internal)
458 << isa<VarDecl>(ND) << ND;
459 } else {
460 assert(cast<FunctionDecl>(ND)->getMostRecentDecl()->isInlined() &&
461 "used object requires definition but isn't inline or internal?");
462 S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND;
463 }
464 if (I->second.isValid())
465 S.Diag(I->second, diag::note_used_here);
John McCall15e310a2011-02-19 02:53:41 +0000466 }
467}
468
Douglas Gregor31e37b22011-07-28 18:09:57 +0000469void Sema::LoadExternalWeakUndeclaredIdentifiers() {
470 if (!ExternalSource)
471 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000472
Douglas Gregor31e37b22011-07-28 18:09:57 +0000473 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
474 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
475 for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
476 llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
477 = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
478 if (Pos != WeakUndeclaredIdentifiers.end())
479 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000480
Douglas Gregor31e37b22011-07-28 18:09:57 +0000481 WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
482 }
483}
484
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000485
486typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
487
488/// \brief Returns true, if all methods and nested classes of the given
489/// CXXRecordDecl are defined in this translation unit.
490///
491/// Should only be called from ActOnEndOfTranslationUnit so that all
492/// definitions are actually read.
493static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
494 RecordCompleteMap &MNCComplete) {
495 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
496 if (Cache != MNCComplete.end())
497 return Cache->second;
498 if (!RD->isCompleteDefinition())
499 return false;
500 bool Complete = true;
501 for (DeclContext::decl_iterator I = RD->decls_begin(),
502 E = RD->decls_end();
503 I != E && Complete; ++I) {
504 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
505 Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jasper0e9e9f82012-06-14 20:56:06 +0000506 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
507 Complete = F->getTemplatedDecl()->isDefined();
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000508 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
509 if (R->isInjectedClassName())
510 continue;
511 if (R->hasDefinition())
512 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
513 MNCComplete);
514 else
515 Complete = false;
516 }
517 }
518 MNCComplete[RD] = Complete;
519 return Complete;
520}
521
522/// \brief Returns true, if the given CXXRecordDecl is fully defined in this
523/// translation unit, i.e. all methods are defined or pure virtual and all
524/// friends, friend functions and nested classes are fully defined in this
525/// translation unit.
526///
527/// Should only be called from ActOnEndOfTranslationUnit so that all
528/// definitions are actually read.
529static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
530 RecordCompleteMap &RecordsComplete,
531 RecordCompleteMap &MNCComplete) {
532 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
533 if (Cache != RecordsComplete.end())
534 return Cache->second;
535 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
536 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
537 E = RD->friend_end();
538 I != E && Complete; ++I) {
539 // Check if friend classes and methods are complete.
540 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
541 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
542 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
543 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
544 else
545 Complete = false;
546 } else {
547 // Friend functions are available through the NamedDecl of FriendDecl.
548 if (const FunctionDecl *FD =
549 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
550 Complete = FD->isDefined();
551 else
552 // This is a template friend, give up.
553 Complete = false;
554 }
555 }
556 RecordsComplete[RD] = Complete;
557 return Complete;
558}
559
Chris Lattner9299f3f2008-08-23 03:19:52 +0000560/// ActOnEndOfTranslationUnit - This is called at the very end of the
561/// translation unit when EOF is reached and all but the top-level scope is
562/// popped.
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000563void Sema::ActOnEndOfTranslationUnit() {
John McCall92576642012-05-07 06:16:41 +0000564 assert(DelayedDiagnostics.getCurrentPool() == NULL
565 && "reached end of translation unit with a pool attached?");
566
Douglas Gregord82f5eb2012-08-17 22:17:36 +0000567 // If code completion is enabled, don't perform any end-of-translation-unit
568 // work.
569 if (PP.isCodeCompletionEnabled())
570 return;
571
Richard Smithb7751002013-07-25 23:08:39 +0000572 // Complete translation units and modules define vtables and perform implicit
573 // instantiations. PCH files do not.
574 if (TUKind != TU_Prefix) {
Argyrios Kyrtzidis849639d2012-02-07 16:50:53 +0000575 DiagnoseUseOfUnimplementedSelectors();
576
Chandler Carruthaee543a2010-12-12 21:36:11 +0000577 // If any dynamic classes have their key function defined within
578 // this translation unit, then those vtables are considered "used" and must
579 // be emitted.
Douglas Gregora126f172011-07-28 00:53:40 +0000580 for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
581 E = DynamicClasses.end();
582 I != E; ++I) {
583 assert(!(*I)->isDependentType() &&
Anders Carlssona5c6c2a2011-01-25 18:08:22 +0000584 "Should not see dependent types here!");
John McCalld5617ee2013-01-25 22:31:03 +0000585 if (const CXXMethodDecl *KeyFunction = Context.getCurrentKeyFunction(*I)) {
Chandler Carruthaee543a2010-12-12 21:36:11 +0000586 const FunctionDecl *Definition = 0;
587 if (KeyFunction->hasBody(Definition))
Douglas Gregora126f172011-07-28 00:53:40 +0000588 MarkVTableUsed(Definition->getLocation(), *I, true);
Chandler Carruthaee543a2010-12-12 21:36:11 +0000589 }
590 }
591
Nick Lewycky81559102011-05-31 07:58:42 +0000592 // If DefinedUsedVTables ends up marking any virtual member functions it
593 // might lead to more pending template instantiations, which we then need
594 // to instantiate.
595 DefineUsedVTables();
Argyrios Kyrtzidis0e036382010-08-05 09:48:16 +0000596
Nick Lewycky81559102011-05-31 07:58:42 +0000597 // C++: Perform implicit template instantiations.
598 //
599 // FIXME: When we perform these implicit instantiations, we do not
600 // carefully keep track of the point of instantiation (C++ [temp.point]).
601 // This means that name lookup that occurs within the template
602 // instantiation will always happen at the end of the translation unit,
Richard Smithb7751002013-07-25 23:08:39 +0000603 // so it will find some names that are not required to be found. This is
604 // valid, but we could do better by diagnosing if an instantiation uses a
605 // name that was not visible at its first point of instantiation.
Nick Lewycky81559102011-05-31 07:58:42 +0000606 PerformPendingInstantiations();
Nick Lewycky2a5f99e2010-11-25 00:35:20 +0000607 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000608
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000609 // Remove file scoped decls that turned out to be used.
Daniel Jasper676ea9d2013-04-30 06:43:16 +0000610 UnusedFileScopedDecls.erase(
611 std::remove_if(UnusedFileScopedDecls.begin(0, true),
612 UnusedFileScopedDecls.end(),
613 std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)),
614 UnusedFileScopedDecls.end());
Douglas Gregor47268a32010-04-09 17:41:13 +0000615
Douglas Gregor467dc882011-08-25 22:30:56 +0000616 if (TUKind == TU_Prefix) {
617 // Translation unit prefixes don't need any of the checking below.
Douglas Gregor87c08a52010-08-13 22:48:40 +0000618 TUScope = 0;
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000619 return;
Douglas Gregor87c08a52010-08-13 22:48:40 +0000620 }
Argyrios Kyrtzidis72b90572010-08-05 09:48:08 +0000621
Chris Lattner63d65f82009-09-08 18:19:27 +0000622 // Check for #pragma weak identifiers that were never declared
623 // FIXME: This will cause diagnostics to be emitted in a non-determinstic
624 // order! Iterating over a densemap like this is bad.
Douglas Gregor31e37b22011-07-28 18:09:57 +0000625 LoadExternalWeakUndeclaredIdentifiers();
Ryan Flynne25ff832009-07-30 03:15:39 +0000626 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
Chris Lattner63d65f82009-09-08 18:19:27 +0000627 I = WeakUndeclaredIdentifiers.begin(),
628 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
629 if (I->second.getUsed()) continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000630
Chris Lattner63d65f82009-09-08 18:19:27 +0000631 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
632 << I->first;
Ryan Flynne25ff832009-07-30 03:15:39 +0000633 }
634
Argyrios Kyrtzidis975d3532013-03-14 04:44:56 +0000635 if (LangOpts.CPlusPlus11 &&
636 Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
637 SourceLocation())
638 != DiagnosticsEngine::Ignored)
639 CheckDelegatingCtorCycles();
640
Douglas Gregor467dc882011-08-25 22:30:56 +0000641 if (TUKind == TU_Module) {
Douglas Gregor90db2602011-12-02 01:47:07 +0000642 // If we are building a module, resolve all of the exported declarations
643 // now.
644 if (Module *CurrentModule = PP.getCurrentModule()) {
645 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesman0116a402013-01-20 01:04:14 +0000646
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000647 SmallVector<Module *, 2> Stack;
Douglas Gregor90db2602011-12-02 01:47:07 +0000648 Stack.push_back(CurrentModule);
649 while (!Stack.empty()) {
Robert Wilhelm344472e2013-08-23 16:11:15 +0000650 Module *Mod = Stack.pop_back_val();
Michael Gottesman0116a402013-01-20 01:04:14 +0000651
Douglas Gregor906d66a2013-03-20 21:10:35 +0000652 // Resolve the exported declarations and conflicts.
Douglas Gregor90db2602011-12-02 01:47:07 +0000653 // FIXME: Actually complain, once we figure out how to teach the
Douglas Gregor906d66a2013-03-20 21:10:35 +0000654 // diagnostic client to deal with complaints in the module map at this
Douglas Gregor90db2602011-12-02 01:47:07 +0000655 // point.
656 ModMap.resolveExports(Mod, /*Complain=*/false);
Daniel Jasperddd2dfc2013-09-24 09:14:14 +0000657 ModMap.resolveUses(Mod, /*Complain=*/false);
Douglas Gregor906d66a2013-03-20 21:10:35 +0000658 ModMap.resolveConflicts(Mod, /*Complain=*/false);
Michael Gottesman0116a402013-01-20 01:04:14 +0000659
Douglas Gregor90db2602011-12-02 01:47:07 +0000660 // Queue the submodules, so their exports will also be resolved.
Douglas Gregorb7a78192012-01-04 23:32:19 +0000661 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
662 SubEnd = Mod->submodule_end();
Douglas Gregor90db2602011-12-02 01:47:07 +0000663 Sub != SubEnd; ++Sub) {
Douglas Gregorb7a78192012-01-04 23:32:19 +0000664 Stack.push_back(*Sub);
Douglas Gregor90db2602011-12-02 01:47:07 +0000665 }
666 }
667 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000668
Douglas Gregor467dc882011-08-25 22:30:56 +0000669 // Modules don't need any of the checking below.
670 TUScope = 0;
671 return;
672 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000673
Douglas Gregor275a3692009-03-10 23:43:53 +0000674 // C99 6.9.2p2:
675 // A declaration of an identifier for an object that has file
676 // scope without an initializer, and without a storage-class
677 // specifier or with the storage-class specifier static,
678 // constitutes a tentative definition. If a translation unit
679 // contains one or more tentative definitions for an identifier,
680 // and the translation unit contains no external definition for
681 // that identifier, then the behavior is exactly as if the
682 // translation unit contains a file scope declaration of that
683 // identifier, with the composite type as of the end of the
684 // translation unit, with an initializer equal to 0.
Sebastian Redle9d12b62010-01-31 22:27:38 +0000685 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesman0116a402013-01-20 01:04:14 +0000686 for (TentativeDefinitionsType::iterator
Douglas Gregora8623202011-07-27 20:58:46 +0000687 T = TentativeDefinitions.begin(ExternalSource),
688 TEnd = TentativeDefinitions.end();
Michael Gottesman0116a402013-01-20 01:04:14 +0000689 T != TEnd; ++T)
Douglas Gregora8623202011-07-27 20:58:46 +0000690 {
691 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump1eb44332009-09-09 15:08:12 +0000692
Sebastian Redle9d12b62010-01-31 22:27:38 +0000693 // If the tentative definition was completed, getActingDefinition() returns
694 // null. If we've already seen this variable before, insert()'s second
695 // return value is false.
696 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000697 continue;
698
Mike Stump1eb44332009-09-09 15:08:12 +0000699 if (const IncompleteArrayType *ArrayT
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000700 = Context.getAsIncompleteArrayType(VD->getType())) {
Chris Lattner63d65f82009-09-08 18:19:27 +0000701 // Set the length of the array to 1 (C99 6.9.2p5).
702 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
703 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
John McCall46a617a2009-10-16 00:14:28 +0000704 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
705 One, ArrayType::Normal, 0);
Chris Lattner63d65f82009-09-08 18:19:27 +0000706 VD->setType(T);
Mike Stump1eb44332009-09-09 15:08:12 +0000707 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000708 diag::err_tentative_def_incomplete_type))
709 VD->setInvalidDecl();
710
Eli Friedmane4851f22012-10-23 20:19:32 +0000711 CheckCompleteVariableDeclaration(VD);
712
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000713 // Notify the consumer that we've completed a tentative definition.
714 if (!VD->isInvalidDecl())
715 Consumer.CompleteTentativeDefinition(VD);
716
Douglas Gregor275a3692009-03-10 23:43:53 +0000717 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000718
719 // If there were errors, disable 'unused' warnings since they will mostly be
720 // noise.
721 if (!Diags.hasErrorOccurred()) {
722 // Output warning for unused file scoped decls.
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000723 for (UnusedFileScopedDeclsType::iterator
724 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000725 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora2ee20a2011-07-27 21:45:57 +0000726 if (ShouldRemoveFromUnused(this, *I))
727 continue;
Michael Gottesman0116a402013-01-20 01:04:14 +0000728
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000729 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
730 const FunctionDecl *DiagD;
731 if (!FD->hasBody(DiagD))
732 DiagD = FD;
Argyrios Kyrtzidis48b89592011-03-03 17:47:42 +0000733 if (DiagD->isDeleted())
734 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000735 if (DiagD->isReferenced()) {
736 if (isa<CXXMethodDecl>(DiagD))
737 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
738 << DiagD->getDeclName();
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000739 else {
Rafael Espindolad2615cc2013-04-03 19:27:57 +0000740 if (FD->getStorageClass() == SC_Static &&
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000741 !FD->isInlineSpecified() &&
Eli Friedman24146972013-08-22 00:27:10 +0000742 !SourceMgr.isInMainFile(
Fariborz Jahanian12d2cc72012-06-27 19:43:29 +0000743 SourceMgr.getExpansionLoc(FD->getLocation())))
744 Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
745 << DiagD->getDeclName();
746 else
747 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
748 << /*function*/0 << DiagD->getDeclName();
749 }
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000750 } else {
751 Diag(DiagD->getLocation(),
752 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
753 : diag::warn_unused_function)
754 << DiagD->getDeclName();
755 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000756 } else {
757 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
758 if (!DiagD)
759 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000760 if (DiagD->isReferenced()) {
761 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
762 << /*variable*/1 << DiagD->getDeclName();
Daniel Jasper71fcba82013-09-11 10:37:35 +0000763 } else if (DiagD->getType().isConstQualified()) {
764 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
765 << DiagD->getDeclName();
Eli Friedman39bd3712013-09-10 03:05:56 +0000766 } else {
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000767 Diag(DiagD->getLocation(), diag::warn_unused_variable)
Matt Beaumont-Gay19b6a702013-04-10 00:47:10 +0000768 << DiagD->getDeclName();
Argyrios Kyrtzidis6b6b42a2011-04-19 19:51:10 +0000769 }
Argyrios Kyrtzidis43f0a7c2011-01-31 07:04:37 +0000770 }
Argyrios Kyrtzidisbbc64542010-08-15 01:15:20 +0000771 }
John McCall15e310a2011-02-19 02:53:41 +0000772
Nick Lewycky01a41142013-01-26 00:35:08 +0000773 if (ExternalSource)
Nick Lewyckycd0655b2013-02-01 08:13:20 +0000774 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
775 checkUndefinedButUsed(*this);
Argyrios Kyrtzidis49b96d12010-08-13 18:42:17 +0000776 }
Douglas Gregor87c08a52010-08-13 22:48:40 +0000777
Daniel Jasperf8cc02e2012-06-06 08:32:04 +0000778 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
779 SourceLocation())
780 != DiagnosticsEngine::Ignored) {
781 RecordCompleteMap RecordsComplete;
782 RecordCompleteMap MNCComplete;
783 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
784 E = UnusedPrivateFields.end(); I != E; ++I) {
785 const NamedDecl *D = *I;
786 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
787 if (RD && !RD->isUnion() &&
788 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
789 Diag(D->getLocation(), diag::warn_unused_private_field)
790 << D->getDeclName();
791 }
792 }
793 }
794
Richard Smith483b9f32011-02-21 20:05:19 +0000795 // Check we've noticed that we're no longer parsing the initializer for every
796 // variable. If we miss cases, then at best we have a performance issue and
797 // at worst a rejects-valid bug.
798 assert(ParsingInitForAutoVars.empty() &&
799 "Didn't unmark var as having its initializer parsed");
800
Douglas Gregor87c08a52010-08-13 22:48:40 +0000801 TUScope = 0;
Chris Lattner9299f3f2008-08-23 03:19:52 +0000802}
803
804
Reid Spencer5f016e22007-07-11 17:01:13 +0000805//===----------------------------------------------------------------------===//
806// Helper functions.
807//===----------------------------------------------------------------------===//
808
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000809DeclContext *Sema::getFunctionLevelDeclContext() {
John McCalldb0ee1d2009-12-19 10:53:49 +0000810 DeclContext *DC = CurContext;
Mike Stump1eb44332009-09-09 15:08:12 +0000811
Eli Friedman72899c32012-01-07 04:59:52 +0000812 while (true) {
Tareq A. Siraj6afcf882013-04-16 19:37:38 +0000813 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
Eli Friedman72899c32012-01-07 04:59:52 +0000814 DC = DC->getParent();
815 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor215e4e12012-02-12 17:34:23 +0000816 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman72899c32012-01-07 04:59:52 +0000817 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
818 DC = DC->getParent()->getParent();
819 }
820 else break;
821 }
Mike Stump1eb44332009-09-09 15:08:12 +0000822
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000823 return DC;
824}
825
Chris Lattner371f2582008-12-04 23:50:19 +0000826/// getCurFunctionDecl - If inside of a function body, this returns a pointer
827/// to the function decl for the function being parsed. If we're currently
828/// in a 'block', this returns the containing context.
829FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000830 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000831 return dyn_cast<FunctionDecl>(DC);
832}
833
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000834ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000835 DeclContext *DC = getFunctionLevelDeclContext();
Fariborz Jahanian69f86d92013-05-31 21:51:12 +0000836 while (isa<RecordDecl>(DC))
837 DC = DC->getParent();
Steve Naroffd7612e12008-11-17 16:28:52 +0000838 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000839}
Chris Lattner371f2582008-12-04 23:50:19 +0000840
841NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000842 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner371f2582008-12-04 23:50:19 +0000843 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000844 return cast<NamedDecl>(DC);
Chris Lattner371f2582008-12-04 23:50:19 +0000845 return 0;
846}
847
Daniel Dunbar393eed72012-03-14 09:49:32 +0000848void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
849 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
850 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
851 // been made more painfully obvious by the refactor that introduced this
852 // function, but it is possible that the incoming argument can be
853 // eliminnated. If it truly cannot be (for example, there is some reentrancy
854 // issue I am not seeing yet), then there should at least be a clarifying
855 // comment somewhere.
David Blaikiedc84cd52013-02-20 22:23:23 +0000856 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
Daniel Dunbar393eed72012-03-14 09:49:32 +0000857 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
858 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000859 case DiagnosticIDs::SFINAE_Report:
Richard Smith77faa362011-10-19 00:07:01 +0000860 // We'll report the diagnostic below.
Douglas Gregor9b623632010-10-12 23:32:35 +0000861 break;
Michael Gottesman0116a402013-01-20 01:04:14 +0000862
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000863 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor9b623632010-10-12 23:32:35 +0000864 // Count this failure so that we know that template argument deduction
865 // has failed.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000866 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000867
868 // Make a copy of this suppressed diagnostic and store it with the
869 // template-deduction information.
870 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
871 Diagnostic DiagInfo(&Diags);
872 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
873 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
874 }
875
Daniel Dunbar393eed72012-03-14 09:49:32 +0000876 Diags.setLastDiagnosticIgnored();
877 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000878 return;
Michael Gottesman0116a402013-01-20 01:04:14 +0000879
Richard Smith77faa362011-10-19 00:07:01 +0000880 case DiagnosticIDs::SFINAE_AccessControl: {
881 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbar00b43842012-03-13 18:30:54 +0000882 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith77faa362011-10-19 00:07:01 +0000883 // make access control a part of SFINAE for the purposes of checking
884 // type traits.
Richard Smith80ad52f2013-01-02 11:42:31 +0000885 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith77faa362011-10-19 00:07:01 +0000886 break;
887
Daniel Dunbar393eed72012-03-14 09:49:32 +0000888 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith77faa362011-10-19 00:07:01 +0000889
890 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000891 ++NumSFINAEErrors;
Richard Smithb8590f32012-05-07 09:03:25 +0000892
893 // Make a copy of this suppressed diagnostic and store it with the
894 // template-deduction information.
895 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
896 Diagnostic DiagInfo(&Diags);
897 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
898 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
899 }
900
Daniel Dunbar393eed72012-03-14 09:49:32 +0000901 Diags.setLastDiagnosticIgnored();
902 Diags.Clear();
Richard Smith77faa362011-10-19 00:07:01 +0000903
904 // Now the diagnostic state is clear, produce a C++98 compatibility
905 // warning.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000906 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith77faa362011-10-19 00:07:01 +0000907
908 // The last diagnostic which Sema produced was ignored. Suppress any
909 // notes attached to it.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000910 Diags.setLastDiagnosticIgnored();
Richard Smith77faa362011-10-19 00:07:01 +0000911 return;
912 }
913
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000914 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor9b623632010-10-12 23:32:35 +0000915 // Make a copy of this suppressed diagnostic and store it with the
916 // template-deduction information;
Richard Smithb8590f32012-05-07 09:03:25 +0000917 if (*Info) {
918 Diagnostic DiagInfo(&Diags);
Douglas Gregor1eee5dc2011-01-27 22:31:44 +0000919 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smithb8590f32012-05-07 09:03:25 +0000920 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
921 }
922
923 // Suppress this diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000924 Diags.setLastDiagnosticIgnored();
925 Diags.Clear();
Douglas Gregor9b623632010-10-12 23:32:35 +0000926 return;
927 }
928 }
Michael Gottesman0116a402013-01-20 01:04:14 +0000929
Douglas Gregor8987b232011-09-27 23:30:47 +0000930 // Set up the context's printing policy based on our current state.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000931 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesman0116a402013-01-20 01:04:14 +0000932
Douglas Gregor9b623632010-10-12 23:32:35 +0000933 // Emit the diagnostic.
Daniel Dunbar393eed72012-03-14 09:49:32 +0000934 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000935 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000936
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000937 // If this is not a note, and we're in a template instantiation
938 // that is different from the last template instantiation where
939 // we emitted an error, print a template instantiation
940 // backtrace.
Argyrios Kyrtzidis33e4e702010-11-18 20:06:41 +0000941 if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
Daniel Dunbar393eed72012-03-14 09:49:32 +0000942 !ActiveTemplateInstantiations.empty() &&
943 ActiveTemplateInstantiations.back()
944 != LastTemplateInstantiationErrorContext) {
945 PrintInstantiationStack();
946 LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000947 }
948}
Douglas Gregor2e222532009-07-02 17:08:52 +0000949
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000950Sema::SemaDiagnosticBuilder
951Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
952 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
953 PD.Emit(Builder);
Mike Stump1eb44332009-09-09 15:08:12 +0000954
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000955 return Builder;
956}
957
Chandler Carruth108f7562011-07-26 05:40:03 +0000958/// \brief Looks through the macro-expansion chain for the given
959/// location, looking for a macro expansion with the given name.
John McCall834e3f62011-03-08 07:59:04 +0000960/// If one is found, returns true and sets the location to that
Chandler Carruth108f7562011-07-26 05:40:03 +0000961/// expansion loc.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000962bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall834e3f62011-03-08 07:59:04 +0000963 SourceLocation loc = locref;
964 if (!loc.isMacroID()) return false;
965
966 // There's no good way right now to look at the intermediate
Chandler Carruth108f7562011-07-26 05:40:03 +0000967 // expansions, so just jump to the expansion location.
Chandler Carruth40278532011-07-25 16:49:02 +0000968 loc = getSourceManager().getExpansionLoc(loc);
John McCall834e3f62011-03-08 07:59:04 +0000969
970 // If that's written with the name, stop here.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000971 SmallVector<char, 16> buffer;
John McCall834e3f62011-03-08 07:59:04 +0000972 if (getPreprocessor().getSpelling(loc, buffer) == name) {
973 locref = loc;
974 return true;
975 }
976 return false;
977}
978
Douglas Gregor23c94db2010-07-02 17:43:08 +0000979/// \brief Determines the active Scope associated with the given declaration
980/// context.
981///
982/// This routine maps a declaration context to the active Scope object that
983/// represents that declaration context in the parser. It is typically used
984/// from "scope-less" code (e.g., template instantiation, lazy creation of
985/// declarations) that injects a name for name-lookup purposes and, therefore,
986/// must update the Scope.
987///
988/// \returns The scope corresponding to the given declaraion context, or NULL
989/// if no such scope is open.
990Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesman0116a402013-01-20 01:04:14 +0000991
Douglas Gregor23c94db2010-07-02 17:43:08 +0000992 if (!Ctx)
993 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +0000994
Douglas Gregor23c94db2010-07-02 17:43:08 +0000995 Ctx = Ctx->getPrimaryContext();
996 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcddc69f2010-07-08 23:07:34 +0000997 // Ignore scopes that cannot have declarations. This is important for
998 // out-of-line definitions of static class members.
999 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1000 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
1001 if (Ctx == Entity->getPrimaryContext())
1002 return S;
Douglas Gregor23c94db2010-07-02 17:43:08 +00001003 }
Michael Gottesman0116a402013-01-20 01:04:14 +00001004
Douglas Gregor23c94db2010-07-02 17:43:08 +00001005 return 0;
1006}
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001007
1008/// \brief Enter a new function scope
1009void Sema::PushFunctionScope() {
John McCall781472f2010-08-25 08:40:02 +00001010 if (FunctionScopes.size() == 1) {
1011 // Use the "top" function scope rather than having to allocate
1012 // memory for a new scope.
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001013 FunctionScopes.back()->Clear();
John McCall781472f2010-08-25 08:40:02 +00001014 FunctionScopes.push_back(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001015 return;
1016 }
Michael Gottesman0116a402013-01-20 01:04:14 +00001017
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001018 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001019}
1020
1021void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidis8fc32d22010-11-19 00:19:15 +00001022 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001023 BlockScope, Block));
1024}
1025
Manuel Klimek152b4e42013-08-22 12:12:24 +00001026void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
1027 CXXMethodDecl *CallOperator) {
1028 FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
1029 CallOperator));
Eli Friedmanec9ea722012-01-05 03:35:19 +00001030}
1031
1032void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1033 const Decl *D, const BlockExpr *blkExpr) {
Michael Gottesman0116a402013-01-20 01:04:14 +00001034 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
John McCall781472f2010-08-25 08:40:02 +00001035 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Michael Gottesman0116a402013-01-20 01:04:14 +00001036
Ted Kremenek3ed6fc02011-02-23 01:51:48 +00001037 // Issue any analysis-based warnings.
1038 if (WP && D)
Ted Kremenek283a3582011-02-23 01:51:53 +00001039 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
Ted Kremenek351ba912011-02-23 01:52:04 +00001040 else {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001041 for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
Ted Kremenek351ba912011-02-23 01:52:04 +00001042 i = Scope->PossiblyUnreachableDiags.begin(),
1043 e = Scope->PossiblyUnreachableDiags.end();
1044 i != e; ++i) {
1045 const sema::PossiblyUnreachableDiag &D = *i;
1046 Diag(D.Loc, D.PD);
1047 }
1048 }
Ted Kremenek3ed6fc02011-02-23 01:51:48 +00001049
Ted Kremenek351ba912011-02-23 01:52:04 +00001050 if (FunctionScopes.back() != Scope) {
John McCall781472f2010-08-25 08:40:02 +00001051 delete Scope;
Ted Kremenek351ba912011-02-23 01:52:04 +00001052 }
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001053}
1054
Dmitri Gribenko625bb562012-02-14 22:14:32 +00001055void Sema::PushCompoundScope() {
1056 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
1057}
1058
1059void Sema::PopCompoundScope() {
1060 FunctionScopeInfo *CurFunction = getCurFunction();
1061 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1062
1063 CurFunction->CompoundScopes.pop_back();
1064}
1065
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001066/// \brief Determine whether any errors occurred within this function/method/
1067/// block.
John McCallf85e1932011-06-15 23:02:42 +00001068bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1069 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001070}
1071
1072BlockScopeInfo *Sema::getCurBlock() {
1073 if (FunctionScopes.empty())
1074 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001075
1076 return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001077}
John McCall76bd1f32010-06-01 09:23:16 +00001078
Eli Friedman906a7e12012-01-06 03:05:34 +00001079LambdaScopeInfo *Sema::getCurLambda() {
1080 if (FunctionScopes.empty())
1081 return 0;
Michael Gottesman0116a402013-01-20 01:04:14 +00001082
1083 return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
Eli Friedman906a7e12012-01-06 03:05:34 +00001084}
1085
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001086void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenek127ff2e2012-09-13 06:41:18 +00001087 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1088 SourceMgr.isInSystemHeader(Comment.getBegin()))
1089 return;
Dmitri Gribenko6fd7d302013-04-10 15:35:17 +00001090 RawComment RC(SourceMgr, Comment, false,
1091 LangOpts.CommentOpts.ParseAllComments);
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001092 if (RC.isAlmostTrailingComment()) {
1093 SourceRange MagicMarkerRange(Comment.getBegin(),
1094 Comment.getBegin().getLocWithOffset(3));
1095 StringRef MagicMarkerText;
1096 switch (RC.getKind()) {
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001097 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001098 MagicMarkerText = "///<";
1099 break;
Abramo Bagnarac50a0e32012-07-04 07:30:26 +00001100 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko9dda4742012-06-22 16:02:55 +00001101 MagicMarkerText = "/**<";
1102 break;
1103 default:
1104 llvm_unreachable("if this is an almost Doxygen comment, "
1105 "it should be ordinary");
1106 }
1107 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1108 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1109 }
Dmitri Gribenkoaa0cd852012-06-20 00:34:58 +00001110 Context.addComment(RC);
1111}
1112
John McCall76bd1f32010-06-01 09:23:16 +00001113// Pin this vtable to this file.
1114ExternalSemaSource::~ExternalSemaSource() {}
John McCallf312b1e2010-08-26 23:41:50 +00001115
Douglas Gregor5ac4b692012-01-25 00:49:42 +00001116void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Sebastian Redl8c845712010-09-28 20:23:00 +00001117
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001118void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesman0116a402013-01-20 01:04:14 +00001119 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001120}
1121
Nick Lewyckycd0655b2013-02-01 08:13:20 +00001122void ExternalSemaSource::ReadUndefinedButUsed(
Nick Lewycky995e26b2013-01-31 03:23:57 +00001123 llvm::DenseMap<NamedDecl *, SourceLocation> &Undefined) {
Nick Lewycky01a41142013-01-26 00:35:08 +00001124}
1125
Chris Lattner5f9e2722011-07-23 10:55:15 +00001126void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
John McCallf312b1e2010-08-26 23:41:50 +00001127 SourceLocation Loc = this->Loc;
1128 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
1129 if (Loc.isValid()) {
1130 Loc.print(OS, S.getSourceManager());
1131 OS << ": ";
1132 }
1133 OS << Message;
1134
1135 if (TheDecl && isa<NamedDecl>(TheDecl)) {
1136 std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
1137 if (!Name.empty())
1138 OS << " '" << Name << '\'';
1139 }
1140
1141 OS << '\n';
1142}
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001143
1144/// \brief Figure out if an expression could be turned into a call.
1145///
1146/// Use this when trying to recover from an error where the programmer may have
1147/// written just the name of a function instead of actually calling it.
1148///
1149/// \param E - The expression to examine.
1150/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1151/// with no arguments, this parameter is set to the type returned by such a
1152/// call; otherwise, it is set to an empty QualType.
John McCall6dbba4f2011-10-11 23:14:30 +00001153/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001154/// name, this parameter is populated with the decls of the various overloads.
David Blaikiec8fa5252013-06-21 23:54:45 +00001155bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1156 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001157 ZeroArgCallReturnTy = QualType();
John McCall6dbba4f2011-10-11 23:14:30 +00001158 OverloadSet.clear();
1159
David Blaikiec2fe8182013-06-04 00:28:46 +00001160 const OverloadExpr *Overloads = NULL;
David Blaikiec8fa5252013-06-21 23:54:45 +00001161 bool IsMemExpr = false;
John McCall6dbba4f2011-10-11 23:14:30 +00001162 if (E.getType() == Context.OverloadTy) {
1163 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
John McCall6dbba4f2011-10-11 23:14:30 +00001164
David Blaikiec2fe8182013-06-04 00:28:46 +00001165 // Ignore overloads that are pointer-to-member constants.
1166 if (FR.HasFormOfMemberPointer)
1167 return false;
1168
1169 Overloads = FR.Expression;
1170 } else if (E.getType() == Context.BoundMemberTy) {
1171 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
David Blaikiec8fa5252013-06-21 23:54:45 +00001172 IsMemExpr = true;
David Blaikiec2fe8182013-06-04 00:28:46 +00001173 }
David Blaikiec8fa5252013-06-21 23:54:45 +00001174
1175 bool Ambiguous = false;
1176
David Blaikiec2fe8182013-06-04 00:28:46 +00001177 if (Overloads) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001178 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1179 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall6dbba4f2011-10-11 23:14:30 +00001180 OverloadSet.addDecl(*it);
1181
David Blaikiec8fa5252013-06-21 23:54:45 +00001182 // Check whether the function is a non-template, non-member which takes no
John McCall6dbba4f2011-10-11 23:14:30 +00001183 // arguments.
David Blaikiec8fa5252013-06-21 23:54:45 +00001184 if (IsMemExpr)
1185 continue;
John McCall6dbba4f2011-10-11 23:14:30 +00001186 if (const FunctionDecl *OverloadDecl
1187 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
David Blaikiec2fe8182013-06-04 00:28:46 +00001188 if (OverloadDecl->getMinRequiredArguments() == 0) {
1189 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) {
1190 ZeroArgCallReturnTy = QualType();
1191 Ambiguous = true;
1192 } else
1193 ZeroArgCallReturnTy = OverloadDecl->getResultType();
1194 }
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001195 }
1196 }
John McCall6dbba4f2011-10-11 23:14:30 +00001197
David Blaikiec8fa5252013-06-21 23:54:45 +00001198 // If it's not a member, use better machinery to try to resolve the call
1199 if (!IsMemExpr)
1200 return !ZeroArgCallReturnTy.isNull();
1201 }
1202
1203 // Attempt to call the member with no arguments - this will correctly handle
1204 // member templates with defaults/deduction of template arguments, overloads
1205 // with default arguments, etc.
Eli Friedmand739c4e2013-07-08 23:35:04 +00001206 if (IsMemExpr && !E.isTypeDependent()) {
David Blaikiec8fa5252013-06-21 23:54:45 +00001207 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1208 getDiagnostics().setSuppressAllDiagnostics(true);
1209 ExprResult R = BuildCallToMemberFunction(NULL, &E, SourceLocation(), None,
1210 SourceLocation());
1211 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1212 if (R.isUsable()) {
1213 ZeroArgCallReturnTy = R.get()->getType();
1214 return true;
1215 }
1216 return false;
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001217 }
1218
John McCall6dbba4f2011-10-11 23:14:30 +00001219 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001220 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1221 if (Fun->getMinRequiredArguments() == 0)
1222 ZeroArgCallReturnTy = Fun->getResultType();
1223 return true;
1224 }
1225 }
1226
1227 // We don't have an expression that's convenient to get a FunctionDecl from,
1228 // but we can at least check if the type is "function of 0 arguments".
1229 QualType ExprTy = E.getType();
1230 const FunctionType *FunTy = NULL;
Matt Beaumont-Gay9389ddc2011-05-05 00:59:35 +00001231 QualType PointeeTy = ExprTy->getPointeeType();
1232 if (!PointeeTy.isNull())
1233 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001234 if (!FunTy)
1235 FunTy = ExprTy->getAs<FunctionType>();
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001236
1237 if (const FunctionProtoType *FPT =
1238 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1239 if (FPT->getNumArgs() == 0)
1240 ZeroArgCallReturnTy = FunTy->getResultType();
1241 return true;
1242 }
1243 return false;
1244}
1245
1246/// \brief Give notes for a set of overloads.
1247///
David Blaikiec8fa5252013-06-21 23:54:45 +00001248/// A companion to tryExprAsCall. In cases when the name that the programmer
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001249/// wrote was an overloaded function, we may be able to make some guesses about
1250/// plausible overloads based on their return types; such guesses can be handed
1251/// off to this method to be emitted as notes.
1252///
1253/// \param Overloads - The overloads to note.
1254/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1255/// -fshow-overloads=best, this is the location to attach to the note about too
1256/// many candidates. Typically this will be the location of the original
1257/// ill-formed expression.
John McCall6dbba4f2011-10-11 23:14:30 +00001258static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1259 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001260 int ShownOverloads = 0;
1261 int SuppressedOverloads = 0;
1262 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1263 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1264 // FIXME: Magic number for max shown overloads stolen from
1265 // OverloadCandidateSet::NoteCandidates.
Douglas Gregordc7b6412012-10-23 23:11:23 +00001266 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001267 ++SuppressedOverloads;
1268 continue;
1269 }
John McCall6dbba4f2011-10-11 23:14:30 +00001270
1271 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Abramo Bagnara9c0e1ec2011-11-15 21:43:28 +00001272 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001273 ++ShownOverloads;
1274 }
John McCall6dbba4f2011-10-11 23:14:30 +00001275
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001276 if (SuppressedOverloads)
John McCall6dbba4f2011-10-11 23:14:30 +00001277 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1278 << SuppressedOverloads;
1279}
1280
1281static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1282 const UnresolvedSetImpl &Overloads,
1283 bool (*IsPlausibleResult)(QualType)) {
1284 if (!IsPlausibleResult)
1285 return noteOverloads(S, Overloads, Loc);
1286
1287 UnresolvedSet<2> PlausibleOverloads;
1288 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1289 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1290 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1291 QualType OverloadResultTy = OverloadDecl->getResultType();
1292 if (IsPlausibleResult(OverloadResultTy))
1293 PlausibleOverloads.addDecl(It.getDecl());
1294 }
1295 noteOverloads(S, PlausibleOverloads, Loc);
1296}
1297
1298/// Determine whether the given expression can be called by just
1299/// putting parentheses after it. Notably, expressions with unary
1300/// operators can't be because the unary operator will start parsing
1301/// outside the call.
1302static bool IsCallableWithAppend(Expr *E) {
1303 E = E->IgnoreImplicit();
1304 return (!isa<CStyleCastExpr>(E) &&
1305 !isa<UnaryOperator>(E) &&
1306 !isa<BinaryOperator>(E) &&
1307 !isa<CXXOperatorCallExpr>(E));
1308}
1309
1310bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1311 bool ForceComplain,
1312 bool (*IsPlausibleResult)(QualType)) {
1313 SourceLocation Loc = E.get()->getExprLoc();
1314 SourceRange Range = E.get()->getSourceRange();
1315
1316 QualType ZeroArgCallTy;
1317 UnresolvedSet<4> Overloads;
David Blaikiec8fa5252013-06-21 23:54:45 +00001318 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
John McCall6dbba4f2011-10-11 23:14:30 +00001319 !ZeroArgCallTy.isNull() &&
1320 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1321 // At this point, we know E is potentially callable with 0
1322 // arguments and that it returns something of a reasonable type,
1323 // so we can emit a fixit and carry on pretending that E was
1324 // actually a CallExpr.
Nick Lewyckyf96df622013-08-21 19:09:44 +00001325 SourceLocation ParenInsertionLoc = PP.getLocForEndOfToken(Range.getEnd());
Michael Gottesman0116a402013-01-20 01:04:14 +00001326 Diag(Loc, PD)
John McCall6dbba4f2011-10-11 23:14:30 +00001327 << /*zero-arg*/ 1 << Range
1328 << (IsCallableWithAppend(E.get())
1329 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1330 : FixItHint());
1331 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1332
1333 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1334 // while doing so.
Nick Lewyckyf96df622013-08-21 19:09:44 +00001335 E = ActOnCallExpr(0, E.take(), Range.getEnd(), None,
1336 Range.getEnd().getLocWithOffset(1));
John McCall6dbba4f2011-10-11 23:14:30 +00001337 return true;
1338 }
1339
1340 if (!ForceComplain) return false;
1341
1342 Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
1343 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1344 E = ExprError();
1345 return true;
Matt Beaumont-Gayc9366ba2011-05-04 22:10:40 +00001346}
Argyrios Kyrtzidis57f8da52013-03-14 22:56:43 +00001347
1348IdentifierInfo *Sema::getSuperIdentifier() const {
1349 if (!Ident_super)
1350 Ident_super = &Context.Idents.get("super");
1351 return Ident_super;
1352}
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001353
Nico Webercac18ad2013-06-20 21:44:55 +00001354IdentifierInfo *Sema::getFloat128Identifier() const {
1355 if (!Ident___float128)
1356 Ident___float128 = &Context.Idents.get("__float128");
1357 return Ident___float128;
1358}
1359
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001360void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
Ben Langmuir3a2f9122013-04-29 13:32:41 +00001361 CapturedRegionKind K) {
Ben Langmuir8c045ac2013-05-03 19:00:33 +00001362 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(getDiagnostics(), S, CD, RD,
1363 CD->getContextParam(), K);
Tareq A. Siraj6afcf882013-04-16 19:37:38 +00001364 CSI->ReturnType = Context.VoidTy;
1365 FunctionScopes.push_back(CSI);
1366}
1367
1368CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1369 if (FunctionScopes.empty())
1370 return 0;
1371
1372 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1373}