blob: a4ddba3740d61a801bd42058f6e7c59a81a3a6ed [file] [log] [blame]
Chris Lattner3d1cee32008-04-08 05:04:30 +00001//===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for C++ declarations.
11//
12//===----------------------------------------------------------------------===//
13
John McCall2d887082010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
John McCall5f1e0942010-08-24 08:50:51 +000015#include "clang/Sema/CXXFieldCollector.h"
16#include "clang/Sema/Scope.h"
Douglas Gregore737f502010-08-12 20:07:10 +000017#include "clang/Sema/Initialization.h"
18#include "clang/Sema/Lookup.h"
Eli Friedman7badd242012-02-09 20:13:14 +000019#include "clang/Sema/ScopeInfo.h"
Argyrios Kyrtzidisa4755c62008-08-09 00:58:37 +000020#include "clang/AST/ASTConsumer.h"
Douglas Gregore37ac4f2008-04-13 21:30:24 +000021#include "clang/AST/ASTContext.h"
Sebastian Redl58a2cd82011-04-24 16:28:06 +000022#include "clang/AST/ASTMutationListener.h"
Douglas Gregor06a9f362010-05-01 20:49:11 +000023#include "clang/AST/CharUnits.h"
Douglas Gregora8f32e02009-10-06 17:59:45 +000024#include "clang/AST/CXXInheritance.h"
Anders Carlsson8211eff2009-03-24 01:19:16 +000025#include "clang/AST/DeclVisitor.h"
Richard Trieude5e75c2012-06-14 23:11:34 +000026#include "clang/AST/EvaluatedExprVisitor.h"
Sean Hunt41717662011-02-26 19:13:13 +000027#include "clang/AST/ExprCXX.h"
Douglas Gregor06a9f362010-05-01 20:49:11 +000028#include "clang/AST/RecordLayout.h"
Douglas Gregorcefc3af2012-04-16 07:05:22 +000029#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregor06a9f362010-05-01 20:49:11 +000030#include "clang/AST/StmtVisitor.h"
Douglas Gregor802ab452009-12-02 22:36:29 +000031#include "clang/AST/TypeLoc.h"
Douglas Gregor02189362008-10-22 21:13:31 +000032#include "clang/AST/TypeOrdering.h"
John McCall19510852010-08-20 18:27:03 +000033#include "clang/Sema/DeclSpec.h"
34#include "clang/Sema/ParsedTemplate.h"
Anders Carlssonb7906612009-08-26 23:45:07 +000035#include "clang/Basic/PartialDiagnostic.h"
Argyrios Kyrtzidis06ad1f52008-10-06 18:37:09 +000036#include "clang/Lex/Preprocessor.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000037#include "llvm/ADT/SmallString.h"
Douglas Gregor3fc749d2008-12-23 00:26:44 +000038#include "llvm/ADT/STLExtras.h"
Douglas Gregorf8268ae2008-10-22 17:49:05 +000039#include <map>
Douglas Gregora8f32e02009-10-06 17:59:45 +000040#include <set>
Chris Lattner3d1cee32008-04-08 05:04:30 +000041
42using namespace clang;
43
Chris Lattner8123a952008-04-10 02:22:51 +000044//===----------------------------------------------------------------------===//
45// CheckDefaultArgumentVisitor
46//===----------------------------------------------------------------------===//
47
Chris Lattner9e979552008-04-12 23:52:44 +000048namespace {
49 /// CheckDefaultArgumentVisitor - C++ [dcl.fct.default] Traverses
50 /// the default argument of a parameter to determine whether it
51 /// contains any ill-formed subexpressions. For example, this will
52 /// diagnose the use of local variables or parameters within the
53 /// default argument expression.
Benjamin Kramer85b45212009-11-28 19:45:26 +000054 class CheckDefaultArgumentVisitor
Chris Lattnerb77792e2008-07-26 22:17:49 +000055 : public StmtVisitor<CheckDefaultArgumentVisitor, bool> {
Chris Lattner9e979552008-04-12 23:52:44 +000056 Expr *DefaultArg;
57 Sema *S;
Chris Lattner8123a952008-04-10 02:22:51 +000058
Chris Lattner9e979552008-04-12 23:52:44 +000059 public:
Mike Stump1eb44332009-09-09 15:08:12 +000060 CheckDefaultArgumentVisitor(Expr *defarg, Sema *s)
Chris Lattner9e979552008-04-12 23:52:44 +000061 : DefaultArg(defarg), S(s) {}
Chris Lattner8123a952008-04-10 02:22:51 +000062
Chris Lattner9e979552008-04-12 23:52:44 +000063 bool VisitExpr(Expr *Node);
64 bool VisitDeclRefExpr(DeclRefExpr *DRE);
Douglas Gregor796da182008-11-04 14:32:21 +000065 bool VisitCXXThisExpr(CXXThisExpr *ThisE);
Douglas Gregorf0459f82012-02-10 23:30:22 +000066 bool VisitLambdaExpr(LambdaExpr *Lambda);
Chris Lattner9e979552008-04-12 23:52:44 +000067 };
Chris Lattner8123a952008-04-10 02:22:51 +000068
Chris Lattner9e979552008-04-12 23:52:44 +000069 /// VisitExpr - Visit all of the children of this expression.
70 bool CheckDefaultArgumentVisitor::VisitExpr(Expr *Node) {
71 bool IsInvalid = false;
John McCall7502c1d2011-02-13 04:07:26 +000072 for (Stmt::child_range I = Node->children(); I; ++I)
Chris Lattnerb77792e2008-07-26 22:17:49 +000073 IsInvalid |= Visit(*I);
Chris Lattner9e979552008-04-12 23:52:44 +000074 return IsInvalid;
Chris Lattner8123a952008-04-10 02:22:51 +000075 }
76
Chris Lattner9e979552008-04-12 23:52:44 +000077 /// VisitDeclRefExpr - Visit a reference to a declaration, to
78 /// determine whether this declaration can be used in the default
79 /// argument expression.
80 bool CheckDefaultArgumentVisitor::VisitDeclRefExpr(DeclRefExpr *DRE) {
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000081 NamedDecl *Decl = DRE->getDecl();
Chris Lattner9e979552008-04-12 23:52:44 +000082 if (ParmVarDecl *Param = dyn_cast<ParmVarDecl>(Decl)) {
83 // C++ [dcl.fct.default]p9
84 // Default arguments are evaluated each time the function is
85 // called. The order of evaluation of function arguments is
86 // unspecified. Consequently, parameters of a function shall not
87 // be used in default argument expressions, even if they are not
88 // evaluated. Parameters of a function declared before a default
89 // argument expression are in scope and can hide namespace and
90 // class member names.
Daniel Dunbar96a00142012-03-09 18:35:03 +000091 return S->Diag(DRE->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +000092 diag::err_param_default_argument_references_param)
Chris Lattner08631c52008-11-23 21:45:46 +000093 << Param->getDeclName() << DefaultArg->getSourceRange();
Steve Naroff248a7532008-04-15 22:42:06 +000094 } else if (VarDecl *VDecl = dyn_cast<VarDecl>(Decl)) {
Chris Lattner9e979552008-04-12 23:52:44 +000095 // C++ [dcl.fct.default]p7
96 // Local variables shall not be used in default argument
97 // expressions.
John McCallb6bbcc92010-10-15 04:57:14 +000098 if (VDecl->isLocalVarDecl())
Daniel Dunbar96a00142012-03-09 18:35:03 +000099 return S->Diag(DRE->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000100 diag::err_param_default_argument_references_local)
Chris Lattner08631c52008-11-23 21:45:46 +0000101 << VDecl->getDeclName() << DefaultArg->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +0000102 }
Chris Lattner8123a952008-04-10 02:22:51 +0000103
Douglas Gregor3996f232008-11-04 13:41:56 +0000104 return false;
105 }
Chris Lattner9e979552008-04-12 23:52:44 +0000106
Douglas Gregor796da182008-11-04 14:32:21 +0000107 /// VisitCXXThisExpr - Visit a C++ "this" expression.
108 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(CXXThisExpr *ThisE) {
109 // C++ [dcl.fct.default]p8:
110 // The keyword this shall not be used in a default argument of a
111 // member function.
Daniel Dunbar96a00142012-03-09 18:35:03 +0000112 return S->Diag(ThisE->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000113 diag::err_param_default_argument_references_this)
114 << ThisE->getSourceRange();
Chris Lattner9e979552008-04-12 23:52:44 +0000115 }
Douglas Gregorf0459f82012-02-10 23:30:22 +0000116
117 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(LambdaExpr *Lambda) {
118 // C++11 [expr.lambda.prim]p13:
119 // A lambda-expression appearing in a default argument shall not
120 // implicitly or explicitly capture any entity.
121 if (Lambda->capture_begin() == Lambda->capture_end())
122 return false;
123
124 return S->Diag(Lambda->getLocStart(),
125 diag::err_lambda_capture_default_arg);
126 }
Chris Lattner8123a952008-04-10 02:22:51 +0000127}
128
Richard Smithe6975e92012-04-17 00:58:00 +0000129void Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
130 CXXMethodDecl *Method) {
Richard Smithb9d0b762012-07-27 04:22:15 +0000131 // If we have an MSAny spec already, don't bother.
132 if (!Method || ComputedEST == EST_MSAny)
Sean Hunt001cad92011-05-10 00:49:42 +0000133 return;
134
135 const FunctionProtoType *Proto
136 = Method->getType()->getAs<FunctionProtoType>();
Richard Smithe6975e92012-04-17 00:58:00 +0000137 Proto = Self->ResolveExceptionSpec(CallLoc, Proto);
138 if (!Proto)
139 return;
Sean Hunt001cad92011-05-10 00:49:42 +0000140
141 ExceptionSpecificationType EST = Proto->getExceptionSpecType();
142
143 // If this function can throw any exceptions, make a note of that.
Richard Smithb9d0b762012-07-27 04:22:15 +0000144 if (EST == EST_MSAny || EST == EST_None) {
Sean Hunt001cad92011-05-10 00:49:42 +0000145 ClearExceptions();
146 ComputedEST = EST;
147 return;
148 }
149
Richard Smith7a614d82011-06-11 17:19:42 +0000150 // FIXME: If the call to this decl is using any of its default arguments, we
151 // need to search them for potentially-throwing calls.
152
Sean Hunt001cad92011-05-10 00:49:42 +0000153 // If this function has a basic noexcept, it doesn't affect the outcome.
154 if (EST == EST_BasicNoexcept)
155 return;
156
157 // If we have a throw-all spec at this point, ignore the function.
158 if (ComputedEST == EST_None)
159 return;
160
161 // If we're still at noexcept(true) and there's a nothrow() callee,
162 // change to that specification.
163 if (EST == EST_DynamicNone) {
164 if (ComputedEST == EST_BasicNoexcept)
165 ComputedEST = EST_DynamicNone;
166 return;
167 }
168
169 // Check out noexcept specs.
170 if (EST == EST_ComputedNoexcept) {
Richard Smithe6975e92012-04-17 00:58:00 +0000171 FunctionProtoType::NoexceptResult NR =
172 Proto->getNoexceptSpec(Self->Context);
Sean Hunt001cad92011-05-10 00:49:42 +0000173 assert(NR != FunctionProtoType::NR_NoNoexcept &&
174 "Must have noexcept result for EST_ComputedNoexcept.");
175 assert(NR != FunctionProtoType::NR_Dependent &&
176 "Should not generate implicit declarations for dependent cases, "
177 "and don't know how to handle them anyway.");
178
179 // noexcept(false) -> no spec on the new function
180 if (NR == FunctionProtoType::NR_Throw) {
181 ClearExceptions();
182 ComputedEST = EST_None;
183 }
184 // noexcept(true) won't change anything either.
185 return;
186 }
187
188 assert(EST == EST_Dynamic && "EST case not considered earlier.");
189 assert(ComputedEST != EST_None &&
190 "Shouldn't collect exceptions when throw-all is guaranteed.");
191 ComputedEST = EST_Dynamic;
192 // Record the exceptions in this function's exception specification.
193 for (FunctionProtoType::exception_iterator E = Proto->exception_begin(),
194 EEnd = Proto->exception_end();
195 E != EEnd; ++E)
Richard Smithe6975e92012-04-17 00:58:00 +0000196 if (ExceptionsSeen.insert(Self->Context.getCanonicalType(*E)))
Sean Hunt001cad92011-05-10 00:49:42 +0000197 Exceptions.push_back(*E);
198}
199
Richard Smith7a614d82011-06-11 17:19:42 +0000200void Sema::ImplicitExceptionSpecification::CalledExpr(Expr *E) {
Richard Smithb9d0b762012-07-27 04:22:15 +0000201 if (!E || ComputedEST == EST_MSAny)
Richard Smith7a614d82011-06-11 17:19:42 +0000202 return;
203
204 // FIXME:
205 //
206 // C++0x [except.spec]p14:
NAKAMURA Takumi48579472011-06-21 03:19:28 +0000207 // [An] implicit exception-specification specifies the type-id T if and
208 // only if T is allowed by the exception-specification of a function directly
209 // invoked by f's implicit definition; f shall allow all exceptions if any
Richard Smith7a614d82011-06-11 17:19:42 +0000210 // function it directly invokes allows all exceptions, and f shall allow no
211 // exceptions if every function it directly invokes allows no exceptions.
212 //
213 // Note in particular that if an implicit exception-specification is generated
214 // for a function containing a throw-expression, that specification can still
215 // be noexcept(true).
216 //
217 // Note also that 'directly invoked' is not defined in the standard, and there
218 // is no indication that we should only consider potentially-evaluated calls.
219 //
220 // Ultimately we should implement the intent of the standard: the exception
221 // specification should be the set of exceptions which can be thrown by the
222 // implicit definition. For now, we assume that any non-nothrow expression can
223 // throw any exception.
224
Richard Smithe6975e92012-04-17 00:58:00 +0000225 if (Self->canThrow(E))
Richard Smith7a614d82011-06-11 17:19:42 +0000226 ComputedEST = EST_None;
227}
228
Anders Carlssoned961f92009-08-25 02:29:20 +0000229bool
John McCall9ae2f072010-08-23 23:25:46 +0000230Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
Mike Stump1eb44332009-09-09 15:08:12 +0000231 SourceLocation EqualLoc) {
Anders Carlsson5653ca52009-08-25 13:46:13 +0000232 if (RequireCompleteType(Param->getLocation(), Param->getType(),
233 diag::err_typecheck_decl_incomplete_type)) {
234 Param->setInvalidDecl();
235 return true;
236 }
237
Anders Carlssoned961f92009-08-25 02:29:20 +0000238 // C++ [dcl.fct.default]p5
239 // A default argument expression is implicitly converted (clause
240 // 4) to the parameter type. The default argument expression has
241 // the same semantic constraints as the initializer expression in
242 // a declaration of a variable of the parameter type, using the
243 // copy-initialization semantics (8.5).
Fariborz Jahanian745da3a2010-09-24 17:30:16 +0000244 InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
245 Param);
Douglas Gregor99a2e602009-12-16 01:38:02 +0000246 InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
247 EqualLoc);
Eli Friedman4a2c19b2009-12-22 02:46:13 +0000248 InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1);
Benjamin Kramer5354e772012-08-23 23:38:35 +0000249 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Arg);
Eli Friedman4a2c19b2009-12-22 02:46:13 +0000250 if (Result.isInvalid())
Anders Carlsson9351c172009-08-25 03:18:48 +0000251 return true;
Eli Friedman4a2c19b2009-12-22 02:46:13 +0000252 Arg = Result.takeAs<Expr>();
Anders Carlssoned961f92009-08-25 02:29:20 +0000253
John McCallb4eb64d2010-10-08 02:01:28 +0000254 CheckImplicitConversions(Arg, EqualLoc);
John McCall4765fa02010-12-06 08:20:24 +0000255 Arg = MaybeCreateExprWithCleanups(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000256
Anders Carlssoned961f92009-08-25 02:29:20 +0000257 // Okay: add the default argument to the parameter
258 Param->setDefaultArg(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +0000259
Douglas Gregor8cfb7a32010-10-12 18:23:32 +0000260 // We have already instantiated this parameter; provide each of the
261 // instantiations with the uninstantiated default argument.
262 UnparsedDefaultArgInstantiationsMap::iterator InstPos
263 = UnparsedDefaultArgInstantiations.find(Param);
264 if (InstPos != UnparsedDefaultArgInstantiations.end()) {
265 for (unsigned I = 0, N = InstPos->second.size(); I != N; ++I)
266 InstPos->second[I]->setUninstantiatedDefaultArg(Arg);
267
268 // We're done tracking this parameter's instantiations.
269 UnparsedDefaultArgInstantiations.erase(InstPos);
270 }
271
Anders Carlsson9351c172009-08-25 03:18:48 +0000272 return false;
Anders Carlssoned961f92009-08-25 02:29:20 +0000273}
274
Chris Lattner8123a952008-04-10 02:22:51 +0000275/// ActOnParamDefaultArgument - Check whether the default argument
276/// provided for a function parameter is well-formed. If so, attach it
277/// to the parameter declaration.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000278void
John McCalld226f652010-08-21 09:40:31 +0000279Sema::ActOnParamDefaultArgument(Decl *param, SourceLocation EqualLoc,
John McCall9ae2f072010-08-23 23:25:46 +0000280 Expr *DefaultArg) {
281 if (!param || !DefaultArg)
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000282 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000283
John McCalld226f652010-08-21 09:40:31 +0000284 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000285 UnparsedDefaultArgLocs.erase(Param);
286
Chris Lattner3d1cee32008-04-08 05:04:30 +0000287 // Default arguments are only permitted in C++
David Blaikie4e4d0842012-03-11 07:00:24 +0000288 if (!getLangOpts().CPlusPlus) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000289 Diag(EqualLoc, diag::err_param_default_argument)
290 << DefaultArg->getSourceRange();
Douglas Gregor72b505b2008-12-16 21:30:33 +0000291 Param->setInvalidDecl();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000292 return;
293 }
294
Douglas Gregor6f526752010-12-16 08:48:57 +0000295 // Check for unexpanded parameter packs.
296 if (DiagnoseUnexpandedParameterPack(DefaultArg, UPPC_DefaultArgument)) {
297 Param->setInvalidDecl();
298 return;
299 }
300
Anders Carlsson66e30672009-08-25 01:02:06 +0000301 // Check that the default argument is well-formed
John McCall9ae2f072010-08-23 23:25:46 +0000302 CheckDefaultArgumentVisitor DefaultArgChecker(DefaultArg, this);
303 if (DefaultArgChecker.Visit(DefaultArg)) {
Anders Carlsson66e30672009-08-25 01:02:06 +0000304 Param->setInvalidDecl();
305 return;
306 }
Mike Stump1eb44332009-09-09 15:08:12 +0000307
John McCall9ae2f072010-08-23 23:25:46 +0000308 SetParamDefaultArgument(Param, DefaultArg, EqualLoc);
Chris Lattner3d1cee32008-04-08 05:04:30 +0000309}
310
Douglas Gregor61366e92008-12-24 00:01:03 +0000311/// ActOnParamUnparsedDefaultArgument - We've seen a default
312/// argument for a function parameter, but we can't parse it yet
313/// because we're inside a class definition. Note that this default
314/// argument will be parsed later.
John McCalld226f652010-08-21 09:40:31 +0000315void Sema::ActOnParamUnparsedDefaultArgument(Decl *param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000316 SourceLocation EqualLoc,
317 SourceLocation ArgLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000318 if (!param)
319 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000320
John McCalld226f652010-08-21 09:40:31 +0000321 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Douglas Gregor61366e92008-12-24 00:01:03 +0000322 if (Param)
323 Param->setUnparsedDefaultArg();
Mike Stump1eb44332009-09-09 15:08:12 +0000324
Anders Carlsson5e300d12009-06-12 16:51:40 +0000325 UnparsedDefaultArgLocs[Param] = ArgLoc;
Douglas Gregor61366e92008-12-24 00:01:03 +0000326}
327
Douglas Gregor72b505b2008-12-16 21:30:33 +0000328/// ActOnParamDefaultArgumentError - Parsing or semantic analysis of
329/// the default argument for the parameter param failed.
John McCalld226f652010-08-21 09:40:31 +0000330void Sema::ActOnParamDefaultArgumentError(Decl *param) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +0000331 if (!param)
332 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000333
John McCalld226f652010-08-21 09:40:31 +0000334 ParmVarDecl *Param = cast<ParmVarDecl>(param);
Mike Stump1eb44332009-09-09 15:08:12 +0000335
Anders Carlsson5e300d12009-06-12 16:51:40 +0000336 Param->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000337
Anders Carlsson5e300d12009-06-12 16:51:40 +0000338 UnparsedDefaultArgLocs.erase(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000339}
340
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000341/// CheckExtraCXXDefaultArguments - Check for any extra default
342/// arguments in the declarator, which is not a function declaration
343/// or definition and therefore is not permitted to have default
344/// arguments. This routine should be invoked for every declarator
345/// that is not a function declaration or definition.
346void Sema::CheckExtraCXXDefaultArguments(Declarator &D) {
347 // C++ [dcl.fct.default]p3
348 // A default argument expression shall be specified only in the
349 // parameter-declaration-clause of a function declaration or in a
350 // template-parameter (14.1). It shall not be specified for a
351 // parameter pack. If it is specified in a
352 // parameter-declaration-clause, it shall not occur within a
353 // declarator or abstract-declarator of a parameter-declaration.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000354 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000355 DeclaratorChunk &chunk = D.getTypeObject(i);
356 if (chunk.Kind == DeclaratorChunk::Function) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000357 for (unsigned argIdx = 0, e = chunk.Fun.NumArgs; argIdx != e; ++argIdx) {
358 ParmVarDecl *Param =
John McCalld226f652010-08-21 09:40:31 +0000359 cast<ParmVarDecl>(chunk.Fun.ArgInfo[argIdx].Param);
Douglas Gregor61366e92008-12-24 00:01:03 +0000360 if (Param->hasUnparsedDefaultArg()) {
361 CachedTokens *Toks = chunk.Fun.ArgInfo[argIdx].DefaultArgTokens;
Douglas Gregor72b505b2008-12-16 21:30:33 +0000362 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
363 << SourceRange((*Toks)[1].getLocation(), Toks->back().getLocation());
364 delete Toks;
365 chunk.Fun.ArgInfo[argIdx].DefaultArgTokens = 0;
Douglas Gregor61366e92008-12-24 00:01:03 +0000366 } else if (Param->getDefaultArg()) {
367 Diag(Param->getLocation(), diag::err_param_default_argument_nonfunc)
368 << Param->getDefaultArg()->getSourceRange();
369 Param->setDefaultArg(0);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000370 }
371 }
372 }
373 }
374}
375
Craig Topper1a6eac82012-09-21 04:33:26 +0000376/// MergeCXXFunctionDecl - Merge two declarations of the same C++
377/// function, once we already know that they have the same
378/// type. Subroutine of MergeFunctionDecl. Returns true if there was an
379/// error, false otherwise.
James Molloy9cda03f2012-03-13 08:55:35 +0000380bool Sema::MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old,
381 Scope *S) {
Douglas Gregorcda9c672009-02-16 17:45:42 +0000382 bool Invalid = false;
383
Chris Lattner3d1cee32008-04-08 05:04:30 +0000384 // C++ [dcl.fct.default]p4:
Chris Lattner3d1cee32008-04-08 05:04:30 +0000385 // For non-template functions, default arguments can be added in
386 // later declarations of a function in the same
387 // scope. Declarations in different scopes have completely
388 // distinct sets of default arguments. That is, declarations in
389 // inner scopes do not acquire default arguments from
390 // declarations in outer scopes, and vice versa. In a given
391 // function declaration, all parameters subsequent to a
392 // parameter with a default argument shall have default
393 // arguments supplied in this or previous declarations. A
394 // default argument shall not be redefined by a later
395 // declaration (not even to the same value).
Douglas Gregor6cc15182009-09-11 18:44:32 +0000396 //
397 // C++ [dcl.fct.default]p6:
398 // Except for member functions of class templates, the default arguments
399 // in a member function definition that appears outside of the class
400 // definition are added to the set of default arguments provided by the
401 // member function declaration in the class definition.
Chris Lattner3d1cee32008-04-08 05:04:30 +0000402 for (unsigned p = 0, NumParams = Old->getNumParams(); p < NumParams; ++p) {
403 ParmVarDecl *OldParam = Old->getParamDecl(p);
404 ParmVarDecl *NewParam = New->getParamDecl(p);
405
James Molloy9cda03f2012-03-13 08:55:35 +0000406 bool OldParamHasDfl = OldParam->hasDefaultArg();
407 bool NewParamHasDfl = NewParam->hasDefaultArg();
408
409 NamedDecl *ND = Old;
410 if (S && !isDeclInScope(ND, New->getDeclContext(), S))
411 // Ignore default parameters of old decl if they are not in
412 // the same scope.
413 OldParamHasDfl = false;
414
415 if (OldParamHasDfl && NewParamHasDfl) {
Francois Pichet8cf90492011-04-10 04:58:30 +0000416
Francois Pichet8d051e02011-04-10 03:03:52 +0000417 unsigned DiagDefaultParamID =
418 diag::err_param_default_argument_redefinition;
419
420 // MSVC accepts that default parameters be redefined for member functions
421 // of template class. The new default parameter's value is ignored.
422 Invalid = true;
David Blaikie4e4d0842012-03-11 07:00:24 +0000423 if (getLangOpts().MicrosoftExt) {
Francois Pichet8d051e02011-04-10 03:03:52 +0000424 CXXMethodDecl* MD = dyn_cast<CXXMethodDecl>(New);
425 if (MD && MD->getParent()->getDescribedClassTemplate()) {
Francois Pichet8cf90492011-04-10 04:58:30 +0000426 // Merge the old default argument into the new parameter.
427 NewParam->setHasInheritedDefaultArg();
428 if (OldParam->hasUninstantiatedDefaultArg())
429 NewParam->setUninstantiatedDefaultArg(
430 OldParam->getUninstantiatedDefaultArg());
431 else
432 NewParam->setDefaultArg(OldParam->getInit());
Francois Pichetcf320c62011-04-22 08:25:24 +0000433 DiagDefaultParamID = diag::warn_param_default_argument_redefinition;
Francois Pichet8d051e02011-04-10 03:03:52 +0000434 Invalid = false;
435 }
436 }
Douglas Gregor4f123ff2010-01-13 00:12:48 +0000437
Francois Pichet8cf90492011-04-10 04:58:30 +0000438 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
439 // hint here. Alternatively, we could walk the type-source information
440 // for NewParam to find the last source location in the type... but it
441 // isn't worth the effort right now. This is the kind of test case that
442 // is hard to get right:
Douglas Gregor4f123ff2010-01-13 00:12:48 +0000443 // int f(int);
444 // void g(int (*fp)(int) = f);
445 // void g(int (*fp)(int) = &f);
Francois Pichet8d051e02011-04-10 03:03:52 +0000446 Diag(NewParam->getLocation(), DiagDefaultParamID)
Douglas Gregor4f123ff2010-01-13 00:12:48 +0000447 << NewParam->getDefaultArgRange();
Douglas Gregor6cc15182009-09-11 18:44:32 +0000448
449 // Look for the function declaration where the default argument was
450 // actually written, which may be a declaration prior to Old.
Douglas Gregoref96ee02012-01-14 16:38:05 +0000451 for (FunctionDecl *Older = Old->getPreviousDecl();
452 Older; Older = Older->getPreviousDecl()) {
Douglas Gregor6cc15182009-09-11 18:44:32 +0000453 if (!Older->getParamDecl(p)->hasDefaultArg())
454 break;
455
456 OldParam = Older->getParamDecl(p);
457 }
458
459 Diag(OldParam->getLocation(), diag::note_previous_definition)
460 << OldParam->getDefaultArgRange();
James Molloy9cda03f2012-03-13 08:55:35 +0000461 } else if (OldParamHasDfl) {
John McCall3d6c1782010-05-04 01:53:42 +0000462 // Merge the old default argument into the new parameter.
463 // It's important to use getInit() here; getDefaultArg()
John McCall4765fa02010-12-06 08:20:24 +0000464 // strips off any top-level ExprWithCleanups.
John McCallbf73b352010-03-12 18:31:32 +0000465 NewParam->setHasInheritedDefaultArg();
Douglas Gregord85cef52009-09-17 19:51:30 +0000466 if (OldParam->hasUninstantiatedDefaultArg())
467 NewParam->setUninstantiatedDefaultArg(
468 OldParam->getUninstantiatedDefaultArg());
469 else
John McCall3d6c1782010-05-04 01:53:42 +0000470 NewParam->setDefaultArg(OldParam->getInit());
James Molloy9cda03f2012-03-13 08:55:35 +0000471 } else if (NewParamHasDfl) {
Douglas Gregor6cc15182009-09-11 18:44:32 +0000472 if (New->getDescribedFunctionTemplate()) {
473 // Paragraph 4, quoted above, only applies to non-template functions.
474 Diag(NewParam->getLocation(),
475 diag::err_param_default_argument_template_redecl)
476 << NewParam->getDefaultArgRange();
477 Diag(Old->getLocation(), diag::note_template_prev_declaration)
478 << false;
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000479 } else if (New->getTemplateSpecializationKind()
480 != TSK_ImplicitInstantiation &&
481 New->getTemplateSpecializationKind() != TSK_Undeclared) {
482 // C++ [temp.expr.spec]p21:
483 // Default function arguments shall not be specified in a declaration
484 // or a definition for one of the following explicit specializations:
485 // - the explicit specialization of a function template;
Douglas Gregor8c638ab2009-10-13 23:52:38 +0000486 // - the explicit specialization of a member function template;
487 // - the explicit specialization of a member function of a class
Douglas Gregor096ebfd2009-10-13 17:02:54 +0000488 // template where the class template specialization to which the
489 // member function specialization belongs is implicitly
490 // instantiated.
491 Diag(NewParam->getLocation(), diag::err_template_spec_default_arg)
492 << (New->getTemplateSpecializationKind() ==TSK_ExplicitSpecialization)
493 << New->getDeclName()
494 << NewParam->getDefaultArgRange();
Douglas Gregor6cc15182009-09-11 18:44:32 +0000495 } else if (New->getDeclContext()->isDependentContext()) {
496 // C++ [dcl.fct.default]p6 (DR217):
497 // Default arguments for a member function of a class template shall
498 // be specified on the initial declaration of the member function
499 // within the class template.
500 //
501 // Reading the tea leaves a bit in DR217 and its reference to DR205
502 // leads me to the conclusion that one cannot add default function
503 // arguments for an out-of-line definition of a member function of a
504 // dependent type.
505 int WhichKind = 2;
506 if (CXXRecordDecl *Record
507 = dyn_cast<CXXRecordDecl>(New->getDeclContext())) {
508 if (Record->getDescribedClassTemplate())
509 WhichKind = 0;
510 else if (isa<ClassTemplatePartialSpecializationDecl>(Record))
511 WhichKind = 1;
512 else
513 WhichKind = 2;
514 }
515
516 Diag(NewParam->getLocation(),
517 diag::err_param_default_argument_member_template_redecl)
518 << WhichKind
519 << NewParam->getDefaultArgRange();
Sean Hunt9ae60d52011-05-26 01:26:05 +0000520 } else if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(New)) {
521 CXXSpecialMember NewSM = getSpecialMember(Ctor),
522 OldSM = getSpecialMember(cast<CXXConstructorDecl>(Old));
523 if (NewSM != OldSM) {
524 Diag(NewParam->getLocation(),diag::warn_default_arg_makes_ctor_special)
525 << NewParam->getDefaultArgRange() << NewSM;
526 Diag(Old->getLocation(), diag::note_previous_declaration_special)
527 << OldSM;
528 }
Douglas Gregor6cc15182009-09-11 18:44:32 +0000529 }
Chris Lattner3d1cee32008-04-08 05:04:30 +0000530 }
531 }
532
Richard Smithff234882012-02-20 23:28:05 +0000533 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
Richard Smith9f569cc2011-10-01 02:31:28 +0000534 // template has a constexpr specifier then all its declarations shall
Richard Smithff234882012-02-20 23:28:05 +0000535 // contain the constexpr specifier.
Richard Smith9f569cc2011-10-01 02:31:28 +0000536 if (New->isConstexpr() != Old->isConstexpr()) {
537 Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
538 << New << New->isConstexpr();
539 Diag(Old->getLocation(), diag::note_previous_declaration);
540 Invalid = true;
541 }
542
Douglas Gregore13ad832010-02-12 07:32:17 +0000543 if (CheckEquivalentExceptionSpec(Old, New))
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000544 Invalid = true;
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000545
Douglas Gregorcda9c672009-02-16 17:45:42 +0000546 return Invalid;
Chris Lattner3d1cee32008-04-08 05:04:30 +0000547}
548
Sebastian Redl60618fa2011-03-12 11:50:43 +0000549/// \brief Merge the exception specifications of two variable declarations.
550///
551/// This is called when there's a redeclaration of a VarDecl. The function
552/// checks if the redeclaration might have an exception specification and
553/// validates compatibility and merges the specs if necessary.
554void Sema::MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old) {
555 // Shortcut if exceptions are disabled.
David Blaikie4e4d0842012-03-11 07:00:24 +0000556 if (!getLangOpts().CXXExceptions)
Sebastian Redl60618fa2011-03-12 11:50:43 +0000557 return;
558
559 assert(Context.hasSameType(New->getType(), Old->getType()) &&
560 "Should only be called if types are otherwise the same.");
561
562 QualType NewType = New->getType();
563 QualType OldType = Old->getType();
564
565 // We're only interested in pointers and references to functions, as well
566 // as pointers to member functions.
567 if (const ReferenceType *R = NewType->getAs<ReferenceType>()) {
568 NewType = R->getPointeeType();
569 OldType = OldType->getAs<ReferenceType>()->getPointeeType();
570 } else if (const PointerType *P = NewType->getAs<PointerType>()) {
571 NewType = P->getPointeeType();
572 OldType = OldType->getAs<PointerType>()->getPointeeType();
573 } else if (const MemberPointerType *M = NewType->getAs<MemberPointerType>()) {
574 NewType = M->getPointeeType();
575 OldType = OldType->getAs<MemberPointerType>()->getPointeeType();
576 }
577
578 if (!NewType->isFunctionProtoType())
579 return;
580
581 // There's lots of special cases for functions. For function pointers, system
582 // libraries are hopefully not as broken so that we don't need these
583 // workarounds.
584 if (CheckEquivalentExceptionSpec(
585 OldType->getAs<FunctionProtoType>(), Old->getLocation(),
586 NewType->getAs<FunctionProtoType>(), New->getLocation())) {
587 New->setInvalidDecl();
588 }
589}
590
Chris Lattner3d1cee32008-04-08 05:04:30 +0000591/// CheckCXXDefaultArguments - Verify that the default arguments for a
592/// function declaration are well-formed according to C++
593/// [dcl.fct.default].
594void Sema::CheckCXXDefaultArguments(FunctionDecl *FD) {
595 unsigned NumParams = FD->getNumParams();
596 unsigned p;
597
Douglas Gregorc6889e72012-02-14 22:28:59 +0000598 bool IsLambda = FD->getOverloadedOperator() == OO_Call &&
599 isa<CXXMethodDecl>(FD) &&
600 cast<CXXMethodDecl>(FD)->getParent()->isLambda();
601
Chris Lattner3d1cee32008-04-08 05:04:30 +0000602 // Find first parameter with a default argument
603 for (p = 0; p < NumParams; ++p) {
604 ParmVarDecl *Param = FD->getParamDecl(p);
Douglas Gregorc6889e72012-02-14 22:28:59 +0000605 if (Param->hasDefaultArg()) {
606 // C++11 [expr.prim.lambda]p5:
607 // [...] Default arguments (8.3.6) shall not be specified in the
608 // parameter-declaration-clause of a lambda-declarator.
609 //
610 // FIXME: Core issue 974 strikes this sentence, we only provide an
611 // extension warning.
612 if (IsLambda)
613 Diag(Param->getLocation(), diag::ext_lambda_default_arguments)
614 << Param->getDefaultArgRange();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000615 break;
Douglas Gregorc6889e72012-02-14 22:28:59 +0000616 }
Chris Lattner3d1cee32008-04-08 05:04:30 +0000617 }
618
619 // C++ [dcl.fct.default]p4:
620 // In a given function declaration, all parameters
621 // subsequent to a parameter with a default argument shall
622 // have default arguments supplied in this or previous
623 // declarations. A default argument shall not be redefined
624 // by a later declaration (not even to the same value).
625 unsigned LastMissingDefaultArg = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000626 for (; p < NumParams; ++p) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000627 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5f49a0c2009-08-25 01:23:32 +0000628 if (!Param->hasDefaultArg()) {
Douglas Gregor72b505b2008-12-16 21:30:33 +0000629 if (Param->isInvalidDecl())
630 /* We already complained about this parameter. */;
631 else if (Param->getIdentifier())
Mike Stump1eb44332009-09-09 15:08:12 +0000632 Diag(Param->getLocation(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000633 diag::err_param_default_argument_missing_name)
Chris Lattner43b628c2008-11-19 07:32:16 +0000634 << Param->getIdentifier();
Chris Lattner3d1cee32008-04-08 05:04:30 +0000635 else
Mike Stump1eb44332009-09-09 15:08:12 +0000636 Diag(Param->getLocation(),
Chris Lattner3d1cee32008-04-08 05:04:30 +0000637 diag::err_param_default_argument_missing);
Mike Stump1eb44332009-09-09 15:08:12 +0000638
Chris Lattner3d1cee32008-04-08 05:04:30 +0000639 LastMissingDefaultArg = p;
640 }
641 }
642
643 if (LastMissingDefaultArg > 0) {
644 // Some default arguments were missing. Clear out all of the
645 // default arguments up to (and including) the last missing
646 // default argument, so that we leave the function parameters
647 // in a semantically valid state.
648 for (p = 0; p <= LastMissingDefaultArg; ++p) {
649 ParmVarDecl *Param = FD->getParamDecl(p);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000650 if (Param->hasDefaultArg()) {
Chris Lattner3d1cee32008-04-08 05:04:30 +0000651 Param->setDefaultArg(0);
652 }
653 }
654 }
655}
Douglas Gregore37ac4f2008-04-13 21:30:24 +0000656
Richard Smith9f569cc2011-10-01 02:31:28 +0000657// CheckConstexprParameterTypes - Check whether a function's parameter types
658// are all literal types. If so, return true. If not, produce a suitable
Richard Smith86c3ae42012-02-13 03:54:03 +0000659// diagnostic and return false.
660static bool CheckConstexprParameterTypes(Sema &SemaRef,
661 const FunctionDecl *FD) {
Richard Smith9f569cc2011-10-01 02:31:28 +0000662 unsigned ArgIndex = 0;
663 const FunctionProtoType *FT = FD->getType()->getAs<FunctionProtoType>();
664 for (FunctionProtoType::arg_type_iterator i = FT->arg_type_begin(),
665 e = FT->arg_type_end(); i != e; ++i, ++ArgIndex) {
666 const ParmVarDecl *PD = FD->getParamDecl(ArgIndex);
667 SourceLocation ParamLoc = PD->getLocation();
668 if (!(*i)->isDependentType() &&
Richard Smith86c3ae42012-02-13 03:54:03 +0000669 SemaRef.RequireLiteralType(ParamLoc, *i,
Douglas Gregorf502d8e2012-05-04 16:48:41 +0000670 diag::err_constexpr_non_literal_param,
671 ArgIndex+1, PD->getSourceRange(),
672 isa<CXXConstructorDecl>(FD)))
Richard Smith9f569cc2011-10-01 02:31:28 +0000673 return false;
Richard Smith9f569cc2011-10-01 02:31:28 +0000674 }
Joao Matos17d35c32012-08-31 22:18:20 +0000675 return true;
676}
677
678/// \brief Get diagnostic %select index for tag kind for
679/// record diagnostic message.
680/// WARNING: Indexes apply to particular diagnostics only!
681///
682/// \returns diagnostic %select index.
Joao Matosf143ae92012-09-01 00:13:24 +0000683static unsigned getRecordDiagFromTagKind(TagTypeKind Tag) {
Joao Matos17d35c32012-08-31 22:18:20 +0000684 switch (Tag) {
Joao Matosf143ae92012-09-01 00:13:24 +0000685 case TTK_Struct: return 0;
686 case TTK_Interface: return 1;
687 case TTK_Class: return 2;
688 default: llvm_unreachable("Invalid tag kind for record diagnostic!");
Joao Matos17d35c32012-08-31 22:18:20 +0000689 }
Joao Matos17d35c32012-08-31 22:18:20 +0000690}
691
692// CheckConstexprFunctionDecl - Check whether a function declaration satisfies
693// the requirements of a constexpr function definition or a constexpr
694// constructor definition. If so, return true. If not, produce appropriate
Richard Smith86c3ae42012-02-13 03:54:03 +0000695// diagnostics and return false.
Richard Smith9f569cc2011-10-01 02:31:28 +0000696//
Richard Smith86c3ae42012-02-13 03:54:03 +0000697// This implements C++11 [dcl.constexpr]p3,4, as amended by DR1360.
698bool Sema::CheckConstexprFunctionDecl(const FunctionDecl *NewFD) {
Richard Smith35340502012-01-13 04:54:00 +0000699 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
700 if (MD && MD->isInstance()) {
Richard Smith86c3ae42012-02-13 03:54:03 +0000701 // C++11 [dcl.constexpr]p4:
702 // The definition of a constexpr constructor shall satisfy the following
703 // constraints:
Richard Smith9f569cc2011-10-01 02:31:28 +0000704 // - the class shall not have any virtual base classes;
Joao Matos17d35c32012-08-31 22:18:20 +0000705 const CXXRecordDecl *RD = MD->getParent();
706 if (RD->getNumVBases()) {
707 Diag(NewFD->getLocation(), diag::err_constexpr_virtual_base)
708 << isa<CXXConstructorDecl>(NewFD)
709 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases();
710 for (CXXRecordDecl::base_class_const_iterator I = RD->vbases_begin(),
711 E = RD->vbases_end(); I != E; ++I)
712 Diag(I->getLocStart(),
Richard Smith86c3ae42012-02-13 03:54:03 +0000713 diag::note_constexpr_virtual_base_here) << I->getSourceRange();
Richard Smith9f569cc2011-10-01 02:31:28 +0000714 return false;
715 }
Richard Smith35340502012-01-13 04:54:00 +0000716 }
717
718 if (!isa<CXXConstructorDecl>(NewFD)) {
719 // C++11 [dcl.constexpr]p3:
Richard Smith9f569cc2011-10-01 02:31:28 +0000720 // The definition of a constexpr function shall satisfy the following
721 // constraints:
722 // - it shall not be virtual;
723 const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD);
724 if (Method && Method->isVirtual()) {
Richard Smith86c3ae42012-02-13 03:54:03 +0000725 Diag(NewFD->getLocation(), diag::err_constexpr_virtual);
Richard Smith9f569cc2011-10-01 02:31:28 +0000726
Richard Smith86c3ae42012-02-13 03:54:03 +0000727 // If it's not obvious why this function is virtual, find an overridden
728 // function which uses the 'virtual' keyword.
729 const CXXMethodDecl *WrittenVirtual = Method;
730 while (!WrittenVirtual->isVirtualAsWritten())
731 WrittenVirtual = *WrittenVirtual->begin_overridden_methods();
732 if (WrittenVirtual != Method)
733 Diag(WrittenVirtual->getLocation(),
734 diag::note_overridden_virtual_function);
Richard Smith9f569cc2011-10-01 02:31:28 +0000735 return false;
736 }
737
738 // - its return type shall be a literal type;
739 QualType RT = NewFD->getResultType();
740 if (!RT->isDependentType() &&
Richard Smith86c3ae42012-02-13 03:54:03 +0000741 RequireLiteralType(NewFD->getLocation(), RT,
Douglas Gregorf502d8e2012-05-04 16:48:41 +0000742 diag::err_constexpr_non_literal_return))
Richard Smith9f569cc2011-10-01 02:31:28 +0000743 return false;
Richard Smith9f569cc2011-10-01 02:31:28 +0000744 }
745
Richard Smith35340502012-01-13 04:54:00 +0000746 // - each of its parameter types shall be a literal type;
Richard Smith86c3ae42012-02-13 03:54:03 +0000747 if (!CheckConstexprParameterTypes(*this, NewFD))
Richard Smith35340502012-01-13 04:54:00 +0000748 return false;
749
Richard Smith9f569cc2011-10-01 02:31:28 +0000750 return true;
751}
752
753/// Check the given declaration statement is legal within a constexpr function
754/// body. C++0x [dcl.constexpr]p3,p4.
755///
756/// \return true if the body is OK, false if we have diagnosed a problem.
757static bool CheckConstexprDeclStmt(Sema &SemaRef, const FunctionDecl *Dcl,
758 DeclStmt *DS) {
759 // C++0x [dcl.constexpr]p3 and p4:
760 // The definition of a constexpr function(p3) or constructor(p4) [...] shall
761 // contain only
762 for (DeclStmt::decl_iterator DclIt = DS->decl_begin(),
763 DclEnd = DS->decl_end(); DclIt != DclEnd; ++DclIt) {
764 switch ((*DclIt)->getKind()) {
765 case Decl::StaticAssert:
766 case Decl::Using:
767 case Decl::UsingShadow:
768 case Decl::UsingDirective:
769 case Decl::UnresolvedUsingTypename:
770 // - static_assert-declarations
771 // - using-declarations,
772 // - using-directives,
773 continue;
774
775 case Decl::Typedef:
776 case Decl::TypeAlias: {
777 // - typedef declarations and alias-declarations that do not define
778 // classes or enumerations,
779 TypedefNameDecl *TN = cast<TypedefNameDecl>(*DclIt);
780 if (TN->getUnderlyingType()->isVariablyModifiedType()) {
781 // Don't allow variably-modified types in constexpr functions.
782 TypeLoc TL = TN->getTypeSourceInfo()->getTypeLoc();
783 SemaRef.Diag(TL.getBeginLoc(), diag::err_constexpr_vla)
784 << TL.getSourceRange() << TL.getType()
785 << isa<CXXConstructorDecl>(Dcl);
786 return false;
787 }
788 continue;
789 }
790
791 case Decl::Enum:
792 case Decl::CXXRecord:
793 // As an extension, we allow the declaration (but not the definition) of
794 // classes and enumerations in all declarations, not just in typedef and
795 // alias declarations.
796 if (cast<TagDecl>(*DclIt)->isThisDeclarationADefinition()) {
797 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_type_definition)
798 << isa<CXXConstructorDecl>(Dcl);
799 return false;
800 }
801 continue;
802
803 case Decl::Var:
804 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_var_declaration)
805 << isa<CXXConstructorDecl>(Dcl);
806 return false;
807
808 default:
809 SemaRef.Diag(DS->getLocStart(), diag::err_constexpr_body_invalid_stmt)
810 << isa<CXXConstructorDecl>(Dcl);
811 return false;
812 }
813 }
814
815 return true;
816}
817
818/// Check that the given field is initialized within a constexpr constructor.
819///
820/// \param Dcl The constexpr constructor being checked.
821/// \param Field The field being checked. This may be a member of an anonymous
822/// struct or union nested within the class being checked.
823/// \param Inits All declarations, including anonymous struct/union members and
824/// indirect members, for which any initialization was provided.
825/// \param Diagnosed Set to true if an error is produced.
826static void CheckConstexprCtorInitializer(Sema &SemaRef,
827 const FunctionDecl *Dcl,
828 FieldDecl *Field,
829 llvm::SmallSet<Decl*, 16> &Inits,
830 bool &Diagnosed) {
Douglas Gregord61db332011-10-10 17:22:13 +0000831 if (Field->isUnnamedBitfield())
832 return;
Richard Smith30ecfad2012-02-09 06:40:58 +0000833
834 if (Field->isAnonymousStructOrUnion() &&
835 Field->getType()->getAsCXXRecordDecl()->isEmpty())
836 return;
837
Richard Smith9f569cc2011-10-01 02:31:28 +0000838 if (!Inits.count(Field)) {
839 if (!Diagnosed) {
840 SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
841 Diagnosed = true;
842 }
843 SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
844 } else if (Field->isAnonymousStructOrUnion()) {
845 const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
846 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
847 I != E; ++I)
848 // If an anonymous union contains an anonymous struct of which any member
849 // is initialized, all members must be initialized.
David Blaikie581deb32012-06-06 20:45:41 +0000850 if (!RD->isUnion() || Inits.count(*I))
851 CheckConstexprCtorInitializer(SemaRef, Dcl, *I, Inits, Diagnosed);
Richard Smith9f569cc2011-10-01 02:31:28 +0000852 }
853}
854
855/// Check the body for the given constexpr function declaration only contains
856/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
857///
858/// \return true if the body is OK, false if we have diagnosed a problem.
Richard Smith86c3ae42012-02-13 03:54:03 +0000859bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
Richard Smith9f569cc2011-10-01 02:31:28 +0000860 if (isa<CXXTryStmt>(Body)) {
Richard Smith5ba73e12012-02-04 00:33:54 +0000861 // C++11 [dcl.constexpr]p3:
Richard Smith9f569cc2011-10-01 02:31:28 +0000862 // The definition of a constexpr function shall satisfy the following
863 // constraints: [...]
864 // - its function-body shall be = delete, = default, or a
865 // compound-statement
866 //
Richard Smith5ba73e12012-02-04 00:33:54 +0000867 // C++11 [dcl.constexpr]p4:
Richard Smith9f569cc2011-10-01 02:31:28 +0000868 // In the definition of a constexpr constructor, [...]
869 // - its function-body shall not be a function-try-block;
870 Diag(Body->getLocStart(), diag::err_constexpr_function_try_block)
871 << isa<CXXConstructorDecl>(Dcl);
872 return false;
873 }
874
875 // - its function-body shall be [...] a compound-statement that contains only
876 CompoundStmt *CompBody = cast<CompoundStmt>(Body);
877
878 llvm::SmallVector<SourceLocation, 4> ReturnStmts;
879 for (CompoundStmt::body_iterator BodyIt = CompBody->body_begin(),
880 BodyEnd = CompBody->body_end(); BodyIt != BodyEnd; ++BodyIt) {
881 switch ((*BodyIt)->getStmtClass()) {
882 case Stmt::NullStmtClass:
883 // - null statements,
884 continue;
885
886 case Stmt::DeclStmtClass:
887 // - static_assert-declarations
888 // - using-declarations,
889 // - using-directives,
890 // - typedef declarations and alias-declarations that do not define
891 // classes or enumerations,
892 if (!CheckConstexprDeclStmt(*this, Dcl, cast<DeclStmt>(*BodyIt)))
893 return false;
894 continue;
895
896 case Stmt::ReturnStmtClass:
897 // - and exactly one return statement;
898 if (isa<CXXConstructorDecl>(Dcl))
899 break;
900
901 ReturnStmts.push_back((*BodyIt)->getLocStart());
Richard Smith9f569cc2011-10-01 02:31:28 +0000902 continue;
903
904 default:
905 break;
906 }
907
908 Diag((*BodyIt)->getLocStart(), diag::err_constexpr_body_invalid_stmt)
909 << isa<CXXConstructorDecl>(Dcl);
910 return false;
911 }
912
913 if (const CXXConstructorDecl *Constructor
914 = dyn_cast<CXXConstructorDecl>(Dcl)) {
915 const CXXRecordDecl *RD = Constructor->getParent();
Richard Smith30ecfad2012-02-09 06:40:58 +0000916 // DR1359:
917 // - every non-variant non-static data member and base class sub-object
918 // shall be initialized;
919 // - if the class is a non-empty union, or for each non-empty anonymous
920 // union member of a non-union class, exactly one non-static data member
921 // shall be initialized;
Richard Smith9f569cc2011-10-01 02:31:28 +0000922 if (RD->isUnion()) {
Richard Smith30ecfad2012-02-09 06:40:58 +0000923 if (Constructor->getNumCtorInitializers() == 0 && !RD->isEmpty()) {
Richard Smith9f569cc2011-10-01 02:31:28 +0000924 Diag(Dcl->getLocation(), diag::err_constexpr_union_ctor_no_init);
925 return false;
926 }
Richard Smith6e433752011-10-10 16:38:04 +0000927 } else if (!Constructor->isDependentContext() &&
928 !Constructor->isDelegatingConstructor()) {
Richard Smith9f569cc2011-10-01 02:31:28 +0000929 assert(RD->getNumVBases() == 0 && "constexpr ctor with virtual bases");
930
931 // Skip detailed checking if we have enough initializers, and we would
932 // allow at most one initializer per member.
933 bool AnyAnonStructUnionMembers = false;
934 unsigned Fields = 0;
935 for (CXXRecordDecl::field_iterator I = RD->field_begin(),
936 E = RD->field_end(); I != E; ++I, ++Fields) {
David Blaikie262bc182012-04-30 02:36:29 +0000937 if (I->isAnonymousStructOrUnion()) {
Richard Smith9f569cc2011-10-01 02:31:28 +0000938 AnyAnonStructUnionMembers = true;
939 break;
940 }
941 }
942 if (AnyAnonStructUnionMembers ||
943 Constructor->getNumCtorInitializers() != RD->getNumBases() + Fields) {
944 // Check initialization of non-static data members. Base classes are
945 // always initialized so do not need to be checked. Dependent bases
946 // might not have initializers in the member initializer list.
947 llvm::SmallSet<Decl*, 16> Inits;
948 for (CXXConstructorDecl::init_const_iterator
949 I = Constructor->init_begin(), E = Constructor->init_end();
950 I != E; ++I) {
951 if (FieldDecl *FD = (*I)->getMember())
952 Inits.insert(FD);
953 else if (IndirectFieldDecl *ID = (*I)->getIndirectMember())
954 Inits.insert(ID->chain_begin(), ID->chain_end());
955 }
956
957 bool Diagnosed = false;
958 for (CXXRecordDecl::field_iterator I = RD->field_begin(),
959 E = RD->field_end(); I != E; ++I)
David Blaikie581deb32012-06-06 20:45:41 +0000960 CheckConstexprCtorInitializer(*this, Dcl, *I, Inits, Diagnosed);
Richard Smith9f569cc2011-10-01 02:31:28 +0000961 if (Diagnosed)
962 return false;
963 }
964 }
Richard Smith9f569cc2011-10-01 02:31:28 +0000965 } else {
966 if (ReturnStmts.empty()) {
967 Diag(Dcl->getLocation(), diag::err_constexpr_body_no_return);
968 return false;
969 }
970 if (ReturnStmts.size() > 1) {
971 Diag(ReturnStmts.back(), diag::err_constexpr_body_multiple_return);
972 for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)
973 Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);
974 return false;
975 }
976 }
977
Richard Smith5ba73e12012-02-04 00:33:54 +0000978 // C++11 [dcl.constexpr]p5:
979 // if no function argument values exist such that the function invocation
980 // substitution would produce a constant expression, the program is
981 // ill-formed; no diagnostic required.
982 // C++11 [dcl.constexpr]p3:
983 // - every constructor call and implicit conversion used in initializing the
984 // return value shall be one of those allowed in a constant expression.
985 // C++11 [dcl.constexpr]p4:
986 // - every constructor involved in initializing non-static data members and
987 // base class sub-objects shall be a constexpr constructor.
Richard Smith745f5142012-01-27 01:14:48 +0000988 llvm::SmallVector<PartialDiagnosticAt, 8> Diags;
Richard Smith86c3ae42012-02-13 03:54:03 +0000989 if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
Richard Smith745f5142012-01-27 01:14:48 +0000990 Diag(Dcl->getLocation(), diag::err_constexpr_function_never_constant_expr)
991 << isa<CXXConstructorDecl>(Dcl);
992 for (size_t I = 0, N = Diags.size(); I != N; ++I)
993 Diag(Diags[I].first, Diags[I].second);
994 return false;
995 }
996
Richard Smith9f569cc2011-10-01 02:31:28 +0000997 return true;
998}
999
Douglas Gregorb48fe382008-10-31 09:07:45 +00001000/// isCurrentClassName - Determine whether the identifier II is the
1001/// name of the class type currently being defined. In the case of
1002/// nested classes, this will only return true if II is the name of
1003/// the innermost class.
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001004bool Sema::isCurrentClassName(const IdentifierInfo &II, Scope *,
1005 const CXXScopeSpec *SS) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001006 assert(getLangOpts().CPlusPlus && "No class names in C!");
Douglas Gregorb862b8f2010-01-11 23:29:10 +00001007
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001008 CXXRecordDecl *CurDecl;
Douglas Gregore4e5b052009-03-19 00:18:19 +00001009 if (SS && SS->isSet() && !SS->isInvalid()) {
Douglas Gregorac373c42009-08-21 22:16:40 +00001010 DeclContext *DC = computeDeclContext(*SS, true);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001011 CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);
1012 } else
1013 CurDecl = dyn_cast_or_null<CXXRecordDecl>(CurContext);
1014
Douglas Gregor6f7a17b2010-02-05 06:12:42 +00001015 if (CurDecl && CurDecl->getIdentifier())
Douglas Gregorb48fe382008-10-31 09:07:45 +00001016 return &II == CurDecl->getIdentifier();
1017 else
1018 return false;
1019}
1020
Mike Stump1eb44332009-09-09 15:08:12 +00001021/// \brief Check the validity of a C++ base class specifier.
Douglas Gregor2943aed2009-03-03 04:44:36 +00001022///
1023/// \returns a new CXXBaseSpecifier if well-formed, emits diagnostics
1024/// and returns NULL otherwise.
1025CXXBaseSpecifier *
1026Sema::CheckBaseSpecifier(CXXRecordDecl *Class,
1027 SourceRange SpecifierRange,
1028 bool Virtual, AccessSpecifier Access,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001029 TypeSourceInfo *TInfo,
1030 SourceLocation EllipsisLoc) {
Nick Lewycky56062202010-07-26 16:56:01 +00001031 QualType BaseType = TInfo->getType();
1032
Douglas Gregor2943aed2009-03-03 04:44:36 +00001033 // C++ [class.union]p1:
1034 // A union shall not have base classes.
1035 if (Class->isUnion()) {
1036 Diag(Class->getLocation(), diag::err_base_clause_on_union)
1037 << SpecifierRange;
1038 return 0;
1039 }
1040
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001041 if (EllipsisLoc.isValid() &&
1042 !TInfo->getType()->containsUnexpandedParameterPack()) {
1043 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
1044 << TInfo->getTypeLoc().getSourceRange();
1045 EllipsisLoc = SourceLocation();
1046 }
1047
Douglas Gregor2943aed2009-03-03 04:44:36 +00001048 if (BaseType->isDependentType())
Mike Stump1eb44332009-09-09 15:08:12 +00001049 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Nick Lewycky56062202010-07-26 16:56:01 +00001050 Class->getTagKind() == TTK_Class,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001051 Access, TInfo, EllipsisLoc);
Nick Lewycky56062202010-07-26 16:56:01 +00001052
1053 SourceLocation BaseLoc = TInfo->getTypeLoc().getBeginLoc();
Douglas Gregor2943aed2009-03-03 04:44:36 +00001054
1055 // Base specifiers must be record types.
1056 if (!BaseType->isRecordType()) {
1057 Diag(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;
1058 return 0;
1059 }
1060
1061 // C++ [class.union]p1:
1062 // A union shall not be used as a base class.
1063 if (BaseType->isUnionType()) {
1064 Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;
1065 return 0;
1066 }
1067
1068 // C++ [class.derived]p2:
1069 // The class-name in a base-specifier shall not be an incompletely
1070 // defined class.
Mike Stump1eb44332009-09-09 15:08:12 +00001071 if (RequireCompleteType(BaseLoc, BaseType,
Douglas Gregord10099e2012-05-04 16:32:21 +00001072 diag::err_incomplete_base_class, SpecifierRange)) {
John McCall572fc622010-08-17 07:23:57 +00001073 Class->setInvalidDecl();
Douglas Gregor2943aed2009-03-03 04:44:36 +00001074 return 0;
John McCall572fc622010-08-17 07:23:57 +00001075 }
Douglas Gregor2943aed2009-03-03 04:44:36 +00001076
Eli Friedman1d954f62009-08-15 21:55:26 +00001077 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
Ted Kremenek6217b802009-07-29 21:53:49 +00001078 RecordDecl *BaseDecl = BaseType->getAs<RecordType>()->getDecl();
Douglas Gregor2943aed2009-03-03 04:44:36 +00001079 assert(BaseDecl && "Record type has no declaration");
Douglas Gregor952b0172010-02-11 01:04:33 +00001080 BaseDecl = BaseDecl->getDefinition();
Douglas Gregor2943aed2009-03-03 04:44:36 +00001081 assert(BaseDecl && "Base type is not incomplete, but has no definition");
Eli Friedman1d954f62009-08-15 21:55:26 +00001082 CXXRecordDecl * CXXBaseDecl = cast<CXXRecordDecl>(BaseDecl);
1083 assert(CXXBaseDecl && "Base type is not a C++ type");
Eli Friedmand0137332009-12-05 23:03:49 +00001084
Anders Carlsson1d209272011-03-25 14:55:14 +00001085 // C++ [class]p3:
1086 // If a class is marked final and it appears as a base-type-specifier in
1087 // base-clause, the program is ill-formed.
Anders Carlssoncb88a1f2011-01-24 16:26:15 +00001088 if (CXXBaseDecl->hasAttr<FinalAttr>()) {
Anders Carlssondfc2f102011-01-22 17:51:53 +00001089 Diag(BaseLoc, diag::err_class_marked_final_used_as_base)
1090 << CXXBaseDecl->getDeclName();
1091 Diag(CXXBaseDecl->getLocation(), diag::note_previous_decl)
1092 << CXXBaseDecl->getDeclName();
1093 return 0;
1094 }
1095
John McCall572fc622010-08-17 07:23:57 +00001096 if (BaseDecl->isInvalidDecl())
1097 Class->setInvalidDecl();
Anders Carlsson51f94042009-12-03 17:49:57 +00001098
1099 // Create the base specifier.
Anders Carlsson51f94042009-12-03 17:49:57 +00001100 return new (Context) CXXBaseSpecifier(SpecifierRange, Virtual,
Nick Lewycky56062202010-07-26 16:56:01 +00001101 Class->getTagKind() == TTK_Class,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001102 Access, TInfo, EllipsisLoc);
Anders Carlsson51f94042009-12-03 17:49:57 +00001103}
1104
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001105/// ActOnBaseSpecifier - Parsed a base specifier. A base specifier is
1106/// one entry in the base class list of a class specifier, for
Mike Stump1eb44332009-09-09 15:08:12 +00001107/// example:
1108/// class foo : public bar, virtual private baz {
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001109/// 'public bar' and 'virtual private baz' are each base-specifiers.
John McCallf312b1e2010-08-26 23:41:50 +00001110BaseResult
John McCalld226f652010-08-21 09:40:31 +00001111Sema::ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange,
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001112 bool Virtual, AccessSpecifier Access,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001113 ParsedType basetype, SourceLocation BaseLoc,
1114 SourceLocation EllipsisLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001115 if (!classdecl)
1116 return true;
1117
Douglas Gregor40808ce2009-03-09 23:48:35 +00001118 AdjustDeclIfTemplate(classdecl);
John McCalld226f652010-08-21 09:40:31 +00001119 CXXRecordDecl *Class = dyn_cast<CXXRecordDecl>(classdecl);
Douglas Gregor5fe8c042010-02-27 00:25:28 +00001120 if (!Class)
1121 return true;
1122
Nick Lewycky56062202010-07-26 16:56:01 +00001123 TypeSourceInfo *TInfo = 0;
1124 GetTypeFromParser(basetype, &TInfo);
Douglas Gregord0937222010-12-13 22:49:22 +00001125
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001126 if (EllipsisLoc.isInvalid() &&
1127 DiagnoseUnexpandedParameterPack(SpecifierRange.getBegin(), TInfo,
Douglas Gregord0937222010-12-13 22:49:22 +00001128 UPPC_BaseType))
1129 return true;
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001130
Douglas Gregor2943aed2009-03-03 04:44:36 +00001131 if (CXXBaseSpecifier *BaseSpec = CheckBaseSpecifier(Class, SpecifierRange,
Douglas Gregorf90b27a2011-01-03 22:36:02 +00001132 Virtual, Access, TInfo,
1133 EllipsisLoc))
Douglas Gregor2943aed2009-03-03 04:44:36 +00001134 return BaseSpec;
Douglas Gregor8a50fe02012-07-02 21:00:41 +00001135 else
1136 Class->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001137
Douglas Gregor2943aed2009-03-03 04:44:36 +00001138 return true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001139}
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001140
Douglas Gregor2943aed2009-03-03 04:44:36 +00001141/// \brief Performs the actual work of attaching the given base class
1142/// specifiers to a C++ class.
1143bool Sema::AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
1144 unsigned NumBases) {
1145 if (NumBases == 0)
1146 return false;
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001147
1148 // Used to keep track of which base types we have already seen, so
1149 // that we can properly diagnose redundant direct base types. Note
Douglas Gregor57c856b2008-10-23 18:13:27 +00001150 // that the key is always the unqualified canonical type of the base
1151 // class.
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001152 std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;
1153
1154 // Copy non-redundant base specifiers into permanent storage.
Douglas Gregor57c856b2008-10-23 18:13:27 +00001155 unsigned NumGoodBases = 0;
Douglas Gregor2943aed2009-03-03 04:44:36 +00001156 bool Invalid = false;
Douglas Gregor57c856b2008-10-23 18:13:27 +00001157 for (unsigned idx = 0; idx < NumBases; ++idx) {
Mike Stump1eb44332009-09-09 15:08:12 +00001158 QualType NewBaseType
Douglas Gregor2943aed2009-03-03 04:44:36 +00001159 = Context.getCanonicalType(Bases[idx]->getType());
Douglas Gregora4923eb2009-11-16 21:35:15 +00001160 NewBaseType = NewBaseType.getLocalUnqualifiedType();
Benjamin Kramer52c16682012-03-05 17:20:04 +00001161
1162 CXXBaseSpecifier *&KnownBase = KnownBaseTypes[NewBaseType];
1163 if (KnownBase) {
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001164 // C++ [class.mi]p3:
1165 // A class shall not be specified as a direct base class of a
1166 // derived class more than once.
Daniel Dunbar96a00142012-03-09 18:35:03 +00001167 Diag(Bases[idx]->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001168 diag::err_duplicate_base_class)
Benjamin Kramer52c16682012-03-05 17:20:04 +00001169 << KnownBase->getType()
Douglas Gregor2943aed2009-03-03 04:44:36 +00001170 << Bases[idx]->getSourceRange();
Douglas Gregor57c856b2008-10-23 18:13:27 +00001171
1172 // Delete the duplicate base class specifier; we're going to
1173 // overwrite its pointer later.
Douglas Gregor2aef06d2009-07-22 20:55:49 +00001174 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001175
1176 Invalid = true;
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001177 } else {
1178 // Okay, add this new base class.
Benjamin Kramer52c16682012-03-05 17:20:04 +00001179 KnownBase = Bases[idx];
Douglas Gregor2943aed2009-03-03 04:44:36 +00001180 Bases[NumGoodBases++] = Bases[idx];
Fariborz Jahanian91589022011-10-24 17:30:45 +00001181 if (const RecordType *Record = NewBaseType->getAs<RecordType>())
Fariborz Jahanian13c7fcc2011-10-21 22:27:12 +00001182 if (const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl()))
1183 if (RD->hasAttr<WeakAttr>())
1184 Class->addAttr(::new (Context) WeakAttr(SourceRange(), Context));
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001185 }
1186 }
1187
1188 // Attach the remaining base class specifiers to the derived class.
Douglas Gregor2d5b7032010-02-11 01:30:34 +00001189 Class->setBases(Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +00001190
1191 // Delete the remaining (good) base class specifiers, since their
1192 // data has been copied into the CXXRecordDecl.
1193 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2aef06d2009-07-22 20:55:49 +00001194 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001195
1196 return Invalid;
1197}
1198
1199/// ActOnBaseSpecifiers - Attach the given base specifiers to the
1200/// class, after checking whether there are any duplicate base
1201/// classes.
Richard Trieu90ab75b2011-09-09 03:18:59 +00001202void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +00001203 unsigned NumBases) {
1204 if (!ClassDecl || !Bases || !NumBases)
1205 return;
1206
1207 AdjustDeclIfTemplate(ClassDecl);
John McCalld226f652010-08-21 09:40:31 +00001208 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl),
Douglas Gregor2943aed2009-03-03 04:44:36 +00001209 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001210}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001211
John McCall3cb0ebd2010-03-10 03:28:59 +00001212static CXXRecordDecl *GetClassForType(QualType T) {
1213 if (const RecordType *RT = T->getAs<RecordType>())
1214 return cast<CXXRecordDecl>(RT->getDecl());
1215 else if (const InjectedClassNameType *ICT = T->getAs<InjectedClassNameType>())
1216 return ICT->getDecl();
1217 else
1218 return 0;
1219}
1220
Douglas Gregora8f32e02009-10-06 17:59:45 +00001221/// \brief Determine whether the type \p Derived is a C++ class that is
1222/// derived from the type \p Base.
1223bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001224 if (!getLangOpts().CPlusPlus)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001225 return false;
John McCall3cb0ebd2010-03-10 03:28:59 +00001226
1227 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
1228 if (!DerivedRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001229 return false;
1230
John McCall3cb0ebd2010-03-10 03:28:59 +00001231 CXXRecordDecl *BaseRD = GetClassForType(Base);
1232 if (!BaseRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001233 return false;
1234
John McCall86ff3082010-02-04 22:26:26 +00001235 // FIXME: instantiate DerivedRD if necessary. We need a PoI for this.
1236 return DerivedRD->hasDefinition() && DerivedRD->isDerivedFrom(BaseRD);
Douglas Gregora8f32e02009-10-06 17:59:45 +00001237}
1238
1239/// \brief Determine whether the type \p Derived is a C++ class that is
1240/// derived from the type \p Base.
1241bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001242 if (!getLangOpts().CPlusPlus)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001243 return false;
1244
John McCall3cb0ebd2010-03-10 03:28:59 +00001245 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
1246 if (!DerivedRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001247 return false;
1248
John McCall3cb0ebd2010-03-10 03:28:59 +00001249 CXXRecordDecl *BaseRD = GetClassForType(Base);
1250 if (!BaseRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001251 return false;
1252
Douglas Gregora8f32e02009-10-06 17:59:45 +00001253 return DerivedRD->isDerivedFrom(BaseRD, Paths);
1254}
1255
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001256void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
John McCallf871d0c2010-08-07 06:22:56 +00001257 CXXCastPath &BasePathArray) {
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001258 assert(BasePathArray.empty() && "Base path array must be empty!");
1259 assert(Paths.isRecordingPaths() && "Must record paths!");
1260
1261 const CXXBasePath &Path = Paths.front();
1262
1263 // We first go backward and check if we have a virtual base.
1264 // FIXME: It would be better if CXXBasePath had the base specifier for
1265 // the nearest virtual base.
1266 unsigned Start = 0;
1267 for (unsigned I = Path.size(); I != 0; --I) {
1268 if (Path[I - 1].Base->isVirtual()) {
1269 Start = I - 1;
1270 break;
1271 }
1272 }
1273
1274 // Now add all bases.
1275 for (unsigned I = Start, E = Path.size(); I != E; ++I)
John McCallf871d0c2010-08-07 06:22:56 +00001276 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001277}
1278
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001279/// \brief Determine whether the given base path includes a virtual
1280/// base class.
John McCallf871d0c2010-08-07 06:22:56 +00001281bool Sema::BasePathInvolvesVirtualBase(const CXXCastPath &BasePath) {
1282 for (CXXCastPath::const_iterator B = BasePath.begin(),
1283 BEnd = BasePath.end();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001284 B != BEnd; ++B)
1285 if ((*B)->isVirtual())
1286 return true;
1287
1288 return false;
1289}
1290
Douglas Gregora8f32e02009-10-06 17:59:45 +00001291/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
1292/// conversion (where Derived and Base are class types) is
1293/// well-formed, meaning that the conversion is unambiguous (and
1294/// that all of the base classes are accessible). Returns true
1295/// and emits a diagnostic if the code is ill-formed, returns false
1296/// otherwise. Loc is the location where this routine should point to
1297/// if there is an error, and Range is the source range to highlight
1298/// if there is an error.
1299bool
1300Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
John McCall58e6f342010-03-16 05:22:47 +00001301 unsigned InaccessibleBaseID,
Douglas Gregora8f32e02009-10-06 17:59:45 +00001302 unsigned AmbigiousBaseConvID,
1303 SourceLocation Loc, SourceRange Range,
Anders Carlssone25a96c2010-04-24 17:11:09 +00001304 DeclarationName Name,
John McCallf871d0c2010-08-07 06:22:56 +00001305 CXXCastPath *BasePath) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001306 // First, determine whether the path from Derived to Base is
1307 // ambiguous. This is slightly more expensive than checking whether
1308 // the Derived to Base conversion exists, because here we need to
1309 // explore multiple paths to determine if there is an ambiguity.
1310 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1311 /*DetectVirtual=*/false);
1312 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
1313 assert(DerivationOkay &&
1314 "Can only be used with a derived-to-base conversion");
1315 (void)DerivationOkay;
1316
1317 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001318 if (InaccessibleBaseID) {
1319 // Check that the base class can be accessed.
1320 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
1321 InaccessibleBaseID)) {
1322 case AR_inaccessible:
1323 return true;
1324 case AR_accessible:
1325 case AR_dependent:
1326 case AR_delayed:
1327 break;
Anders Carlssone25a96c2010-04-24 17:11:09 +00001328 }
John McCall6b2accb2010-02-10 09:31:12 +00001329 }
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001330
1331 // Build a base path if necessary.
1332 if (BasePath)
1333 BuildBasePathArray(Paths, *BasePath);
1334 return false;
Douglas Gregora8f32e02009-10-06 17:59:45 +00001335 }
1336
1337 // We know that the derived-to-base conversion is ambiguous, and
1338 // we're going to produce a diagnostic. Perform the derived-to-base
1339 // search just one more time to compute all of the possible paths so
1340 // that we can print them out. This is more expensive than any of
1341 // the previous derived-to-base checks we've done, but at this point
1342 // performance isn't as much of an issue.
1343 Paths.clear();
1344 Paths.setRecordingPaths(true);
1345 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
1346 assert(StillOkay && "Can only be used with a derived-to-base conversion");
1347 (void)StillOkay;
1348
1349 // Build up a textual representation of the ambiguous paths, e.g.,
1350 // D -> B -> A, that will be used to illustrate the ambiguous
1351 // conversions in the diagnostic. We only print one of the paths
1352 // to each base class subobject.
1353 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1354
1355 Diag(Loc, AmbigiousBaseConvID)
1356 << Derived << Base << PathDisplayStr << Range << Name;
1357 return true;
1358}
1359
1360bool
1361Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001362 SourceLocation Loc, SourceRange Range,
John McCallf871d0c2010-08-07 06:22:56 +00001363 CXXCastPath *BasePath,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001364 bool IgnoreAccess) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001365 return CheckDerivedToBaseConversion(Derived, Base,
John McCall58e6f342010-03-16 05:22:47 +00001366 IgnoreAccess ? 0
1367 : diag::err_upcast_to_inaccessible_base,
Douglas Gregora8f32e02009-10-06 17:59:45 +00001368 diag::err_ambiguous_derived_to_base_conv,
Anders Carlssone25a96c2010-04-24 17:11:09 +00001369 Loc, Range, DeclarationName(),
1370 BasePath);
Douglas Gregora8f32e02009-10-06 17:59:45 +00001371}
1372
1373
1374/// @brief Builds a string representing ambiguous paths from a
1375/// specific derived class to different subobjects of the same base
1376/// class.
1377///
1378/// This function builds a string that can be used in error messages
1379/// to show the different paths that one can take through the
1380/// inheritance hierarchy to go from the derived class to different
1381/// subobjects of a base class. The result looks something like this:
1382/// @code
1383/// struct D -> struct B -> struct A
1384/// struct D -> struct C -> struct A
1385/// @endcode
1386std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
1387 std::string PathDisplayStr;
1388 std::set<unsigned> DisplayedPaths;
1389 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1390 Path != Paths.end(); ++Path) {
1391 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
1392 // We haven't displayed a path to this particular base
1393 // class subobject yet.
1394 PathDisplayStr += "\n ";
1395 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
1396 for (CXXBasePath::const_iterator Element = Path->begin();
1397 Element != Path->end(); ++Element)
1398 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
1399 }
1400 }
1401
1402 return PathDisplayStr;
1403}
1404
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001405//===----------------------------------------------------------------------===//
1406// C++ class member Handling
1407//===----------------------------------------------------------------------===//
1408
Abramo Bagnara6206d532010-06-05 05:09:32 +00001409/// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
Erik Verbruggen5f1c8222011-10-13 09:41:32 +00001410bool Sema::ActOnAccessSpecifier(AccessSpecifier Access,
1411 SourceLocation ASLoc,
1412 SourceLocation ColonLoc,
1413 AttributeList *Attrs) {
Abramo Bagnara6206d532010-06-05 05:09:32 +00001414 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
John McCalld226f652010-08-21 09:40:31 +00001415 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
Abramo Bagnara6206d532010-06-05 05:09:32 +00001416 ASLoc, ColonLoc);
1417 CurContext->addHiddenDecl(ASDecl);
Erik Verbruggen5f1c8222011-10-13 09:41:32 +00001418 return ProcessAccessDeclAttributeList(ASDecl, Attrs);
Abramo Bagnara6206d532010-06-05 05:09:32 +00001419}
1420
Richard Smitha4b39652012-08-06 03:25:17 +00001421/// CheckOverrideControl - Check C++11 override control semantics.
1422void Sema::CheckOverrideControl(Decl *D) {
Richard Smithcddbc1d2012-09-06 18:32:18 +00001423 if (D->isInvalidDecl())
1424 return;
1425
Chris Lattner5f9e2722011-07-23 10:55:15 +00001426 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
Anders Carlsson9e682d92011-01-20 05:57:14 +00001427
Richard Smitha4b39652012-08-06 03:25:17 +00001428 // Do we know which functions this declaration might be overriding?
1429 bool OverridesAreKnown = !MD ||
1430 (!MD->getParent()->hasAnyDependentBases() &&
1431 !MD->getType()->isDependentType());
Anders Carlsson3ffe1832011-01-20 06:33:26 +00001432
Richard Smitha4b39652012-08-06 03:25:17 +00001433 if (!MD || !MD->isVirtual()) {
1434 if (OverridesAreKnown) {
1435 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1436 Diag(OA->getLocation(),
1437 diag::override_keyword_only_allowed_on_virtual_member_functions)
1438 << "override" << FixItHint::CreateRemoval(OA->getLocation());
1439 D->dropAttr<OverrideAttr>();
1440 }
1441 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1442 Diag(FA->getLocation(),
1443 diag::override_keyword_only_allowed_on_virtual_member_functions)
1444 << "final" << FixItHint::CreateRemoval(FA->getLocation());
1445 D->dropAttr<FinalAttr>();
1446 }
1447 }
Anders Carlsson9e682d92011-01-20 05:57:14 +00001448 return;
1449 }
Richard Smitha4b39652012-08-06 03:25:17 +00001450
1451 if (!OverridesAreKnown)
1452 return;
1453
1454 // C++11 [class.virtual]p5:
1455 // If a virtual function is marked with the virt-specifier override and
1456 // does not override a member function of a base class, the program is
1457 // ill-formed.
1458 bool HasOverriddenMethods =
1459 MD->begin_overridden_methods() != MD->end_overridden_methods();
1460 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
1461 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
1462 << MD->getDeclName();
Anders Carlsson9e682d92011-01-20 05:57:14 +00001463}
1464
Richard Smitha4b39652012-08-06 03:25:17 +00001465/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001466/// function overrides a virtual member function marked 'final', according to
Richard Smitha4b39652012-08-06 03:25:17 +00001467/// C++11 [class.virtual]p4.
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001468bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1469 const CXXMethodDecl *Old) {
Anders Carlssoncb88a1f2011-01-24 16:26:15 +00001470 if (!Old->hasAttr<FinalAttr>())
Anders Carlssonf89e0422011-01-23 21:07:30 +00001471 return false;
1472
1473 Diag(New->getLocation(), diag::err_final_function_overridden)
1474 << New->getDeclName();
1475 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
1476 return true;
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001477}
1478
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001479static bool InitializationHasSideEffects(const FieldDecl &FD) {
Richard Smith0b8220a2012-08-07 21:30:42 +00001480 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1481 // FIXME: Destruction of ObjC lifetime types has side-effects.
1482 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1483 return !RD->isCompleteDefinition() ||
1484 !RD->hasTrivialDefaultConstructor() ||
1485 !RD->hasTrivialDestructor();
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001486 return false;
1487}
1488
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001489/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
1490/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
Richard Smith7a614d82011-06-11 17:19:42 +00001491/// bitfield width if there is one, 'InitExpr' specifies the initializer if
Richard Smithca523302012-06-10 03:12:00 +00001492/// one has been parsed, and 'InitStyle' is set if an in-class initializer is
1493/// present (but parsing it has been deferred).
John McCalld226f652010-08-21 09:40:31 +00001494Decl *
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001495Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +00001496 MultiTemplateParamsArg TemplateParameterLists,
Richard Trieuf81e5a92011-09-09 02:00:50 +00001497 Expr *BW, const VirtSpecifiers &VS,
Richard Smithca523302012-06-10 03:12:00 +00001498 InClassInitStyle InitStyle) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001499 const DeclSpec &DS = D.getDeclSpec();
Abramo Bagnara25777432010-08-11 22:01:17 +00001500 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
1501 DeclarationName Name = NameInfo.getName();
1502 SourceLocation Loc = NameInfo.getLoc();
Douglas Gregor90ba6d52010-11-09 03:31:16 +00001503
1504 // For anonymous bitfields, the location should point to the type.
1505 if (Loc.isInvalid())
Daniel Dunbar96a00142012-03-09 18:35:03 +00001506 Loc = D.getLocStart();
Douglas Gregor90ba6d52010-11-09 03:31:16 +00001507
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001508 Expr *BitWidth = static_cast<Expr*>(BW);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001509
John McCall4bde1e12010-06-04 08:34:12 +00001510 assert(isa<CXXRecordDecl>(CurContext));
John McCall67d1a672009-08-06 02:15:43 +00001511 assert(!DS.isFriendSpecified());
1512
Richard Smith1ab0d902011-06-25 02:28:38 +00001513 bool isFunc = D.isDeclarationOfFunction();
John McCall4bde1e12010-06-04 08:34:12 +00001514
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001515 // C++ 9.2p6: A member shall not be declared to have automatic storage
1516 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +00001517 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
1518 // data members and cannot be applied to names declared const or static,
1519 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001520 switch (DS.getStorageClassSpec()) {
1521 case DeclSpec::SCS_unspecified:
1522 case DeclSpec::SCS_typedef:
1523 case DeclSpec::SCS_static:
1524 // FALL THROUGH.
1525 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001526 case DeclSpec::SCS_mutable:
1527 if (isFunc) {
1528 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001529 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +00001530 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001531 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
Mike Stump1eb44332009-09-09 15:08:12 +00001532
Sebastian Redla11f42f2008-11-17 23:24:37 +00001533 // FIXME: It would be nicer if the keyword was ignored only for this
1534 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +00001535 D.getMutableDeclSpec().ClearStorageClassSpecs();
Sebastian Redl669d5d72008-11-14 23:42:31 +00001536 }
1537 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001538 default:
1539 if (DS.getStorageClassSpecLoc().isValid())
1540 Diag(DS.getStorageClassSpecLoc(),
1541 diag::err_storageclass_invalid_for_member);
1542 else
1543 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
1544 D.getMutableDeclSpec().ClearStorageClassSpecs();
1545 }
1546
Sebastian Redl669d5d72008-11-14 23:42:31 +00001547 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
1548 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +00001549 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001550
1551 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +00001552 if (isInstField) {
Douglas Gregor922fff22010-10-13 22:19:53 +00001553 CXXScopeSpec &SS = D.getCXXScopeSpec();
Douglas Gregorb5a01872011-10-09 18:55:59 +00001554
1555 // Data members must have identifiers for names.
Benjamin Kramerc1aa40c2012-05-19 16:34:46 +00001556 if (!Name.isIdentifier()) {
Douglas Gregorb5a01872011-10-09 18:55:59 +00001557 Diag(Loc, diag::err_bad_variable_name)
1558 << Name;
1559 return 0;
1560 }
Douglas Gregorf2503652011-09-21 14:40:46 +00001561
Benjamin Kramerc1aa40c2012-05-19 16:34:46 +00001562 IdentifierInfo *II = Name.getAsIdentifierInfo();
1563
Douglas Gregorf2503652011-09-21 14:40:46 +00001564 // Member field could not be with "template" keyword.
1565 // So TemplateParameterLists should be empty in this case.
1566 if (TemplateParameterLists.size()) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001567 TemplateParameterList* TemplateParams = TemplateParameterLists[0];
Douglas Gregorf2503652011-09-21 14:40:46 +00001568 if (TemplateParams->size()) {
1569 // There is no such thing as a member field template.
1570 Diag(D.getIdentifierLoc(), diag::err_template_member)
1571 << II
1572 << SourceRange(TemplateParams->getTemplateLoc(),
1573 TemplateParams->getRAngleLoc());
1574 } else {
1575 // There is an extraneous 'template<>' for this member.
1576 Diag(TemplateParams->getTemplateLoc(),
1577 diag::err_template_member_noparams)
1578 << II
1579 << SourceRange(TemplateParams->getTemplateLoc(),
1580 TemplateParams->getRAngleLoc());
1581 }
1582 return 0;
1583 }
1584
Douglas Gregor922fff22010-10-13 22:19:53 +00001585 if (SS.isSet() && !SS.isInvalid()) {
1586 // The user provided a superfluous scope specifier inside a class
1587 // definition:
1588 //
1589 // class X {
1590 // int X::member;
1591 // };
Douglas Gregor69605872012-03-28 16:01:27 +00001592 if (DeclContext *DC = computeDeclContext(SS, false))
1593 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
Douglas Gregor922fff22010-10-13 22:19:53 +00001594 else
1595 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
1596 << Name << SS.getRange();
Douglas Gregor5d8419c2011-11-01 22:13:30 +00001597
Douglas Gregor922fff22010-10-13 22:19:53 +00001598 SS.clear();
1599 }
Douglas Gregorf2503652011-09-21 14:40:46 +00001600
Douglas Gregor4dd55f52009-03-11 20:50:30 +00001601 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
Richard Smithca523302012-06-10 03:12:00 +00001602 InitStyle, AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +00001603 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +00001604 } else {
Richard Smithca523302012-06-10 03:12:00 +00001605 assert(InitStyle == ICIS_NoInit);
Richard Smith7a614d82011-06-11 17:19:42 +00001606
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001607 Member = HandleDeclarator(S, D, TemplateParameterLists);
Chris Lattner6f8ce142009-03-05 23:03:49 +00001608 if (!Member) {
John McCalld226f652010-08-21 09:40:31 +00001609 return 0;
Chris Lattner6f8ce142009-03-05 23:03:49 +00001610 }
Chris Lattner8b963ef2009-03-05 23:01:03 +00001611
1612 // Non-instance-fields can't have a bitfield.
1613 if (BitWidth) {
1614 if (Member->isInvalidDecl()) {
1615 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +00001616 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +00001617 // C++ 9.6p3: A bit-field shall not be a static member.
1618 // "static member 'A' cannot be a bit-field"
1619 Diag(Loc, diag::err_static_not_bitfield)
1620 << Name << BitWidth->getSourceRange();
1621 } else if (isa<TypedefDecl>(Member)) {
1622 // "typedef member 'x' cannot be a bit-field"
1623 Diag(Loc, diag::err_typedef_not_bitfield)
1624 << Name << BitWidth->getSourceRange();
1625 } else {
1626 // A function typedef ("typedef int f(); f a;").
1627 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
1628 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump1eb44332009-09-09 15:08:12 +00001629 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor3cf538d2009-03-11 18:59:21 +00001630 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +00001631 }
Mike Stump1eb44332009-09-09 15:08:12 +00001632
Chris Lattner8b963ef2009-03-05 23:01:03 +00001633 BitWidth = 0;
1634 Member->setInvalidDecl();
1635 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +00001636
1637 Member->setAccess(AS);
Mike Stump1eb44332009-09-09 15:08:12 +00001638
Douglas Gregor37b372b2009-08-20 22:52:58 +00001639 // If we have declared a member function template, set the access of the
1640 // templated declaration as well.
1641 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
1642 FunTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +00001643 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001644
Richard Smitha4b39652012-08-06 03:25:17 +00001645 if (VS.isOverrideSpecified())
1646 Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context));
1647 if (VS.isFinalSpecified())
1648 Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context));
Anders Carlsson9e682d92011-01-20 05:57:14 +00001649
Douglas Gregorf5251602011-03-08 17:10:18 +00001650 if (VS.getLastLocation().isValid()) {
1651 // Update the end location of a method that has a virt-specifiers.
1652 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
1653 MD->setRangeEnd(VS.getLastLocation());
1654 }
Richard Smitha4b39652012-08-06 03:25:17 +00001655
Anders Carlsson4ebf1602011-01-20 06:29:02 +00001656 CheckOverrideControl(Member);
Anders Carlsson9e682d92011-01-20 05:57:14 +00001657
Douglas Gregor10bd3682008-11-17 22:58:34 +00001658 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001659
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001660 if (isInstField) {
1661 FieldDecl *FD = cast<FieldDecl>(Member);
1662 FieldCollector->Add(FD);
1663
1664 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
1665 FD->getLocation())
1666 != DiagnosticsEngine::Ignored) {
1667 // Remember all explicit private FieldDecls that have a name, no side
1668 // effects and are not part of a dependent type declaration.
1669 if (!FD->isImplicit() && FD->getDeclName() &&
1670 FD->getAccess() == AS_private &&
Daniel Jasper568eae42012-06-13 18:31:09 +00001671 !FD->hasAttr<UnusedAttr>() &&
Richard Smith0b8220a2012-08-07 21:30:42 +00001672 !FD->getParent()->isDependentContext() &&
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001673 !InitializationHasSideEffects(*FD))
1674 UnusedPrivateFields.insert(FD);
1675 }
1676 }
1677
John McCalld226f652010-08-21 09:40:31 +00001678 return Member;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001679}
1680
Hans Wennborg471f9852012-09-18 15:58:06 +00001681namespace {
1682 class UninitializedFieldVisitor
1683 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
1684 Sema &S;
1685 ValueDecl *VD;
1686 public:
1687 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
1688 UninitializedFieldVisitor(Sema &S, ValueDecl *VD) : Inherited(S.Context),
1689 S(S), VD(VD) {
1690 }
1691
1692 void HandleExpr(Expr *E) {
1693 if (!E) return;
1694
1695 // Expressions like x(x) sometimes lack the surrounding expressions
1696 // but need to be checked anyways.
1697 HandleValue(E);
1698 Visit(E);
1699 }
1700
1701 void HandleValue(Expr *E) {
1702 E = E->IgnoreParens();
1703
1704 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1705 if (isa<EnumConstantDecl>(ME->getMemberDecl()))
1706 return;
1707 Expr *Base = E;
1708 while (isa<MemberExpr>(Base)) {
1709 ME = dyn_cast<MemberExpr>(Base);
1710 if (VarDecl *VarD = dyn_cast<VarDecl>(ME->getMemberDecl()))
1711 if (VarD->hasGlobalStorage())
1712 return;
1713 Base = ME->getBase();
1714 }
1715
1716 if (VD == ME->getMemberDecl() && isa<CXXThisExpr>(Base)) {
1717 unsigned diag = VD->getType()->isReferenceType()
1718 ? diag::warn_reference_field_is_uninit
1719 : diag::warn_field_is_uninit;
Hans Wennborg7821e072012-09-21 08:58:33 +00001720 S.Diag(ME->getExprLoc(), diag) << ME->getMemberNameInfo().getName();
Hans Wennborg471f9852012-09-18 15:58:06 +00001721 return;
1722 }
1723 }
1724
1725 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1726 HandleValue(CO->getTrueExpr());
1727 HandleValue(CO->getFalseExpr());
1728 return;
1729 }
1730
1731 if (BinaryConditionalOperator *BCO =
1732 dyn_cast<BinaryConditionalOperator>(E)) {
1733 HandleValue(BCO->getCommon());
1734 HandleValue(BCO->getFalseExpr());
1735 return;
1736 }
1737
1738 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
1739 switch (BO->getOpcode()) {
1740 default:
1741 return;
1742 case(BO_PtrMemD):
1743 case(BO_PtrMemI):
1744 HandleValue(BO->getLHS());
1745 return;
1746 case(BO_Comma):
1747 HandleValue(BO->getRHS());
1748 return;
1749 }
1750 }
1751 }
1752
1753 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
1754 if (E->getCastKind() == CK_LValueToRValue)
1755 HandleValue(E->getSubExpr());
1756
1757 Inherited::VisitImplicitCastExpr(E);
1758 }
1759
1760 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1761 Expr *Callee = E->getCallee();
1762 if (isa<MemberExpr>(Callee))
1763 HandleValue(Callee);
1764
1765 Inherited::VisitCXXMemberCallExpr(E);
1766 }
1767 };
1768 static void CheckInitExprContainsUninitializedFields(Sema &S, Expr *E,
1769 ValueDecl *VD) {
1770 UninitializedFieldVisitor(S, VD).HandleExpr(E);
1771 }
1772} // namespace
1773
Richard Smith7a614d82011-06-11 17:19:42 +00001774/// ActOnCXXInClassMemberInitializer - This is invoked after parsing an
Richard Smith0ff6f8f2011-07-20 00:12:52 +00001775/// in-class initializer for a non-static C++ class member, and after
1776/// instantiating an in-class initializer in a class template. Such actions
1777/// are deferred until the class is complete.
Richard Smith7a614d82011-06-11 17:19:42 +00001778void
Richard Smithca523302012-06-10 03:12:00 +00001779Sema::ActOnCXXInClassMemberInitializer(Decl *D, SourceLocation InitLoc,
Richard Smith7a614d82011-06-11 17:19:42 +00001780 Expr *InitExpr) {
1781 FieldDecl *FD = cast<FieldDecl>(D);
Richard Smithca523302012-06-10 03:12:00 +00001782 assert(FD->getInClassInitStyle() != ICIS_NoInit &&
1783 "must set init style when field is created");
Richard Smith7a614d82011-06-11 17:19:42 +00001784
1785 if (!InitExpr) {
1786 FD->setInvalidDecl();
1787 FD->removeInClassInitializer();
1788 return;
1789 }
1790
Peter Collingbournefef21892011-10-23 18:59:44 +00001791 if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
1792 FD->setInvalidDecl();
1793 FD->removeInClassInitializer();
1794 return;
1795 }
1796
Hans Wennborg471f9852012-09-18 15:58:06 +00001797 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, InitLoc)
1798 != DiagnosticsEngine::Ignored) {
1799 CheckInitExprContainsUninitializedFields(*this, InitExpr, FD);
1800 }
1801
Richard Smith7a614d82011-06-11 17:19:42 +00001802 ExprResult Init = InitExpr;
Douglas Gregordd084272012-09-14 04:20:37 +00001803 if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent() &&
1804 !FD->getDeclContext()->isDependentContext()) {
1805 // Note: We don't type-check when we're in a dependent context, because
1806 // the initialization-substitution code does not properly handle direct
1807 // list initialization. We have the same hackaround for ctor-initializers.
Sebastian Redl772291a2012-02-19 16:31:05 +00001808 if (isa<InitListExpr>(InitExpr) && isStdInitializerList(FD->getType(), 0)) {
Sebastian Redl33deb352012-02-22 10:50:08 +00001809 Diag(FD->getLocation(), diag::warn_dangling_std_initializer_list)
Sebastian Redl772291a2012-02-19 16:31:05 +00001810 << /*at end of ctor*/1 << InitExpr->getSourceRange();
1811 }
Sebastian Redl33deb352012-02-22 10:50:08 +00001812 Expr **Inits = &InitExpr;
1813 unsigned NumInits = 1;
1814 InitializedEntity Entity = InitializedEntity::InitializeMember(FD);
Richard Smithca523302012-06-10 03:12:00 +00001815 InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit
Sebastian Redl33deb352012-02-22 10:50:08 +00001816 ? InitializationKind::CreateDirectList(InitExpr->getLocStart())
Richard Smithca523302012-06-10 03:12:00 +00001817 : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
Sebastian Redl33deb352012-02-22 10:50:08 +00001818 InitializationSequence Seq(*this, Entity, Kind, Inits, NumInits);
1819 Init = Seq.Perform(*this, Entity, Kind, MultiExprArg(Inits, NumInits));
Richard Smith7a614d82011-06-11 17:19:42 +00001820 if (Init.isInvalid()) {
1821 FD->setInvalidDecl();
1822 return;
1823 }
1824
Richard Smithca523302012-06-10 03:12:00 +00001825 CheckImplicitConversions(Init.get(), InitLoc);
Richard Smith7a614d82011-06-11 17:19:42 +00001826 }
1827
1828 // C++0x [class.base.init]p7:
1829 // The initialization of each base and member constitutes a
1830 // full-expression.
1831 Init = MaybeCreateExprWithCleanups(Init);
1832 if (Init.isInvalid()) {
1833 FD->setInvalidDecl();
1834 return;
1835 }
1836
1837 InitExpr = Init.release();
1838
1839 FD->setInClassInitializer(InitExpr);
1840}
1841
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001842/// \brief Find the direct and/or virtual base specifiers that
1843/// correspond to the given base type, for use in base initialization
1844/// within a constructor.
1845static bool FindBaseInitializer(Sema &SemaRef,
1846 CXXRecordDecl *ClassDecl,
1847 QualType BaseType,
1848 const CXXBaseSpecifier *&DirectBaseSpec,
1849 const CXXBaseSpecifier *&VirtualBaseSpec) {
1850 // First, check for a direct base class.
1851 DirectBaseSpec = 0;
1852 for (CXXRecordDecl::base_class_const_iterator Base
1853 = ClassDecl->bases_begin();
1854 Base != ClassDecl->bases_end(); ++Base) {
1855 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
1856 // We found a direct base of this type. That's what we're
1857 // initializing.
1858 DirectBaseSpec = &*Base;
1859 break;
1860 }
1861 }
1862
1863 // Check for a virtual base class.
1864 // FIXME: We might be able to short-circuit this if we know in advance that
1865 // there are no virtual bases.
1866 VirtualBaseSpec = 0;
1867 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
1868 // We haven't found a base yet; search the class hierarchy for a
1869 // virtual base class.
1870 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1871 /*DetectVirtual=*/false);
1872 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl),
1873 BaseType, Paths)) {
1874 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1875 Path != Paths.end(); ++Path) {
1876 if (Path->back().Base->isVirtual()) {
1877 VirtualBaseSpec = Path->back().Base;
1878 break;
1879 }
1880 }
1881 }
1882 }
1883
1884 return DirectBaseSpec || VirtualBaseSpec;
1885}
1886
Sebastian Redl6df65482011-09-24 17:48:25 +00001887/// \brief Handle a C++ member initializer using braced-init-list syntax.
1888MemInitResult
1889Sema::ActOnMemInitializer(Decl *ConstructorD,
1890 Scope *S,
1891 CXXScopeSpec &SS,
1892 IdentifierInfo *MemberOrBase,
1893 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00001894 const DeclSpec &DS,
Sebastian Redl6df65482011-09-24 17:48:25 +00001895 SourceLocation IdLoc,
1896 Expr *InitList,
1897 SourceLocation EllipsisLoc) {
1898 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001899 DS, IdLoc, InitList,
David Blaikief2116622012-01-24 06:03:59 +00001900 EllipsisLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001901}
1902
1903/// \brief Handle a C++ member initializer using parentheses syntax.
John McCallf312b1e2010-08-26 23:41:50 +00001904MemInitResult
John McCalld226f652010-08-21 09:40:31 +00001905Sema::ActOnMemInitializer(Decl *ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001906 Scope *S,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00001907 CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001908 IdentifierInfo *MemberOrBase,
John McCallb3d87482010-08-24 05:47:05 +00001909 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00001910 const DeclSpec &DS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001911 SourceLocation IdLoc,
1912 SourceLocation LParenLoc,
Richard Trieuf81e5a92011-09-09 02:00:50 +00001913 Expr **Args, unsigned NumArgs,
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00001914 SourceLocation RParenLoc,
1915 SourceLocation EllipsisLoc) {
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001916 Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
1917 llvm::makeArrayRef(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001918 RParenLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001919 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001920 DS, IdLoc, List, EllipsisLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001921}
1922
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00001923namespace {
1924
Kaelyn Uhraindc98cd02012-01-11 21:17:51 +00001925// Callback to only accept typo corrections that can be a valid C++ member
1926// intializer: either a non-static field member or a base class.
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00001927class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
1928 public:
1929 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
1930 : ClassDecl(ClassDecl) {}
1931
1932 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1933 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
1934 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
1935 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
1936 else
1937 return isa<TypeDecl>(ND);
1938 }
1939 return false;
1940 }
1941
1942 private:
1943 CXXRecordDecl *ClassDecl;
1944};
1945
1946}
1947
Sebastian Redl6df65482011-09-24 17:48:25 +00001948/// \brief Handle a C++ member initializer.
1949MemInitResult
1950Sema::BuildMemInitializer(Decl *ConstructorD,
1951 Scope *S,
1952 CXXScopeSpec &SS,
1953 IdentifierInfo *MemberOrBase,
1954 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00001955 const DeclSpec &DS,
Sebastian Redl6df65482011-09-24 17:48:25 +00001956 SourceLocation IdLoc,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001957 Expr *Init,
Sebastian Redl6df65482011-09-24 17:48:25 +00001958 SourceLocation EllipsisLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00001959 if (!ConstructorD)
1960 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001961
Douglas Gregorefd5bda2009-08-24 11:57:43 +00001962 AdjustDeclIfTemplate(ConstructorD);
Mike Stump1eb44332009-09-09 15:08:12 +00001963
1964 CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00001965 = dyn_cast<CXXConstructorDecl>(ConstructorD);
Douglas Gregor7ad83902008-11-05 04:29:56 +00001966 if (!Constructor) {
1967 // The user wrote a constructor initializer on a function that is
1968 // not a C++ constructor. Ignore the error for now, because we may
1969 // have more member initializers coming; we'll diagnose it just
1970 // once in ActOnMemInitializers.
1971 return true;
1972 }
1973
1974 CXXRecordDecl *ClassDecl = Constructor->getParent();
1975
1976 // C++ [class.base.init]p2:
1977 // Names in a mem-initializer-id are looked up in the scope of the
Nick Lewycky7663f392010-11-20 01:29:55 +00001978 // constructor's class and, if not found in that scope, are looked
1979 // up in the scope containing the constructor's definition.
1980 // [Note: if the constructor's class contains a member with the
1981 // same name as a direct or virtual base class of the class, a
1982 // mem-initializer-id naming the member or base class and composed
1983 // of a single identifier refers to the class member. A
Douglas Gregor7ad83902008-11-05 04:29:56 +00001984 // mem-initializer-id for the hidden base class may be specified
1985 // using a qualified name. ]
Fariborz Jahanian96174332009-07-01 19:21:19 +00001986 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001987 // Look for a member, first.
Mike Stump1eb44332009-09-09 15:08:12 +00001988 DeclContext::lookup_result Result
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00001989 = ClassDecl->lookup(MemberOrBase);
Francois Pichet87c2e122010-11-21 06:08:52 +00001990 if (Result.first != Result.second) {
Peter Collingbournedc69be22011-10-23 18:59:37 +00001991 ValueDecl *Member;
1992 if ((Member = dyn_cast<FieldDecl>(*Result.first)) ||
1993 (Member = dyn_cast<IndirectFieldDecl>(*Result.first))) {
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00001994 if (EllipsisLoc.isValid())
1995 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001996 << MemberOrBase
1997 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
Sebastian Redl6df65482011-09-24 17:48:25 +00001998
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001999 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002000 }
Francois Pichet00eb3f92010-12-04 09:14:42 +00002001 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00002002 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00002003 // It didn't name a member, so see if it names a class.
Douglas Gregor802ab452009-12-02 22:36:29 +00002004 QualType BaseType;
John McCalla93c9342009-12-07 02:54:59 +00002005 TypeSourceInfo *TInfo = 0;
John McCall2b194412009-12-21 10:41:20 +00002006
2007 if (TemplateTypeTy) {
John McCalla93c9342009-12-07 02:54:59 +00002008 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
David Blaikief2116622012-01-24 06:03:59 +00002009 } else if (DS.getTypeSpecType() == TST_decltype) {
2010 BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
John McCall2b194412009-12-21 10:41:20 +00002011 } else {
2012 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
2013 LookupParsedName(R, S, &SS);
2014
2015 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
2016 if (!TyD) {
2017 if (R.isAmbiguous()) return true;
2018
John McCallfd225442010-04-09 19:01:14 +00002019 // We don't want access-control diagnostics here.
2020 R.suppressDiagnostics();
2021
Douglas Gregor7a886e12010-01-19 06:46:48 +00002022 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
2023 bool NotUnknownSpecialization = false;
2024 DeclContext *DC = computeDeclContext(SS, false);
2025 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
2026 NotUnknownSpecialization = !Record->hasAnyDependentBases();
2027
2028 if (!NotUnknownSpecialization) {
2029 // When the scope specifier can refer to a member of an unknown
2030 // specialization, we take it as a type name.
Douglas Gregore29425b2011-02-28 22:42:13 +00002031 BaseType = CheckTypenameType(ETK_None, SourceLocation(),
2032 SS.getWithLocInContext(Context),
2033 *MemberOrBase, IdLoc);
Douglas Gregora50ce322010-03-07 23:26:22 +00002034 if (BaseType.isNull())
2035 return true;
2036
Douglas Gregor7a886e12010-01-19 06:46:48 +00002037 R.clear();
Douglas Gregor12eb5d62010-06-29 19:27:42 +00002038 R.setLookupName(MemberOrBase);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002039 }
2040 }
2041
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002042 // If no results were found, try to correct typos.
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002043 TypoCorrection Corr;
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00002044 MemInitializerValidatorCCC Validator(ClassDecl);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002045 if (R.empty() && BaseType.isNull() &&
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002046 (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00002047 Validator, ClassDecl))) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002048 std::string CorrectedStr(Corr.getAsString(getLangOpts()));
2049 std::string CorrectedQuotedStr(Corr.getQuoted(getLangOpts()));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002050 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00002051 // We have found a non-static data member with a similar
2052 // name to what was typed; complain and initialize that
2053 // member.
2054 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
2055 << MemberOrBase << true << CorrectedQuotedStr
2056 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr);
2057 Diag(Member->getLocation(), diag::note_previous_decl)
2058 << CorrectedQuotedStr;
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002059
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002060 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002061 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002062 const CXXBaseSpecifier *DirectBaseSpec;
2063 const CXXBaseSpecifier *VirtualBaseSpec;
2064 if (FindBaseInitializer(*this, ClassDecl,
2065 Context.getTypeDeclType(Type),
2066 DirectBaseSpec, VirtualBaseSpec)) {
2067 // We have found a direct or virtual base class with a
2068 // similar name to what was typed; complain and initialize
2069 // that base class.
2070 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002071 << MemberOrBase << false << CorrectedQuotedStr
2072 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr);
Douglas Gregor0d535c82010-01-07 00:26:25 +00002073
2074 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec? DirectBaseSpec
2075 : VirtualBaseSpec;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002076 Diag(BaseSpec->getLocStart(),
Douglas Gregor0d535c82010-01-07 00:26:25 +00002077 diag::note_base_class_specified_here)
2078 << BaseSpec->getType()
2079 << BaseSpec->getSourceRange();
2080
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002081 TyD = Type;
2082 }
2083 }
2084 }
2085
Douglas Gregor7a886e12010-01-19 06:46:48 +00002086 if (!TyD && BaseType.isNull()) {
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002087 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002088 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002089 return true;
2090 }
John McCall2b194412009-12-21 10:41:20 +00002091 }
2092
Douglas Gregor7a886e12010-01-19 06:46:48 +00002093 if (BaseType.isNull()) {
2094 BaseType = Context.getTypeDeclType(TyD);
2095 if (SS.isSet()) {
2096 NestedNameSpecifier *Qualifier =
2097 static_cast<NestedNameSpecifier*>(SS.getScopeRep());
John McCall2b194412009-12-21 10:41:20 +00002098
Douglas Gregor7a886e12010-01-19 06:46:48 +00002099 // FIXME: preserve source range information
Abramo Bagnara465d41b2010-05-11 21:36:43 +00002100 BaseType = Context.getElaboratedType(ETK_None, Qualifier, BaseType);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002101 }
John McCall2b194412009-12-21 10:41:20 +00002102 }
2103 }
Mike Stump1eb44332009-09-09 15:08:12 +00002104
John McCalla93c9342009-12-07 02:54:59 +00002105 if (!TInfo)
2106 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002107
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002108 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
Eli Friedman59c04372009-07-29 19:44:27 +00002109}
2110
Chandler Carruth81c64772011-09-03 01:14:15 +00002111/// Checks a member initializer expression for cases where reference (or
2112/// pointer) members are bound to by-value parameters (or their addresses).
Chandler Carruth81c64772011-09-03 01:14:15 +00002113static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member,
2114 Expr *Init,
2115 SourceLocation IdLoc) {
2116 QualType MemberTy = Member->getType();
2117
2118 // We only handle pointers and references currently.
2119 // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
2120 if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
2121 return;
2122
2123 const bool IsPointer = MemberTy->isPointerType();
2124 if (IsPointer) {
2125 if (const UnaryOperator *Op
2126 = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
2127 // The only case we're worried about with pointers requires taking the
2128 // address.
2129 if (Op->getOpcode() != UO_AddrOf)
2130 return;
2131
2132 Init = Op->getSubExpr();
2133 } else {
2134 // We only handle address-of expression initializers for pointers.
2135 return;
2136 }
2137 }
2138
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002139 if (isa<MaterializeTemporaryExpr>(Init->IgnoreParens())) {
2140 // Taking the address of a temporary will be diagnosed as a hard error.
2141 if (IsPointer)
2142 return;
Chandler Carruth81c64772011-09-03 01:14:15 +00002143
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002144 S.Diag(Init->getExprLoc(), diag::warn_bind_ref_member_to_temporary)
2145 << Member << Init->getSourceRange();
2146 } else if (const DeclRefExpr *DRE
2147 = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
2148 // We only warn when referring to a non-reference parameter declaration.
2149 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
2150 if (!Parameter || Parameter->getType()->isReferenceType())
Chandler Carruth81c64772011-09-03 01:14:15 +00002151 return;
2152
2153 S.Diag(Init->getExprLoc(),
2154 IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
2155 : diag::warn_bind_ref_member_to_parameter)
2156 << Member << Parameter << Init->getSourceRange();
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002157 } else {
2158 // Other initializers are fine.
2159 return;
Chandler Carruth81c64772011-09-03 01:14:15 +00002160 }
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002161
2162 S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
2163 << (unsigned)IsPointer;
Chandler Carruth81c64772011-09-03 01:14:15 +00002164}
2165
John McCallf312b1e2010-08-26 23:41:50 +00002166MemInitResult
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002167Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
Sebastian Redl6df65482011-09-24 17:48:25 +00002168 SourceLocation IdLoc) {
Chandler Carruth894aed92010-12-06 09:23:57 +00002169 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
2170 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
2171 assert((DirectMember || IndirectMember) &&
Francois Pichet00eb3f92010-12-04 09:14:42 +00002172 "Member must be a FieldDecl or IndirectFieldDecl");
2173
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002174 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Peter Collingbournefef21892011-10-23 18:59:44 +00002175 return true;
2176
Douglas Gregor464b2f02010-11-05 22:21:31 +00002177 if (Member->isInvalidDecl())
2178 return true;
Chandler Carruth894aed92010-12-06 09:23:57 +00002179
John McCallb4190042009-11-04 23:02:40 +00002180 // Diagnose value-uses of fields to initialize themselves, e.g.
2181 // foo(foo)
2182 // where foo is not also a parameter to the constructor.
John McCall6aee6212009-11-04 23:13:52 +00002183 // TODO: implement -Wuninitialized and fold this into that framework.
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002184 Expr **Args;
2185 unsigned NumArgs;
2186 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
2187 Args = ParenList->getExprs();
2188 NumArgs = ParenList->getNumExprs();
2189 } else {
2190 InitListExpr *InitList = cast<InitListExpr>(Init);
2191 Args = InitList->getInits();
2192 NumArgs = InitList->getNumInits();
2193 }
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00002194
Richard Trieude5e75c2012-06-14 23:11:34 +00002195 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, IdLoc)
2196 != DiagnosticsEngine::Ignored)
2197 for (unsigned i = 0; i < NumArgs; ++i)
2198 // FIXME: Warn about the case when other fields are used before being
Hans Wennborg471f9852012-09-18 15:58:06 +00002199 // initialized. For example, let this field be the i'th field. When
John McCallb4190042009-11-04 23:02:40 +00002200 // initializing the i'th field, throw a warning if any of the >= i'th
2201 // fields are used, as they are not yet initialized.
2202 // Right now we are only handling the case where the i'th field uses
2203 // itself in its initializer.
Hans Wennborg471f9852012-09-18 15:58:06 +00002204 // Also need to take into account that some fields may be initialized by
2205 // in-class initializers, see C++11 [class.base.init]p9.
Richard Trieude5e75c2012-06-14 23:11:34 +00002206 CheckInitExprContainsUninitializedFields(*this, Args[i], Member);
John McCallb4190042009-11-04 23:02:40 +00002207
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002208 SourceRange InitRange = Init->getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00002209
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002210 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002211 // Can't check initialization for a member of dependent type or when
2212 // any of the arguments are type-dependent expressions.
John McCallf85e1932011-06-15 23:02:42 +00002213 DiscardCleanupsInEvaluationContext();
Chandler Carruth894aed92010-12-06 09:23:57 +00002214 } else {
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002215 bool InitList = false;
2216 if (isa<InitListExpr>(Init)) {
2217 InitList = true;
2218 Args = &Init;
2219 NumArgs = 1;
Sebastian Redl772291a2012-02-19 16:31:05 +00002220
2221 if (isStdInitializerList(Member->getType(), 0)) {
2222 Diag(IdLoc, diag::warn_dangling_std_initializer_list)
2223 << /*at end of ctor*/1 << InitRange;
2224 }
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002225 }
2226
Chandler Carruth894aed92010-12-06 09:23:57 +00002227 // Initialize the member.
2228 InitializedEntity MemberEntity =
2229 DirectMember ? InitializedEntity::InitializeMember(DirectMember, 0)
2230 : InitializedEntity::InitializeMember(IndirectMember, 0);
2231 InitializationKind Kind =
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002232 InitList ? InitializationKind::CreateDirectList(IdLoc)
2233 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
2234 InitRange.getEnd());
John McCallb4eb64d2010-10-08 02:01:28 +00002235
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002236 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args, NumArgs);
2237 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002238 MultiExprArg(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002239 0);
Chandler Carruth894aed92010-12-06 09:23:57 +00002240 if (MemberInit.isInvalid())
2241 return true;
2242
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002243 CheckImplicitConversions(MemberInit.get(),
2244 InitRange.getBegin());
Chandler Carruth894aed92010-12-06 09:23:57 +00002245
2246 // C++0x [class.base.init]p7:
2247 // The initialization of each base and member constitutes a
2248 // full-expression.
Douglas Gregor53c374f2010-12-07 00:41:46 +00002249 MemberInit = MaybeCreateExprWithCleanups(MemberInit);
Chandler Carruth894aed92010-12-06 09:23:57 +00002250 if (MemberInit.isInvalid())
2251 return true;
2252
2253 // If we are in a dependent context, template instantiation will
2254 // perform this type-checking again. Just save the arguments that we
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002255 // received.
Chandler Carruth894aed92010-12-06 09:23:57 +00002256 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2257 // of the information that we have about the member
2258 // initializer. However, deconstructing the ASTs is a dicey process,
2259 // and this approach is far more likely to get the corner cases right.
Chandler Carruth81c64772011-09-03 01:14:15 +00002260 if (CurContext->isDependentContext()) {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002261 // The existing Init will do fine.
Chandler Carruth81c64772011-09-03 01:14:15 +00002262 } else {
Chandler Carruth894aed92010-12-06 09:23:57 +00002263 Init = MemberInit.get();
Chandler Carruth81c64772011-09-03 01:14:15 +00002264 CheckForDanglingReferenceOrPointer(*this, Member, Init, IdLoc);
2265 }
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002266 }
2267
Chandler Carruth894aed92010-12-06 09:23:57 +00002268 if (DirectMember) {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002269 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
2270 InitRange.getBegin(), Init,
2271 InitRange.getEnd());
Chandler Carruth894aed92010-12-06 09:23:57 +00002272 } else {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002273 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
2274 InitRange.getBegin(), Init,
2275 InitRange.getEnd());
Chandler Carruth894aed92010-12-06 09:23:57 +00002276 }
Eli Friedman59c04372009-07-29 19:44:27 +00002277}
2278
John McCallf312b1e2010-08-26 23:41:50 +00002279MemInitResult
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002280Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
Sean Hunt41717662011-02-26 19:13:13 +00002281 CXXRecordDecl *ClassDecl) {
Douglas Gregor76852c22011-11-01 01:16:03 +00002282 SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
Sean Hunt97fcc492011-01-08 19:20:43 +00002283 if (!LangOpts.CPlusPlus0x)
Douglas Gregor76852c22011-11-01 01:16:03 +00002284 return Diag(NameLoc, diag::err_delegating_ctor)
Sean Hunt97fcc492011-01-08 19:20:43 +00002285 << TInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor76852c22011-11-01 01:16:03 +00002286 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
Sebastian Redlf9c32eb2011-03-12 13:53:51 +00002287
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002288 bool InitList = true;
2289 Expr **Args = &Init;
2290 unsigned NumArgs = 1;
2291 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
2292 InitList = false;
2293 Args = ParenList->getExprs();
2294 NumArgs = ParenList->getNumExprs();
2295 }
2296
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002297 SourceRange InitRange = Init->getSourceRange();
Sean Hunt41717662011-02-26 19:13:13 +00002298 // Initialize the object.
2299 InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation(
2300 QualType(ClassDecl->getTypeForDecl(), 0));
2301 InitializationKind Kind =
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002302 InitList ? InitializationKind::CreateDirectList(NameLoc)
2303 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
2304 InitRange.getEnd());
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002305 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args, NumArgs);
2306 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002307 MultiExprArg(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002308 0);
Sean Hunt41717662011-02-26 19:13:13 +00002309 if (DelegationInit.isInvalid())
2310 return true;
2311
Matt Beaumont-Gay2eb0ce32011-11-01 18:10:22 +00002312 assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
2313 "Delegating constructor with no target?");
Sean Hunt41717662011-02-26 19:13:13 +00002314
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002315 CheckImplicitConversions(DelegationInit.get(), InitRange.getBegin());
Sean Hunt41717662011-02-26 19:13:13 +00002316
2317 // C++0x [class.base.init]p7:
2318 // The initialization of each base and member constitutes a
2319 // full-expression.
2320 DelegationInit = MaybeCreateExprWithCleanups(DelegationInit);
2321 if (DelegationInit.isInvalid())
2322 return true;
2323
Eli Friedmand21016f2012-05-19 23:35:23 +00002324 // If we are in a dependent context, template instantiation will
2325 // perform this type-checking again. Just save the arguments that we
2326 // received in a ParenListExpr.
2327 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2328 // of the information that we have about the base
2329 // initializer. However, deconstructing the ASTs is a dicey process,
2330 // and this approach is far more likely to get the corner cases right.
2331 if (CurContext->isDependentContext())
2332 DelegationInit = Owned(Init);
2333
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002334 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
Sean Hunt41717662011-02-26 19:13:13 +00002335 DelegationInit.takeAs<Expr>(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002336 InitRange.getEnd());
Sean Hunt97fcc492011-01-08 19:20:43 +00002337}
2338
2339MemInitResult
John McCalla93c9342009-12-07 02:54:59 +00002340Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002341 Expr *Init, CXXRecordDecl *ClassDecl,
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002342 SourceLocation EllipsisLoc) {
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002343 SourceLocation BaseLoc
2344 = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
Sebastian Redl6df65482011-09-24 17:48:25 +00002345
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002346 if (!BaseType->isDependentType() && !BaseType->isRecordType())
2347 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
2348 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
2349
2350 // C++ [class.base.init]p2:
2351 // [...] Unless the mem-initializer-id names a nonstatic data
Nick Lewycky7663f392010-11-20 01:29:55 +00002352 // member of the constructor's class or a direct or virtual base
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002353 // of that class, the mem-initializer is ill-formed. A
2354 // mem-initializer-list can initialize a base class using any
2355 // name that denotes that base class type.
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002356 bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002357
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002358 SourceRange InitRange = Init->getSourceRange();
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002359 if (EllipsisLoc.isValid()) {
2360 // This is a pack expansion.
2361 if (!BaseType->containsUnexpandedParameterPack()) {
2362 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002363 << SourceRange(BaseLoc, InitRange.getEnd());
Sebastian Redl6df65482011-09-24 17:48:25 +00002364
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002365 EllipsisLoc = SourceLocation();
2366 }
2367 } else {
2368 // Check for any unexpanded parameter packs.
2369 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
2370 return true;
Sebastian Redl6df65482011-09-24 17:48:25 +00002371
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002372 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Sebastian Redl6df65482011-09-24 17:48:25 +00002373 return true;
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002374 }
Sebastian Redl6df65482011-09-24 17:48:25 +00002375
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002376 // Check for direct and virtual base classes.
2377 const CXXBaseSpecifier *DirectBaseSpec = 0;
2378 const CXXBaseSpecifier *VirtualBaseSpec = 0;
2379 if (!Dependent) {
Sean Hunt97fcc492011-01-08 19:20:43 +00002380 if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
2381 BaseType))
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002382 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
Sean Hunt97fcc492011-01-08 19:20:43 +00002383
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002384 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
2385 VirtualBaseSpec);
2386
2387 // C++ [base.class.init]p2:
2388 // Unless the mem-initializer-id names a nonstatic data member of the
2389 // constructor's class or a direct or virtual base of that class, the
2390 // mem-initializer is ill-formed.
2391 if (!DirectBaseSpec && !VirtualBaseSpec) {
2392 // If the class has any dependent bases, then it's possible that
2393 // one of those types will resolve to the same type as
2394 // BaseType. Therefore, just treat this as a dependent base
2395 // class initialization. FIXME: Should we try to check the
2396 // initialization anyway? It seems odd.
2397 if (ClassDecl->hasAnyDependentBases())
2398 Dependent = true;
2399 else
2400 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
2401 << BaseType << Context.getTypeDeclType(ClassDecl)
2402 << BaseTInfo->getTypeLoc().getLocalSourceRange();
2403 }
2404 }
2405
2406 if (Dependent) {
John McCallf85e1932011-06-15 23:02:42 +00002407 DiscardCleanupsInEvaluationContext();
Mike Stump1eb44332009-09-09 15:08:12 +00002408
Sebastian Redl6df65482011-09-24 17:48:25 +00002409 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
2410 /*IsVirtual=*/false,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002411 InitRange.getBegin(), Init,
2412 InitRange.getEnd(), EllipsisLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002413 }
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002414
2415 // C++ [base.class.init]p2:
2416 // If a mem-initializer-id is ambiguous because it designates both
2417 // a direct non-virtual base class and an inherited virtual base
2418 // class, the mem-initializer is ill-formed.
2419 if (DirectBaseSpec && VirtualBaseSpec)
2420 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
Abramo Bagnarabd054db2010-05-20 10:00:11 +00002421 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002422
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002423 CXXBaseSpecifier *BaseSpec = const_cast<CXXBaseSpecifier *>(DirectBaseSpec);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002424 if (!BaseSpec)
2425 BaseSpec = const_cast<CXXBaseSpecifier *>(VirtualBaseSpec);
2426
2427 // Initialize the base.
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002428 bool InitList = true;
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002429 Expr **Args = &Init;
2430 unsigned NumArgs = 1;
2431 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002432 InitList = false;
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002433 Args = ParenList->getExprs();
2434 NumArgs = ParenList->getNumExprs();
2435 }
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002436
2437 InitializedEntity BaseEntity =
2438 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
2439 InitializationKind Kind =
2440 InitList ? InitializationKind::CreateDirectList(BaseLoc)
2441 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
2442 InitRange.getEnd());
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002443 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args, NumArgs);
2444 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002445 MultiExprArg(Args, NumArgs), 0);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002446 if (BaseInit.isInvalid())
2447 return true;
John McCallb4eb64d2010-10-08 02:01:28 +00002448
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002449 CheckImplicitConversions(BaseInit.get(), InitRange.getBegin());
Sebastian Redl6df65482011-09-24 17:48:25 +00002450
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002451 // C++0x [class.base.init]p7:
2452 // The initialization of each base and member constitutes a
2453 // full-expression.
Douglas Gregor53c374f2010-12-07 00:41:46 +00002454 BaseInit = MaybeCreateExprWithCleanups(BaseInit);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002455 if (BaseInit.isInvalid())
2456 return true;
2457
2458 // If we are in a dependent context, template instantiation will
2459 // perform this type-checking again. Just save the arguments that we
2460 // received in a ParenListExpr.
2461 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2462 // of the information that we have about the base
2463 // initializer. However, deconstructing the ASTs is a dicey process,
2464 // and this approach is far more likely to get the corner cases right.
Sebastian Redl6df65482011-09-24 17:48:25 +00002465 if (CurContext->isDependentContext())
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002466 BaseInit = Owned(Init);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002467
Sean Huntcbb67482011-01-08 20:30:50 +00002468 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
Sebastian Redl6df65482011-09-24 17:48:25 +00002469 BaseSpec->isVirtual(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002470 InitRange.getBegin(),
Sebastian Redl6df65482011-09-24 17:48:25 +00002471 BaseInit.takeAs<Expr>(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002472 InitRange.getEnd(), EllipsisLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002473}
2474
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002475// Create a static_cast\<T&&>(expr).
2476static Expr *CastForMoving(Sema &SemaRef, Expr *E) {
2477 QualType ExprType = E->getType();
2478 QualType TargetType = SemaRef.Context.getRValueReferenceType(ExprType);
2479 SourceLocation ExprLoc = E->getLocStart();
2480 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
2481 TargetType, ExprLoc);
2482
2483 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
2484 SourceRange(ExprLoc, ExprLoc),
2485 E->getSourceRange()).take();
2486}
2487
Anders Carlssone5ef7402010-04-23 03:10:23 +00002488/// ImplicitInitializerKind - How an implicit base or member initializer should
2489/// initialize its base or member.
2490enum ImplicitInitializerKind {
2491 IIK_Default,
2492 IIK_Copy,
2493 IIK_Move
2494};
2495
Anders Carlssondefefd22010-04-23 02:00:02 +00002496static bool
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002497BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlssone5ef7402010-04-23 03:10:23 +00002498 ImplicitInitializerKind ImplicitInitKind,
Anders Carlsson711f34a2010-04-21 19:52:01 +00002499 CXXBaseSpecifier *BaseSpec,
Anders Carlssondefefd22010-04-23 02:00:02 +00002500 bool IsInheritedVirtualBase,
Sean Huntcbb67482011-01-08 20:30:50 +00002501 CXXCtorInitializer *&CXXBaseInit) {
Anders Carlsson84688f22010-04-20 23:11:20 +00002502 InitializedEntity InitEntity
Anders Carlsson711f34a2010-04-21 19:52:01 +00002503 = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
2504 IsInheritedVirtualBase);
Anders Carlsson84688f22010-04-20 23:11:20 +00002505
John McCall60d7b3a2010-08-24 06:29:42 +00002506 ExprResult BaseInit;
Anders Carlssone5ef7402010-04-23 03:10:23 +00002507
2508 switch (ImplicitInitKind) {
2509 case IIK_Default: {
2510 InitializationKind InitKind
2511 = InitializationKind::CreateDefault(Constructor->getLocation());
2512 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
Benjamin Kramer5354e772012-08-23 23:38:35 +00002513 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg());
Anders Carlssone5ef7402010-04-23 03:10:23 +00002514 break;
2515 }
Anders Carlsson84688f22010-04-20 23:11:20 +00002516
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002517 case IIK_Move:
Anders Carlssone5ef7402010-04-23 03:10:23 +00002518 case IIK_Copy: {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002519 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlssone5ef7402010-04-23 03:10:23 +00002520 ParmVarDecl *Param = Constructor->getParamDecl(0);
2521 QualType ParamType = Param->getType().getNonReferenceType();
Eli Friedmancf7c14c2012-01-16 21:00:51 +00002522
Anders Carlssone5ef7402010-04-23 03:10:23 +00002523 Expr *CopyCtorArg =
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002524 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCallf4b88a42012-03-10 09:33:50 +00002525 SourceLocation(), Param, false,
John McCallf89e55a2010-11-18 06:31:45 +00002526 Constructor->getLocation(), ParamType,
2527 VK_LValue, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002528
Eli Friedman5f2987c2012-02-02 03:46:19 +00002529 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
2530
Anders Carlssonc7957502010-04-24 22:02:54 +00002531 // Cast to the base class to avoid ambiguities.
Anders Carlsson59b7f152010-05-01 16:39:01 +00002532 QualType ArgTy =
2533 SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
2534 ParamType.getQualifiers());
John McCallf871d0c2010-08-07 06:22:56 +00002535
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002536 if (Moving) {
2537 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
2538 }
2539
John McCallf871d0c2010-08-07 06:22:56 +00002540 CXXCastPath BasePath;
2541 BasePath.push_back(BaseSpec);
John Wiegley429bb272011-04-08 18:41:53 +00002542 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
2543 CK_UncheckedDerivedToBase,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002544 Moving ? VK_XValue : VK_LValue,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002545 &BasePath).take();
Anders Carlssonc7957502010-04-24 22:02:54 +00002546
Anders Carlssone5ef7402010-04-23 03:10:23 +00002547 InitializationKind InitKind
2548 = InitializationKind::CreateDirect(Constructor->getLocation(),
2549 SourceLocation(), SourceLocation());
2550 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind,
2551 &CopyCtorArg, 1);
2552 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind,
John McCallf312b1e2010-08-26 23:41:50 +00002553 MultiExprArg(&CopyCtorArg, 1));
Anders Carlssone5ef7402010-04-23 03:10:23 +00002554 break;
2555 }
Anders Carlssone5ef7402010-04-23 03:10:23 +00002556 }
John McCall9ae2f072010-08-23 23:25:46 +00002557
Douglas Gregor53c374f2010-12-07 00:41:46 +00002558 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
Anders Carlsson84688f22010-04-20 23:11:20 +00002559 if (BaseInit.isInvalid())
Anders Carlssondefefd22010-04-23 02:00:02 +00002560 return true;
Anders Carlsson84688f22010-04-20 23:11:20 +00002561
Anders Carlssondefefd22010-04-23 02:00:02 +00002562 CXXBaseInit =
Sean Huntcbb67482011-01-08 20:30:50 +00002563 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
Anders Carlsson84688f22010-04-20 23:11:20 +00002564 SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
2565 SourceLocation()),
2566 BaseSpec->isVirtual(),
2567 SourceLocation(),
2568 BaseInit.takeAs<Expr>(),
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002569 SourceLocation(),
Anders Carlsson84688f22010-04-20 23:11:20 +00002570 SourceLocation());
2571
Anders Carlssondefefd22010-04-23 02:00:02 +00002572 return false;
Anders Carlsson84688f22010-04-20 23:11:20 +00002573}
2574
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002575static bool RefersToRValueRef(Expr *MemRef) {
2576 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
2577 return Referenced->getType()->isRValueReferenceType();
2578}
2579
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002580static bool
2581BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlssone5ef7402010-04-23 03:10:23 +00002582 ImplicitInitializerKind ImplicitInitKind,
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002583 FieldDecl *Field, IndirectFieldDecl *Indirect,
Sean Huntcbb67482011-01-08 20:30:50 +00002584 CXXCtorInitializer *&CXXMemberInit) {
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002585 if (Field->isInvalidDecl())
2586 return true;
2587
Chandler Carruthf186b542010-06-29 23:50:44 +00002588 SourceLocation Loc = Constructor->getLocation();
2589
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002590 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
2591 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002592 ParmVarDecl *Param = Constructor->getParamDecl(0);
2593 QualType ParamType = Param->getType().getNonReferenceType();
John McCallb77115d2011-06-17 00:18:42 +00002594
2595 // Suppress copying zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002596 if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
2597 return false;
Douglas Gregorddb21472011-11-02 23:04:16 +00002598
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002599 Expr *MemberExprBase =
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002600 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCallf4b88a42012-03-10 09:33:50 +00002601 SourceLocation(), Param, false,
John McCallf89e55a2010-11-18 06:31:45 +00002602 Loc, ParamType, VK_LValue, 0);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002603
Eli Friedman5f2987c2012-02-02 03:46:19 +00002604 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
2605
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002606 if (Moving) {
2607 MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
2608 }
2609
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002610 // Build a reference to this field within the parameter.
2611 CXXScopeSpec SS;
2612 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
2613 Sema::LookupMemberName);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002614 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
2615 : cast<ValueDecl>(Field), AS_public);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002616 MemberLookup.resolveKind();
Sebastian Redl74e611a2011-09-04 18:14:28 +00002617 ExprResult CtorArg
John McCall9ae2f072010-08-23 23:25:46 +00002618 = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002619 ParamType, Loc,
2620 /*IsArrow=*/false,
2621 SS,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002622 /*TemplateKWLoc=*/SourceLocation(),
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002623 /*FirstQualifierInScope=*/0,
2624 MemberLookup,
2625 /*TemplateArgs=*/0);
Sebastian Redl74e611a2011-09-04 18:14:28 +00002626 if (CtorArg.isInvalid())
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002627 return true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002628
2629 // C++11 [class.copy]p15:
2630 // - if a member m has rvalue reference type T&&, it is direct-initialized
2631 // with static_cast<T&&>(x.m);
Sebastian Redl74e611a2011-09-04 18:14:28 +00002632 if (RefersToRValueRef(CtorArg.get())) {
2633 CtorArg = CastForMoving(SemaRef, CtorArg.take());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002634 }
2635
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002636 // When the field we are copying is an array, create index variables for
2637 // each dimension of the array. We use these index variables to subscript
2638 // the source array, and other clients (e.g., CodeGen) will perform the
2639 // necessary iteration with these index variables.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002640 SmallVector<VarDecl *, 4> IndexVariables;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002641 QualType BaseType = Field->getType();
2642 QualType SizeType = SemaRef.Context.getSizeType();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002643 bool InitializingArray = false;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002644 while (const ConstantArrayType *Array
2645 = SemaRef.Context.getAsConstantArrayType(BaseType)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002646 InitializingArray = true;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002647 // Create the iteration variable for this array index.
2648 IdentifierInfo *IterationVarName = 0;
2649 {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00002650 SmallString<8> Str;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002651 llvm::raw_svector_ostream OS(Str);
2652 OS << "__i" << IndexVariables.size();
2653 IterationVarName = &SemaRef.Context.Idents.get(OS.str());
2654 }
2655 VarDecl *IterationVar
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00002656 = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002657 IterationVarName, SizeType,
2658 SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
John McCalld931b082010-08-26 03:08:43 +00002659 SC_None, SC_None);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002660 IndexVariables.push_back(IterationVar);
2661
2662 // Create a reference to the iteration variable.
John McCall60d7b3a2010-08-24 06:29:42 +00002663 ExprResult IterationVarRef
Eli Friedman8c382062012-01-23 02:35:22 +00002664 = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002665 assert(!IterationVarRef.isInvalid() &&
2666 "Reference to invented variable cannot fail!");
Eli Friedman8c382062012-01-23 02:35:22 +00002667 IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.take());
2668 assert(!IterationVarRef.isInvalid() &&
2669 "Conversion of invented variable cannot fail!");
Sebastian Redl74e611a2011-09-04 18:14:28 +00002670
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002671 // Subscript the array with this iteration variable.
Sebastian Redl74e611a2011-09-04 18:14:28 +00002672 CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.take(), Loc,
John McCall9ae2f072010-08-23 23:25:46 +00002673 IterationVarRef.take(),
Sebastian Redl74e611a2011-09-04 18:14:28 +00002674 Loc);
2675 if (CtorArg.isInvalid())
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002676 return true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002677
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002678 BaseType = Array->getElementType();
2679 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002680
2681 // The array subscript expression is an lvalue, which is wrong for moving.
2682 if (Moving && InitializingArray)
Sebastian Redl74e611a2011-09-04 18:14:28 +00002683 CtorArg = CastForMoving(SemaRef, CtorArg.take());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002684
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002685 // Construct the entity that we will be initializing. For an array, this
2686 // will be first element in the array, which may require several levels
2687 // of array-subscript entities.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002688 SmallVector<InitializedEntity, 4> Entities;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002689 Entities.reserve(1 + IndexVariables.size());
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002690 if (Indirect)
2691 Entities.push_back(InitializedEntity::InitializeMember(Indirect));
2692 else
2693 Entities.push_back(InitializedEntity::InitializeMember(Field));
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002694 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
2695 Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context,
2696 0,
2697 Entities.back()));
2698
2699 // Direct-initialize to use the copy constructor.
2700 InitializationKind InitKind =
2701 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());
2702
Sebastian Redl74e611a2011-09-04 18:14:28 +00002703 Expr *CtorArgE = CtorArg.takeAs<Expr>();
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002704 InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002705 &CtorArgE, 1);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002706
John McCall60d7b3a2010-08-24 06:29:42 +00002707 ExprResult MemberInit
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002708 = InitSeq.Perform(SemaRef, Entities.back(), InitKind,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002709 MultiExprArg(&CtorArgE, 1));
Douglas Gregor53c374f2010-12-07 00:41:46 +00002710 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002711 if (MemberInit.isInvalid())
2712 return true;
2713
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002714 if (Indirect) {
2715 assert(IndexVariables.size() == 0 &&
2716 "Indirect field improperly initialized");
2717 CXXMemberInit
2718 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
2719 Loc, Loc,
2720 MemberInit.takeAs<Expr>(),
2721 Loc);
2722 } else
2723 CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc,
2724 Loc, MemberInit.takeAs<Expr>(),
2725 Loc,
2726 IndexVariables.data(),
2727 IndexVariables.size());
Anders Carlssone5ef7402010-04-23 03:10:23 +00002728 return false;
2729 }
2730
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002731 assert(ImplicitInitKind == IIK_Default && "Unhandled implicit init kind!");
2732
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002733 QualType FieldBaseElementType =
2734 SemaRef.Context.getBaseElementType(Field->getType());
2735
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002736 if (FieldBaseElementType->isRecordType()) {
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002737 InitializedEntity InitEntity
2738 = Indirect? InitializedEntity::InitializeMember(Indirect)
2739 : InitializedEntity::InitializeMember(Field);
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002740 InitializationKind InitKind =
Chandler Carruthf186b542010-06-29 23:50:44 +00002741 InitializationKind::CreateDefault(Loc);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002742
2743 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
John McCall60d7b3a2010-08-24 06:29:42 +00002744 ExprResult MemberInit =
John McCallf312b1e2010-08-26 23:41:50 +00002745 InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg());
John McCall9ae2f072010-08-23 23:25:46 +00002746
Douglas Gregor53c374f2010-12-07 00:41:46 +00002747 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002748 if (MemberInit.isInvalid())
2749 return true;
2750
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002751 if (Indirect)
2752 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
2753 Indirect, Loc,
2754 Loc,
2755 MemberInit.get(),
2756 Loc);
2757 else
2758 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
2759 Field, Loc, Loc,
2760 MemberInit.get(),
2761 Loc);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002762 return false;
2763 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002764
Sean Hunt1f2f3842011-05-17 00:19:05 +00002765 if (!Field->getParent()->isUnion()) {
2766 if (FieldBaseElementType->isReferenceType()) {
2767 SemaRef.Diag(Constructor->getLocation(),
2768 diag::err_uninitialized_member_in_ctor)
2769 << (int)Constructor->isImplicit()
2770 << SemaRef.Context.getTagDeclType(Constructor->getParent())
2771 << 0 << Field->getDeclName();
2772 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
2773 return true;
2774 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002775
Sean Hunt1f2f3842011-05-17 00:19:05 +00002776 if (FieldBaseElementType.isConstQualified()) {
2777 SemaRef.Diag(Constructor->getLocation(),
2778 diag::err_uninitialized_member_in_ctor)
2779 << (int)Constructor->isImplicit()
2780 << SemaRef.Context.getTagDeclType(Constructor->getParent())
2781 << 1 << Field->getDeclName();
2782 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
2783 return true;
2784 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002785 }
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002786
David Blaikie4e4d0842012-03-11 07:00:24 +00002787 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00002788 FieldBaseElementType->isObjCRetainableType() &&
2789 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None &&
2790 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
Douglas Gregor3fe52ff2012-07-23 04:23:39 +00002791 // ARC:
John McCallf85e1932011-06-15 23:02:42 +00002792 // Default-initialize Objective-C pointers to NULL.
2793 CXXMemberInit
2794 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
2795 Loc, Loc,
2796 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
2797 Loc);
2798 return false;
2799 }
2800
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002801 // Nothing to initialize.
2802 CXXMemberInit = 0;
2803 return false;
2804}
John McCallf1860e52010-05-20 23:23:51 +00002805
2806namespace {
2807struct BaseAndFieldInfo {
2808 Sema &S;
2809 CXXConstructorDecl *Ctor;
2810 bool AnyErrorsInInits;
2811 ImplicitInitializerKind IIK;
Sean Huntcbb67482011-01-08 20:30:50 +00002812 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002813 SmallVector<CXXCtorInitializer*, 8> AllToInit;
John McCallf1860e52010-05-20 23:23:51 +00002814
2815 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
2816 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002817 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
2818 if (Generated && Ctor->isCopyConstructor())
John McCallf1860e52010-05-20 23:23:51 +00002819 IIK = IIK_Copy;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002820 else if (Generated && Ctor->isMoveConstructor())
2821 IIK = IIK_Move;
John McCallf1860e52010-05-20 23:23:51 +00002822 else
2823 IIK = IIK_Default;
2824 }
Douglas Gregorf4853882011-11-28 20:03:15 +00002825
2826 bool isImplicitCopyOrMove() const {
2827 switch (IIK) {
2828 case IIK_Copy:
2829 case IIK_Move:
2830 return true;
2831
2832 case IIK_Default:
2833 return false;
2834 }
David Blaikie30263482012-01-20 21:50:17 +00002835
2836 llvm_unreachable("Invalid ImplicitInitializerKind!");
Douglas Gregorf4853882011-11-28 20:03:15 +00002837 }
Richard Smith0b8220a2012-08-07 21:30:42 +00002838
2839 bool addFieldInitializer(CXXCtorInitializer *Init) {
2840 AllToInit.push_back(Init);
2841
2842 // Check whether this initializer makes the field "used".
2843 if (Init->getInit() && Init->getInit()->HasSideEffects(S.Context))
2844 S.UnusedPrivateFields.remove(Init->getAnyMember());
2845
2846 return false;
2847 }
John McCallf1860e52010-05-20 23:23:51 +00002848};
2849}
2850
Richard Smitha4950662011-09-19 13:34:43 +00002851/// \brief Determine whether the given indirect field declaration is somewhere
2852/// within an anonymous union.
2853static bool isWithinAnonymousUnion(IndirectFieldDecl *F) {
2854 for (IndirectFieldDecl::chain_iterator C = F->chain_begin(),
2855 CEnd = F->chain_end();
2856 C != CEnd; ++C)
2857 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>((*C)->getDeclContext()))
2858 if (Record->isUnion())
2859 return true;
2860
2861 return false;
2862}
2863
Douglas Gregorddb21472011-11-02 23:04:16 +00002864/// \brief Determine whether the given type is an incomplete or zero-lenfgth
2865/// array type.
2866static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
2867 if (T->isIncompleteArrayType())
2868 return true;
2869
2870 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
2871 if (!ArrayT->getSize())
2872 return true;
2873
2874 T = ArrayT->getElementType();
2875 }
2876
2877 return false;
2878}
2879
Richard Smith7a614d82011-06-11 17:19:42 +00002880static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002881 FieldDecl *Field,
2882 IndirectFieldDecl *Indirect = 0) {
John McCallf1860e52010-05-20 23:23:51 +00002883
Chandler Carruthe861c602010-06-30 02:59:29 +00002884 // Overwhelmingly common case: we have a direct initializer for this field.
Richard Smith0b8220a2012-08-07 21:30:42 +00002885 if (CXXCtorInitializer *Init = Info.AllBaseFields.lookup(Field))
2886 return Info.addFieldInitializer(Init);
John McCallf1860e52010-05-20 23:23:51 +00002887
Richard Smith0b8220a2012-08-07 21:30:42 +00002888 // C++11 [class.base.init]p8: if the entity is a non-static data member that
Richard Smith7a614d82011-06-11 17:19:42 +00002889 // has a brace-or-equal-initializer, the entity is initialized as specified
2890 // in [dcl.init].
Douglas Gregorf4853882011-11-28 20:03:15 +00002891 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002892 CXXCtorInitializer *Init;
2893 if (Indirect)
2894 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
2895 SourceLocation(),
2896 SourceLocation(), 0,
2897 SourceLocation());
2898 else
2899 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
2900 SourceLocation(),
2901 SourceLocation(), 0,
2902 SourceLocation());
Richard Smith0b8220a2012-08-07 21:30:42 +00002903 return Info.addFieldInitializer(Init);
Richard Smith7a614d82011-06-11 17:19:42 +00002904 }
2905
Richard Smithc115f632011-09-18 11:14:50 +00002906 // Don't build an implicit initializer for union members if none was
2907 // explicitly specified.
Richard Smitha4950662011-09-19 13:34:43 +00002908 if (Field->getParent()->isUnion() ||
2909 (Indirect && isWithinAnonymousUnion(Indirect)))
Richard Smithc115f632011-09-18 11:14:50 +00002910 return false;
2911
Douglas Gregorddb21472011-11-02 23:04:16 +00002912 // Don't initialize incomplete or zero-length arrays.
2913 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
2914 return false;
2915
John McCallf1860e52010-05-20 23:23:51 +00002916 // Don't try to build an implicit initializer if there were semantic
2917 // errors in any of the initializers (and therefore we might be
2918 // missing some that the user actually wrote).
Richard Smith7a614d82011-06-11 17:19:42 +00002919 if (Info.AnyErrorsInInits || Field->isInvalidDecl())
John McCallf1860e52010-05-20 23:23:51 +00002920 return false;
2921
Sean Huntcbb67482011-01-08 20:30:50 +00002922 CXXCtorInitializer *Init = 0;
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002923 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
2924 Indirect, Init))
John McCallf1860e52010-05-20 23:23:51 +00002925 return true;
John McCallf1860e52010-05-20 23:23:51 +00002926
Richard Smith0b8220a2012-08-07 21:30:42 +00002927 if (!Init)
2928 return false;
Francois Pichet00eb3f92010-12-04 09:14:42 +00002929
Richard Smith0b8220a2012-08-07 21:30:42 +00002930 return Info.addFieldInitializer(Init);
John McCallf1860e52010-05-20 23:23:51 +00002931}
Sean Hunt059ce0d2011-05-01 07:04:31 +00002932
2933bool
2934Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
2935 CXXCtorInitializer *Initializer) {
Sean Huntfe57eef2011-05-04 05:57:24 +00002936 assert(Initializer->isDelegatingInitializer());
Sean Hunt01aacc02011-05-03 20:43:02 +00002937 Constructor->setNumCtorInitializers(1);
2938 CXXCtorInitializer **initializer =
2939 new (Context) CXXCtorInitializer*[1];
2940 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
2941 Constructor->setCtorInitializers(initializer);
2942
Sean Huntb76af9c2011-05-03 23:05:34 +00002943 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00002944 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
Sean Huntb76af9c2011-05-03 23:05:34 +00002945 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
2946 }
2947
Sean Huntc1598702011-05-05 00:05:47 +00002948 DelegatingCtorDecls.push_back(Constructor);
Sean Huntfe57eef2011-05-04 05:57:24 +00002949
Sean Hunt059ce0d2011-05-01 07:04:31 +00002950 return false;
2951}
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002952
John McCallb77115d2011-06-17 00:18:42 +00002953bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor,
2954 CXXCtorInitializer **Initializers,
2955 unsigned NumInitializers,
2956 bool AnyErrors) {
Douglas Gregord836c0d2011-09-22 23:04:35 +00002957 if (Constructor->isDependentContext()) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002958 // Just store the initializers as written, they will be checked during
2959 // instantiation.
2960 if (NumInitializers > 0) {
Sean Huntcbb67482011-01-08 20:30:50 +00002961 Constructor->setNumCtorInitializers(NumInitializers);
2962 CXXCtorInitializer **baseOrMemberInitializers =
2963 new (Context) CXXCtorInitializer*[NumInitializers];
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002964 memcpy(baseOrMemberInitializers, Initializers,
Sean Huntcbb67482011-01-08 20:30:50 +00002965 NumInitializers * sizeof(CXXCtorInitializer*));
2966 Constructor->setCtorInitializers(baseOrMemberInitializers);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002967 }
Richard Smith54b3ba82012-09-25 00:23:05 +00002968
2969 // Let template instantiation know whether we had errors.
2970 if (AnyErrors)
2971 Constructor->setInvalidDecl();
2972
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002973 return false;
2974 }
2975
John McCallf1860e52010-05-20 23:23:51 +00002976 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
Anders Carlssone5ef7402010-04-23 03:10:23 +00002977
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00002978 // We need to build the initializer AST according to order of construction
2979 // and not what user specified in the Initializers list.
Anders Carlssonea356fb2010-04-02 05:42:15 +00002980 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
Douglas Gregord6068482010-03-26 22:43:07 +00002981 if (!ClassDecl)
2982 return true;
2983
Eli Friedman80c30da2009-11-09 19:20:36 +00002984 bool HadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +00002985
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00002986 for (unsigned i = 0; i < NumInitializers; i++) {
Sean Huntcbb67482011-01-08 20:30:50 +00002987 CXXCtorInitializer *Member = Initializers[i];
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002988
2989 if (Member->isBaseInitializer())
John McCallf1860e52010-05-20 23:23:51 +00002990 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002991 else
Francois Pichet00eb3f92010-12-04 09:14:42 +00002992 Info.AllBaseFields[Member->getAnyMember()] = Member;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00002993 }
2994
Anders Carlsson711f34a2010-04-21 19:52:01 +00002995 // Keep track of the direct virtual bases.
2996 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
2997 for (CXXRecordDecl::base_class_iterator I = ClassDecl->bases_begin(),
2998 E = ClassDecl->bases_end(); I != E; ++I) {
2999 if (I->isVirtual())
3000 DirectVBases.insert(I);
3001 }
3002
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003003 // Push virtual bases before others.
3004 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
3005 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
3006
Sean Huntcbb67482011-01-08 20:30:50 +00003007 if (CXXCtorInitializer *Value
John McCallf1860e52010-05-20 23:23:51 +00003008 = Info.AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
3009 Info.AllToInit.push_back(Value);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003010 } else if (!AnyErrors) {
Anders Carlsson711f34a2010-04-21 19:52:01 +00003011 bool IsInheritedVirtualBase = !DirectVBases.count(VBase);
Sean Huntcbb67482011-01-08 20:30:50 +00003012 CXXCtorInitializer *CXXBaseInit;
John McCallf1860e52010-05-20 23:23:51 +00003013 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Anders Carlssone5ef7402010-04-23 03:10:23 +00003014 VBase, IsInheritedVirtualBase,
3015 CXXBaseInit)) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003016 HadError = true;
3017 continue;
3018 }
Anders Carlsson84688f22010-04-20 23:11:20 +00003019
John McCallf1860e52010-05-20 23:23:51 +00003020 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003021 }
3022 }
Mike Stump1eb44332009-09-09 15:08:12 +00003023
John McCallf1860e52010-05-20 23:23:51 +00003024 // Non-virtual bases.
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003025 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3026 E = ClassDecl->bases_end(); Base != E; ++Base) {
3027 // Virtuals are in the virtual base list and already constructed.
3028 if (Base->isVirtual())
3029 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00003030
Sean Huntcbb67482011-01-08 20:30:50 +00003031 if (CXXCtorInitializer *Value
John McCallf1860e52010-05-20 23:23:51 +00003032 = Info.AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
3033 Info.AllToInit.push_back(Value);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003034 } else if (!AnyErrors) {
Sean Huntcbb67482011-01-08 20:30:50 +00003035 CXXCtorInitializer *CXXBaseInit;
John McCallf1860e52010-05-20 23:23:51 +00003036 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Anders Carlssone5ef7402010-04-23 03:10:23 +00003037 Base, /*IsInheritedVirtualBase=*/false,
Anders Carlssondefefd22010-04-23 02:00:02 +00003038 CXXBaseInit)) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003039 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003040 continue;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003041 }
Fariborz Jahanian9d436202009-09-03 21:32:41 +00003042
John McCallf1860e52010-05-20 23:23:51 +00003043 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003044 }
3045 }
Mike Stump1eb44332009-09-09 15:08:12 +00003046
John McCallf1860e52010-05-20 23:23:51 +00003047 // Fields.
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003048 for (DeclContext::decl_iterator Mem = ClassDecl->decls_begin(),
3049 MemEnd = ClassDecl->decls_end();
3050 Mem != MemEnd; ++Mem) {
3051 if (FieldDecl *F = dyn_cast<FieldDecl>(*Mem)) {
Douglas Gregord61db332011-10-10 17:22:13 +00003052 // C++ [class.bit]p2:
3053 // A declaration for a bit-field that omits the identifier declares an
3054 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
3055 // initialized.
3056 if (F->isUnnamedBitfield())
3057 continue;
Douglas Gregorddb21472011-11-02 23:04:16 +00003058
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00003059 // If we're not generating the implicit copy/move constructor, then we'll
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003060 // handle anonymous struct/union fields based on their individual
3061 // indirect fields.
3062 if (F->isAnonymousStructOrUnion() && Info.IIK == IIK_Default)
3063 continue;
3064
3065 if (CollectFieldInitializer(*this, Info, F))
3066 HadError = true;
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00003067 continue;
3068 }
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003069
3070 // Beyond this point, we only consider default initialization.
3071 if (Info.IIK != IIK_Default)
3072 continue;
3073
3074 if (IndirectFieldDecl *F = dyn_cast<IndirectFieldDecl>(*Mem)) {
3075 if (F->getType()->isIncompleteArrayType()) {
3076 assert(ClassDecl->hasFlexibleArrayMember() &&
3077 "Incomplete array type is not valid");
3078 continue;
3079 }
3080
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003081 // Initialize each field of an anonymous struct individually.
3082 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
3083 HadError = true;
3084
3085 continue;
3086 }
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00003087 }
Mike Stump1eb44332009-09-09 15:08:12 +00003088
John McCallf1860e52010-05-20 23:23:51 +00003089 NumInitializers = Info.AllToInit.size();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003090 if (NumInitializers > 0) {
Sean Huntcbb67482011-01-08 20:30:50 +00003091 Constructor->setNumCtorInitializers(NumInitializers);
3092 CXXCtorInitializer **baseOrMemberInitializers =
3093 new (Context) CXXCtorInitializer*[NumInitializers];
John McCallf1860e52010-05-20 23:23:51 +00003094 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
Sean Huntcbb67482011-01-08 20:30:50 +00003095 NumInitializers * sizeof(CXXCtorInitializer*));
3096 Constructor->setCtorInitializers(baseOrMemberInitializers);
Rafael Espindola961b1672010-03-13 18:12:56 +00003097
John McCallef027fe2010-03-16 21:39:52 +00003098 // Constructors implicitly reference the base and member
3099 // destructors.
3100 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
3101 Constructor->getParent());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003102 }
Eli Friedman80c30da2009-11-09 19:20:36 +00003103
3104 return HadError;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003105}
3106
Eli Friedman6347f422009-07-21 19:28:10 +00003107static void *GetKeyForTopLevelField(FieldDecl *Field) {
3108 // For anonymous unions, use the class declaration as the key.
Ted Kremenek6217b802009-07-29 21:53:49 +00003109 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
Eli Friedman6347f422009-07-21 19:28:10 +00003110 if (RT->getDecl()->isAnonymousStructOrUnion())
3111 return static_cast<void *>(RT->getDecl());
3112 }
3113 return static_cast<void *>(Field);
3114}
3115
Anders Carlssonea356fb2010-04-02 05:42:15 +00003116static void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
John McCallf4c73712011-01-19 06:33:43 +00003117 return const_cast<Type*>(Context.getCanonicalType(BaseType).getTypePtr());
Anders Carlssoncdc83c72009-09-01 06:22:14 +00003118}
3119
Anders Carlssonea356fb2010-04-02 05:42:15 +00003120static void *GetKeyForMember(ASTContext &Context,
Sean Huntcbb67482011-01-08 20:30:50 +00003121 CXXCtorInitializer *Member) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00003122 if (!Member->isAnyMemberInitializer())
Anders Carlssonea356fb2010-04-02 05:42:15 +00003123 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
Anders Carlsson8f1a2402010-03-30 15:39:27 +00003124
Eli Friedman6347f422009-07-21 19:28:10 +00003125 // For fields injected into the class via declaration of an anonymous union,
3126 // use its anonymous union class declaration as the unique key.
Francois Pichet00eb3f92010-12-04 09:14:42 +00003127 FieldDecl *Field = Member->getAnyMember();
3128
John McCall3c3ccdb2010-04-10 09:28:51 +00003129 // If the field is a member of an anonymous struct or union, our key
3130 // is the anonymous record decl that's a direct child of the class.
Anders Carlssonee11b2d2010-03-30 16:19:37 +00003131 RecordDecl *RD = Field->getParent();
John McCall3c3ccdb2010-04-10 09:28:51 +00003132 if (RD->isAnonymousStructOrUnion()) {
3133 while (true) {
3134 RecordDecl *Parent = cast<RecordDecl>(RD->getDeclContext());
3135 if (Parent->isAnonymousStructOrUnion())
3136 RD = Parent;
3137 else
3138 break;
3139 }
3140
Anders Carlssonee11b2d2010-03-30 16:19:37 +00003141 return static_cast<void *>(RD);
John McCall3c3ccdb2010-04-10 09:28:51 +00003142 }
Mike Stump1eb44332009-09-09 15:08:12 +00003143
Anders Carlsson8f1a2402010-03-30 15:39:27 +00003144 return static_cast<void *>(Field);
Eli Friedman6347f422009-07-21 19:28:10 +00003145}
3146
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003147static void
3148DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef,
Anders Carlsson071d6102010-04-02 03:38:04 +00003149 const CXXConstructorDecl *Constructor,
Sean Huntcbb67482011-01-08 20:30:50 +00003150 CXXCtorInitializer **Inits,
John McCalld6ca8da2010-04-10 07:37:23 +00003151 unsigned NumInits) {
3152 if (Constructor->getDeclContext()->isDependentContext())
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00003153 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003154
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003155 // Don't check initializers order unless the warning is enabled at the
3156 // location of at least one initializer.
3157 bool ShouldCheckOrder = false;
3158 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) {
Sean Huntcbb67482011-01-08 20:30:50 +00003159 CXXCtorInitializer *Init = Inits[InitIndex];
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003160 if (SemaRef.Diags.getDiagnosticLevel(diag::warn_initializer_out_of_order,
3161 Init->getSourceLocation())
David Blaikied6471f72011-09-25 23:23:43 +00003162 != DiagnosticsEngine::Ignored) {
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003163 ShouldCheckOrder = true;
3164 break;
3165 }
3166 }
3167 if (!ShouldCheckOrder)
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003168 return;
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003169
John McCalld6ca8da2010-04-10 07:37:23 +00003170 // Build the list of bases and members in the order that they'll
3171 // actually be initialized. The explicit initializers should be in
3172 // this same order but may be missing things.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003173 SmallVector<const void*, 32> IdealInitKeys;
Mike Stump1eb44332009-09-09 15:08:12 +00003174
Anders Carlsson071d6102010-04-02 03:38:04 +00003175 const CXXRecordDecl *ClassDecl = Constructor->getParent();
3176
John McCalld6ca8da2010-04-10 07:37:23 +00003177 // 1. Virtual bases.
Anders Carlsson071d6102010-04-02 03:38:04 +00003178 for (CXXRecordDecl::base_class_const_iterator VBase =
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003179 ClassDecl->vbases_begin(),
3180 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
John McCalld6ca8da2010-04-10 07:37:23 +00003181 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00003182
John McCalld6ca8da2010-04-10 07:37:23 +00003183 // 2. Non-virtual bases.
Anders Carlsson071d6102010-04-02 03:38:04 +00003184 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003185 E = ClassDecl->bases_end(); Base != E; ++Base) {
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003186 if (Base->isVirtual())
3187 continue;
John McCalld6ca8da2010-04-10 07:37:23 +00003188 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base->getType()));
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003189 }
Mike Stump1eb44332009-09-09 15:08:12 +00003190
John McCalld6ca8da2010-04-10 07:37:23 +00003191 // 3. Direct fields.
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003192 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
Douglas Gregord61db332011-10-10 17:22:13 +00003193 E = ClassDecl->field_end(); Field != E; ++Field) {
3194 if (Field->isUnnamedBitfield())
3195 continue;
3196
David Blaikie581deb32012-06-06 20:45:41 +00003197 IdealInitKeys.push_back(GetKeyForTopLevelField(*Field));
Douglas Gregord61db332011-10-10 17:22:13 +00003198 }
3199
John McCalld6ca8da2010-04-10 07:37:23 +00003200 unsigned NumIdealInits = IdealInitKeys.size();
3201 unsigned IdealIndex = 0;
Eli Friedman6347f422009-07-21 19:28:10 +00003202
Sean Huntcbb67482011-01-08 20:30:50 +00003203 CXXCtorInitializer *PrevInit = 0;
John McCalld6ca8da2010-04-10 07:37:23 +00003204 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) {
Sean Huntcbb67482011-01-08 20:30:50 +00003205 CXXCtorInitializer *Init = Inits[InitIndex];
Francois Pichet00eb3f92010-12-04 09:14:42 +00003206 void *InitKey = GetKeyForMember(SemaRef.Context, Init);
John McCalld6ca8da2010-04-10 07:37:23 +00003207
3208 // Scan forward to try to find this initializer in the idealized
3209 // initializers list.
3210 for (; IdealIndex != NumIdealInits; ++IdealIndex)
3211 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003212 break;
John McCalld6ca8da2010-04-10 07:37:23 +00003213
3214 // If we didn't find this initializer, it must be because we
3215 // scanned past it on a previous iteration. That can only
3216 // happen if we're out of order; emit a warning.
Douglas Gregorfe2d3792010-05-20 23:49:34 +00003217 if (IdealIndex == NumIdealInits && PrevInit) {
John McCalld6ca8da2010-04-10 07:37:23 +00003218 Sema::SemaDiagnosticBuilder D =
3219 SemaRef.Diag(PrevInit->getSourceLocation(),
3220 diag::warn_initializer_out_of_order);
3221
Francois Pichet00eb3f92010-12-04 09:14:42 +00003222 if (PrevInit->isAnyMemberInitializer())
3223 D << 0 << PrevInit->getAnyMember()->getDeclName();
John McCalld6ca8da2010-04-10 07:37:23 +00003224 else
Douglas Gregor76852c22011-11-01 01:16:03 +00003225 D << 1 << PrevInit->getTypeSourceInfo()->getType();
John McCalld6ca8da2010-04-10 07:37:23 +00003226
Francois Pichet00eb3f92010-12-04 09:14:42 +00003227 if (Init->isAnyMemberInitializer())
3228 D << 0 << Init->getAnyMember()->getDeclName();
John McCalld6ca8da2010-04-10 07:37:23 +00003229 else
Douglas Gregor76852c22011-11-01 01:16:03 +00003230 D << 1 << Init->getTypeSourceInfo()->getType();
John McCalld6ca8da2010-04-10 07:37:23 +00003231
3232 // Move back to the initializer's location in the ideal list.
3233 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
3234 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003235 break;
John McCalld6ca8da2010-04-10 07:37:23 +00003236
3237 assert(IdealIndex != NumIdealInits &&
3238 "initializer not found in initializer list");
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00003239 }
John McCalld6ca8da2010-04-10 07:37:23 +00003240
3241 PrevInit = Init;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00003242 }
Anders Carlssona7b35212009-03-25 02:58:17 +00003243}
3244
John McCall3c3ccdb2010-04-10 09:28:51 +00003245namespace {
3246bool CheckRedundantInit(Sema &S,
Sean Huntcbb67482011-01-08 20:30:50 +00003247 CXXCtorInitializer *Init,
3248 CXXCtorInitializer *&PrevInit) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003249 if (!PrevInit) {
3250 PrevInit = Init;
3251 return false;
3252 }
3253
3254 if (FieldDecl *Field = Init->getMember())
3255 S.Diag(Init->getSourceLocation(),
3256 diag::err_multiple_mem_initialization)
3257 << Field->getDeclName()
3258 << Init->getSourceRange();
3259 else {
John McCallf4c73712011-01-19 06:33:43 +00003260 const Type *BaseClass = Init->getBaseClass();
John McCall3c3ccdb2010-04-10 09:28:51 +00003261 assert(BaseClass && "neither field nor base");
3262 S.Diag(Init->getSourceLocation(),
3263 diag::err_multiple_base_initialization)
3264 << QualType(BaseClass, 0)
3265 << Init->getSourceRange();
3266 }
3267 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
3268 << 0 << PrevInit->getSourceRange();
3269
3270 return true;
3271}
3272
Sean Huntcbb67482011-01-08 20:30:50 +00003273typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
John McCall3c3ccdb2010-04-10 09:28:51 +00003274typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
3275
3276bool CheckRedundantUnionInit(Sema &S,
Sean Huntcbb67482011-01-08 20:30:50 +00003277 CXXCtorInitializer *Init,
John McCall3c3ccdb2010-04-10 09:28:51 +00003278 RedundantUnionMap &Unions) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00003279 FieldDecl *Field = Init->getAnyMember();
John McCall3c3ccdb2010-04-10 09:28:51 +00003280 RecordDecl *Parent = Field->getParent();
John McCall3c3ccdb2010-04-10 09:28:51 +00003281 NamedDecl *Child = Field;
David Blaikie6fe29652011-11-17 06:01:57 +00003282
3283 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003284 if (Parent->isUnion()) {
3285 UnionEntry &En = Unions[Parent];
3286 if (En.first && En.first != Child) {
3287 S.Diag(Init->getSourceLocation(),
3288 diag::err_multiple_mem_union_initialization)
3289 << Field->getDeclName()
3290 << Init->getSourceRange();
3291 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
3292 << 0 << En.second->getSourceRange();
3293 return true;
David Blaikie5bbe8162011-11-12 20:54:14 +00003294 }
3295 if (!En.first) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003296 En.first = Child;
3297 En.second = Init;
3298 }
David Blaikie6fe29652011-11-17 06:01:57 +00003299 if (!Parent->isAnonymousStructOrUnion())
3300 return false;
John McCall3c3ccdb2010-04-10 09:28:51 +00003301 }
3302
3303 Child = Parent;
3304 Parent = cast<RecordDecl>(Parent->getDeclContext());
David Blaikie6fe29652011-11-17 06:01:57 +00003305 }
John McCall3c3ccdb2010-04-10 09:28:51 +00003306
3307 return false;
3308}
3309}
3310
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003311/// ActOnMemInitializers - Handle the member initializers for a constructor.
John McCalld226f652010-08-21 09:40:31 +00003312void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003313 SourceLocation ColonLoc,
Richard Trieu90ab75b2011-09-09 03:18:59 +00003314 CXXCtorInitializer **meminits,
3315 unsigned NumMemInits,
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003316 bool AnyErrors) {
3317 if (!ConstructorDecl)
3318 return;
3319
3320 AdjustDeclIfTemplate(ConstructorDecl);
3321
3322 CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00003323 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003324
3325 if (!Constructor) {
3326 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
3327 return;
3328 }
3329
Sean Huntcbb67482011-01-08 20:30:50 +00003330 CXXCtorInitializer **MemInits =
3331 reinterpret_cast<CXXCtorInitializer **>(meminits);
John McCall3c3ccdb2010-04-10 09:28:51 +00003332
3333 // Mapping for the duplicate initializers check.
3334 // For member initializers, this is keyed with a FieldDecl*.
3335 // For base initializers, this is keyed with a Type*.
Sean Huntcbb67482011-01-08 20:30:50 +00003336 llvm::DenseMap<void*, CXXCtorInitializer *> Members;
John McCall3c3ccdb2010-04-10 09:28:51 +00003337
3338 // Mapping for the inconsistent anonymous-union initializers check.
3339 RedundantUnionMap MemberUnions;
3340
Anders Carlssonea356fb2010-04-02 05:42:15 +00003341 bool HadError = false;
3342 for (unsigned i = 0; i < NumMemInits; i++) {
Sean Huntcbb67482011-01-08 20:30:50 +00003343 CXXCtorInitializer *Init = MemInits[i];
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003344
Abramo Bagnaraa0af3b42010-05-26 18:09:23 +00003345 // Set the source order index.
3346 Init->setSourceOrder(i);
3347
Francois Pichet00eb3f92010-12-04 09:14:42 +00003348 if (Init->isAnyMemberInitializer()) {
3349 FieldDecl *Field = Init->getAnyMember();
John McCall3c3ccdb2010-04-10 09:28:51 +00003350 if (CheckRedundantInit(*this, Init, Members[Field]) ||
3351 CheckRedundantUnionInit(*this, Init, MemberUnions))
3352 HadError = true;
Sean Hunt41717662011-02-26 19:13:13 +00003353 } else if (Init->isBaseInitializer()) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003354 void *Key = GetKeyForBase(Context, QualType(Init->getBaseClass(), 0));
3355 if (CheckRedundantInit(*this, Init, Members[Key]))
3356 HadError = true;
Sean Hunt41717662011-02-26 19:13:13 +00003357 } else {
3358 assert(Init->isDelegatingInitializer());
3359 // This must be the only initializer
Richard Smitha6ddea62012-09-14 18:21:10 +00003360 if (NumMemInits != 1) {
3361 Diag(Init->getSourceLocation(),
Sean Hunt41717662011-02-26 19:13:13 +00003362 diag::err_delegating_initializer_alone)
Richard Smitha6ddea62012-09-14 18:21:10 +00003363 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
Sean Hunt059ce0d2011-05-01 07:04:31 +00003364 // We will treat this as being the only initializer.
Sean Hunt41717662011-02-26 19:13:13 +00003365 }
Sean Huntfe57eef2011-05-04 05:57:24 +00003366 SetDelegatingInitializer(Constructor, MemInits[i]);
Sean Hunt059ce0d2011-05-01 07:04:31 +00003367 // Return immediately as the initializer is set.
3368 return;
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003369 }
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003370 }
3371
Anders Carlssonea356fb2010-04-02 05:42:15 +00003372 if (HadError)
3373 return;
3374
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003375 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits, NumMemInits);
Anders Carlssonec3332b2010-04-02 03:43:34 +00003376
Sean Huntcbb67482011-01-08 20:30:50 +00003377 SetCtorInitializers(Constructor, MemInits, NumMemInits, AnyErrors);
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003378}
3379
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003380void
John McCallef027fe2010-03-16 21:39:52 +00003381Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
3382 CXXRecordDecl *ClassDecl) {
Richard Smith416f63e2011-09-18 12:11:43 +00003383 // Ignore dependent contexts. Also ignore unions, since their members never
3384 // have destructors implicitly called.
3385 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003386 return;
John McCall58e6f342010-03-16 05:22:47 +00003387
3388 // FIXME: all the access-control diagnostics are positioned on the
3389 // field/base declaration. That's probably good; that said, the
3390 // user might reasonably want to know why the destructor is being
3391 // emitted, and we currently don't say.
Anders Carlsson9f853df2009-11-17 04:44:12 +00003392
Anders Carlsson9f853df2009-11-17 04:44:12 +00003393 // Non-static data members.
3394 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
3395 E = ClassDecl->field_end(); I != E; ++I) {
David Blaikie581deb32012-06-06 20:45:41 +00003396 FieldDecl *Field = *I;
Fariborz Jahanian9614dc02010-05-17 18:15:18 +00003397 if (Field->isInvalidDecl())
3398 continue;
Douglas Gregorddb21472011-11-02 23:04:16 +00003399
3400 // Don't destroy incomplete or zero-length arrays.
3401 if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
3402 continue;
3403
Anders Carlsson9f853df2009-11-17 04:44:12 +00003404 QualType FieldType = Context.getBaseElementType(Field->getType());
3405
3406 const RecordType* RT = FieldType->getAs<RecordType>();
3407 if (!RT)
3408 continue;
3409
3410 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003411 if (FieldClassDecl->isInvalidDecl())
3412 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003413 if (FieldClassDecl->hasIrrelevantDestructor())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003414 continue;
Richard Smith9a561d52012-02-26 09:11:52 +00003415 // The destructor for an implicit anonymous union member is never invoked.
3416 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
3417 continue;
Anders Carlsson9f853df2009-11-17 04:44:12 +00003418
Douglas Gregordb89f282010-07-01 22:47:18 +00003419 CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003420 assert(Dtor && "No dtor found for FieldClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003421 CheckDestructorAccess(Field->getLocation(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003422 PDiag(diag::err_access_dtor_field)
John McCall58e6f342010-03-16 05:22:47 +00003423 << Field->getDeclName()
3424 << FieldType);
3425
Eli Friedman5f2987c2012-02-02 03:46:19 +00003426 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003427 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003428 }
3429
John McCall58e6f342010-03-16 05:22:47 +00003430 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
3431
Anders Carlsson9f853df2009-11-17 04:44:12 +00003432 // Bases.
3433 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3434 E = ClassDecl->bases_end(); Base != E; ++Base) {
John McCall58e6f342010-03-16 05:22:47 +00003435 // Bases are always records in a well-formed non-dependent class.
3436 const RecordType *RT = Base->getType()->getAs<RecordType>();
3437
3438 // Remember direct virtual bases.
Anders Carlsson9f853df2009-11-17 04:44:12 +00003439 if (Base->isVirtual())
John McCall58e6f342010-03-16 05:22:47 +00003440 DirectVirtualBases.insert(RT);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003441
John McCall58e6f342010-03-16 05:22:47 +00003442 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003443 // If our base class is invalid, we probably can't get its dtor anyway.
3444 if (BaseClassDecl->isInvalidDecl())
3445 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003446 if (BaseClassDecl->hasIrrelevantDestructor())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003447 continue;
John McCall58e6f342010-03-16 05:22:47 +00003448
Douglas Gregordb89f282010-07-01 22:47:18 +00003449 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003450 assert(Dtor && "No dtor found for BaseClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003451
3452 // FIXME: caret should be on the start of the class name
Daniel Dunbar96a00142012-03-09 18:35:03 +00003453 CheckDestructorAccess(Base->getLocStart(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003454 PDiag(diag::err_access_dtor_base)
John McCall58e6f342010-03-16 05:22:47 +00003455 << Base->getType()
John McCallb9abd8722012-04-07 03:04:20 +00003456 << Base->getSourceRange(),
3457 Context.getTypeDeclType(ClassDecl));
Anders Carlsson9f853df2009-11-17 04:44:12 +00003458
Eli Friedman5f2987c2012-02-02 03:46:19 +00003459 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003460 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003461 }
3462
3463 // Virtual bases.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003464 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
3465 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
John McCall58e6f342010-03-16 05:22:47 +00003466
3467 // Bases are always records in a well-formed non-dependent class.
John McCall63f55782012-04-09 21:51:56 +00003468 const RecordType *RT = VBase->getType()->castAs<RecordType>();
John McCall58e6f342010-03-16 05:22:47 +00003469
3470 // Ignore direct virtual bases.
3471 if (DirectVirtualBases.count(RT))
3472 continue;
3473
John McCall58e6f342010-03-16 05:22:47 +00003474 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003475 // If our base class is invalid, we probably can't get its dtor anyway.
3476 if (BaseClassDecl->isInvalidDecl())
3477 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003478 if (BaseClassDecl->hasIrrelevantDestructor())
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003479 continue;
John McCall58e6f342010-03-16 05:22:47 +00003480
Douglas Gregordb89f282010-07-01 22:47:18 +00003481 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003482 assert(Dtor && "No dtor found for BaseClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003483 CheckDestructorAccess(ClassDecl->getLocation(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003484 PDiag(diag::err_access_dtor_vbase)
John McCall63f55782012-04-09 21:51:56 +00003485 << VBase->getType(),
3486 Context.getTypeDeclType(ClassDecl));
John McCall58e6f342010-03-16 05:22:47 +00003487
Eli Friedman5f2987c2012-02-02 03:46:19 +00003488 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003489 DiagnoseUseOfDecl(Dtor, Location);
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003490 }
3491}
3492
John McCalld226f652010-08-21 09:40:31 +00003493void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
Fariborz Jahanian560de452009-07-15 22:34:08 +00003494 if (!CDtorDecl)
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00003495 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003496
Mike Stump1eb44332009-09-09 15:08:12 +00003497 if (CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00003498 = dyn_cast<CXXConstructorDecl>(CDtorDecl))
Sean Huntcbb67482011-01-08 20:30:50 +00003499 SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00003500}
3501
Mike Stump1eb44332009-09-09 15:08:12 +00003502bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
John McCall94c3b562010-08-18 09:41:07 +00003503 unsigned DiagID, AbstractDiagSelID SelID) {
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003504 class NonAbstractTypeDiagnoser : public TypeDiagnoser {
3505 unsigned DiagID;
3506 AbstractDiagSelID SelID;
3507
3508 public:
3509 NonAbstractTypeDiagnoser(unsigned DiagID, AbstractDiagSelID SelID)
3510 : TypeDiagnoser(DiagID == 0), DiagID(DiagID), SelID(SelID) { }
3511
3512 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
Eli Friedman2217f852012-08-14 02:06:07 +00003513 if (Suppressed) return;
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003514 if (SelID == -1)
3515 S.Diag(Loc, DiagID) << T;
3516 else
3517 S.Diag(Loc, DiagID) << SelID << T;
3518 }
3519 } Diagnoser(DiagID, SelID);
3520
3521 return RequireNonAbstractType(Loc, T, Diagnoser);
Mike Stump1eb44332009-09-09 15:08:12 +00003522}
3523
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00003524bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003525 TypeDiagnoser &Diagnoser) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003526 if (!getLangOpts().CPlusPlus)
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003527 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003528
Anders Carlsson11f21a02009-03-23 19:10:31 +00003529 if (const ArrayType *AT = Context.getAsArrayType(T))
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003530 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Mike Stump1eb44332009-09-09 15:08:12 +00003531
Ted Kremenek6217b802009-07-29 21:53:49 +00003532 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003533 // Find the innermost pointer type.
Ted Kremenek6217b802009-07-29 21:53:49 +00003534 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003535 PT = T;
Mike Stump1eb44332009-09-09 15:08:12 +00003536
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003537 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003538 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003539 }
Mike Stump1eb44332009-09-09 15:08:12 +00003540
Ted Kremenek6217b802009-07-29 21:53:49 +00003541 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003542 if (!RT)
3543 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003544
John McCall86ff3082010-02-04 22:26:26 +00003545 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003546
John McCall94c3b562010-08-18 09:41:07 +00003547 // We can't answer whether something is abstract until it has a
3548 // definition. If it's currently being defined, we'll walk back
3549 // over all the declarations when we have a full definition.
3550 const CXXRecordDecl *Def = RD->getDefinition();
3551 if (!Def || Def->isBeingDefined())
John McCall86ff3082010-02-04 22:26:26 +00003552 return false;
3553
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003554 if (!RD->isAbstract())
3555 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003556
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003557 Diagnoser.diagnose(*this, Loc, T);
John McCall94c3b562010-08-18 09:41:07 +00003558 DiagnoseAbstractType(RD);
Mike Stump1eb44332009-09-09 15:08:12 +00003559
John McCall94c3b562010-08-18 09:41:07 +00003560 return true;
3561}
3562
3563void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
3564 // Check if we've already emitted the list of pure virtual functions
3565 // for this class.
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003566 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
John McCall94c3b562010-08-18 09:41:07 +00003567 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003568
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003569 CXXFinalOverriderMap FinalOverriders;
3570 RD->getFinalOverriders(FinalOverriders);
Mike Stump1eb44332009-09-09 15:08:12 +00003571
Anders Carlssonffdb2d22010-06-03 01:00:02 +00003572 // Keep a set of seen pure methods so we won't diagnose the same method
3573 // more than once.
3574 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
3575
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003576 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
3577 MEnd = FinalOverriders.end();
3578 M != MEnd;
3579 ++M) {
3580 for (OverridingMethods::iterator SO = M->second.begin(),
3581 SOEnd = M->second.end();
3582 SO != SOEnd; ++SO) {
3583 // C++ [class.abstract]p4:
3584 // A class is abstract if it contains or inherits at least one
3585 // pure virtual function for which the final overrider is pure
3586 // virtual.
Mike Stump1eb44332009-09-09 15:08:12 +00003587
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003588 //
3589 if (SO->second.size() != 1)
3590 continue;
3591
3592 if (!SO->second.front().Method->isPure())
3593 continue;
3594
Anders Carlssonffdb2d22010-06-03 01:00:02 +00003595 if (!SeenPureMethods.insert(SO->second.front().Method))
3596 continue;
3597
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003598 Diag(SO->second.front().Method->getLocation(),
3599 diag::note_pure_virtual_function)
Chandler Carruth45f11b72011-02-18 23:59:51 +00003600 << SO->second.front().Method->getDeclName() << RD->getDeclName();
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003601 }
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003602 }
3603
3604 if (!PureVirtualClassDiagSet)
3605 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
3606 PureVirtualClassDiagSet->insert(RD);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003607}
3608
Anders Carlsson8211eff2009-03-24 01:19:16 +00003609namespace {
John McCall94c3b562010-08-18 09:41:07 +00003610struct AbstractUsageInfo {
3611 Sema &S;
3612 CXXRecordDecl *Record;
3613 CanQualType AbstractType;
3614 bool Invalid;
Mike Stump1eb44332009-09-09 15:08:12 +00003615
John McCall94c3b562010-08-18 09:41:07 +00003616 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
3617 : S(S), Record(Record),
3618 AbstractType(S.Context.getCanonicalType(
3619 S.Context.getTypeDeclType(Record))),
3620 Invalid(false) {}
Anders Carlsson8211eff2009-03-24 01:19:16 +00003621
John McCall94c3b562010-08-18 09:41:07 +00003622 void DiagnoseAbstractType() {
3623 if (Invalid) return;
3624 S.DiagnoseAbstractType(Record);
3625 Invalid = true;
3626 }
Anders Carlssone65a3c82009-03-24 17:23:42 +00003627
John McCall94c3b562010-08-18 09:41:07 +00003628 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
3629};
3630
3631struct CheckAbstractUsage {
3632 AbstractUsageInfo &Info;
3633 const NamedDecl *Ctx;
3634
3635 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
3636 : Info(Info), Ctx(Ctx) {}
3637
3638 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
3639 switch (TL.getTypeLocClass()) {
3640#define ABSTRACT_TYPELOC(CLASS, PARENT)
3641#define TYPELOC(CLASS, PARENT) \
3642 case TypeLoc::CLASS: Check(cast<CLASS##TypeLoc>(TL), Sel); break;
3643#include "clang/AST/TypeLocNodes.def"
Anders Carlsson8211eff2009-03-24 01:19:16 +00003644 }
John McCall94c3b562010-08-18 09:41:07 +00003645 }
Mike Stump1eb44332009-09-09 15:08:12 +00003646
John McCall94c3b562010-08-18 09:41:07 +00003647 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3648 Visit(TL.getResultLoc(), Sema::AbstractReturnType);
3649 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
Douglas Gregor70191862011-02-22 23:21:06 +00003650 if (!TL.getArg(I))
3651 continue;
3652
John McCall94c3b562010-08-18 09:41:07 +00003653 TypeSourceInfo *TSI = TL.getArg(I)->getTypeSourceInfo();
3654 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
Anders Carlssone65a3c82009-03-24 17:23:42 +00003655 }
John McCall94c3b562010-08-18 09:41:07 +00003656 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00003657
John McCall94c3b562010-08-18 09:41:07 +00003658 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3659 Visit(TL.getElementLoc(), Sema::AbstractArrayType);
3660 }
Mike Stump1eb44332009-09-09 15:08:12 +00003661
John McCall94c3b562010-08-18 09:41:07 +00003662 void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3663 // Visit the type parameters from a permissive context.
3664 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
3665 TemplateArgumentLoc TAL = TL.getArgLoc(I);
3666 if (TAL.getArgument().getKind() == TemplateArgument::Type)
3667 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
3668 Visit(TSI->getTypeLoc(), Sema::AbstractNone);
3669 // TODO: other template argument types?
Anders Carlsson8211eff2009-03-24 01:19:16 +00003670 }
John McCall94c3b562010-08-18 09:41:07 +00003671 }
Mike Stump1eb44332009-09-09 15:08:12 +00003672
John McCall94c3b562010-08-18 09:41:07 +00003673 // Visit pointee types from a permissive context.
3674#define CheckPolymorphic(Type) \
3675 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
3676 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
3677 }
3678 CheckPolymorphic(PointerTypeLoc)
3679 CheckPolymorphic(ReferenceTypeLoc)
3680 CheckPolymorphic(MemberPointerTypeLoc)
3681 CheckPolymorphic(BlockPointerTypeLoc)
Eli Friedmanb001de72011-10-06 23:00:33 +00003682 CheckPolymorphic(AtomicTypeLoc)
Mike Stump1eb44332009-09-09 15:08:12 +00003683
John McCall94c3b562010-08-18 09:41:07 +00003684 /// Handle all the types we haven't given a more specific
3685 /// implementation for above.
3686 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
3687 // Every other kind of type that we haven't called out already
3688 // that has an inner type is either (1) sugar or (2) contains that
3689 // inner type in some way as a subobject.
3690 if (TypeLoc Next = TL.getNextTypeLoc())
3691 return Visit(Next, Sel);
3692
3693 // If there's no inner type and we're in a permissive context,
3694 // don't diagnose.
3695 if (Sel == Sema::AbstractNone) return;
3696
3697 // Check whether the type matches the abstract type.
3698 QualType T = TL.getType();
3699 if (T->isArrayType()) {
3700 Sel = Sema::AbstractArrayType;
3701 T = Info.S.Context.getBaseElementType(T);
Anders Carlssone65a3c82009-03-24 17:23:42 +00003702 }
John McCall94c3b562010-08-18 09:41:07 +00003703 CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType();
3704 if (CT != Info.AbstractType) return;
3705
3706 // It matched; do some magic.
3707 if (Sel == Sema::AbstractArrayType) {
3708 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
3709 << T << TL.getSourceRange();
3710 } else {
3711 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
3712 << Sel << T << TL.getSourceRange();
3713 }
3714 Info.DiagnoseAbstractType();
3715 }
3716};
3717
3718void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
3719 Sema::AbstractDiagSelID Sel) {
3720 CheckAbstractUsage(*this, D).Visit(TL, Sel);
3721}
3722
3723}
3724
3725/// Check for invalid uses of an abstract type in a method declaration.
3726static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
3727 CXXMethodDecl *MD) {
3728 // No need to do the check on definitions, which require that
3729 // the return/param types be complete.
Sean Hunt10620eb2011-05-06 20:44:56 +00003730 if (MD->doesThisDeclarationHaveABody())
John McCall94c3b562010-08-18 09:41:07 +00003731 return;
3732
3733 // For safety's sake, just ignore it if we don't have type source
3734 // information. This should never happen for non-implicit methods,
3735 // but...
3736 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
3737 Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
3738}
3739
3740/// Check for invalid uses of an abstract type within a class definition.
3741static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
3742 CXXRecordDecl *RD) {
3743 for (CXXRecordDecl::decl_iterator
3744 I = RD->decls_begin(), E = RD->decls_end(); I != E; ++I) {
3745 Decl *D = *I;
3746 if (D->isImplicit()) continue;
3747
3748 // Methods and method templates.
3749 if (isa<CXXMethodDecl>(D)) {
3750 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
3751 } else if (isa<FunctionTemplateDecl>(D)) {
3752 FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
3753 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
3754
3755 // Fields and static variables.
3756 } else if (isa<FieldDecl>(D)) {
3757 FieldDecl *FD = cast<FieldDecl>(D);
3758 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
3759 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
3760 } else if (isa<VarDecl>(D)) {
3761 VarDecl *VD = cast<VarDecl>(D);
3762 if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
3763 Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
3764
3765 // Nested classes and class templates.
3766 } else if (isa<CXXRecordDecl>(D)) {
3767 CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
3768 } else if (isa<ClassTemplateDecl>(D)) {
3769 CheckAbstractClassUsage(Info,
3770 cast<ClassTemplateDecl>(D)->getTemplatedDecl());
3771 }
3772 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00003773}
3774
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003775/// \brief Perform semantic checks on a class definition that has been
3776/// completing, introducing implicitly-declared members, checking for
3777/// abstract types, etc.
Douglas Gregor23c94db2010-07-02 17:43:08 +00003778void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
Douglas Gregor7a39dd02010-09-29 00:15:42 +00003779 if (!Record)
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003780 return;
3781
John McCall94c3b562010-08-18 09:41:07 +00003782 if (Record->isAbstract() && !Record->isInvalidDecl()) {
3783 AbstractUsageInfo Info(*this, Record);
3784 CheckAbstractClassUsage(Info, Record);
3785 }
Douglas Gregor325e5932010-04-15 00:00:53 +00003786
3787 // If this is not an aggregate type and has no user-declared constructor,
3788 // complain about any non-static data members of reference or const scalar
3789 // type, since they will never get initializers.
3790 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
Douglas Gregor5e058eb2012-02-09 02:20:38 +00003791 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
3792 !Record->isLambda()) {
Douglas Gregor325e5932010-04-15 00:00:53 +00003793 bool Complained = false;
3794 for (RecordDecl::field_iterator F = Record->field_begin(),
3795 FEnd = Record->field_end();
3796 F != FEnd; ++F) {
Douglas Gregord61db332011-10-10 17:22:13 +00003797 if (F->hasInClassInitializer() || F->isUnnamedBitfield())
Richard Smith7a614d82011-06-11 17:19:42 +00003798 continue;
3799
Douglas Gregor325e5932010-04-15 00:00:53 +00003800 if (F->getType()->isReferenceType() ||
Benjamin Kramer1deea662010-04-16 17:43:15 +00003801 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
Douglas Gregor325e5932010-04-15 00:00:53 +00003802 if (!Complained) {
3803 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
3804 << Record->getTagKind() << Record;
3805 Complained = true;
3806 }
3807
3808 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
3809 << F->getType()->isReferenceType()
3810 << F->getDeclName();
3811 }
3812 }
3813 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +00003814
Anders Carlssona5c6c2a2011-01-25 18:08:22 +00003815 if (Record->isDynamicClass() && !Record->isDependentType())
Douglas Gregor6fb745b2010-05-13 16:44:06 +00003816 DynamicClasses.push_back(Record);
Douglas Gregora6e937c2010-10-15 13:21:21 +00003817
3818 if (Record->getIdentifier()) {
3819 // C++ [class.mem]p13:
3820 // If T is the name of a class, then each of the following shall have a
3821 // name different from T:
3822 // - every member of every anonymous union that is a member of class T.
3823 //
3824 // C++ [class.mem]p14:
3825 // In addition, if class T has a user-declared constructor (12.1), every
3826 // non-static data member of class T shall have a name different from T.
3827 for (DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
Francois Pichet87c2e122010-11-21 06:08:52 +00003828 R.first != R.second; ++R.first) {
3829 NamedDecl *D = *R.first;
3830 if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
3831 isa<IndirectFieldDecl>(D)) {
3832 Diag(D->getLocation(), diag::err_member_name_of_class)
3833 << D->getDeclName();
Douglas Gregora6e937c2010-10-15 13:21:21 +00003834 break;
3835 }
Francois Pichet87c2e122010-11-21 06:08:52 +00003836 }
Douglas Gregora6e937c2010-10-15 13:21:21 +00003837 }
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003838
Argyrios Kyrtzidis9641fc82011-01-31 17:10:25 +00003839 // Warn if the class has virtual methods but non-virtual public destructor.
Douglas Gregorf4b793c2011-02-19 19:14:36 +00003840 if (Record->isPolymorphic() && !Record->isDependentType()) {
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003841 CXXDestructorDecl *dtor = Record->getDestructor();
Argyrios Kyrtzidis9641fc82011-01-31 17:10:25 +00003842 if (!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public))
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003843 Diag(dtor ? dtor->getLocation() : Record->getLocation(),
3844 diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
3845 }
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003846
David Blaikieb6b5b972012-09-21 03:21:07 +00003847 if (Record->isAbstract() && Record->hasAttr<FinalAttr>()) {
3848 Diag(Record->getLocation(), diag::warn_abstract_final_class);
3849 DiagnoseAbstractType(Record);
3850 }
3851
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003852 // See if a method overloads virtual methods in a base
3853 /// class without overriding any.
3854 if (!Record->isDependentType()) {
3855 for (CXXRecordDecl::method_iterator M = Record->method_begin(),
3856 MEnd = Record->method_end();
3857 M != MEnd; ++M) {
David Blaikie262bc182012-04-30 02:36:29 +00003858 if (!M->isStatic())
David Blaikie581deb32012-06-06 20:45:41 +00003859 DiagnoseHiddenVirtualMethods(Record, *M);
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003860 }
3861 }
Sebastian Redlf677ea32011-02-05 19:23:19 +00003862
Richard Smith9f569cc2011-10-01 02:31:28 +00003863 // C++0x [dcl.constexpr]p8: A constexpr specifier for a non-static member
3864 // function that is not a constructor declares that member function to be
3865 // const. [...] The class of which that function is a member shall be
3866 // a literal type.
3867 //
Richard Smith9f569cc2011-10-01 02:31:28 +00003868 // If the class has virtual bases, any constexpr members will already have
3869 // been diagnosed by the checks performed on the member declaration, so
3870 // suppress this (less useful) diagnostic.
3871 if (LangOpts.CPlusPlus0x && !Record->isDependentType() &&
3872 !Record->isLiteral() && !Record->getNumVBases()) {
3873 for (CXXRecordDecl::method_iterator M = Record->method_begin(),
3874 MEnd = Record->method_end();
3875 M != MEnd; ++M) {
Richard Smith86c3ae42012-02-13 03:54:03 +00003876 if (M->isConstexpr() && M->isInstance() && !isa<CXXConstructorDecl>(*M)) {
Richard Smith9f569cc2011-10-01 02:31:28 +00003877 switch (Record->getTemplateSpecializationKind()) {
3878 case TSK_ImplicitInstantiation:
3879 case TSK_ExplicitInstantiationDeclaration:
3880 case TSK_ExplicitInstantiationDefinition:
3881 // If a template instantiates to a non-literal type, but its members
3882 // instantiate to constexpr functions, the template is technically
Richard Smith86c3ae42012-02-13 03:54:03 +00003883 // ill-formed, but we allow it for sanity.
Richard Smith9f569cc2011-10-01 02:31:28 +00003884 continue;
3885
3886 case TSK_Undeclared:
3887 case TSK_ExplicitSpecialization:
David Blaikie262bc182012-04-30 02:36:29 +00003888 RequireLiteralType(M->getLocation(), Context.getRecordType(Record),
Douglas Gregorf502d8e2012-05-04 16:48:41 +00003889 diag::err_constexpr_method_non_literal);
Richard Smith9f569cc2011-10-01 02:31:28 +00003890 break;
3891 }
3892
3893 // Only produce one error per class.
3894 break;
3895 }
3896 }
3897 }
3898
Sebastian Redlf677ea32011-02-05 19:23:19 +00003899 // Declare inherited constructors. We do this eagerly here because:
3900 // - The standard requires an eager diagnostic for conflicting inherited
3901 // constructors from different classes.
3902 // - The lazy declaration of the other implicit constructors is so as to not
3903 // waste space and performance on classes that are not meant to be
3904 // instantiated (e.g. meta-functions). This doesn't apply to classes that
3905 // have inherited constructors.
Sebastian Redlcaa35e42011-03-12 13:44:32 +00003906 DeclareInheritedConstructors(Record);
Sean Hunt001cad92011-05-10 00:49:42 +00003907}
3908
3909void Sema::CheckExplicitlyDefaultedMethods(CXXRecordDecl *Record) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00003910 for (CXXRecordDecl::method_iterator MI = Record->method_begin(),
3911 ME = Record->method_end();
Richard Smith3003e1d2012-05-15 04:39:51 +00003912 MI != ME; ++MI)
3913 if (!MI->isInvalidDecl() && MI->isExplicitlyDefaulted())
David Blaikie581deb32012-06-06 20:45:41 +00003914 CheckExplicitlyDefaultedSpecialMember(*MI);
Sean Hunt001cad92011-05-10 00:49:42 +00003915}
3916
Richard Smith7756afa2012-06-10 05:43:50 +00003917/// Is the special member function which would be selected to perform the
3918/// specified operation on the specified class type a constexpr constructor?
3919static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
3920 Sema::CXXSpecialMember CSM,
3921 bool ConstArg) {
3922 Sema::SpecialMemberOverloadResult *SMOR =
3923 S.LookupSpecialMember(ClassDecl, CSM, ConstArg,
3924 false, false, false, false);
3925 if (!SMOR || !SMOR->getMethod())
3926 // A constructor we wouldn't select can't be "involved in initializing"
3927 // anything.
3928 return true;
3929 return SMOR->getMethod()->isConstexpr();
3930}
3931
3932/// Determine whether the specified special member function would be constexpr
3933/// if it were implicitly defined.
3934static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
3935 Sema::CXXSpecialMember CSM,
3936 bool ConstArg) {
3937 if (!S.getLangOpts().CPlusPlus0x)
3938 return false;
3939
3940 // C++11 [dcl.constexpr]p4:
3941 // In the definition of a constexpr constructor [...]
3942 switch (CSM) {
3943 case Sema::CXXDefaultConstructor:
Richard Smithd3861ce2012-06-10 07:07:24 +00003944 // Since default constructor lookup is essentially trivial (and cannot
3945 // involve, for instance, template instantiation), we compute whether a
3946 // defaulted default constructor is constexpr directly within CXXRecordDecl.
3947 //
3948 // This is important for performance; we need to know whether the default
3949 // constructor is constexpr to determine whether the type is a literal type.
3950 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
3951
Richard Smith7756afa2012-06-10 05:43:50 +00003952 case Sema::CXXCopyConstructor:
3953 case Sema::CXXMoveConstructor:
Richard Smithd3861ce2012-06-10 07:07:24 +00003954 // For copy or move constructors, we need to perform overload resolution.
Richard Smith7756afa2012-06-10 05:43:50 +00003955 break;
3956
3957 case Sema::CXXCopyAssignment:
3958 case Sema::CXXMoveAssignment:
3959 case Sema::CXXDestructor:
3960 case Sema::CXXInvalid:
3961 return false;
3962 }
3963
3964 // -- if the class is a non-empty union, or for each non-empty anonymous
3965 // union member of a non-union class, exactly one non-static data member
3966 // shall be initialized; [DR1359]
Richard Smithd3861ce2012-06-10 07:07:24 +00003967 //
3968 // If we squint, this is guaranteed, since exactly one non-static data member
3969 // will be initialized (if the constructor isn't deleted), we just don't know
3970 // which one.
Richard Smith7756afa2012-06-10 05:43:50 +00003971 if (ClassDecl->isUnion())
Richard Smithd3861ce2012-06-10 07:07:24 +00003972 return true;
Richard Smith7756afa2012-06-10 05:43:50 +00003973
3974 // -- the class shall not have any virtual base classes;
3975 if (ClassDecl->getNumVBases())
3976 return false;
3977
3978 // -- every constructor involved in initializing [...] base class
3979 // sub-objects shall be a constexpr constructor;
3980 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
3981 BEnd = ClassDecl->bases_end();
3982 B != BEnd; ++B) {
3983 const RecordType *BaseType = B->getType()->getAs<RecordType>();
3984 if (!BaseType) continue;
3985
3986 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
3987 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, ConstArg))
3988 return false;
3989 }
3990
3991 // -- every constructor involved in initializing non-static data members
3992 // [...] shall be a constexpr constructor;
3993 // -- every non-static data member and base class sub-object shall be
3994 // initialized
3995 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
3996 FEnd = ClassDecl->field_end();
3997 F != FEnd; ++F) {
3998 if (F->isInvalidDecl())
3999 continue;
Richard Smithd3861ce2012-06-10 07:07:24 +00004000 if (const RecordType *RecordTy =
4001 S.Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
Richard Smith7756afa2012-06-10 05:43:50 +00004002 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
4003 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM, ConstArg))
4004 return false;
Richard Smith7756afa2012-06-10 05:43:50 +00004005 }
4006 }
4007
4008 // All OK, it's constexpr!
4009 return true;
4010}
4011
Richard Smithb9d0b762012-07-27 04:22:15 +00004012static Sema::ImplicitExceptionSpecification
4013computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) {
4014 switch (S.getSpecialMember(MD)) {
4015 case Sema::CXXDefaultConstructor:
4016 return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD);
4017 case Sema::CXXCopyConstructor:
4018 return S.ComputeDefaultedCopyCtorExceptionSpec(MD);
4019 case Sema::CXXCopyAssignment:
4020 return S.ComputeDefaultedCopyAssignmentExceptionSpec(MD);
4021 case Sema::CXXMoveConstructor:
4022 return S.ComputeDefaultedMoveCtorExceptionSpec(MD);
4023 case Sema::CXXMoveAssignment:
4024 return S.ComputeDefaultedMoveAssignmentExceptionSpec(MD);
4025 case Sema::CXXDestructor:
4026 return S.ComputeDefaultedDtorExceptionSpec(MD);
4027 case Sema::CXXInvalid:
4028 break;
4029 }
4030 llvm_unreachable("only special members have implicit exception specs");
4031}
4032
Richard Smithdd25e802012-07-30 23:48:14 +00004033static void
4034updateExceptionSpec(Sema &S, FunctionDecl *FD, const FunctionProtoType *FPT,
4035 const Sema::ImplicitExceptionSpecification &ExceptSpec) {
4036 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
4037 ExceptSpec.getEPI(EPI);
4038 const FunctionProtoType *NewFPT = cast<FunctionProtoType>(
4039 S.Context.getFunctionType(FPT->getResultType(), FPT->arg_type_begin(),
4040 FPT->getNumArgs(), EPI));
4041 FD->setType(QualType(NewFPT, 0));
4042}
4043
Richard Smithb9d0b762012-07-27 04:22:15 +00004044void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
4045 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
4046 if (FPT->getExceptionSpecType() != EST_Unevaluated)
4047 return;
4048
Richard Smithdd25e802012-07-30 23:48:14 +00004049 // Evaluate the exception specification.
4050 ImplicitExceptionSpecification ExceptSpec =
4051 computeImplicitExceptionSpec(*this, Loc, MD);
4052
4053 // Update the type of the special member to use it.
4054 updateExceptionSpec(*this, MD, FPT, ExceptSpec);
4055
4056 // A user-provided destructor can be defined outside the class. When that
4057 // happens, be sure to update the exception specification on both
4058 // declarations.
4059 const FunctionProtoType *CanonicalFPT =
4060 MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>();
4061 if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
4062 updateExceptionSpec(*this, MD->getCanonicalDecl(),
4063 CanonicalFPT, ExceptSpec);
Richard Smithb9d0b762012-07-27 04:22:15 +00004064}
4065
4066static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl);
4067static bool isImplicitCopyAssignmentArgConst(Sema &S, CXXRecordDecl *ClassDecl);
4068
Richard Smith3003e1d2012-05-15 04:39:51 +00004069void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
4070 CXXRecordDecl *RD = MD->getParent();
4071 CXXSpecialMember CSM = getSpecialMember(MD);
Sean Hunt001cad92011-05-10 00:49:42 +00004072
Richard Smith3003e1d2012-05-15 04:39:51 +00004073 assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
4074 "not an explicitly-defaulted special member");
Sean Hunt49634cf2011-05-13 06:10:58 +00004075
4076 // Whether this was the first-declared instance of the constructor.
Richard Smith3003e1d2012-05-15 04:39:51 +00004077 // This affects whether we implicitly add an exception spec and constexpr.
Sean Hunt2b188082011-05-14 05:23:28 +00004078 bool First = MD == MD->getCanonicalDecl();
4079
4080 bool HadError = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004081
4082 // C++11 [dcl.fct.def.default]p1:
4083 // A function that is explicitly defaulted shall
4084 // -- be a special member function (checked elsewhere),
4085 // -- have the same type (except for ref-qualifiers, and except that a
4086 // copy operation can take a non-const reference) as an implicit
4087 // declaration, and
4088 // -- not have default arguments.
4089 unsigned ExpectedParams = 1;
4090 if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
4091 ExpectedParams = 0;
4092 if (MD->getNumParams() != ExpectedParams) {
4093 // This also checks for default arguments: a copy or move constructor with a
4094 // default argument is classified as a default constructor, and assignment
4095 // operations and destructors can't have default arguments.
4096 Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
4097 << CSM << MD->getSourceRange();
Sean Hunt2b188082011-05-14 05:23:28 +00004098 HadError = true;
4099 }
4100
Richard Smith3003e1d2012-05-15 04:39:51 +00004101 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
Sean Hunt2b188082011-05-14 05:23:28 +00004102
Richard Smithb9d0b762012-07-27 04:22:15 +00004103 // Compute argument constness, constexpr, and triviality.
Richard Smith7756afa2012-06-10 05:43:50 +00004104 bool CanHaveConstParam = false;
Axel Naumann8f411c32012-09-17 14:26:53 +00004105 bool Trivial = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004106 switch (CSM) {
4107 case CXXDefaultConstructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004108 Trivial = RD->hasTrivialDefaultConstructor();
4109 break;
4110 case CXXCopyConstructor:
Richard Smithb9d0b762012-07-27 04:22:15 +00004111 CanHaveConstParam = isImplicitCopyCtorArgConst(*this, RD);
Richard Smith3003e1d2012-05-15 04:39:51 +00004112 Trivial = RD->hasTrivialCopyConstructor();
4113 break;
4114 case CXXCopyAssignment:
Richard Smithb9d0b762012-07-27 04:22:15 +00004115 CanHaveConstParam = isImplicitCopyAssignmentArgConst(*this, RD);
Richard Smith3003e1d2012-05-15 04:39:51 +00004116 Trivial = RD->hasTrivialCopyAssignment();
4117 break;
4118 case CXXMoveConstructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004119 Trivial = RD->hasTrivialMoveConstructor();
4120 break;
4121 case CXXMoveAssignment:
Richard Smith3003e1d2012-05-15 04:39:51 +00004122 Trivial = RD->hasTrivialMoveAssignment();
4123 break;
4124 case CXXDestructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004125 Trivial = RD->hasTrivialDestructor();
4126 break;
4127 case CXXInvalid:
4128 llvm_unreachable("non-special member explicitly defaulted!");
4129 }
Sean Hunt2b188082011-05-14 05:23:28 +00004130
Richard Smith3003e1d2012-05-15 04:39:51 +00004131 QualType ReturnType = Context.VoidTy;
4132 if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
4133 // Check for return type matching.
4134 ReturnType = Type->getResultType();
4135 QualType ExpectedReturnType =
4136 Context.getLValueReferenceType(Context.getTypeDeclType(RD));
4137 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
4138 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
4139 << (CSM == CXXMoveAssignment) << ExpectedReturnType;
4140 HadError = true;
4141 }
4142
4143 // A defaulted special member cannot have cv-qualifiers.
4144 if (Type->getTypeQuals()) {
4145 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
4146 << (CSM == CXXMoveAssignment);
4147 HadError = true;
4148 }
4149 }
4150
4151 // Check for parameter type matching.
4152 QualType ArgType = ExpectedParams ? Type->getArgType(0) : QualType();
Richard Smith7756afa2012-06-10 05:43:50 +00004153 bool HasConstParam = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004154 if (ExpectedParams && ArgType->isReferenceType()) {
4155 // Argument must be reference to possibly-const T.
4156 QualType ReferentType = ArgType->getPointeeType();
Richard Smith7756afa2012-06-10 05:43:50 +00004157 HasConstParam = ReferentType.isConstQualified();
Richard Smith3003e1d2012-05-15 04:39:51 +00004158
4159 if (ReferentType.isVolatileQualified()) {
4160 Diag(MD->getLocation(),
4161 diag::err_defaulted_special_member_volatile_param) << CSM;
4162 HadError = true;
4163 }
4164
Richard Smith7756afa2012-06-10 05:43:50 +00004165 if (HasConstParam && !CanHaveConstParam) {
Richard Smith3003e1d2012-05-15 04:39:51 +00004166 if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
4167 Diag(MD->getLocation(),
4168 diag::err_defaulted_special_member_copy_const_param)
4169 << (CSM == CXXCopyAssignment);
4170 // FIXME: Explain why this special member can't be const.
4171 } else {
4172 Diag(MD->getLocation(),
4173 diag::err_defaulted_special_member_move_const_param)
4174 << (CSM == CXXMoveAssignment);
4175 }
4176 HadError = true;
4177 }
4178
4179 // If a function is explicitly defaulted on its first declaration, it shall
4180 // have the same parameter type as if it had been implicitly declared.
4181 // (Presumably this is to prevent it from being trivial?)
Richard Smith7756afa2012-06-10 05:43:50 +00004182 if (!HasConstParam && CanHaveConstParam && First)
Richard Smith3003e1d2012-05-15 04:39:51 +00004183 Diag(MD->getLocation(),
4184 diag::err_defaulted_special_member_copy_non_const_param)
4185 << (CSM == CXXCopyAssignment);
4186 } else if (ExpectedParams) {
4187 // A copy assignment operator can take its argument by value, but a
4188 // defaulted one cannot.
4189 assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
Sean Huntbe631222011-05-17 20:44:43 +00004190 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
Sean Hunt2b188082011-05-14 05:23:28 +00004191 HadError = true;
4192 }
Sean Huntbe631222011-05-17 20:44:43 +00004193
Richard Smithb9d0b762012-07-27 04:22:15 +00004194 // Rebuild the type with the implicit exception specification added, if we
4195 // are going to need it.
4196 const FunctionProtoType *ImplicitType = 0;
4197 if (First || Type->hasExceptionSpec()) {
4198 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
4199 computeImplicitExceptionSpec(*this, MD->getLocation(), MD).getEPI(EPI);
4200 ImplicitType = cast<FunctionProtoType>(
4201 Context.getFunctionType(ReturnType, &ArgType, ExpectedParams, EPI));
4202 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004203
Richard Smith61802452011-12-22 02:22:31 +00004204 // C++11 [dcl.fct.def.default]p2:
4205 // An explicitly-defaulted function may be declared constexpr only if it
4206 // would have been implicitly declared as constexpr,
Richard Smith3003e1d2012-05-15 04:39:51 +00004207 // Do not apply this rule to members of class templates, since core issue 1358
4208 // makes such functions always instantiate to constexpr functions. For
4209 // non-constructors, this is checked elsewhere.
Richard Smith7756afa2012-06-10 05:43:50 +00004210 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
4211 HasConstParam);
Richard Smith3003e1d2012-05-15 04:39:51 +00004212 if (isa<CXXConstructorDecl>(MD) && MD->isConstexpr() && !Constexpr &&
4213 MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
4214 Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
Richard Smith7756afa2012-06-10 05:43:50 +00004215 // FIXME: Explain why the constructor can't be constexpr.
Richard Smith3003e1d2012-05-15 04:39:51 +00004216 HadError = true;
Richard Smith61802452011-12-22 02:22:31 +00004217 }
4218 // and may have an explicit exception-specification only if it is compatible
4219 // with the exception-specification on the implicit declaration.
Richard Smith3003e1d2012-05-15 04:39:51 +00004220 if (Type->hasExceptionSpec() &&
4221 CheckEquivalentExceptionSpec(
4222 PDiag(diag::err_incorrect_defaulted_exception_spec) << CSM,
4223 PDiag(), ImplicitType, SourceLocation(), Type, MD->getLocation()))
4224 HadError = true;
Richard Smith61802452011-12-22 02:22:31 +00004225
4226 // If a function is explicitly defaulted on its first declaration,
4227 if (First) {
4228 // -- it is implicitly considered to be constexpr if the implicit
4229 // definition would be,
Richard Smith3003e1d2012-05-15 04:39:51 +00004230 MD->setConstexpr(Constexpr);
Richard Smith61802452011-12-22 02:22:31 +00004231
Richard Smith3003e1d2012-05-15 04:39:51 +00004232 // -- it is implicitly considered to have the same exception-specification
4233 // as if it had been implicitly declared,
4234 MD->setType(QualType(ImplicitType, 0));
Richard Smithe653ba22012-02-26 00:31:33 +00004235
4236 // Such a function is also trivial if the implicitly-declared function
4237 // would have been.
Richard Smith3003e1d2012-05-15 04:39:51 +00004238 MD->setTrivial(Trivial);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004239 }
4240
Richard Smith3003e1d2012-05-15 04:39:51 +00004241 if (ShouldDeleteSpecialMember(MD, CSM)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004242 if (First) {
4243 MD->setDeletedAsWritten();
4244 } else {
Richard Smith3003e1d2012-05-15 04:39:51 +00004245 // C++11 [dcl.fct.def.default]p4:
4246 // [For a] user-provided explicitly-defaulted function [...] if such a
4247 // function is implicitly defined as deleted, the program is ill-formed.
4248 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
4249 HadError = true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004250 }
4251 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004252
Richard Smith3003e1d2012-05-15 04:39:51 +00004253 if (HadError)
4254 MD->setInvalidDecl();
Sean Huntcb45a0f2011-05-12 22:46:25 +00004255}
4256
Richard Smith7d5088a2012-02-18 02:02:13 +00004257namespace {
4258struct SpecialMemberDeletionInfo {
4259 Sema &S;
4260 CXXMethodDecl *MD;
4261 Sema::CXXSpecialMember CSM;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004262 bool Diagnose;
Richard Smith7d5088a2012-02-18 02:02:13 +00004263
4264 // Properties of the special member, computed for convenience.
4265 bool IsConstructor, IsAssignment, IsMove, ConstArg, VolatileArg;
4266 SourceLocation Loc;
4267
4268 bool AllFieldsAreConst;
4269
4270 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
Richard Smith6c4c36c2012-03-30 20:53:28 +00004271 Sema::CXXSpecialMember CSM, bool Diagnose)
4272 : S(S), MD(MD), CSM(CSM), Diagnose(Diagnose),
Richard Smith7d5088a2012-02-18 02:02:13 +00004273 IsConstructor(false), IsAssignment(false), IsMove(false),
4274 ConstArg(false), VolatileArg(false), Loc(MD->getLocation()),
4275 AllFieldsAreConst(true) {
4276 switch (CSM) {
4277 case Sema::CXXDefaultConstructor:
4278 case Sema::CXXCopyConstructor:
4279 IsConstructor = true;
4280 break;
4281 case Sema::CXXMoveConstructor:
4282 IsConstructor = true;
4283 IsMove = true;
4284 break;
4285 case Sema::CXXCopyAssignment:
4286 IsAssignment = true;
4287 break;
4288 case Sema::CXXMoveAssignment:
4289 IsAssignment = true;
4290 IsMove = true;
4291 break;
4292 case Sema::CXXDestructor:
4293 break;
4294 case Sema::CXXInvalid:
4295 llvm_unreachable("invalid special member kind");
4296 }
4297
4298 if (MD->getNumParams()) {
4299 ConstArg = MD->getParamDecl(0)->getType().isConstQualified();
4300 VolatileArg = MD->getParamDecl(0)->getType().isVolatileQualified();
4301 }
4302 }
4303
4304 bool inUnion() const { return MD->getParent()->isUnion(); }
4305
4306 /// Look up the corresponding special member in the given class.
Richard Smith517bb842012-07-18 03:51:16 +00004307 Sema::SpecialMemberOverloadResult *lookupIn(CXXRecordDecl *Class,
4308 unsigned Quals) {
Richard Smith7d5088a2012-02-18 02:02:13 +00004309 unsigned TQ = MD->getTypeQualifiers();
Richard Smith517bb842012-07-18 03:51:16 +00004310 // cv-qualifiers on class members don't affect default ctor / dtor calls.
4311 if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
4312 Quals = 0;
4313 return S.LookupSpecialMember(Class, CSM,
4314 ConstArg || (Quals & Qualifiers::Const),
4315 VolatileArg || (Quals & Qualifiers::Volatile),
Richard Smith7d5088a2012-02-18 02:02:13 +00004316 MD->getRefQualifier() == RQ_RValue,
4317 TQ & Qualifiers::Const,
4318 TQ & Qualifiers::Volatile);
4319 }
4320
Richard Smith6c4c36c2012-03-30 20:53:28 +00004321 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
Richard Smith9a561d52012-02-26 09:11:52 +00004322
Richard Smith6c4c36c2012-03-30 20:53:28 +00004323 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
Richard Smith7d5088a2012-02-18 02:02:13 +00004324 bool shouldDeleteForField(FieldDecl *FD);
4325 bool shouldDeleteForAllConstMembers();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004326
Richard Smith517bb842012-07-18 03:51:16 +00004327 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
4328 unsigned Quals);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004329 bool shouldDeleteForSubobjectCall(Subobject Subobj,
4330 Sema::SpecialMemberOverloadResult *SMOR,
4331 bool IsDtorCallInCtor);
John McCall12d8d802012-04-09 20:53:23 +00004332
4333 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
Richard Smith7d5088a2012-02-18 02:02:13 +00004334};
4335}
4336
John McCall12d8d802012-04-09 20:53:23 +00004337/// Is the given special member inaccessible when used on the given
4338/// sub-object.
4339bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
4340 CXXMethodDecl *target) {
4341 /// If we're operating on a base class, the object type is the
4342 /// type of this special member.
4343 QualType objectTy;
Dmitri Gribenko1ad23d62012-09-10 21:20:09 +00004344 AccessSpecifier access = target->getAccess();
John McCall12d8d802012-04-09 20:53:23 +00004345 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
4346 objectTy = S.Context.getTypeDeclType(MD->getParent());
4347 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
4348
4349 // If we're operating on a field, the object type is the type of the field.
4350 } else {
4351 objectTy = S.Context.getTypeDeclType(target->getParent());
4352 }
4353
4354 return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
4355}
4356
Richard Smith6c4c36c2012-03-30 20:53:28 +00004357/// Check whether we should delete a special member due to the implicit
4358/// definition containing a call to a special member of a subobject.
4359bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
4360 Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR,
4361 bool IsDtorCallInCtor) {
4362 CXXMethodDecl *Decl = SMOR->getMethod();
4363 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
4364
4365 int DiagKind = -1;
4366
4367 if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)
4368 DiagKind = !Decl ? 0 : 1;
4369 else if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
4370 DiagKind = 2;
John McCall12d8d802012-04-09 20:53:23 +00004371 else if (!isAccessible(Subobj, Decl))
Richard Smith6c4c36c2012-03-30 20:53:28 +00004372 DiagKind = 3;
4373 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
4374 !Decl->isTrivial()) {
4375 // A member of a union must have a trivial corresponding special member.
4376 // As a weird special case, a destructor call from a union's constructor
4377 // must be accessible and non-deleted, but need not be trivial. Such a
4378 // destructor is never actually called, but is semantically checked as
4379 // if it were.
4380 DiagKind = 4;
4381 }
4382
4383 if (DiagKind == -1)
4384 return false;
4385
4386 if (Diagnose) {
4387 if (Field) {
4388 S.Diag(Field->getLocation(),
4389 diag::note_deleted_special_member_class_subobject)
4390 << CSM << MD->getParent() << /*IsField*/true
4391 << Field << DiagKind << IsDtorCallInCtor;
4392 } else {
4393 CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
4394 S.Diag(Base->getLocStart(),
4395 diag::note_deleted_special_member_class_subobject)
4396 << CSM << MD->getParent() << /*IsField*/false
4397 << Base->getType() << DiagKind << IsDtorCallInCtor;
4398 }
4399
4400 if (DiagKind == 1)
4401 S.NoteDeletedFunction(Decl);
4402 // FIXME: Explain inaccessibility if DiagKind == 3.
4403 }
4404
4405 return true;
4406}
4407
Richard Smith9a561d52012-02-26 09:11:52 +00004408/// Check whether we should delete a special member function due to having a
Richard Smith517bb842012-07-18 03:51:16 +00004409/// direct or virtual base class or non-static data member of class type M.
Richard Smith9a561d52012-02-26 09:11:52 +00004410bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
Richard Smith517bb842012-07-18 03:51:16 +00004411 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00004412 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
Richard Smith7d5088a2012-02-18 02:02:13 +00004413
4414 // C++11 [class.ctor]p5:
Richard Smithdf8dc862012-03-29 19:00:10 +00004415 // -- any direct or virtual base class, or non-static data member with no
4416 // brace-or-equal-initializer, has class type M (or array thereof) and
Richard Smith7d5088a2012-02-18 02:02:13 +00004417 // either M has no default constructor or overload resolution as applied
4418 // to M's default constructor results in an ambiguity or in a function
4419 // that is deleted or inaccessible
4420 // C++11 [class.copy]p11, C++11 [class.copy]p23:
4421 // -- a direct or virtual base class B that cannot be copied/moved because
4422 // overload resolution, as applied to B's corresponding special member,
4423 // results in an ambiguity or a function that is deleted or inaccessible
4424 // from the defaulted special member
Richard Smith6c4c36c2012-03-30 20:53:28 +00004425 // C++11 [class.dtor]p5:
4426 // -- any direct or virtual base class [...] has a type with a destructor
4427 // that is deleted or inaccessible
4428 if (!(CSM == Sema::CXXDefaultConstructor &&
Richard Smith1c931be2012-04-02 18:40:40 +00004429 Field && Field->hasInClassInitializer()) &&
Richard Smith517bb842012-07-18 03:51:16 +00004430 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals), false))
Richard Smith1c931be2012-04-02 18:40:40 +00004431 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004432
Richard Smith6c4c36c2012-03-30 20:53:28 +00004433 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
4434 // -- any direct or virtual base class or non-static data member has a
4435 // type with a destructor that is deleted or inaccessible
4436 if (IsConstructor) {
4437 Sema::SpecialMemberOverloadResult *SMOR =
4438 S.LookupSpecialMember(Class, Sema::CXXDestructor,
4439 false, false, false, false, false);
4440 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
4441 return true;
4442 }
4443
Richard Smith9a561d52012-02-26 09:11:52 +00004444 return false;
4445}
4446
4447/// Check whether we should delete a special member function due to the class
4448/// having a particular direct or virtual base class.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004449bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
Richard Smith1c931be2012-04-02 18:40:40 +00004450 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
Richard Smith517bb842012-07-18 03:51:16 +00004451 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
Richard Smith7d5088a2012-02-18 02:02:13 +00004452}
4453
4454/// Check whether we should delete a special member function due to the class
4455/// having a particular non-static data member.
4456bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
4457 QualType FieldType = S.Context.getBaseElementType(FD->getType());
4458 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
4459
4460 if (CSM == Sema::CXXDefaultConstructor) {
4461 // For a default constructor, all references must be initialized in-class
4462 // and, if a union, it must have a non-const member.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004463 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
4464 if (Diagnose)
4465 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
4466 << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smith7d5088a2012-02-18 02:02:13 +00004467 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004468 }
Richard Smith79363f52012-02-27 06:07:25 +00004469 // C++11 [class.ctor]p5: any non-variant non-static data member of
4470 // const-qualified type (or array thereof) with no
4471 // brace-or-equal-initializer does not have a user-provided default
4472 // constructor.
4473 if (!inUnion() && FieldType.isConstQualified() &&
4474 !FD->hasInClassInitializer() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004475 (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
4476 if (Diagnose)
4477 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
Richard Smitha2e76f52012-04-29 06:32:34 +00004478 << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith79363f52012-02-27 06:07:25 +00004479 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004480 }
4481
4482 if (inUnion() && !FieldType.isConstQualified())
4483 AllFieldsAreConst = false;
Richard Smith7d5088a2012-02-18 02:02:13 +00004484 } else if (CSM == Sema::CXXCopyConstructor) {
4485 // For a copy constructor, data members must not be of rvalue reference
4486 // type.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004487 if (FieldType->isRValueReferenceType()) {
4488 if (Diagnose)
4489 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
4490 << MD->getParent() << FD << FieldType;
Richard Smith7d5088a2012-02-18 02:02:13 +00004491 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004492 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004493 } else if (IsAssignment) {
4494 // For an assignment operator, data members must not be of reference type.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004495 if (FieldType->isReferenceType()) {
4496 if (Diagnose)
4497 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
4498 << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smith7d5088a2012-02-18 02:02:13 +00004499 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004500 }
4501 if (!FieldRecord && FieldType.isConstQualified()) {
4502 // C++11 [class.copy]p23:
4503 // -- a non-static data member of const non-class type (or array thereof)
4504 if (Diagnose)
4505 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
Richard Smitha2e76f52012-04-29 06:32:34 +00004506 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004507 return true;
4508 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004509 }
4510
4511 if (FieldRecord) {
Richard Smith7d5088a2012-02-18 02:02:13 +00004512 // Some additional restrictions exist on the variant members.
4513 if (!inUnion() && FieldRecord->isUnion() &&
4514 FieldRecord->isAnonymousStructOrUnion()) {
4515 bool AllVariantFieldsAreConst = true;
4516
Richard Smithdf8dc862012-03-29 19:00:10 +00004517 // FIXME: Handle anonymous unions declared within anonymous unions.
Richard Smith7d5088a2012-02-18 02:02:13 +00004518 for (CXXRecordDecl::field_iterator UI = FieldRecord->field_begin(),
4519 UE = FieldRecord->field_end();
4520 UI != UE; ++UI) {
4521 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
Richard Smith7d5088a2012-02-18 02:02:13 +00004522
4523 if (!UnionFieldType.isConstQualified())
4524 AllVariantFieldsAreConst = false;
4525
Richard Smith9a561d52012-02-26 09:11:52 +00004526 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
4527 if (UnionFieldRecord &&
Richard Smith517bb842012-07-18 03:51:16 +00004528 shouldDeleteForClassSubobject(UnionFieldRecord, *UI,
4529 UnionFieldType.getCVRQualifiers()))
Richard Smith9a561d52012-02-26 09:11:52 +00004530 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004531 }
4532
4533 // At least one member in each anonymous union must be non-const
Douglas Gregor221c27f2012-02-24 21:25:53 +00004534 if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004535 FieldRecord->field_begin() != FieldRecord->field_end()) {
4536 if (Diagnose)
4537 S.Diag(FieldRecord->getLocation(),
4538 diag::note_deleted_default_ctor_all_const)
4539 << MD->getParent() << /*anonymous union*/1;
Richard Smith7d5088a2012-02-18 02:02:13 +00004540 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004541 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004542
Richard Smithdf8dc862012-03-29 19:00:10 +00004543 // Don't check the implicit member of the anonymous union type.
Richard Smith7d5088a2012-02-18 02:02:13 +00004544 // This is technically non-conformant, but sanity demands it.
4545 return false;
4546 }
4547
Richard Smith517bb842012-07-18 03:51:16 +00004548 if (shouldDeleteForClassSubobject(FieldRecord, FD,
4549 FieldType.getCVRQualifiers()))
Richard Smithdf8dc862012-03-29 19:00:10 +00004550 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004551 }
4552
4553 return false;
4554}
4555
4556/// C++11 [class.ctor] p5:
4557/// A defaulted default constructor for a class X is defined as deleted if
4558/// X is a union and all of its variant members are of const-qualified type.
4559bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
Douglas Gregor221c27f2012-02-24 21:25:53 +00004560 // This is a silly definition, because it gives an empty union a deleted
4561 // default constructor. Don't do that.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004562 if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst &&
4563 (MD->getParent()->field_begin() != MD->getParent()->field_end())) {
4564 if (Diagnose)
4565 S.Diag(MD->getParent()->getLocation(),
4566 diag::note_deleted_default_ctor_all_const)
4567 << MD->getParent() << /*not anonymous union*/0;
4568 return true;
4569 }
4570 return false;
Richard Smith7d5088a2012-02-18 02:02:13 +00004571}
4572
4573/// Determine whether a defaulted special member function should be defined as
4574/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
4575/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004576bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
4577 bool Diagnose) {
Richard Smitheef00292012-08-06 02:25:10 +00004578 if (MD->isInvalidDecl())
4579 return false;
Sean Hunte16da072011-10-10 06:18:57 +00004580 CXXRecordDecl *RD = MD->getParent();
Sean Huntcdee3fe2011-05-11 22:34:38 +00004581 assert(!RD->isDependentType() && "do deletion after instantiation");
Abramo Bagnaracdb80762011-07-11 08:52:40 +00004582 if (!LangOpts.CPlusPlus0x || RD->isInvalidDecl())
Sean Huntcdee3fe2011-05-11 22:34:38 +00004583 return false;
4584
Richard Smith7d5088a2012-02-18 02:02:13 +00004585 // C++11 [expr.lambda.prim]p19:
4586 // The closure type associated with a lambda-expression has a
4587 // deleted (8.4.3) default constructor and a deleted copy
4588 // assignment operator.
4589 if (RD->isLambda() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004590 (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
4591 if (Diagnose)
4592 Diag(RD->getLocation(), diag::note_lambda_decl);
Richard Smith7d5088a2012-02-18 02:02:13 +00004593 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004594 }
4595
Richard Smith5bdaac52012-04-02 20:59:25 +00004596 // For an anonymous struct or union, the copy and assignment special members
4597 // will never be used, so skip the check. For an anonymous union declared at
4598 // namespace scope, the constructor and destructor are used.
4599 if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
4600 RD->isAnonymousStructOrUnion())
4601 return false;
4602
Richard Smith6c4c36c2012-03-30 20:53:28 +00004603 // C++11 [class.copy]p7, p18:
4604 // If the class definition declares a move constructor or move assignment
4605 // operator, an implicitly declared copy constructor or copy assignment
4606 // operator is defined as deleted.
4607 if (MD->isImplicit() &&
4608 (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
4609 CXXMethodDecl *UserDeclaredMove = 0;
4610
4611 // In Microsoft mode, a user-declared move only causes the deletion of the
4612 // corresponding copy operation, not both copy operations.
4613 if (RD->hasUserDeclaredMoveConstructor() &&
4614 (!getLangOpts().MicrosoftMode || CSM == CXXCopyConstructor)) {
4615 if (!Diagnose) return true;
4616 UserDeclaredMove = RD->getMoveConstructor();
Richard Smith1c931be2012-04-02 18:40:40 +00004617 assert(UserDeclaredMove);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004618 } else if (RD->hasUserDeclaredMoveAssignment() &&
4619 (!getLangOpts().MicrosoftMode || CSM == CXXCopyAssignment)) {
4620 if (!Diagnose) return true;
4621 UserDeclaredMove = RD->getMoveAssignmentOperator();
Richard Smith1c931be2012-04-02 18:40:40 +00004622 assert(UserDeclaredMove);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004623 }
4624
4625 if (UserDeclaredMove) {
4626 Diag(UserDeclaredMove->getLocation(),
4627 diag::note_deleted_copy_user_declared_move)
Richard Smithe6af6602012-04-02 21:07:48 +00004628 << (CSM == CXXCopyAssignment) << RD
Richard Smith6c4c36c2012-03-30 20:53:28 +00004629 << UserDeclaredMove->isMoveAssignmentOperator();
4630 return true;
4631 }
4632 }
Sean Hunte16da072011-10-10 06:18:57 +00004633
Richard Smith5bdaac52012-04-02 20:59:25 +00004634 // Do access control from the special member function
4635 ContextRAII MethodContext(*this, MD);
4636
Richard Smith9a561d52012-02-26 09:11:52 +00004637 // C++11 [class.dtor]p5:
4638 // -- for a virtual destructor, lookup of the non-array deallocation function
4639 // results in an ambiguity or in a function that is deleted or inaccessible
Richard Smith6c4c36c2012-03-30 20:53:28 +00004640 if (CSM == CXXDestructor && MD->isVirtual()) {
Richard Smith9a561d52012-02-26 09:11:52 +00004641 FunctionDecl *OperatorDelete = 0;
4642 DeclarationName Name =
4643 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
4644 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
Richard Smith6c4c36c2012-03-30 20:53:28 +00004645 OperatorDelete, false)) {
4646 if (Diagnose)
4647 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
Richard Smith9a561d52012-02-26 09:11:52 +00004648 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004649 }
Richard Smith9a561d52012-02-26 09:11:52 +00004650 }
4651
Richard Smith6c4c36c2012-03-30 20:53:28 +00004652 SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose);
Sean Huntcdee3fe2011-05-11 22:34:38 +00004653
Sean Huntcdee3fe2011-05-11 22:34:38 +00004654 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004655 BE = RD->bases_end(); BI != BE; ++BI)
4656 if (!BI->isVirtual() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004657 SMI.shouldDeleteForBase(BI))
Richard Smith7d5088a2012-02-18 02:02:13 +00004658 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004659
4660 for (CXXRecordDecl::base_class_iterator BI = RD->vbases_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004661 BE = RD->vbases_end(); BI != BE; ++BI)
Richard Smith6c4c36c2012-03-30 20:53:28 +00004662 if (SMI.shouldDeleteForBase(BI))
Richard Smith7d5088a2012-02-18 02:02:13 +00004663 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004664
4665 for (CXXRecordDecl::field_iterator FI = RD->field_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004666 FE = RD->field_end(); FI != FE; ++FI)
4667 if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() &&
David Blaikie581deb32012-06-06 20:45:41 +00004668 SMI.shouldDeleteForField(*FI))
Sean Hunte3406822011-05-20 21:43:47 +00004669 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004670
Richard Smith7d5088a2012-02-18 02:02:13 +00004671 if (SMI.shouldDeleteForAllConstMembers())
Sean Huntcdee3fe2011-05-11 22:34:38 +00004672 return true;
4673
4674 return false;
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004675}
4676
4677/// \brief Data used with FindHiddenVirtualMethod
Benjamin Kramerc54061a2011-03-04 13:12:48 +00004678namespace {
4679 struct FindHiddenVirtualMethodData {
4680 Sema *S;
4681 CXXMethodDecl *Method;
4682 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004683 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
Benjamin Kramerc54061a2011-03-04 13:12:48 +00004684 };
4685}
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004686
4687/// \brief Member lookup function that determines whether a given C++
4688/// method overloads virtual methods in a base class without overriding any,
4689/// to be used with CXXRecordDecl::lookupInBases().
4690static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier,
4691 CXXBasePath &Path,
4692 void *UserData) {
4693 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
4694
4695 FindHiddenVirtualMethodData &Data
4696 = *static_cast<FindHiddenVirtualMethodData*>(UserData);
4697
4698 DeclarationName Name = Data.Method->getDeclName();
4699 assert(Name.getNameKind() == DeclarationName::Identifier);
4700
4701 bool foundSameNameMethod = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004702 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004703 for (Path.Decls = BaseRecord->lookup(Name);
4704 Path.Decls.first != Path.Decls.second;
4705 ++Path.Decls.first) {
4706 NamedDecl *D = *Path.Decls.first;
4707 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004708 MD = MD->getCanonicalDecl();
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004709 foundSameNameMethod = true;
4710 // Interested only in hidden virtual methods.
4711 if (!MD->isVirtual())
4712 continue;
4713 // If the method we are checking overrides a method from its base
4714 // don't warn about the other overloaded methods.
4715 if (!Data.S->IsOverload(Data.Method, MD, false))
4716 return true;
4717 // Collect the overload only if its hidden.
4718 if (!Data.OverridenAndUsingBaseMethods.count(MD))
4719 overloadedMethods.push_back(MD);
4720 }
4721 }
4722
4723 if (foundSameNameMethod)
4724 Data.OverloadedMethods.append(overloadedMethods.begin(),
4725 overloadedMethods.end());
4726 return foundSameNameMethod;
4727}
4728
4729/// \brief See if a method overloads virtual methods in a base class without
4730/// overriding any.
4731void Sema::DiagnoseHiddenVirtualMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
4732 if (Diags.getDiagnosticLevel(diag::warn_overloaded_virtual,
David Blaikied6471f72011-09-25 23:23:43 +00004733 MD->getLocation()) == DiagnosticsEngine::Ignored)
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004734 return;
Benjamin Kramerc4704422012-05-19 16:03:58 +00004735 if (!MD->getDeclName().isIdentifier())
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004736 return;
4737
4738 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
4739 /*bool RecordPaths=*/false,
4740 /*bool DetectVirtual=*/false);
4741 FindHiddenVirtualMethodData Data;
4742 Data.Method = MD;
4743 Data.S = this;
4744
4745 // Keep the base methods that were overriden or introduced in the subclass
4746 // by 'using' in a set. A base method not in this set is hidden.
4747 for (DeclContext::lookup_result res = DC->lookup(MD->getDeclName());
4748 res.first != res.second; ++res.first) {
4749 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*res.first))
4750 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
4751 E = MD->end_overridden_methods();
4752 I != E; ++I)
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004753 Data.OverridenAndUsingBaseMethods.insert((*I)->getCanonicalDecl());
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004754 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*res.first))
4755 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(shad->getTargetDecl()))
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004756 Data.OverridenAndUsingBaseMethods.insert(MD->getCanonicalDecl());
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004757 }
4758
4759 if (DC->lookupInBases(&FindHiddenVirtualMethod, &Data, Paths) &&
4760 !Data.OverloadedMethods.empty()) {
4761 Diag(MD->getLocation(), diag::warn_overloaded_virtual)
4762 << MD << (Data.OverloadedMethods.size() > 1);
4763
4764 for (unsigned i = 0, e = Data.OverloadedMethods.size(); i != e; ++i) {
4765 CXXMethodDecl *overloadedMD = Data.OverloadedMethods[i];
4766 Diag(overloadedMD->getLocation(),
4767 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
4768 }
4769 }
Douglas Gregor1ab537b2009-12-03 18:33:45 +00004770}
4771
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004772void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
John McCalld226f652010-08-21 09:40:31 +00004773 Decl *TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004774 SourceLocation LBrac,
Douglas Gregor0b4c9b52010-03-29 14:42:08 +00004775 SourceLocation RBrac,
4776 AttributeList *AttrList) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004777 if (!TagDecl)
4778 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004779
Douglas Gregor42af25f2009-05-11 19:58:34 +00004780 AdjustDeclIfTemplate(TagDecl);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00004781
Rafael Espindolaf729ce02012-07-12 04:32:30 +00004782 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4783 if (l->getKind() != AttributeList::AT_Visibility)
4784 continue;
4785 l->setInvalid();
4786 Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
4787 l->getName();
4788 }
4789
David Blaikie77b6de02011-09-22 02:58:26 +00004790 ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
John McCalld226f652010-08-21 09:40:31 +00004791 // strict aliasing violation!
4792 reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
David Blaikie77b6de02011-09-22 02:58:26 +00004793 FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
Douglas Gregor2943aed2009-03-03 04:44:36 +00004794
Douglas Gregor23c94db2010-07-02 17:43:08 +00004795 CheckCompletedCXXClass(
John McCalld226f652010-08-21 09:40:31 +00004796 dyn_cast_or_null<CXXRecordDecl>(TagDecl));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004797}
4798
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004799/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
4800/// special functions, such as the default constructor, copy
4801/// constructor, or destructor, to the given C++ class (C++
4802/// [special]p1). This routine can only be executed just before the
4803/// definition of the class is complete.
Douglas Gregor23c94db2010-07-02 17:43:08 +00004804void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor32df23e2010-07-01 22:02:46 +00004805 if (!ClassDecl->hasUserDeclaredConstructor())
Douglas Gregor18274032010-07-03 00:47:00 +00004806 ++ASTContext::NumImplicitDefaultConstructors;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004807
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00004808 if (!ClassDecl->hasUserDeclaredCopyConstructor())
Douglas Gregor22584312010-07-02 23:41:54 +00004809 ++ASTContext::NumImplicitCopyConstructors;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004810
David Blaikie4e4d0842012-03-11 07:00:24 +00004811 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveConstructor())
Richard Smithb701d3d2011-12-24 21:56:24 +00004812 ++ASTContext::NumImplicitMoveConstructors;
4813
Douglas Gregora376d102010-07-02 21:50:04 +00004814 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
4815 ++ASTContext::NumImplicitCopyAssignmentOperators;
4816
4817 // If we have a dynamic class, then the copy assignment operator may be
4818 // virtual, so we have to declare it immediately. This ensures that, e.g.,
4819 // it shows up in the right place in the vtable and that we diagnose
4820 // problems with the implicit exception specification.
4821 if (ClassDecl->isDynamicClass())
4822 DeclareImplicitCopyAssignment(ClassDecl);
4823 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00004824
Richard Smith1c931be2012-04-02 18:40:40 +00004825 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveAssignment()) {
Richard Smithb701d3d2011-12-24 21:56:24 +00004826 ++ASTContext::NumImplicitMoveAssignmentOperators;
4827
4828 // Likewise for the move assignment operator.
4829 if (ClassDecl->isDynamicClass())
4830 DeclareImplicitMoveAssignment(ClassDecl);
4831 }
4832
Douglas Gregor4923aa22010-07-02 20:37:36 +00004833 if (!ClassDecl->hasUserDeclaredDestructor()) {
4834 ++ASTContext::NumImplicitDestructors;
4835
4836 // If we have a dynamic class, then the destructor may be virtual, so we
4837 // have to declare the destructor immediately. This ensures that, e.g., it
4838 // shows up in the right place in the vtable and that we diagnose problems
4839 // with the implicit exception specification.
4840 if (ClassDecl->isDynamicClass())
4841 DeclareImplicitDestructor(ClassDecl);
4842 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004843}
4844
Francois Pichet8387e2a2011-04-22 22:18:13 +00004845void Sema::ActOnReenterDeclaratorTemplateScope(Scope *S, DeclaratorDecl *D) {
4846 if (!D)
4847 return;
4848
4849 int NumParamList = D->getNumTemplateParameterLists();
4850 for (int i = 0; i < NumParamList; i++) {
4851 TemplateParameterList* Params = D->getTemplateParameterList(i);
4852 for (TemplateParameterList::iterator Param = Params->begin(),
4853 ParamEnd = Params->end();
4854 Param != ParamEnd; ++Param) {
4855 NamedDecl *Named = cast<NamedDecl>(*Param);
4856 if (Named->getDeclName()) {
4857 S->AddDecl(Named);
4858 IdResolver.AddDecl(Named);
4859 }
4860 }
4861 }
4862}
4863
John McCalld226f652010-08-21 09:40:31 +00004864void Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
Douglas Gregor1cdcc572009-09-10 00:12:48 +00004865 if (!D)
4866 return;
4867
4868 TemplateParameterList *Params = 0;
4869 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
4870 Params = Template->getTemplateParameters();
4871 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4872 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
4873 Params = PartialSpec->getTemplateParameters();
4874 else
Douglas Gregor6569d682009-05-27 23:11:45 +00004875 return;
4876
Douglas Gregor6569d682009-05-27 23:11:45 +00004877 for (TemplateParameterList::iterator Param = Params->begin(),
4878 ParamEnd = Params->end();
4879 Param != ParamEnd; ++Param) {
4880 NamedDecl *Named = cast<NamedDecl>(*Param);
4881 if (Named->getDeclName()) {
John McCalld226f652010-08-21 09:40:31 +00004882 S->AddDecl(Named);
Douglas Gregor6569d682009-05-27 23:11:45 +00004883 IdResolver.AddDecl(Named);
4884 }
4885 }
4886}
4887
John McCalld226f652010-08-21 09:40:31 +00004888void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall7a1dc562009-12-19 10:49:29 +00004889 if (!RecordD) return;
4890 AdjustDeclIfTemplate(RecordD);
John McCalld226f652010-08-21 09:40:31 +00004891 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
John McCall7a1dc562009-12-19 10:49:29 +00004892 PushDeclContext(S, Record);
4893}
4894
John McCalld226f652010-08-21 09:40:31 +00004895void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall7a1dc562009-12-19 10:49:29 +00004896 if (!RecordD) return;
4897 PopDeclContext();
4898}
4899
Douglas Gregor72b505b2008-12-16 21:30:33 +00004900/// ActOnStartDelayedCXXMethodDeclaration - We have completed
4901/// parsing a top-level (non-nested) C++ class, and we are now
4902/// parsing those parts of the given Method declaration that could
4903/// not be parsed earlier (C++ [class.mem]p2), such as default
4904/// arguments. This action should enter the scope of the given
4905/// Method declaration as if we had just parsed the qualified method
4906/// name. However, it should not bring the parameters into scope;
4907/// that will be performed by ActOnDelayedCXXMethodParameter.
John McCalld226f652010-08-21 09:40:31 +00004908void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004909}
4910
4911/// ActOnDelayedCXXMethodParameter - We've already started a delayed
4912/// C++ method declaration. We're (re-)introducing the given
4913/// function parameter into scope for use in parsing later parts of
4914/// the method declaration. For example, we could see an
4915/// ActOnParamDefaultArgument event for this parameter.
John McCalld226f652010-08-21 09:40:31 +00004916void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004917 if (!ParamD)
4918 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004919
John McCalld226f652010-08-21 09:40:31 +00004920 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
Douglas Gregor61366e92008-12-24 00:01:03 +00004921
4922 // If this parameter has an unparsed default argument, clear it out
4923 // to make way for the parsed default argument.
4924 if (Param->hasUnparsedDefaultArg())
4925 Param->setDefaultArg(0);
4926
John McCalld226f652010-08-21 09:40:31 +00004927 S->AddDecl(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +00004928 if (Param->getDeclName())
4929 IdResolver.AddDecl(Param);
4930}
4931
4932/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
4933/// processing the delayed method declaration for Method. The method
4934/// declaration is now considered finished. There may be a separate
4935/// ActOnStartOfFunctionDef action later (not necessarily
4936/// immediately!) for this method, if it was also defined inside the
4937/// class body.
John McCalld226f652010-08-21 09:40:31 +00004938void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004939 if (!MethodD)
4940 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004941
Douglas Gregorefd5bda2009-08-24 11:57:43 +00004942 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00004943
John McCalld226f652010-08-21 09:40:31 +00004944 FunctionDecl *Method = cast<FunctionDecl>(MethodD);
Douglas Gregor72b505b2008-12-16 21:30:33 +00004945
4946 // Now that we have our default arguments, check the constructor
4947 // again. It could produce additional diagnostics or affect whether
4948 // the class has implicitly-declared destructors, among other
4949 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00004950 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
4951 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00004952
4953 // Check the default arguments, which we may have added.
4954 if (!Method->isInvalidDecl())
4955 CheckCXXDefaultArguments(Method);
4956}
4957
Douglas Gregor42a552f2008-11-05 20:51:48 +00004958/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00004959/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00004960/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00004961/// emit diagnostics and set the invalid bit to true. In any case, the type
4962/// will be updated to reflect a well-formed type for the constructor and
4963/// returned.
4964QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
John McCalld931b082010-08-26 03:08:43 +00004965 StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00004966 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00004967
4968 // C++ [class.ctor]p3:
4969 // A constructor shall not be virtual (10.3) or static (9.4). A
4970 // constructor can be invoked for a const, volatile or const
4971 // volatile object. A constructor shall not be declared const,
4972 // volatile, or const volatile (9.3.2).
4973 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00004974 if (!D.isInvalidType())
4975 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
4976 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
4977 << SourceRange(D.getIdentifierLoc());
4978 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00004979 }
John McCalld931b082010-08-26 03:08:43 +00004980 if (SC == SC_Static) {
Chris Lattner65401802009-04-25 08:28:21 +00004981 if (!D.isInvalidType())
4982 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
4983 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
4984 << SourceRange(D.getIdentifierLoc());
4985 D.setInvalidType();
John McCalld931b082010-08-26 03:08:43 +00004986 SC = SC_None;
Douglas Gregor42a552f2008-11-05 20:51:48 +00004987 }
Mike Stump1eb44332009-09-09 15:08:12 +00004988
Abramo Bagnara075f8f12010-12-10 16:29:40 +00004989 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner65401802009-04-25 08:28:21 +00004990 if (FTI.TypeQuals != 0) {
John McCall0953e762009-09-24 19:53:00 +00004991 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00004992 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
4993 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00004994 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00004995 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
4996 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00004997 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00004998 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
4999 << "restrict" << SourceRange(D.getIdentifierLoc());
John McCalle23cf432010-12-14 08:05:40 +00005000 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005001 }
Mike Stump1eb44332009-09-09 15:08:12 +00005002
Douglas Gregorc938c162011-01-26 05:01:58 +00005003 // C++0x [class.ctor]p4:
5004 // A constructor shall not be declared with a ref-qualifier.
5005 if (FTI.hasRefQualifier()) {
5006 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
5007 << FTI.RefQualifierIsLValueRef
5008 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
5009 D.setInvalidType();
5010 }
5011
Douglas Gregor42a552f2008-11-05 20:51:48 +00005012 // Rebuild the function type "R" without any type qualifiers (in
5013 // case any of the errors above fired) and with "void" as the
Douglas Gregord92ec472010-07-01 05:10:53 +00005014 // return type, since constructors don't have return types.
John McCall183700f2009-09-21 23:43:11 +00005015 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00005016 if (Proto->getResultType() == Context.VoidTy && !D.isInvalidType())
5017 return R;
5018
5019 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
5020 EPI.TypeQuals = 0;
Douglas Gregorc938c162011-01-26 05:01:58 +00005021 EPI.RefQualifier = RQ_None;
5022
Chris Lattner65401802009-04-25 08:28:21 +00005023 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
John McCalle23cf432010-12-14 08:05:40 +00005024 Proto->getNumArgs(), EPI);
Douglas Gregor42a552f2008-11-05 20:51:48 +00005025}
5026
Douglas Gregor72b505b2008-12-16 21:30:33 +00005027/// CheckConstructor - Checks a fully-formed constructor for
5028/// well-formedness, issuing any diagnostics required. Returns true if
5029/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00005030void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump1eb44332009-09-09 15:08:12 +00005031 CXXRecordDecl *ClassDecl
Douglas Gregor33297562009-03-27 04:38:56 +00005032 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
5033 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00005034 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00005035
5036 // C++ [class.copy]p3:
5037 // A declaration of a constructor for a class X is ill-formed if
5038 // its first parameter is of type (optionally cv-qualified) X and
5039 // either there are no other parameters or else all other
5040 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00005041 if (!Constructor->isInvalidDecl() &&
Mike Stump1eb44332009-09-09 15:08:12 +00005042 ((Constructor->getNumParams() == 1) ||
5043 (Constructor->getNumParams() > 1 &&
Douglas Gregor66724ea2009-11-14 01:20:54 +00005044 Constructor->getParamDecl(1)->hasDefaultArg())) &&
5045 Constructor->getTemplateSpecializationKind()
5046 != TSK_ImplicitInstantiation) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00005047 QualType ParamType = Constructor->getParamDecl(0)->getType();
5048 QualType ClassTy = Context.getTagDeclType(ClassDecl);
5049 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00005050 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
Douglas Gregoraeb4a282010-05-27 21:28:21 +00005051 const char *ConstRef
5052 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
5053 : " const &";
Douglas Gregora3a83512009-04-01 23:51:29 +00005054 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregoraeb4a282010-05-27 21:28:21 +00005055 << FixItHint::CreateInsertion(ParamLoc, ConstRef);
Douglas Gregor66724ea2009-11-14 01:20:54 +00005056
5057 // FIXME: Rather that making the constructor invalid, we should endeavor
5058 // to fix the type.
Chris Lattner6e475012009-04-25 08:35:12 +00005059 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00005060 }
5061 }
Douglas Gregor72b505b2008-12-16 21:30:33 +00005062}
5063
John McCall15442822010-08-04 01:04:25 +00005064/// CheckDestructor - Checks a fully-formed destructor definition for
5065/// well-formedness, issuing any diagnostics required. Returns true
5066/// on error.
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005067bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson6d701392009-11-15 22:49:34 +00005068 CXXRecordDecl *RD = Destructor->getParent();
5069
5070 if (Destructor->isVirtual()) {
5071 SourceLocation Loc;
5072
5073 if (!Destructor->isImplicit())
5074 Loc = Destructor->getLocation();
5075 else
5076 Loc = RD->getLocation();
5077
5078 // If we have a virtual destructor, look up the deallocation function
5079 FunctionDecl *OperatorDelete = 0;
5080 DeclarationName Name =
5081 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005082 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson37909802009-11-30 21:24:50 +00005083 return true;
John McCall5efd91a2010-07-03 18:33:00 +00005084
Eli Friedman5f2987c2012-02-02 03:46:19 +00005085 MarkFunctionReferenced(Loc, OperatorDelete);
Anders Carlsson37909802009-11-30 21:24:50 +00005086
5087 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson6d701392009-11-15 22:49:34 +00005088 }
Anders Carlsson37909802009-11-30 21:24:50 +00005089
5090 return false;
Anders Carlsson6d701392009-11-15 22:49:34 +00005091}
5092
Mike Stump1eb44332009-09-09 15:08:12 +00005093static inline bool
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005094FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
5095 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5096 FTI.ArgInfo[0].Param &&
John McCalld226f652010-08-21 09:40:31 +00005097 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType());
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005098}
5099
Douglas Gregor42a552f2008-11-05 20:51:48 +00005100/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
5101/// the well-formednes of the destructor declarator @p D with type @p
5102/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00005103/// emit diagnostics and set the declarator to invalid. Even if this happens,
5104/// will be updated to reflect a well-formed type for the destructor and
5105/// returned.
Douglas Gregord92ec472010-07-01 05:10:53 +00005106QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
John McCalld931b082010-08-26 03:08:43 +00005107 StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005108 // C++ [class.dtor]p1:
5109 // [...] A typedef-name that names a class is a class-name
5110 // (7.1.3); however, a typedef-name that names a class shall not
5111 // be used as the identifier in the declarator for a destructor
5112 // declaration.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005113 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Richard Smith162e1c12011-04-15 14:24:37 +00005114 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
Chris Lattner65401802009-04-25 08:28:21 +00005115 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Richard Smith162e1c12011-04-15 14:24:37 +00005116 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
Richard Smith3e4c6c42011-05-05 21:57:07 +00005117 else if (const TemplateSpecializationType *TST =
5118 DeclaratorType->getAs<TemplateSpecializationType>())
5119 if (TST->isTypeAlias())
5120 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
5121 << DeclaratorType << 1;
Douglas Gregor42a552f2008-11-05 20:51:48 +00005122
5123 // C++ [class.dtor]p2:
5124 // A destructor is used to destroy objects of its class type. A
5125 // destructor takes no parameters, and no return type can be
5126 // specified for it (not even void). The address of a destructor
5127 // shall not be taken. A destructor shall not be static. A
5128 // destructor can be invoked for a const, volatile or const
5129 // volatile object. A destructor shall not be declared const,
5130 // volatile or const volatile (9.3.2).
John McCalld931b082010-08-26 03:08:43 +00005131 if (SC == SC_Static) {
Chris Lattner65401802009-04-25 08:28:21 +00005132 if (!D.isInvalidType())
5133 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
5134 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
Douglas Gregord92ec472010-07-01 05:10:53 +00005135 << SourceRange(D.getIdentifierLoc())
5136 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5137
John McCalld931b082010-08-26 03:08:43 +00005138 SC = SC_None;
Douglas Gregor42a552f2008-11-05 20:51:48 +00005139 }
Chris Lattner65401802009-04-25 08:28:21 +00005140 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005141 // Destructors don't have return types, but the parser will
5142 // happily parse something like:
5143 //
5144 // class X {
5145 // float ~X();
5146 // };
5147 //
5148 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005149 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
5150 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
5151 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00005152 }
Mike Stump1eb44332009-09-09 15:08:12 +00005153
Abramo Bagnara075f8f12010-12-10 16:29:40 +00005154 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner65401802009-04-25 08:28:21 +00005155 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall0953e762009-09-24 19:53:00 +00005156 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005157 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5158 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005159 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005160 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5161 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005162 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005163 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5164 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00005165 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005166 }
5167
Douglas Gregorc938c162011-01-26 05:01:58 +00005168 // C++0x [class.dtor]p2:
5169 // A destructor shall not be declared with a ref-qualifier.
5170 if (FTI.hasRefQualifier()) {
5171 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
5172 << FTI.RefQualifierIsLValueRef
5173 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
5174 D.setInvalidType();
5175 }
5176
Douglas Gregor42a552f2008-11-05 20:51:48 +00005177 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005178 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005179 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
5180
5181 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00005182 FTI.freeArgs();
5183 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005184 }
5185
Mike Stump1eb44332009-09-09 15:08:12 +00005186 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00005187 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005188 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00005189 D.setInvalidType();
5190 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00005191
5192 // Rebuild the function type "R" without any type qualifiers or
5193 // parameters (in case any of the errors above fired) and with
5194 // "void" as the return type, since destructors don't have return
Douglas Gregord92ec472010-07-01 05:10:53 +00005195 // types.
John McCalle23cf432010-12-14 08:05:40 +00005196 if (!D.isInvalidType())
5197 return R;
5198
Douglas Gregord92ec472010-07-01 05:10:53 +00005199 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00005200 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
5201 EPI.Variadic = false;
5202 EPI.TypeQuals = 0;
Douglas Gregorc938c162011-01-26 05:01:58 +00005203 EPI.RefQualifier = RQ_None;
John McCalle23cf432010-12-14 08:05:40 +00005204 return Context.getFunctionType(Context.VoidTy, 0, 0, EPI);
Douglas Gregor42a552f2008-11-05 20:51:48 +00005205}
5206
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005207/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
5208/// well-formednes of the conversion function declarator @p D with
5209/// type @p R. If there are any errors in the declarator, this routine
5210/// will emit diagnostics and return true. Otherwise, it will return
5211/// false. Either way, the type @p R will be updated to reflect a
5212/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00005213void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
John McCalld931b082010-08-26 03:08:43 +00005214 StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005215 // C++ [class.conv.fct]p1:
5216 // Neither parameter types nor return type can be specified. The
Eli Friedman33a31382009-08-05 19:21:58 +00005217 // type of a conversion function (8.3.5) is "function taking no
Mike Stump1eb44332009-09-09 15:08:12 +00005218 // parameter returning conversion-type-id."
John McCalld931b082010-08-26 03:08:43 +00005219 if (SC == SC_Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00005220 if (!D.isInvalidType())
5221 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
5222 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
5223 << SourceRange(D.getIdentifierLoc());
5224 D.setInvalidType();
John McCalld931b082010-08-26 03:08:43 +00005225 SC = SC_None;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005226 }
John McCalla3f81372010-04-13 00:04:31 +00005227
5228 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
5229
Chris Lattner6e475012009-04-25 08:35:12 +00005230 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005231 // Conversion functions don't have return types, but the parser will
5232 // happily parse something like:
5233 //
5234 // class X {
5235 // float operator bool();
5236 // };
5237 //
5238 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005239 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
5240 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
5241 << SourceRange(D.getIdentifierLoc());
John McCalla3f81372010-04-13 00:04:31 +00005242 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005243 }
5244
John McCalla3f81372010-04-13 00:04:31 +00005245 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
5246
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005247 // Make sure we don't have any parameters.
John McCalla3f81372010-04-13 00:04:31 +00005248 if (Proto->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005249 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
5250
5251 // Delete the parameters.
Abramo Bagnara075f8f12010-12-10 16:29:40 +00005252 D.getFunctionTypeInfo().freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00005253 D.setInvalidType();
John McCalla3f81372010-04-13 00:04:31 +00005254 } else if (Proto->isVariadic()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005255 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00005256 D.setInvalidType();
5257 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005258
John McCalla3f81372010-04-13 00:04:31 +00005259 // Diagnose "&operator bool()" and other such nonsense. This
5260 // is actually a gcc extension which we don't support.
5261 if (Proto->getResultType() != ConvType) {
5262 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
5263 << Proto->getResultType();
5264 D.setInvalidType();
5265 ConvType = Proto->getResultType();
5266 }
5267
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005268 // C++ [class.conv.fct]p4:
5269 // The conversion-type-id shall not represent a function type nor
5270 // an array type.
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005271 if (ConvType->isArrayType()) {
5272 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
5273 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00005274 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005275 } else if (ConvType->isFunctionType()) {
5276 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
5277 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00005278 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005279 }
5280
5281 // Rebuild the function type "R" without any parameters (in case any
5282 // of the errors above fired) and with the conversion type as the
Mike Stump1eb44332009-09-09 15:08:12 +00005283 // return type.
John McCalle23cf432010-12-14 08:05:40 +00005284 if (D.isInvalidType())
5285 R = Context.getFunctionType(ConvType, 0, 0, Proto->getExtProtoInfo());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005286
Douglas Gregor09f41cf2009-01-14 15:45:31 +00005287 // C++0x explicit conversion operators.
Richard Smithebaf0e62011-10-18 20:49:44 +00005288 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00005289 Diag(D.getDeclSpec().getExplicitSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +00005290 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +00005291 diag::warn_cxx98_compat_explicit_conversion_functions :
5292 diag::ext_explicit_conversion_functions)
Douglas Gregor09f41cf2009-01-14 15:45:31 +00005293 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005294}
5295
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005296/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
5297/// the declaration of the given C++ conversion function. This routine
5298/// is responsible for recording the conversion function in the C++
5299/// class, if possible.
John McCalld226f652010-08-21 09:40:31 +00005300Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005301 assert(Conversion && "Expected to receive a conversion function declaration");
5302
Douglas Gregor9d350972008-12-12 08:25:50 +00005303 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005304
5305 // Make sure we aren't redeclaring the conversion function.
5306 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005307
5308 // C++ [class.conv.fct]p1:
5309 // [...] A conversion function is never used to convert a
5310 // (possibly cv-qualified) object to the (possibly cv-qualified)
5311 // same object type (or a reference to it), to a (possibly
5312 // cv-qualified) base class of that type (or a reference to it),
5313 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00005314 // FIXME: Suppress this warning if the conversion function ends up being a
5315 // virtual function that overrides a virtual function in a base class.
Mike Stump1eb44332009-09-09 15:08:12 +00005316 QualType ClassType
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005317 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek6217b802009-07-29 21:53:49 +00005318 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005319 ConvType = ConvTypeRef->getPointeeType();
Douglas Gregorda0fd9a2010-09-12 07:22:28 +00005320 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
5321 Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
Douglas Gregor10341702010-09-13 16:44:26 +00005322 /* Suppress diagnostics for instantiations. */;
Douglas Gregorda0fd9a2010-09-12 07:22:28 +00005323 else if (ConvType->isRecordType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005324 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
5325 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00005326 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005327 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005328 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00005329 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005330 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005331 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00005332 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005333 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005334 }
5335
Douglas Gregore80622f2010-09-29 04:25:11 +00005336 if (FunctionTemplateDecl *ConversionTemplate
5337 = Conversion->getDescribedFunctionTemplate())
5338 return ConversionTemplate;
5339
John McCalld226f652010-08-21 09:40:31 +00005340 return Conversion;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005341}
5342
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005343//===----------------------------------------------------------------------===//
5344// Namespace Handling
5345//===----------------------------------------------------------------------===//
5346
John McCallea318642010-08-26 09:15:37 +00005347
5348
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005349/// ActOnStartNamespaceDef - This is called at the start of a namespace
5350/// definition.
John McCalld226f652010-08-21 09:40:31 +00005351Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
Sebastian Redld078e642010-08-27 23:12:46 +00005352 SourceLocation InlineLoc,
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005353 SourceLocation NamespaceLoc,
John McCallea318642010-08-26 09:15:37 +00005354 SourceLocation IdentLoc,
5355 IdentifierInfo *II,
5356 SourceLocation LBrace,
5357 AttributeList *AttrList) {
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005358 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
5359 // For anonymous namespace, take the location of the left brace.
5360 SourceLocation Loc = II ? IdentLoc : LBrace;
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005361 bool IsInline = InlineLoc.isValid();
Douglas Gregor67310742012-01-10 22:14:10 +00005362 bool IsInvalid = false;
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005363 bool IsStd = false;
5364 bool AddToKnown = false;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005365 Scope *DeclRegionScope = NamespcScope->getParent();
5366
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005367 NamespaceDecl *PrevNS = 0;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005368 if (II) {
5369 // C++ [namespace.def]p2:
Douglas Gregorfe7574b2010-10-22 15:24:46 +00005370 // The identifier in an original-namespace-definition shall not
5371 // have been previously defined in the declarative region in
5372 // which the original-namespace-definition appears. The
5373 // identifier in an original-namespace-definition is the name of
5374 // the namespace. Subsequently in that declarative region, it is
5375 // treated as an original-namespace-name.
5376 //
5377 // Since namespace names are unique in their scope, and we don't
Douglas Gregor010157f2011-05-06 23:28:47 +00005378 // look through using directives, just look for any ordinary names.
5379
5380 const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member |
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005381 Decl::IDNS_Type | Decl::IDNS_Using | Decl::IDNS_Tag |
5382 Decl::IDNS_Namespace;
Douglas Gregor010157f2011-05-06 23:28:47 +00005383 NamedDecl *PrevDecl = 0;
5384 for (DeclContext::lookup_result R
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005385 = CurContext->getRedeclContext()->lookup(II);
Douglas Gregor010157f2011-05-06 23:28:47 +00005386 R.first != R.second; ++R.first) {
5387 if ((*R.first)->getIdentifierNamespace() & IDNS) {
5388 PrevDecl = *R.first;
5389 break;
5390 }
5391 }
5392
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005393 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
5394
5395 if (PrevNS) {
Douglas Gregor44b43212008-12-11 16:49:14 +00005396 // This is an extended namespace definition.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005397 if (IsInline != PrevNS->isInline()) {
Sebastian Redl4e4d5702010-08-31 00:36:36 +00005398 // inline-ness must match
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005399 if (PrevNS->isInline()) {
Douglas Gregorb7ec9062011-05-20 15:48:31 +00005400 // The user probably just forgot the 'inline', so suggest that it
5401 // be added back.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005402 Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
Douglas Gregorb7ec9062011-05-20 15:48:31 +00005403 << FixItHint::CreateInsertion(NamespaceLoc, "inline ");
5404 } else {
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005405 Diag(Loc, diag::err_inline_namespace_mismatch)
5406 << IsInline;
Douglas Gregorb7ec9062011-05-20 15:48:31 +00005407 }
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005408 Diag(PrevNS->getLocation(), diag::note_previous_definition);
5409
5410 IsInline = PrevNS->isInline();
5411 }
Douglas Gregor44b43212008-12-11 16:49:14 +00005412 } else if (PrevDecl) {
5413 // This is an invalid name redefinition.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005414 Diag(Loc, diag::err_redefinition_different_kind)
5415 << II;
Douglas Gregor44b43212008-12-11 16:49:14 +00005416 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Douglas Gregor67310742012-01-10 22:14:10 +00005417 IsInvalid = true;
Douglas Gregor44b43212008-12-11 16:49:14 +00005418 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005419 } else if (II->isStr("std") &&
Sebastian Redl7a126a42010-08-31 00:36:30 +00005420 CurContext->getRedeclContext()->isTranslationUnit()) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005421 // This is the first "real" definition of the namespace "std", so update
5422 // our cache of the "std" namespace to point at this definition.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005423 PrevNS = getStdNamespace();
5424 IsStd = true;
5425 AddToKnown = !IsInline;
5426 } else {
5427 // We've seen this namespace for the first time.
5428 AddToKnown = !IsInline;
Mike Stump1eb44332009-09-09 15:08:12 +00005429 }
Douglas Gregor44b43212008-12-11 16:49:14 +00005430 } else {
John McCall9aeed322009-10-01 00:25:31 +00005431 // Anonymous namespaces.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005432
5433 // Determine whether the parent already has an anonymous namespace.
Sebastian Redl7a126a42010-08-31 00:36:30 +00005434 DeclContext *Parent = CurContext->getRedeclContext();
John McCall5fdd7642009-12-16 02:06:49 +00005435 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005436 PrevNS = TU->getAnonymousNamespace();
John McCall5fdd7642009-12-16 02:06:49 +00005437 } else {
5438 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005439 PrevNS = ND->getAnonymousNamespace();
John McCall5fdd7642009-12-16 02:06:49 +00005440 }
5441
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005442 if (PrevNS && IsInline != PrevNS->isInline()) {
5443 // inline-ness must match
5444 Diag(Loc, diag::err_inline_namespace_mismatch)
5445 << IsInline;
5446 Diag(PrevNS->getLocation(), diag::note_previous_definition);
Douglas Gregor67310742012-01-10 22:14:10 +00005447
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005448 // Recover by ignoring the new namespace's inline status.
5449 IsInline = PrevNS->isInline();
5450 }
5451 }
5452
5453 NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
5454 StartLoc, Loc, II, PrevNS);
Douglas Gregor67310742012-01-10 22:14:10 +00005455 if (IsInvalid)
5456 Namespc->setInvalidDecl();
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005457
5458 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
Sebastian Redl4e4d5702010-08-31 00:36:36 +00005459
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005460 // FIXME: Should we be merging attributes?
5461 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
Rafael Espindola20039ae2012-02-01 23:24:59 +00005462 PushNamespaceVisibilityAttr(Attr, Loc);
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005463
5464 if (IsStd)
5465 StdNamespace = Namespc;
5466 if (AddToKnown)
5467 KnownNamespaces[Namespc] = false;
5468
5469 if (II) {
5470 PushOnScopeChains(Namespc, DeclRegionScope);
5471 } else {
5472 // Link the anonymous namespace into its parent.
5473 DeclContext *Parent = CurContext->getRedeclContext();
5474 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
5475 TU->setAnonymousNamespace(Namespc);
5476 } else {
5477 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
John McCall5fdd7642009-12-16 02:06:49 +00005478 }
John McCall9aeed322009-10-01 00:25:31 +00005479
Douglas Gregora4181472010-03-24 00:46:35 +00005480 CurContext->addDecl(Namespc);
5481
John McCall9aeed322009-10-01 00:25:31 +00005482 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
5483 // behaves as if it were replaced by
5484 // namespace unique { /* empty body */ }
5485 // using namespace unique;
5486 // namespace unique { namespace-body }
5487 // where all occurrences of 'unique' in a translation unit are
5488 // replaced by the same identifier and this identifier differs
5489 // from all other identifiers in the entire program.
5490
5491 // We just create the namespace with an empty name and then add an
5492 // implicit using declaration, just like the standard suggests.
5493 //
5494 // CodeGen enforces the "universally unique" aspect by giving all
5495 // declarations semantically contained within an anonymous
5496 // namespace internal linkage.
5497
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005498 if (!PrevNS) {
John McCall5fdd7642009-12-16 02:06:49 +00005499 UsingDirectiveDecl* UD
5500 = UsingDirectiveDecl::Create(Context, CurContext,
5501 /* 'using' */ LBrace,
5502 /* 'namespace' */ SourceLocation(),
Douglas Gregordb992412011-02-25 16:33:46 +00005503 /* qualifier */ NestedNameSpecifierLoc(),
John McCall5fdd7642009-12-16 02:06:49 +00005504 /* identifier */ SourceLocation(),
5505 Namespc,
5506 /* Ancestor */ CurContext);
5507 UD->setImplicit();
5508 CurContext->addDecl(UD);
5509 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005510 }
5511
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00005512 ActOnDocumentableDecl(Namespc);
5513
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005514 // Although we could have an invalid decl (i.e. the namespace name is a
5515 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00005516 // FIXME: We should be able to push Namespc here, so that the each DeclContext
5517 // for the namespace has the declarations that showed up in that particular
5518 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00005519 PushDeclContext(NamespcScope, Namespc);
John McCalld226f652010-08-21 09:40:31 +00005520 return Namespc;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005521}
5522
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005523/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
5524/// is a namespace alias, returns the namespace it points to.
5525static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
5526 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
5527 return AD->getNamespace();
5528 return dyn_cast_or_null<NamespaceDecl>(D);
5529}
5530
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005531/// ActOnFinishNamespaceDef - This callback is called after a namespace is
5532/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
John McCalld226f652010-08-21 09:40:31 +00005533void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005534 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
5535 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005536 Namespc->setRBraceLoc(RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005537 PopDeclContext();
Eli Friedmanaa8b0d12010-08-05 06:57:20 +00005538 if (Namespc->hasAttr<VisibilityAttr>())
Rafael Espindola20039ae2012-02-01 23:24:59 +00005539 PopPragmaVisibility(true, RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005540}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00005541
John McCall384aff82010-08-25 07:42:41 +00005542CXXRecordDecl *Sema::getStdBadAlloc() const {
5543 return cast_or_null<CXXRecordDecl>(
5544 StdBadAlloc.get(Context.getExternalSource()));
5545}
5546
5547NamespaceDecl *Sema::getStdNamespace() const {
5548 return cast_or_null<NamespaceDecl>(
5549 StdNamespace.get(Context.getExternalSource()));
5550}
5551
Douglas Gregor66992202010-06-29 17:53:46 +00005552/// \brief Retrieve the special "std" namespace, which may require us to
5553/// implicitly define the namespace.
Argyrios Kyrtzidis26faaac2010-08-02 07:14:39 +00005554NamespaceDecl *Sema::getOrCreateStdNamespace() {
Douglas Gregor66992202010-06-29 17:53:46 +00005555 if (!StdNamespace) {
5556 // The "std" namespace has not yet been defined, so build one implicitly.
5557 StdNamespace = NamespaceDecl::Create(Context,
5558 Context.getTranslationUnitDecl(),
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005559 /*Inline=*/false,
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005560 SourceLocation(), SourceLocation(),
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005561 &PP.getIdentifierTable().get("std"),
5562 /*PrevDecl=*/0);
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005563 getStdNamespace()->setImplicit(true);
Douglas Gregor66992202010-06-29 17:53:46 +00005564 }
5565
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005566 return getStdNamespace();
Douglas Gregor66992202010-06-29 17:53:46 +00005567}
5568
Sebastian Redl395e04d2012-01-17 22:49:33 +00005569bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
David Blaikie4e4d0842012-03-11 07:00:24 +00005570 assert(getLangOpts().CPlusPlus &&
Sebastian Redl395e04d2012-01-17 22:49:33 +00005571 "Looking for std::initializer_list outside of C++.");
5572
5573 // We're looking for implicit instantiations of
5574 // template <typename E> class std::initializer_list.
5575
5576 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
5577 return false;
5578
Sebastian Redl84760e32012-01-17 22:49:58 +00005579 ClassTemplateDecl *Template = 0;
5580 const TemplateArgument *Arguments = 0;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005581
Sebastian Redl84760e32012-01-17 22:49:58 +00005582 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Sebastian Redl395e04d2012-01-17 22:49:33 +00005583
Sebastian Redl84760e32012-01-17 22:49:58 +00005584 ClassTemplateSpecializationDecl *Specialization =
5585 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
5586 if (!Specialization)
5587 return false;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005588
Sebastian Redl84760e32012-01-17 22:49:58 +00005589 Template = Specialization->getSpecializedTemplate();
5590 Arguments = Specialization->getTemplateArgs().data();
5591 } else if (const TemplateSpecializationType *TST =
5592 Ty->getAs<TemplateSpecializationType>()) {
5593 Template = dyn_cast_or_null<ClassTemplateDecl>(
5594 TST->getTemplateName().getAsTemplateDecl());
5595 Arguments = TST->getArgs();
5596 }
5597 if (!Template)
5598 return false;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005599
5600 if (!StdInitializerList) {
5601 // Haven't recognized std::initializer_list yet, maybe this is it.
5602 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
5603 if (TemplateClass->getIdentifier() !=
5604 &PP.getIdentifierTable().get("initializer_list") ||
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005605 !getStdNamespace()->InEnclosingNamespaceSetOf(
5606 TemplateClass->getDeclContext()))
Sebastian Redl395e04d2012-01-17 22:49:33 +00005607 return false;
5608 // This is a template called std::initializer_list, but is it the right
5609 // template?
5610 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005611 if (Params->getMinRequiredArguments() != 1)
Sebastian Redl395e04d2012-01-17 22:49:33 +00005612 return false;
5613 if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
5614 return false;
5615
5616 // It's the right template.
5617 StdInitializerList = Template;
5618 }
5619
5620 if (Template != StdInitializerList)
5621 return false;
5622
5623 // This is an instance of std::initializer_list. Find the argument type.
Sebastian Redl84760e32012-01-17 22:49:58 +00005624 if (Element)
5625 *Element = Arguments[0].getAsType();
Sebastian Redl395e04d2012-01-17 22:49:33 +00005626 return true;
5627}
5628
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00005629static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
5630 NamespaceDecl *Std = S.getStdNamespace();
5631 if (!Std) {
5632 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
5633 return 0;
5634 }
5635
5636 LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
5637 Loc, Sema::LookupOrdinaryName);
5638 if (!S.LookupQualifiedName(Result, Std)) {
5639 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
5640 return 0;
5641 }
5642 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
5643 if (!Template) {
5644 Result.suppressDiagnostics();
5645 // We found something weird. Complain about the first thing we found.
5646 NamedDecl *Found = *Result.begin();
5647 S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
5648 return 0;
5649 }
5650
5651 // We found some template called std::initializer_list. Now verify that it's
5652 // correct.
5653 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005654 if (Params->getMinRequiredArguments() != 1 ||
5655 !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00005656 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
5657 return 0;
5658 }
5659
5660 return Template;
5661}
5662
5663QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
5664 if (!StdInitializerList) {
5665 StdInitializerList = LookupStdInitializerList(*this, Loc);
5666 if (!StdInitializerList)
5667 return QualType();
5668 }
5669
5670 TemplateArgumentListInfo Args(Loc, Loc);
5671 Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
5672 Context.getTrivialTypeSourceInfo(Element,
5673 Loc)));
5674 return Context.getCanonicalType(
5675 CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
5676}
5677
Sebastian Redl98d36062012-01-17 22:50:14 +00005678bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
5679 // C++ [dcl.init.list]p2:
5680 // A constructor is an initializer-list constructor if its first parameter
5681 // is of type std::initializer_list<E> or reference to possibly cv-qualified
5682 // std::initializer_list<E> for some type E, and either there are no other
5683 // parameters or else all other parameters have default arguments.
5684 if (Ctor->getNumParams() < 1 ||
5685 (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
5686 return false;
5687
5688 QualType ArgType = Ctor->getParamDecl(0)->getType();
5689 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
5690 ArgType = RT->getPointeeType().getUnqualifiedType();
5691
5692 return isStdInitializerList(ArgType, 0);
5693}
5694
Douglas Gregor9172aa62011-03-26 22:25:30 +00005695/// \brief Determine whether a using statement is in a context where it will be
5696/// apply in all contexts.
5697static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
5698 switch (CurContext->getDeclKind()) {
5699 case Decl::TranslationUnit:
5700 return true;
5701 case Decl::LinkageSpec:
5702 return IsUsingDirectiveInToplevelContext(CurContext->getParent());
5703 default:
5704 return false;
5705 }
5706}
5707
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005708namespace {
5709
5710// Callback to only accept typo corrections that are namespaces.
5711class NamespaceValidatorCCC : public CorrectionCandidateCallback {
5712 public:
5713 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
5714 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
5715 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
5716 }
5717 return false;
5718 }
5719};
5720
5721}
5722
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005723static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
5724 CXXScopeSpec &SS,
5725 SourceLocation IdentLoc,
5726 IdentifierInfo *Ident) {
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005727 NamespaceValidatorCCC Validator;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005728 R.clear();
5729 if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(),
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005730 R.getLookupKind(), Sc, &SS,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00005731 Validator)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00005732 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
5733 std::string CorrectedQuotedStr(Corrected.getQuoted(S.getLangOpts()));
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005734 if (DeclContext *DC = S.computeDeclContext(SS, false))
5735 S.Diag(IdentLoc, diag::err_using_directive_member_suggest)
5736 << Ident << DC << CorrectedQuotedStr << SS.getRange()
5737 << FixItHint::CreateReplacement(IdentLoc, CorrectedStr);
5738 else
5739 S.Diag(IdentLoc, diag::err_using_directive_suggest)
5740 << Ident << CorrectedQuotedStr
5741 << FixItHint::CreateReplacement(IdentLoc, CorrectedStr);
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005742
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005743 S.Diag(Corrected.getCorrectionDecl()->getLocation(),
5744 diag::note_namespace_defined_here) << CorrectedQuotedStr;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005745
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005746 R.addDecl(Corrected.getCorrectionDecl());
5747 return true;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005748 }
5749 return false;
5750}
5751
John McCalld226f652010-08-21 09:40:31 +00005752Decl *Sema::ActOnUsingDirective(Scope *S,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005753 SourceLocation UsingLoc,
5754 SourceLocation NamespcLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00005755 CXXScopeSpec &SS,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005756 SourceLocation IdentLoc,
5757 IdentifierInfo *NamespcName,
5758 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00005759 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
5760 assert(NamespcName && "Invalid NamespcName.");
5761 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
John McCall78b81052010-11-10 02:40:36 +00005762
5763 // This can only happen along a recovery path.
5764 while (S->getFlags() & Scope::TemplateParamScope)
5765 S = S->getParent();
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005766 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00005767
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005768 UsingDirectiveDecl *UDir = 0;
Douglas Gregor66992202010-06-29 17:53:46 +00005769 NestedNameSpecifier *Qualifier = 0;
5770 if (SS.isSet())
5771 Qualifier = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
5772
Douglas Gregoreb11cd02009-01-14 22:20:51 +00005773 // Lookup namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00005774 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
5775 LookupParsedName(R, S, &SS);
5776 if (R.isAmbiguous())
John McCalld226f652010-08-21 09:40:31 +00005777 return 0;
John McCalla24dc2e2009-11-17 02:14:36 +00005778
Douglas Gregor66992202010-06-29 17:53:46 +00005779 if (R.empty()) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005780 R.clear();
Douglas Gregor66992202010-06-29 17:53:46 +00005781 // Allow "using namespace std;" or "using namespace ::std;" even if
5782 // "std" hasn't been defined yet, for GCC compatibility.
5783 if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
5784 NamespcName->isStr("std")) {
5785 Diag(IdentLoc, diag::ext_using_undefined_std);
Argyrios Kyrtzidis26faaac2010-08-02 07:14:39 +00005786 R.addDecl(getOrCreateStdNamespace());
Douglas Gregor66992202010-06-29 17:53:46 +00005787 R.resolveKind();
5788 }
5789 // Otherwise, attempt typo correction.
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005790 else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
Douglas Gregor66992202010-06-29 17:53:46 +00005791 }
5792
John McCallf36e02d2009-10-09 21:13:30 +00005793 if (!R.empty()) {
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005794 NamedDecl *Named = R.getFoundDecl();
5795 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
5796 && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005797 // C++ [namespace.udir]p1:
5798 // A using-directive specifies that the names in the nominated
5799 // namespace can be used in the scope in which the
5800 // using-directive appears after the using-directive. During
5801 // unqualified name lookup (3.4.1), the names appear as if they
5802 // were declared in the nearest enclosing namespace which
5803 // contains both the using-directive and the nominated
Eli Friedman33a31382009-08-05 19:21:58 +00005804 // namespace. [Note: in this context, "contains" means "contains
5805 // directly or indirectly". ]
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005806
5807 // Find enclosing context containing both using-directive and
5808 // nominated namespace.
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005809 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005810 DeclContext *CommonAncestor = cast<DeclContext>(NS);
5811 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
5812 CommonAncestor = CommonAncestor->getParent();
5813
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005814 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregordb992412011-02-25 16:33:46 +00005815 SS.getWithLocInContext(Context),
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005816 IdentLoc, Named, CommonAncestor);
Douglas Gregord6a49bb2011-03-18 16:10:52 +00005817
Douglas Gregor9172aa62011-03-26 22:25:30 +00005818 if (IsUsingDirectiveInToplevelContext(CurContext) &&
Chandler Carruth40278532011-07-25 16:49:02 +00005819 !SourceMgr.isFromMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
Douglas Gregord6a49bb2011-03-18 16:10:52 +00005820 Diag(IdentLoc, diag::warn_using_directive_in_header);
5821 }
5822
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005823 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00005824 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00005825 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00005826 }
5827
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005828 // FIXME: We ignore attributes for now.
John McCalld226f652010-08-21 09:40:31 +00005829 return UDir;
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005830}
5831
5832void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
Richard Smith1b7f9cb2012-03-13 03:12:56 +00005833 // If the scope has an associated entity and the using directive is at
5834 // namespace or translation unit scope, add the UsingDirectiveDecl into
5835 // its lookup structure so qualified name lookup can find it.
5836 DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity());
5837 if (Ctx && !Ctx->isFunctionOrMethod())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005838 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005839 else
Richard Smith1b7f9cb2012-03-13 03:12:56 +00005840 // Otherwise, it is at block sope. The using-directives will affect lookup
5841 // only to the end of the scope.
John McCalld226f652010-08-21 09:40:31 +00005842 S->PushUsingDirective(UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00005843}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00005844
Douglas Gregor9cfbe482009-06-20 00:51:54 +00005845
John McCalld226f652010-08-21 09:40:31 +00005846Decl *Sema::ActOnUsingDeclaration(Scope *S,
John McCall78b81052010-11-10 02:40:36 +00005847 AccessSpecifier AS,
5848 bool HasUsingKeyword,
5849 SourceLocation UsingLoc,
5850 CXXScopeSpec &SS,
5851 UnqualifiedId &Name,
5852 AttributeList *AttrList,
5853 bool IsTypeName,
5854 SourceLocation TypenameLoc) {
Douglas Gregor9cfbe482009-06-20 00:51:54 +00005855 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump1eb44332009-09-09 15:08:12 +00005856
Douglas Gregor12c118a2009-11-04 16:30:06 +00005857 switch (Name.getKind()) {
Fariborz Jahanian98a54032011-07-12 17:16:56 +00005858 case UnqualifiedId::IK_ImplicitSelfParam:
Douglas Gregor12c118a2009-11-04 16:30:06 +00005859 case UnqualifiedId::IK_Identifier:
5860 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunt0486d742009-11-28 04:44:28 +00005861 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor12c118a2009-11-04 16:30:06 +00005862 case UnqualifiedId::IK_ConversionFunctionId:
5863 break;
5864
5865 case UnqualifiedId::IK_ConstructorName:
Douglas Gregor0efc2c12010-01-13 17:31:36 +00005866 case UnqualifiedId::IK_ConstructorTemplateId:
Richard Smitha1366cb2012-04-27 19:33:05 +00005867 // C++11 inheriting constructors.
Daniel Dunbar96a00142012-03-09 18:35:03 +00005868 Diag(Name.getLocStart(),
David Blaikie4e4d0842012-03-11 07:00:24 +00005869 getLangOpts().CPlusPlus0x ?
Richard Smitha1366cb2012-04-27 19:33:05 +00005870 // FIXME: Produce warn_cxx98_compat_using_decl_constructor
5871 // instead once inheriting constructors work.
5872 diag::err_using_decl_constructor_unsupported :
Richard Smithebaf0e62011-10-18 20:49:44 +00005873 diag::err_using_decl_constructor)
5874 << SS.getRange();
5875
David Blaikie4e4d0842012-03-11 07:00:24 +00005876 if (getLangOpts().CPlusPlus0x) break;
John McCall604e7f12009-12-08 07:46:18 +00005877
John McCalld226f652010-08-21 09:40:31 +00005878 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005879
5880 case UnqualifiedId::IK_DestructorName:
Daniel Dunbar96a00142012-03-09 18:35:03 +00005881 Diag(Name.getLocStart(), diag::err_using_decl_destructor)
Douglas Gregor12c118a2009-11-04 16:30:06 +00005882 << SS.getRange();
John McCalld226f652010-08-21 09:40:31 +00005883 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005884
5885 case UnqualifiedId::IK_TemplateId:
Daniel Dunbar96a00142012-03-09 18:35:03 +00005886 Diag(Name.getLocStart(), diag::err_using_decl_template_id)
Douglas Gregor12c118a2009-11-04 16:30:06 +00005887 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
John McCalld226f652010-08-21 09:40:31 +00005888 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005889 }
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00005890
5891 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
5892 DeclarationName TargetName = TargetNameInfo.getName();
John McCall604e7f12009-12-08 07:46:18 +00005893 if (!TargetName)
John McCalld226f652010-08-21 09:40:31 +00005894 return 0;
John McCall604e7f12009-12-08 07:46:18 +00005895
John McCall60fa3cf2009-12-11 02:10:03 +00005896 // Warn about using declarations.
5897 // TODO: store that the declaration was written without 'using' and
5898 // talk about access decls instead of using decls in the
5899 // diagnostics.
5900 if (!HasUsingKeyword) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00005901 UsingLoc = Name.getLocStart();
John McCall60fa3cf2009-12-11 02:10:03 +00005902
5903 Diag(UsingLoc, diag::warn_access_decl_deprecated)
Douglas Gregor849b2432010-03-31 17:46:05 +00005904 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
John McCall60fa3cf2009-12-11 02:10:03 +00005905 }
5906
Douglas Gregor56c04582010-12-16 00:46:58 +00005907 if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
5908 DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
5909 return 0;
5910
John McCall9488ea12009-11-17 05:59:44 +00005911 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00005912 TargetNameInfo, AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00005913 /* IsInstantiation */ false,
5914 IsTypeName, TypenameLoc);
John McCalled976492009-12-04 22:46:56 +00005915 if (UD)
5916 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump1eb44332009-09-09 15:08:12 +00005917
John McCalld226f652010-08-21 09:40:31 +00005918 return UD;
Anders Carlssonc72160b2009-08-28 05:40:36 +00005919}
5920
Douglas Gregor09acc982010-07-07 23:08:52 +00005921/// \brief Determine whether a using declaration considers the given
5922/// declarations as "equivalent", e.g., if they are redeclarations of
5923/// the same entity or are both typedefs of the same type.
5924static bool
5925IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2,
5926 bool &SuppressRedeclaration) {
5927 if (D1->getCanonicalDecl() == D2->getCanonicalDecl()) {
5928 SuppressRedeclaration = false;
5929 return true;
5930 }
5931
Richard Smith162e1c12011-04-15 14:24:37 +00005932 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
5933 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2)) {
Douglas Gregor09acc982010-07-07 23:08:52 +00005934 SuppressRedeclaration = true;
5935 return Context.hasSameType(TD1->getUnderlyingType(),
5936 TD2->getUnderlyingType());
5937 }
5938
5939 return false;
5940}
5941
5942
John McCall9f54ad42009-12-10 09:41:52 +00005943/// Determines whether to create a using shadow decl for a particular
5944/// decl, given the set of decls existing prior to this using lookup.
5945bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
5946 const LookupResult &Previous) {
5947 // Diagnose finding a decl which is not from a base class of the
5948 // current class. We do this now because there are cases where this
5949 // function will silently decide not to build a shadow decl, which
5950 // will pre-empt further diagnostics.
5951 //
5952 // We don't need to do this in C++0x because we do the check once on
5953 // the qualifier.
5954 //
5955 // FIXME: diagnose the following if we care enough:
5956 // struct A { int foo; };
5957 // struct B : A { using A::foo; };
5958 // template <class T> struct C : A {};
5959 // template <class T> struct D : C<T> { using B::foo; } // <---
5960 // This is invalid (during instantiation) in C++03 because B::foo
5961 // resolves to the using decl in B, which is not a base class of D<T>.
5962 // We can't diagnose it immediately because C<T> is an unknown
5963 // specialization. The UsingShadowDecl in D<T> then points directly
5964 // to A::foo, which will look well-formed when we instantiate.
5965 // The right solution is to not collapse the shadow-decl chain.
David Blaikie4e4d0842012-03-11 07:00:24 +00005966 if (!getLangOpts().CPlusPlus0x && CurContext->isRecord()) {
John McCall9f54ad42009-12-10 09:41:52 +00005967 DeclContext *OrigDC = Orig->getDeclContext();
5968
5969 // Handle enums and anonymous structs.
5970 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
5971 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
5972 while (OrigRec->isAnonymousStructOrUnion())
5973 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
5974
5975 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
5976 if (OrigDC == CurContext) {
5977 Diag(Using->getLocation(),
5978 diag::err_using_decl_nested_name_specifier_is_current_class)
Douglas Gregordc355712011-02-25 00:36:19 +00005979 << Using->getQualifierLoc().getSourceRange();
John McCall9f54ad42009-12-10 09:41:52 +00005980 Diag(Orig->getLocation(), diag::note_using_decl_target);
5981 return true;
5982 }
5983
Douglas Gregordc355712011-02-25 00:36:19 +00005984 Diag(Using->getQualifierLoc().getBeginLoc(),
John McCall9f54ad42009-12-10 09:41:52 +00005985 diag::err_using_decl_nested_name_specifier_is_not_base_class)
Douglas Gregordc355712011-02-25 00:36:19 +00005986 << Using->getQualifier()
John McCall9f54ad42009-12-10 09:41:52 +00005987 << cast<CXXRecordDecl>(CurContext)
Douglas Gregordc355712011-02-25 00:36:19 +00005988 << Using->getQualifierLoc().getSourceRange();
John McCall9f54ad42009-12-10 09:41:52 +00005989 Diag(Orig->getLocation(), diag::note_using_decl_target);
5990 return true;
5991 }
5992 }
5993
5994 if (Previous.empty()) return false;
5995
5996 NamedDecl *Target = Orig;
5997 if (isa<UsingShadowDecl>(Target))
5998 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
5999
John McCalld7533ec2009-12-11 02:33:26 +00006000 // If the target happens to be one of the previous declarations, we
6001 // don't have a conflict.
6002 //
6003 // FIXME: but we might be increasing its access, in which case we
6004 // should redeclare it.
6005 NamedDecl *NonTag = 0, *Tag = 0;
6006 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6007 I != E; ++I) {
6008 NamedDecl *D = (*I)->getUnderlyingDecl();
Douglas Gregor09acc982010-07-07 23:08:52 +00006009 bool Result;
6010 if (IsEquivalentForUsingDecl(Context, D, Target, Result))
6011 return Result;
John McCalld7533ec2009-12-11 02:33:26 +00006012
6013 (isa<TagDecl>(D) ? Tag : NonTag) = D;
6014 }
6015
John McCall9f54ad42009-12-10 09:41:52 +00006016 if (Target->isFunctionOrFunctionTemplate()) {
6017 FunctionDecl *FD;
6018 if (isa<FunctionTemplateDecl>(Target))
6019 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
6020 else
6021 FD = cast<FunctionDecl>(Target);
6022
6023 NamedDecl *OldDecl = 0;
John McCallad00b772010-06-16 08:42:20 +00006024 switch (CheckOverload(0, FD, Previous, OldDecl, /*IsForUsingDecl*/ true)) {
John McCall9f54ad42009-12-10 09:41:52 +00006025 case Ovl_Overload:
6026 return false;
6027
6028 case Ovl_NonFunction:
John McCall41ce66f2009-12-10 19:51:03 +00006029 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006030 break;
6031
6032 // We found a decl with the exact signature.
6033 case Ovl_Match:
John McCall9f54ad42009-12-10 09:41:52 +00006034 // If we're in a record, we want to hide the target, so we
6035 // return true (without a diagnostic) to tell the caller not to
6036 // build a shadow decl.
6037 if (CurContext->isRecord())
6038 return true;
6039
6040 // If we're not in a record, this is an error.
John McCall41ce66f2009-12-10 19:51:03 +00006041 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006042 break;
6043 }
6044
6045 Diag(Target->getLocation(), diag::note_using_decl_target);
6046 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
6047 return true;
6048 }
6049
6050 // Target is not a function.
6051
John McCall9f54ad42009-12-10 09:41:52 +00006052 if (isa<TagDecl>(Target)) {
6053 // No conflict between a tag and a non-tag.
6054 if (!Tag) return false;
6055
John McCall41ce66f2009-12-10 19:51:03 +00006056 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006057 Diag(Target->getLocation(), diag::note_using_decl_target);
6058 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
6059 return true;
6060 }
6061
6062 // No conflict between a tag and a non-tag.
6063 if (!NonTag) return false;
6064
John McCall41ce66f2009-12-10 19:51:03 +00006065 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006066 Diag(Target->getLocation(), diag::note_using_decl_target);
6067 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
6068 return true;
6069}
6070
John McCall9488ea12009-11-17 05:59:44 +00006071/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall604e7f12009-12-08 07:46:18 +00006072UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall604e7f12009-12-08 07:46:18 +00006073 UsingDecl *UD,
6074 NamedDecl *Orig) {
John McCall9488ea12009-11-17 05:59:44 +00006075
6076 // If we resolved to another shadow declaration, just coalesce them.
John McCall604e7f12009-12-08 07:46:18 +00006077 NamedDecl *Target = Orig;
6078 if (isa<UsingShadowDecl>(Target)) {
6079 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
6080 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall9488ea12009-11-17 05:59:44 +00006081 }
6082
6083 UsingShadowDecl *Shadow
John McCall604e7f12009-12-08 07:46:18 +00006084 = UsingShadowDecl::Create(Context, CurContext,
6085 UD->getLocation(), UD, Target);
John McCall9488ea12009-11-17 05:59:44 +00006086 UD->addShadowDecl(Shadow);
Douglas Gregore80622f2010-09-29 04:25:11 +00006087
6088 Shadow->setAccess(UD->getAccess());
6089 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
6090 Shadow->setInvalidDecl();
6091
John McCall9488ea12009-11-17 05:59:44 +00006092 if (S)
John McCall604e7f12009-12-08 07:46:18 +00006093 PushOnScopeChains(Shadow, S);
John McCall9488ea12009-11-17 05:59:44 +00006094 else
John McCall604e7f12009-12-08 07:46:18 +00006095 CurContext->addDecl(Shadow);
John McCall9488ea12009-11-17 05:59:44 +00006096
John McCall604e7f12009-12-08 07:46:18 +00006097
John McCall9f54ad42009-12-10 09:41:52 +00006098 return Shadow;
6099}
John McCall604e7f12009-12-08 07:46:18 +00006100
John McCall9f54ad42009-12-10 09:41:52 +00006101/// Hides a using shadow declaration. This is required by the current
6102/// using-decl implementation when a resolvable using declaration in a
6103/// class is followed by a declaration which would hide or override
6104/// one or more of the using decl's targets; for example:
6105///
6106/// struct Base { void foo(int); };
6107/// struct Derived : Base {
6108/// using Base::foo;
6109/// void foo(int);
6110/// };
6111///
6112/// The governing language is C++03 [namespace.udecl]p12:
6113///
6114/// When a using-declaration brings names from a base class into a
6115/// derived class scope, member functions in the derived class
6116/// override and/or hide member functions with the same name and
6117/// parameter types in a base class (rather than conflicting).
6118///
6119/// There are two ways to implement this:
6120/// (1) optimistically create shadow decls when they're not hidden
6121/// by existing declarations, or
6122/// (2) don't create any shadow decls (or at least don't make them
6123/// visible) until we've fully parsed/instantiated the class.
6124/// The problem with (1) is that we might have to retroactively remove
6125/// a shadow decl, which requires several O(n) operations because the
6126/// decl structures are (very reasonably) not designed for removal.
6127/// (2) avoids this but is very fiddly and phase-dependent.
6128void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
John McCall32daa422010-03-31 01:36:47 +00006129 if (Shadow->getDeclName().getNameKind() ==
6130 DeclarationName::CXXConversionFunctionName)
6131 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
6132
John McCall9f54ad42009-12-10 09:41:52 +00006133 // Remove it from the DeclContext...
6134 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00006135
John McCall9f54ad42009-12-10 09:41:52 +00006136 // ...and the scope, if applicable...
6137 if (S) {
John McCalld226f652010-08-21 09:40:31 +00006138 S->RemoveDecl(Shadow);
John McCall9f54ad42009-12-10 09:41:52 +00006139 IdResolver.RemoveDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00006140 }
6141
John McCall9f54ad42009-12-10 09:41:52 +00006142 // ...and the using decl.
6143 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
6144
6145 // TODO: complain somehow if Shadow was used. It shouldn't
John McCall32daa422010-03-31 01:36:47 +00006146 // be possible for this to happen, because...?
John McCall9488ea12009-11-17 05:59:44 +00006147}
6148
John McCall7ba107a2009-11-18 02:36:19 +00006149/// Builds a using declaration.
6150///
6151/// \param IsInstantiation - Whether this call arises from an
6152/// instantiation of an unresolved using declaration. We treat
6153/// the lookup differently for these declarations.
John McCall9488ea12009-11-17 05:59:44 +00006154NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
6155 SourceLocation UsingLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00006156 CXXScopeSpec &SS,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006157 const DeclarationNameInfo &NameInfo,
Anders Carlssonc72160b2009-08-28 05:40:36 +00006158 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00006159 bool IsInstantiation,
6160 bool IsTypeName,
6161 SourceLocation TypenameLoc) {
Anders Carlssonc72160b2009-08-28 05:40:36 +00006162 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006163 SourceLocation IdentLoc = NameInfo.getLoc();
Anders Carlssonc72160b2009-08-28 05:40:36 +00006164 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman2a16a132009-08-27 05:09:36 +00006165
Anders Carlsson550b14b2009-08-28 05:49:21 +00006166 // FIXME: We ignore attributes for now.
Mike Stump1eb44332009-09-09 15:08:12 +00006167
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006168 if (SS.isEmpty()) {
6169 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlssonc72160b2009-08-28 05:40:36 +00006170 return 0;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006171 }
Mike Stump1eb44332009-09-09 15:08:12 +00006172
John McCall9f54ad42009-12-10 09:41:52 +00006173 // Do the redeclaration lookup in the current scope.
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006174 LookupResult Previous(*this, NameInfo, LookupUsingDeclName,
John McCall9f54ad42009-12-10 09:41:52 +00006175 ForRedeclaration);
6176 Previous.setHideTags(false);
6177 if (S) {
6178 LookupName(Previous, S);
6179
6180 // It is really dumb that we have to do this.
6181 LookupResult::Filter F = Previous.makeFilter();
6182 while (F.hasNext()) {
6183 NamedDecl *D = F.next();
6184 if (!isDeclInScope(D, CurContext, S))
6185 F.erase();
6186 }
6187 F.done();
6188 } else {
6189 assert(IsInstantiation && "no scope in non-instantiation");
6190 assert(CurContext->isRecord() && "scope not record in instantiation");
6191 LookupQualifiedName(Previous, CurContext);
6192 }
6193
John McCall9f54ad42009-12-10 09:41:52 +00006194 // Check for invalid redeclarations.
6195 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
6196 return 0;
6197
6198 // Check for bad qualifiers.
John McCalled976492009-12-04 22:46:56 +00006199 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
6200 return 0;
6201
John McCallaf8e6ed2009-11-12 03:15:40 +00006202 DeclContext *LookupContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00006203 NamedDecl *D;
Douglas Gregordc355712011-02-25 00:36:19 +00006204 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCallaf8e6ed2009-11-12 03:15:40 +00006205 if (!LookupContext) {
John McCall7ba107a2009-11-18 02:36:19 +00006206 if (IsTypeName) {
John McCalled976492009-12-04 22:46:56 +00006207 // FIXME: not all declaration name kinds are legal here
6208 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
6209 UsingLoc, TypenameLoc,
Douglas Gregordc355712011-02-25 00:36:19 +00006210 QualifierLoc,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006211 IdentLoc, NameInfo.getName());
John McCalled976492009-12-04 22:46:56 +00006212 } else {
Douglas Gregordc355712011-02-25 00:36:19 +00006213 D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
6214 QualifierLoc, NameInfo);
John McCall7ba107a2009-11-18 02:36:19 +00006215 }
John McCalled976492009-12-04 22:46:56 +00006216 } else {
Douglas Gregordc355712011-02-25 00:36:19 +00006217 D = UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
6218 NameInfo, IsTypeName);
Anders Carlsson550b14b2009-08-28 05:49:21 +00006219 }
John McCalled976492009-12-04 22:46:56 +00006220 D->setAccess(AS);
6221 CurContext->addDecl(D);
6222
6223 if (!LookupContext) return D;
6224 UsingDecl *UD = cast<UsingDecl>(D);
Mike Stump1eb44332009-09-09 15:08:12 +00006225
John McCall77bb1aa2010-05-01 00:40:08 +00006226 if (RequireCompleteDeclContext(SS, LookupContext)) {
John McCall604e7f12009-12-08 07:46:18 +00006227 UD->setInvalidDecl();
6228 return UD;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006229 }
6230
Richard Smithc5a89a12012-04-02 01:30:27 +00006231 // The normal rules do not apply to inheriting constructor declarations.
Sebastian Redlf677ea32011-02-05 19:23:19 +00006232 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
Richard Smithc5a89a12012-04-02 01:30:27 +00006233 if (CheckInheritingConstructorUsingDecl(UD))
Sebastian Redlcaa35e42011-03-12 13:44:32 +00006234 UD->setInvalidDecl();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006235 return UD;
6236 }
6237
6238 // Otherwise, look up the target name.
John McCall604e7f12009-12-08 07:46:18 +00006239
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006240 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCall7ba107a2009-11-18 02:36:19 +00006241
John McCall604e7f12009-12-08 07:46:18 +00006242 // Unlike most lookups, we don't always want to hide tag
6243 // declarations: tag names are visible through the using declaration
6244 // even if hidden by ordinary names, *except* in a dependent context
6245 // where it's important for the sanity of two-phase lookup.
John McCall7ba107a2009-11-18 02:36:19 +00006246 if (!IsInstantiation)
6247 R.setHideTags(false);
John McCall9488ea12009-11-17 05:59:44 +00006248
John McCallb9abd8722012-04-07 03:04:20 +00006249 // For the purposes of this lookup, we have a base object type
6250 // equal to that of the current context.
6251 if (CurContext->isRecord()) {
6252 R.setBaseObjectType(
6253 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
6254 }
6255
John McCalla24dc2e2009-11-17 02:14:36 +00006256 LookupQualifiedName(R, LookupContext);
Mike Stump1eb44332009-09-09 15:08:12 +00006257
John McCallf36e02d2009-10-09 21:13:30 +00006258 if (R.empty()) {
Douglas Gregor3f093272009-10-13 21:16:44 +00006259 Diag(IdentLoc, diag::err_no_member)
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006260 << NameInfo.getName() << LookupContext << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00006261 UD->setInvalidDecl();
6262 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00006263 }
6264
John McCalled976492009-12-04 22:46:56 +00006265 if (R.isAmbiguous()) {
6266 UD->setInvalidDecl();
6267 return UD;
6268 }
Mike Stump1eb44332009-09-09 15:08:12 +00006269
John McCall7ba107a2009-11-18 02:36:19 +00006270 if (IsTypeName) {
6271 // If we asked for a typename and got a non-type decl, error out.
John McCalled976492009-12-04 22:46:56 +00006272 if (!R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00006273 Diag(IdentLoc, diag::err_using_typename_non_type);
6274 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
6275 Diag((*I)->getUnderlyingDecl()->getLocation(),
6276 diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00006277 UD->setInvalidDecl();
6278 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00006279 }
6280 } else {
6281 // If we asked for a non-typename and we got a type, error out,
6282 // but only if this is an instantiation of an unresolved using
6283 // decl. Otherwise just silently find the type name.
John McCalled976492009-12-04 22:46:56 +00006284 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00006285 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
6286 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00006287 UD->setInvalidDecl();
6288 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00006289 }
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006290 }
6291
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006292 // C++0x N2914 [namespace.udecl]p6:
6293 // A using-declaration shall not name a namespace.
John McCalled976492009-12-04 22:46:56 +00006294 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006295 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
6296 << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00006297 UD->setInvalidDecl();
6298 return UD;
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006299 }
Mike Stump1eb44332009-09-09 15:08:12 +00006300
John McCall9f54ad42009-12-10 09:41:52 +00006301 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
6302 if (!CheckUsingShadowDecl(UD, *I, Previous))
6303 BuildUsingShadowDecl(S, UD, *I);
6304 }
John McCall9488ea12009-11-17 05:59:44 +00006305
6306 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00006307}
6308
Sebastian Redlf677ea32011-02-05 19:23:19 +00006309/// Additional checks for a using declaration referring to a constructor name.
Richard Smithc5a89a12012-04-02 01:30:27 +00006310bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
6311 assert(!UD->isTypeName() && "expecting a constructor name");
Sebastian Redlf677ea32011-02-05 19:23:19 +00006312
Douglas Gregordc355712011-02-25 00:36:19 +00006313 const Type *SourceType = UD->getQualifier()->getAsType();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006314 assert(SourceType &&
6315 "Using decl naming constructor doesn't have type in scope spec.");
6316 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
6317
6318 // Check whether the named type is a direct base class.
6319 CanQualType CanonicalSourceType = SourceType->getCanonicalTypeUnqualified();
6320 CXXRecordDecl::base_class_iterator BaseIt, BaseE;
6321 for (BaseIt = TargetClass->bases_begin(), BaseE = TargetClass->bases_end();
6322 BaseIt != BaseE; ++BaseIt) {
6323 CanQualType BaseType = BaseIt->getType()->getCanonicalTypeUnqualified();
6324 if (CanonicalSourceType == BaseType)
6325 break;
Richard Smithc5a89a12012-04-02 01:30:27 +00006326 if (BaseIt->getType()->isDependentType())
6327 break;
Sebastian Redlf677ea32011-02-05 19:23:19 +00006328 }
6329
6330 if (BaseIt == BaseE) {
6331 // Did not find SourceType in the bases.
6332 Diag(UD->getUsingLocation(),
6333 diag::err_using_decl_constructor_not_in_direct_base)
6334 << UD->getNameInfo().getSourceRange()
6335 << QualType(SourceType, 0) << TargetClass;
6336 return true;
6337 }
6338
Richard Smithc5a89a12012-04-02 01:30:27 +00006339 if (!CurContext->isDependentContext())
6340 BaseIt->setInheritConstructors();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006341
6342 return false;
6343}
6344
John McCall9f54ad42009-12-10 09:41:52 +00006345/// Checks that the given using declaration is not an invalid
6346/// redeclaration. Note that this is checking only for the using decl
6347/// itself, not for any ill-formedness among the UsingShadowDecls.
6348bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
6349 bool isTypeName,
6350 const CXXScopeSpec &SS,
6351 SourceLocation NameLoc,
6352 const LookupResult &Prev) {
6353 // C++03 [namespace.udecl]p8:
6354 // C++0x [namespace.udecl]p10:
6355 // A using-declaration is a declaration and can therefore be used
6356 // repeatedly where (and only where) multiple declarations are
6357 // allowed.
Douglas Gregora97badf2010-05-06 23:31:27 +00006358 //
John McCall8a726212010-11-29 18:01:58 +00006359 // That's in non-member contexts.
6360 if (!CurContext->getRedeclContext()->isRecord())
John McCall9f54ad42009-12-10 09:41:52 +00006361 return false;
6362
6363 NestedNameSpecifier *Qual
6364 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
6365
6366 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
6367 NamedDecl *D = *I;
6368
6369 bool DTypename;
6370 NestedNameSpecifier *DQual;
6371 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
6372 DTypename = UD->isTypeName();
Douglas Gregordc355712011-02-25 00:36:19 +00006373 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006374 } else if (UnresolvedUsingValueDecl *UD
6375 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
6376 DTypename = false;
Douglas Gregordc355712011-02-25 00:36:19 +00006377 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006378 } else if (UnresolvedUsingTypenameDecl *UD
6379 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
6380 DTypename = true;
Douglas Gregordc355712011-02-25 00:36:19 +00006381 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006382 } else continue;
6383
6384 // using decls differ if one says 'typename' and the other doesn't.
6385 // FIXME: non-dependent using decls?
6386 if (isTypeName != DTypename) continue;
6387
6388 // using decls differ if they name different scopes (but note that
6389 // template instantiation can cause this check to trigger when it
6390 // didn't before instantiation).
6391 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
6392 Context.getCanonicalNestedNameSpecifier(DQual))
6393 continue;
6394
6395 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCall41ce66f2009-12-10 19:51:03 +00006396 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall9f54ad42009-12-10 09:41:52 +00006397 return true;
6398 }
6399
6400 return false;
6401}
6402
John McCall604e7f12009-12-08 07:46:18 +00006403
John McCalled976492009-12-04 22:46:56 +00006404/// Checks that the given nested-name qualifier used in a using decl
6405/// in the current context is appropriately related to the current
6406/// scope. If an error is found, diagnoses it and returns true.
6407bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
6408 const CXXScopeSpec &SS,
6409 SourceLocation NameLoc) {
John McCall604e7f12009-12-08 07:46:18 +00006410 DeclContext *NamedContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00006411
John McCall604e7f12009-12-08 07:46:18 +00006412 if (!CurContext->isRecord()) {
6413 // C++03 [namespace.udecl]p3:
6414 // C++0x [namespace.udecl]p8:
6415 // A using-declaration for a class member shall be a member-declaration.
6416
6417 // If we weren't able to compute a valid scope, it must be a
6418 // dependent class scope.
6419 if (!NamedContext || NamedContext->isRecord()) {
6420 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
6421 << SS.getRange();
6422 return true;
6423 }
6424
6425 // Otherwise, everything is known to be fine.
6426 return false;
6427 }
6428
6429 // The current scope is a record.
6430
6431 // If the named context is dependent, we can't decide much.
6432 if (!NamedContext) {
6433 // FIXME: in C++0x, we can diagnose if we can prove that the
6434 // nested-name-specifier does not refer to a base class, which is
6435 // still possible in some cases.
6436
6437 // Otherwise we have to conservatively report that things might be
6438 // okay.
6439 return false;
6440 }
6441
6442 if (!NamedContext->isRecord()) {
6443 // Ideally this would point at the last name in the specifier,
6444 // but we don't have that level of source info.
6445 Diag(SS.getRange().getBegin(),
6446 diag::err_using_decl_nested_name_specifier_is_not_class)
6447 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
6448 return true;
6449 }
6450
Douglas Gregor6fb07292010-12-21 07:41:49 +00006451 if (!NamedContext->isDependentContext() &&
6452 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
6453 return true;
6454
David Blaikie4e4d0842012-03-11 07:00:24 +00006455 if (getLangOpts().CPlusPlus0x) {
John McCall604e7f12009-12-08 07:46:18 +00006456 // C++0x [namespace.udecl]p3:
6457 // In a using-declaration used as a member-declaration, the
6458 // nested-name-specifier shall name a base class of the class
6459 // being defined.
6460
6461 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
6462 cast<CXXRecordDecl>(NamedContext))) {
6463 if (CurContext == NamedContext) {
6464 Diag(NameLoc,
6465 diag::err_using_decl_nested_name_specifier_is_current_class)
6466 << SS.getRange();
6467 return true;
6468 }
6469
6470 Diag(SS.getRange().getBegin(),
6471 diag::err_using_decl_nested_name_specifier_is_not_base_class)
6472 << (NestedNameSpecifier*) SS.getScopeRep()
6473 << cast<CXXRecordDecl>(CurContext)
6474 << SS.getRange();
6475 return true;
6476 }
6477
6478 return false;
6479 }
6480
6481 // C++03 [namespace.udecl]p4:
6482 // A using-declaration used as a member-declaration shall refer
6483 // to a member of a base class of the class being defined [etc.].
6484
6485 // Salient point: SS doesn't have to name a base class as long as
6486 // lookup only finds members from base classes. Therefore we can
6487 // diagnose here only if we can prove that that can't happen,
6488 // i.e. if the class hierarchies provably don't intersect.
6489
6490 // TODO: it would be nice if "definitely valid" results were cached
6491 // in the UsingDecl and UsingShadowDecl so that these checks didn't
6492 // need to be repeated.
6493
6494 struct UserData {
Benjamin Kramer8c43dcc2012-02-23 16:06:01 +00006495 llvm::SmallPtrSet<const CXXRecordDecl*, 4> Bases;
John McCall604e7f12009-12-08 07:46:18 +00006496
6497 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
6498 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
6499 Data->Bases.insert(Base);
6500 return true;
6501 }
6502
6503 bool hasDependentBases(const CXXRecordDecl *Class) {
6504 return !Class->forallBases(collect, this);
6505 }
6506
6507 /// Returns true if the base is dependent or is one of the
6508 /// accumulated base classes.
6509 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
6510 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
6511 return !Data->Bases.count(Base);
6512 }
6513
6514 bool mightShareBases(const CXXRecordDecl *Class) {
6515 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
6516 }
6517 };
6518
6519 UserData Data;
6520
6521 // Returns false if we find a dependent base.
6522 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
6523 return false;
6524
6525 // Returns false if the class has a dependent base or if it or one
6526 // of its bases is present in the base set of the current context.
6527 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
6528 return false;
6529
6530 Diag(SS.getRange().getBegin(),
6531 diag::err_using_decl_nested_name_specifier_is_not_base_class)
6532 << (NestedNameSpecifier*) SS.getScopeRep()
6533 << cast<CXXRecordDecl>(CurContext)
6534 << SS.getRange();
6535
6536 return true;
John McCalled976492009-12-04 22:46:56 +00006537}
6538
Richard Smith162e1c12011-04-15 14:24:37 +00006539Decl *Sema::ActOnAliasDeclaration(Scope *S,
6540 AccessSpecifier AS,
Richard Smith3e4c6c42011-05-05 21:57:07 +00006541 MultiTemplateParamsArg TemplateParamLists,
Richard Smith162e1c12011-04-15 14:24:37 +00006542 SourceLocation UsingLoc,
6543 UnqualifiedId &Name,
6544 TypeResult Type) {
Richard Smith3e4c6c42011-05-05 21:57:07 +00006545 // Skip up to the relevant declaration scope.
6546 while (S->getFlags() & Scope::TemplateParamScope)
6547 S = S->getParent();
Richard Smith162e1c12011-04-15 14:24:37 +00006548 assert((S->getFlags() & Scope::DeclScope) &&
6549 "got alias-declaration outside of declaration scope");
6550
6551 if (Type.isInvalid())
6552 return 0;
6553
6554 bool Invalid = false;
6555 DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
6556 TypeSourceInfo *TInfo = 0;
Nick Lewyckyb79bf1d2011-05-02 01:07:19 +00006557 GetTypeFromParser(Type.get(), &TInfo);
Richard Smith162e1c12011-04-15 14:24:37 +00006558
6559 if (DiagnoseClassNameShadow(CurContext, NameInfo))
6560 return 0;
6561
6562 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
Richard Smith3e4c6c42011-05-05 21:57:07 +00006563 UPPC_DeclarationType)) {
Richard Smith162e1c12011-04-15 14:24:37 +00006564 Invalid = true;
Richard Smith3e4c6c42011-05-05 21:57:07 +00006565 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
6566 TInfo->getTypeLoc().getBeginLoc());
6567 }
Richard Smith162e1c12011-04-15 14:24:37 +00006568
6569 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, ForRedeclaration);
6570 LookupName(Previous, S);
6571
6572 // Warn about shadowing the name of a template parameter.
6573 if (Previous.isSingleResult() &&
6574 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregorcb8f9512011-10-20 17:58:49 +00006575 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
Richard Smith162e1c12011-04-15 14:24:37 +00006576 Previous.clear();
6577 }
6578
6579 assert(Name.Kind == UnqualifiedId::IK_Identifier &&
6580 "name in alias declaration must be an identifier");
6581 TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
6582 Name.StartLocation,
6583 Name.Identifier, TInfo);
6584
6585 NewTD->setAccess(AS);
6586
6587 if (Invalid)
6588 NewTD->setInvalidDecl();
6589
Richard Smith3e4c6c42011-05-05 21:57:07 +00006590 CheckTypedefForVariablyModifiedType(S, NewTD);
6591 Invalid |= NewTD->isInvalidDecl();
6592
Richard Smith162e1c12011-04-15 14:24:37 +00006593 bool Redeclaration = false;
Richard Smith3e4c6c42011-05-05 21:57:07 +00006594
6595 NamedDecl *NewND;
6596 if (TemplateParamLists.size()) {
6597 TypeAliasTemplateDecl *OldDecl = 0;
6598 TemplateParameterList *OldTemplateParams = 0;
6599
6600 if (TemplateParamLists.size() != 1) {
6601 Diag(UsingLoc, diag::err_alias_template_extra_headers)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006602 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
6603 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
Richard Smith3e4c6c42011-05-05 21:57:07 +00006604 }
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006605 TemplateParameterList *TemplateParams = TemplateParamLists[0];
Richard Smith3e4c6c42011-05-05 21:57:07 +00006606
6607 // Only consider previous declarations in the same scope.
6608 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
6609 /*ExplicitInstantiationOrSpecialization*/false);
6610 if (!Previous.empty()) {
6611 Redeclaration = true;
6612
6613 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
6614 if (!OldDecl && !Invalid) {
6615 Diag(UsingLoc, diag::err_redefinition_different_kind)
6616 << Name.Identifier;
6617
6618 NamedDecl *OldD = Previous.getRepresentativeDecl();
6619 if (OldD->getLocation().isValid())
6620 Diag(OldD->getLocation(), diag::note_previous_definition);
6621
6622 Invalid = true;
6623 }
6624
6625 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
6626 if (TemplateParameterListsAreEqual(TemplateParams,
6627 OldDecl->getTemplateParameters(),
6628 /*Complain=*/true,
6629 TPL_TemplateMatch))
6630 OldTemplateParams = OldDecl->getTemplateParameters();
6631 else
6632 Invalid = true;
6633
6634 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
6635 if (!Invalid &&
6636 !Context.hasSameType(OldTD->getUnderlyingType(),
6637 NewTD->getUnderlyingType())) {
6638 // FIXME: The C++0x standard does not clearly say this is ill-formed,
6639 // but we can't reasonably accept it.
6640 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
6641 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
6642 if (OldTD->getLocation().isValid())
6643 Diag(OldTD->getLocation(), diag::note_previous_definition);
6644 Invalid = true;
6645 }
6646 }
6647 }
6648
6649 // Merge any previous default template arguments into our parameters,
6650 // and check the parameter list.
6651 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
6652 TPC_TypeAliasTemplate))
6653 return 0;
6654
6655 TypeAliasTemplateDecl *NewDecl =
6656 TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
6657 Name.Identifier, TemplateParams,
6658 NewTD);
6659
6660 NewDecl->setAccess(AS);
6661
6662 if (Invalid)
6663 NewDecl->setInvalidDecl();
6664 else if (OldDecl)
6665 NewDecl->setPreviousDeclaration(OldDecl);
6666
6667 NewND = NewDecl;
6668 } else {
6669 ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
6670 NewND = NewTD;
6671 }
Richard Smith162e1c12011-04-15 14:24:37 +00006672
6673 if (!Redeclaration)
Richard Smith3e4c6c42011-05-05 21:57:07 +00006674 PushOnScopeChains(NewND, S);
Richard Smith162e1c12011-04-15 14:24:37 +00006675
Dmitri Gribenkoc27bc802012-08-02 20:49:51 +00006676 ActOnDocumentableDecl(NewND);
Richard Smith3e4c6c42011-05-05 21:57:07 +00006677 return NewND;
Richard Smith162e1c12011-04-15 14:24:37 +00006678}
6679
John McCalld226f652010-08-21 09:40:31 +00006680Decl *Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00006681 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00006682 SourceLocation AliasLoc,
6683 IdentifierInfo *Alias,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00006684 CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00006685 SourceLocation IdentLoc,
6686 IdentifierInfo *Ident) {
Mike Stump1eb44332009-09-09 15:08:12 +00006687
Anders Carlsson81c85c42009-03-28 23:53:49 +00006688 // Lookup the namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00006689 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
6690 LookupParsedName(R, S, &SS);
Anders Carlsson81c85c42009-03-28 23:53:49 +00006691
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006692 // Check if we have a previous declaration with the same name.
Douglas Gregorae374752010-05-03 15:37:31 +00006693 NamedDecl *PrevDecl
6694 = LookupSingleName(S, Alias, AliasLoc, LookupOrdinaryName,
6695 ForRedeclaration);
6696 if (PrevDecl && !isDeclInScope(PrevDecl, CurContext, S))
6697 PrevDecl = 0;
6698
6699 if (PrevDecl) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00006700 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00006701 // We already have an alias with the same name that points to the same
Anders Carlsson81c85c42009-03-28 23:53:49 +00006702 // namespace, so don't create a new one.
Douglas Gregorc67b0322010-03-26 22:59:39 +00006703 // FIXME: At some point, we'll want to create the (redundant)
6704 // declaration to maintain better source information.
John McCallf36e02d2009-10-09 21:13:30 +00006705 if (!R.isAmbiguous() && !R.empty() &&
Douglas Gregorc67b0322010-03-26 22:59:39 +00006706 AD->getNamespace()->Equals(getNamespaceDecl(R.getFoundDecl())))
John McCalld226f652010-08-21 09:40:31 +00006707 return 0;
Anders Carlsson81c85c42009-03-28 23:53:49 +00006708 }
Mike Stump1eb44332009-09-09 15:08:12 +00006709
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006710 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
6711 diag::err_redefinition_different_kind;
6712 Diag(AliasLoc, DiagID) << Alias;
6713 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
John McCalld226f652010-08-21 09:40:31 +00006714 return 0;
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006715 }
6716
John McCalla24dc2e2009-11-17 02:14:36 +00006717 if (R.isAmbiguous())
John McCalld226f652010-08-21 09:40:31 +00006718 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00006719
John McCallf36e02d2009-10-09 21:13:30 +00006720 if (R.empty()) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00006721 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
Richard Smithbf9658c2012-04-05 23:13:23 +00006722 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
John McCalld226f652010-08-21 09:40:31 +00006723 return 0;
Douglas Gregor0e8c4b92010-06-29 18:55:19 +00006724 }
Anders Carlsson5721c682009-03-28 06:42:02 +00006725 }
Mike Stump1eb44332009-09-09 15:08:12 +00006726
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006727 NamespaceAliasDecl *AliasDecl =
Mike Stump1eb44332009-09-09 15:08:12 +00006728 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
Douglas Gregor0cfaf6a2011-02-25 17:08:07 +00006729 Alias, SS.getWithLocInContext(Context),
John McCallf36e02d2009-10-09 21:13:30 +00006730 IdentLoc, R.getFoundDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00006731
John McCall3dbd3d52010-02-16 06:53:13 +00006732 PushOnScopeChains(AliasDecl, S);
John McCalld226f652010-08-21 09:40:31 +00006733 return AliasDecl;
Anders Carlssondbb00942009-03-28 05:27:17 +00006734}
6735
Douglas Gregor39957dc2010-05-01 15:04:51 +00006736namespace {
6737 /// \brief Scoped object used to handle the state changes required in Sema
6738 /// to implicitly define the body of a C++ member function;
6739 class ImplicitlyDefinedFunctionScope {
6740 Sema &S;
John McCalleee1d542011-02-14 07:13:47 +00006741 Sema::ContextRAII SavedContext;
Douglas Gregor39957dc2010-05-01 15:04:51 +00006742
6743 public:
6744 ImplicitlyDefinedFunctionScope(Sema &S, CXXMethodDecl *Method)
John McCalleee1d542011-02-14 07:13:47 +00006745 : S(S), SavedContext(S, Method)
Douglas Gregor39957dc2010-05-01 15:04:51 +00006746 {
Douglas Gregor39957dc2010-05-01 15:04:51 +00006747 S.PushFunctionScope();
6748 S.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
6749 }
6750
6751 ~ImplicitlyDefinedFunctionScope() {
6752 S.PopExpressionEvaluationContext();
Eli Friedmanec9ea722012-01-05 03:35:19 +00006753 S.PopFunctionScopeInfo();
Douglas Gregor39957dc2010-05-01 15:04:51 +00006754 }
6755 };
6756}
6757
Sean Hunt001cad92011-05-10 00:49:42 +00006758Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00006759Sema::ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
6760 CXXMethodDecl *MD) {
6761 CXXRecordDecl *ClassDecl = MD->getParent();
6762
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006763 // C++ [except.spec]p14:
6764 // An implicitly declared special member function (Clause 12) shall have an
6765 // exception-specification. [...]
Richard Smithe6975e92012-04-17 00:58:00 +00006766 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00006767 if (ClassDecl->isInvalidDecl())
6768 return ExceptSpec;
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006769
Sebastian Redl60618fa2011-03-12 11:50:43 +00006770 // Direct base-class constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006771 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
6772 BEnd = ClassDecl->bases_end();
6773 B != BEnd; ++B) {
6774 if (B->isVirtual()) // Handled below.
6775 continue;
6776
Douglas Gregor18274032010-07-03 00:47:00 +00006777 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
6778 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Sean Huntb320e0c2011-06-10 03:50:41 +00006779 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
6780 // If this is a deleted function, add it anyway. This might be conformant
6781 // with the standard. This might not. I'm not sure. It might not matter.
6782 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006783 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006784 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006785 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00006786
6787 // Virtual base-class constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006788 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
6789 BEnd = ClassDecl->vbases_end();
6790 B != BEnd; ++B) {
Douglas Gregor18274032010-07-03 00:47:00 +00006791 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
6792 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Sean Huntb320e0c2011-06-10 03:50:41 +00006793 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
6794 // If this is a deleted function, add it anyway. This might be conformant
6795 // with the standard. This might not. I'm not sure. It might not matter.
6796 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006797 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006798 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006799 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00006800
6801 // Field constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006802 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
6803 FEnd = ClassDecl->field_end();
6804 F != FEnd; ++F) {
Richard Smith7a614d82011-06-11 17:19:42 +00006805 if (F->hasInClassInitializer()) {
6806 if (Expr *E = F->getInClassInitializer())
6807 ExceptSpec.CalledExpr(E);
6808 else if (!F->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00006809 // DR1351:
6810 // If the brace-or-equal-initializer of a non-static data member
6811 // invokes a defaulted default constructor of its class or of an
6812 // enclosing class in a potentially evaluated subexpression, the
6813 // program is ill-formed.
6814 //
6815 // This resolution is unworkable: the exception specification of the
6816 // default constructor can be needed in an unevaluated context, in
6817 // particular, in the operand of a noexcept-expression, and we can be
6818 // unable to compute an exception specification for an enclosed class.
6819 //
6820 // We do not allow an in-class initializer to require the evaluation
6821 // of the exception specification for any in-class initializer whose
6822 // definition is not lexically complete.
6823 Diag(Loc, diag::err_in_class_initializer_references_def_ctor) << MD;
Richard Smith7a614d82011-06-11 17:19:42 +00006824 } else if (const RecordType *RecordTy
Douglas Gregor18274032010-07-03 00:47:00 +00006825 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
Sean Huntb320e0c2011-06-10 03:50:41 +00006826 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
6827 CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
6828 // If this is a deleted function, add it anyway. This might be conformant
6829 // with the standard. This might not. I'm not sure. It might not matter.
6830 // In particular, the problem is that this function never gets called. It
6831 // might just be ill-formed because this function attempts to refer to
6832 // a deleted function here.
6833 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006834 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006835 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006836 }
John McCalle23cf432010-12-14 08:05:40 +00006837
Sean Hunt001cad92011-05-10 00:49:42 +00006838 return ExceptSpec;
6839}
6840
6841CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
6842 CXXRecordDecl *ClassDecl) {
6843 // C++ [class.ctor]p5:
6844 // A default constructor for a class X is a constructor of class X
6845 // that can be called without an argument. If there is no
6846 // user-declared constructor for class X, a default constructor is
6847 // implicitly declared. An implicitly-declared default constructor
6848 // is an inline public member of its class.
6849 assert(!ClassDecl->hasUserDeclaredConstructor() &&
6850 "Should not build implicit default constructor!");
6851
Richard Smith7756afa2012-06-10 05:43:50 +00006852 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
6853 CXXDefaultConstructor,
6854 false);
6855
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006856 // Create the actual constructor declaration.
Douglas Gregor32df23e2010-07-01 22:02:46 +00006857 CanQualType ClassType
6858 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00006859 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregor32df23e2010-07-01 22:02:46 +00006860 DeclarationName Name
6861 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00006862 DeclarationNameInfo NameInfo(Name, ClassLoc);
Richard Smith61802452011-12-22 02:22:31 +00006863 CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00006864 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00006865 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00006866 Constexpr);
Douglas Gregor32df23e2010-07-01 22:02:46 +00006867 DefaultCon->setAccess(AS_public);
Sean Hunt1e238652011-05-12 03:51:51 +00006868 DefaultCon->setDefaulted();
Douglas Gregor32df23e2010-07-01 22:02:46 +00006869 DefaultCon->setImplicit();
Sean Hunt023df372011-05-09 18:22:59 +00006870 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
Richard Smithb9d0b762012-07-27 04:22:15 +00006871
6872 // Build an exception specification pointing back at this constructor.
6873 FunctionProtoType::ExtProtoInfo EPI;
6874 EPI.ExceptionSpecType = EST_Unevaluated;
6875 EPI.ExceptionSpecDecl = DefaultCon;
6876 DefaultCon->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
6877
Douglas Gregor18274032010-07-03 00:47:00 +00006878 // Note that we have declared this constructor.
Douglas Gregor18274032010-07-03 00:47:00 +00006879 ++ASTContext::NumImplicitDefaultConstructorsDeclared;
6880
Douglas Gregor23c94db2010-07-02 17:43:08 +00006881 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor18274032010-07-03 00:47:00 +00006882 PushOnScopeChains(DefaultCon, S, false);
6883 ClassDecl->addDecl(DefaultCon);
Sean Hunt71a682f2011-05-18 03:41:58 +00006884
Sean Hunte16da072011-10-10 06:18:57 +00006885 if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
Sean Hunt71a682f2011-05-18 03:41:58 +00006886 DefaultCon->setDeletedAsWritten();
Douglas Gregor18274032010-07-03 00:47:00 +00006887
Douglas Gregor32df23e2010-07-01 22:02:46 +00006888 return DefaultCon;
6889}
6890
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006891void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
6892 CXXConstructorDecl *Constructor) {
Sean Hunt1e238652011-05-12 03:51:51 +00006893 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Sean Huntcd10dec2011-05-23 23:14:04 +00006894 !Constructor->doesThisDeclarationHaveABody() &&
6895 !Constructor->isDeleted()) &&
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00006896 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00006897
Anders Carlssonf6513ed2010-04-23 16:04:08 +00006898 CXXRecordDecl *ClassDecl = Constructor->getParent();
Eli Friedman80c30da2009-11-09 19:20:36 +00006899 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedman49c16da2009-11-09 01:05:47 +00006900
Douglas Gregor39957dc2010-05-01 15:04:51 +00006901 ImplicitlyDefinedFunctionScope Scope(*this, Constructor);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00006902 DiagnosticErrorTrap Trap(Diags);
Sean Huntcbb67482011-01-08 20:30:50 +00006903 if (SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false) ||
Douglas Gregorc63d2c82010-05-12 16:39:35 +00006904 Trap.hasErrorOccurred()) {
Anders Carlsson37909802009-11-30 21:24:50 +00006905 Diag(CurrentLocation, diag::note_member_synthesized_at)
Sean Huntf961ea52011-05-10 19:08:14 +00006906 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00006907 Constructor->setInvalidDecl();
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006908 return;
Eli Friedman80c30da2009-11-09 19:20:36 +00006909 }
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006910
6911 SourceLocation Loc = Constructor->getLocation();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00006912 Constructor->setBody(new (Context) CompoundStmt(Loc));
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006913
6914 Constructor->setUsed();
6915 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redl58a2cd82011-04-24 16:28:06 +00006916
6917 if (ASTMutationListener *L = getASTMutationListener()) {
6918 L->CompletedImplicitDefinition(Constructor);
6919 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006920}
6921
Richard Smith7a614d82011-06-11 17:19:42 +00006922void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
6923 if (!D) return;
6924 AdjustDeclIfTemplate(D);
6925
6926 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D);
Richard Smith7a614d82011-06-11 17:19:42 +00006927
Richard Smithb9d0b762012-07-27 04:22:15 +00006928 if (!ClassDecl->isDependentType())
6929 CheckExplicitlyDefaultedMethods(ClassDecl);
Richard Smith7a614d82011-06-11 17:19:42 +00006930}
6931
Sebastian Redlf677ea32011-02-05 19:23:19 +00006932void Sema::DeclareInheritedConstructors(CXXRecordDecl *ClassDecl) {
6933 // We start with an initial pass over the base classes to collect those that
6934 // inherit constructors from. If there are none, we can forgo all further
6935 // processing.
Chris Lattner5f9e2722011-07-23 10:55:15 +00006936 typedef SmallVector<const RecordType *, 4> BasesVector;
Sebastian Redlf677ea32011-02-05 19:23:19 +00006937 BasesVector BasesToInheritFrom;
6938 for (CXXRecordDecl::base_class_iterator BaseIt = ClassDecl->bases_begin(),
6939 BaseE = ClassDecl->bases_end();
6940 BaseIt != BaseE; ++BaseIt) {
6941 if (BaseIt->getInheritConstructors()) {
6942 QualType Base = BaseIt->getType();
6943 if (Base->isDependentType()) {
6944 // If we inherit constructors from anything that is dependent, just
6945 // abort processing altogether. We'll get another chance for the
6946 // instantiations.
6947 return;
6948 }
6949 BasesToInheritFrom.push_back(Base->castAs<RecordType>());
6950 }
6951 }
6952 if (BasesToInheritFrom.empty())
6953 return;
6954
6955 // Now collect the constructors that we already have in the current class.
6956 // Those take precedence over inherited constructors.
6957 // C++0x [class.inhctor]p3: [...] a constructor is implicitly declared [...]
6958 // unless there is a user-declared constructor with the same signature in
6959 // the class where the using-declaration appears.
6960 llvm::SmallSet<const Type *, 8> ExistingConstructors;
6961 for (CXXRecordDecl::ctor_iterator CtorIt = ClassDecl->ctor_begin(),
6962 CtorE = ClassDecl->ctor_end();
6963 CtorIt != CtorE; ++CtorIt) {
6964 ExistingConstructors.insert(
6965 Context.getCanonicalType(CtorIt->getType()).getTypePtr());
6966 }
6967
Sebastian Redlf677ea32011-02-05 19:23:19 +00006968 DeclarationName CreatedCtorName =
6969 Context.DeclarationNames.getCXXConstructorName(
6970 ClassDecl->getTypeForDecl()->getCanonicalTypeUnqualified());
6971
6972 // Now comes the true work.
6973 // First, we keep a map from constructor types to the base that introduced
6974 // them. Needed for finding conflicting constructors. We also keep the
6975 // actually inserted declarations in there, for pretty diagnostics.
6976 typedef std::pair<CanQualType, CXXConstructorDecl *> ConstructorInfo;
6977 typedef llvm::DenseMap<const Type *, ConstructorInfo> ConstructorToSourceMap;
6978 ConstructorToSourceMap InheritedConstructors;
6979 for (BasesVector::iterator BaseIt = BasesToInheritFrom.begin(),
6980 BaseE = BasesToInheritFrom.end();
6981 BaseIt != BaseE; ++BaseIt) {
6982 const RecordType *Base = *BaseIt;
6983 CanQualType CanonicalBase = Base->getCanonicalTypeUnqualified();
6984 CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(Base->getDecl());
6985 for (CXXRecordDecl::ctor_iterator CtorIt = BaseDecl->ctor_begin(),
6986 CtorE = BaseDecl->ctor_end();
6987 CtorIt != CtorE; ++CtorIt) {
6988 // Find the using declaration for inheriting this base's constructors.
Richard Smithc5a89a12012-04-02 01:30:27 +00006989 // FIXME: Don't perform name lookup just to obtain a source location!
Sebastian Redlf677ea32011-02-05 19:23:19 +00006990 DeclarationName Name =
6991 Context.DeclarationNames.getCXXConstructorName(CanonicalBase);
Richard Smithc5a89a12012-04-02 01:30:27 +00006992 LookupResult Result(*this, Name, SourceLocation(), LookupUsingDeclName);
6993 LookupQualifiedName(Result, CurContext);
6994 UsingDecl *UD = Result.getAsSingle<UsingDecl>();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006995 SourceLocation UsingLoc = UD ? UD->getLocation() :
6996 ClassDecl->getLocation();
6997
6998 // C++0x [class.inhctor]p1: The candidate set of inherited constructors
6999 // from the class X named in the using-declaration consists of actual
7000 // constructors and notional constructors that result from the
7001 // transformation of defaulted parameters as follows:
7002 // - all non-template default constructors of X, and
7003 // - for each non-template constructor of X that has at least one
7004 // parameter with a default argument, the set of constructors that
7005 // results from omitting any ellipsis parameter specification and
7006 // successively omitting parameters with a default argument from the
7007 // end of the parameter-type-list.
David Blaikie581deb32012-06-06 20:45:41 +00007008 CXXConstructorDecl *BaseCtor = *CtorIt;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007009 bool CanBeCopyOrMove = BaseCtor->isCopyOrMoveConstructor();
7010 const FunctionProtoType *BaseCtorType =
7011 BaseCtor->getType()->getAs<FunctionProtoType>();
7012
7013 for (unsigned params = BaseCtor->getMinRequiredArguments(),
7014 maxParams = BaseCtor->getNumParams();
7015 params <= maxParams; ++params) {
7016 // Skip default constructors. They're never inherited.
7017 if (params == 0)
7018 continue;
7019 // Skip copy and move constructors for the same reason.
7020 if (CanBeCopyOrMove && params == 1)
7021 continue;
7022
7023 // Build up a function type for this particular constructor.
7024 // FIXME: The working paper does not consider that the exception spec
7025 // for the inheriting constructor might be larger than that of the
Richard Smith7a614d82011-06-11 17:19:42 +00007026 // source. This code doesn't yet, either. When it does, this code will
7027 // need to be delayed until after exception specifications and in-class
7028 // member initializers are attached.
Sebastian Redlf677ea32011-02-05 19:23:19 +00007029 const Type *NewCtorType;
7030 if (params == maxParams)
7031 NewCtorType = BaseCtorType;
7032 else {
Chris Lattner5f9e2722011-07-23 10:55:15 +00007033 SmallVector<QualType, 16> Args;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007034 for (unsigned i = 0; i < params; ++i) {
7035 Args.push_back(BaseCtorType->getArgType(i));
7036 }
7037 FunctionProtoType::ExtProtoInfo ExtInfo =
7038 BaseCtorType->getExtProtoInfo();
7039 ExtInfo.Variadic = false;
7040 NewCtorType = Context.getFunctionType(BaseCtorType->getResultType(),
7041 Args.data(), params, ExtInfo)
7042 .getTypePtr();
7043 }
7044 const Type *CanonicalNewCtorType =
7045 Context.getCanonicalType(NewCtorType);
7046
7047 // Now that we have the type, first check if the class already has a
7048 // constructor with this signature.
7049 if (ExistingConstructors.count(CanonicalNewCtorType))
7050 continue;
7051
7052 // Then we check if we have already declared an inherited constructor
7053 // with this signature.
7054 std::pair<ConstructorToSourceMap::iterator, bool> result =
7055 InheritedConstructors.insert(std::make_pair(
7056 CanonicalNewCtorType,
7057 std::make_pair(CanonicalBase, (CXXConstructorDecl*)0)));
7058 if (!result.second) {
7059 // Already in the map. If it came from a different class, that's an
7060 // error. Not if it's from the same.
7061 CanQualType PreviousBase = result.first->second.first;
7062 if (CanonicalBase != PreviousBase) {
7063 const CXXConstructorDecl *PrevCtor = result.first->second.second;
7064 const CXXConstructorDecl *PrevBaseCtor =
7065 PrevCtor->getInheritedConstructor();
7066 assert(PrevBaseCtor && "Conflicting constructor was not inherited");
7067
7068 Diag(UsingLoc, diag::err_using_decl_constructor_conflict);
7069 Diag(BaseCtor->getLocation(),
7070 diag::note_using_decl_constructor_conflict_current_ctor);
7071 Diag(PrevBaseCtor->getLocation(),
7072 diag::note_using_decl_constructor_conflict_previous_ctor);
7073 Diag(PrevCtor->getLocation(),
7074 diag::note_using_decl_constructor_conflict_previous_using);
7075 }
7076 continue;
7077 }
7078
7079 // OK, we're there, now add the constructor.
7080 // C++0x [class.inhctor]p8: [...] that would be performed by a
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007081 // user-written inline constructor [...]
Sebastian Redlf677ea32011-02-05 19:23:19 +00007082 DeclarationNameInfo DNI(CreatedCtorName, UsingLoc);
7083 CXXConstructorDecl *NewCtor = CXXConstructorDecl::Create(
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007084 Context, ClassDecl, UsingLoc, DNI, QualType(NewCtorType, 0),
7085 /*TInfo=*/0, BaseCtor->isExplicit(), /*Inline=*/true,
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007086 /*ImplicitlyDeclared=*/true,
7087 // FIXME: Due to a defect in the standard, we treat inherited
7088 // constructors as constexpr even if that makes them ill-formed.
7089 /*Constexpr=*/BaseCtor->isConstexpr());
Sebastian Redlf677ea32011-02-05 19:23:19 +00007090 NewCtor->setAccess(BaseCtor->getAccess());
7091
7092 // Build up the parameter decls and add them.
Chris Lattner5f9e2722011-07-23 10:55:15 +00007093 SmallVector<ParmVarDecl *, 16> ParamDecls;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007094 for (unsigned i = 0; i < params; ++i) {
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007095 ParamDecls.push_back(ParmVarDecl::Create(Context, NewCtor,
7096 UsingLoc, UsingLoc,
Sebastian Redlf677ea32011-02-05 19:23:19 +00007097 /*IdentifierInfo=*/0,
7098 BaseCtorType->getArgType(i),
7099 /*TInfo=*/0, SC_None,
7100 SC_None, /*DefaultArg=*/0));
7101 }
David Blaikie4278c652011-09-21 18:16:56 +00007102 NewCtor->setParams(ParamDecls);
Sebastian Redlf677ea32011-02-05 19:23:19 +00007103 NewCtor->setInheritedConstructor(BaseCtor);
7104
Sebastian Redlf677ea32011-02-05 19:23:19 +00007105 ClassDecl->addDecl(NewCtor);
7106 result.first->second.second = NewCtor;
7107 }
7108 }
7109 }
7110}
7111
Sean Huntcb45a0f2011-05-12 22:46:25 +00007112Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00007113Sema::ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD) {
7114 CXXRecordDecl *ClassDecl = MD->getParent();
7115
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007116 // C++ [except.spec]p14:
7117 // An implicitly declared special member function (Clause 12) shall have
7118 // an exception-specification.
Richard Smithe6975e92012-04-17 00:58:00 +00007119 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007120 if (ClassDecl->isInvalidDecl())
7121 return ExceptSpec;
7122
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007123 // Direct base-class destructors.
7124 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
7125 BEnd = ClassDecl->bases_end();
7126 B != BEnd; ++B) {
7127 if (B->isVirtual()) // Handled below.
7128 continue;
7129
7130 if (const RecordType *BaseType = B->getType()->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007131 ExceptSpec.CalledDecl(B->getLocStart(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007132 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007133 }
Sebastian Redl0ee33912011-05-19 05:13:44 +00007134
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007135 // Virtual base-class destructors.
7136 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
7137 BEnd = ClassDecl->vbases_end();
7138 B != BEnd; ++B) {
7139 if (const RecordType *BaseType = B->getType()->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007140 ExceptSpec.CalledDecl(B->getLocStart(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007141 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007142 }
Sebastian Redl0ee33912011-05-19 05:13:44 +00007143
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007144 // Field destructors.
7145 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
7146 FEnd = ClassDecl->field_end();
7147 F != FEnd; ++F) {
7148 if (const RecordType *RecordTy
7149 = Context.getBaseElementType(F->getType())->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007150 ExceptSpec.CalledDecl(F->getLocation(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007151 LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007152 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00007153
Sean Huntcb45a0f2011-05-12 22:46:25 +00007154 return ExceptSpec;
7155}
7156
7157CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
7158 // C++ [class.dtor]p2:
7159 // If a class has no user-declared destructor, a destructor is
7160 // declared implicitly. An implicitly-declared destructor is an
7161 // inline public member of its class.
Sean Huntcb45a0f2011-05-12 22:46:25 +00007162
Douglas Gregor4923aa22010-07-02 20:37:36 +00007163 // Create the actual destructor declaration.
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007164 CanQualType ClassType
7165 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007166 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007167 DeclarationName Name
7168 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007169 DeclarationNameInfo NameInfo(Name, ClassLoc);
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007170 CXXDestructorDecl *Destructor
Richard Smithb9d0b762012-07-27 04:22:15 +00007171 = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
7172 QualType(), 0, /*isInline=*/true,
Sebastian Redl60618fa2011-03-12 11:50:43 +00007173 /*isImplicitlyDeclared=*/true);
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007174 Destructor->setAccess(AS_public);
Sean Huntcb45a0f2011-05-12 22:46:25 +00007175 Destructor->setDefaulted();
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007176 Destructor->setImplicit();
7177 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Richard Smithb9d0b762012-07-27 04:22:15 +00007178
7179 // Build an exception specification pointing back at this destructor.
7180 FunctionProtoType::ExtProtoInfo EPI;
7181 EPI.ExceptionSpecType = EST_Unevaluated;
7182 EPI.ExceptionSpecDecl = Destructor;
7183 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
7184
Douglas Gregor4923aa22010-07-02 20:37:36 +00007185 // Note that we have declared this destructor.
Douglas Gregor4923aa22010-07-02 20:37:36 +00007186 ++ASTContext::NumImplicitDestructorsDeclared;
Richard Smithb9d0b762012-07-27 04:22:15 +00007187
Douglas Gregor4923aa22010-07-02 20:37:36 +00007188 // Introduce this destructor into its scope.
Douglas Gregor23c94db2010-07-02 17:43:08 +00007189 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor4923aa22010-07-02 20:37:36 +00007190 PushOnScopeChains(Destructor, S, false);
7191 ClassDecl->addDecl(Destructor);
Sean Huntcb45a0f2011-05-12 22:46:25 +00007192
Richard Smith9a561d52012-02-26 09:11:52 +00007193 AddOverriddenMethods(ClassDecl, Destructor);
7194
Richard Smith7d5088a2012-02-18 02:02:13 +00007195 if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
Sean Huntcb45a0f2011-05-12 22:46:25 +00007196 Destructor->setDeletedAsWritten();
Richard Smith9a561d52012-02-26 09:11:52 +00007197
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007198 return Destructor;
7199}
7200
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007201void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregor4fe95f92009-09-04 19:04:08 +00007202 CXXDestructorDecl *Destructor) {
Sean Huntcd10dec2011-05-23 23:14:04 +00007203 assert((Destructor->isDefaulted() &&
Richard Smith03f68782012-02-26 07:51:39 +00007204 !Destructor->doesThisDeclarationHaveABody() &&
7205 !Destructor->isDeleted()) &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007206 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson6d701392009-11-15 22:49:34 +00007207 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007208 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00007209
Douglas Gregorc63d2c82010-05-12 16:39:35 +00007210 if (Destructor->isInvalidDecl())
7211 return;
7212
Douglas Gregor39957dc2010-05-01 15:04:51 +00007213 ImplicitlyDefinedFunctionScope Scope(*this, Destructor);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00007214
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00007215 DiagnosticErrorTrap Trap(Diags);
John McCallef027fe2010-03-16 21:39:52 +00007216 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
7217 Destructor->getParent());
Mike Stump1eb44332009-09-09 15:08:12 +00007218
Douglas Gregorc63d2c82010-05-12 16:39:35 +00007219 if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) {
Anders Carlsson37909802009-11-30 21:24:50 +00007220 Diag(CurrentLocation, diag::note_member_synthesized_at)
7221 << CXXDestructor << Context.getTagDeclType(ClassDecl);
7222
7223 Destructor->setInvalidDecl();
7224 return;
7225 }
7226
Douglas Gregor4ada9d32010-09-20 16:48:21 +00007227 SourceLocation Loc = Destructor->getLocation();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00007228 Destructor->setBody(new (Context) CompoundStmt(Loc));
Douglas Gregor690b2db2011-09-22 20:32:43 +00007229 Destructor->setImplicitlyDefined(true);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007230 Destructor->setUsed();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00007231 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redl58a2cd82011-04-24 16:28:06 +00007232
7233 if (ASTMutationListener *L = getASTMutationListener()) {
7234 L->CompletedImplicitDefinition(Destructor);
7235 }
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007236}
7237
Richard Smitha4156b82012-04-21 18:42:51 +00007238/// \brief Perform any semantic analysis which needs to be delayed until all
7239/// pending class member declarations have been parsed.
7240void Sema::ActOnFinishCXXMemberDecls() {
Richard Smitha4156b82012-04-21 18:42:51 +00007241 // Perform any deferred checking of exception specifications for virtual
7242 // destructors.
7243 for (unsigned i = 0, e = DelayedDestructorExceptionSpecChecks.size();
7244 i != e; ++i) {
7245 const CXXDestructorDecl *Dtor =
7246 DelayedDestructorExceptionSpecChecks[i].first;
7247 assert(!Dtor->getParent()->isDependentType() &&
7248 "Should not ever add destructors of templates into the list.");
7249 CheckOverridingFunctionExceptionSpec(Dtor,
7250 DelayedDestructorExceptionSpecChecks[i].second);
7251 }
7252 DelayedDestructorExceptionSpecChecks.clear();
7253}
7254
Richard Smithb9d0b762012-07-27 04:22:15 +00007255void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
7256 CXXDestructorDecl *Destructor) {
7257 assert(getLangOpts().CPlusPlus0x &&
7258 "adjusting dtor exception specs was introduced in c++11");
7259
Sebastian Redl0ee33912011-05-19 05:13:44 +00007260 // C++11 [class.dtor]p3:
7261 // A declaration of a destructor that does not have an exception-
7262 // specification is implicitly considered to have the same exception-
7263 // specification as an implicit declaration.
Richard Smithb9d0b762012-07-27 04:22:15 +00007264 const FunctionProtoType *DtorType = Destructor->getType()->
Sebastian Redl0ee33912011-05-19 05:13:44 +00007265 getAs<FunctionProtoType>();
Richard Smithb9d0b762012-07-27 04:22:15 +00007266 if (DtorType->hasExceptionSpec())
Sebastian Redl0ee33912011-05-19 05:13:44 +00007267 return;
7268
Chandler Carruth3f224b22011-09-20 04:55:26 +00007269 // Replace the destructor's type, building off the existing one. Fortunately,
7270 // the only thing of interest in the destructor type is its extended info.
7271 // The return and arguments are fixed.
Richard Smithb9d0b762012-07-27 04:22:15 +00007272 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
7273 EPI.ExceptionSpecType = EST_Unevaluated;
7274 EPI.ExceptionSpecDecl = Destructor;
7275 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
Richard Smitha4156b82012-04-21 18:42:51 +00007276
Sebastian Redl0ee33912011-05-19 05:13:44 +00007277 // FIXME: If the destructor has a body that could throw, and the newly created
7278 // spec doesn't allow exceptions, we should emit a warning, because this
7279 // change in behavior can break conforming C++03 programs at runtime.
Richard Smithb9d0b762012-07-27 04:22:15 +00007280 // However, we don't have a body or an exception specification yet, so it
7281 // needs to be done somewhere else.
Sebastian Redl0ee33912011-05-19 05:13:44 +00007282}
7283
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007284/// \brief Builds a statement that copies/moves the given entity from \p From to
Douglas Gregor06a9f362010-05-01 20:49:11 +00007285/// \c To.
7286///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007287/// This routine is used to copy/move the members of a class with an
7288/// implicitly-declared copy/move assignment operator. When the entities being
Douglas Gregor06a9f362010-05-01 20:49:11 +00007289/// copied are arrays, this routine builds for loops to copy them.
7290///
7291/// \param S The Sema object used for type-checking.
7292///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007293/// \param Loc The location where the implicit copy/move is being generated.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007294///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007295/// \param T The type of the expressions being copied/moved. Both expressions
7296/// must have this type.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007297///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007298/// \param To The expression we are copying/moving to.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007299///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007300/// \param From The expression we are copying/moving from.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007301///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007302/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
Douglas Gregor6cdc1612010-05-04 15:20:55 +00007303/// Otherwise, it's a non-static member subobject.
7304///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007305/// \param Copying Whether we're copying or moving.
7306///
Douglas Gregor06a9f362010-05-01 20:49:11 +00007307/// \param Depth Internal parameter recording the depth of the recursion.
7308///
7309/// \returns A statement or a loop that copies the expressions.
John McCall60d7b3a2010-08-24 06:29:42 +00007310static StmtResult
Douglas Gregor06a9f362010-05-01 20:49:11 +00007311BuildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
John McCall9ae2f072010-08-23 23:25:46 +00007312 Expr *To, Expr *From,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007313 bool CopyingBaseSubobject, bool Copying,
7314 unsigned Depth = 0) {
7315 // C++0x [class.copy]p28:
Douglas Gregor06a9f362010-05-01 20:49:11 +00007316 // Each subobject is assigned in the manner appropriate to its type:
7317 //
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007318 // - if the subobject is of class type, as if by a call to operator= with
7319 // the subobject as the object expression and the corresponding
7320 // subobject of x as a single function argument (as if by explicit
7321 // qualification; that is, ignoring any possible virtual overriding
7322 // functions in more derived classes);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007323 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
7324 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7325
7326 // Look for operator=.
7327 DeclarationName Name
7328 = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal);
7329 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
7330 S.LookupQualifiedName(OpLookup, ClassDecl, false);
7331
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007332 // Filter out any result that isn't a copy/move-assignment operator.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007333 LookupResult::Filter F = OpLookup.makeFilter();
7334 while (F.hasNext()) {
7335 NamedDecl *D = F.next();
7336 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
Richard Smith1c931be2012-04-02 18:40:40 +00007337 if (Method->isCopyAssignmentOperator() ||
7338 (!Copying && Method->isMoveAssignmentOperator()))
Douglas Gregor06a9f362010-05-01 20:49:11 +00007339 continue;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007340
Douglas Gregor06a9f362010-05-01 20:49:11 +00007341 F.erase();
John McCallb0207482010-03-16 06:11:48 +00007342 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007343 F.done();
7344
Douglas Gregor6cdc1612010-05-04 15:20:55 +00007345 // Suppress the protected check (C++ [class.protected]) for each of the
7346 // assignment operators we found. This strange dance is required when
7347 // we're assigning via a base classes's copy-assignment operator. To
7348 // ensure that we're getting the right base class subobject (without
7349 // ambiguities), we need to cast "this" to that subobject type; to
7350 // ensure that we don't go through the virtual call mechanism, we need
7351 // to qualify the operator= name with the base class (see below). However,
7352 // this means that if the base class has a protected copy assignment
7353 // operator, the protected member access check will fail. So, we
7354 // rewrite "protected" access to "public" access in this case, since we
7355 // know by construction that we're calling from a derived class.
7356 if (CopyingBaseSubobject) {
7357 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
7358 L != LEnd; ++L) {
7359 if (L.getAccess() == AS_protected)
7360 L.setAccess(AS_public);
7361 }
7362 }
7363
Douglas Gregor06a9f362010-05-01 20:49:11 +00007364 // Create the nested-name-specifier that will be used to qualify the
7365 // reference to operator=; this is required to suppress the virtual
7366 // call mechanism.
7367 CXXScopeSpec SS;
Manuel Klimek5b6a3dd2012-02-06 21:51:39 +00007368 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
Douglas Gregorc34348a2011-02-24 17:54:50 +00007369 SS.MakeTrivial(S.Context,
7370 NestedNameSpecifier::Create(S.Context, 0, false,
Manuel Klimek5b6a3dd2012-02-06 21:51:39 +00007371 CanonicalT),
Douglas Gregorc34348a2011-02-24 17:54:50 +00007372 Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007373
7374 // Create the reference to operator=.
John McCall60d7b3a2010-08-24 06:29:42 +00007375 ExprResult OpEqualRef
John McCall9ae2f072010-08-23 23:25:46 +00007376 = S.BuildMemberReferenceExpr(To, T, Loc, /*isArrow=*/false, SS,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007377 /*TemplateKWLoc=*/SourceLocation(),
7378 /*FirstQualifierInScope=*/0,
7379 OpLookup,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007380 /*TemplateArgs=*/0,
7381 /*SuppressQualifierCheck=*/true);
7382 if (OpEqualRef.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007383 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007384
7385 // Build the call to the assignment operator.
John McCall9ae2f072010-08-23 23:25:46 +00007386
John McCall60d7b3a2010-08-24 06:29:42 +00007387 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/0,
Douglas Gregora1a04782010-09-09 16:33:13 +00007388 OpEqualRef.takeAs<Expr>(),
7389 Loc, &From, 1, Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007390 if (Call.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007391 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007392
7393 return S.Owned(Call.takeAs<Stmt>());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007394 }
John McCallb0207482010-03-16 06:11:48 +00007395
Douglas Gregor06a9f362010-05-01 20:49:11 +00007396 // - if the subobject is of scalar type, the built-in assignment
7397 // operator is used.
7398 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
7399 if (!ArrayTy) {
John McCall2de56d12010-08-25 11:45:40 +00007400 ExprResult Assignment = S.CreateBuiltinBinOp(Loc, BO_Assign, To, From);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007401 if (Assignment.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007402 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007403
7404 return S.Owned(Assignment.takeAs<Stmt>());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007405 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007406
7407 // - if the subobject is an array, each element is assigned, in the
7408 // manner appropriate to the element type;
7409
7410 // Construct a loop over the array bounds, e.g.,
7411 //
7412 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
7413 //
7414 // that will copy each of the array elements.
7415 QualType SizeType = S.Context.getSizeType();
7416
7417 // Create the iteration variable.
7418 IdentifierInfo *IterationVarName = 0;
7419 {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00007420 SmallString<8> Str;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007421 llvm::raw_svector_ostream OS(Str);
7422 OS << "__i" << Depth;
7423 IterationVarName = &S.Context.Idents.get(OS.str());
7424 }
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007425 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007426 IterationVarName, SizeType,
7427 S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
John McCalld931b082010-08-26 03:08:43 +00007428 SC_None, SC_None);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007429
7430 // Initialize the iteration variable to zero.
7431 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00007432 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
Douglas Gregor06a9f362010-05-01 20:49:11 +00007433
7434 // Create a reference to the iteration variable; we'll use this several
7435 // times throughout.
7436 Expr *IterationVarRef
Eli Friedman8c382062012-01-23 02:35:22 +00007437 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007438 assert(IterationVarRef && "Reference to invented variable cannot fail!");
Eli Friedman8c382062012-01-23 02:35:22 +00007439 Expr *IterationVarRefRVal = S.DefaultLvalueConversion(IterationVarRef).take();
7440 assert(IterationVarRefRVal && "Conversion of invented variable cannot fail!");
7441
Douglas Gregor06a9f362010-05-01 20:49:11 +00007442 // Create the DeclStmt that holds the iteration variable.
7443 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
7444
7445 // Create the comparison against the array bound.
Jay Foad9f71a8f2010-12-07 08:25:34 +00007446 llvm::APInt Upper
7447 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
John McCall9ae2f072010-08-23 23:25:46 +00007448 Expr *Comparison
Eli Friedman8c382062012-01-23 02:35:22 +00007449 = new (S.Context) BinaryOperator(IterationVarRefRVal,
John McCallf89e55a2010-11-18 06:31:45 +00007450 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
7451 BO_NE, S.Context.BoolTy,
7452 VK_RValue, OK_Ordinary, Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007453
7454 // Create the pre-increment of the iteration variable.
John McCall9ae2f072010-08-23 23:25:46 +00007455 Expr *Increment
John McCallf89e55a2010-11-18 06:31:45 +00007456 = new (S.Context) UnaryOperator(IterationVarRef, UO_PreInc, SizeType,
7457 VK_LValue, OK_Ordinary, Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007458
7459 // Subscript the "from" and "to" expressions with the iteration variable.
John McCall9ae2f072010-08-23 23:25:46 +00007460 From = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(From, Loc,
Eli Friedman8c382062012-01-23 02:35:22 +00007461 IterationVarRefRVal,
7462 Loc));
John McCall9ae2f072010-08-23 23:25:46 +00007463 To = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(To, Loc,
Eli Friedman8c382062012-01-23 02:35:22 +00007464 IterationVarRefRVal,
7465 Loc));
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007466 if (!Copying) // Cast to rvalue
7467 From = CastForMoving(S, From);
7468
7469 // Build the copy/move for an individual element of the array.
John McCallf89e55a2010-11-18 06:31:45 +00007470 StmtResult Copy = BuildSingleCopyAssign(S, Loc, ArrayTy->getElementType(),
7471 To, From, CopyingBaseSubobject,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007472 Copying, Depth + 1);
Douglas Gregorff331c12010-07-25 18:17:45 +00007473 if (Copy.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007474 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007475
7476 // Construct the loop that copies all elements of this array.
John McCall9ae2f072010-08-23 23:25:46 +00007477 return S.ActOnForStmt(Loc, Loc, InitStmt,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007478 S.MakeFullExpr(Comparison),
John McCalld226f652010-08-21 09:40:31 +00007479 0, S.MakeFullExpr(Increment),
John McCall9ae2f072010-08-23 23:25:46 +00007480 Loc, Copy.take());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007481}
7482
Richard Smithb9d0b762012-07-27 04:22:15 +00007483/// Determine whether an implicit copy assignment operator for ClassDecl has a
7484/// const argument.
7485/// FIXME: It ought to be possible to store this on the record.
7486static bool isImplicitCopyAssignmentArgConst(Sema &S,
7487 CXXRecordDecl *ClassDecl) {
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007488 if (ClassDecl->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00007489 return true;
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007490
Douglas Gregord3c35902010-07-01 16:36:15 +00007491 // C++ [class.copy]p10:
7492 // If the class definition does not explicitly declare a copy
7493 // assignment operator, one is declared implicitly.
7494 // The implicitly-defined copy assignment operator for a class X
7495 // will have the form
7496 //
7497 // X& X::operator=(const X&)
7498 //
7499 // if
Douglas Gregord3c35902010-07-01 16:36:15 +00007500 // -- each direct base class B of X has a copy assignment operator
7501 // whose parameter is of type const B&, const volatile B& or B,
7502 // and
7503 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7504 BaseEnd = ClassDecl->bases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007505 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007506 // We'll handle this below
Richard Smithb9d0b762012-07-27 04:22:15 +00007507 if (S.getLangOpts().CPlusPlus0x && Base->isVirtual())
Sean Hunt661c67a2011-06-21 23:42:56 +00007508 continue;
7509
Douglas Gregord3c35902010-07-01 16:36:15 +00007510 assert(!Base->getType()->isDependentType() &&
7511 "Cannot generate implicit members for class with dependent bases.");
Sean Hunt661c67a2011-06-21 23:42:56 +00007512 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl();
Richard Smithb9d0b762012-07-27 04:22:15 +00007513 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const, false, 0))
7514 return false;
Sean Hunt661c67a2011-06-21 23:42:56 +00007515 }
7516
Richard Smithebaf0e62011-10-18 20:49:44 +00007517 // In C++11, the above citation has "or virtual" added
Richard Smithb9d0b762012-07-27 04:22:15 +00007518 if (S.getLangOpts().CPlusPlus0x) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007519 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
7520 BaseEnd = ClassDecl->vbases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007521 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007522 assert(!Base->getType()->isDependentType() &&
7523 "Cannot generate implicit members for class with dependent bases.");
7524 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl();
Richard Smithb9d0b762012-07-27 04:22:15 +00007525 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const,
7526 false, 0))
7527 return false;
Sean Hunt661c67a2011-06-21 23:42:56 +00007528 }
Douglas Gregord3c35902010-07-01 16:36:15 +00007529 }
7530
7531 // -- for all the nonstatic data members of X that are of a class
7532 // type M (or array thereof), each such class type has a copy
7533 // assignment operator whose parameter is of type const M&,
7534 // const volatile M& or M.
7535 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7536 FieldEnd = ClassDecl->field_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007537 Field != FieldEnd; ++Field) {
7538 QualType FieldType = S.Context.getBaseElementType(Field->getType());
7539 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl())
7540 if (!S.LookupCopyingAssignment(FieldClassDecl, Qualifiers::Const,
7541 false, 0))
7542 return false;
Douglas Gregord3c35902010-07-01 16:36:15 +00007543 }
7544
7545 // Otherwise, the implicitly declared copy assignment operator will
7546 // have the form
7547 //
7548 // X& X::operator=(X&)
Richard Smithb9d0b762012-07-27 04:22:15 +00007549
7550 return true;
7551}
7552
7553Sema::ImplicitExceptionSpecification
7554Sema::ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD) {
7555 CXXRecordDecl *ClassDecl = MD->getParent();
7556
7557 ImplicitExceptionSpecification ExceptSpec(*this);
7558 if (ClassDecl->isInvalidDecl())
7559 return ExceptSpec;
7560
7561 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
7562 assert(T->getNumArgs() == 1 && "not a copy assignment op");
7563 unsigned ArgQuals = T->getArgType(0).getNonReferenceType().getCVRQualifiers();
7564
Douglas Gregorb87786f2010-07-01 17:48:08 +00007565 // C++ [except.spec]p14:
Richard Smithb9d0b762012-07-27 04:22:15 +00007566 // An implicitly declared special member function (Clause 12) shall have an
Douglas Gregorb87786f2010-07-01 17:48:08 +00007567 // exception-specification. [...]
Sean Hunt661c67a2011-06-21 23:42:56 +00007568
7569 // It is unspecified whether or not an implicit copy assignment operator
7570 // attempts to deduplicate calls to assignment operators of virtual bases are
7571 // made. As such, this exception specification is effectively unspecified.
7572 // Based on a similar decision made for constness in C++0x, we're erring on
7573 // the side of assuming such calls to be made regardless of whether they
7574 // actually happen.
Douglas Gregorb87786f2010-07-01 17:48:08 +00007575 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7576 BaseEnd = ClassDecl->bases_end();
7577 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007578 if (Base->isVirtual())
7579 continue;
7580
Douglas Gregora376d102010-07-02 21:50:04 +00007581 CXXRecordDecl *BaseClassDecl
Douglas Gregorb87786f2010-07-01 17:48:08 +00007582 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Hunt661c67a2011-06-21 23:42:56 +00007583 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
7584 ArgQuals, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007585 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign);
Douglas Gregorb87786f2010-07-01 17:48:08 +00007586 }
Sean Hunt661c67a2011-06-21 23:42:56 +00007587
7588 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
7589 BaseEnd = ClassDecl->vbases_end();
7590 Base != BaseEnd; ++Base) {
7591 CXXRecordDecl *BaseClassDecl
7592 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
7593 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
7594 ArgQuals, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007595 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign);
Sean Hunt661c67a2011-06-21 23:42:56 +00007596 }
7597
Douglas Gregorb87786f2010-07-01 17:48:08 +00007598 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7599 FieldEnd = ClassDecl->field_end();
7600 Field != FieldEnd;
7601 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00007602 QualType FieldType = Context.getBaseElementType(Field->getType());
Sean Hunt661c67a2011-06-21 23:42:56 +00007603 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
7604 if (CXXMethodDecl *CopyAssign =
Richard Smith6a06e5f2012-07-18 03:36:00 +00007605 LookupCopyingAssignment(FieldClassDecl,
7606 ArgQuals | FieldType.getCVRQualifiers(),
7607 false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007608 ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007609 }
Douglas Gregorb87786f2010-07-01 17:48:08 +00007610 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00007611
Richard Smithb9d0b762012-07-27 04:22:15 +00007612 return ExceptSpec;
Sean Hunt30de05c2011-05-14 05:23:20 +00007613}
7614
7615CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
7616 // Note: The following rules are largely analoguous to the copy
7617 // constructor rules. Note that virtual bases are not taken into account
7618 // for determining the argument type of the operator. Note also that
7619 // operators taking an object instead of a reference are allowed.
7620
Sean Hunt30de05c2011-05-14 05:23:20 +00007621 QualType ArgType = Context.getTypeDeclType(ClassDecl);
7622 QualType RetType = Context.getLValueReferenceType(ArgType);
Richard Smithb9d0b762012-07-27 04:22:15 +00007623 if (isImplicitCopyAssignmentArgConst(*this, ClassDecl))
Sean Hunt30de05c2011-05-14 05:23:20 +00007624 ArgType = ArgType.withConst();
7625 ArgType = Context.getLValueReferenceType(ArgType);
7626
Douglas Gregord3c35902010-07-01 16:36:15 +00007627 // An implicitly-declared copy assignment operator is an inline public
7628 // member of its class.
7629 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007630 SourceLocation ClassLoc = ClassDecl->getLocation();
7631 DeclarationNameInfo NameInfo(Name, ClassLoc);
Douglas Gregord3c35902010-07-01 16:36:15 +00007632 CXXMethodDecl *CopyAssignment
Richard Smithb9d0b762012-07-27 04:22:15 +00007633 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Douglas Gregord3c35902010-07-01 16:36:15 +00007634 /*TInfo=*/0, /*isStatic=*/false,
John McCalld931b082010-08-26 03:08:43 +00007635 /*StorageClassAsWritten=*/SC_None,
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007636 /*isInline=*/true, /*isConstexpr=*/false,
Douglas Gregorf5251602011-03-08 17:10:18 +00007637 SourceLocation());
Douglas Gregord3c35902010-07-01 16:36:15 +00007638 CopyAssignment->setAccess(AS_public);
Sean Hunt7f410192011-05-14 05:23:24 +00007639 CopyAssignment->setDefaulted();
Douglas Gregord3c35902010-07-01 16:36:15 +00007640 CopyAssignment->setImplicit();
7641 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Richard Smithb9d0b762012-07-27 04:22:15 +00007642
7643 // Build an exception specification pointing back at this member.
7644 FunctionProtoType::ExtProtoInfo EPI;
7645 EPI.ExceptionSpecType = EST_Unevaluated;
7646 EPI.ExceptionSpecDecl = CopyAssignment;
7647 CopyAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI));
7648
Douglas Gregord3c35902010-07-01 16:36:15 +00007649 // Add the parameter to the operator.
7650 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007651 ClassLoc, ClassLoc, /*Id=*/0,
Douglas Gregord3c35902010-07-01 16:36:15 +00007652 ArgType, /*TInfo=*/0,
John McCalld931b082010-08-26 03:08:43 +00007653 SC_None,
7654 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00007655 CopyAssignment->setParams(FromParam);
Douglas Gregord3c35902010-07-01 16:36:15 +00007656
Douglas Gregora376d102010-07-02 21:50:04 +00007657 // Note that we have added this copy-assignment operator.
Douglas Gregora376d102010-07-02 21:50:04 +00007658 ++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
Sean Hunt7f410192011-05-14 05:23:24 +00007659
Douglas Gregor23c94db2010-07-02 17:43:08 +00007660 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregora376d102010-07-02 21:50:04 +00007661 PushOnScopeChains(CopyAssignment, S, false);
7662 ClassDecl->addDecl(CopyAssignment);
Douglas Gregord3c35902010-07-01 16:36:15 +00007663
Nico Weberafcc96a2012-01-23 03:19:29 +00007664 // C++0x [class.copy]p19:
7665 // .... If the class definition does not explicitly declare a copy
7666 // assignment operator, there is no user-declared move constructor, and
7667 // there is no user-declared move assignment operator, a copy assignment
7668 // operator is implicitly declared as defaulted.
Richard Smith6c4c36c2012-03-30 20:53:28 +00007669 if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
Sean Hunt71a682f2011-05-18 03:41:58 +00007670 CopyAssignment->setDeletedAsWritten();
Richard Smith6c4c36c2012-03-30 20:53:28 +00007671
Douglas Gregord3c35902010-07-01 16:36:15 +00007672 AddOverriddenMethods(ClassDecl, CopyAssignment);
7673 return CopyAssignment;
7674}
7675
Douglas Gregor06a9f362010-05-01 20:49:11 +00007676void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
7677 CXXMethodDecl *CopyAssignOperator) {
Sean Hunt7f410192011-05-14 05:23:24 +00007678 assert((CopyAssignOperator->isDefaulted() &&
Douglas Gregor06a9f362010-05-01 20:49:11 +00007679 CopyAssignOperator->isOverloadedOperator() &&
7680 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith03f68782012-02-26 07:51:39 +00007681 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
7682 !CopyAssignOperator->isDeleted()) &&
Douglas Gregor06a9f362010-05-01 20:49:11 +00007683 "DefineImplicitCopyAssignment called for wrong function");
7684
7685 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
7686
7687 if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) {
7688 CopyAssignOperator->setInvalidDecl();
7689 return;
7690 }
7691
7692 CopyAssignOperator->setUsed();
7693
7694 ImplicitlyDefinedFunctionScope Scope(*this, CopyAssignOperator);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00007695 DiagnosticErrorTrap Trap(Diags);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007696
7697 // C++0x [class.copy]p30:
7698 // The implicitly-defined or explicitly-defaulted copy assignment operator
7699 // for a non-union class X performs memberwise copy assignment of its
7700 // subobjects. The direct base classes of X are assigned first, in the
7701 // order of their declaration in the base-specifier-list, and then the
7702 // immediate non-static data members of X are assigned, in the order in
7703 // which they were declared in the class definition.
7704
7705 // The statements that form the synthesized function body.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00007706 SmallVector<Stmt*, 8> Statements;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007707
7708 // The parameter for the "other" object, which we are copying from.
7709 ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
7710 Qualifiers OtherQuals = Other->getType().getQualifiers();
7711 QualType OtherRefType = Other->getType();
7712 if (const LValueReferenceType *OtherRef
7713 = OtherRefType->getAs<LValueReferenceType>()) {
7714 OtherRefType = OtherRef->getPointeeType();
7715 OtherQuals = OtherRefType.getQualifiers();
7716 }
7717
7718 // Our location for everything implicitly-generated.
7719 SourceLocation Loc = CopyAssignOperator->getLocation();
7720
7721 // Construct a reference to the "other" object. We'll be using this
7722 // throughout the generated ASTs.
John McCall09431682010-11-18 19:01:18 +00007723 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007724 assert(OtherRef && "Reference to parameter cannot fail!");
7725
7726 // Construct the "this" pointer. We'll be using this throughout the generated
7727 // ASTs.
7728 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>();
7729 assert(This && "Reference to this cannot fail!");
7730
7731 // Assign base classes.
7732 bool Invalid = false;
7733 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7734 E = ClassDecl->bases_end(); Base != E; ++Base) {
7735 // Form the assignment:
7736 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
7737 QualType BaseType = Base->getType().getUnqualifiedType();
Jeffrey Yasskindec09842011-01-18 02:00:16 +00007738 if (!BaseType->isRecordType()) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007739 Invalid = true;
7740 continue;
7741 }
7742
John McCallf871d0c2010-08-07 06:22:56 +00007743 CXXCastPath BasePath;
7744 BasePath.push_back(Base);
7745
Douglas Gregor06a9f362010-05-01 20:49:11 +00007746 // Construct the "from" expression, which is an implicit cast to the
7747 // appropriately-qualified base type.
John McCall3fa5cae2010-10-26 07:05:15 +00007748 Expr *From = OtherRef;
John Wiegley429bb272011-04-08 18:41:53 +00007749 From = ImpCastExprToType(From, Context.getQualifiedType(BaseType, OtherQuals),
7750 CK_UncheckedDerivedToBase,
7751 VK_LValue, &BasePath).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007752
7753 // Dereference "this".
John McCall5baba9d2010-08-25 10:28:54 +00007754 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007755
7756 // Implicitly cast "this" to the appropriately-qualified base type.
John Wiegley429bb272011-04-08 18:41:53 +00007757 To = ImpCastExprToType(To.take(),
7758 Context.getCVRQualifiedType(BaseType,
7759 CopyAssignOperator->getTypeQualifiers()),
7760 CK_UncheckedDerivedToBase,
7761 VK_LValue, &BasePath);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007762
7763 // Build the copy.
John McCall60d7b3a2010-08-24 06:29:42 +00007764 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00007765 To.get(), From,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007766 /*CopyingBaseSubobject=*/true,
7767 /*Copying=*/true);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007768 if (Copy.isInvalid()) {
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007769 Diag(CurrentLocation, diag::note_member_synthesized_at)
7770 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
7771 CopyAssignOperator->setInvalidDecl();
7772 return;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007773 }
7774
7775 // Success! Record the copy.
7776 Statements.push_back(Copy.takeAs<Expr>());
7777 }
7778
7779 // \brief Reference to the __builtin_memcpy function.
7780 Expr *BuiltinMemCpyRef = 0;
Fariborz Jahanian8e2eab22010-06-16 16:22:04 +00007781 // \brief Reference to the __builtin_objc_memmove_collectable function.
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007782 Expr *CollectableMemCpyRef = 0;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007783
7784 // Assign non-static members.
7785 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7786 FieldEnd = ClassDecl->field_end();
7787 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +00007788 if (Field->isUnnamedBitfield())
7789 continue;
7790
Douglas Gregor06a9f362010-05-01 20:49:11 +00007791 // Check for members of reference type; we can't copy those.
7792 if (Field->getType()->isReferenceType()) {
7793 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
7794 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
7795 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007796 Diag(CurrentLocation, diag::note_member_synthesized_at)
7797 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007798 Invalid = true;
7799 continue;
7800 }
7801
7802 // Check for members of const-qualified, non-class type.
7803 QualType BaseType = Context.getBaseElementType(Field->getType());
7804 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
7805 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
7806 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
7807 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007808 Diag(CurrentLocation, diag::note_member_synthesized_at)
7809 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007810 Invalid = true;
7811 continue;
7812 }
John McCallb77115d2011-06-17 00:18:42 +00007813
7814 // Suppress assigning zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00007815 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
7816 continue;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007817
7818 QualType FieldType = Field->getType().getNonReferenceType();
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00007819 if (FieldType->isIncompleteArrayType()) {
7820 assert(ClassDecl->hasFlexibleArrayMember() &&
7821 "Incomplete array type is not valid");
7822 continue;
7823 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007824
7825 // Build references to the field in the object we're copying from and to.
7826 CXXScopeSpec SS; // Intentionally empty
7827 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
7828 LookupMemberName);
David Blaikie581deb32012-06-06 20:45:41 +00007829 MemberLookup.addDecl(*Field);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007830 MemberLookup.resolveKind();
John McCall60d7b3a2010-08-24 06:29:42 +00007831 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType,
John McCall09431682010-11-18 19:01:18 +00007832 Loc, /*IsArrow=*/false,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007833 SS, SourceLocation(), 0,
7834 MemberLookup, 0);
John McCall60d7b3a2010-08-24 06:29:42 +00007835 ExprResult To = BuildMemberReferenceExpr(This, This->getType(),
John McCall09431682010-11-18 19:01:18 +00007836 Loc, /*IsArrow=*/true,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007837 SS, SourceLocation(), 0,
7838 MemberLookup, 0);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007839 assert(!From.isInvalid() && "Implicit field reference cannot fail");
7840 assert(!To.isInvalid() && "Implicit field reference cannot fail");
7841
7842 // If the field should be copied with __builtin_memcpy rather than via
7843 // explicit assignments, do so. This optimization only applies for arrays
7844 // of scalars and arrays of class type with trivial copy-assignment
7845 // operators.
Fariborz Jahanian6b167f42011-08-09 00:26:11 +00007846 if (FieldType->isArrayType() && !FieldType.isVolatileQualified()
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007847 && BaseType.hasTrivialAssignment(Context, /*Copying=*/true)) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007848 // Compute the size of the memory buffer to be copied.
7849 QualType SizeType = Context.getSizeType();
7850 llvm::APInt Size(Context.getTypeSize(SizeType),
7851 Context.getTypeSizeInChars(BaseType).getQuantity());
7852 for (const ConstantArrayType *Array
7853 = Context.getAsConstantArrayType(FieldType);
7854 Array;
7855 Array = Context.getAsConstantArrayType(Array->getElementType())) {
Jay Foad9f71a8f2010-12-07 08:25:34 +00007856 llvm::APInt ArraySize
7857 = Array->getSize().zextOrTrunc(Size.getBitWidth());
Douglas Gregor06a9f362010-05-01 20:49:11 +00007858 Size *= ArraySize;
7859 }
7860
7861 // Take the address of the field references for "from" and "to".
John McCall2de56d12010-08-25 11:45:40 +00007862 From = CreateBuiltinUnaryOp(Loc, UO_AddrOf, From.get());
7863 To = CreateBuiltinUnaryOp(Loc, UO_AddrOf, To.get());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007864
7865 bool NeedsCollectableMemCpy =
7866 (BaseType->isRecordType() &&
7867 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember());
7868
7869 if (NeedsCollectableMemCpy) {
7870 if (!CollectableMemCpyRef) {
Fariborz Jahanian8e2eab22010-06-16 16:22:04 +00007871 // Create a reference to the __builtin_objc_memmove_collectable function.
7872 LookupResult R(*this,
7873 &Context.Idents.get("__builtin_objc_memmove_collectable"),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007874 Loc, LookupOrdinaryName);
7875 LookupName(R, TUScope, true);
7876
7877 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>();
7878 if (!CollectableMemCpy) {
7879 // Something went horribly wrong earlier, and we will have
7880 // complained about it.
7881 Invalid = true;
7882 continue;
7883 }
7884
7885 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00007886 Context.BuiltinFnTy,
7887 VK_RValue, Loc, 0).take();
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007888 assert(CollectableMemCpyRef && "Builtin reference cannot fail");
7889 }
7890 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007891 // Create a reference to the __builtin_memcpy builtin function.
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007892 else if (!BuiltinMemCpyRef) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007893 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc,
7894 LookupOrdinaryName);
7895 LookupName(R, TUScope, true);
7896
7897 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>();
7898 if (!BuiltinMemCpy) {
7899 // Something went horribly wrong earlier, and we will have complained
7900 // about it.
7901 Invalid = true;
7902 continue;
7903 }
7904
7905 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00007906 Context.BuiltinFnTy,
7907 VK_RValue, Loc, 0).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007908 assert(BuiltinMemCpyRef && "Builtin reference cannot fail");
7909 }
7910
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00007911 SmallVector<Expr*, 8> CallArgs;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007912 CallArgs.push_back(To.takeAs<Expr>());
7913 CallArgs.push_back(From.takeAs<Expr>());
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00007914 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc));
John McCall60d7b3a2010-08-24 06:29:42 +00007915 ExprResult Call = ExprError();
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00007916 if (NeedsCollectableMemCpy)
7917 Call = ActOnCallExpr(/*Scope=*/0,
John McCall9ae2f072010-08-23 23:25:46 +00007918 CollectableMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00007919 Loc, CallArgs,
Douglas Gregora1a04782010-09-09 16:33:13 +00007920 Loc);
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00007921 else
7922 Call = ActOnCallExpr(/*Scope=*/0,
John McCall9ae2f072010-08-23 23:25:46 +00007923 BuiltinMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00007924 Loc, CallArgs,
Douglas Gregora1a04782010-09-09 16:33:13 +00007925 Loc);
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00007926
Douglas Gregor06a9f362010-05-01 20:49:11 +00007927 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
7928 Statements.push_back(Call.takeAs<Expr>());
7929 continue;
7930 }
7931
7932 // Build the copy of this field.
John McCall60d7b3a2010-08-24 06:29:42 +00007933 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, FieldType,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007934 To.get(), From.get(),
7935 /*CopyingBaseSubobject=*/false,
7936 /*Copying=*/true);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007937 if (Copy.isInvalid()) {
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007938 Diag(CurrentLocation, diag::note_member_synthesized_at)
7939 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
7940 CopyAssignOperator->setInvalidDecl();
7941 return;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007942 }
7943
7944 // Success! Record the copy.
7945 Statements.push_back(Copy.takeAs<Stmt>());
7946 }
7947
7948 if (!Invalid) {
7949 // Add a "return *this;"
John McCall2de56d12010-08-25 11:45:40 +00007950 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007951
John McCall60d7b3a2010-08-24 06:29:42 +00007952 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get());
Douglas Gregor06a9f362010-05-01 20:49:11 +00007953 if (Return.isInvalid())
7954 Invalid = true;
7955 else {
7956 Statements.push_back(Return.takeAs<Stmt>());
Douglas Gregorc63d2c82010-05-12 16:39:35 +00007957
7958 if (Trap.hasErrorOccurred()) {
7959 Diag(CurrentLocation, diag::note_member_synthesized_at)
7960 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
7961 Invalid = true;
7962 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007963 }
7964 }
7965
7966 if (Invalid) {
7967 CopyAssignOperator->setInvalidDecl();
7968 return;
7969 }
Dmitri Gribenko625bb562012-02-14 22:14:32 +00007970
7971 StmtResult Body;
7972 {
7973 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00007974 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko625bb562012-02-14 22:14:32 +00007975 /*isStmtExpr=*/false);
7976 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
7977 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007978 CopyAssignOperator->setBody(Body.takeAs<Stmt>());
Sebastian Redl58a2cd82011-04-24 16:28:06 +00007979
7980 if (ASTMutationListener *L = getASTMutationListener()) {
7981 L->CompletedImplicitDefinition(CopyAssignOperator);
7982 }
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007983}
7984
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007985Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00007986Sema::ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD) {
7987 CXXRecordDecl *ClassDecl = MD->getParent();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007988
Richard Smithb9d0b762012-07-27 04:22:15 +00007989 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007990 if (ClassDecl->isInvalidDecl())
7991 return ExceptSpec;
7992
7993 // C++0x [except.spec]p14:
7994 // An implicitly declared special member function (Clause 12) shall have an
7995 // exception-specification. [...]
7996
7997 // It is unspecified whether or not an implicit move assignment operator
7998 // attempts to deduplicate calls to assignment operators of virtual bases are
7999 // made. As such, this exception specification is effectively unspecified.
8000 // Based on a similar decision made for constness in C++0x, we're erring on
8001 // the side of assuming such calls to be made regardless of whether they
8002 // actually happen.
8003 // Note that a move constructor is not implicitly declared when there are
8004 // virtual bases, but it can still be user-declared and explicitly defaulted.
8005 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8006 BaseEnd = ClassDecl->bases_end();
8007 Base != BaseEnd; ++Base) {
8008 if (Base->isVirtual())
8009 continue;
8010
8011 CXXRecordDecl *BaseClassDecl
8012 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8013 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith6a06e5f2012-07-18 03:36:00 +00008014 0, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008015 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008016 }
8017
8018 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8019 BaseEnd = ClassDecl->vbases_end();
8020 Base != BaseEnd; ++Base) {
8021 CXXRecordDecl *BaseClassDecl
8022 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8023 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith6a06e5f2012-07-18 03:36:00 +00008024 0, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008025 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008026 }
8027
8028 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8029 FieldEnd = ClassDecl->field_end();
8030 Field != FieldEnd;
8031 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008032 QualType FieldType = Context.getBaseElementType(Field->getType());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008033 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
Richard Smith6a06e5f2012-07-18 03:36:00 +00008034 if (CXXMethodDecl *MoveAssign =
8035 LookupMovingAssignment(FieldClassDecl,
8036 FieldType.getCVRQualifiers(),
8037 false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008038 ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008039 }
8040 }
8041
8042 return ExceptSpec;
8043}
8044
Richard Smith1c931be2012-04-02 18:40:40 +00008045/// Determine whether the class type has any direct or indirect virtual base
8046/// classes which have a non-trivial move assignment operator.
8047static bool
8048hasVirtualBaseWithNonTrivialMoveAssignment(Sema &S, CXXRecordDecl *ClassDecl) {
8049 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8050 BaseEnd = ClassDecl->vbases_end();
8051 Base != BaseEnd; ++Base) {
8052 CXXRecordDecl *BaseClass =
8053 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8054
8055 // Try to declare the move assignment. If it would be deleted, then the
8056 // class does not have a non-trivial move assignment.
8057 if (BaseClass->needsImplicitMoveAssignment())
8058 S.DeclareImplicitMoveAssignment(BaseClass);
8059
8060 // If the class has both a trivial move assignment and a non-trivial move
8061 // assignment, hasTrivialMoveAssignment() is false.
8062 if (BaseClass->hasDeclaredMoveAssignment() &&
8063 !BaseClass->hasTrivialMoveAssignment())
8064 return true;
8065 }
8066
8067 return false;
8068}
8069
8070/// Determine whether the given type either has a move constructor or is
8071/// trivially copyable.
8072static bool
8073hasMoveOrIsTriviallyCopyable(Sema &S, QualType Type, bool IsConstructor) {
8074 Type = S.Context.getBaseElementType(Type);
8075
8076 // FIXME: Technically, non-trivially-copyable non-class types, such as
8077 // reference types, are supposed to return false here, but that appears
8078 // to be a standard defect.
8079 CXXRecordDecl *ClassDecl = Type->getAsCXXRecordDecl();
Richard Smith5d59b792012-04-25 18:28:49 +00008080 if (!ClassDecl || !ClassDecl->getDefinition())
Richard Smith1c931be2012-04-02 18:40:40 +00008081 return true;
8082
8083 if (Type.isTriviallyCopyableType(S.Context))
8084 return true;
8085
8086 if (IsConstructor) {
8087 if (ClassDecl->needsImplicitMoveConstructor())
8088 S.DeclareImplicitMoveConstructor(ClassDecl);
8089 return ClassDecl->hasDeclaredMoveConstructor();
8090 }
8091
8092 if (ClassDecl->needsImplicitMoveAssignment())
8093 S.DeclareImplicitMoveAssignment(ClassDecl);
8094 return ClassDecl->hasDeclaredMoveAssignment();
8095}
8096
8097/// Determine whether all non-static data members and direct or virtual bases
8098/// of class \p ClassDecl have either a move operation, or are trivially
8099/// copyable.
8100static bool subobjectsHaveMoveOrTrivialCopy(Sema &S, CXXRecordDecl *ClassDecl,
8101 bool IsConstructor) {
8102 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8103 BaseEnd = ClassDecl->bases_end();
8104 Base != BaseEnd; ++Base) {
8105 if (Base->isVirtual())
8106 continue;
8107
8108 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor))
8109 return false;
8110 }
8111
8112 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8113 BaseEnd = ClassDecl->vbases_end();
8114 Base != BaseEnd; ++Base) {
8115 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor))
8116 return false;
8117 }
8118
8119 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8120 FieldEnd = ClassDecl->field_end();
8121 Field != FieldEnd; ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008122 if (!hasMoveOrIsTriviallyCopyable(S, Field->getType(), IsConstructor))
Richard Smith1c931be2012-04-02 18:40:40 +00008123 return false;
8124 }
8125
8126 return true;
8127}
8128
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008129CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
Richard Smith1c931be2012-04-02 18:40:40 +00008130 // C++11 [class.copy]p20:
8131 // If the definition of a class X does not explicitly declare a move
8132 // assignment operator, one will be implicitly declared as defaulted
8133 // if and only if:
8134 //
8135 // - [first 4 bullets]
8136 assert(ClassDecl->needsImplicitMoveAssignment());
8137
8138 // [Checked after we build the declaration]
8139 // - the move assignment operator would not be implicitly defined as
8140 // deleted,
8141
8142 // [DR1402]:
8143 // - X has no direct or indirect virtual base class with a non-trivial
8144 // move assignment operator, and
8145 // - each of X's non-static data members and direct or virtual base classes
8146 // has a type that either has a move assignment operator or is trivially
8147 // copyable.
8148 if (hasVirtualBaseWithNonTrivialMoveAssignment(*this, ClassDecl) ||
8149 !subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl,/*Constructor*/false)) {
8150 ClassDecl->setFailedImplicitMoveAssignment();
8151 return 0;
8152 }
8153
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008154 // Note: The following rules are largely analoguous to the move
8155 // constructor rules.
8156
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008157 QualType ArgType = Context.getTypeDeclType(ClassDecl);
8158 QualType RetType = Context.getLValueReferenceType(ArgType);
8159 ArgType = Context.getRValueReferenceType(ArgType);
8160
8161 // An implicitly-declared move assignment operator is an inline public
8162 // member of its class.
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008163 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
8164 SourceLocation ClassLoc = ClassDecl->getLocation();
8165 DeclarationNameInfo NameInfo(Name, ClassLoc);
8166 CXXMethodDecl *MoveAssignment
Richard Smithb9d0b762012-07-27 04:22:15 +00008167 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008168 /*TInfo=*/0, /*isStatic=*/false,
8169 /*StorageClassAsWritten=*/SC_None,
8170 /*isInline=*/true,
8171 /*isConstexpr=*/false,
8172 SourceLocation());
8173 MoveAssignment->setAccess(AS_public);
8174 MoveAssignment->setDefaulted();
8175 MoveAssignment->setImplicit();
8176 MoveAssignment->setTrivial(ClassDecl->hasTrivialMoveAssignment());
8177
Richard Smithb9d0b762012-07-27 04:22:15 +00008178 // Build an exception specification pointing back at this member.
8179 FunctionProtoType::ExtProtoInfo EPI;
8180 EPI.ExceptionSpecType = EST_Unevaluated;
8181 EPI.ExceptionSpecDecl = MoveAssignment;
8182 MoveAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI));
8183
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008184 // Add the parameter to the operator.
8185 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
8186 ClassLoc, ClassLoc, /*Id=*/0,
8187 ArgType, /*TInfo=*/0,
8188 SC_None,
8189 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008190 MoveAssignment->setParams(FromParam);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008191
8192 // Note that we have added this copy-assignment operator.
8193 ++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
8194
8195 // C++0x [class.copy]p9:
8196 // If the definition of a class X does not explicitly declare a move
8197 // assignment operator, one will be implicitly declared as defaulted if and
8198 // only if:
8199 // [...]
8200 // - the move assignment operator would not be implicitly defined as
8201 // deleted.
Richard Smith7d5088a2012-02-18 02:02:13 +00008202 if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008203 // Cache this result so that we don't try to generate this over and over
8204 // on every lookup, leaking memory and wasting time.
8205 ClassDecl->setFailedImplicitMoveAssignment();
8206 return 0;
8207 }
8208
8209 if (Scope *S = getScopeForContext(ClassDecl))
8210 PushOnScopeChains(MoveAssignment, S, false);
8211 ClassDecl->addDecl(MoveAssignment);
8212
8213 AddOverriddenMethods(ClassDecl, MoveAssignment);
8214 return MoveAssignment;
8215}
8216
8217void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
8218 CXXMethodDecl *MoveAssignOperator) {
8219 assert((MoveAssignOperator->isDefaulted() &&
8220 MoveAssignOperator->isOverloadedOperator() &&
8221 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith03f68782012-02-26 07:51:39 +00008222 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
8223 !MoveAssignOperator->isDeleted()) &&
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008224 "DefineImplicitMoveAssignment called for wrong function");
8225
8226 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
8227
8228 if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) {
8229 MoveAssignOperator->setInvalidDecl();
8230 return;
8231 }
8232
8233 MoveAssignOperator->setUsed();
8234
8235 ImplicitlyDefinedFunctionScope Scope(*this, MoveAssignOperator);
8236 DiagnosticErrorTrap Trap(Diags);
8237
8238 // C++0x [class.copy]p28:
8239 // The implicitly-defined or move assignment operator for a non-union class
8240 // X performs memberwise move assignment of its subobjects. The direct base
8241 // classes of X are assigned first, in the order of their declaration in the
8242 // base-specifier-list, and then the immediate non-static data members of X
8243 // are assigned, in the order in which they were declared in the class
8244 // definition.
8245
8246 // The statements that form the synthesized function body.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00008247 SmallVector<Stmt*, 8> Statements;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008248
8249 // The parameter for the "other" object, which we are move from.
8250 ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
8251 QualType OtherRefType = Other->getType()->
8252 getAs<RValueReferenceType>()->getPointeeType();
8253 assert(OtherRefType.getQualifiers() == 0 &&
8254 "Bad argument type of defaulted move assignment");
8255
8256 // Our location for everything implicitly-generated.
8257 SourceLocation Loc = MoveAssignOperator->getLocation();
8258
8259 // Construct a reference to the "other" object. We'll be using this
8260 // throughout the generated ASTs.
8261 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take();
8262 assert(OtherRef && "Reference to parameter cannot fail!");
8263 // Cast to rvalue.
8264 OtherRef = CastForMoving(*this, OtherRef);
8265
8266 // Construct the "this" pointer. We'll be using this throughout the generated
8267 // ASTs.
8268 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>();
8269 assert(This && "Reference to this cannot fail!");
Richard Smith1c931be2012-04-02 18:40:40 +00008270
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008271 // Assign base classes.
8272 bool Invalid = false;
8273 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8274 E = ClassDecl->bases_end(); Base != E; ++Base) {
8275 // Form the assignment:
8276 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
8277 QualType BaseType = Base->getType().getUnqualifiedType();
8278 if (!BaseType->isRecordType()) {
8279 Invalid = true;
8280 continue;
8281 }
8282
8283 CXXCastPath BasePath;
8284 BasePath.push_back(Base);
8285
8286 // Construct the "from" expression, which is an implicit cast to the
8287 // appropriately-qualified base type.
8288 Expr *From = OtherRef;
8289 From = ImpCastExprToType(From, BaseType, CK_UncheckedDerivedToBase,
Douglas Gregorb2b56582011-09-06 16:26:56 +00008290 VK_XValue, &BasePath).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008291
8292 // Dereference "this".
8293 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
8294
8295 // Implicitly cast "this" to the appropriately-qualified base type.
8296 To = ImpCastExprToType(To.take(),
8297 Context.getCVRQualifiedType(BaseType,
8298 MoveAssignOperator->getTypeQualifiers()),
8299 CK_UncheckedDerivedToBase,
8300 VK_LValue, &BasePath);
8301
8302 // Build the move.
8303 StmtResult Move = BuildSingleCopyAssign(*this, Loc, BaseType,
8304 To.get(), From,
8305 /*CopyingBaseSubobject=*/true,
8306 /*Copying=*/false);
8307 if (Move.isInvalid()) {
8308 Diag(CurrentLocation, diag::note_member_synthesized_at)
8309 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8310 MoveAssignOperator->setInvalidDecl();
8311 return;
8312 }
8313
8314 // Success! Record the move.
8315 Statements.push_back(Move.takeAs<Expr>());
8316 }
8317
8318 // \brief Reference to the __builtin_memcpy function.
8319 Expr *BuiltinMemCpyRef = 0;
8320 // \brief Reference to the __builtin_objc_memmove_collectable function.
8321 Expr *CollectableMemCpyRef = 0;
8322
8323 // Assign non-static members.
8324 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8325 FieldEnd = ClassDecl->field_end();
8326 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +00008327 if (Field->isUnnamedBitfield())
8328 continue;
8329
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008330 // Check for members of reference type; we can't move those.
8331 if (Field->getType()->isReferenceType()) {
8332 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
8333 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
8334 Diag(Field->getLocation(), diag::note_declared_at);
8335 Diag(CurrentLocation, diag::note_member_synthesized_at)
8336 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8337 Invalid = true;
8338 continue;
8339 }
8340
8341 // Check for members of const-qualified, non-class type.
8342 QualType BaseType = Context.getBaseElementType(Field->getType());
8343 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
8344 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
8345 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
8346 Diag(Field->getLocation(), diag::note_declared_at);
8347 Diag(CurrentLocation, diag::note_member_synthesized_at)
8348 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8349 Invalid = true;
8350 continue;
8351 }
8352
8353 // Suppress assigning zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00008354 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
8355 continue;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008356
8357 QualType FieldType = Field->getType().getNonReferenceType();
8358 if (FieldType->isIncompleteArrayType()) {
8359 assert(ClassDecl->hasFlexibleArrayMember() &&
8360 "Incomplete array type is not valid");
8361 continue;
8362 }
8363
8364 // Build references to the field in the object we're copying from and to.
8365 CXXScopeSpec SS; // Intentionally empty
8366 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
8367 LookupMemberName);
David Blaikie581deb32012-06-06 20:45:41 +00008368 MemberLookup.addDecl(*Field);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008369 MemberLookup.resolveKind();
8370 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType,
8371 Loc, /*IsArrow=*/false,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00008372 SS, SourceLocation(), 0,
8373 MemberLookup, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008374 ExprResult To = BuildMemberReferenceExpr(This, This->getType(),
8375 Loc, /*IsArrow=*/true,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00008376 SS, SourceLocation(), 0,
8377 MemberLookup, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008378 assert(!From.isInvalid() && "Implicit field reference cannot fail");
8379 assert(!To.isInvalid() && "Implicit field reference cannot fail");
8380
8381 assert(!From.get()->isLValue() && // could be xvalue or prvalue
8382 "Member reference with rvalue base must be rvalue except for reference "
8383 "members, which aren't allowed for move assignment.");
8384
8385 // If the field should be copied with __builtin_memcpy rather than via
8386 // explicit assignments, do so. This optimization only applies for arrays
8387 // of scalars and arrays of class type with trivial move-assignment
8388 // operators.
8389 if (FieldType->isArrayType() && !FieldType.isVolatileQualified()
8390 && BaseType.hasTrivialAssignment(Context, /*Copying=*/false)) {
8391 // Compute the size of the memory buffer to be copied.
8392 QualType SizeType = Context.getSizeType();
8393 llvm::APInt Size(Context.getTypeSize(SizeType),
8394 Context.getTypeSizeInChars(BaseType).getQuantity());
8395 for (const ConstantArrayType *Array
8396 = Context.getAsConstantArrayType(FieldType);
8397 Array;
8398 Array = Context.getAsConstantArrayType(Array->getElementType())) {
8399 llvm::APInt ArraySize
8400 = Array->getSize().zextOrTrunc(Size.getBitWidth());
8401 Size *= ArraySize;
8402 }
8403
Douglas Gregor45d3d712011-09-01 02:09:07 +00008404 // Take the address of the field references for "from" and "to". We
8405 // directly construct UnaryOperators here because semantic analysis
8406 // does not permit us to take the address of an xvalue.
8407 From = new (Context) UnaryOperator(From.get(), UO_AddrOf,
8408 Context.getPointerType(From.get()->getType()),
8409 VK_RValue, OK_Ordinary, Loc);
8410 To = new (Context) UnaryOperator(To.get(), UO_AddrOf,
8411 Context.getPointerType(To.get()->getType()),
8412 VK_RValue, OK_Ordinary, Loc);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008413
8414 bool NeedsCollectableMemCpy =
8415 (BaseType->isRecordType() &&
8416 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember());
8417
8418 if (NeedsCollectableMemCpy) {
8419 if (!CollectableMemCpyRef) {
8420 // Create a reference to the __builtin_objc_memmove_collectable function.
8421 LookupResult R(*this,
8422 &Context.Idents.get("__builtin_objc_memmove_collectable"),
8423 Loc, LookupOrdinaryName);
8424 LookupName(R, TUScope, true);
8425
8426 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>();
8427 if (!CollectableMemCpy) {
8428 // Something went horribly wrong earlier, and we will have
8429 // complained about it.
8430 Invalid = true;
8431 continue;
8432 }
8433
8434 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00008435 Context.BuiltinFnTy,
8436 VK_RValue, Loc, 0).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008437 assert(CollectableMemCpyRef && "Builtin reference cannot fail");
8438 }
8439 }
8440 // Create a reference to the __builtin_memcpy builtin function.
8441 else if (!BuiltinMemCpyRef) {
8442 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc,
8443 LookupOrdinaryName);
8444 LookupName(R, TUScope, true);
8445
8446 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>();
8447 if (!BuiltinMemCpy) {
8448 // Something went horribly wrong earlier, and we will have complained
8449 // about it.
8450 Invalid = true;
8451 continue;
8452 }
8453
8454 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00008455 Context.BuiltinFnTy,
8456 VK_RValue, Loc, 0).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008457 assert(BuiltinMemCpyRef && "Builtin reference cannot fail");
8458 }
8459
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00008460 SmallVector<Expr*, 8> CallArgs;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008461 CallArgs.push_back(To.takeAs<Expr>());
8462 CallArgs.push_back(From.takeAs<Expr>());
8463 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc));
8464 ExprResult Call = ExprError();
8465 if (NeedsCollectableMemCpy)
8466 Call = ActOnCallExpr(/*Scope=*/0,
8467 CollectableMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008468 Loc, CallArgs,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008469 Loc);
8470 else
8471 Call = ActOnCallExpr(/*Scope=*/0,
8472 BuiltinMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008473 Loc, CallArgs,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008474 Loc);
8475
8476 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
8477 Statements.push_back(Call.takeAs<Expr>());
8478 continue;
8479 }
8480
8481 // Build the move of this field.
8482 StmtResult Move = BuildSingleCopyAssign(*this, Loc, FieldType,
8483 To.get(), From.get(),
8484 /*CopyingBaseSubobject=*/false,
8485 /*Copying=*/false);
8486 if (Move.isInvalid()) {
8487 Diag(CurrentLocation, diag::note_member_synthesized_at)
8488 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8489 MoveAssignOperator->setInvalidDecl();
8490 return;
8491 }
8492
8493 // Success! Record the copy.
8494 Statements.push_back(Move.takeAs<Stmt>());
8495 }
8496
8497 if (!Invalid) {
8498 // Add a "return *this;"
8499 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
8500
8501 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get());
8502 if (Return.isInvalid())
8503 Invalid = true;
8504 else {
8505 Statements.push_back(Return.takeAs<Stmt>());
8506
8507 if (Trap.hasErrorOccurred()) {
8508 Diag(CurrentLocation, diag::note_member_synthesized_at)
8509 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8510 Invalid = true;
8511 }
8512 }
8513 }
8514
8515 if (Invalid) {
8516 MoveAssignOperator->setInvalidDecl();
8517 return;
8518 }
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008519
8520 StmtResult Body;
8521 {
8522 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008523 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008524 /*isStmtExpr=*/false);
8525 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
8526 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008527 MoveAssignOperator->setBody(Body.takeAs<Stmt>());
8528
8529 if (ASTMutationListener *L = getASTMutationListener()) {
8530 L->CompletedImplicitDefinition(MoveAssignOperator);
8531 }
8532}
8533
Richard Smithb9d0b762012-07-27 04:22:15 +00008534/// Determine whether an implicit copy constructor for ClassDecl has a const
8535/// argument.
8536/// FIXME: It ought to be possible to store this on the record.
8537static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl) {
Abramo Bagnaracdb80762011-07-11 08:52:40 +00008538 if (ClassDecl->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00008539 return true;
Abramo Bagnaracdb80762011-07-11 08:52:40 +00008540
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008541 // C++ [class.copy]p5:
8542 // The implicitly-declared copy constructor for a class X will
8543 // have the form
8544 //
8545 // X::X(const X&)
8546 //
8547 // if
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008548 // -- each direct or virtual base class B of X has a copy
8549 // constructor whose first parameter is of type const B& or
8550 // const volatile B&, and
8551 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8552 BaseEnd = ClassDecl->bases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008553 Base != BaseEnd; ++Base) {
Douglas Gregor598a8542010-07-01 18:27:03 +00008554 // Virtual bases are handled below.
8555 if (Base->isVirtual())
8556 continue;
Richard Smithb9d0b762012-07-27 04:22:15 +00008557
Douglas Gregor22584312010-07-02 23:41:54 +00008558 CXXRecordDecl *BaseClassDecl
Douglas Gregor598a8542010-07-01 18:27:03 +00008559 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Richard Smithb9d0b762012-07-27 04:22:15 +00008560 // FIXME: This lookup is wrong. If the copy ctor for a member or base is
8561 // ambiguous, we should still produce a constructor with a const-qualified
8562 // parameter.
8563 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const))
8564 return false;
Douglas Gregor598a8542010-07-01 18:27:03 +00008565 }
8566
8567 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8568 BaseEnd = ClassDecl->vbases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008569 Base != BaseEnd; ++Base) {
Douglas Gregor22584312010-07-02 23:41:54 +00008570 CXXRecordDecl *BaseClassDecl
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008571 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Richard Smithb9d0b762012-07-27 04:22:15 +00008572 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const))
8573 return false;
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008574 }
Richard Smithb9d0b762012-07-27 04:22:15 +00008575
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008576 // -- for all the nonstatic data members of X that are of a
8577 // class type M (or array thereof), each such class type
8578 // has a copy constructor whose first parameter is of type
8579 // const M& or const volatile M&.
8580 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8581 FieldEnd = ClassDecl->field_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008582 Field != FieldEnd; ++Field) {
8583 QualType FieldType = S.Context.getBaseElementType(Field->getType());
Sean Huntc530d172011-06-10 04:44:37 +00008584 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
Richard Smithb9d0b762012-07-27 04:22:15 +00008585 if (!S.LookupCopyingConstructor(FieldClassDecl, Qualifiers::Const))
8586 return false;
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008587 }
8588 }
Richard Smithb9d0b762012-07-27 04:22:15 +00008589
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008590 // Otherwise, the implicitly declared copy constructor will have
8591 // the form
8592 //
8593 // X::X(X&)
Richard Smithb9d0b762012-07-27 04:22:15 +00008594
8595 return true;
8596}
8597
8598Sema::ImplicitExceptionSpecification
8599Sema::ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD) {
8600 CXXRecordDecl *ClassDecl = MD->getParent();
8601
8602 ImplicitExceptionSpecification ExceptSpec(*this);
8603 if (ClassDecl->isInvalidDecl())
8604 return ExceptSpec;
8605
8606 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
8607 assert(T->getNumArgs() >= 1 && "not a copy ctor");
8608 unsigned Quals = T->getArgType(0).getNonReferenceType().getCVRQualifiers();
8609
Douglas Gregor0d405db2010-07-01 20:59:04 +00008610 // C++ [except.spec]p14:
8611 // An implicitly declared special member function (Clause 12) shall have an
8612 // exception-specification. [...]
Douglas Gregor0d405db2010-07-01 20:59:04 +00008613 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8614 BaseEnd = ClassDecl->bases_end();
8615 Base != BaseEnd;
8616 ++Base) {
8617 // Virtual bases are handled below.
8618 if (Base->isVirtual())
8619 continue;
8620
Douglas Gregor22584312010-07-02 23:41:54 +00008621 CXXRecordDecl *BaseClassDecl
Douglas Gregor0d405db2010-07-01 20:59:04 +00008622 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Huntc530d172011-06-10 04:44:37 +00008623 if (CXXConstructorDecl *CopyConstructor =
Sean Hunt661c67a2011-06-21 23:42:56 +00008624 LookupCopyingConstructor(BaseClassDecl, Quals))
Richard Smithe6975e92012-04-17 00:58:00 +00008625 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008626 }
8627 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8628 BaseEnd = ClassDecl->vbases_end();
8629 Base != BaseEnd;
8630 ++Base) {
Douglas Gregor22584312010-07-02 23:41:54 +00008631 CXXRecordDecl *BaseClassDecl
Douglas Gregor0d405db2010-07-01 20:59:04 +00008632 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Huntc530d172011-06-10 04:44:37 +00008633 if (CXXConstructorDecl *CopyConstructor =
Sean Hunt661c67a2011-06-21 23:42:56 +00008634 LookupCopyingConstructor(BaseClassDecl, Quals))
Richard Smithe6975e92012-04-17 00:58:00 +00008635 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008636 }
8637 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8638 FieldEnd = ClassDecl->field_end();
8639 Field != FieldEnd;
8640 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008641 QualType FieldType = Context.getBaseElementType(Field->getType());
Sean Huntc530d172011-06-10 04:44:37 +00008642 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
8643 if (CXXConstructorDecl *CopyConstructor =
Richard Smith6a06e5f2012-07-18 03:36:00 +00008644 LookupCopyingConstructor(FieldClassDecl,
8645 Quals | FieldType.getCVRQualifiers()))
Richard Smithe6975e92012-04-17 00:58:00 +00008646 ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008647 }
8648 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00008649
Richard Smithb9d0b762012-07-27 04:22:15 +00008650 return ExceptSpec;
Sean Hunt49634cf2011-05-13 06:10:58 +00008651}
8652
8653CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
8654 CXXRecordDecl *ClassDecl) {
8655 // C++ [class.copy]p4:
8656 // If the class definition does not explicitly declare a copy
8657 // constructor, one is declared implicitly.
8658
Sean Hunt49634cf2011-05-13 06:10:58 +00008659 QualType ClassType = Context.getTypeDeclType(ClassDecl);
8660 QualType ArgType = ClassType;
Richard Smithb9d0b762012-07-27 04:22:15 +00008661 bool Const = isImplicitCopyCtorArgConst(*this, ClassDecl);
Sean Hunt49634cf2011-05-13 06:10:58 +00008662 if (Const)
8663 ArgType = ArgType.withConst();
8664 ArgType = Context.getLValueReferenceType(ArgType);
Sean Hunt49634cf2011-05-13 06:10:58 +00008665
Richard Smith7756afa2012-06-10 05:43:50 +00008666 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8667 CXXCopyConstructor,
8668 Const);
8669
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008670 DeclarationName Name
8671 = Context.DeclarationNames.getCXXConstructorName(
8672 Context.getCanonicalType(ClassType));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00008673 SourceLocation ClassLoc = ClassDecl->getLocation();
8674 DeclarationNameInfo NameInfo(Name, ClassLoc);
Sean Hunt49634cf2011-05-13 06:10:58 +00008675
8676 // An implicitly-declared copy constructor is an inline public
Richard Smith61802452011-12-22 02:22:31 +00008677 // member of its class.
8678 CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00008679 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00008680 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00008681 Constexpr);
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008682 CopyConstructor->setAccess(AS_public);
Sean Hunt49634cf2011-05-13 06:10:58 +00008683 CopyConstructor->setDefaulted();
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008684 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Richard Smith61802452011-12-22 02:22:31 +00008685
Richard Smithb9d0b762012-07-27 04:22:15 +00008686 // Build an exception specification pointing back at this member.
8687 FunctionProtoType::ExtProtoInfo EPI;
8688 EPI.ExceptionSpecType = EST_Unevaluated;
8689 EPI.ExceptionSpecDecl = CopyConstructor;
8690 CopyConstructor->setType(
8691 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI));
8692
Douglas Gregor22584312010-07-02 23:41:54 +00008693 // Note that we have declared this constructor.
Douglas Gregor22584312010-07-02 23:41:54 +00008694 ++ASTContext::NumImplicitCopyConstructorsDeclared;
8695
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008696 // Add the parameter to the constructor.
8697 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00008698 ClassLoc, ClassLoc,
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008699 /*IdentifierInfo=*/0,
8700 ArgType, /*TInfo=*/0,
John McCalld931b082010-08-26 03:08:43 +00008701 SC_None,
8702 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008703 CopyConstructor->setParams(FromParam);
Sean Hunt49634cf2011-05-13 06:10:58 +00008704
Douglas Gregor23c94db2010-07-02 17:43:08 +00008705 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor22584312010-07-02 23:41:54 +00008706 PushOnScopeChains(CopyConstructor, S, false);
8707 ClassDecl->addDecl(CopyConstructor);
Sean Hunt71a682f2011-05-18 03:41:58 +00008708
Nico Weberafcc96a2012-01-23 03:19:29 +00008709 // C++11 [class.copy]p8:
8710 // ... If the class definition does not explicitly declare a copy
8711 // constructor, there is no user-declared move constructor, and there is no
8712 // user-declared move assignment operator, a copy constructor is implicitly
8713 // declared as defaulted.
Richard Smith6c4c36c2012-03-30 20:53:28 +00008714 if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
Sean Hunt71a682f2011-05-18 03:41:58 +00008715 CopyConstructor->setDeletedAsWritten();
Richard Smith6c4c36c2012-03-30 20:53:28 +00008716
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008717 return CopyConstructor;
8718}
8719
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008720void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
Sean Hunt49634cf2011-05-13 06:10:58 +00008721 CXXConstructorDecl *CopyConstructor) {
8722 assert((CopyConstructor->isDefaulted() &&
8723 CopyConstructor->isCopyConstructor() &&
Richard Smith03f68782012-02-26 07:51:39 +00008724 !CopyConstructor->doesThisDeclarationHaveABody() &&
8725 !CopyConstructor->isDeleted()) &&
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008726 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00008727
Anders Carlsson63010a72010-04-23 16:24:12 +00008728 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008729 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00008730
Douglas Gregor39957dc2010-05-01 15:04:51 +00008731 ImplicitlyDefinedFunctionScope Scope(*this, CopyConstructor);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00008732 DiagnosticErrorTrap Trap(Diags);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00008733
Sean Huntcbb67482011-01-08 20:30:50 +00008734 if (SetCtorInitializers(CopyConstructor, 0, 0, /*AnyErrors=*/false) ||
Douglas Gregorc63d2c82010-05-12 16:39:35 +00008735 Trap.hasErrorOccurred()) {
Anders Carlsson59b7f152010-05-01 16:39:01 +00008736 Diag(CurrentLocation, diag::note_member_synthesized_at)
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008737 << CXXCopyConstructor << Context.getTagDeclType(ClassDecl);
Anders Carlsson59b7f152010-05-01 16:39:01 +00008738 CopyConstructor->setInvalidDecl();
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008739 } else {
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008740 Sema::CompoundScopeRAII CompoundScope(*this);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008741 CopyConstructor->setBody(ActOnCompoundStmt(CopyConstructor->getLocation(),
8742 CopyConstructor->getLocation(),
Benjamin Kramer5354e772012-08-23 23:38:35 +00008743 MultiStmtArg(),
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008744 /*isStmtExpr=*/false)
8745 .takeAs<Stmt>());
Douglas Gregor690b2db2011-09-22 20:32:43 +00008746 CopyConstructor->setImplicitlyDefined(true);
Anders Carlsson8e142cc2010-04-25 00:52:09 +00008747 }
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008748
8749 CopyConstructor->setUsed();
Sebastian Redl58a2cd82011-04-24 16:28:06 +00008750 if (ASTMutationListener *L = getASTMutationListener()) {
8751 L->CompletedImplicitDefinition(CopyConstructor);
8752 }
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008753}
8754
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008755Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00008756Sema::ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD) {
8757 CXXRecordDecl *ClassDecl = MD->getParent();
8758
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008759 // C++ [except.spec]p14:
8760 // An implicitly declared special member function (Clause 12) shall have an
8761 // exception-specification. [...]
Richard Smithe6975e92012-04-17 00:58:00 +00008762 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008763 if (ClassDecl->isInvalidDecl())
8764 return ExceptSpec;
8765
8766 // Direct base-class constructors.
8767 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
8768 BEnd = ClassDecl->bases_end();
8769 B != BEnd; ++B) {
8770 if (B->isVirtual()) // Handled below.
8771 continue;
8772
8773 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
8774 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith6a06e5f2012-07-18 03:36:00 +00008775 CXXConstructorDecl *Constructor =
8776 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008777 // If this is a deleted function, add it anyway. This might be conformant
8778 // with the standard. This might not. I'm not sure. It might not matter.
8779 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008780 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008781 }
8782 }
8783
8784 // Virtual base-class constructors.
8785 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
8786 BEnd = ClassDecl->vbases_end();
8787 B != BEnd; ++B) {
8788 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
8789 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith6a06e5f2012-07-18 03:36:00 +00008790 CXXConstructorDecl *Constructor =
8791 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008792 // If this is a deleted function, add it anyway. This might be conformant
8793 // with the standard. This might not. I'm not sure. It might not matter.
8794 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008795 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008796 }
8797 }
8798
8799 // Field constructors.
8800 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
8801 FEnd = ClassDecl->field_end();
8802 F != FEnd; ++F) {
Richard Smith6a06e5f2012-07-18 03:36:00 +00008803 QualType FieldType = Context.getBaseElementType(F->getType());
8804 if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) {
8805 CXXConstructorDecl *Constructor =
8806 LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008807 // If this is a deleted function, add it anyway. This might be conformant
8808 // with the standard. This might not. I'm not sure. It might not matter.
8809 // In particular, the problem is that this function never gets called. It
8810 // might just be ill-formed because this function attempts to refer to
8811 // a deleted function here.
8812 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008813 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008814 }
8815 }
8816
8817 return ExceptSpec;
8818}
8819
8820CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
8821 CXXRecordDecl *ClassDecl) {
Richard Smith1c931be2012-04-02 18:40:40 +00008822 // C++11 [class.copy]p9:
8823 // If the definition of a class X does not explicitly declare a move
8824 // constructor, one will be implicitly declared as defaulted if and only if:
8825 //
8826 // - [first 4 bullets]
8827 assert(ClassDecl->needsImplicitMoveConstructor());
8828
8829 // [Checked after we build the declaration]
8830 // - the move assignment operator would not be implicitly defined as
8831 // deleted,
8832
8833 // [DR1402]:
8834 // - each of X's non-static data members and direct or virtual base classes
8835 // has a type that either has a move constructor or is trivially copyable.
8836 if (!subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl, /*Constructor*/true)) {
8837 ClassDecl->setFailedImplicitMoveConstructor();
8838 return 0;
8839 }
8840
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008841 QualType ClassType = Context.getTypeDeclType(ClassDecl);
8842 QualType ArgType = Context.getRValueReferenceType(ClassType);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008843
Richard Smith7756afa2012-06-10 05:43:50 +00008844 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8845 CXXMoveConstructor,
8846 false);
8847
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008848 DeclarationName Name
8849 = Context.DeclarationNames.getCXXConstructorName(
8850 Context.getCanonicalType(ClassType));
8851 SourceLocation ClassLoc = ClassDecl->getLocation();
8852 DeclarationNameInfo NameInfo(Name, ClassLoc);
8853
8854 // C++0x [class.copy]p11:
8855 // An implicitly-declared copy/move constructor is an inline public
Richard Smith61802452011-12-22 02:22:31 +00008856 // member of its class.
8857 CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00008858 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00008859 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00008860 Constexpr);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008861 MoveConstructor->setAccess(AS_public);
8862 MoveConstructor->setDefaulted();
8863 MoveConstructor->setTrivial(ClassDecl->hasTrivialMoveConstructor());
Richard Smith61802452011-12-22 02:22:31 +00008864
Richard Smithb9d0b762012-07-27 04:22:15 +00008865 // Build an exception specification pointing back at this member.
8866 FunctionProtoType::ExtProtoInfo EPI;
8867 EPI.ExceptionSpecType = EST_Unevaluated;
8868 EPI.ExceptionSpecDecl = MoveConstructor;
8869 MoveConstructor->setType(
8870 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI));
8871
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008872 // Add the parameter to the constructor.
8873 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
8874 ClassLoc, ClassLoc,
8875 /*IdentifierInfo=*/0,
8876 ArgType, /*TInfo=*/0,
8877 SC_None,
8878 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008879 MoveConstructor->setParams(FromParam);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008880
8881 // C++0x [class.copy]p9:
8882 // If the definition of a class X does not explicitly declare a move
8883 // constructor, one will be implicitly declared as defaulted if and only if:
8884 // [...]
8885 // - the move constructor would not be implicitly defined as deleted.
Sean Hunt769bb2d2011-10-11 06:43:29 +00008886 if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008887 // Cache this result so that we don't try to generate this over and over
8888 // on every lookup, leaking memory and wasting time.
8889 ClassDecl->setFailedImplicitMoveConstructor();
8890 return 0;
8891 }
8892
8893 // Note that we have declared this constructor.
8894 ++ASTContext::NumImplicitMoveConstructorsDeclared;
8895
8896 if (Scope *S = getScopeForContext(ClassDecl))
8897 PushOnScopeChains(MoveConstructor, S, false);
8898 ClassDecl->addDecl(MoveConstructor);
8899
8900 return MoveConstructor;
8901}
8902
8903void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
8904 CXXConstructorDecl *MoveConstructor) {
8905 assert((MoveConstructor->isDefaulted() &&
8906 MoveConstructor->isMoveConstructor() &&
Richard Smith03f68782012-02-26 07:51:39 +00008907 !MoveConstructor->doesThisDeclarationHaveABody() &&
8908 !MoveConstructor->isDeleted()) &&
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008909 "DefineImplicitMoveConstructor - call it for implicit move ctor");
8910
8911 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
8912 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
8913
8914 ImplicitlyDefinedFunctionScope Scope(*this, MoveConstructor);
8915 DiagnosticErrorTrap Trap(Diags);
8916
8917 if (SetCtorInitializers(MoveConstructor, 0, 0, /*AnyErrors=*/false) ||
8918 Trap.hasErrorOccurred()) {
8919 Diag(CurrentLocation, diag::note_member_synthesized_at)
8920 << CXXMoveConstructor << Context.getTagDeclType(ClassDecl);
8921 MoveConstructor->setInvalidDecl();
8922 } else {
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008923 Sema::CompoundScopeRAII CompoundScope(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008924 MoveConstructor->setBody(ActOnCompoundStmt(MoveConstructor->getLocation(),
8925 MoveConstructor->getLocation(),
Benjamin Kramer5354e772012-08-23 23:38:35 +00008926 MultiStmtArg(),
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008927 /*isStmtExpr=*/false)
8928 .takeAs<Stmt>());
Douglas Gregor690b2db2011-09-22 20:32:43 +00008929 MoveConstructor->setImplicitlyDefined(true);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008930 }
8931
8932 MoveConstructor->setUsed();
8933
8934 if (ASTMutationListener *L = getASTMutationListener()) {
8935 L->CompletedImplicitDefinition(MoveConstructor);
8936 }
8937}
8938
Douglas Gregore4e68d42012-02-15 19:33:52 +00008939bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
8940 return FD->isDeleted() &&
8941 (FD->isDefaulted() || FD->isImplicit()) &&
8942 isa<CXXMethodDecl>(FD);
8943}
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008944
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008945/// \brief Mark the call operator of the given lambda closure type as "used".
8946static void markLambdaCallOperatorUsed(Sema &S, CXXRecordDecl *Lambda) {
8947 CXXMethodDecl *CallOperator
Douglas Gregorac1303e2012-02-22 05:02:47 +00008948 = cast<CXXMethodDecl>(
8949 *Lambda->lookup(
8950 S.Context.DeclarationNames.getCXXOperatorName(OO_Call)).first);
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008951 CallOperator->setReferenced();
8952 CallOperator->setUsed();
8953}
8954
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008955void Sema::DefineImplicitLambdaToFunctionPointerConversion(
8956 SourceLocation CurrentLocation,
8957 CXXConversionDecl *Conv)
8958{
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008959 CXXRecordDecl *Lambda = Conv->getParent();
8960
8961 // Make sure that the lambda call operator is marked used.
8962 markLambdaCallOperatorUsed(*this, Lambda);
8963
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008964 Conv->setUsed();
8965
8966 ImplicitlyDefinedFunctionScope Scope(*this, Conv);
8967 DiagnosticErrorTrap Trap(Diags);
8968
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008969 // Return the address of the __invoke function.
8970 DeclarationName InvokeName = &Context.Idents.get("__invoke");
8971 CXXMethodDecl *Invoke
8972 = cast<CXXMethodDecl>(*Lambda->lookup(InvokeName).first);
8973 Expr *FunctionRef = BuildDeclRefExpr(Invoke, Invoke->getType(),
8974 VK_LValue, Conv->getLocation()).take();
8975 assert(FunctionRef && "Can't refer to __invoke function?");
8976 Stmt *Return = ActOnReturnStmt(Conv->getLocation(), FunctionRef).take();
8977 Conv->setBody(new (Context) CompoundStmt(Context, &Return, 1,
8978 Conv->getLocation(),
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008979 Conv->getLocation()));
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008980
8981 // Fill in the __invoke function with a dummy implementation. IR generation
8982 // will fill in the actual details.
8983 Invoke->setUsed();
8984 Invoke->setReferenced();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00008985 Invoke->setBody(new (Context) CompoundStmt(Conv->getLocation()));
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008986
8987 if (ASTMutationListener *L = getASTMutationListener()) {
8988 L->CompletedImplicitDefinition(Conv);
Douglas Gregor27dd7d92012-02-17 03:02:34 +00008989 L->CompletedImplicitDefinition(Invoke);
Douglas Gregorf6e2e022012-02-16 01:06:16 +00008990 }
8991}
8992
8993void Sema::DefineImplicitLambdaToBlockPointerConversion(
8994 SourceLocation CurrentLocation,
8995 CXXConversionDecl *Conv)
8996{
8997 Conv->setUsed();
8998
8999 ImplicitlyDefinedFunctionScope Scope(*this, Conv);
9000 DiagnosticErrorTrap Trap(Diags);
9001
Douglas Gregorac1303e2012-02-22 05:02:47 +00009002 // Copy-initialize the lambda object as needed to capture it.
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009003 Expr *This = ActOnCXXThis(CurrentLocation).take();
9004 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).take();
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009005
Eli Friedman23f02672012-03-01 04:01:32 +00009006 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
9007 Conv->getLocation(),
9008 Conv, DerefThis);
9009
9010 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
9011 // behavior. Note that only the general conversion function does this
9012 // (since it's unusable otherwise); in the case where we inline the
9013 // block literal, it has block literal lifetime semantics.
David Blaikie4e4d0842012-03-11 07:00:24 +00009014 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
Eli Friedman23f02672012-03-01 04:01:32 +00009015 BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
9016 CK_CopyAndAutoreleaseBlockObject,
9017 BuildBlock.get(), 0, VK_RValue);
9018
9019 if (BuildBlock.isInvalid()) {
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009020 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
Douglas Gregorac1303e2012-02-22 05:02:47 +00009021 Conv->setInvalidDecl();
9022 return;
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009023 }
Douglas Gregorac1303e2012-02-22 05:02:47 +00009024
Douglas Gregorac1303e2012-02-22 05:02:47 +00009025 // Create the return statement that returns the block from the conversion
9026 // function.
Eli Friedman23f02672012-03-01 04:01:32 +00009027 StmtResult Return = ActOnReturnStmt(Conv->getLocation(), BuildBlock.get());
Douglas Gregorac1303e2012-02-22 05:02:47 +00009028 if (Return.isInvalid()) {
9029 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
9030 Conv->setInvalidDecl();
9031 return;
9032 }
9033
9034 // Set the body of the conversion function.
9035 Stmt *ReturnS = Return.take();
9036 Conv->setBody(new (Context) CompoundStmt(Context, &ReturnS, 1,
9037 Conv->getLocation(),
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009038 Conv->getLocation()));
9039
Douglas Gregorac1303e2012-02-22 05:02:47 +00009040 // We're done; notify the mutation listener, if any.
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009041 if (ASTMutationListener *L = getASTMutationListener()) {
9042 L->CompletedImplicitDefinition(Conv);
9043 }
9044}
9045
Douglas Gregorf52757d2012-03-10 06:53:13 +00009046/// \brief Determine whether the given list arguments contains exactly one
9047/// "real" (non-default) argument.
9048static bool hasOneRealArgument(MultiExprArg Args) {
9049 switch (Args.size()) {
9050 case 0:
9051 return false;
9052
9053 default:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009054 if (!Args[1]->isDefaultArgument())
Douglas Gregorf52757d2012-03-10 06:53:13 +00009055 return false;
9056
9057 // fall through
9058 case 1:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009059 return !Args[0]->isDefaultArgument();
Douglas Gregorf52757d2012-03-10 06:53:13 +00009060 }
9061
9062 return false;
9063}
9064
John McCall60d7b3a2010-08-24 06:29:42 +00009065ExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00009066Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump1eb44332009-09-09 15:08:12 +00009067 CXXConstructorDecl *Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00009068 MultiExprArg ExprArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009069 bool HadMultipleCandidates,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00009070 bool RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009071 unsigned ConstructKind,
9072 SourceRange ParenRange) {
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009073 bool Elidable = false;
Mike Stump1eb44332009-09-09 15:08:12 +00009074
Douglas Gregor2f599792010-04-02 18:24:57 +00009075 // C++0x [class.copy]p34:
9076 // When certain criteria are met, an implementation is allowed to
9077 // omit the copy/move construction of a class object, even if the
9078 // copy/move constructor and/or destructor for the object have
9079 // side effects. [...]
9080 // - when a temporary class object that has not been bound to a
9081 // reference (12.2) would be copied/moved to a class object
9082 // with the same cv-unqualified type, the copy/move operation
9083 // can be omitted by constructing the temporary object
9084 // directly into the target of the omitted copy/move
John McCall558d2ab2010-09-15 10:14:12 +00009085 if (ConstructKind == CXXConstructExpr::CK_Complete &&
Douglas Gregorf52757d2012-03-10 06:53:13 +00009086 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
Benjamin Kramer5354e772012-08-23 23:38:35 +00009087 Expr *SubExpr = ExprArgs[0];
John McCall558d2ab2010-09-15 10:14:12 +00009088 Elidable = SubExpr->isTemporaryObject(Context, Constructor->getParent());
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009089 }
Mike Stump1eb44332009-09-09 15:08:12 +00009090
9091 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009092 Elidable, ExprArgs, HadMultipleCandidates,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009093 RequiresZeroInit, ConstructKind, ParenRange);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009094}
9095
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009096/// BuildCXXConstructExpr - Creates a complete call to a constructor,
9097/// including handling of its default argument expressions.
John McCall60d7b3a2010-08-24 06:29:42 +00009098ExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00009099Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
9100 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +00009101 MultiExprArg ExprArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009102 bool HadMultipleCandidates,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00009103 bool RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009104 unsigned ConstructKind,
9105 SourceRange ParenRange) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00009106 MarkFunctionReferenced(ConstructLoc, Constructor);
Douglas Gregor99a2e602009-12-16 01:38:02 +00009107 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00009108 Constructor, Elidable, ExprArgs,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00009109 HadMultipleCandidates, /*FIXME*/false,
9110 RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009111 static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
9112 ParenRange));
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009113}
9114
Mike Stump1eb44332009-09-09 15:08:12 +00009115bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009116 CXXConstructorDecl *Constructor,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009117 MultiExprArg Exprs,
9118 bool HadMultipleCandidates) {
Chandler Carruth428edaf2010-10-25 08:47:36 +00009119 // FIXME: Provide the correct paren SourceRange when available.
John McCall60d7b3a2010-08-24 06:29:42 +00009120 ExprResult TempResult =
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00009121 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009122 Exprs, HadMultipleCandidates, false,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009123 CXXConstructExpr::CK_Complete, SourceRange());
Anders Carlssonfe2de492009-08-25 05:18:00 +00009124 if (TempResult.isInvalid())
9125 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00009126
Anders Carlssonda3f4e22009-08-25 05:12:04 +00009127 Expr *Temp = TempResult.takeAs<Expr>();
John McCallb4eb64d2010-10-08 02:01:28 +00009128 CheckImplicitConversions(Temp, VD->getLocation());
Eli Friedman5f2987c2012-02-02 03:46:19 +00009129 MarkFunctionReferenced(VD->getLocation(), Constructor);
John McCall4765fa02010-12-06 08:20:24 +00009130 Temp = MaybeCreateExprWithCleanups(Temp);
Douglas Gregor838db382010-02-11 01:19:42 +00009131 VD->setInit(Temp);
Mike Stump1eb44332009-09-09 15:08:12 +00009132
Anders Carlssonfe2de492009-08-25 05:18:00 +00009133 return false;
Anders Carlsson930e8d02009-04-16 23:50:50 +00009134}
9135
John McCall68c6c9a2010-02-02 09:10:11 +00009136void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009137 if (VD->isInvalidDecl()) return;
9138
John McCall68c6c9a2010-02-02 09:10:11 +00009139 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009140 if (ClassDecl->isInvalidDecl()) return;
Richard Smith213d70b2012-02-18 04:13:32 +00009141 if (ClassDecl->hasIrrelevantDestructor()) return;
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009142 if (ClassDecl->isDependentContext()) return;
John McCall626e96e2010-08-01 20:20:59 +00009143
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009144 CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
Eli Friedman5f2987c2012-02-02 03:46:19 +00009145 MarkFunctionReferenced(VD->getLocation(), Destructor);
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009146 CheckDestructorAccess(VD->getLocation(), Destructor,
9147 PDiag(diag::err_access_dtor_var)
9148 << VD->getDeclName()
9149 << VD->getType());
Richard Smith213d70b2012-02-18 04:13:32 +00009150 DiagnoseUseOfDecl(Destructor, VD->getLocation());
Anders Carlsson2b32dad2011-03-24 01:01:41 +00009151
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009152 if (!VD->hasGlobalStorage()) return;
9153
9154 // Emit warning for non-trivial dtor in global scope (a real global,
9155 // class-static, function-static).
9156 Diag(VD->getLocation(), diag::warn_exit_time_destructor);
9157
9158 // TODO: this should be re-enabled for static locals by !CXAAtExit
9159 if (!VD->isStaticLocal())
9160 Diag(VD->getLocation(), diag::warn_global_destructor);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00009161}
9162
Douglas Gregor39da0b82009-09-09 23:08:42 +00009163/// \brief Given a constructor and the set of arguments provided for the
9164/// constructor, convert the arguments and add any required default arguments
9165/// to form a proper call to this constructor.
9166///
9167/// \returns true if an error occurred, false otherwise.
9168bool
9169Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
9170 MultiExprArg ArgsPtr,
Richard Smith831421f2012-06-25 20:30:08 +00009171 SourceLocation Loc,
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00009172 SmallVectorImpl<Expr*> &ConvertedArgs,
Douglas Gregored878af2012-02-24 23:56:31 +00009173 bool AllowExplicit) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00009174 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
9175 unsigned NumArgs = ArgsPtr.size();
Benjamin Kramer5354e772012-08-23 23:38:35 +00009176 Expr **Args = ArgsPtr.data();
Douglas Gregor39da0b82009-09-09 23:08:42 +00009177
9178 const FunctionProtoType *Proto
9179 = Constructor->getType()->getAs<FunctionProtoType>();
9180 assert(Proto && "Constructor without a prototype?");
9181 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregor39da0b82009-09-09 23:08:42 +00009182
9183 // If too few arguments are available, we'll fill in the rest with defaults.
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009184 if (NumArgs < NumArgsInProto)
Douglas Gregor39da0b82009-09-09 23:08:42 +00009185 ConvertedArgs.reserve(NumArgsInProto);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009186 else
Douglas Gregor39da0b82009-09-09 23:08:42 +00009187 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009188
9189 VariadicCallType CallType =
9190 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
Chris Lattner5f9e2722011-07-23 10:55:15 +00009191 SmallVector<Expr *, 8> AllArgs;
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009192 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
9193 Proto, 0, Args, NumArgs, AllArgs,
Douglas Gregored878af2012-02-24 23:56:31 +00009194 CallType, AllowExplicit);
Benjamin Kramer14c59822012-02-14 12:06:21 +00009195 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
Eli Friedmane61eb042012-02-18 04:48:30 +00009196
9197 DiagnoseSentinelCalls(Constructor, Loc, AllArgs.data(), AllArgs.size());
9198
Richard Smith831421f2012-06-25 20:30:08 +00009199 CheckConstructorCall(Constructor, AllArgs.data(), AllArgs.size(),
9200 Proto, Loc);
Eli Friedmane61eb042012-02-18 04:48:30 +00009201
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009202 return Invalid;
Douglas Gregor18fe5682008-11-03 20:45:27 +00009203}
9204
Anders Carlsson20d45d22009-12-12 00:32:00 +00009205static inline bool
9206CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
9207 const FunctionDecl *FnDecl) {
Sebastian Redl7a126a42010-08-31 00:36:30 +00009208 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
Anders Carlsson20d45d22009-12-12 00:32:00 +00009209 if (isa<NamespaceDecl>(DC)) {
9210 return SemaRef.Diag(FnDecl->getLocation(),
9211 diag::err_operator_new_delete_declared_in_namespace)
9212 << FnDecl->getDeclName();
9213 }
9214
9215 if (isa<TranslationUnitDecl>(DC) &&
John McCalld931b082010-08-26 03:08:43 +00009216 FnDecl->getStorageClass() == SC_Static) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00009217 return SemaRef.Diag(FnDecl->getLocation(),
9218 diag::err_operator_new_delete_declared_static)
9219 << FnDecl->getDeclName();
9220 }
9221
Anders Carlssonfcfdb2b2009-12-12 02:43:16 +00009222 return false;
Anders Carlsson20d45d22009-12-12 00:32:00 +00009223}
9224
Anders Carlsson156c78e2009-12-13 17:53:43 +00009225static inline bool
9226CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
9227 CanQualType ExpectedResultType,
9228 CanQualType ExpectedFirstParamType,
9229 unsigned DependentParamTypeDiag,
9230 unsigned InvalidParamTypeDiag) {
9231 QualType ResultType =
9232 FnDecl->getType()->getAs<FunctionType>()->getResultType();
9233
9234 // Check that the result type is not dependent.
9235 if (ResultType->isDependentType())
9236 return SemaRef.Diag(FnDecl->getLocation(),
9237 diag::err_operator_new_delete_dependent_result_type)
9238 << FnDecl->getDeclName() << ExpectedResultType;
9239
9240 // Check that the result type is what we expect.
9241 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
9242 return SemaRef.Diag(FnDecl->getLocation(),
9243 diag::err_operator_new_delete_invalid_result_type)
9244 << FnDecl->getDeclName() << ExpectedResultType;
9245
9246 // A function template must have at least 2 parameters.
9247 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
9248 return SemaRef.Diag(FnDecl->getLocation(),
9249 diag::err_operator_new_delete_template_too_few_parameters)
9250 << FnDecl->getDeclName();
9251
9252 // The function decl must have at least 1 parameter.
9253 if (FnDecl->getNumParams() == 0)
9254 return SemaRef.Diag(FnDecl->getLocation(),
9255 diag::err_operator_new_delete_too_few_parameters)
9256 << FnDecl->getDeclName();
9257
Sylvestre Ledrubed28ac2012-07-23 08:59:39 +00009258 // Check the first parameter type is not dependent.
Anders Carlsson156c78e2009-12-13 17:53:43 +00009259 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
9260 if (FirstParamType->isDependentType())
9261 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
9262 << FnDecl->getDeclName() << ExpectedFirstParamType;
9263
9264 // Check that the first parameter type is what we expect.
Douglas Gregor6e790ab2009-12-22 23:42:49 +00009265 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
Anders Carlsson156c78e2009-12-13 17:53:43 +00009266 ExpectedFirstParamType)
9267 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
9268 << FnDecl->getDeclName() << ExpectedFirstParamType;
9269
9270 return false;
9271}
9272
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009273static bool
Anders Carlsson156c78e2009-12-13 17:53:43 +00009274CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00009275 // C++ [basic.stc.dynamic.allocation]p1:
9276 // A program is ill-formed if an allocation function is declared in a
9277 // namespace scope other than global scope or declared static in global
9278 // scope.
9279 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
9280 return true;
Anders Carlsson156c78e2009-12-13 17:53:43 +00009281
9282 CanQualType SizeTy =
9283 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
9284
9285 // C++ [basic.stc.dynamic.allocation]p1:
9286 // The return type shall be void*. The first parameter shall have type
9287 // std::size_t.
9288 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
9289 SizeTy,
9290 diag::err_operator_new_dependent_param_type,
9291 diag::err_operator_new_param_type))
9292 return true;
9293
9294 // C++ [basic.stc.dynamic.allocation]p1:
9295 // The first parameter shall not have an associated default argument.
9296 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlssona3ccda52009-12-12 00:26:23 +00009297 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson156c78e2009-12-13 17:53:43 +00009298 diag::err_operator_new_default_arg)
9299 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
9300
9301 return false;
Anders Carlssona3ccda52009-12-12 00:26:23 +00009302}
9303
9304static bool
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009305CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
9306 // C++ [basic.stc.dynamic.deallocation]p1:
9307 // A program is ill-formed if deallocation functions are declared in a
9308 // namespace scope other than global scope or declared static in global
9309 // scope.
Anders Carlsson20d45d22009-12-12 00:32:00 +00009310 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
9311 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009312
9313 // C++ [basic.stc.dynamic.deallocation]p2:
9314 // Each deallocation function shall return void and its first parameter
9315 // shall be void*.
Anders Carlsson156c78e2009-12-13 17:53:43 +00009316 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
9317 SemaRef.Context.VoidPtrTy,
9318 diag::err_operator_delete_dependent_param_type,
9319 diag::err_operator_delete_param_type))
9320 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009321
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009322 return false;
9323}
9324
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009325/// CheckOverloadedOperatorDeclaration - Check whether the declaration
9326/// of this overloaded operator is well-formed. If so, returns false;
9327/// otherwise, emits appropriate diagnostics and returns true.
9328bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009329 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009330 "Expected an overloaded operator declaration");
9331
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009332 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
9333
Mike Stump1eb44332009-09-09 15:08:12 +00009334 // C++ [over.oper]p5:
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009335 // The allocation and deallocation functions, operator new,
9336 // operator new[], operator delete and operator delete[], are
9337 // described completely in 3.7.3. The attributes and restrictions
9338 // found in the rest of this subclause do not apply to them unless
9339 // explicitly stated in 3.7.3.
Anders Carlsson1152c392009-12-11 23:31:21 +00009340 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009341 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanianb03bfa52009-11-10 23:47:18 +00009342
Anders Carlssona3ccda52009-12-12 00:26:23 +00009343 if (Op == OO_New || Op == OO_Array_New)
9344 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009345
9346 // C++ [over.oper]p6:
9347 // An operator function shall either be a non-static member
9348 // function or be a non-member function and have at least one
9349 // parameter whose type is a class, a reference to a class, an
9350 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009351 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
9352 if (MethodDecl->isStatic())
9353 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009354 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009355 } else {
9356 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009357 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
9358 ParamEnd = FnDecl->param_end();
9359 Param != ParamEnd; ++Param) {
9360 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00009361 if (ParamType->isDependentType() || ParamType->isRecordType() ||
9362 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009363 ClassOrEnumParam = true;
9364 break;
9365 }
9366 }
9367
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009368 if (!ClassOrEnumParam)
9369 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009370 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009371 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009372 }
9373
9374 // C++ [over.oper]p8:
9375 // An operator function cannot have default arguments (8.3.6),
9376 // except where explicitly stated below.
9377 //
Mike Stump1eb44332009-09-09 15:08:12 +00009378 // Only the function-call operator allows default arguments
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009379 // (C++ [over.call]p1).
9380 if (Op != OO_Call) {
9381 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
9382 Param != FnDecl->param_end(); ++Param) {
Anders Carlsson156c78e2009-12-13 17:53:43 +00009383 if ((*Param)->hasDefaultArg())
Mike Stump1eb44332009-09-09 15:08:12 +00009384 return Diag((*Param)->getLocation(),
Douglas Gregor61366e92008-12-24 00:01:03 +00009385 diag::err_operator_overload_default_arg)
Anders Carlsson156c78e2009-12-13 17:53:43 +00009386 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009387 }
9388 }
9389
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009390 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
9391 { false, false, false }
9392#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
9393 , { Unary, Binary, MemberOnly }
9394#include "clang/Basic/OperatorKinds.def"
9395 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009396
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009397 bool CanBeUnaryOperator = OperatorUses[Op][0];
9398 bool CanBeBinaryOperator = OperatorUses[Op][1];
9399 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009400
9401 // C++ [over.oper]p8:
9402 // [...] Operator functions cannot have more or fewer parameters
9403 // than the number required for the corresponding operator, as
9404 // described in the rest of this subclause.
Mike Stump1eb44332009-09-09 15:08:12 +00009405 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009406 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009407 if (Op != OO_Call &&
9408 ((NumParams == 1 && !CanBeUnaryOperator) ||
9409 (NumParams == 2 && !CanBeBinaryOperator) ||
9410 (NumParams < 1) || (NumParams > 2))) {
9411 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00009412 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009413 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00009414 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009415 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00009416 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009417 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00009418 assert(CanBeBinaryOperator &&
9419 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00009420 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009421 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009422
Chris Lattner416e46f2008-11-21 07:57:12 +00009423 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009424 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009425 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00009426
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009427 // Overloaded operators other than operator() cannot be variadic.
9428 if (Op != OO_Call &&
John McCall183700f2009-09-21 23:43:11 +00009429 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009430 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009431 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009432 }
9433
9434 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009435 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
9436 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009437 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009438 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009439 }
9440
9441 // C++ [over.inc]p1:
9442 // The user-defined function called operator++ implements the
9443 // prefix and postfix ++ operator. If this function is a member
9444 // function with no parameters, or a non-member function with one
9445 // parameter of class or enumeration type, it defines the prefix
9446 // increment operator ++ for objects of that type. If the function
9447 // is a member function with one parameter (which shall be of type
9448 // int) or a non-member function with two parameters (the second
9449 // of which shall be of type int), it defines the postfix
9450 // increment operator ++ for objects of that type.
9451 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
9452 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
9453 bool ParamIsInt = false;
John McCall183700f2009-09-21 23:43:11 +00009454 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009455 ParamIsInt = BT->getKind() == BuiltinType::Int;
9456
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00009457 if (!ParamIsInt)
9458 return Diag(LastParam->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00009459 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00009460 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009461 }
9462
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009463 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009464}
Chris Lattner5a003a42008-12-17 07:09:26 +00009465
Sean Hunta6c058d2010-01-13 09:01:02 +00009466/// CheckLiteralOperatorDeclaration - Check whether the declaration
9467/// of this literal operator function is well-formed. If so, returns
9468/// false; otherwise, emits appropriate diagnostics and returns true.
9469bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
Richard Smithe5658f02012-03-10 22:18:57 +00009470 if (isa<CXXMethodDecl>(FnDecl)) {
Sean Hunta6c058d2010-01-13 09:01:02 +00009471 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
9472 << FnDecl->getDeclName();
9473 return true;
9474 }
9475
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009476 if (FnDecl->isExternC()) {
9477 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
9478 return true;
9479 }
9480
Sean Hunta6c058d2010-01-13 09:01:02 +00009481 bool Valid = false;
9482
Richard Smith36f5cfe2012-03-09 08:00:36 +00009483 // This might be the definition of a literal operator template.
9484 FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
9485 // This might be a specialization of a literal operator template.
9486 if (!TpDecl)
9487 TpDecl = FnDecl->getPrimaryTemplate();
9488
Sean Hunt216c2782010-04-07 23:11:06 +00009489 // template <char...> type operator "" name() is the only valid template
9490 // signature, and the only valid signature with no parameters.
Richard Smith36f5cfe2012-03-09 08:00:36 +00009491 if (TpDecl) {
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009492 if (FnDecl->param_size() == 0) {
Sean Hunt216c2782010-04-07 23:11:06 +00009493 // Must have only one template parameter
9494 TemplateParameterList *Params = TpDecl->getTemplateParameters();
9495 if (Params->size() == 1) {
9496 NonTypeTemplateParmDecl *PmDecl =
Richard Smith5295b972012-08-03 21:14:57 +00009497 dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(0));
Sean Hunta6c058d2010-01-13 09:01:02 +00009498
Sean Hunt216c2782010-04-07 23:11:06 +00009499 // The template parameter must be a char parameter pack.
Sean Hunt216c2782010-04-07 23:11:06 +00009500 if (PmDecl && PmDecl->isTemplateParameterPack() &&
9501 Context.hasSameType(PmDecl->getType(), Context.CharTy))
9502 Valid = true;
9503 }
9504 }
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009505 } else if (FnDecl->param_size()) {
Sean Hunta6c058d2010-01-13 09:01:02 +00009506 // Check the first parameter
Sean Hunt216c2782010-04-07 23:11:06 +00009507 FunctionDecl::param_iterator Param = FnDecl->param_begin();
9508
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009509 QualType T = (*Param)->getType().getUnqualifiedType();
Sean Hunta6c058d2010-01-13 09:01:02 +00009510
Sean Hunt30019c02010-04-07 22:57:35 +00009511 // unsigned long long int, long double, and any character type are allowed
9512 // as the only parameters.
Sean Hunta6c058d2010-01-13 09:01:02 +00009513 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
9514 Context.hasSameType(T, Context.LongDoubleTy) ||
9515 Context.hasSameType(T, Context.CharTy) ||
9516 Context.hasSameType(T, Context.WCharTy) ||
9517 Context.hasSameType(T, Context.Char16Ty) ||
9518 Context.hasSameType(T, Context.Char32Ty)) {
9519 if (++Param == FnDecl->param_end())
9520 Valid = true;
9521 goto FinishedParams;
9522 }
9523
Sean Hunt30019c02010-04-07 22:57:35 +00009524 // Otherwise it must be a pointer to const; let's strip those qualifiers.
Sean Hunta6c058d2010-01-13 09:01:02 +00009525 const PointerType *PT = T->getAs<PointerType>();
9526 if (!PT)
9527 goto FinishedParams;
9528 T = PT->getPointeeType();
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009529 if (!T.isConstQualified() || T.isVolatileQualified())
Sean Hunta6c058d2010-01-13 09:01:02 +00009530 goto FinishedParams;
9531 T = T.getUnqualifiedType();
9532
9533 // Move on to the second parameter;
9534 ++Param;
9535
9536 // If there is no second parameter, the first must be a const char *
9537 if (Param == FnDecl->param_end()) {
9538 if (Context.hasSameType(T, Context.CharTy))
9539 Valid = true;
9540 goto FinishedParams;
9541 }
9542
9543 // const char *, const wchar_t*, const char16_t*, and const char32_t*
9544 // are allowed as the first parameter to a two-parameter function
9545 if (!(Context.hasSameType(T, Context.CharTy) ||
9546 Context.hasSameType(T, Context.WCharTy) ||
9547 Context.hasSameType(T, Context.Char16Ty) ||
9548 Context.hasSameType(T, Context.Char32Ty)))
9549 goto FinishedParams;
9550
9551 // The second and final parameter must be an std::size_t
9552 T = (*Param)->getType().getUnqualifiedType();
9553 if (Context.hasSameType(T, Context.getSizeType()) &&
9554 ++Param == FnDecl->param_end())
9555 Valid = true;
9556 }
9557
9558 // FIXME: This diagnostic is absolutely terrible.
9559FinishedParams:
9560 if (!Valid) {
9561 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
9562 << FnDecl->getDeclName();
9563 return true;
9564 }
9565
Richard Smitha9e88b22012-03-09 08:16:22 +00009566 // A parameter-declaration-clause containing a default argument is not
9567 // equivalent to any of the permitted forms.
9568 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
9569 ParamEnd = FnDecl->param_end();
9570 Param != ParamEnd; ++Param) {
9571 if ((*Param)->hasDefaultArg()) {
9572 Diag((*Param)->getDefaultArgRange().getBegin(),
9573 diag::err_literal_operator_default_argument)
9574 << (*Param)->getDefaultArgRange();
9575 break;
9576 }
9577 }
9578
Richard Smith2fb4ae32012-03-08 02:39:21 +00009579 StringRef LiteralName
Douglas Gregor1155c422011-08-30 22:40:35 +00009580 = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
9581 if (LiteralName[0] != '_') {
Richard Smith2fb4ae32012-03-08 02:39:21 +00009582 // C++11 [usrlit.suffix]p1:
9583 // Literal suffix identifiers that do not start with an underscore
9584 // are reserved for future standardization.
9585 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved);
Douglas Gregor1155c422011-08-30 22:40:35 +00009586 }
Richard Smith2fb4ae32012-03-08 02:39:21 +00009587
Sean Hunta6c058d2010-01-13 09:01:02 +00009588 return false;
9589}
9590
Douglas Gregor074149e2009-01-05 19:45:36 +00009591/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
9592/// linkage specification, including the language and (if present)
9593/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
9594/// the location of the language string literal, which is provided
9595/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
9596/// the '{' brace. Otherwise, this linkage specification does not
9597/// have any braces.
Chris Lattner7d642712010-11-09 20:15:55 +00009598Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
9599 SourceLocation LangLoc,
Chris Lattner5f9e2722011-07-23 10:55:15 +00009600 StringRef Lang,
Chris Lattner7d642712010-11-09 20:15:55 +00009601 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00009602 LinkageSpecDecl::LanguageIDs Language;
Benjamin Kramerd5663812010-05-03 13:08:54 +00009603 if (Lang == "\"C\"")
Chris Lattnercc98eac2008-12-17 07:13:27 +00009604 Language = LinkageSpecDecl::lang_c;
Benjamin Kramerd5663812010-05-03 13:08:54 +00009605 else if (Lang == "\"C++\"")
Chris Lattnercc98eac2008-12-17 07:13:27 +00009606 Language = LinkageSpecDecl::lang_cxx;
9607 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00009608 Diag(LangLoc, diag::err_bad_language);
John McCalld226f652010-08-21 09:40:31 +00009609 return 0;
Chris Lattnercc98eac2008-12-17 07:13:27 +00009610 }
Mike Stump1eb44332009-09-09 15:08:12 +00009611
Chris Lattnercc98eac2008-12-17 07:13:27 +00009612 // FIXME: Add all the various semantics of linkage specifications
Mike Stump1eb44332009-09-09 15:08:12 +00009613
Douglas Gregor074149e2009-01-05 19:45:36 +00009614 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009615 ExternLoc, LangLoc, Language);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009616 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00009617 PushDeclContext(S, D);
John McCalld226f652010-08-21 09:40:31 +00009618 return D;
Chris Lattnercc98eac2008-12-17 07:13:27 +00009619}
9620
Abramo Bagnara35f9a192010-07-30 16:47:02 +00009621/// ActOnFinishLinkageSpecification - Complete the definition of
Douglas Gregor074149e2009-01-05 19:45:36 +00009622/// the C++ linkage specification LinkageSpec. If RBraceLoc is
9623/// valid, it's the position of the closing '}' brace in a linkage
9624/// specification that uses braces.
John McCalld226f652010-08-21 09:40:31 +00009625Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
Abramo Bagnara5f6bcbe2011-03-03 14:52:38 +00009626 Decl *LinkageSpec,
9627 SourceLocation RBraceLoc) {
9628 if (LinkageSpec) {
9629 if (RBraceLoc.isValid()) {
9630 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
9631 LSDecl->setRBraceLoc(RBraceLoc);
9632 }
Douglas Gregor074149e2009-01-05 19:45:36 +00009633 PopDeclContext();
Abramo Bagnara5f6bcbe2011-03-03 14:52:38 +00009634 }
Douglas Gregor074149e2009-01-05 19:45:36 +00009635 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00009636}
9637
Douglas Gregord308e622009-05-18 20:51:54 +00009638/// \brief Perform semantic analysis for the variable declaration that
9639/// occurs within a C++ catch clause, returning the newly-created
9640/// variable.
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009641VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
John McCalla93c9342009-12-07 02:54:59 +00009642 TypeSourceInfo *TInfo,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009643 SourceLocation StartLoc,
9644 SourceLocation Loc,
9645 IdentifierInfo *Name) {
Douglas Gregord308e622009-05-18 20:51:54 +00009646 bool Invalid = false;
Douglas Gregor83cb9422010-09-09 17:09:21 +00009647 QualType ExDeclType = TInfo->getType();
9648
Sebastian Redl4b07b292008-12-22 19:15:10 +00009649 // Arrays and functions decay.
9650 if (ExDeclType->isArrayType())
9651 ExDeclType = Context.getArrayDecayedType(ExDeclType);
9652 else if (ExDeclType->isFunctionType())
9653 ExDeclType = Context.getPointerType(ExDeclType);
9654
9655 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
9656 // The exception-declaration shall not denote a pointer or reference to an
9657 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009658 // N2844 forbids rvalue references.
Mike Stump1eb44332009-09-09 15:08:12 +00009659 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregor83cb9422010-09-09 17:09:21 +00009660 Diag(Loc, diag::err_catch_rvalue_ref);
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009661 Invalid = true;
9662 }
Douglas Gregord308e622009-05-18 20:51:54 +00009663
Sebastian Redl4b07b292008-12-22 19:15:10 +00009664 QualType BaseType = ExDeclType;
9665 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00009666 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek6217b802009-07-29 21:53:49 +00009667 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009668 BaseType = Ptr->getPointeeType();
9669 Mode = 1;
Douglas Gregorecd7b042012-01-24 19:01:26 +00009670 DK = diag::err_catch_incomplete_ptr;
Mike Stump1eb44332009-09-09 15:08:12 +00009671 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009672 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00009673 BaseType = Ref->getPointeeType();
9674 Mode = 2;
Douglas Gregorecd7b042012-01-24 19:01:26 +00009675 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009676 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009677 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregorecd7b042012-01-24 19:01:26 +00009678 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00009679 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009680
Mike Stump1eb44332009-09-09 15:08:12 +00009681 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregord308e622009-05-18 20:51:54 +00009682 RequireNonAbstractType(Loc, ExDeclType,
9683 diag::err_abstract_type_in_decl,
9684 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00009685 Invalid = true;
9686
John McCall5a180392010-07-24 00:37:23 +00009687 // Only the non-fragile NeXT runtime currently supports C++ catches
9688 // of ObjC types, and no runtime supports catching ObjC types by value.
David Blaikie4e4d0842012-03-11 07:00:24 +00009689 if (!Invalid && getLangOpts().ObjC1) {
John McCall5a180392010-07-24 00:37:23 +00009690 QualType T = ExDeclType;
9691 if (const ReferenceType *RT = T->getAs<ReferenceType>())
9692 T = RT->getPointeeType();
9693
9694 if (T->isObjCObjectType()) {
9695 Diag(Loc, diag::err_objc_object_catch);
9696 Invalid = true;
9697 } else if (T->isObjCObjectPointerType()) {
John McCall260611a2012-06-20 06:18:46 +00009698 // FIXME: should this be a test for macosx-fragile specifically?
9699 if (getLangOpts().ObjCRuntime.isFragile())
Fariborz Jahaniancf5abc72011-06-23 19:00:08 +00009700 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
John McCall5a180392010-07-24 00:37:23 +00009701 }
9702 }
9703
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009704 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
9705 ExDeclType, TInfo, SC_None, SC_None);
Douglas Gregor324b54d2010-05-03 18:51:14 +00009706 ExDecl->setExceptionVariable(true);
9707
Douglas Gregor9aab9c42011-12-10 01:22:52 +00009708 // In ARC, infer 'retaining' for variables of retainable type.
David Blaikie4e4d0842012-03-11 07:00:24 +00009709 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
Douglas Gregor9aab9c42011-12-10 01:22:52 +00009710 Invalid = true;
9711
Douglas Gregorc41b8782011-07-06 18:14:43 +00009712 if (!Invalid && !ExDeclType->isDependentType()) {
John McCalle996ffd2011-02-16 08:02:54 +00009713 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
Douglas Gregor6d182892010-03-05 23:38:39 +00009714 // C++ [except.handle]p16:
9715 // The object declared in an exception-declaration or, if the
9716 // exception-declaration does not specify a name, a temporary (12.2) is
9717 // copy-initialized (8.5) from the exception object. [...]
9718 // The object is destroyed when the handler exits, after the destruction
9719 // of any automatic objects initialized within the handler.
9720 //
9721 // We just pretend to initialize the object with itself, then make sure
9722 // it can be destroyed later.
John McCalle996ffd2011-02-16 08:02:54 +00009723 QualType initType = ExDeclType;
9724
9725 InitializedEntity entity =
9726 InitializedEntity::InitializeVariable(ExDecl);
9727 InitializationKind initKind =
9728 InitializationKind::CreateCopy(Loc, SourceLocation());
9729
9730 Expr *opaqueValue =
9731 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
9732 InitializationSequence sequence(*this, entity, initKind, &opaqueValue, 1);
9733 ExprResult result = sequence.Perform(*this, entity, initKind,
9734 MultiExprArg(&opaqueValue, 1));
9735 if (result.isInvalid())
Douglas Gregor6d182892010-03-05 23:38:39 +00009736 Invalid = true;
John McCalle996ffd2011-02-16 08:02:54 +00009737 else {
9738 // If the constructor used was non-trivial, set this as the
9739 // "initializer".
9740 CXXConstructExpr *construct = cast<CXXConstructExpr>(result.take());
9741 if (!construct->getConstructor()->isTrivial()) {
9742 Expr *init = MaybeCreateExprWithCleanups(construct);
9743 ExDecl->setInit(init);
9744 }
9745
9746 // And make sure it's destructable.
9747 FinalizeVarWithDestructor(ExDecl, recordType);
9748 }
Douglas Gregor6d182892010-03-05 23:38:39 +00009749 }
9750 }
9751
Douglas Gregord308e622009-05-18 20:51:54 +00009752 if (Invalid)
9753 ExDecl->setInvalidDecl();
9754
9755 return ExDecl;
9756}
9757
9758/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
9759/// handler.
John McCalld226f652010-08-21 09:40:31 +00009760Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCallbf1a0282010-06-04 23:28:52 +00009761 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
Douglas Gregora669c532010-12-16 17:48:04 +00009762 bool Invalid = D.isInvalidType();
9763
9764 // Check for unexpanded parameter packs.
9765 if (TInfo && DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
9766 UPPC_ExceptionType)) {
9767 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
9768 D.getIdentifierLoc());
9769 Invalid = true;
9770 }
9771
Sebastian Redl4b07b292008-12-22 19:15:10 +00009772 IdentifierInfo *II = D.getIdentifier();
Douglas Gregorc83c6872010-04-15 22:33:43 +00009773 if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
Douglas Gregorc0b39642010-04-15 23:40:53 +00009774 LookupOrdinaryName,
9775 ForRedeclaration)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009776 // The scope should be freshly made just for us. There is just no way
9777 // it contains any previous declaration.
John McCalld226f652010-08-21 09:40:31 +00009778 assert(!S->isDeclScope(PrevDecl));
Sebastian Redl4b07b292008-12-22 19:15:10 +00009779 if (PrevDecl->isTemplateParameter()) {
9780 // Maybe we will complain about the shadowed template parameter.
9781 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Douglas Gregorcb8f9512011-10-20 17:58:49 +00009782 PrevDecl = 0;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009783 }
9784 }
9785
Chris Lattnereaaebc72009-04-25 08:06:05 +00009786 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009787 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
9788 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00009789 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009790 }
9791
Douglas Gregor83cb9422010-09-09 17:09:21 +00009792 VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
Daniel Dunbar96a00142012-03-09 18:35:03 +00009793 D.getLocStart(),
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009794 D.getIdentifierLoc(),
9795 D.getIdentifier());
Chris Lattnereaaebc72009-04-25 08:06:05 +00009796 if (Invalid)
9797 ExDecl->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00009798
Sebastian Redl4b07b292008-12-22 19:15:10 +00009799 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00009800 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00009801 PushOnScopeChains(ExDecl, S);
9802 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009803 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00009804
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00009805 ProcessDeclAttributes(S, ExDecl, D);
John McCalld226f652010-08-21 09:40:31 +00009806 return ExDecl;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009807}
Anders Carlssonfb311762009-03-14 00:25:26 +00009808
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009809Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
John McCall9ae2f072010-08-23 23:25:46 +00009810 Expr *AssertExpr,
Richard Smithe3f470a2012-07-11 22:37:56 +00009811 Expr *AssertMessageExpr,
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009812 SourceLocation RParenLoc) {
Richard Smithe3f470a2012-07-11 22:37:56 +00009813 StringLiteral *AssertMessage = cast<StringLiteral>(AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00009814
Richard Smithe3f470a2012-07-11 22:37:56 +00009815 if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
9816 return 0;
9817
9818 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
9819 AssertMessage, RParenLoc, false);
9820}
9821
9822Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
9823 Expr *AssertExpr,
9824 StringLiteral *AssertMessage,
9825 SourceLocation RParenLoc,
9826 bool Failed) {
9827 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
9828 !Failed) {
Richard Smith282e7e62012-02-04 09:53:13 +00009829 // In a static_assert-declaration, the constant-expression shall be a
9830 // constant expression that can be contextually converted to bool.
9831 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
9832 if (Converted.isInvalid())
Richard Smithe3f470a2012-07-11 22:37:56 +00009833 Failed = true;
Richard Smith282e7e62012-02-04 09:53:13 +00009834
Richard Smithdaaefc52011-12-14 23:32:26 +00009835 llvm::APSInt Cond;
Richard Smithe3f470a2012-07-11 22:37:56 +00009836 if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
Douglas Gregorab41fe92012-05-04 22:38:52 +00009837 diag::err_static_assert_expression_is_not_constant,
Richard Smith282e7e62012-02-04 09:53:13 +00009838 /*AllowFold=*/false).isInvalid())
Richard Smithe3f470a2012-07-11 22:37:56 +00009839 Failed = true;
Anders Carlssonfb311762009-03-14 00:25:26 +00009840
Richard Smithe3f470a2012-07-11 22:37:56 +00009841 if (!Failed && !Cond) {
Richard Smith0cc323c2012-03-05 23:20:05 +00009842 llvm::SmallString<256> MsgBuffer;
9843 llvm::raw_svector_ostream Msg(MsgBuffer);
Richard Smithd1420c62012-08-16 03:56:14 +00009844 AssertMessage->printPretty(Msg, 0, getPrintingPolicy());
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009845 Diag(StaticAssertLoc, diag::err_static_assert_failed)
Richard Smith0cc323c2012-03-05 23:20:05 +00009846 << Msg.str() << AssertExpr->getSourceRange();
Richard Smithe3f470a2012-07-11 22:37:56 +00009847 Failed = true;
Richard Smith0cc323c2012-03-05 23:20:05 +00009848 }
Anders Carlssonc3082412009-03-14 00:33:21 +00009849 }
Mike Stump1eb44332009-09-09 15:08:12 +00009850
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009851 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
Richard Smithe3f470a2012-07-11 22:37:56 +00009852 AssertExpr, AssertMessage, RParenLoc,
9853 Failed);
Mike Stump1eb44332009-09-09 15:08:12 +00009854
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009855 CurContext->addDecl(Decl);
John McCalld226f652010-08-21 09:40:31 +00009856 return Decl;
Anders Carlssonfb311762009-03-14 00:25:26 +00009857}
Sebastian Redl50de12f2009-03-24 22:27:57 +00009858
Douglas Gregor1d869352010-04-07 16:53:43 +00009859/// \brief Perform semantic analysis of the given friend type declaration.
9860///
9861/// \returns A friend declaration that.
Richard Smithd6f80da2012-09-20 01:31:00 +00009862FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart,
Abramo Bagnara0216df82011-10-29 20:52:52 +00009863 SourceLocation FriendLoc,
Douglas Gregor1d869352010-04-07 16:53:43 +00009864 TypeSourceInfo *TSInfo) {
9865 assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
9866
9867 QualType T = TSInfo->getType();
Abramo Bagnarabd054db2010-05-20 10:00:11 +00009868 SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor1d869352010-04-07 16:53:43 +00009869
Richard Smith6b130222011-10-18 21:39:00 +00009870 // C++03 [class.friend]p2:
9871 // An elaborated-type-specifier shall be used in a friend declaration
9872 // for a class.*
9873 //
9874 // * The class-key of the elaborated-type-specifier is required.
9875 if (!ActiveTemplateInstantiations.empty()) {
9876 // Do not complain about the form of friend template types during
9877 // template instantiation; we will already have complained when the
9878 // template was declared.
9879 } else if (!T->isElaboratedTypeSpecifier()) {
9880 // If we evaluated the type to a record type, suggest putting
9881 // a tag in front.
9882 if (const RecordType *RT = T->getAs<RecordType>()) {
9883 RecordDecl *RD = RT->getDecl();
9884
9885 std::string InsertionText = std::string(" ") + RD->getKindName();
9886
9887 Diag(TypeRange.getBegin(),
David Blaikie4e4d0842012-03-11 07:00:24 +00009888 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009889 diag::warn_cxx98_compat_unelaborated_friend_type :
9890 diag::ext_unelaborated_friend_type)
9891 << (unsigned) RD->getTagKind()
9892 << T
9893 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(FriendLoc),
9894 InsertionText);
9895 } else {
9896 Diag(FriendLoc,
David Blaikie4e4d0842012-03-11 07:00:24 +00009897 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009898 diag::warn_cxx98_compat_nonclass_type_friend :
9899 diag::ext_nonclass_type_friend)
Douglas Gregor1d869352010-04-07 16:53:43 +00009900 << T
Richard Smithd6f80da2012-09-20 01:31:00 +00009901 << TypeRange;
Douglas Gregor1d869352010-04-07 16:53:43 +00009902 }
Richard Smith6b130222011-10-18 21:39:00 +00009903 } else if (T->getAs<EnumType>()) {
9904 Diag(FriendLoc,
David Blaikie4e4d0842012-03-11 07:00:24 +00009905 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009906 diag::warn_cxx98_compat_enum_friend :
9907 diag::ext_enum_friend)
9908 << T
Richard Smithd6f80da2012-09-20 01:31:00 +00009909 << TypeRange;
Douglas Gregor1d869352010-04-07 16:53:43 +00009910 }
9911
Richard Smithd6f80da2012-09-20 01:31:00 +00009912 // C++11 [class.friend]p3:
9913 // A friend declaration that does not declare a function shall have one
9914 // of the following forms:
9915 // friend elaborated-type-specifier ;
9916 // friend simple-type-specifier ;
9917 // friend typename-specifier ;
9918 if (getLangOpts().CPlusPlus0x && LocStart != FriendLoc)
9919 Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
9920
Douglas Gregor06245bf2010-04-07 17:57:12 +00009921 // If the type specifier in a friend declaration designates a (possibly
Richard Smithd6f80da2012-09-20 01:31:00 +00009922 // cv-qualified) class type, that class is declared as a friend; otherwise,
Douglas Gregor06245bf2010-04-07 17:57:12 +00009923 // the friend declaration is ignored.
Richard Smithd6f80da2012-09-20 01:31:00 +00009924 return FriendDecl::Create(Context, CurContext, LocStart, TSInfo, FriendLoc);
Douglas Gregor1d869352010-04-07 16:53:43 +00009925}
9926
John McCall9a34edb2010-10-19 01:40:49 +00009927/// Handle a friend tag declaration where the scope specifier was
9928/// templated.
9929Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
9930 unsigned TagSpec, SourceLocation TagLoc,
9931 CXXScopeSpec &SS,
9932 IdentifierInfo *Name, SourceLocation NameLoc,
9933 AttributeList *Attr,
9934 MultiTemplateParamsArg TempParamLists) {
9935 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
9936
9937 bool isExplicitSpecialization = false;
John McCall9a34edb2010-10-19 01:40:49 +00009938 bool Invalid = false;
9939
9940 if (TemplateParameterList *TemplateParams
Douglas Gregorc8406492011-05-10 18:27:06 +00009941 = MatchTemplateParametersToScopeSpecifier(TagLoc, NameLoc, SS,
Benjamin Kramer5354e772012-08-23 23:38:35 +00009942 TempParamLists.data(),
John McCall9a34edb2010-10-19 01:40:49 +00009943 TempParamLists.size(),
9944 /*friend*/ true,
9945 isExplicitSpecialization,
9946 Invalid)) {
John McCall9a34edb2010-10-19 01:40:49 +00009947 if (TemplateParams->size() > 0) {
9948 // This is a declaration of a class template.
9949 if (Invalid)
9950 return 0;
Abramo Bagnarac57c17d2011-03-10 13:28:31 +00009951
Eric Christopher4110e132011-07-21 05:34:24 +00009952 return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc,
9953 SS, Name, NameLoc, Attr,
9954 TemplateParams, AS_public,
Douglas Gregore7612302011-09-09 19:05:14 +00009955 /*ModulePrivateLoc=*/SourceLocation(),
Eric Christopher4110e132011-07-21 05:34:24 +00009956 TempParamLists.size() - 1,
Benjamin Kramer5354e772012-08-23 23:38:35 +00009957 TempParamLists.data()).take();
John McCall9a34edb2010-10-19 01:40:49 +00009958 } else {
9959 // The "template<>" header is extraneous.
9960 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
9961 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
9962 isExplicitSpecialization = true;
9963 }
9964 }
9965
9966 if (Invalid) return 0;
9967
John McCall9a34edb2010-10-19 01:40:49 +00009968 bool isAllExplicitSpecializations = true;
Abramo Bagnara7f0a9152011-03-18 15:16:37 +00009969 for (unsigned I = TempParamLists.size(); I-- > 0; ) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009970 if (TempParamLists[I]->size()) {
John McCall9a34edb2010-10-19 01:40:49 +00009971 isAllExplicitSpecializations = false;
9972 break;
9973 }
9974 }
9975
9976 // FIXME: don't ignore attributes.
9977
9978 // If it's explicit specializations all the way down, just forget
9979 // about the template header and build an appropriate non-templated
9980 // friend. TODO: for source fidelity, remember the headers.
9981 if (isAllExplicitSpecializations) {
Douglas Gregorba4ee9a2011-10-20 15:58:54 +00009982 if (SS.isEmpty()) {
9983 bool Owned = false;
9984 bool IsDependent = false;
9985 return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
9986 Attr, AS_public,
9987 /*ModulePrivateLoc=*/SourceLocation(),
9988 MultiTemplateParamsArg(), Owned, IsDependent,
Richard Smithbdad7a22012-01-10 01:33:14 +00009989 /*ScopedEnumKWLoc=*/SourceLocation(),
Douglas Gregorba4ee9a2011-10-20 15:58:54 +00009990 /*ScopedEnumUsesClassTag=*/false,
9991 /*UnderlyingType=*/TypeResult());
9992 }
9993
Douglas Gregor2494dd02011-03-01 01:34:45 +00009994 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCall9a34edb2010-10-19 01:40:49 +00009995 ElaboratedTypeKeyword Keyword
9996 = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
Douglas Gregor2494dd02011-03-01 01:34:45 +00009997 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
Douglas Gregore29425b2011-02-28 22:42:13 +00009998 *Name, NameLoc);
John McCall9a34edb2010-10-19 01:40:49 +00009999 if (T.isNull())
10000 return 0;
10001
10002 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
10003 if (isa<DependentNameType>(T)) {
10004 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010005 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor2494dd02011-03-01 01:34:45 +000010006 TL.setQualifierLoc(QualifierLoc);
John McCall9a34edb2010-10-19 01:40:49 +000010007 TL.setNameLoc(NameLoc);
10008 } else {
10009 ElaboratedTypeLoc TL = cast<ElaboratedTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010010 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor9e876872011-03-01 18:12:44 +000010011 TL.setQualifierLoc(QualifierLoc);
John McCall9a34edb2010-10-19 01:40:49 +000010012 cast<TypeSpecTypeLoc>(TL.getNamedTypeLoc()).setNameLoc(NameLoc);
10013 }
10014
10015 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
10016 TSI, FriendLoc);
10017 Friend->setAccess(AS_public);
10018 CurContext->addDecl(Friend);
10019 return Friend;
10020 }
Douglas Gregorba4ee9a2011-10-20 15:58:54 +000010021
10022 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
10023
10024
John McCall9a34edb2010-10-19 01:40:49 +000010025
10026 // Handle the case of a templated-scope friend class. e.g.
10027 // template <class T> class A<T>::B;
10028 // FIXME: we don't support these right now.
10029 ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
10030 QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
10031 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
10032 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010033 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor2494dd02011-03-01 01:34:45 +000010034 TL.setQualifierLoc(SS.getWithLocInContext(Context));
John McCall9a34edb2010-10-19 01:40:49 +000010035 TL.setNameLoc(NameLoc);
10036
10037 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
10038 TSI, FriendLoc);
10039 Friend->setAccess(AS_public);
10040 Friend->setUnsupportedFriend(true);
10041 CurContext->addDecl(Friend);
10042 return Friend;
10043}
10044
10045
John McCalldd4a3b02009-09-16 22:47:08 +000010046/// Handle a friend type declaration. This works in tandem with
10047/// ActOnTag.
10048///
10049/// Notes on friend class templates:
10050///
10051/// We generally treat friend class declarations as if they were
10052/// declaring a class. So, for example, the elaborated type specifier
10053/// in a friend declaration is required to obey the restrictions of a
10054/// class-head (i.e. no typedefs in the scope chain), template
10055/// parameters are required to match up with simple template-ids, &c.
10056/// However, unlike when declaring a template specialization, it's
10057/// okay to refer to a template specialization without an empty
10058/// template parameter declaration, e.g.
10059/// friend class A<T>::B<unsigned>;
10060/// We permit this as a special case; if there are any template
10061/// parameters present at all, require proper matching, i.e.
James Dennettef2b5b32012-06-15 22:23:43 +000010062/// template <> template \<class T> friend class A<int>::B;
John McCalld226f652010-08-21 09:40:31 +000010063Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCallbe04b6d2010-10-16 07:23:36 +000010064 MultiTemplateParamsArg TempParams) {
Daniel Dunbar96a00142012-03-09 18:35:03 +000010065 SourceLocation Loc = DS.getLocStart();
John McCall67d1a672009-08-06 02:15:43 +000010066
10067 assert(DS.isFriendSpecified());
10068 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
10069
John McCalldd4a3b02009-09-16 22:47:08 +000010070 // Try to convert the decl specifier to a type. This works for
10071 // friend templates because ActOnTag never produces a ClassTemplateDecl
10072 // for a TUK_Friend.
Chris Lattnerc7f19042009-10-25 17:47:27 +000010073 Declarator TheDeclarator(DS, Declarator::MemberContext);
John McCallbf1a0282010-06-04 23:28:52 +000010074 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
10075 QualType T = TSI->getType();
Chris Lattnerc7f19042009-10-25 17:47:27 +000010076 if (TheDeclarator.isInvalidType())
John McCalld226f652010-08-21 09:40:31 +000010077 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010078
Douglas Gregor6ccab972010-12-16 01:14:37 +000010079 if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
10080 return 0;
10081
John McCalldd4a3b02009-09-16 22:47:08 +000010082 // This is definitely an error in C++98. It's probably meant to
10083 // be forbidden in C++0x, too, but the specification is just
10084 // poorly written.
10085 //
10086 // The problem is with declarations like the following:
10087 // template <T> friend A<T>::foo;
10088 // where deciding whether a class C is a friend or not now hinges
10089 // on whether there exists an instantiation of A that causes
10090 // 'foo' to equal C. There are restrictions on class-heads
10091 // (which we declare (by fiat) elaborated friend declarations to
10092 // be) that makes this tractable.
10093 //
10094 // FIXME: handle "template <> friend class A<T>;", which
10095 // is possibly well-formed? Who even knows?
Douglas Gregor40336422010-03-31 22:19:08 +000010096 if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
John McCalldd4a3b02009-09-16 22:47:08 +000010097 Diag(Loc, diag::err_tagless_friend_type_template)
10098 << DS.getSourceRange();
John McCalld226f652010-08-21 09:40:31 +000010099 return 0;
John McCalldd4a3b02009-09-16 22:47:08 +000010100 }
Douglas Gregor1d869352010-04-07 16:53:43 +000010101
John McCall02cace72009-08-28 07:59:38 +000010102 // C++98 [class.friend]p1: A friend of a class is a function
10103 // or class that is not a member of the class . . .
John McCalla236a552009-12-22 00:59:39 +000010104 // This is fixed in DR77, which just barely didn't make the C++03
10105 // deadline. It's also a very silly restriction that seriously
10106 // affects inner classes and which nobody else seems to implement;
10107 // thus we never diagnose it, not even in -pedantic.
John McCall32f2fb52010-03-25 18:04:51 +000010108 //
10109 // But note that we could warn about it: it's always useless to
10110 // friend one of your own members (it's not, however, worthless to
10111 // friend a member of an arbitrary specialization of your template).
John McCall02cace72009-08-28 07:59:38 +000010112
John McCalldd4a3b02009-09-16 22:47:08 +000010113 Decl *D;
Douglas Gregor1d869352010-04-07 16:53:43 +000010114 if (unsigned NumTempParamLists = TempParams.size())
John McCalldd4a3b02009-09-16 22:47:08 +000010115 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
Douglas Gregor1d869352010-04-07 16:53:43 +000010116 NumTempParamLists,
Benjamin Kramer5354e772012-08-23 23:38:35 +000010117 TempParams.data(),
John McCall32f2fb52010-03-25 18:04:51 +000010118 TSI,
John McCalldd4a3b02009-09-16 22:47:08 +000010119 DS.getFriendSpecLoc());
10120 else
Abramo Bagnara0216df82011-10-29 20:52:52 +000010121 D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
Douglas Gregor1d869352010-04-07 16:53:43 +000010122
10123 if (!D)
John McCalld226f652010-08-21 09:40:31 +000010124 return 0;
Douglas Gregor1d869352010-04-07 16:53:43 +000010125
John McCalldd4a3b02009-09-16 22:47:08 +000010126 D->setAccess(AS_public);
10127 CurContext->addDecl(D);
John McCall02cace72009-08-28 07:59:38 +000010128
John McCalld226f652010-08-21 09:40:31 +000010129 return D;
John McCall02cace72009-08-28 07:59:38 +000010130}
10131
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010132Decl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
John McCall337ec3d2010-10-12 23:13:28 +000010133 MultiTemplateParamsArg TemplateParams) {
John McCall02cace72009-08-28 07:59:38 +000010134 const DeclSpec &DS = D.getDeclSpec();
10135
10136 assert(DS.isFriendSpecified());
10137 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
10138
10139 SourceLocation Loc = D.getIdentifierLoc();
John McCallbf1a0282010-06-04 23:28:52 +000010140 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall67d1a672009-08-06 02:15:43 +000010141
10142 // C++ [class.friend]p1
10143 // A friend of a class is a function or class....
10144 // Note that this sees through typedefs, which is intended.
John McCall02cace72009-08-28 07:59:38 +000010145 // It *doesn't* see through dependent types, which is correct
10146 // according to [temp.arg.type]p3:
10147 // If a declaration acquires a function type through a
10148 // type dependent on a template-parameter and this causes
10149 // a declaration that does not use the syntactic form of a
10150 // function declarator to have a function type, the program
10151 // is ill-formed.
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010152 if (!TInfo->getType()->isFunctionType()) {
John McCall67d1a672009-08-06 02:15:43 +000010153 Diag(Loc, diag::err_unexpected_friend);
10154
10155 // It might be worthwhile to try to recover by creating an
10156 // appropriate declaration.
John McCalld226f652010-08-21 09:40:31 +000010157 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010158 }
10159
10160 // C++ [namespace.memdef]p3
10161 // - If a friend declaration in a non-local class first declares a
10162 // class or function, the friend class or function is a member
10163 // of the innermost enclosing namespace.
10164 // - The name of the friend is not found by simple name lookup
10165 // until a matching declaration is provided in that namespace
10166 // scope (either before or after the class declaration granting
10167 // friendship).
10168 // - If a friend function is called, its name may be found by the
10169 // name lookup that considers functions from namespaces and
10170 // classes associated with the types of the function arguments.
10171 // - When looking for a prior declaration of a class or a function
10172 // declared as a friend, scopes outside the innermost enclosing
10173 // namespace scope are not considered.
10174
John McCall337ec3d2010-10-12 23:13:28 +000010175 CXXScopeSpec &SS = D.getCXXScopeSpec();
Abramo Bagnara25777432010-08-11 22:01:17 +000010176 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
10177 DeclarationName Name = NameInfo.getName();
John McCall67d1a672009-08-06 02:15:43 +000010178 assert(Name);
10179
Douglas Gregor6ccab972010-12-16 01:14:37 +000010180 // Check for unexpanded parameter packs.
10181 if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
10182 DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
10183 DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
10184 return 0;
10185
John McCall67d1a672009-08-06 02:15:43 +000010186 // The context we found the declaration in, or in which we should
10187 // create the declaration.
10188 DeclContext *DC;
John McCall380aaa42010-10-13 06:22:15 +000010189 Scope *DCScope = S;
Abramo Bagnara25777432010-08-11 22:01:17 +000010190 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall68263142009-11-18 22:49:29 +000010191 ForRedeclaration);
John McCall67d1a672009-08-06 02:15:43 +000010192
John McCall337ec3d2010-10-12 23:13:28 +000010193 // FIXME: there are different rules in local classes
John McCall67d1a672009-08-06 02:15:43 +000010194
John McCall337ec3d2010-10-12 23:13:28 +000010195 // There are four cases here.
10196 // - There's no scope specifier, in which case we just go to the
John McCall29ae6e52010-10-13 05:45:15 +000010197 // appropriate scope and look for a function or function template
John McCall337ec3d2010-10-12 23:13:28 +000010198 // there as appropriate.
10199 // Recover from invalid scope qualifiers as if they just weren't there.
10200 if (SS.isInvalid() || !SS.isSet()) {
John McCall29ae6e52010-10-13 05:45:15 +000010201 // C++0x [namespace.memdef]p3:
10202 // If the name in a friend declaration is neither qualified nor
10203 // a template-id and the declaration is a function or an
10204 // elaborated-type-specifier, the lookup to determine whether
10205 // the entity has been previously declared shall not consider
10206 // any scopes outside the innermost enclosing namespace.
10207 // C++0x [class.friend]p11:
10208 // If a friend declaration appears in a local class and the name
10209 // specified is an unqualified name, a prior declaration is
10210 // looked up without considering scopes that are outside the
10211 // innermost enclosing non-class scope. For a friend function
10212 // declaration, if there is no prior declaration, the program is
10213 // ill-formed.
10214 bool isLocal = cast<CXXRecordDecl>(CurContext)->isLocalClass();
John McCall8a407372010-10-14 22:22:28 +000010215 bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
John McCall67d1a672009-08-06 02:15:43 +000010216
John McCall29ae6e52010-10-13 05:45:15 +000010217 // Find the appropriate context according to the above.
John McCall67d1a672009-08-06 02:15:43 +000010218 DC = CurContext;
10219 while (true) {
10220 // Skip class contexts. If someone can cite chapter and verse
10221 // for this behavior, that would be nice --- it's what GCC and
10222 // EDG do, and it seems like a reasonable intent, but the spec
10223 // really only says that checks for unqualified existing
10224 // declarations should stop at the nearest enclosing namespace,
10225 // not that they should only consider the nearest enclosing
10226 // namespace.
Nick Lewycky9c6fde52012-03-16 19:51:19 +000010227 while (DC->isRecord() || DC->isTransparentContext())
Douglas Gregor182ddf02009-09-28 00:08:27 +000010228 DC = DC->getParent();
John McCall67d1a672009-08-06 02:15:43 +000010229
John McCall68263142009-11-18 22:49:29 +000010230 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +000010231
10232 // TODO: decide what we think about using declarations.
John McCall29ae6e52010-10-13 05:45:15 +000010233 if (isLocal || !Previous.empty())
John McCall67d1a672009-08-06 02:15:43 +000010234 break;
John McCall29ae6e52010-10-13 05:45:15 +000010235
John McCall8a407372010-10-14 22:22:28 +000010236 if (isTemplateId) {
10237 if (isa<TranslationUnitDecl>(DC)) break;
10238 } else {
10239 if (DC->isFileContext()) break;
10240 }
John McCall67d1a672009-08-06 02:15:43 +000010241 DC = DC->getParent();
10242 }
10243
10244 // C++ [class.friend]p1: A friend of a class is a function or
10245 // class that is not a member of the class . . .
Richard Smithebaf0e62011-10-18 20:49:44 +000010246 // C++11 changes this for both friend types and functions.
John McCall7f27d922009-08-06 20:49:32 +000010247 // Most C++ 98 compilers do seem to give an error here, so
10248 // we do, too.
Richard Smithebaf0e62011-10-18 20:49:44 +000010249 if (!Previous.empty() && DC->Equals(CurContext))
10250 Diag(DS.getFriendSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +000010251 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +000010252 diag::warn_cxx98_compat_friend_is_member :
10253 diag::err_friend_is_member);
John McCall337ec3d2010-10-12 23:13:28 +000010254
John McCall380aaa42010-10-13 06:22:15 +000010255 DCScope = getScopeForDeclContext(S, DC);
Douglas Gregorfb35e8f2011-11-03 16:37:14 +000010256
Douglas Gregor883af832011-10-10 01:11:59 +000010257 // C++ [class.friend]p6:
10258 // A function can be defined in a friend declaration of a class if and
10259 // only if the class is a non-local class (9.8), the function name is
10260 // unqualified, and the function has namespace scope.
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010261 if (isLocal && D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010262 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
10263 }
10264
John McCall337ec3d2010-10-12 23:13:28 +000010265 // - There's a non-dependent scope specifier, in which case we
10266 // compute it and do a previous lookup there for a function
10267 // or function template.
10268 } else if (!SS.getScopeRep()->isDependent()) {
10269 DC = computeDeclContext(SS);
10270 if (!DC) return 0;
10271
10272 if (RequireCompleteDeclContext(SS, DC)) return 0;
10273
10274 LookupQualifiedName(Previous, DC);
10275
10276 // Ignore things found implicitly in the wrong scope.
10277 // TODO: better diagnostics for this case. Suggesting the right
10278 // qualified scope would be nice...
10279 LookupResult::Filter F = Previous.makeFilter();
10280 while (F.hasNext()) {
10281 NamedDecl *D = F.next();
10282 if (!DC->InEnclosingNamespaceSetOf(
10283 D->getDeclContext()->getRedeclContext()))
10284 F.erase();
10285 }
10286 F.done();
10287
10288 if (Previous.empty()) {
10289 D.setInvalidType();
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010290 Diag(Loc, diag::err_qualified_friend_not_found)
10291 << Name << TInfo->getType();
John McCall337ec3d2010-10-12 23:13:28 +000010292 return 0;
10293 }
10294
10295 // C++ [class.friend]p1: A friend of a class is a function or
10296 // class that is not a member of the class . . .
Richard Smithebaf0e62011-10-18 20:49:44 +000010297 if (DC->Equals(CurContext))
10298 Diag(DS.getFriendSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +000010299 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +000010300 diag::warn_cxx98_compat_friend_is_member :
10301 diag::err_friend_is_member);
Douglas Gregor883af832011-10-10 01:11:59 +000010302
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010303 if (D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010304 // C++ [class.friend]p6:
10305 // A function can be defined in a friend declaration of a class if and
10306 // only if the class is a non-local class (9.8), the function name is
10307 // unqualified, and the function has namespace scope.
10308 SemaDiagnosticBuilder DB
10309 = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
10310
10311 DB << SS.getScopeRep();
10312 if (DC->isFileContext())
10313 DB << FixItHint::CreateRemoval(SS.getRange());
10314 SS.clear();
10315 }
John McCall337ec3d2010-10-12 23:13:28 +000010316
10317 // - There's a scope specifier that does not match any template
10318 // parameter lists, in which case we use some arbitrary context,
10319 // create a method or method template, and wait for instantiation.
10320 // - There's a scope specifier that does match some template
10321 // parameter lists, which we don't handle right now.
10322 } else {
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010323 if (D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010324 // C++ [class.friend]p6:
10325 // A function can be defined in a friend declaration of a class if and
10326 // only if the class is a non-local class (9.8), the function name is
10327 // unqualified, and the function has namespace scope.
10328 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
10329 << SS.getScopeRep();
10330 }
10331
John McCall337ec3d2010-10-12 23:13:28 +000010332 DC = CurContext;
10333 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
John McCall67d1a672009-08-06 02:15:43 +000010334 }
Douglas Gregor883af832011-10-10 01:11:59 +000010335
John McCall29ae6e52010-10-13 05:45:15 +000010336 if (!DC->isRecord()) {
John McCall67d1a672009-08-06 02:15:43 +000010337 // This implies that it has to be an operator or function.
Douglas Gregor3f9a0562009-11-03 01:35:08 +000010338 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
10339 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
10340 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall67d1a672009-08-06 02:15:43 +000010341 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor3f9a0562009-11-03 01:35:08 +000010342 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
10343 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCalld226f652010-08-21 09:40:31 +000010344 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010345 }
John McCall67d1a672009-08-06 02:15:43 +000010346 }
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010347
Douglas Gregorfb35e8f2011-11-03 16:37:14 +000010348 // FIXME: This is an egregious hack to cope with cases where the scope stack
10349 // does not contain the declaration context, i.e., in an out-of-line
10350 // definition of a class.
10351 Scope FakeDCScope(S, Scope::DeclScope, Diags);
10352 if (!DCScope) {
10353 FakeDCScope.setEntity(DC);
10354 DCScope = &FakeDCScope;
10355 }
10356
Francois Pichetaf0f4d02011-08-14 03:52:19 +000010357 bool AddToScope = true;
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010358 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +000010359 TemplateParams, AddToScope);
John McCalld226f652010-08-21 09:40:31 +000010360 if (!ND) return 0;
John McCallab88d972009-08-31 22:39:49 +000010361
Douglas Gregor182ddf02009-09-28 00:08:27 +000010362 assert(ND->getDeclContext() == DC);
10363 assert(ND->getLexicalDeclContext() == CurContext);
John McCall88232aa2009-08-18 00:00:49 +000010364
John McCallab88d972009-08-31 22:39:49 +000010365 // Add the function declaration to the appropriate lookup tables,
10366 // adjusting the redeclarations list as necessary. We don't
10367 // want to do this yet if the friending class is dependent.
Mike Stump1eb44332009-09-09 15:08:12 +000010368 //
John McCallab88d972009-08-31 22:39:49 +000010369 // Also update the scope-based lookup if the target context's
10370 // lookup context is in lexical scope.
10371 if (!CurContext->isDependentContext()) {
Sebastian Redl7a126a42010-08-31 00:36:30 +000010372 DC = DC->getRedeclContext();
Richard Smith1b7f9cb2012-03-13 03:12:56 +000010373 DC->makeDeclVisibleInContext(ND);
John McCallab88d972009-08-31 22:39:49 +000010374 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregor182ddf02009-09-28 00:08:27 +000010375 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCallab88d972009-08-31 22:39:49 +000010376 }
John McCall02cace72009-08-28 07:59:38 +000010377
10378 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregor182ddf02009-09-28 00:08:27 +000010379 D.getIdentifierLoc(), ND,
John McCall02cace72009-08-28 07:59:38 +000010380 DS.getFriendSpecLoc());
John McCall5fee1102009-08-29 03:50:18 +000010381 FrD->setAccess(AS_public);
John McCall02cace72009-08-28 07:59:38 +000010382 CurContext->addDecl(FrD);
John McCall67d1a672009-08-06 02:15:43 +000010383
John McCall1f2e1a92012-08-10 03:15:35 +000010384 if (ND->isInvalidDecl()) {
John McCall337ec3d2010-10-12 23:13:28 +000010385 FrD->setInvalidDecl();
John McCall1f2e1a92012-08-10 03:15:35 +000010386 } else {
10387 if (DC->isRecord()) CheckFriendAccess(ND);
10388
John McCall6102ca12010-10-16 06:59:13 +000010389 FunctionDecl *FD;
10390 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
10391 FD = FTD->getTemplatedDecl();
10392 else
10393 FD = cast<FunctionDecl>(ND);
10394
10395 // Mark templated-scope function declarations as unsupported.
10396 if (FD->getNumTemplateParameterLists())
10397 FrD->setUnsupportedFriend(true);
10398 }
John McCall337ec3d2010-10-12 23:13:28 +000010399
John McCalld226f652010-08-21 09:40:31 +000010400 return ND;
Anders Carlsson00338362009-05-11 22:55:49 +000010401}
10402
John McCalld226f652010-08-21 09:40:31 +000010403void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
10404 AdjustDeclIfTemplate(Dcl);
Mike Stump1eb44332009-09-09 15:08:12 +000010405
Sebastian Redl50de12f2009-03-24 22:27:57 +000010406 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
10407 if (!Fn) {
10408 Diag(DelLoc, diag::err_deleted_non_function);
10409 return;
10410 }
Douglas Gregoref96ee02012-01-14 16:38:05 +000010411 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
David Blaikied9cf8262012-06-25 21:55:30 +000010412 // Don't consider the implicit declaration we generate for explicit
10413 // specializations. FIXME: Do not generate these implicit declarations.
David Blaikie619ee6a2012-06-29 18:00:25 +000010414 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization
10415 || Prev->getPreviousDecl()) && !Prev->isDefined()) {
David Blaikied9cf8262012-06-25 21:55:30 +000010416 Diag(DelLoc, diag::err_deleted_decl_not_first);
10417 Diag(Prev->getLocation(), diag::note_previous_declaration);
10418 }
Sebastian Redl50de12f2009-03-24 22:27:57 +000010419 // If the declaration wasn't the first, we delete the function anyway for
10420 // recovery.
10421 }
Sean Hunt10620eb2011-05-06 20:44:56 +000010422 Fn->setDeletedAsWritten();
Richard Smithe653ba22012-02-26 00:31:33 +000010423
10424 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl);
10425 if (!MD)
10426 return;
10427
10428 // A deleted special member function is trivial if the corresponding
10429 // implicitly-declared function would have been.
10430 switch (getSpecialMember(MD)) {
10431 case CXXInvalid:
10432 break;
10433 case CXXDefaultConstructor:
10434 MD->setTrivial(MD->getParent()->hasTrivialDefaultConstructor());
10435 break;
10436 case CXXCopyConstructor:
10437 MD->setTrivial(MD->getParent()->hasTrivialCopyConstructor());
10438 break;
10439 case CXXMoveConstructor:
10440 MD->setTrivial(MD->getParent()->hasTrivialMoveConstructor());
10441 break;
10442 case CXXCopyAssignment:
10443 MD->setTrivial(MD->getParent()->hasTrivialCopyAssignment());
10444 break;
10445 case CXXMoveAssignment:
10446 MD->setTrivial(MD->getParent()->hasTrivialMoveAssignment());
10447 break;
10448 case CXXDestructor:
10449 MD->setTrivial(MD->getParent()->hasTrivialDestructor());
10450 break;
10451 }
Sebastian Redl50de12f2009-03-24 22:27:57 +000010452}
Sebastian Redl13e88542009-04-27 21:33:24 +000010453
Sean Hunte4246a62011-05-12 06:15:49 +000010454void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
10455 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl);
10456
10457 if (MD) {
Sean Hunteb88ae52011-05-23 21:07:59 +000010458 if (MD->getParent()->isDependentType()) {
10459 MD->setDefaulted();
10460 MD->setExplicitlyDefaulted();
10461 return;
10462 }
10463
Sean Hunte4246a62011-05-12 06:15:49 +000010464 CXXSpecialMember Member = getSpecialMember(MD);
10465 if (Member == CXXInvalid) {
10466 Diag(DefaultLoc, diag::err_default_special_members);
10467 return;
10468 }
10469
10470 MD->setDefaulted();
10471 MD->setExplicitlyDefaulted();
10472
Sean Huntcd10dec2011-05-23 23:14:04 +000010473 // If this definition appears within the record, do the checking when
10474 // the record is complete.
10475 const FunctionDecl *Primary = MD;
Richard Smitha8eaf002012-08-23 06:16:52 +000010476 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
Sean Huntcd10dec2011-05-23 23:14:04 +000010477 // Find the uninstantiated declaration that actually had the '= default'
10478 // on it.
Richard Smitha8eaf002012-08-23 06:16:52 +000010479 Pattern->isDefined(Primary);
Sean Huntcd10dec2011-05-23 23:14:04 +000010480
10481 if (Primary == Primary->getCanonicalDecl())
Sean Hunte4246a62011-05-12 06:15:49 +000010482 return;
10483
Richard Smithb9d0b762012-07-27 04:22:15 +000010484 CheckExplicitlyDefaultedSpecialMember(MD);
10485
Sean Hunte4246a62011-05-12 06:15:49 +000010486 switch (Member) {
10487 case CXXDefaultConstructor: {
10488 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010489 if (!CD->isInvalidDecl())
10490 DefineImplicitDefaultConstructor(DefaultLoc, CD);
10491 break;
10492 }
10493
10494 case CXXCopyConstructor: {
10495 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010496 if (!CD->isInvalidDecl())
10497 DefineImplicitCopyConstructor(DefaultLoc, CD);
Sean Hunte4246a62011-05-12 06:15:49 +000010498 break;
10499 }
Sean Huntcb45a0f2011-05-12 22:46:25 +000010500
Sean Hunt2b188082011-05-14 05:23:28 +000010501 case CXXCopyAssignment: {
Sean Hunt2b188082011-05-14 05:23:28 +000010502 if (!MD->isInvalidDecl())
10503 DefineImplicitCopyAssignment(DefaultLoc, MD);
10504 break;
10505 }
10506
Sean Huntcb45a0f2011-05-12 22:46:25 +000010507 case CXXDestructor: {
10508 CXXDestructorDecl *DD = cast<CXXDestructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010509 if (!DD->isInvalidDecl())
10510 DefineImplicitDestructor(DefaultLoc, DD);
Sean Huntcb45a0f2011-05-12 22:46:25 +000010511 break;
10512 }
10513
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010514 case CXXMoveConstructor: {
10515 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010516 if (!CD->isInvalidDecl())
10517 DefineImplicitMoveConstructor(DefaultLoc, CD);
Sean Hunt82713172011-05-25 23:16:36 +000010518 break;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010519 }
Sean Hunt82713172011-05-25 23:16:36 +000010520
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010521 case CXXMoveAssignment: {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010522 if (!MD->isInvalidDecl())
10523 DefineImplicitMoveAssignment(DefaultLoc, MD);
10524 break;
10525 }
10526
10527 case CXXInvalid:
David Blaikieb219cfc2011-09-23 05:06:16 +000010528 llvm_unreachable("Invalid special member.");
Sean Hunte4246a62011-05-12 06:15:49 +000010529 }
10530 } else {
10531 Diag(DefaultLoc, diag::err_default_special_members);
10532 }
10533}
10534
Sebastian Redl13e88542009-04-27 21:33:24 +000010535static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
John McCall7502c1d2011-02-13 04:07:26 +000010536 for (Stmt::child_range CI = S->children(); CI; ++CI) {
Sebastian Redl13e88542009-04-27 21:33:24 +000010537 Stmt *SubStmt = *CI;
10538 if (!SubStmt)
10539 continue;
10540 if (isa<ReturnStmt>(SubStmt))
Daniel Dunbar96a00142012-03-09 18:35:03 +000010541 Self.Diag(SubStmt->getLocStart(),
Sebastian Redl13e88542009-04-27 21:33:24 +000010542 diag::err_return_in_constructor_handler);
10543 if (!isa<Expr>(SubStmt))
10544 SearchForReturnInStmt(Self, SubStmt);
10545 }
10546}
10547
10548void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
10549 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
10550 CXXCatchStmt *Handler = TryBlock->getHandler(I);
10551 SearchForReturnInStmt(*this, Handler);
10552 }
10553}
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010554
Mike Stump1eb44332009-09-09 15:08:12 +000010555bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010556 const CXXMethodDecl *Old) {
John McCall183700f2009-09-21 23:43:11 +000010557 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
10558 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010559
Chandler Carruth73857792010-02-15 11:53:20 +000010560 if (Context.hasSameType(NewTy, OldTy) ||
10561 NewTy->isDependentType() || OldTy->isDependentType())
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010562 return false;
Mike Stump1eb44332009-09-09 15:08:12 +000010563
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010564 // Check if the return types are covariant
10565 QualType NewClassTy, OldClassTy;
Mike Stump1eb44332009-09-09 15:08:12 +000010566
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010567 /// Both types must be pointers or references to classes.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010568 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
10569 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010570 NewClassTy = NewPT->getPointeeType();
10571 OldClassTy = OldPT->getPointeeType();
10572 }
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010573 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
10574 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
10575 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
10576 NewClassTy = NewRT->getPointeeType();
10577 OldClassTy = OldRT->getPointeeType();
10578 }
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010579 }
10580 }
Mike Stump1eb44332009-09-09 15:08:12 +000010581
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010582 // The return types aren't either both pointers or references to a class type.
10583 if (NewClassTy.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +000010584 Diag(New->getLocation(),
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010585 diag::err_different_return_type_for_overriding_virtual_function)
10586 << New->getDeclName() << NewTy << OldTy;
10587 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump1eb44332009-09-09 15:08:12 +000010588
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010589 return true;
10590 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010591
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010592 // C++ [class.virtual]p6:
10593 // If the return type of D::f differs from the return type of B::f, the
10594 // class type in the return type of D::f shall be complete at the point of
10595 // declaration of D::f or shall be the class type D.
Anders Carlssonac4c9392009-12-31 18:54:35 +000010596 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
10597 if (!RT->isBeingDefined() &&
10598 RequireCompleteType(New->getLocation(), NewClassTy,
Douglas Gregord10099e2012-05-04 16:32:21 +000010599 diag::err_covariant_return_incomplete,
10600 New->getDeclName()))
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010601 return true;
Anders Carlssonac4c9392009-12-31 18:54:35 +000010602 }
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010603
Douglas Gregora4923eb2009-11-16 21:35:15 +000010604 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010605 // Check if the new class derives from the old class.
10606 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
10607 Diag(New->getLocation(),
10608 diag::err_covariant_return_not_derived)
10609 << New->getDeclName() << NewTy << OldTy;
10610 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10611 return true;
10612 }
Mike Stump1eb44332009-09-09 15:08:12 +000010613
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010614 // Check if we the conversion from derived to base is valid.
John McCall58e6f342010-03-16 05:22:47 +000010615 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlssone25a96c2010-04-24 17:11:09 +000010616 diag::err_covariant_return_inaccessible_base,
10617 diag::err_covariant_return_ambiguous_derived_to_base_conv,
10618 // FIXME: Should this point to the return type?
10619 New->getLocation(), SourceRange(), New->getDeclName(), 0)) {
John McCalleee1d542011-02-14 07:13:47 +000010620 // FIXME: this note won't trigger for delayed access control
10621 // diagnostics, and it's impossible to get an undelayed error
10622 // here from access control during the original parse because
10623 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010624 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10625 return true;
10626 }
10627 }
Mike Stump1eb44332009-09-09 15:08:12 +000010628
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010629 // The qualifiers of the return types must be the same.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010630 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010631 Diag(New->getLocation(),
10632 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010633 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010634 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10635 return true;
10636 };
Mike Stump1eb44332009-09-09 15:08:12 +000010637
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010638
10639 // The new class type must have the same or less qualifiers as the old type.
10640 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
10641 Diag(New->getLocation(),
10642 diag::err_covariant_return_type_class_type_more_qualified)
10643 << New->getDeclName() << NewTy << OldTy;
10644 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10645 return true;
10646 };
Mike Stump1eb44332009-09-09 15:08:12 +000010647
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010648 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010649}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010650
Douglas Gregor4ba31362009-12-01 17:24:26 +000010651/// \brief Mark the given method pure.
10652///
10653/// \param Method the method to be marked pure.
10654///
10655/// \param InitRange the source range that covers the "0" initializer.
10656bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
Abramo Bagnara796aa442011-03-12 11:17:06 +000010657 SourceLocation EndLoc = InitRange.getEnd();
10658 if (EndLoc.isValid())
10659 Method->setRangeEnd(EndLoc);
10660
Douglas Gregor4ba31362009-12-01 17:24:26 +000010661 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
10662 Method->setPure();
Douglas Gregor4ba31362009-12-01 17:24:26 +000010663 return false;
Abramo Bagnara796aa442011-03-12 11:17:06 +000010664 }
Douglas Gregor4ba31362009-12-01 17:24:26 +000010665
10666 if (!Method->isInvalidDecl())
10667 Diag(Method->getLocation(), diag::err_non_virtual_pure)
10668 << Method->getDeclName() << InitRange;
10669 return true;
10670}
10671
Douglas Gregor552e2992012-02-21 02:22:07 +000010672/// \brief Determine whether the given declaration is a static data member.
10673static bool isStaticDataMember(Decl *D) {
10674 VarDecl *Var = dyn_cast_or_null<VarDecl>(D);
10675 if (!Var)
10676 return false;
10677
10678 return Var->isStaticDataMember();
10679}
John McCall731ad842009-12-19 09:28:58 +000010680/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
10681/// an initializer for the out-of-line declaration 'Dcl'. The scope
10682/// is a fresh scope pushed for just this purpose.
10683///
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010684/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
10685/// static data member of class X, names should be looked up in the scope of
10686/// class X.
John McCalld226f652010-08-21 09:40:31 +000010687void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010688 // If there is no declaration, there was an error parsing it.
Argyrios Kyrtzidisb65abda2011-04-22 18:52:25 +000010689 if (D == 0 || D->isInvalidDecl()) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010690
John McCall731ad842009-12-19 09:28:58 +000010691 // We should only get called for declarations with scope specifiers, like:
10692 // int foo::bar;
10693 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +000010694 EnterDeclaratorContext(S, D->getDeclContext());
Douglas Gregor552e2992012-02-21 02:22:07 +000010695
10696 // If we are parsing the initializer for a static data member, push a
10697 // new expression evaluation context that is associated with this static
10698 // data member.
10699 if (isStaticDataMember(D))
10700 PushExpressionEvaluationContext(PotentiallyEvaluated, D);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010701}
10702
10703/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
John McCalld226f652010-08-21 09:40:31 +000010704/// initializer for the out-of-line declaration 'D'.
10705void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010706 // If there is no declaration, there was an error parsing it.
Argyrios Kyrtzidisb65abda2011-04-22 18:52:25 +000010707 if (D == 0 || D->isInvalidDecl()) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010708
Douglas Gregor552e2992012-02-21 02:22:07 +000010709 if (isStaticDataMember(D))
10710 PopExpressionEvaluationContext();
10711
John McCall731ad842009-12-19 09:28:58 +000010712 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +000010713 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010714}
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010715
10716/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
10717/// C++ if/switch/while/for statement.
10718/// e.g: "if (int x = f()) {...}"
John McCalld226f652010-08-21 09:40:31 +000010719DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010720 // C++ 6.4p2:
10721 // The declarator shall not specify a function or an array.
10722 // The type-specifier-seq shall not contain typedef and shall not declare a
10723 // new class or enumeration.
10724 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
10725 "Parser allowed 'typedef' as storage class of condition decl.");
Argyrios Kyrtzidisdb7abf72011-06-28 03:01:12 +000010726
10727 Decl *Dcl = ActOnDeclarator(S, D);
Douglas Gregor9a30c992011-07-05 16:13:20 +000010728 if (!Dcl)
10729 return true;
10730
Argyrios Kyrtzidisdb7abf72011-06-28 03:01:12 +000010731 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
10732 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010733 << D.getSourceRange();
Douglas Gregor9a30c992011-07-05 16:13:20 +000010734 return true;
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010735 }
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010736
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010737 return Dcl;
10738}
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010739
Douglas Gregordfe65432011-07-28 19:11:31 +000010740void Sema::LoadExternalVTableUses() {
10741 if (!ExternalSource)
10742 return;
10743
10744 SmallVector<ExternalVTableUse, 4> VTables;
10745 ExternalSource->ReadUsedVTables(VTables);
10746 SmallVector<VTableUse, 4> NewUses;
10747 for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
10748 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
10749 = VTablesUsed.find(VTables[I].Record);
10750 // Even if a definition wasn't required before, it may be required now.
10751 if (Pos != VTablesUsed.end()) {
10752 if (!Pos->second && VTables[I].DefinitionRequired)
10753 Pos->second = true;
10754 continue;
10755 }
10756
10757 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
10758 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
10759 }
10760
10761 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
10762}
10763
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010764void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
10765 bool DefinitionRequired) {
10766 // Ignore any vtable uses in unevaluated operands or for classes that do
10767 // not have a vtable.
10768 if (!Class->isDynamicClass() || Class->isDependentContext() ||
10769 CurContext->isDependentContext() ||
Eli Friedman78a54242012-01-21 04:44:06 +000010770 ExprEvalContexts.back().Context == Unevaluated)
Rafael Espindolabbf58bb2010-03-10 02:19:29 +000010771 return;
10772
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010773 // Try to insert this class into the map.
Douglas Gregordfe65432011-07-28 19:11:31 +000010774 LoadExternalVTableUses();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010775 Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
10776 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
10777 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
10778 if (!Pos.second) {
Daniel Dunbarb9aefa72010-05-25 00:33:13 +000010779 // If we already had an entry, check to see if we are promoting this vtable
10780 // to required a definition. If so, we need to reappend to the VTableUses
10781 // list, since we may have already processed the first entry.
10782 if (DefinitionRequired && !Pos.first->second) {
10783 Pos.first->second = true;
10784 } else {
10785 // Otherwise, we can early exit.
10786 return;
10787 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010788 }
10789
10790 // Local classes need to have their virtual members marked
10791 // immediately. For all other classes, we mark their virtual members
10792 // at the end of the translation unit.
10793 if (Class->isLocalClass())
10794 MarkVirtualMembersReferenced(Loc, Class);
Daniel Dunbar380c2132010-05-11 21:32:35 +000010795 else
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010796 VTableUses.push_back(std::make_pair(Class, Loc));
Douglas Gregorbbbe0742010-05-11 20:24:17 +000010797}
10798
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010799bool Sema::DefineUsedVTables() {
Douglas Gregordfe65432011-07-28 19:11:31 +000010800 LoadExternalVTableUses();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010801 if (VTableUses.empty())
Anders Carlssond6a637f2009-12-07 08:24:59 +000010802 return false;
Chandler Carruthaee543a2010-12-12 21:36:11 +000010803
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010804 // Note: The VTableUses vector could grow as a result of marking
10805 // the members of a class as "used", so we check the size each
Richard Smithb9d0b762012-07-27 04:22:15 +000010806 // time through the loop and prefer indices (which are stable) to
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010807 // iterators (which are not).
Douglas Gregor78844032011-04-22 22:25:37 +000010808 bool DefinedAnything = false;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010809 for (unsigned I = 0; I != VTableUses.size(); ++I) {
Daniel Dunbare669f892010-05-25 00:32:58 +000010810 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010811 if (!Class)
10812 continue;
10813
10814 SourceLocation Loc = VTableUses[I].second;
10815
Richard Smithb9d0b762012-07-27 04:22:15 +000010816 bool DefineVTable = true;
10817
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010818 // If this class has a key function, but that key function is
10819 // defined in another translation unit, we don't need to emit the
10820 // vtable even though we're using it.
10821 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(Class);
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +000010822 if (KeyFunction && !KeyFunction->hasBody()) {
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010823 switch (KeyFunction->getTemplateSpecializationKind()) {
10824 case TSK_Undeclared:
10825 case TSK_ExplicitSpecialization:
10826 case TSK_ExplicitInstantiationDeclaration:
10827 // The key function is in another translation unit.
Richard Smithb9d0b762012-07-27 04:22:15 +000010828 DefineVTable = false;
10829 break;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010830
10831 case TSK_ExplicitInstantiationDefinition:
10832 case TSK_ImplicitInstantiation:
10833 // We will be instantiating the key function.
10834 break;
10835 }
10836 } else if (!KeyFunction) {
10837 // If we have a class with no key function that is the subject
10838 // of an explicit instantiation declaration, suppress the
10839 // vtable; it will live with the explicit instantiation
10840 // definition.
10841 bool IsExplicitInstantiationDeclaration
10842 = Class->getTemplateSpecializationKind()
10843 == TSK_ExplicitInstantiationDeclaration;
10844 for (TagDecl::redecl_iterator R = Class->redecls_begin(),
10845 REnd = Class->redecls_end();
10846 R != REnd; ++R) {
10847 TemplateSpecializationKind TSK
10848 = cast<CXXRecordDecl>(*R)->getTemplateSpecializationKind();
10849 if (TSK == TSK_ExplicitInstantiationDeclaration)
10850 IsExplicitInstantiationDeclaration = true;
10851 else if (TSK == TSK_ExplicitInstantiationDefinition) {
10852 IsExplicitInstantiationDeclaration = false;
10853 break;
10854 }
10855 }
10856
10857 if (IsExplicitInstantiationDeclaration)
Richard Smithb9d0b762012-07-27 04:22:15 +000010858 DefineVTable = false;
10859 }
10860
10861 // The exception specifications for all virtual members may be needed even
10862 // if we are not providing an authoritative form of the vtable in this TU.
10863 // We may choose to emit it available_externally anyway.
10864 if (!DefineVTable) {
10865 MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
10866 continue;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010867 }
10868
10869 // Mark all of the virtual members of this class as referenced, so
10870 // that we can build a vtable. Then, tell the AST consumer that a
10871 // vtable for this class is required.
Douglas Gregor78844032011-04-22 22:25:37 +000010872 DefinedAnything = true;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010873 MarkVirtualMembersReferenced(Loc, Class);
10874 CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
10875 Consumer.HandleVTable(Class, VTablesUsed[Canonical]);
10876
10877 // Optionally warn if we're emitting a weak vtable.
10878 if (Class->getLinkage() == ExternalLinkage &&
10879 Class->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
Douglas Gregora120d012011-09-23 19:04:03 +000010880 const FunctionDecl *KeyFunctionDef = 0;
10881 if (!KeyFunction ||
10882 (KeyFunction->hasBody(KeyFunctionDef) &&
10883 KeyFunctionDef->isInlined()))
David Blaikie44d95b52011-12-09 18:32:50 +000010884 Diag(Class->getLocation(), Class->getTemplateSpecializationKind() ==
10885 TSK_ExplicitInstantiationDefinition
10886 ? diag::warn_weak_template_vtable : diag::warn_weak_vtable)
10887 << Class;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010888 }
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010889 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010890 VTableUses.clear();
10891
Douglas Gregor78844032011-04-22 22:25:37 +000010892 return DefinedAnything;
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010893}
Anders Carlssond6a637f2009-12-07 08:24:59 +000010894
Richard Smithb9d0b762012-07-27 04:22:15 +000010895void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
10896 const CXXRecordDecl *RD) {
10897 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
10898 E = RD->method_end(); I != E; ++I)
10899 if ((*I)->isVirtual() && !(*I)->isPure())
10900 ResolveExceptionSpec(Loc, (*I)->getType()->castAs<FunctionProtoType>());
10901}
10902
Rafael Espindola3e1ae932010-03-26 00:36:59 +000010903void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
10904 const CXXRecordDecl *RD) {
Richard Smithff817f72012-07-07 06:59:51 +000010905 // Mark all functions which will appear in RD's vtable as used.
10906 CXXFinalOverriderMap FinalOverriders;
10907 RD->getFinalOverriders(FinalOverriders);
10908 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
10909 E = FinalOverriders.end();
10910 I != E; ++I) {
10911 for (OverridingMethods::const_iterator OI = I->second.begin(),
10912 OE = I->second.end();
10913 OI != OE; ++OI) {
10914 assert(OI->second.size() > 0 && "no final overrider");
10915 CXXMethodDecl *Overrider = OI->second.front().Method;
Anders Carlssond6a637f2009-12-07 08:24:59 +000010916
Richard Smithff817f72012-07-07 06:59:51 +000010917 // C++ [basic.def.odr]p2:
10918 // [...] A virtual member function is used if it is not pure. [...]
10919 if (!Overrider->isPure())
10920 MarkFunctionReferenced(Loc, Overrider);
10921 }
Anders Carlssond6a637f2009-12-07 08:24:59 +000010922 }
Rafael Espindola3e1ae932010-03-26 00:36:59 +000010923
10924 // Only classes that have virtual bases need a VTT.
10925 if (RD->getNumVBases() == 0)
10926 return;
10927
10928 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
10929 e = RD->bases_end(); i != e; ++i) {
10930 const CXXRecordDecl *Base =
10931 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Rafael Espindola3e1ae932010-03-26 00:36:59 +000010932 if (Base->getNumVBases() == 0)
10933 continue;
10934 MarkVirtualMembersReferenced(Loc, Base);
10935 }
Anders Carlssond6a637f2009-12-07 08:24:59 +000010936}
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010937
10938/// SetIvarInitializers - This routine builds initialization ASTs for the
10939/// Objective-C implementation whose ivars need be initialized.
10940void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {
David Blaikie4e4d0842012-03-11 07:00:24 +000010941 if (!getLangOpts().CPlusPlus)
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010942 return;
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +000010943 if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +000010944 SmallVector<ObjCIvarDecl*, 8> ivars;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010945 CollectIvarsToConstructOrDestruct(OID, ivars);
10946 if (ivars.empty())
10947 return;
Chris Lattner5f9e2722011-07-23 10:55:15 +000010948 SmallVector<CXXCtorInitializer*, 32> AllToInit;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010949 for (unsigned i = 0; i < ivars.size(); i++) {
10950 FieldDecl *Field = ivars[i];
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000010951 if (Field->isInvalidDecl())
10952 continue;
10953
Sean Huntcbb67482011-01-08 20:30:50 +000010954 CXXCtorInitializer *Member;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010955 InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field);
10956 InitializationKind InitKind =
10957 InitializationKind::CreateDefault(ObjCImplementation->getLocation());
10958
10959 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
John McCall60d7b3a2010-08-24 06:29:42 +000010960 ExprResult MemberInit =
John McCallf312b1e2010-08-26 23:41:50 +000010961 InitSeq.Perform(*this, InitEntity, InitKind, MultiExprArg());
Douglas Gregor53c374f2010-12-07 00:41:46 +000010962 MemberInit = MaybeCreateExprWithCleanups(MemberInit);
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010963 // Note, MemberInit could actually come back empty if no initialization
10964 // is required (e.g., because it would call a trivial default constructor)
10965 if (!MemberInit.get() || MemberInit.isInvalid())
10966 continue;
John McCallb4eb64d2010-10-08 02:01:28 +000010967
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010968 Member =
Sean Huntcbb67482011-01-08 20:30:50 +000010969 new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
10970 SourceLocation(),
10971 MemberInit.takeAs<Expr>(),
10972 SourceLocation());
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010973 AllToInit.push_back(Member);
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000010974
10975 // Be sure that the destructor is accessible and is marked as referenced.
10976 if (const RecordType *RecordTy
10977 = Context.getBaseElementType(Field->getType())
10978 ->getAs<RecordType>()) {
10979 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
Douglas Gregordb89f282010-07-01 22:47:18 +000010980 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
Eli Friedman5f2987c2012-02-02 03:46:19 +000010981 MarkFunctionReferenced(Field->getLocation(), Destructor);
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000010982 CheckDestructorAccess(Field->getLocation(), Destructor,
10983 PDiag(diag::err_access_dtor_ivar)
10984 << Context.getBaseElementType(Field->getType()));
10985 }
10986 }
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000010987 }
10988 ObjCImplementation->setIvarInitializers(Context,
10989 AllToInit.data(), AllToInit.size());
10990 }
10991}
Sean Huntfe57eef2011-05-04 05:57:24 +000010992
Sean Huntebcbe1d2011-05-04 23:29:54 +000010993static
10994void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
10995 llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
10996 llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
10997 llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
10998 Sema &S) {
10999 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(),
11000 CE = Current.end();
11001 if (Ctor->isInvalidDecl())
11002 return;
11003
Richard Smitha8eaf002012-08-23 06:16:52 +000011004 CXXConstructorDecl *Target = Ctor->getTargetConstructor();
11005
11006 // Target may not be determinable yet, for instance if this is a dependent
11007 // call in an uninstantiated template.
11008 if (Target) {
11009 const FunctionDecl *FNTarget = 0;
11010 (void)Target->hasBody(FNTarget);
11011 Target = const_cast<CXXConstructorDecl*>(
11012 cast_or_null<CXXConstructorDecl>(FNTarget));
11013 }
Sean Huntebcbe1d2011-05-04 23:29:54 +000011014
11015 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
11016 // Avoid dereferencing a null pointer here.
11017 *TCanonical = Target ? Target->getCanonicalDecl() : 0;
11018
11019 if (!Current.insert(Canonical))
11020 return;
11021
11022 // We know that beyond here, we aren't chaining into a cycle.
11023 if (!Target || !Target->isDelegatingConstructor() ||
11024 Target->isInvalidDecl() || Valid.count(TCanonical)) {
11025 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI)
11026 Valid.insert(*CI);
11027 Current.clear();
11028 // We've hit a cycle.
11029 } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
11030 Current.count(TCanonical)) {
11031 // If we haven't diagnosed this cycle yet, do so now.
11032 if (!Invalid.count(TCanonical)) {
11033 S.Diag((*Ctor->init_begin())->getSourceLocation(),
Sean Huntc1598702011-05-05 00:05:47 +000011034 diag::warn_delegating_ctor_cycle)
Sean Huntebcbe1d2011-05-04 23:29:54 +000011035 << Ctor;
11036
Richard Smitha8eaf002012-08-23 06:16:52 +000011037 // Don't add a note for a function delegating directly to itself.
Sean Huntebcbe1d2011-05-04 23:29:54 +000011038 if (TCanonical != Canonical)
11039 S.Diag(Target->getLocation(), diag::note_it_delegates_to);
11040
11041 CXXConstructorDecl *C = Target;
11042 while (C->getCanonicalDecl() != Canonical) {
Richard Smitha8eaf002012-08-23 06:16:52 +000011043 const FunctionDecl *FNTarget = 0;
Sean Huntebcbe1d2011-05-04 23:29:54 +000011044 (void)C->getTargetConstructor()->hasBody(FNTarget);
11045 assert(FNTarget && "Ctor cycle through bodiless function");
11046
Richard Smitha8eaf002012-08-23 06:16:52 +000011047 C = const_cast<CXXConstructorDecl*>(
11048 cast<CXXConstructorDecl>(FNTarget));
Sean Huntebcbe1d2011-05-04 23:29:54 +000011049 S.Diag(C->getLocation(), diag::note_which_delegates_to);
11050 }
11051 }
11052
11053 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI)
11054 Invalid.insert(*CI);
11055 Current.clear();
11056 } else {
11057 DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
11058 }
11059}
11060
11061
Sean Huntfe57eef2011-05-04 05:57:24 +000011062void Sema::CheckDelegatingCtorCycles() {
11063 llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
11064
Sean Huntebcbe1d2011-05-04 23:29:54 +000011065 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(),
11066 CE = Current.end();
Sean Huntfe57eef2011-05-04 05:57:24 +000011067
Douglas Gregor0129b562011-07-27 21:57:17 +000011068 for (DelegatingCtorDeclsType::iterator
11069 I = DelegatingCtorDecls.begin(ExternalSource),
Sean Huntebcbe1d2011-05-04 23:29:54 +000011070 E = DelegatingCtorDecls.end();
Richard Smitha8eaf002012-08-23 06:16:52 +000011071 I != E; ++I)
11072 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
Sean Huntebcbe1d2011-05-04 23:29:54 +000011073
11074 for (CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
11075 (*CI)->setInvalidDecl();
Sean Huntfe57eef2011-05-04 05:57:24 +000011076}
Peter Collingbourne78dd67e2011-10-02 23:49:40 +000011077
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011078namespace {
11079 /// \brief AST visitor that finds references to the 'this' expression.
11080 class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
11081 Sema &S;
11082
11083 public:
11084 explicit FindCXXThisExpr(Sema &S) : S(S) { }
11085
11086 bool VisitCXXThisExpr(CXXThisExpr *E) {
11087 S.Diag(E->getLocation(), diag::err_this_static_member_func)
11088 << E->isImplicit();
11089 return false;
11090 }
11091 };
11092}
11093
11094bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
11095 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
11096 if (!TSInfo)
11097 return false;
11098
11099 TypeLoc TL = TSInfo->getTypeLoc();
11100 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL);
11101 if (!ProtoTL)
11102 return false;
11103
11104 // C++11 [expr.prim.general]p3:
11105 // [The expression this] shall not appear before the optional
11106 // cv-qualifier-seq and it shall not appear within the declaration of a
11107 // static member function (although its type and value category are defined
11108 // within a static member function as they are within a non-static member
11109 // function). [ Note: this is because declaration matching does not occur
NAKAMURA Takumic86d1fd2012-04-21 09:40:04 +000011110 // until the complete declarator is known. - end note ]
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011111 const FunctionProtoType *Proto = ProtoTL->getTypePtr();
11112 FindCXXThisExpr Finder(*this);
11113
11114 // If the return type came after the cv-qualifier-seq, check it now.
11115 if (Proto->hasTrailingReturn() &&
11116 !Finder.TraverseTypeLoc(ProtoTL->getResultLoc()))
11117 return true;
11118
11119 // Check the exception specification.
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011120 if (checkThisInStaticMemberFunctionExceptionSpec(Method))
11121 return true;
11122
11123 return checkThisInStaticMemberFunctionAttributes(Method);
11124}
11125
11126bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
11127 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
11128 if (!TSInfo)
11129 return false;
11130
11131 TypeLoc TL = TSInfo->getTypeLoc();
11132 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL);
11133 if (!ProtoTL)
11134 return false;
11135
11136 const FunctionProtoType *Proto = ProtoTL->getTypePtr();
11137 FindCXXThisExpr Finder(*this);
11138
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011139 switch (Proto->getExceptionSpecType()) {
Richard Smithe6975e92012-04-17 00:58:00 +000011140 case EST_Uninstantiated:
Richard Smithb9d0b762012-07-27 04:22:15 +000011141 case EST_Unevaluated:
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011142 case EST_BasicNoexcept:
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011143 case EST_DynamicNone:
11144 case EST_MSAny:
11145 case EST_None:
11146 break;
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011147
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011148 case EST_ComputedNoexcept:
11149 if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
11150 return true;
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011151
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011152 case EST_Dynamic:
11153 for (FunctionProtoType::exception_iterator E = Proto->exception_begin(),
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011154 EEnd = Proto->exception_end();
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011155 E != EEnd; ++E) {
11156 if (!Finder.TraverseType(*E))
11157 return true;
11158 }
11159 break;
11160 }
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011161
11162 return false;
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011163}
11164
11165bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
11166 FindCXXThisExpr Finder(*this);
11167
11168 // Check attributes.
11169 for (Decl::attr_iterator A = Method->attr_begin(), AEnd = Method->attr_end();
11170 A != AEnd; ++A) {
11171 // FIXME: This should be emitted by tblgen.
11172 Expr *Arg = 0;
11173 ArrayRef<Expr *> Args;
11174 if (GuardedByAttr *G = dyn_cast<GuardedByAttr>(*A))
11175 Arg = G->getArg();
11176 else if (PtGuardedByAttr *G = dyn_cast<PtGuardedByAttr>(*A))
11177 Arg = G->getArg();
11178 else if (AcquiredAfterAttr *AA = dyn_cast<AcquiredAfterAttr>(*A))
11179 Args = ArrayRef<Expr *>(AA->args_begin(), AA->args_size());
11180 else if (AcquiredBeforeAttr *AB = dyn_cast<AcquiredBeforeAttr>(*A))
11181 Args = ArrayRef<Expr *>(AB->args_begin(), AB->args_size());
11182 else if (ExclusiveLockFunctionAttr *ELF
11183 = dyn_cast<ExclusiveLockFunctionAttr>(*A))
11184 Args = ArrayRef<Expr *>(ELF->args_begin(), ELF->args_size());
11185 else if (SharedLockFunctionAttr *SLF
11186 = dyn_cast<SharedLockFunctionAttr>(*A))
11187 Args = ArrayRef<Expr *>(SLF->args_begin(), SLF->args_size());
11188 else if (ExclusiveTrylockFunctionAttr *ETLF
11189 = dyn_cast<ExclusiveTrylockFunctionAttr>(*A)) {
11190 Arg = ETLF->getSuccessValue();
11191 Args = ArrayRef<Expr *>(ETLF->args_begin(), ETLF->args_size());
11192 } else if (SharedTrylockFunctionAttr *STLF
11193 = dyn_cast<SharedTrylockFunctionAttr>(*A)) {
11194 Arg = STLF->getSuccessValue();
11195 Args = ArrayRef<Expr *>(STLF->args_begin(), STLF->args_size());
11196 } else if (UnlockFunctionAttr *UF = dyn_cast<UnlockFunctionAttr>(*A))
11197 Args = ArrayRef<Expr *>(UF->args_begin(), UF->args_size());
11198 else if (LockReturnedAttr *LR = dyn_cast<LockReturnedAttr>(*A))
11199 Arg = LR->getArg();
11200 else if (LocksExcludedAttr *LE = dyn_cast<LocksExcludedAttr>(*A))
11201 Args = ArrayRef<Expr *>(LE->args_begin(), LE->args_size());
11202 else if (ExclusiveLocksRequiredAttr *ELR
11203 = dyn_cast<ExclusiveLocksRequiredAttr>(*A))
11204 Args = ArrayRef<Expr *>(ELR->args_begin(), ELR->args_size());
11205 else if (SharedLocksRequiredAttr *SLR
11206 = dyn_cast<SharedLocksRequiredAttr>(*A))
11207 Args = ArrayRef<Expr *>(SLR->args_begin(), SLR->args_size());
11208
11209 if (Arg && !Finder.TraverseStmt(Arg))
11210 return true;
11211
11212 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
11213 if (!Finder.TraverseStmt(Args[I]))
11214 return true;
11215 }
11216 }
11217
11218 return false;
11219}
11220
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011221void
11222Sema::checkExceptionSpecification(ExceptionSpecificationType EST,
11223 ArrayRef<ParsedType> DynamicExceptions,
11224 ArrayRef<SourceRange> DynamicExceptionRanges,
11225 Expr *NoexceptExpr,
11226 llvm::SmallVectorImpl<QualType> &Exceptions,
11227 FunctionProtoType::ExtProtoInfo &EPI) {
11228 Exceptions.clear();
11229 EPI.ExceptionSpecType = EST;
11230 if (EST == EST_Dynamic) {
11231 Exceptions.reserve(DynamicExceptions.size());
11232 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
11233 // FIXME: Preserve type source info.
11234 QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
11235
11236 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11237 collectUnexpandedParameterPacks(ET, Unexpanded);
11238 if (!Unexpanded.empty()) {
11239 DiagnoseUnexpandedParameterPacks(DynamicExceptionRanges[ei].getBegin(),
11240 UPPC_ExceptionType,
11241 Unexpanded);
11242 continue;
11243 }
11244
11245 // Check that the type is valid for an exception spec, and
11246 // drop it if not.
11247 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
11248 Exceptions.push_back(ET);
11249 }
11250 EPI.NumExceptions = Exceptions.size();
11251 EPI.Exceptions = Exceptions.data();
11252 return;
11253 }
11254
11255 if (EST == EST_ComputedNoexcept) {
11256 // If an error occurred, there's no expression here.
11257 if (NoexceptExpr) {
11258 assert((NoexceptExpr->isTypeDependent() ||
11259 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
11260 Context.BoolTy) &&
11261 "Parser should have made sure that the expression is boolean");
11262 if (NoexceptExpr && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
11263 EPI.ExceptionSpecType = EST_BasicNoexcept;
11264 return;
11265 }
11266
11267 if (!NoexceptExpr->isValueDependent())
11268 NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, 0,
Douglas Gregorab41fe92012-05-04 22:38:52 +000011269 diag::err_noexcept_needs_constant_expression,
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011270 /*AllowFold*/ false).take();
11271 EPI.NoexceptExpr = NoexceptExpr;
11272 }
11273 return;
11274 }
11275}
11276
Peter Collingbourne78dd67e2011-10-02 23:49:40 +000011277/// IdentifyCUDATarget - Determine the CUDA compilation target for this function
11278Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D) {
11279 // Implicitly declared functions (e.g. copy constructors) are
11280 // __host__ __device__
11281 if (D->isImplicit())
11282 return CFT_HostDevice;
11283
11284 if (D->hasAttr<CUDAGlobalAttr>())
11285 return CFT_Global;
11286
11287 if (D->hasAttr<CUDADeviceAttr>()) {
11288 if (D->hasAttr<CUDAHostAttr>())
11289 return CFT_HostDevice;
11290 else
11291 return CFT_Device;
11292 }
11293
11294 return CFT_Host;
11295}
11296
11297bool Sema::CheckCUDATarget(CUDAFunctionTarget CallerTarget,
11298 CUDAFunctionTarget CalleeTarget) {
11299 // CUDA B.1.1 "The __device__ qualifier declares a function that is...
11300 // Callable from the device only."
11301 if (CallerTarget == CFT_Host && CalleeTarget == CFT_Device)
11302 return true;
11303
11304 // CUDA B.1.2 "The __global__ qualifier declares a function that is...
11305 // Callable from the host only."
11306 // CUDA B.1.3 "The __host__ qualifier declares a function that is...
11307 // Callable from the host only."
11308 if ((CallerTarget == CFT_Device || CallerTarget == CFT_Global) &&
11309 (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global))
11310 return true;
11311
11312 if (CallerTarget == CFT_HostDevice && CalleeTarget != CFT_HostDevice)
11313 return true;
11314
11315 return false;
11316}