blob: 8d891a37e73b587eae5855f4d6b96a2016c4261c [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];
John McCalle402e722012-09-25 07:32:39 +00001181 if (const RecordType *Record = NewBaseType->getAs<RecordType>()) {
1182 const CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
1183 if (Class->isInterface() &&
1184 (!RD->isInterface() ||
1185 KnownBase->getAccessSpecifier() != AS_public)) {
1186 // The Microsoft extension __interface does not permit bases that
1187 // are not themselves public interfaces.
1188 Diag(KnownBase->getLocStart(), diag::err_invalid_base_in_interface)
1189 << getRecordDiagFromTagKind(RD->getTagKind()) << RD->getName()
1190 << RD->getSourceRange();
1191 Invalid = true;
1192 }
1193 if (RD->hasAttr<WeakAttr>())
1194 Class->addAttr(::new (Context) WeakAttr(SourceRange(), Context));
1195 }
Douglas Gregorf8268ae2008-10-22 17:49:05 +00001196 }
1197 }
1198
1199 // Attach the remaining base class specifiers to the derived class.
Douglas Gregor2d5b7032010-02-11 01:30:34 +00001200 Class->setBases(Bases, NumGoodBases);
Douglas Gregor57c856b2008-10-23 18:13:27 +00001201
1202 // Delete the remaining (good) base class specifiers, since their
1203 // data has been copied into the CXXRecordDecl.
1204 for (unsigned idx = 0; idx < NumGoodBases; ++idx)
Douglas Gregor2aef06d2009-07-22 20:55:49 +00001205 Context.Deallocate(Bases[idx]);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001206
1207 return Invalid;
1208}
1209
1210/// ActOnBaseSpecifiers - Attach the given base specifiers to the
1211/// class, after checking whether there are any duplicate base
1212/// classes.
Richard Trieu90ab75b2011-09-09 03:18:59 +00001213void Sema::ActOnBaseSpecifiers(Decl *ClassDecl, CXXBaseSpecifier **Bases,
Douglas Gregor2943aed2009-03-03 04:44:36 +00001214 unsigned NumBases) {
1215 if (!ClassDecl || !Bases || !NumBases)
1216 return;
1217
1218 AdjustDeclIfTemplate(ClassDecl);
John McCalld226f652010-08-21 09:40:31 +00001219 AttachBaseSpecifiers(cast<CXXRecordDecl>(ClassDecl),
Douglas Gregor2943aed2009-03-03 04:44:36 +00001220 (CXXBaseSpecifier**)(Bases), NumBases);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001221}
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001222
John McCall3cb0ebd2010-03-10 03:28:59 +00001223static CXXRecordDecl *GetClassForType(QualType T) {
1224 if (const RecordType *RT = T->getAs<RecordType>())
1225 return cast<CXXRecordDecl>(RT->getDecl());
1226 else if (const InjectedClassNameType *ICT = T->getAs<InjectedClassNameType>())
1227 return ICT->getDecl();
1228 else
1229 return 0;
1230}
1231
Douglas Gregora8f32e02009-10-06 17:59:45 +00001232/// \brief Determine whether the type \p Derived is a C++ class that is
1233/// derived from the type \p Base.
1234bool Sema::IsDerivedFrom(QualType Derived, QualType Base) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001235 if (!getLangOpts().CPlusPlus)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001236 return false;
John McCall3cb0ebd2010-03-10 03:28:59 +00001237
1238 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
1239 if (!DerivedRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001240 return false;
1241
John McCall3cb0ebd2010-03-10 03:28:59 +00001242 CXXRecordDecl *BaseRD = GetClassForType(Base);
1243 if (!BaseRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001244 return false;
1245
John McCall86ff3082010-02-04 22:26:26 +00001246 // FIXME: instantiate DerivedRD if necessary. We need a PoI for this.
1247 return DerivedRD->hasDefinition() && DerivedRD->isDerivedFrom(BaseRD);
Douglas Gregora8f32e02009-10-06 17:59:45 +00001248}
1249
1250/// \brief Determine whether the type \p Derived is a C++ class that is
1251/// derived from the type \p Base.
1252bool Sema::IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths) {
David Blaikie4e4d0842012-03-11 07:00:24 +00001253 if (!getLangOpts().CPlusPlus)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001254 return false;
1255
John McCall3cb0ebd2010-03-10 03:28:59 +00001256 CXXRecordDecl *DerivedRD = GetClassForType(Derived);
1257 if (!DerivedRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001258 return false;
1259
John McCall3cb0ebd2010-03-10 03:28:59 +00001260 CXXRecordDecl *BaseRD = GetClassForType(Base);
1261 if (!BaseRD)
Douglas Gregora8f32e02009-10-06 17:59:45 +00001262 return false;
1263
Douglas Gregora8f32e02009-10-06 17:59:45 +00001264 return DerivedRD->isDerivedFrom(BaseRD, Paths);
1265}
1266
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001267void Sema::BuildBasePathArray(const CXXBasePaths &Paths,
John McCallf871d0c2010-08-07 06:22:56 +00001268 CXXCastPath &BasePathArray) {
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001269 assert(BasePathArray.empty() && "Base path array must be empty!");
1270 assert(Paths.isRecordingPaths() && "Must record paths!");
1271
1272 const CXXBasePath &Path = Paths.front();
1273
1274 // We first go backward and check if we have a virtual base.
1275 // FIXME: It would be better if CXXBasePath had the base specifier for
1276 // the nearest virtual base.
1277 unsigned Start = 0;
1278 for (unsigned I = Path.size(); I != 0; --I) {
1279 if (Path[I - 1].Base->isVirtual()) {
1280 Start = I - 1;
1281 break;
1282 }
1283 }
1284
1285 // Now add all bases.
1286 for (unsigned I = Start, E = Path.size(); I != E; ++I)
John McCallf871d0c2010-08-07 06:22:56 +00001287 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001288}
1289
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001290/// \brief Determine whether the given base path includes a virtual
1291/// base class.
John McCallf871d0c2010-08-07 06:22:56 +00001292bool Sema::BasePathInvolvesVirtualBase(const CXXCastPath &BasePath) {
1293 for (CXXCastPath::const_iterator B = BasePath.begin(),
1294 BEnd = BasePath.end();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001295 B != BEnd; ++B)
1296 if ((*B)->isVirtual())
1297 return true;
1298
1299 return false;
1300}
1301
Douglas Gregora8f32e02009-10-06 17:59:45 +00001302/// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
1303/// conversion (where Derived and Base are class types) is
1304/// well-formed, meaning that the conversion is unambiguous (and
1305/// that all of the base classes are accessible). Returns true
1306/// and emits a diagnostic if the code is ill-formed, returns false
1307/// otherwise. Loc is the location where this routine should point to
1308/// if there is an error, and Range is the source range to highlight
1309/// if there is an error.
1310bool
1311Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
John McCall58e6f342010-03-16 05:22:47 +00001312 unsigned InaccessibleBaseID,
Douglas Gregora8f32e02009-10-06 17:59:45 +00001313 unsigned AmbigiousBaseConvID,
1314 SourceLocation Loc, SourceRange Range,
Anders Carlssone25a96c2010-04-24 17:11:09 +00001315 DeclarationName Name,
John McCallf871d0c2010-08-07 06:22:56 +00001316 CXXCastPath *BasePath) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001317 // First, determine whether the path from Derived to Base is
1318 // ambiguous. This is slightly more expensive than checking whether
1319 // the Derived to Base conversion exists, because here we need to
1320 // explore multiple paths to determine if there is an ambiguity.
1321 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1322 /*DetectVirtual=*/false);
1323 bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
1324 assert(DerivationOkay &&
1325 "Can only be used with a derived-to-base conversion");
1326 (void)DerivationOkay;
1327
1328 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType())) {
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001329 if (InaccessibleBaseID) {
1330 // Check that the base class can be accessed.
1331 switch (CheckBaseClassAccess(Loc, Base, Derived, Paths.front(),
1332 InaccessibleBaseID)) {
1333 case AR_inaccessible:
1334 return true;
1335 case AR_accessible:
1336 case AR_dependent:
1337 case AR_delayed:
1338 break;
Anders Carlssone25a96c2010-04-24 17:11:09 +00001339 }
John McCall6b2accb2010-02-10 09:31:12 +00001340 }
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00001341
1342 // Build a base path if necessary.
1343 if (BasePath)
1344 BuildBasePathArray(Paths, *BasePath);
1345 return false;
Douglas Gregora8f32e02009-10-06 17:59:45 +00001346 }
1347
1348 // We know that the derived-to-base conversion is ambiguous, and
1349 // we're going to produce a diagnostic. Perform the derived-to-base
1350 // search just one more time to compute all of the possible paths so
1351 // that we can print them out. This is more expensive than any of
1352 // the previous derived-to-base checks we've done, but at this point
1353 // performance isn't as much of an issue.
1354 Paths.clear();
1355 Paths.setRecordingPaths(true);
1356 bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
1357 assert(StillOkay && "Can only be used with a derived-to-base conversion");
1358 (void)StillOkay;
1359
1360 // Build up a textual representation of the ambiguous paths, e.g.,
1361 // D -> B -> A, that will be used to illustrate the ambiguous
1362 // conversions in the diagnostic. We only print one of the paths
1363 // to each base class subobject.
1364 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
1365
1366 Diag(Loc, AmbigiousBaseConvID)
1367 << Derived << Base << PathDisplayStr << Range << Name;
1368 return true;
1369}
1370
1371bool
1372Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001373 SourceLocation Loc, SourceRange Range,
John McCallf871d0c2010-08-07 06:22:56 +00001374 CXXCastPath *BasePath,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00001375 bool IgnoreAccess) {
Douglas Gregora8f32e02009-10-06 17:59:45 +00001376 return CheckDerivedToBaseConversion(Derived, Base,
John McCall58e6f342010-03-16 05:22:47 +00001377 IgnoreAccess ? 0
1378 : diag::err_upcast_to_inaccessible_base,
Douglas Gregora8f32e02009-10-06 17:59:45 +00001379 diag::err_ambiguous_derived_to_base_conv,
Anders Carlssone25a96c2010-04-24 17:11:09 +00001380 Loc, Range, DeclarationName(),
1381 BasePath);
Douglas Gregora8f32e02009-10-06 17:59:45 +00001382}
1383
1384
1385/// @brief Builds a string representing ambiguous paths from a
1386/// specific derived class to different subobjects of the same base
1387/// class.
1388///
1389/// This function builds a string that can be used in error messages
1390/// to show the different paths that one can take through the
1391/// inheritance hierarchy to go from the derived class to different
1392/// subobjects of a base class. The result looks something like this:
1393/// @code
1394/// struct D -> struct B -> struct A
1395/// struct D -> struct C -> struct A
1396/// @endcode
1397std::string Sema::getAmbiguousPathsDisplayString(CXXBasePaths &Paths) {
1398 std::string PathDisplayStr;
1399 std::set<unsigned> DisplayedPaths;
1400 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1401 Path != Paths.end(); ++Path) {
1402 if (DisplayedPaths.insert(Path->back().SubobjectNumber).second) {
1403 // We haven't displayed a path to this particular base
1404 // class subobject yet.
1405 PathDisplayStr += "\n ";
1406 PathDisplayStr += Context.getTypeDeclType(Paths.getOrigin()).getAsString();
1407 for (CXXBasePath::const_iterator Element = Path->begin();
1408 Element != Path->end(); ++Element)
1409 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
1410 }
1411 }
1412
1413 return PathDisplayStr;
1414}
1415
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001416//===----------------------------------------------------------------------===//
1417// C++ class member Handling
1418//===----------------------------------------------------------------------===//
1419
Abramo Bagnara6206d532010-06-05 05:09:32 +00001420/// ActOnAccessSpecifier - Parsed an access specifier followed by a colon.
Erik Verbruggen5f1c8222011-10-13 09:41:32 +00001421bool Sema::ActOnAccessSpecifier(AccessSpecifier Access,
1422 SourceLocation ASLoc,
1423 SourceLocation ColonLoc,
1424 AttributeList *Attrs) {
Abramo Bagnara6206d532010-06-05 05:09:32 +00001425 assert(Access != AS_none && "Invalid kind for syntactic access specifier!");
John McCalld226f652010-08-21 09:40:31 +00001426 AccessSpecDecl *ASDecl = AccessSpecDecl::Create(Context, Access, CurContext,
Abramo Bagnara6206d532010-06-05 05:09:32 +00001427 ASLoc, ColonLoc);
1428 CurContext->addHiddenDecl(ASDecl);
Erik Verbruggen5f1c8222011-10-13 09:41:32 +00001429 return ProcessAccessDeclAttributeList(ASDecl, Attrs);
Abramo Bagnara6206d532010-06-05 05:09:32 +00001430}
1431
Richard Smitha4b39652012-08-06 03:25:17 +00001432/// CheckOverrideControl - Check C++11 override control semantics.
1433void Sema::CheckOverrideControl(Decl *D) {
Richard Smithcddbc1d2012-09-06 18:32:18 +00001434 if (D->isInvalidDecl())
1435 return;
1436
Chris Lattner5f9e2722011-07-23 10:55:15 +00001437 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D);
Anders Carlsson9e682d92011-01-20 05:57:14 +00001438
Richard Smitha4b39652012-08-06 03:25:17 +00001439 // Do we know which functions this declaration might be overriding?
1440 bool OverridesAreKnown = !MD ||
1441 (!MD->getParent()->hasAnyDependentBases() &&
1442 !MD->getType()->isDependentType());
Anders Carlsson3ffe1832011-01-20 06:33:26 +00001443
Richard Smitha4b39652012-08-06 03:25:17 +00001444 if (!MD || !MD->isVirtual()) {
1445 if (OverridesAreKnown) {
1446 if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {
1447 Diag(OA->getLocation(),
1448 diag::override_keyword_only_allowed_on_virtual_member_functions)
1449 << "override" << FixItHint::CreateRemoval(OA->getLocation());
1450 D->dropAttr<OverrideAttr>();
1451 }
1452 if (FinalAttr *FA = D->getAttr<FinalAttr>()) {
1453 Diag(FA->getLocation(),
1454 diag::override_keyword_only_allowed_on_virtual_member_functions)
1455 << "final" << FixItHint::CreateRemoval(FA->getLocation());
1456 D->dropAttr<FinalAttr>();
1457 }
1458 }
Anders Carlsson9e682d92011-01-20 05:57:14 +00001459 return;
1460 }
Richard Smitha4b39652012-08-06 03:25:17 +00001461
1462 if (!OverridesAreKnown)
1463 return;
1464
1465 // C++11 [class.virtual]p5:
1466 // If a virtual function is marked with the virt-specifier override and
1467 // does not override a member function of a base class, the program is
1468 // ill-formed.
1469 bool HasOverriddenMethods =
1470 MD->begin_overridden_methods() != MD->end_overridden_methods();
1471 if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)
1472 Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding)
1473 << MD->getDeclName();
Anders Carlsson9e682d92011-01-20 05:57:14 +00001474}
1475
Richard Smitha4b39652012-08-06 03:25:17 +00001476/// CheckIfOverriddenFunctionIsMarkedFinal - Checks whether a virtual member
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001477/// function overrides a virtual member function marked 'final', according to
Richard Smitha4b39652012-08-06 03:25:17 +00001478/// C++11 [class.virtual]p4.
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001479bool Sema::CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
1480 const CXXMethodDecl *Old) {
Anders Carlssoncb88a1f2011-01-24 16:26:15 +00001481 if (!Old->hasAttr<FinalAttr>())
Anders Carlssonf89e0422011-01-23 21:07:30 +00001482 return false;
1483
1484 Diag(New->getLocation(), diag::err_final_function_overridden)
1485 << New->getDeclName();
1486 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
1487 return true;
Anders Carlsson2e1c7302011-01-20 16:25:36 +00001488}
1489
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001490static bool InitializationHasSideEffects(const FieldDecl &FD) {
Richard Smith0b8220a2012-08-07 21:30:42 +00001491 const Type *T = FD.getType()->getBaseElementTypeUnsafe();
1492 // FIXME: Destruction of ObjC lifetime types has side-effects.
1493 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1494 return !RD->isCompleteDefinition() ||
1495 !RD->hasTrivialDefaultConstructor() ||
1496 !RD->hasTrivialDestructor();
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001497 return false;
1498}
1499
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001500/// ActOnCXXMemberDeclarator - This is invoked when a C++ class member
1501/// declarator is parsed. 'AS' is the access specifier, 'BW' specifies the
Richard Smith7a614d82011-06-11 17:19:42 +00001502/// bitfield width if there is one, 'InitExpr' specifies the initializer if
Richard Smithca523302012-06-10 03:12:00 +00001503/// one has been parsed, and 'InitStyle' is set if an in-class initializer is
1504/// present (but parsing it has been deferred).
John McCalld226f652010-08-21 09:40:31 +00001505Decl *
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001506Sema::ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +00001507 MultiTemplateParamsArg TemplateParameterLists,
Richard Trieuf81e5a92011-09-09 02:00:50 +00001508 Expr *BW, const VirtSpecifiers &VS,
Richard Smithca523302012-06-10 03:12:00 +00001509 InClassInitStyle InitStyle) {
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001510 const DeclSpec &DS = D.getDeclSpec();
Abramo Bagnara25777432010-08-11 22:01:17 +00001511 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
1512 DeclarationName Name = NameInfo.getName();
1513 SourceLocation Loc = NameInfo.getLoc();
Douglas Gregor90ba6d52010-11-09 03:31:16 +00001514
1515 // For anonymous bitfields, the location should point to the type.
1516 if (Loc.isInvalid())
Daniel Dunbar96a00142012-03-09 18:35:03 +00001517 Loc = D.getLocStart();
Douglas Gregor90ba6d52010-11-09 03:31:16 +00001518
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001519 Expr *BitWidth = static_cast<Expr*>(BW);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001520
John McCall4bde1e12010-06-04 08:34:12 +00001521 assert(isa<CXXRecordDecl>(CurContext));
John McCall67d1a672009-08-06 02:15:43 +00001522 assert(!DS.isFriendSpecified());
1523
Richard Smith1ab0d902011-06-25 02:28:38 +00001524 bool isFunc = D.isDeclarationOfFunction();
John McCall4bde1e12010-06-04 08:34:12 +00001525
John McCalle402e722012-09-25 07:32:39 +00001526 if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
1527 // The Microsoft extension __interface only permits public member functions
1528 // and prohibits constructors, destructors, operators, non-public member
1529 // functions, static methods and data members.
1530 unsigned InvalidDecl;
1531 bool ShowDeclName = true;
1532 if (!isFunc)
1533 InvalidDecl = (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) ? 0 : 1;
1534 else if (AS != AS_public)
1535 InvalidDecl = 2;
1536 else if (DS.getStorageClassSpec() == DeclSpec::SCS_static)
1537 InvalidDecl = 3;
1538 else switch (Name.getNameKind()) {
1539 case DeclarationName::CXXConstructorName:
1540 InvalidDecl = 4;
1541 ShowDeclName = false;
1542 break;
1543
1544 case DeclarationName::CXXDestructorName:
1545 InvalidDecl = 5;
1546 ShowDeclName = false;
1547 break;
1548
1549 case DeclarationName::CXXOperatorName:
1550 case DeclarationName::CXXConversionFunctionName:
1551 InvalidDecl = 6;
1552 break;
1553
1554 default:
1555 InvalidDecl = 0;
1556 break;
1557 }
1558
1559 if (InvalidDecl) {
1560 if (ShowDeclName)
1561 Diag(Loc, diag::err_invalid_member_in_interface)
1562 << (InvalidDecl-1) << Name;
1563 else
1564 Diag(Loc, diag::err_invalid_member_in_interface)
1565 << (InvalidDecl-1) << "";
1566 return 0;
1567 }
1568 }
1569
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001570 // C++ 9.2p6: A member shall not be declared to have automatic storage
1571 // duration (auto, register) or with the extern storage-class-specifier.
Sebastian Redl669d5d72008-11-14 23:42:31 +00001572 // C++ 7.1.1p8: The mutable specifier can be applied only to names of class
1573 // data members and cannot be applied to names declared const or static,
1574 // and cannot be applied to reference members.
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001575 switch (DS.getStorageClassSpec()) {
1576 case DeclSpec::SCS_unspecified:
1577 case DeclSpec::SCS_typedef:
1578 case DeclSpec::SCS_static:
1579 // FALL THROUGH.
1580 break;
Sebastian Redl669d5d72008-11-14 23:42:31 +00001581 case DeclSpec::SCS_mutable:
1582 if (isFunc) {
1583 if (DS.getStorageClassSpecLoc().isValid())
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001584 Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_function);
Sebastian Redl669d5d72008-11-14 23:42:31 +00001585 else
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001586 Diag(DS.getThreadSpecLoc(), diag::err_mutable_function);
Mike Stump1eb44332009-09-09 15:08:12 +00001587
Sebastian Redla11f42f2008-11-17 23:24:37 +00001588 // FIXME: It would be nicer if the keyword was ignored only for this
1589 // declarator. Otherwise we could get follow-up errors.
Sebastian Redl669d5d72008-11-14 23:42:31 +00001590 D.getMutableDeclSpec().ClearStorageClassSpecs();
Sebastian Redl669d5d72008-11-14 23:42:31 +00001591 }
1592 break;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001593 default:
1594 if (DS.getStorageClassSpecLoc().isValid())
1595 Diag(DS.getStorageClassSpecLoc(),
1596 diag::err_storageclass_invalid_for_member);
1597 else
1598 Diag(DS.getThreadSpecLoc(), diag::err_storageclass_invalid_for_member);
1599 D.getMutableDeclSpec().ClearStorageClassSpecs();
1600 }
1601
Sebastian Redl669d5d72008-11-14 23:42:31 +00001602 bool isInstField = ((DS.getStorageClassSpec() == DeclSpec::SCS_unspecified ||
1603 DS.getStorageClassSpec() == DeclSpec::SCS_mutable) &&
Argyrios Kyrtzidisde933f02008-10-08 22:20:31 +00001604 !isFunc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001605
1606 Decl *Member;
Chris Lattner24793662009-03-05 22:45:59 +00001607 if (isInstField) {
Douglas Gregor922fff22010-10-13 22:19:53 +00001608 CXXScopeSpec &SS = D.getCXXScopeSpec();
Douglas Gregorb5a01872011-10-09 18:55:59 +00001609
1610 // Data members must have identifiers for names.
Benjamin Kramerc1aa40c2012-05-19 16:34:46 +00001611 if (!Name.isIdentifier()) {
Douglas Gregorb5a01872011-10-09 18:55:59 +00001612 Diag(Loc, diag::err_bad_variable_name)
1613 << Name;
1614 return 0;
1615 }
Douglas Gregorf2503652011-09-21 14:40:46 +00001616
Benjamin Kramerc1aa40c2012-05-19 16:34:46 +00001617 IdentifierInfo *II = Name.getAsIdentifierInfo();
1618
Douglas Gregorf2503652011-09-21 14:40:46 +00001619 // Member field could not be with "template" keyword.
1620 // So TemplateParameterLists should be empty in this case.
1621 if (TemplateParameterLists.size()) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001622 TemplateParameterList* TemplateParams = TemplateParameterLists[0];
Douglas Gregorf2503652011-09-21 14:40:46 +00001623 if (TemplateParams->size()) {
1624 // There is no such thing as a member field template.
1625 Diag(D.getIdentifierLoc(), diag::err_template_member)
1626 << II
1627 << SourceRange(TemplateParams->getTemplateLoc(),
1628 TemplateParams->getRAngleLoc());
1629 } else {
1630 // There is an extraneous 'template<>' for this member.
1631 Diag(TemplateParams->getTemplateLoc(),
1632 diag::err_template_member_noparams)
1633 << II
1634 << SourceRange(TemplateParams->getTemplateLoc(),
1635 TemplateParams->getRAngleLoc());
1636 }
1637 return 0;
1638 }
1639
Douglas Gregor922fff22010-10-13 22:19:53 +00001640 if (SS.isSet() && !SS.isInvalid()) {
1641 // The user provided a superfluous scope specifier inside a class
1642 // definition:
1643 //
1644 // class X {
1645 // int X::member;
1646 // };
Douglas Gregor69605872012-03-28 16:01:27 +00001647 if (DeclContext *DC = computeDeclContext(SS, false))
1648 diagnoseQualifiedDeclaration(SS, DC, Name, D.getIdentifierLoc());
Douglas Gregor922fff22010-10-13 22:19:53 +00001649 else
1650 Diag(D.getIdentifierLoc(), diag::err_member_qualification)
1651 << Name << SS.getRange();
Douglas Gregor5d8419c2011-11-01 22:13:30 +00001652
Douglas Gregor922fff22010-10-13 22:19:53 +00001653 SS.clear();
1654 }
Douglas Gregorf2503652011-09-21 14:40:46 +00001655
Douglas Gregor4dd55f52009-03-11 20:50:30 +00001656 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D, BitWidth,
Richard Smithca523302012-06-10 03:12:00 +00001657 InitStyle, AS);
Chris Lattner6f8ce142009-03-05 23:03:49 +00001658 assert(Member && "HandleField never returns null");
Chris Lattner24793662009-03-05 22:45:59 +00001659 } else {
Richard Smithca523302012-06-10 03:12:00 +00001660 assert(InitStyle == ICIS_NoInit);
Richard Smith7a614d82011-06-11 17:19:42 +00001661
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00001662 Member = HandleDeclarator(S, D, TemplateParameterLists);
Chris Lattner6f8ce142009-03-05 23:03:49 +00001663 if (!Member) {
John McCalld226f652010-08-21 09:40:31 +00001664 return 0;
Chris Lattner6f8ce142009-03-05 23:03:49 +00001665 }
Chris Lattner8b963ef2009-03-05 23:01:03 +00001666
1667 // Non-instance-fields can't have a bitfield.
1668 if (BitWidth) {
1669 if (Member->isInvalidDecl()) {
1670 // don't emit another diagnostic.
Douglas Gregor2d2e9cf2009-03-11 20:22:50 +00001671 } else if (isa<VarDecl>(Member)) {
Chris Lattner8b963ef2009-03-05 23:01:03 +00001672 // C++ 9.6p3: A bit-field shall not be a static member.
1673 // "static member 'A' cannot be a bit-field"
1674 Diag(Loc, diag::err_static_not_bitfield)
1675 << Name << BitWidth->getSourceRange();
1676 } else if (isa<TypedefDecl>(Member)) {
1677 // "typedef member 'x' cannot be a bit-field"
1678 Diag(Loc, diag::err_typedef_not_bitfield)
1679 << Name << BitWidth->getSourceRange();
1680 } else {
1681 // A function typedef ("typedef int f(); f a;").
1682 // C++ 9.6p3: A bit-field shall have integral or enumeration type.
1683 Diag(Loc, diag::err_not_integral_type_bitfield)
Mike Stump1eb44332009-09-09 15:08:12 +00001684 << Name << cast<ValueDecl>(Member)->getType()
Douglas Gregor3cf538d2009-03-11 18:59:21 +00001685 << BitWidth->getSourceRange();
Chris Lattner8b963ef2009-03-05 23:01:03 +00001686 }
Mike Stump1eb44332009-09-09 15:08:12 +00001687
Chris Lattner8b963ef2009-03-05 23:01:03 +00001688 BitWidth = 0;
1689 Member->setInvalidDecl();
1690 }
Douglas Gregor4dd55f52009-03-11 20:50:30 +00001691
1692 Member->setAccess(AS);
Mike Stump1eb44332009-09-09 15:08:12 +00001693
Douglas Gregor37b372b2009-08-20 22:52:58 +00001694 // If we have declared a member function template, set the access of the
1695 // templated declaration as well.
1696 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Member))
1697 FunTmpl->getTemplatedDecl()->setAccess(AS);
Chris Lattner24793662009-03-05 22:45:59 +00001698 }
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001699
Richard Smitha4b39652012-08-06 03:25:17 +00001700 if (VS.isOverrideSpecified())
1701 Member->addAttr(new (Context) OverrideAttr(VS.getOverrideLoc(), Context));
1702 if (VS.isFinalSpecified())
1703 Member->addAttr(new (Context) FinalAttr(VS.getFinalLoc(), Context));
Anders Carlsson9e682d92011-01-20 05:57:14 +00001704
Douglas Gregorf5251602011-03-08 17:10:18 +00001705 if (VS.getLastLocation().isValid()) {
1706 // Update the end location of a method that has a virt-specifiers.
1707 if (CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(Member))
1708 MD->setRangeEnd(VS.getLastLocation());
1709 }
Richard Smitha4b39652012-08-06 03:25:17 +00001710
Anders Carlsson4ebf1602011-01-20 06:29:02 +00001711 CheckOverrideControl(Member);
Anders Carlsson9e682d92011-01-20 05:57:14 +00001712
Douglas Gregor10bd3682008-11-17 22:58:34 +00001713 assert((Name || isInstField) && "No identifier for non-field ?");
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001714
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001715 if (isInstField) {
1716 FieldDecl *FD = cast<FieldDecl>(Member);
1717 FieldCollector->Add(FD);
1718
1719 if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
1720 FD->getLocation())
1721 != DiagnosticsEngine::Ignored) {
1722 // Remember all explicit private FieldDecls that have a name, no side
1723 // effects and are not part of a dependent type declaration.
1724 if (!FD->isImplicit() && FD->getDeclName() &&
1725 FD->getAccess() == AS_private &&
Daniel Jasper568eae42012-06-13 18:31:09 +00001726 !FD->hasAttr<UnusedAttr>() &&
Richard Smith0b8220a2012-08-07 21:30:42 +00001727 !FD->getParent()->isDependentContext() &&
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00001728 !InitializationHasSideEffects(*FD))
1729 UnusedPrivateFields.insert(FD);
1730 }
1731 }
1732
John McCalld226f652010-08-21 09:40:31 +00001733 return Member;
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001734}
1735
Hans Wennborg471f9852012-09-18 15:58:06 +00001736namespace {
1737 class UninitializedFieldVisitor
1738 : public EvaluatedExprVisitor<UninitializedFieldVisitor> {
1739 Sema &S;
1740 ValueDecl *VD;
1741 public:
1742 typedef EvaluatedExprVisitor<UninitializedFieldVisitor> Inherited;
1743 UninitializedFieldVisitor(Sema &S, ValueDecl *VD) : Inherited(S.Context),
1744 S(S), VD(VD) {
1745 }
1746
1747 void HandleExpr(Expr *E) {
1748 if (!E) return;
1749
1750 // Expressions like x(x) sometimes lack the surrounding expressions
1751 // but need to be checked anyways.
1752 HandleValue(E);
1753 Visit(E);
1754 }
1755
1756 void HandleValue(Expr *E) {
1757 E = E->IgnoreParens();
1758
1759 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1760 if (isa<EnumConstantDecl>(ME->getMemberDecl()))
1761 return;
1762 Expr *Base = E;
1763 while (isa<MemberExpr>(Base)) {
1764 ME = dyn_cast<MemberExpr>(Base);
1765 if (VarDecl *VarD = dyn_cast<VarDecl>(ME->getMemberDecl()))
1766 if (VarD->hasGlobalStorage())
1767 return;
1768 Base = ME->getBase();
1769 }
1770
1771 if (VD == ME->getMemberDecl() && isa<CXXThisExpr>(Base)) {
1772 unsigned diag = VD->getType()->isReferenceType()
1773 ? diag::warn_reference_field_is_uninit
1774 : diag::warn_field_is_uninit;
Hans Wennborg7821e072012-09-21 08:58:33 +00001775 S.Diag(ME->getExprLoc(), diag) << ME->getMemberNameInfo().getName();
Hans Wennborg471f9852012-09-18 15:58:06 +00001776 return;
1777 }
1778 }
1779
1780 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1781 HandleValue(CO->getTrueExpr());
1782 HandleValue(CO->getFalseExpr());
1783 return;
1784 }
1785
1786 if (BinaryConditionalOperator *BCO =
1787 dyn_cast<BinaryConditionalOperator>(E)) {
1788 HandleValue(BCO->getCommon());
1789 HandleValue(BCO->getFalseExpr());
1790 return;
1791 }
1792
1793 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
1794 switch (BO->getOpcode()) {
1795 default:
1796 return;
1797 case(BO_PtrMemD):
1798 case(BO_PtrMemI):
1799 HandleValue(BO->getLHS());
1800 return;
1801 case(BO_Comma):
1802 HandleValue(BO->getRHS());
1803 return;
1804 }
1805 }
1806 }
1807
1808 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
1809 if (E->getCastKind() == CK_LValueToRValue)
1810 HandleValue(E->getSubExpr());
1811
1812 Inherited::VisitImplicitCastExpr(E);
1813 }
1814
1815 void VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1816 Expr *Callee = E->getCallee();
1817 if (isa<MemberExpr>(Callee))
1818 HandleValue(Callee);
1819
1820 Inherited::VisitCXXMemberCallExpr(E);
1821 }
1822 };
1823 static void CheckInitExprContainsUninitializedFields(Sema &S, Expr *E,
1824 ValueDecl *VD) {
1825 UninitializedFieldVisitor(S, VD).HandleExpr(E);
1826 }
1827} // namespace
1828
Richard Smith7a614d82011-06-11 17:19:42 +00001829/// ActOnCXXInClassMemberInitializer - This is invoked after parsing an
Richard Smith0ff6f8f2011-07-20 00:12:52 +00001830/// in-class initializer for a non-static C++ class member, and after
1831/// instantiating an in-class initializer in a class template. Such actions
1832/// are deferred until the class is complete.
Richard Smith7a614d82011-06-11 17:19:42 +00001833void
Richard Smithca523302012-06-10 03:12:00 +00001834Sema::ActOnCXXInClassMemberInitializer(Decl *D, SourceLocation InitLoc,
Richard Smith7a614d82011-06-11 17:19:42 +00001835 Expr *InitExpr) {
1836 FieldDecl *FD = cast<FieldDecl>(D);
Richard Smithca523302012-06-10 03:12:00 +00001837 assert(FD->getInClassInitStyle() != ICIS_NoInit &&
1838 "must set init style when field is created");
Richard Smith7a614d82011-06-11 17:19:42 +00001839
1840 if (!InitExpr) {
1841 FD->setInvalidDecl();
1842 FD->removeInClassInitializer();
1843 return;
1844 }
1845
Peter Collingbournefef21892011-10-23 18:59:44 +00001846 if (DiagnoseUnexpandedParameterPack(InitExpr, UPPC_Initializer)) {
1847 FD->setInvalidDecl();
1848 FD->removeInClassInitializer();
1849 return;
1850 }
1851
Hans Wennborg471f9852012-09-18 15:58:06 +00001852 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, InitLoc)
1853 != DiagnosticsEngine::Ignored) {
1854 CheckInitExprContainsUninitializedFields(*this, InitExpr, FD);
1855 }
1856
Richard Smith7a614d82011-06-11 17:19:42 +00001857 ExprResult Init = InitExpr;
Douglas Gregordd084272012-09-14 04:20:37 +00001858 if (!FD->getType()->isDependentType() && !InitExpr->isTypeDependent() &&
1859 !FD->getDeclContext()->isDependentContext()) {
1860 // Note: We don't type-check when we're in a dependent context, because
1861 // the initialization-substitution code does not properly handle direct
1862 // list initialization. We have the same hackaround for ctor-initializers.
Sebastian Redl772291a2012-02-19 16:31:05 +00001863 if (isa<InitListExpr>(InitExpr) && isStdInitializerList(FD->getType(), 0)) {
Sebastian Redl33deb352012-02-22 10:50:08 +00001864 Diag(FD->getLocation(), diag::warn_dangling_std_initializer_list)
Sebastian Redl772291a2012-02-19 16:31:05 +00001865 << /*at end of ctor*/1 << InitExpr->getSourceRange();
1866 }
Sebastian Redl33deb352012-02-22 10:50:08 +00001867 Expr **Inits = &InitExpr;
1868 unsigned NumInits = 1;
1869 InitializedEntity Entity = InitializedEntity::InitializeMember(FD);
Richard Smithca523302012-06-10 03:12:00 +00001870 InitializationKind Kind = FD->getInClassInitStyle() == ICIS_ListInit
Sebastian Redl33deb352012-02-22 10:50:08 +00001871 ? InitializationKind::CreateDirectList(InitExpr->getLocStart())
Richard Smithca523302012-06-10 03:12:00 +00001872 : InitializationKind::CreateCopy(InitExpr->getLocStart(), InitLoc);
Sebastian Redl33deb352012-02-22 10:50:08 +00001873 InitializationSequence Seq(*this, Entity, Kind, Inits, NumInits);
1874 Init = Seq.Perform(*this, Entity, Kind, MultiExprArg(Inits, NumInits));
Richard Smith7a614d82011-06-11 17:19:42 +00001875 if (Init.isInvalid()) {
1876 FD->setInvalidDecl();
1877 return;
1878 }
1879
Richard Smithca523302012-06-10 03:12:00 +00001880 CheckImplicitConversions(Init.get(), InitLoc);
Richard Smith7a614d82011-06-11 17:19:42 +00001881 }
1882
1883 // C++0x [class.base.init]p7:
1884 // The initialization of each base and member constitutes a
1885 // full-expression.
1886 Init = MaybeCreateExprWithCleanups(Init);
1887 if (Init.isInvalid()) {
1888 FD->setInvalidDecl();
1889 return;
1890 }
1891
1892 InitExpr = Init.release();
1893
1894 FD->setInClassInitializer(InitExpr);
1895}
1896
Douglas Gregorfe0241e2009-12-31 09:10:24 +00001897/// \brief Find the direct and/or virtual base specifiers that
1898/// correspond to the given base type, for use in base initialization
1899/// within a constructor.
1900static bool FindBaseInitializer(Sema &SemaRef,
1901 CXXRecordDecl *ClassDecl,
1902 QualType BaseType,
1903 const CXXBaseSpecifier *&DirectBaseSpec,
1904 const CXXBaseSpecifier *&VirtualBaseSpec) {
1905 // First, check for a direct base class.
1906 DirectBaseSpec = 0;
1907 for (CXXRecordDecl::base_class_const_iterator Base
1908 = ClassDecl->bases_begin();
1909 Base != ClassDecl->bases_end(); ++Base) {
1910 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base->getType())) {
1911 // We found a direct base of this type. That's what we're
1912 // initializing.
1913 DirectBaseSpec = &*Base;
1914 break;
1915 }
1916 }
1917
1918 // Check for a virtual base class.
1919 // FIXME: We might be able to short-circuit this if we know in advance that
1920 // there are no virtual bases.
1921 VirtualBaseSpec = 0;
1922 if (!DirectBaseSpec || !DirectBaseSpec->isVirtual()) {
1923 // We haven't found a base yet; search the class hierarchy for a
1924 // virtual base class.
1925 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1926 /*DetectVirtual=*/false);
1927 if (SemaRef.IsDerivedFrom(SemaRef.Context.getTypeDeclType(ClassDecl),
1928 BaseType, Paths)) {
1929 for (CXXBasePaths::paths_iterator Path = Paths.begin();
1930 Path != Paths.end(); ++Path) {
1931 if (Path->back().Base->isVirtual()) {
1932 VirtualBaseSpec = Path->back().Base;
1933 break;
1934 }
1935 }
1936 }
1937 }
1938
1939 return DirectBaseSpec || VirtualBaseSpec;
1940}
1941
Sebastian Redl6df65482011-09-24 17:48:25 +00001942/// \brief Handle a C++ member initializer using braced-init-list syntax.
1943MemInitResult
1944Sema::ActOnMemInitializer(Decl *ConstructorD,
1945 Scope *S,
1946 CXXScopeSpec &SS,
1947 IdentifierInfo *MemberOrBase,
1948 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00001949 const DeclSpec &DS,
Sebastian Redl6df65482011-09-24 17:48:25 +00001950 SourceLocation IdLoc,
1951 Expr *InitList,
1952 SourceLocation EllipsisLoc) {
1953 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001954 DS, IdLoc, InitList,
David Blaikief2116622012-01-24 06:03:59 +00001955 EllipsisLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001956}
1957
1958/// \brief Handle a C++ member initializer using parentheses syntax.
John McCallf312b1e2010-08-26 23:41:50 +00001959MemInitResult
John McCalld226f652010-08-21 09:40:31 +00001960Sema::ActOnMemInitializer(Decl *ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001961 Scope *S,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00001962 CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001963 IdentifierInfo *MemberOrBase,
John McCallb3d87482010-08-24 05:47:05 +00001964 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00001965 const DeclSpec &DS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001966 SourceLocation IdLoc,
1967 SourceLocation LParenLoc,
Richard Trieuf81e5a92011-09-09 02:00:50 +00001968 Expr **Args, unsigned NumArgs,
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00001969 SourceLocation RParenLoc,
1970 SourceLocation EllipsisLoc) {
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001971 Expr *List = new (Context) ParenListExpr(Context, LParenLoc,
1972 llvm::makeArrayRef(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001973 RParenLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001974 return BuildMemInitializer(ConstructorD, S, SS, MemberOrBase, TemplateTypeTy,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00001975 DS, IdLoc, List, EllipsisLoc);
Sebastian Redl6df65482011-09-24 17:48:25 +00001976}
1977
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00001978namespace {
1979
Kaelyn Uhraindc98cd02012-01-11 21:17:51 +00001980// Callback to only accept typo corrections that can be a valid C++ member
1981// intializer: either a non-static field member or a base class.
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00001982class MemInitializerValidatorCCC : public CorrectionCandidateCallback {
1983 public:
1984 explicit MemInitializerValidatorCCC(CXXRecordDecl *ClassDecl)
1985 : ClassDecl(ClassDecl) {}
1986
1987 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1988 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
1989 if (FieldDecl *Member = dyn_cast<FieldDecl>(ND))
1990 return Member->getDeclContext()->getRedeclContext()->Equals(ClassDecl);
1991 else
1992 return isa<TypeDecl>(ND);
1993 }
1994 return false;
1995 }
1996
1997 private:
1998 CXXRecordDecl *ClassDecl;
1999};
2000
2001}
2002
Sebastian Redl6df65482011-09-24 17:48:25 +00002003/// \brief Handle a C++ member initializer.
2004MemInitResult
2005Sema::BuildMemInitializer(Decl *ConstructorD,
2006 Scope *S,
2007 CXXScopeSpec &SS,
2008 IdentifierInfo *MemberOrBase,
2009 ParsedType TemplateTypeTy,
David Blaikief2116622012-01-24 06:03:59 +00002010 const DeclSpec &DS,
Sebastian Redl6df65482011-09-24 17:48:25 +00002011 SourceLocation IdLoc,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002012 Expr *Init,
Sebastian Redl6df65482011-09-24 17:48:25 +00002013 SourceLocation EllipsisLoc) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00002014 if (!ConstructorD)
2015 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00002016
Douglas Gregorefd5bda2009-08-24 11:57:43 +00002017 AdjustDeclIfTemplate(ConstructorD);
Mike Stump1eb44332009-09-09 15:08:12 +00002018
2019 CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00002020 = dyn_cast<CXXConstructorDecl>(ConstructorD);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002021 if (!Constructor) {
2022 // The user wrote a constructor initializer on a function that is
2023 // not a C++ constructor. Ignore the error for now, because we may
2024 // have more member initializers coming; we'll diagnose it just
2025 // once in ActOnMemInitializers.
2026 return true;
2027 }
2028
2029 CXXRecordDecl *ClassDecl = Constructor->getParent();
2030
2031 // C++ [class.base.init]p2:
2032 // Names in a mem-initializer-id are looked up in the scope of the
Nick Lewycky7663f392010-11-20 01:29:55 +00002033 // constructor's class and, if not found in that scope, are looked
2034 // up in the scope containing the constructor's definition.
2035 // [Note: if the constructor's class contains a member with the
2036 // same name as a direct or virtual base class of the class, a
2037 // mem-initializer-id naming the member or base class and composed
2038 // of a single identifier refers to the class member. A
Douglas Gregor7ad83902008-11-05 04:29:56 +00002039 // mem-initializer-id for the hidden base class may be specified
2040 // using a qualified name. ]
Fariborz Jahanian96174332009-07-01 19:21:19 +00002041 if (!SS.getScopeRep() && !TemplateTypeTy) {
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002042 // Look for a member, first.
Mike Stump1eb44332009-09-09 15:08:12 +00002043 DeclContext::lookup_result Result
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002044 = ClassDecl->lookup(MemberOrBase);
Francois Pichet87c2e122010-11-21 06:08:52 +00002045 if (Result.first != Result.second) {
Peter Collingbournedc69be22011-10-23 18:59:37 +00002046 ValueDecl *Member;
2047 if ((Member = dyn_cast<FieldDecl>(*Result.first)) ||
2048 (Member = dyn_cast<IndirectFieldDecl>(*Result.first))) {
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002049 if (EllipsisLoc.isValid())
2050 Diag(EllipsisLoc, diag::err_pack_expansion_member_init)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002051 << MemberOrBase
2052 << SourceRange(IdLoc, Init->getSourceRange().getEnd());
Sebastian Redl6df65482011-09-24 17:48:25 +00002053
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002054 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002055 }
Francois Pichet00eb3f92010-12-04 09:14:42 +00002056 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00002057 }
Douglas Gregor7ad83902008-11-05 04:29:56 +00002058 // It didn't name a member, so see if it names a class.
Douglas Gregor802ab452009-12-02 22:36:29 +00002059 QualType BaseType;
John McCalla93c9342009-12-07 02:54:59 +00002060 TypeSourceInfo *TInfo = 0;
John McCall2b194412009-12-21 10:41:20 +00002061
2062 if (TemplateTypeTy) {
John McCalla93c9342009-12-07 02:54:59 +00002063 BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
David Blaikief2116622012-01-24 06:03:59 +00002064 } else if (DS.getTypeSpecType() == TST_decltype) {
2065 BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
John McCall2b194412009-12-21 10:41:20 +00002066 } else {
2067 LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
2068 LookupParsedName(R, S, &SS);
2069
2070 TypeDecl *TyD = R.getAsSingle<TypeDecl>();
2071 if (!TyD) {
2072 if (R.isAmbiguous()) return true;
2073
John McCallfd225442010-04-09 19:01:14 +00002074 // We don't want access-control diagnostics here.
2075 R.suppressDiagnostics();
2076
Douglas Gregor7a886e12010-01-19 06:46:48 +00002077 if (SS.isSet() && isDependentScopeSpecifier(SS)) {
2078 bool NotUnknownSpecialization = false;
2079 DeclContext *DC = computeDeclContext(SS, false);
2080 if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(DC))
2081 NotUnknownSpecialization = !Record->hasAnyDependentBases();
2082
2083 if (!NotUnknownSpecialization) {
2084 // When the scope specifier can refer to a member of an unknown
2085 // specialization, we take it as a type name.
Douglas Gregore29425b2011-02-28 22:42:13 +00002086 BaseType = CheckTypenameType(ETK_None, SourceLocation(),
2087 SS.getWithLocInContext(Context),
2088 *MemberOrBase, IdLoc);
Douglas Gregora50ce322010-03-07 23:26:22 +00002089 if (BaseType.isNull())
2090 return true;
2091
Douglas Gregor7a886e12010-01-19 06:46:48 +00002092 R.clear();
Douglas Gregor12eb5d62010-06-29 19:27:42 +00002093 R.setLookupName(MemberOrBase);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002094 }
2095 }
2096
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002097 // If no results were found, try to correct typos.
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002098 TypoCorrection Corr;
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00002099 MemInitializerValidatorCCC Validator(ClassDecl);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002100 if (R.empty() && BaseType.isNull() &&
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002101 (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00002102 Validator, ClassDecl))) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002103 std::string CorrectedStr(Corr.getAsString(getLangOpts()));
2104 std::string CorrectedQuotedStr(Corr.getQuoted(getLangOpts()));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002105 if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00002106 // We have found a non-static data member with a similar
2107 // name to what was typed; complain and initialize that
2108 // member.
2109 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
2110 << MemberOrBase << true << CorrectedQuotedStr
2111 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr);
2112 Diag(Member->getLocation(), diag::note_previous_decl)
2113 << CorrectedQuotedStr;
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002114
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002115 return BuildMemberInitializer(Member, Init, IdLoc);
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002116 } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002117 const CXXBaseSpecifier *DirectBaseSpec;
2118 const CXXBaseSpecifier *VirtualBaseSpec;
2119 if (FindBaseInitializer(*this, ClassDecl,
2120 Context.getTypeDeclType(Type),
2121 DirectBaseSpec, VirtualBaseSpec)) {
2122 // We have found a direct or virtual base class with a
2123 // similar name to what was typed; complain and initialize
2124 // that base class.
2125 Diag(R.getNameLoc(), diag::err_mem_init_not_member_or_class_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +00002126 << MemberOrBase << false << CorrectedQuotedStr
2127 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr);
Douglas Gregor0d535c82010-01-07 00:26:25 +00002128
2129 const CXXBaseSpecifier *BaseSpec = DirectBaseSpec? DirectBaseSpec
2130 : VirtualBaseSpec;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002131 Diag(BaseSpec->getLocStart(),
Douglas Gregor0d535c82010-01-07 00:26:25 +00002132 diag::note_base_class_specified_here)
2133 << BaseSpec->getType()
2134 << BaseSpec->getSourceRange();
2135
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002136 TyD = Type;
2137 }
2138 }
2139 }
2140
Douglas Gregor7a886e12010-01-19 06:46:48 +00002141 if (!TyD && BaseType.isNull()) {
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002142 Diag(IdLoc, diag::err_mem_init_not_member_or_class)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002143 << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
Douglas Gregorfe0241e2009-12-31 09:10:24 +00002144 return true;
2145 }
John McCall2b194412009-12-21 10:41:20 +00002146 }
2147
Douglas Gregor7a886e12010-01-19 06:46:48 +00002148 if (BaseType.isNull()) {
2149 BaseType = Context.getTypeDeclType(TyD);
2150 if (SS.isSet()) {
2151 NestedNameSpecifier *Qualifier =
2152 static_cast<NestedNameSpecifier*>(SS.getScopeRep());
John McCall2b194412009-12-21 10:41:20 +00002153
Douglas Gregor7a886e12010-01-19 06:46:48 +00002154 // FIXME: preserve source range information
Abramo Bagnara465d41b2010-05-11 21:36:43 +00002155 BaseType = Context.getElaboratedType(ETK_None, Qualifier, BaseType);
Douglas Gregor7a886e12010-01-19 06:46:48 +00002156 }
John McCall2b194412009-12-21 10:41:20 +00002157 }
2158 }
Mike Stump1eb44332009-09-09 15:08:12 +00002159
John McCalla93c9342009-12-07 02:54:59 +00002160 if (!TInfo)
2161 TInfo = Context.getTrivialTypeSourceInfo(BaseType, IdLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002162
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002163 return BuildBaseInitializer(BaseType, TInfo, Init, ClassDecl, EllipsisLoc);
Eli Friedman59c04372009-07-29 19:44:27 +00002164}
2165
Chandler Carruth81c64772011-09-03 01:14:15 +00002166/// Checks a member initializer expression for cases where reference (or
2167/// pointer) members are bound to by-value parameters (or their addresses).
Chandler Carruth81c64772011-09-03 01:14:15 +00002168static void CheckForDanglingReferenceOrPointer(Sema &S, ValueDecl *Member,
2169 Expr *Init,
2170 SourceLocation IdLoc) {
2171 QualType MemberTy = Member->getType();
2172
2173 // We only handle pointers and references currently.
2174 // FIXME: Would this be relevant for ObjC object pointers? Or block pointers?
2175 if (!MemberTy->isReferenceType() && !MemberTy->isPointerType())
2176 return;
2177
2178 const bool IsPointer = MemberTy->isPointerType();
2179 if (IsPointer) {
2180 if (const UnaryOperator *Op
2181 = dyn_cast<UnaryOperator>(Init->IgnoreParenImpCasts())) {
2182 // The only case we're worried about with pointers requires taking the
2183 // address.
2184 if (Op->getOpcode() != UO_AddrOf)
2185 return;
2186
2187 Init = Op->getSubExpr();
2188 } else {
2189 // We only handle address-of expression initializers for pointers.
2190 return;
2191 }
2192 }
2193
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002194 if (isa<MaterializeTemporaryExpr>(Init->IgnoreParens())) {
2195 // Taking the address of a temporary will be diagnosed as a hard error.
2196 if (IsPointer)
2197 return;
Chandler Carruth81c64772011-09-03 01:14:15 +00002198
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002199 S.Diag(Init->getExprLoc(), diag::warn_bind_ref_member_to_temporary)
2200 << Member << Init->getSourceRange();
2201 } else if (const DeclRefExpr *DRE
2202 = dyn_cast<DeclRefExpr>(Init->IgnoreParens())) {
2203 // We only warn when referring to a non-reference parameter declaration.
2204 const ParmVarDecl *Parameter = dyn_cast<ParmVarDecl>(DRE->getDecl());
2205 if (!Parameter || Parameter->getType()->isReferenceType())
Chandler Carruth81c64772011-09-03 01:14:15 +00002206 return;
2207
2208 S.Diag(Init->getExprLoc(),
2209 IsPointer ? diag::warn_init_ptr_member_to_parameter_addr
2210 : diag::warn_bind_ref_member_to_parameter)
2211 << Member << Parameter << Init->getSourceRange();
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002212 } else {
2213 // Other initializers are fine.
2214 return;
Chandler Carruth81c64772011-09-03 01:14:15 +00002215 }
Chandler Carruthbf3380a2011-09-03 02:21:57 +00002216
2217 S.Diag(Member->getLocation(), diag::note_ref_or_ptr_member_declared_here)
2218 << (unsigned)IsPointer;
Chandler Carruth81c64772011-09-03 01:14:15 +00002219}
2220
John McCallf312b1e2010-08-26 23:41:50 +00002221MemInitResult
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002222Sema::BuildMemberInitializer(ValueDecl *Member, Expr *Init,
Sebastian Redl6df65482011-09-24 17:48:25 +00002223 SourceLocation IdLoc) {
Chandler Carruth894aed92010-12-06 09:23:57 +00002224 FieldDecl *DirectMember = dyn_cast<FieldDecl>(Member);
2225 IndirectFieldDecl *IndirectMember = dyn_cast<IndirectFieldDecl>(Member);
2226 assert((DirectMember || IndirectMember) &&
Francois Pichet00eb3f92010-12-04 09:14:42 +00002227 "Member must be a FieldDecl or IndirectFieldDecl");
2228
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002229 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Peter Collingbournefef21892011-10-23 18:59:44 +00002230 return true;
2231
Douglas Gregor464b2f02010-11-05 22:21:31 +00002232 if (Member->isInvalidDecl())
2233 return true;
Chandler Carruth894aed92010-12-06 09:23:57 +00002234
John McCallb4190042009-11-04 23:02:40 +00002235 // Diagnose value-uses of fields to initialize themselves, e.g.
2236 // foo(foo)
2237 // where foo is not also a parameter to the constructor.
John McCall6aee6212009-11-04 23:13:52 +00002238 // TODO: implement -Wuninitialized and fold this into that framework.
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002239 Expr **Args;
2240 unsigned NumArgs;
2241 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
2242 Args = ParenList->getExprs();
2243 NumArgs = ParenList->getNumExprs();
2244 } else {
2245 InitListExpr *InitList = cast<InitListExpr>(Init);
2246 Args = InitList->getInits();
2247 NumArgs = InitList->getNumInits();
2248 }
Daniel Jasperf8cc02e2012-06-06 08:32:04 +00002249
Richard Trieude5e75c2012-06-14 23:11:34 +00002250 if (getDiagnostics().getDiagnosticLevel(diag::warn_field_is_uninit, IdLoc)
2251 != DiagnosticsEngine::Ignored)
2252 for (unsigned i = 0; i < NumArgs; ++i)
2253 // FIXME: Warn about the case when other fields are used before being
Hans Wennborg471f9852012-09-18 15:58:06 +00002254 // initialized. For example, let this field be the i'th field. When
John McCallb4190042009-11-04 23:02:40 +00002255 // initializing the i'th field, throw a warning if any of the >= i'th
2256 // fields are used, as they are not yet initialized.
2257 // Right now we are only handling the case where the i'th field uses
2258 // itself in its initializer.
Hans Wennborg471f9852012-09-18 15:58:06 +00002259 // Also need to take into account that some fields may be initialized by
2260 // in-class initializers, see C++11 [class.base.init]p9.
Richard Trieude5e75c2012-06-14 23:11:34 +00002261 CheckInitExprContainsUninitializedFields(*this, Args[i], Member);
John McCallb4190042009-11-04 23:02:40 +00002262
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002263 SourceRange InitRange = Init->getSourceRange();
Eli Friedman59c04372009-07-29 19:44:27 +00002264
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002265 if (Member->getType()->isDependentType() || Init->isTypeDependent()) {
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002266 // Can't check initialization for a member of dependent type or when
2267 // any of the arguments are type-dependent expressions.
John McCallf85e1932011-06-15 23:02:42 +00002268 DiscardCleanupsInEvaluationContext();
Chandler Carruth894aed92010-12-06 09:23:57 +00002269 } else {
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002270 bool InitList = false;
2271 if (isa<InitListExpr>(Init)) {
2272 InitList = true;
2273 Args = &Init;
2274 NumArgs = 1;
Sebastian Redl772291a2012-02-19 16:31:05 +00002275
2276 if (isStdInitializerList(Member->getType(), 0)) {
2277 Diag(IdLoc, diag::warn_dangling_std_initializer_list)
2278 << /*at end of ctor*/1 << InitRange;
2279 }
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002280 }
2281
Chandler Carruth894aed92010-12-06 09:23:57 +00002282 // Initialize the member.
2283 InitializedEntity MemberEntity =
2284 DirectMember ? InitializedEntity::InitializeMember(DirectMember, 0)
2285 : InitializedEntity::InitializeMember(IndirectMember, 0);
2286 InitializationKind Kind =
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002287 InitList ? InitializationKind::CreateDirectList(IdLoc)
2288 : InitializationKind::CreateDirect(IdLoc, InitRange.getBegin(),
2289 InitRange.getEnd());
John McCallb4eb64d2010-10-08 02:01:28 +00002290
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002291 InitializationSequence InitSeq(*this, MemberEntity, Kind, Args, NumArgs);
2292 ExprResult MemberInit = InitSeq.Perform(*this, MemberEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002293 MultiExprArg(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002294 0);
Chandler Carruth894aed92010-12-06 09:23:57 +00002295 if (MemberInit.isInvalid())
2296 return true;
2297
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002298 CheckImplicitConversions(MemberInit.get(),
2299 InitRange.getBegin());
Chandler Carruth894aed92010-12-06 09:23:57 +00002300
2301 // C++0x [class.base.init]p7:
2302 // The initialization of each base and member constitutes a
2303 // full-expression.
Douglas Gregor53c374f2010-12-07 00:41:46 +00002304 MemberInit = MaybeCreateExprWithCleanups(MemberInit);
Chandler Carruth894aed92010-12-06 09:23:57 +00002305 if (MemberInit.isInvalid())
2306 return true;
2307
2308 // If we are in a dependent context, template instantiation will
2309 // perform this type-checking again. Just save the arguments that we
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002310 // received.
Chandler Carruth894aed92010-12-06 09:23:57 +00002311 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2312 // of the information that we have about the member
2313 // initializer. However, deconstructing the ASTs is a dicey process,
2314 // and this approach is far more likely to get the corner cases right.
Chandler Carruth81c64772011-09-03 01:14:15 +00002315 if (CurContext->isDependentContext()) {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002316 // The existing Init will do fine.
Chandler Carruth81c64772011-09-03 01:14:15 +00002317 } else {
Chandler Carruth894aed92010-12-06 09:23:57 +00002318 Init = MemberInit.get();
Chandler Carruth81c64772011-09-03 01:14:15 +00002319 CheckForDanglingReferenceOrPointer(*this, Member, Init, IdLoc);
2320 }
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002321 }
2322
Chandler Carruth894aed92010-12-06 09:23:57 +00002323 if (DirectMember) {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002324 return new (Context) CXXCtorInitializer(Context, DirectMember, IdLoc,
2325 InitRange.getBegin(), Init,
2326 InitRange.getEnd());
Chandler Carruth894aed92010-12-06 09:23:57 +00002327 } else {
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002328 return new (Context) CXXCtorInitializer(Context, IndirectMember, IdLoc,
2329 InitRange.getBegin(), Init,
2330 InitRange.getEnd());
Chandler Carruth894aed92010-12-06 09:23:57 +00002331 }
Eli Friedman59c04372009-07-29 19:44:27 +00002332}
2333
John McCallf312b1e2010-08-26 23:41:50 +00002334MemInitResult
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002335Sema::BuildDelegatingInitializer(TypeSourceInfo *TInfo, Expr *Init,
Sean Hunt41717662011-02-26 19:13:13 +00002336 CXXRecordDecl *ClassDecl) {
Douglas Gregor76852c22011-11-01 01:16:03 +00002337 SourceLocation NameLoc = TInfo->getTypeLoc().getLocalSourceRange().getBegin();
Sean Hunt97fcc492011-01-08 19:20:43 +00002338 if (!LangOpts.CPlusPlus0x)
Douglas Gregor76852c22011-11-01 01:16:03 +00002339 return Diag(NameLoc, diag::err_delegating_ctor)
Sean Hunt97fcc492011-01-08 19:20:43 +00002340 << TInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor76852c22011-11-01 01:16:03 +00002341 Diag(NameLoc, diag::warn_cxx98_compat_delegating_ctor);
Sebastian Redlf9c32eb2011-03-12 13:53:51 +00002342
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002343 bool InitList = true;
2344 Expr **Args = &Init;
2345 unsigned NumArgs = 1;
2346 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
2347 InitList = false;
2348 Args = ParenList->getExprs();
2349 NumArgs = ParenList->getNumExprs();
2350 }
2351
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002352 SourceRange InitRange = Init->getSourceRange();
Sean Hunt41717662011-02-26 19:13:13 +00002353 // Initialize the object.
2354 InitializedEntity DelegationEntity = InitializedEntity::InitializeDelegation(
2355 QualType(ClassDecl->getTypeForDecl(), 0));
2356 InitializationKind Kind =
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002357 InitList ? InitializationKind::CreateDirectList(NameLoc)
2358 : InitializationKind::CreateDirect(NameLoc, InitRange.getBegin(),
2359 InitRange.getEnd());
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002360 InitializationSequence InitSeq(*this, DelegationEntity, Kind, Args, NumArgs);
2361 ExprResult DelegationInit = InitSeq.Perform(*this, DelegationEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002362 MultiExprArg(Args, NumArgs),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002363 0);
Sean Hunt41717662011-02-26 19:13:13 +00002364 if (DelegationInit.isInvalid())
2365 return true;
2366
Matt Beaumont-Gay2eb0ce32011-11-01 18:10:22 +00002367 assert(cast<CXXConstructExpr>(DelegationInit.get())->getConstructor() &&
2368 "Delegating constructor with no target?");
Sean Hunt41717662011-02-26 19:13:13 +00002369
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002370 CheckImplicitConversions(DelegationInit.get(), InitRange.getBegin());
Sean Hunt41717662011-02-26 19:13:13 +00002371
2372 // C++0x [class.base.init]p7:
2373 // The initialization of each base and member constitutes a
2374 // full-expression.
2375 DelegationInit = MaybeCreateExprWithCleanups(DelegationInit);
2376 if (DelegationInit.isInvalid())
2377 return true;
2378
Eli Friedmand21016f2012-05-19 23:35:23 +00002379 // If we are in a dependent context, template instantiation will
2380 // perform this type-checking again. Just save the arguments that we
2381 // received in a ParenListExpr.
2382 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2383 // of the information that we have about the base
2384 // initializer. However, deconstructing the ASTs is a dicey process,
2385 // and this approach is far more likely to get the corner cases right.
2386 if (CurContext->isDependentContext())
2387 DelegationInit = Owned(Init);
2388
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002389 return new (Context) CXXCtorInitializer(Context, TInfo, InitRange.getBegin(),
Sean Hunt41717662011-02-26 19:13:13 +00002390 DelegationInit.takeAs<Expr>(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002391 InitRange.getEnd());
Sean Hunt97fcc492011-01-08 19:20:43 +00002392}
2393
2394MemInitResult
John McCalla93c9342009-12-07 02:54:59 +00002395Sema::BuildBaseInitializer(QualType BaseType, TypeSourceInfo *BaseTInfo,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002396 Expr *Init, CXXRecordDecl *ClassDecl,
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002397 SourceLocation EllipsisLoc) {
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002398 SourceLocation BaseLoc
2399 = BaseTInfo->getTypeLoc().getLocalSourceRange().getBegin();
Sebastian Redl6df65482011-09-24 17:48:25 +00002400
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002401 if (!BaseType->isDependentType() && !BaseType->isRecordType())
2402 return Diag(BaseLoc, diag::err_base_init_does_not_name_class)
2403 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
2404
2405 // C++ [class.base.init]p2:
2406 // [...] Unless the mem-initializer-id names a nonstatic data
Nick Lewycky7663f392010-11-20 01:29:55 +00002407 // member of the constructor's class or a direct or virtual base
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002408 // of that class, the mem-initializer is ill-formed. A
2409 // mem-initializer-list can initialize a base class using any
2410 // name that denotes that base class type.
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002411 bool Dependent = BaseType->isDependentType() || Init->isTypeDependent();
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002412
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002413 SourceRange InitRange = Init->getSourceRange();
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002414 if (EllipsisLoc.isValid()) {
2415 // This is a pack expansion.
2416 if (!BaseType->containsUnexpandedParameterPack()) {
2417 Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002418 << SourceRange(BaseLoc, InitRange.getEnd());
Sebastian Redl6df65482011-09-24 17:48:25 +00002419
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002420 EllipsisLoc = SourceLocation();
2421 }
2422 } else {
2423 // Check for any unexpanded parameter packs.
2424 if (DiagnoseUnexpandedParameterPack(BaseLoc, BaseTInfo, UPPC_Initializer))
2425 return true;
Sebastian Redl6df65482011-09-24 17:48:25 +00002426
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002427 if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer))
Sebastian Redl6df65482011-09-24 17:48:25 +00002428 return true;
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002429 }
Sebastian Redl6df65482011-09-24 17:48:25 +00002430
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002431 // Check for direct and virtual base classes.
2432 const CXXBaseSpecifier *DirectBaseSpec = 0;
2433 const CXXBaseSpecifier *VirtualBaseSpec = 0;
2434 if (!Dependent) {
Sean Hunt97fcc492011-01-08 19:20:43 +00002435 if (Context.hasSameUnqualifiedType(QualType(ClassDecl->getTypeForDecl(),0),
2436 BaseType))
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002437 return BuildDelegatingInitializer(BaseTInfo, Init, ClassDecl);
Sean Hunt97fcc492011-01-08 19:20:43 +00002438
Douglas Gregor3956b1a2010-06-16 16:03:14 +00002439 FindBaseInitializer(*this, ClassDecl, BaseType, DirectBaseSpec,
2440 VirtualBaseSpec);
2441
2442 // C++ [base.class.init]p2:
2443 // Unless the mem-initializer-id names a nonstatic data member of the
2444 // constructor's class or a direct or virtual base of that class, the
2445 // mem-initializer is ill-formed.
2446 if (!DirectBaseSpec && !VirtualBaseSpec) {
2447 // If the class has any dependent bases, then it's possible that
2448 // one of those types will resolve to the same type as
2449 // BaseType. Therefore, just treat this as a dependent base
2450 // class initialization. FIXME: Should we try to check the
2451 // initialization anyway? It seems odd.
2452 if (ClassDecl->hasAnyDependentBases())
2453 Dependent = true;
2454 else
2455 return Diag(BaseLoc, diag::err_not_direct_base_or_virtual)
2456 << BaseType << Context.getTypeDeclType(ClassDecl)
2457 << BaseTInfo->getTypeLoc().getLocalSourceRange();
2458 }
2459 }
2460
2461 if (Dependent) {
John McCallf85e1932011-06-15 23:02:42 +00002462 DiscardCleanupsInEvaluationContext();
Mike Stump1eb44332009-09-09 15:08:12 +00002463
Sebastian Redl6df65482011-09-24 17:48:25 +00002464 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
2465 /*IsVirtual=*/false,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002466 InitRange.getBegin(), Init,
2467 InitRange.getEnd(), EllipsisLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002468 }
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002469
2470 // C++ [base.class.init]p2:
2471 // If a mem-initializer-id is ambiguous because it designates both
2472 // a direct non-virtual base class and an inherited virtual base
2473 // class, the mem-initializer is ill-formed.
2474 if (DirectBaseSpec && VirtualBaseSpec)
2475 return Diag(BaseLoc, diag::err_base_init_direct_and_virtual)
Abramo Bagnarabd054db2010-05-20 10:00:11 +00002476 << BaseType << BaseTInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002477
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002478 CXXBaseSpecifier *BaseSpec = const_cast<CXXBaseSpecifier *>(DirectBaseSpec);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002479 if (!BaseSpec)
2480 BaseSpec = const_cast<CXXBaseSpecifier *>(VirtualBaseSpec);
2481
2482 // Initialize the base.
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002483 bool InitList = true;
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002484 Expr **Args = &Init;
2485 unsigned NumArgs = 1;
2486 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002487 InitList = false;
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002488 Args = ParenList->getExprs();
2489 NumArgs = ParenList->getNumExprs();
2490 }
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00002491
2492 InitializedEntity BaseEntity =
2493 InitializedEntity::InitializeBase(Context, BaseSpec, VirtualBaseSpec);
2494 InitializationKind Kind =
2495 InitList ? InitializationKind::CreateDirectList(BaseLoc)
2496 : InitializationKind::CreateDirect(BaseLoc, InitRange.getBegin(),
2497 InitRange.getEnd());
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002498 InitializationSequence InitSeq(*this, BaseEntity, Kind, Args, NumArgs);
2499 ExprResult BaseInit = InitSeq.Perform(*this, BaseEntity, Kind,
Benjamin Kramer5354e772012-08-23 23:38:35 +00002500 MultiExprArg(Args, NumArgs), 0);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002501 if (BaseInit.isInvalid())
2502 return true;
John McCallb4eb64d2010-10-08 02:01:28 +00002503
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002504 CheckImplicitConversions(BaseInit.get(), InitRange.getBegin());
Sebastian Redl6df65482011-09-24 17:48:25 +00002505
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002506 // C++0x [class.base.init]p7:
2507 // The initialization of each base and member constitutes a
2508 // full-expression.
Douglas Gregor53c374f2010-12-07 00:41:46 +00002509 BaseInit = MaybeCreateExprWithCleanups(BaseInit);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002510 if (BaseInit.isInvalid())
2511 return true;
2512
2513 // If we are in a dependent context, template instantiation will
2514 // perform this type-checking again. Just save the arguments that we
2515 // received in a ParenListExpr.
2516 // FIXME: This isn't quite ideal, since our ASTs don't capture all
2517 // of the information that we have about the base
2518 // initializer. However, deconstructing the ASTs is a dicey process,
2519 // and this approach is far more likely to get the corner cases right.
Sebastian Redl6df65482011-09-24 17:48:25 +00002520 if (CurContext->isDependentContext())
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002521 BaseInit = Owned(Init);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00002522
Sean Huntcbb67482011-01-08 20:30:50 +00002523 return new (Context) CXXCtorInitializer(Context, BaseTInfo,
Sebastian Redl6df65482011-09-24 17:48:25 +00002524 BaseSpec->isVirtual(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002525 InitRange.getBegin(),
Sebastian Redl6df65482011-09-24 17:48:25 +00002526 BaseInit.takeAs<Expr>(),
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00002527 InitRange.getEnd(), EllipsisLoc);
Douglas Gregor7ad83902008-11-05 04:29:56 +00002528}
2529
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002530// Create a static_cast\<T&&>(expr).
2531static Expr *CastForMoving(Sema &SemaRef, Expr *E) {
2532 QualType ExprType = E->getType();
2533 QualType TargetType = SemaRef.Context.getRValueReferenceType(ExprType);
2534 SourceLocation ExprLoc = E->getLocStart();
2535 TypeSourceInfo *TargetLoc = SemaRef.Context.getTrivialTypeSourceInfo(
2536 TargetType, ExprLoc);
2537
2538 return SemaRef.BuildCXXNamedCast(ExprLoc, tok::kw_static_cast, TargetLoc, E,
2539 SourceRange(ExprLoc, ExprLoc),
2540 E->getSourceRange()).take();
2541}
2542
Anders Carlssone5ef7402010-04-23 03:10:23 +00002543/// ImplicitInitializerKind - How an implicit base or member initializer should
2544/// initialize its base or member.
2545enum ImplicitInitializerKind {
2546 IIK_Default,
2547 IIK_Copy,
2548 IIK_Move
2549};
2550
Anders Carlssondefefd22010-04-23 02:00:02 +00002551static bool
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002552BuildImplicitBaseInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlssone5ef7402010-04-23 03:10:23 +00002553 ImplicitInitializerKind ImplicitInitKind,
Anders Carlsson711f34a2010-04-21 19:52:01 +00002554 CXXBaseSpecifier *BaseSpec,
Anders Carlssondefefd22010-04-23 02:00:02 +00002555 bool IsInheritedVirtualBase,
Sean Huntcbb67482011-01-08 20:30:50 +00002556 CXXCtorInitializer *&CXXBaseInit) {
Anders Carlsson84688f22010-04-20 23:11:20 +00002557 InitializedEntity InitEntity
Anders Carlsson711f34a2010-04-21 19:52:01 +00002558 = InitializedEntity::InitializeBase(SemaRef.Context, BaseSpec,
2559 IsInheritedVirtualBase);
Anders Carlsson84688f22010-04-20 23:11:20 +00002560
John McCall60d7b3a2010-08-24 06:29:42 +00002561 ExprResult BaseInit;
Anders Carlssone5ef7402010-04-23 03:10:23 +00002562
2563 switch (ImplicitInitKind) {
2564 case IIK_Default: {
2565 InitializationKind InitKind
2566 = InitializationKind::CreateDefault(Constructor->getLocation());
2567 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
Benjamin Kramer5354e772012-08-23 23:38:35 +00002568 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg());
Anders Carlssone5ef7402010-04-23 03:10:23 +00002569 break;
2570 }
Anders Carlsson84688f22010-04-20 23:11:20 +00002571
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002572 case IIK_Move:
Anders Carlssone5ef7402010-04-23 03:10:23 +00002573 case IIK_Copy: {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002574 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlssone5ef7402010-04-23 03:10:23 +00002575 ParmVarDecl *Param = Constructor->getParamDecl(0);
2576 QualType ParamType = Param->getType().getNonReferenceType();
Eli Friedmancf7c14c2012-01-16 21:00:51 +00002577
Anders Carlssone5ef7402010-04-23 03:10:23 +00002578 Expr *CopyCtorArg =
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002579 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCallf4b88a42012-03-10 09:33:50 +00002580 SourceLocation(), Param, false,
John McCallf89e55a2010-11-18 06:31:45 +00002581 Constructor->getLocation(), ParamType,
2582 VK_LValue, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002583
Eli Friedman5f2987c2012-02-02 03:46:19 +00002584 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(CopyCtorArg));
2585
Anders Carlssonc7957502010-04-24 22:02:54 +00002586 // Cast to the base class to avoid ambiguities.
Anders Carlsson59b7f152010-05-01 16:39:01 +00002587 QualType ArgTy =
2588 SemaRef.Context.getQualifiedType(BaseSpec->getType().getUnqualifiedType(),
2589 ParamType.getQualifiers());
John McCallf871d0c2010-08-07 06:22:56 +00002590
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002591 if (Moving) {
2592 CopyCtorArg = CastForMoving(SemaRef, CopyCtorArg);
2593 }
2594
John McCallf871d0c2010-08-07 06:22:56 +00002595 CXXCastPath BasePath;
2596 BasePath.push_back(BaseSpec);
John Wiegley429bb272011-04-08 18:41:53 +00002597 CopyCtorArg = SemaRef.ImpCastExprToType(CopyCtorArg, ArgTy,
2598 CK_UncheckedDerivedToBase,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002599 Moving ? VK_XValue : VK_LValue,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002600 &BasePath).take();
Anders Carlssonc7957502010-04-24 22:02:54 +00002601
Anders Carlssone5ef7402010-04-23 03:10:23 +00002602 InitializationKind InitKind
2603 = InitializationKind::CreateDirect(Constructor->getLocation(),
2604 SourceLocation(), SourceLocation());
2605 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind,
2606 &CopyCtorArg, 1);
2607 BaseInit = InitSeq.Perform(SemaRef, InitEntity, InitKind,
John McCallf312b1e2010-08-26 23:41:50 +00002608 MultiExprArg(&CopyCtorArg, 1));
Anders Carlssone5ef7402010-04-23 03:10:23 +00002609 break;
2610 }
Anders Carlssone5ef7402010-04-23 03:10:23 +00002611 }
John McCall9ae2f072010-08-23 23:25:46 +00002612
Douglas Gregor53c374f2010-12-07 00:41:46 +00002613 BaseInit = SemaRef.MaybeCreateExprWithCleanups(BaseInit);
Anders Carlsson84688f22010-04-20 23:11:20 +00002614 if (BaseInit.isInvalid())
Anders Carlssondefefd22010-04-23 02:00:02 +00002615 return true;
Anders Carlsson84688f22010-04-20 23:11:20 +00002616
Anders Carlssondefefd22010-04-23 02:00:02 +00002617 CXXBaseInit =
Sean Huntcbb67482011-01-08 20:30:50 +00002618 new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
Anders Carlsson84688f22010-04-20 23:11:20 +00002619 SemaRef.Context.getTrivialTypeSourceInfo(BaseSpec->getType(),
2620 SourceLocation()),
2621 BaseSpec->isVirtual(),
2622 SourceLocation(),
2623 BaseInit.takeAs<Expr>(),
Douglas Gregor3fb9e4b2011-01-04 00:32:56 +00002624 SourceLocation(),
Anders Carlsson84688f22010-04-20 23:11:20 +00002625 SourceLocation());
2626
Anders Carlssondefefd22010-04-23 02:00:02 +00002627 return false;
Anders Carlsson84688f22010-04-20 23:11:20 +00002628}
2629
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002630static bool RefersToRValueRef(Expr *MemRef) {
2631 ValueDecl *Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();
2632 return Referenced->getType()->isRValueReferenceType();
2633}
2634
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002635static bool
2636BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
Anders Carlssone5ef7402010-04-23 03:10:23 +00002637 ImplicitInitializerKind ImplicitInitKind,
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002638 FieldDecl *Field, IndirectFieldDecl *Indirect,
Sean Huntcbb67482011-01-08 20:30:50 +00002639 CXXCtorInitializer *&CXXMemberInit) {
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002640 if (Field->isInvalidDecl())
2641 return true;
2642
Chandler Carruthf186b542010-06-29 23:50:44 +00002643 SourceLocation Loc = Constructor->getLocation();
2644
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002645 if (ImplicitInitKind == IIK_Copy || ImplicitInitKind == IIK_Move) {
2646 bool Moving = ImplicitInitKind == IIK_Move;
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002647 ParmVarDecl *Param = Constructor->getParamDecl(0);
2648 QualType ParamType = Param->getType().getNonReferenceType();
John McCallb77115d2011-06-17 00:18:42 +00002649
2650 // Suppress copying zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002651 if (Field->isBitField() && Field->getBitWidthValue(SemaRef.Context) == 0)
2652 return false;
Douglas Gregorddb21472011-11-02 23:04:16 +00002653
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002654 Expr *MemberExprBase =
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002655 DeclRefExpr::Create(SemaRef.Context, NestedNameSpecifierLoc(),
John McCallf4b88a42012-03-10 09:33:50 +00002656 SourceLocation(), Param, false,
John McCallf89e55a2010-11-18 06:31:45 +00002657 Loc, ParamType, VK_LValue, 0);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002658
Eli Friedman5f2987c2012-02-02 03:46:19 +00002659 SemaRef.MarkDeclRefReferenced(cast<DeclRefExpr>(MemberExprBase));
2660
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002661 if (Moving) {
2662 MemberExprBase = CastForMoving(SemaRef, MemberExprBase);
2663 }
2664
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002665 // Build a reference to this field within the parameter.
2666 CXXScopeSpec SS;
2667 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
2668 Sema::LookupMemberName);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002669 MemberLookup.addDecl(Indirect ? cast<ValueDecl>(Indirect)
2670 : cast<ValueDecl>(Field), AS_public);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002671 MemberLookup.resolveKind();
Sebastian Redl74e611a2011-09-04 18:14:28 +00002672 ExprResult CtorArg
John McCall9ae2f072010-08-23 23:25:46 +00002673 = SemaRef.BuildMemberReferenceExpr(MemberExprBase,
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002674 ParamType, Loc,
2675 /*IsArrow=*/false,
2676 SS,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00002677 /*TemplateKWLoc=*/SourceLocation(),
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002678 /*FirstQualifierInScope=*/0,
2679 MemberLookup,
2680 /*TemplateArgs=*/0);
Sebastian Redl74e611a2011-09-04 18:14:28 +00002681 if (CtorArg.isInvalid())
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002682 return true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002683
2684 // C++11 [class.copy]p15:
2685 // - if a member m has rvalue reference type T&&, it is direct-initialized
2686 // with static_cast<T&&>(x.m);
Sebastian Redl74e611a2011-09-04 18:14:28 +00002687 if (RefersToRValueRef(CtorArg.get())) {
2688 CtorArg = CastForMoving(SemaRef, CtorArg.take());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002689 }
2690
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002691 // When the field we are copying is an array, create index variables for
2692 // each dimension of the array. We use these index variables to subscript
2693 // the source array, and other clients (e.g., CodeGen) will perform the
2694 // necessary iteration with these index variables.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002695 SmallVector<VarDecl *, 4> IndexVariables;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002696 QualType BaseType = Field->getType();
2697 QualType SizeType = SemaRef.Context.getSizeType();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002698 bool InitializingArray = false;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002699 while (const ConstantArrayType *Array
2700 = SemaRef.Context.getAsConstantArrayType(BaseType)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002701 InitializingArray = true;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002702 // Create the iteration variable for this array index.
2703 IdentifierInfo *IterationVarName = 0;
2704 {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00002705 SmallString<8> Str;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002706 llvm::raw_svector_ostream OS(Str);
2707 OS << "__i" << IndexVariables.size();
2708 IterationVarName = &SemaRef.Context.Idents.get(OS.str());
2709 }
2710 VarDecl *IterationVar
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00002711 = VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002712 IterationVarName, SizeType,
2713 SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
John McCalld931b082010-08-26 03:08:43 +00002714 SC_None, SC_None);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002715 IndexVariables.push_back(IterationVar);
2716
2717 // Create a reference to the iteration variable.
John McCall60d7b3a2010-08-24 06:29:42 +00002718 ExprResult IterationVarRef
Eli Friedman8c382062012-01-23 02:35:22 +00002719 = SemaRef.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002720 assert(!IterationVarRef.isInvalid() &&
2721 "Reference to invented variable cannot fail!");
Eli Friedman8c382062012-01-23 02:35:22 +00002722 IterationVarRef = SemaRef.DefaultLvalueConversion(IterationVarRef.take());
2723 assert(!IterationVarRef.isInvalid() &&
2724 "Conversion of invented variable cannot fail!");
Sebastian Redl74e611a2011-09-04 18:14:28 +00002725
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002726 // Subscript the array with this iteration variable.
Sebastian Redl74e611a2011-09-04 18:14:28 +00002727 CtorArg = SemaRef.CreateBuiltinArraySubscriptExpr(CtorArg.take(), Loc,
John McCall9ae2f072010-08-23 23:25:46 +00002728 IterationVarRef.take(),
Sebastian Redl74e611a2011-09-04 18:14:28 +00002729 Loc);
2730 if (CtorArg.isInvalid())
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002731 return true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002732
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002733 BaseType = Array->getElementType();
2734 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002735
2736 // The array subscript expression is an lvalue, which is wrong for moving.
2737 if (Moving && InitializingArray)
Sebastian Redl74e611a2011-09-04 18:14:28 +00002738 CtorArg = CastForMoving(SemaRef, CtorArg.take());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002739
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002740 // Construct the entity that we will be initializing. For an array, this
2741 // will be first element in the array, which may require several levels
2742 // of array-subscript entities.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002743 SmallVector<InitializedEntity, 4> Entities;
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002744 Entities.reserve(1 + IndexVariables.size());
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002745 if (Indirect)
2746 Entities.push_back(InitializedEntity::InitializeMember(Indirect));
2747 else
2748 Entities.push_back(InitializedEntity::InitializeMember(Field));
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002749 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
2750 Entities.push_back(InitializedEntity::InitializeElement(SemaRef.Context,
2751 0,
2752 Entities.back()));
2753
2754 // Direct-initialize to use the copy constructor.
2755 InitializationKind InitKind =
2756 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());
2757
Sebastian Redl74e611a2011-09-04 18:14:28 +00002758 Expr *CtorArgE = CtorArg.takeAs<Expr>();
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002759 InitializationSequence InitSeq(SemaRef, Entities.back(), InitKind,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002760 &CtorArgE, 1);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002761
John McCall60d7b3a2010-08-24 06:29:42 +00002762 ExprResult MemberInit
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002763 = InitSeq.Perform(SemaRef, Entities.back(), InitKind,
Sebastian Redl74e611a2011-09-04 18:14:28 +00002764 MultiExprArg(&CtorArgE, 1));
Douglas Gregor53c374f2010-12-07 00:41:46 +00002765 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00002766 if (MemberInit.isInvalid())
2767 return true;
2768
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002769 if (Indirect) {
2770 assert(IndexVariables.size() == 0 &&
2771 "Indirect field improperly initialized");
2772 CXXMemberInit
2773 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
2774 Loc, Loc,
2775 MemberInit.takeAs<Expr>(),
2776 Loc);
2777 } else
2778 CXXMemberInit = CXXCtorInitializer::Create(SemaRef.Context, Field, Loc,
2779 Loc, MemberInit.takeAs<Expr>(),
2780 Loc,
2781 IndexVariables.data(),
2782 IndexVariables.size());
Anders Carlssone5ef7402010-04-23 03:10:23 +00002783 return false;
2784 }
2785
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002786 assert(ImplicitInitKind == IIK_Default && "Unhandled implicit init kind!");
2787
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002788 QualType FieldBaseElementType =
2789 SemaRef.Context.getBaseElementType(Field->getType());
2790
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002791 if (FieldBaseElementType->isRecordType()) {
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002792 InitializedEntity InitEntity
2793 = Indirect? InitializedEntity::InitializeMember(Indirect)
2794 : InitializedEntity::InitializeMember(Field);
Anders Carlssonf6513ed2010-04-23 16:04:08 +00002795 InitializationKind InitKind =
Chandler Carruthf186b542010-06-29 23:50:44 +00002796 InitializationKind::CreateDefault(Loc);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002797
2798 InitializationSequence InitSeq(SemaRef, InitEntity, InitKind, 0, 0);
John McCall60d7b3a2010-08-24 06:29:42 +00002799 ExprResult MemberInit =
John McCallf312b1e2010-08-26 23:41:50 +00002800 InitSeq.Perform(SemaRef, InitEntity, InitKind, MultiExprArg());
John McCall9ae2f072010-08-23 23:25:46 +00002801
Douglas Gregor53c374f2010-12-07 00:41:46 +00002802 MemberInit = SemaRef.MaybeCreateExprWithCleanups(MemberInit);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002803 if (MemberInit.isInvalid())
2804 return true;
2805
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002806 if (Indirect)
2807 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
2808 Indirect, Loc,
2809 Loc,
2810 MemberInit.get(),
2811 Loc);
2812 else
2813 CXXMemberInit = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context,
2814 Field, Loc, Loc,
2815 MemberInit.get(),
2816 Loc);
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002817 return false;
2818 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002819
Sean Hunt1f2f3842011-05-17 00:19:05 +00002820 if (!Field->getParent()->isUnion()) {
2821 if (FieldBaseElementType->isReferenceType()) {
2822 SemaRef.Diag(Constructor->getLocation(),
2823 diag::err_uninitialized_member_in_ctor)
2824 << (int)Constructor->isImplicit()
2825 << SemaRef.Context.getTagDeclType(Constructor->getParent())
2826 << 0 << Field->getDeclName();
2827 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
2828 return true;
2829 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002830
Sean Hunt1f2f3842011-05-17 00:19:05 +00002831 if (FieldBaseElementType.isConstQualified()) {
2832 SemaRef.Diag(Constructor->getLocation(),
2833 diag::err_uninitialized_member_in_ctor)
2834 << (int)Constructor->isImplicit()
2835 << SemaRef.Context.getTagDeclType(Constructor->getParent())
2836 << 1 << Field->getDeclName();
2837 SemaRef.Diag(Field->getLocation(), diag::note_declared_at);
2838 return true;
2839 }
Anders Carlsson114a2972010-04-23 03:07:47 +00002840 }
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002841
David Blaikie4e4d0842012-03-11 07:00:24 +00002842 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00002843 FieldBaseElementType->isObjCRetainableType() &&
2844 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_None &&
2845 FieldBaseElementType.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
Douglas Gregor3fe52ff2012-07-23 04:23:39 +00002846 // ARC:
John McCallf85e1932011-06-15 23:02:42 +00002847 // Default-initialize Objective-C pointers to NULL.
2848 CXXMemberInit
2849 = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
2850 Loc, Loc,
2851 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()),
2852 Loc);
2853 return false;
2854 }
2855
Anders Carlssonddfb75f2010-04-23 02:15:47 +00002856 // Nothing to initialize.
2857 CXXMemberInit = 0;
2858 return false;
2859}
John McCallf1860e52010-05-20 23:23:51 +00002860
2861namespace {
2862struct BaseAndFieldInfo {
2863 Sema &S;
2864 CXXConstructorDecl *Ctor;
2865 bool AnyErrorsInInits;
2866 ImplicitInitializerKind IIK;
Sean Huntcbb67482011-01-08 20:30:50 +00002867 llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002868 SmallVector<CXXCtorInitializer*, 8> AllToInit;
John McCallf1860e52010-05-20 23:23:51 +00002869
2870 BaseAndFieldInfo(Sema &S, CXXConstructorDecl *Ctor, bool ErrorsInInits)
2871 : S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002872 bool Generated = Ctor->isImplicit() || Ctor->isDefaulted();
2873 if (Generated && Ctor->isCopyConstructor())
John McCallf1860e52010-05-20 23:23:51 +00002874 IIK = IIK_Copy;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00002875 else if (Generated && Ctor->isMoveConstructor())
2876 IIK = IIK_Move;
John McCallf1860e52010-05-20 23:23:51 +00002877 else
2878 IIK = IIK_Default;
2879 }
Douglas Gregorf4853882011-11-28 20:03:15 +00002880
2881 bool isImplicitCopyOrMove() const {
2882 switch (IIK) {
2883 case IIK_Copy:
2884 case IIK_Move:
2885 return true;
2886
2887 case IIK_Default:
2888 return false;
2889 }
David Blaikie30263482012-01-20 21:50:17 +00002890
2891 llvm_unreachable("Invalid ImplicitInitializerKind!");
Douglas Gregorf4853882011-11-28 20:03:15 +00002892 }
Richard Smith0b8220a2012-08-07 21:30:42 +00002893
2894 bool addFieldInitializer(CXXCtorInitializer *Init) {
2895 AllToInit.push_back(Init);
2896
2897 // Check whether this initializer makes the field "used".
2898 if (Init->getInit() && Init->getInit()->HasSideEffects(S.Context))
2899 S.UnusedPrivateFields.remove(Init->getAnyMember());
2900
2901 return false;
2902 }
John McCallf1860e52010-05-20 23:23:51 +00002903};
2904}
2905
Richard Smitha4950662011-09-19 13:34:43 +00002906/// \brief Determine whether the given indirect field declaration is somewhere
2907/// within an anonymous union.
2908static bool isWithinAnonymousUnion(IndirectFieldDecl *F) {
2909 for (IndirectFieldDecl::chain_iterator C = F->chain_begin(),
2910 CEnd = F->chain_end();
2911 C != CEnd; ++C)
2912 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>((*C)->getDeclContext()))
2913 if (Record->isUnion())
2914 return true;
2915
2916 return false;
2917}
2918
Douglas Gregorddb21472011-11-02 23:04:16 +00002919/// \brief Determine whether the given type is an incomplete or zero-lenfgth
2920/// array type.
2921static bool isIncompleteOrZeroLengthArrayType(ASTContext &Context, QualType T) {
2922 if (T->isIncompleteArrayType())
2923 return true;
2924
2925 while (const ConstantArrayType *ArrayT = Context.getAsConstantArrayType(T)) {
2926 if (!ArrayT->getSize())
2927 return true;
2928
2929 T = ArrayT->getElementType();
2930 }
2931
2932 return false;
2933}
2934
Richard Smith7a614d82011-06-11 17:19:42 +00002935static bool CollectFieldInitializer(Sema &SemaRef, BaseAndFieldInfo &Info,
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002936 FieldDecl *Field,
2937 IndirectFieldDecl *Indirect = 0) {
John McCallf1860e52010-05-20 23:23:51 +00002938
Chandler Carruthe861c602010-06-30 02:59:29 +00002939 // Overwhelmingly common case: we have a direct initializer for this field.
Richard Smith0b8220a2012-08-07 21:30:42 +00002940 if (CXXCtorInitializer *Init = Info.AllBaseFields.lookup(Field))
2941 return Info.addFieldInitializer(Init);
John McCallf1860e52010-05-20 23:23:51 +00002942
Richard Smith0b8220a2012-08-07 21:30:42 +00002943 // C++11 [class.base.init]p8: if the entity is a non-static data member that
Richard Smith7a614d82011-06-11 17:19:42 +00002944 // has a brace-or-equal-initializer, the entity is initialized as specified
2945 // in [dcl.init].
Douglas Gregorf4853882011-11-28 20:03:15 +00002946 if (Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002947 CXXCtorInitializer *Init;
2948 if (Indirect)
2949 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Indirect,
2950 SourceLocation(),
2951 SourceLocation(), 0,
2952 SourceLocation());
2953 else
2954 Init = new (SemaRef.Context) CXXCtorInitializer(SemaRef.Context, Field,
2955 SourceLocation(),
2956 SourceLocation(), 0,
2957 SourceLocation());
Richard Smith0b8220a2012-08-07 21:30:42 +00002958 return Info.addFieldInitializer(Init);
Richard Smith7a614d82011-06-11 17:19:42 +00002959 }
2960
Richard Smithc115f632011-09-18 11:14:50 +00002961 // Don't build an implicit initializer for union members if none was
2962 // explicitly specified.
Richard Smitha4950662011-09-19 13:34:43 +00002963 if (Field->getParent()->isUnion() ||
2964 (Indirect && isWithinAnonymousUnion(Indirect)))
Richard Smithc115f632011-09-18 11:14:50 +00002965 return false;
2966
Douglas Gregorddb21472011-11-02 23:04:16 +00002967 // Don't initialize incomplete or zero-length arrays.
2968 if (isIncompleteOrZeroLengthArrayType(SemaRef.Context, Field->getType()))
2969 return false;
2970
John McCallf1860e52010-05-20 23:23:51 +00002971 // Don't try to build an implicit initializer if there were semantic
2972 // errors in any of the initializers (and therefore we might be
2973 // missing some that the user actually wrote).
Richard Smith7a614d82011-06-11 17:19:42 +00002974 if (Info.AnyErrorsInInits || Field->isInvalidDecl())
John McCallf1860e52010-05-20 23:23:51 +00002975 return false;
2976
Sean Huntcbb67482011-01-08 20:30:50 +00002977 CXXCtorInitializer *Init = 0;
Douglas Gregor4dc41c92011-08-10 15:22:55 +00002978 if (BuildImplicitMemberInitializer(Info.S, Info.Ctor, Info.IIK, Field,
2979 Indirect, Init))
John McCallf1860e52010-05-20 23:23:51 +00002980 return true;
John McCallf1860e52010-05-20 23:23:51 +00002981
Richard Smith0b8220a2012-08-07 21:30:42 +00002982 if (!Init)
2983 return false;
Francois Pichet00eb3f92010-12-04 09:14:42 +00002984
Richard Smith0b8220a2012-08-07 21:30:42 +00002985 return Info.addFieldInitializer(Init);
John McCallf1860e52010-05-20 23:23:51 +00002986}
Sean Hunt059ce0d2011-05-01 07:04:31 +00002987
2988bool
2989Sema::SetDelegatingInitializer(CXXConstructorDecl *Constructor,
2990 CXXCtorInitializer *Initializer) {
Sean Huntfe57eef2011-05-04 05:57:24 +00002991 assert(Initializer->isDelegatingInitializer());
Sean Hunt01aacc02011-05-03 20:43:02 +00002992 Constructor->setNumCtorInitializers(1);
2993 CXXCtorInitializer **initializer =
2994 new (Context) CXXCtorInitializer*[1];
2995 memcpy(initializer, &Initializer, sizeof (CXXCtorInitializer*));
2996 Constructor->setCtorInitializers(initializer);
2997
Sean Huntb76af9c2011-05-03 23:05:34 +00002998 if (CXXDestructorDecl *Dtor = LookupDestructor(Constructor->getParent())) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00002999 MarkFunctionReferenced(Initializer->getSourceLocation(), Dtor);
Sean Huntb76af9c2011-05-03 23:05:34 +00003000 DiagnoseUseOfDecl(Dtor, Initializer->getSourceLocation());
3001 }
3002
Sean Huntc1598702011-05-05 00:05:47 +00003003 DelegatingCtorDecls.push_back(Constructor);
Sean Huntfe57eef2011-05-04 05:57:24 +00003004
Sean Hunt059ce0d2011-05-01 07:04:31 +00003005 return false;
3006}
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003007
John McCallb77115d2011-06-17 00:18:42 +00003008bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor,
3009 CXXCtorInitializer **Initializers,
3010 unsigned NumInitializers,
3011 bool AnyErrors) {
Douglas Gregord836c0d2011-09-22 23:04:35 +00003012 if (Constructor->isDependentContext()) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003013 // Just store the initializers as written, they will be checked during
3014 // instantiation.
3015 if (NumInitializers > 0) {
Sean Huntcbb67482011-01-08 20:30:50 +00003016 Constructor->setNumCtorInitializers(NumInitializers);
3017 CXXCtorInitializer **baseOrMemberInitializers =
3018 new (Context) CXXCtorInitializer*[NumInitializers];
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003019 memcpy(baseOrMemberInitializers, Initializers,
Sean Huntcbb67482011-01-08 20:30:50 +00003020 NumInitializers * sizeof(CXXCtorInitializer*));
3021 Constructor->setCtorInitializers(baseOrMemberInitializers);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003022 }
Richard Smith54b3ba82012-09-25 00:23:05 +00003023
3024 // Let template instantiation know whether we had errors.
3025 if (AnyErrors)
3026 Constructor->setInvalidDecl();
3027
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003028 return false;
3029 }
3030
John McCallf1860e52010-05-20 23:23:51 +00003031 BaseAndFieldInfo Info(*this, Constructor, AnyErrors);
Anders Carlssone5ef7402010-04-23 03:10:23 +00003032
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003033 // We need to build the initializer AST according to order of construction
3034 // and not what user specified in the Initializers list.
Anders Carlssonea356fb2010-04-02 05:42:15 +00003035 CXXRecordDecl *ClassDecl = Constructor->getParent()->getDefinition();
Douglas Gregord6068482010-03-26 22:43:07 +00003036 if (!ClassDecl)
3037 return true;
3038
Eli Friedman80c30da2009-11-09 19:20:36 +00003039 bool HadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +00003040
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003041 for (unsigned i = 0; i < NumInitializers; i++) {
Sean Huntcbb67482011-01-08 20:30:50 +00003042 CXXCtorInitializer *Member = Initializers[i];
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003043
3044 if (Member->isBaseInitializer())
John McCallf1860e52010-05-20 23:23:51 +00003045 Info.AllBaseFields[Member->getBaseClass()->getAs<RecordType>()] = Member;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003046 else
Francois Pichet00eb3f92010-12-04 09:14:42 +00003047 Info.AllBaseFields[Member->getAnyMember()] = Member;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003048 }
3049
Anders Carlsson711f34a2010-04-21 19:52:01 +00003050 // Keep track of the direct virtual bases.
3051 llvm::SmallPtrSet<CXXBaseSpecifier *, 16> DirectVBases;
3052 for (CXXRecordDecl::base_class_iterator I = ClassDecl->bases_begin(),
3053 E = ClassDecl->bases_end(); I != E; ++I) {
3054 if (I->isVirtual())
3055 DirectVBases.insert(I);
3056 }
3057
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003058 // Push virtual bases before others.
3059 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
3060 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
3061
Sean Huntcbb67482011-01-08 20:30:50 +00003062 if (CXXCtorInitializer *Value
John McCallf1860e52010-05-20 23:23:51 +00003063 = Info.AllBaseFields.lookup(VBase->getType()->getAs<RecordType>())) {
3064 Info.AllToInit.push_back(Value);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003065 } else if (!AnyErrors) {
Anders Carlsson711f34a2010-04-21 19:52:01 +00003066 bool IsInheritedVirtualBase = !DirectVBases.count(VBase);
Sean Huntcbb67482011-01-08 20:30:50 +00003067 CXXCtorInitializer *CXXBaseInit;
John McCallf1860e52010-05-20 23:23:51 +00003068 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Anders Carlssone5ef7402010-04-23 03:10:23 +00003069 VBase, IsInheritedVirtualBase,
3070 CXXBaseInit)) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003071 HadError = true;
3072 continue;
3073 }
Anders Carlsson84688f22010-04-20 23:11:20 +00003074
John McCallf1860e52010-05-20 23:23:51 +00003075 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003076 }
3077 }
Mike Stump1eb44332009-09-09 15:08:12 +00003078
John McCallf1860e52010-05-20 23:23:51 +00003079 // Non-virtual bases.
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003080 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3081 E = ClassDecl->bases_end(); Base != E; ++Base) {
3082 // Virtuals are in the virtual base list and already constructed.
3083 if (Base->isVirtual())
3084 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00003085
Sean Huntcbb67482011-01-08 20:30:50 +00003086 if (CXXCtorInitializer *Value
John McCallf1860e52010-05-20 23:23:51 +00003087 = Info.AllBaseFields.lookup(Base->getType()->getAs<RecordType>())) {
3088 Info.AllToInit.push_back(Value);
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003089 } else if (!AnyErrors) {
Sean Huntcbb67482011-01-08 20:30:50 +00003090 CXXCtorInitializer *CXXBaseInit;
John McCallf1860e52010-05-20 23:23:51 +00003091 if (BuildImplicitBaseInitializer(*this, Constructor, Info.IIK,
Anders Carlssone5ef7402010-04-23 03:10:23 +00003092 Base, /*IsInheritedVirtualBase=*/false,
Anders Carlssondefefd22010-04-23 02:00:02 +00003093 CXXBaseInit)) {
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003094 HadError = true;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003095 continue;
Anders Carlssonbcc12fd2010-04-02 06:26:44 +00003096 }
Fariborz Jahanian9d436202009-09-03 21:32:41 +00003097
John McCallf1860e52010-05-20 23:23:51 +00003098 Info.AllToInit.push_back(CXXBaseInit);
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003099 }
3100 }
Mike Stump1eb44332009-09-09 15:08:12 +00003101
John McCallf1860e52010-05-20 23:23:51 +00003102 // Fields.
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003103 for (DeclContext::decl_iterator Mem = ClassDecl->decls_begin(),
3104 MemEnd = ClassDecl->decls_end();
3105 Mem != MemEnd; ++Mem) {
3106 if (FieldDecl *F = dyn_cast<FieldDecl>(*Mem)) {
Douglas Gregord61db332011-10-10 17:22:13 +00003107 // C++ [class.bit]p2:
3108 // A declaration for a bit-field that omits the identifier declares an
3109 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
3110 // initialized.
3111 if (F->isUnnamedBitfield())
3112 continue;
Douglas Gregorddb21472011-11-02 23:04:16 +00003113
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00003114 // If we're not generating the implicit copy/move constructor, then we'll
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003115 // handle anonymous struct/union fields based on their individual
3116 // indirect fields.
3117 if (F->isAnonymousStructOrUnion() && Info.IIK == IIK_Default)
3118 continue;
3119
3120 if (CollectFieldInitializer(*this, Info, F))
3121 HadError = true;
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00003122 continue;
3123 }
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003124
3125 // Beyond this point, we only consider default initialization.
3126 if (Info.IIK != IIK_Default)
3127 continue;
3128
3129 if (IndirectFieldDecl *F = dyn_cast<IndirectFieldDecl>(*Mem)) {
3130 if (F->getType()->isIncompleteArrayType()) {
3131 assert(ClassDecl->hasFlexibleArrayMember() &&
3132 "Incomplete array type is not valid");
3133 continue;
3134 }
3135
Douglas Gregor4dc41c92011-08-10 15:22:55 +00003136 // Initialize each field of an anonymous struct individually.
3137 if (CollectFieldInitializer(*this, Info, F->getAnonField(), F))
3138 HadError = true;
3139
3140 continue;
3141 }
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00003142 }
Mike Stump1eb44332009-09-09 15:08:12 +00003143
John McCallf1860e52010-05-20 23:23:51 +00003144 NumInitializers = Info.AllToInit.size();
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003145 if (NumInitializers > 0) {
Sean Huntcbb67482011-01-08 20:30:50 +00003146 Constructor->setNumCtorInitializers(NumInitializers);
3147 CXXCtorInitializer **baseOrMemberInitializers =
3148 new (Context) CXXCtorInitializer*[NumInitializers];
John McCallf1860e52010-05-20 23:23:51 +00003149 memcpy(baseOrMemberInitializers, Info.AllToInit.data(),
Sean Huntcbb67482011-01-08 20:30:50 +00003150 NumInitializers * sizeof(CXXCtorInitializer*));
3151 Constructor->setCtorInitializers(baseOrMemberInitializers);
Rafael Espindola961b1672010-03-13 18:12:56 +00003152
John McCallef027fe2010-03-16 21:39:52 +00003153 // Constructors implicitly reference the base and member
3154 // destructors.
3155 MarkBaseAndMemberDestructorsReferenced(Constructor->getLocation(),
3156 Constructor->getParent());
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003157 }
Eli Friedman80c30da2009-11-09 19:20:36 +00003158
3159 return HadError;
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00003160}
3161
Eli Friedman6347f422009-07-21 19:28:10 +00003162static void *GetKeyForTopLevelField(FieldDecl *Field) {
3163 // For anonymous unions, use the class declaration as the key.
Ted Kremenek6217b802009-07-29 21:53:49 +00003164 if (const RecordType *RT = Field->getType()->getAs<RecordType>()) {
Eli Friedman6347f422009-07-21 19:28:10 +00003165 if (RT->getDecl()->isAnonymousStructOrUnion())
3166 return static_cast<void *>(RT->getDecl());
3167 }
3168 return static_cast<void *>(Field);
3169}
3170
Anders Carlssonea356fb2010-04-02 05:42:15 +00003171static void *GetKeyForBase(ASTContext &Context, QualType BaseType) {
John McCallf4c73712011-01-19 06:33:43 +00003172 return const_cast<Type*>(Context.getCanonicalType(BaseType).getTypePtr());
Anders Carlssoncdc83c72009-09-01 06:22:14 +00003173}
3174
Anders Carlssonea356fb2010-04-02 05:42:15 +00003175static void *GetKeyForMember(ASTContext &Context,
Sean Huntcbb67482011-01-08 20:30:50 +00003176 CXXCtorInitializer *Member) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00003177 if (!Member->isAnyMemberInitializer())
Anders Carlssonea356fb2010-04-02 05:42:15 +00003178 return GetKeyForBase(Context, QualType(Member->getBaseClass(), 0));
Anders Carlsson8f1a2402010-03-30 15:39:27 +00003179
Eli Friedman6347f422009-07-21 19:28:10 +00003180 // For fields injected into the class via declaration of an anonymous union,
3181 // use its anonymous union class declaration as the unique key.
Francois Pichet00eb3f92010-12-04 09:14:42 +00003182 FieldDecl *Field = Member->getAnyMember();
3183
John McCall3c3ccdb2010-04-10 09:28:51 +00003184 // If the field is a member of an anonymous struct or union, our key
3185 // is the anonymous record decl that's a direct child of the class.
Anders Carlssonee11b2d2010-03-30 16:19:37 +00003186 RecordDecl *RD = Field->getParent();
John McCall3c3ccdb2010-04-10 09:28:51 +00003187 if (RD->isAnonymousStructOrUnion()) {
3188 while (true) {
3189 RecordDecl *Parent = cast<RecordDecl>(RD->getDeclContext());
3190 if (Parent->isAnonymousStructOrUnion())
3191 RD = Parent;
3192 else
3193 break;
3194 }
3195
Anders Carlssonee11b2d2010-03-30 16:19:37 +00003196 return static_cast<void *>(RD);
John McCall3c3ccdb2010-04-10 09:28:51 +00003197 }
Mike Stump1eb44332009-09-09 15:08:12 +00003198
Anders Carlsson8f1a2402010-03-30 15:39:27 +00003199 return static_cast<void *>(Field);
Eli Friedman6347f422009-07-21 19:28:10 +00003200}
3201
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003202static void
3203DiagnoseBaseOrMemInitializerOrder(Sema &SemaRef,
Anders Carlsson071d6102010-04-02 03:38:04 +00003204 const CXXConstructorDecl *Constructor,
Sean Huntcbb67482011-01-08 20:30:50 +00003205 CXXCtorInitializer **Inits,
John McCalld6ca8da2010-04-10 07:37:23 +00003206 unsigned NumInits) {
3207 if (Constructor->getDeclContext()->isDependentContext())
Anders Carlsson8d4c5ea2009-08-27 05:57:30 +00003208 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003209
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003210 // Don't check initializers order unless the warning is enabled at the
3211 // location of at least one initializer.
3212 bool ShouldCheckOrder = false;
3213 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) {
Sean Huntcbb67482011-01-08 20:30:50 +00003214 CXXCtorInitializer *Init = Inits[InitIndex];
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003215 if (SemaRef.Diags.getDiagnosticLevel(diag::warn_initializer_out_of_order,
3216 Init->getSourceLocation())
David Blaikied6471f72011-09-25 23:23:43 +00003217 != DiagnosticsEngine::Ignored) {
Argyrios Kyrtzidis08274082010-12-15 18:44:22 +00003218 ShouldCheckOrder = true;
3219 break;
3220 }
3221 }
3222 if (!ShouldCheckOrder)
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003223 return;
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003224
John McCalld6ca8da2010-04-10 07:37:23 +00003225 // Build the list of bases and members in the order that they'll
3226 // actually be initialized. The explicit initializers should be in
3227 // this same order but may be missing things.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003228 SmallVector<const void*, 32> IdealInitKeys;
Mike Stump1eb44332009-09-09 15:08:12 +00003229
Anders Carlsson071d6102010-04-02 03:38:04 +00003230 const CXXRecordDecl *ClassDecl = Constructor->getParent();
3231
John McCalld6ca8da2010-04-10 07:37:23 +00003232 // 1. Virtual bases.
Anders Carlsson071d6102010-04-02 03:38:04 +00003233 for (CXXRecordDecl::base_class_const_iterator VBase =
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003234 ClassDecl->vbases_begin(),
3235 E = ClassDecl->vbases_end(); VBase != E; ++VBase)
John McCalld6ca8da2010-04-10 07:37:23 +00003236 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, VBase->getType()));
Mike Stump1eb44332009-09-09 15:08:12 +00003237
John McCalld6ca8da2010-04-10 07:37:23 +00003238 // 2. Non-virtual bases.
Anders Carlsson071d6102010-04-02 03:38:04 +00003239 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(),
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003240 E = ClassDecl->bases_end(); Base != E; ++Base) {
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003241 if (Base->isVirtual())
3242 continue;
John McCalld6ca8da2010-04-10 07:37:23 +00003243 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base->getType()));
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003244 }
Mike Stump1eb44332009-09-09 15:08:12 +00003245
John McCalld6ca8da2010-04-10 07:37:23 +00003246 // 3. Direct fields.
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003247 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
Douglas Gregord61db332011-10-10 17:22:13 +00003248 E = ClassDecl->field_end(); Field != E; ++Field) {
3249 if (Field->isUnnamedBitfield())
3250 continue;
3251
David Blaikie581deb32012-06-06 20:45:41 +00003252 IdealInitKeys.push_back(GetKeyForTopLevelField(*Field));
Douglas Gregord61db332011-10-10 17:22:13 +00003253 }
3254
John McCalld6ca8da2010-04-10 07:37:23 +00003255 unsigned NumIdealInits = IdealInitKeys.size();
3256 unsigned IdealIndex = 0;
Eli Friedman6347f422009-07-21 19:28:10 +00003257
Sean Huntcbb67482011-01-08 20:30:50 +00003258 CXXCtorInitializer *PrevInit = 0;
John McCalld6ca8da2010-04-10 07:37:23 +00003259 for (unsigned InitIndex = 0; InitIndex != NumInits; ++InitIndex) {
Sean Huntcbb67482011-01-08 20:30:50 +00003260 CXXCtorInitializer *Init = Inits[InitIndex];
Francois Pichet00eb3f92010-12-04 09:14:42 +00003261 void *InitKey = GetKeyForMember(SemaRef.Context, Init);
John McCalld6ca8da2010-04-10 07:37:23 +00003262
3263 // Scan forward to try to find this initializer in the idealized
3264 // initializers list.
3265 for (; IdealIndex != NumIdealInits; ++IdealIndex)
3266 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003267 break;
John McCalld6ca8da2010-04-10 07:37:23 +00003268
3269 // If we didn't find this initializer, it must be because we
3270 // scanned past it on a previous iteration. That can only
3271 // happen if we're out of order; emit a warning.
Douglas Gregorfe2d3792010-05-20 23:49:34 +00003272 if (IdealIndex == NumIdealInits && PrevInit) {
John McCalld6ca8da2010-04-10 07:37:23 +00003273 Sema::SemaDiagnosticBuilder D =
3274 SemaRef.Diag(PrevInit->getSourceLocation(),
3275 diag::warn_initializer_out_of_order);
3276
Francois Pichet00eb3f92010-12-04 09:14:42 +00003277 if (PrevInit->isAnyMemberInitializer())
3278 D << 0 << PrevInit->getAnyMember()->getDeclName();
John McCalld6ca8da2010-04-10 07:37:23 +00003279 else
Douglas Gregor76852c22011-11-01 01:16:03 +00003280 D << 1 << PrevInit->getTypeSourceInfo()->getType();
John McCalld6ca8da2010-04-10 07:37:23 +00003281
Francois Pichet00eb3f92010-12-04 09:14:42 +00003282 if (Init->isAnyMemberInitializer())
3283 D << 0 << Init->getAnyMember()->getDeclName();
John McCalld6ca8da2010-04-10 07:37:23 +00003284 else
Douglas Gregor76852c22011-11-01 01:16:03 +00003285 D << 1 << Init->getTypeSourceInfo()->getType();
John McCalld6ca8da2010-04-10 07:37:23 +00003286
3287 // Move back to the initializer's location in the ideal list.
3288 for (IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)
3289 if (InitKey == IdealInitKeys[IdealIndex])
Anders Carlsson5c36fb22009-08-27 05:45:01 +00003290 break;
John McCalld6ca8da2010-04-10 07:37:23 +00003291
3292 assert(IdealIndex != NumIdealInits &&
3293 "initializer not found in initializer list");
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00003294 }
John McCalld6ca8da2010-04-10 07:37:23 +00003295
3296 PrevInit = Init;
Fariborz Jahanianeb96e122009-07-09 19:59:47 +00003297 }
Anders Carlssona7b35212009-03-25 02:58:17 +00003298}
3299
John McCall3c3ccdb2010-04-10 09:28:51 +00003300namespace {
3301bool CheckRedundantInit(Sema &S,
Sean Huntcbb67482011-01-08 20:30:50 +00003302 CXXCtorInitializer *Init,
3303 CXXCtorInitializer *&PrevInit) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003304 if (!PrevInit) {
3305 PrevInit = Init;
3306 return false;
3307 }
3308
3309 if (FieldDecl *Field = Init->getMember())
3310 S.Diag(Init->getSourceLocation(),
3311 diag::err_multiple_mem_initialization)
3312 << Field->getDeclName()
3313 << Init->getSourceRange();
3314 else {
John McCallf4c73712011-01-19 06:33:43 +00003315 const Type *BaseClass = Init->getBaseClass();
John McCall3c3ccdb2010-04-10 09:28:51 +00003316 assert(BaseClass && "neither field nor base");
3317 S.Diag(Init->getSourceLocation(),
3318 diag::err_multiple_base_initialization)
3319 << QualType(BaseClass, 0)
3320 << Init->getSourceRange();
3321 }
3322 S.Diag(PrevInit->getSourceLocation(), diag::note_previous_initializer)
3323 << 0 << PrevInit->getSourceRange();
3324
3325 return true;
3326}
3327
Sean Huntcbb67482011-01-08 20:30:50 +00003328typedef std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;
John McCall3c3ccdb2010-04-10 09:28:51 +00003329typedef llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;
3330
3331bool CheckRedundantUnionInit(Sema &S,
Sean Huntcbb67482011-01-08 20:30:50 +00003332 CXXCtorInitializer *Init,
John McCall3c3ccdb2010-04-10 09:28:51 +00003333 RedundantUnionMap &Unions) {
Francois Pichet00eb3f92010-12-04 09:14:42 +00003334 FieldDecl *Field = Init->getAnyMember();
John McCall3c3ccdb2010-04-10 09:28:51 +00003335 RecordDecl *Parent = Field->getParent();
John McCall3c3ccdb2010-04-10 09:28:51 +00003336 NamedDecl *Child = Field;
David Blaikie6fe29652011-11-17 06:01:57 +00003337
3338 while (Parent->isAnonymousStructOrUnion() || Parent->isUnion()) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003339 if (Parent->isUnion()) {
3340 UnionEntry &En = Unions[Parent];
3341 if (En.first && En.first != Child) {
3342 S.Diag(Init->getSourceLocation(),
3343 diag::err_multiple_mem_union_initialization)
3344 << Field->getDeclName()
3345 << Init->getSourceRange();
3346 S.Diag(En.second->getSourceLocation(), diag::note_previous_initializer)
3347 << 0 << En.second->getSourceRange();
3348 return true;
David Blaikie5bbe8162011-11-12 20:54:14 +00003349 }
3350 if (!En.first) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003351 En.first = Child;
3352 En.second = Init;
3353 }
David Blaikie6fe29652011-11-17 06:01:57 +00003354 if (!Parent->isAnonymousStructOrUnion())
3355 return false;
John McCall3c3ccdb2010-04-10 09:28:51 +00003356 }
3357
3358 Child = Parent;
3359 Parent = cast<RecordDecl>(Parent->getDeclContext());
David Blaikie6fe29652011-11-17 06:01:57 +00003360 }
John McCall3c3ccdb2010-04-10 09:28:51 +00003361
3362 return false;
3363}
3364}
3365
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003366/// ActOnMemInitializers - Handle the member initializers for a constructor.
John McCalld226f652010-08-21 09:40:31 +00003367void Sema::ActOnMemInitializers(Decl *ConstructorDecl,
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003368 SourceLocation ColonLoc,
Richard Trieu90ab75b2011-09-09 03:18:59 +00003369 CXXCtorInitializer **meminits,
3370 unsigned NumMemInits,
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003371 bool AnyErrors) {
3372 if (!ConstructorDecl)
3373 return;
3374
3375 AdjustDeclIfTemplate(ConstructorDecl);
3376
3377 CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00003378 = dyn_cast<CXXConstructorDecl>(ConstructorDecl);
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003379
3380 if (!Constructor) {
3381 Diag(ColonLoc, diag::err_only_constructors_take_base_inits);
3382 return;
3383 }
3384
Sean Huntcbb67482011-01-08 20:30:50 +00003385 CXXCtorInitializer **MemInits =
3386 reinterpret_cast<CXXCtorInitializer **>(meminits);
John McCall3c3ccdb2010-04-10 09:28:51 +00003387
3388 // Mapping for the duplicate initializers check.
3389 // For member initializers, this is keyed with a FieldDecl*.
3390 // For base initializers, this is keyed with a Type*.
Sean Huntcbb67482011-01-08 20:30:50 +00003391 llvm::DenseMap<void*, CXXCtorInitializer *> Members;
John McCall3c3ccdb2010-04-10 09:28:51 +00003392
3393 // Mapping for the inconsistent anonymous-union initializers check.
3394 RedundantUnionMap MemberUnions;
3395
Anders Carlssonea356fb2010-04-02 05:42:15 +00003396 bool HadError = false;
3397 for (unsigned i = 0; i < NumMemInits; i++) {
Sean Huntcbb67482011-01-08 20:30:50 +00003398 CXXCtorInitializer *Init = MemInits[i];
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003399
Abramo Bagnaraa0af3b42010-05-26 18:09:23 +00003400 // Set the source order index.
3401 Init->setSourceOrder(i);
3402
Francois Pichet00eb3f92010-12-04 09:14:42 +00003403 if (Init->isAnyMemberInitializer()) {
3404 FieldDecl *Field = Init->getAnyMember();
John McCall3c3ccdb2010-04-10 09:28:51 +00003405 if (CheckRedundantInit(*this, Init, Members[Field]) ||
3406 CheckRedundantUnionInit(*this, Init, MemberUnions))
3407 HadError = true;
Sean Hunt41717662011-02-26 19:13:13 +00003408 } else if (Init->isBaseInitializer()) {
John McCall3c3ccdb2010-04-10 09:28:51 +00003409 void *Key = GetKeyForBase(Context, QualType(Init->getBaseClass(), 0));
3410 if (CheckRedundantInit(*this, Init, Members[Key]))
3411 HadError = true;
Sean Hunt41717662011-02-26 19:13:13 +00003412 } else {
3413 assert(Init->isDelegatingInitializer());
3414 // This must be the only initializer
Richard Smitha6ddea62012-09-14 18:21:10 +00003415 if (NumMemInits != 1) {
3416 Diag(Init->getSourceLocation(),
Sean Hunt41717662011-02-26 19:13:13 +00003417 diag::err_delegating_initializer_alone)
Richard Smitha6ddea62012-09-14 18:21:10 +00003418 << Init->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();
Sean Hunt059ce0d2011-05-01 07:04:31 +00003419 // We will treat this as being the only initializer.
Sean Hunt41717662011-02-26 19:13:13 +00003420 }
Sean Huntfe57eef2011-05-04 05:57:24 +00003421 SetDelegatingInitializer(Constructor, MemInits[i]);
Sean Hunt059ce0d2011-05-01 07:04:31 +00003422 // Return immediately as the initializer is set.
3423 return;
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003424 }
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003425 }
3426
Anders Carlssonea356fb2010-04-02 05:42:15 +00003427 if (HadError)
3428 return;
3429
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003430 DiagnoseBaseOrMemInitializerOrder(*this, Constructor, MemInits, NumMemInits);
Anders Carlssonec3332b2010-04-02 03:43:34 +00003431
Sean Huntcbb67482011-01-08 20:30:50 +00003432 SetCtorInitializers(Constructor, MemInits, NumMemInits, AnyErrors);
Anders Carlsson58cfbde2010-04-02 03:37:03 +00003433}
3434
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003435void
John McCallef027fe2010-03-16 21:39:52 +00003436Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location,
3437 CXXRecordDecl *ClassDecl) {
Richard Smith416f63e2011-09-18 12:11:43 +00003438 // Ignore dependent contexts. Also ignore unions, since their members never
3439 // have destructors implicitly called.
3440 if (ClassDecl->isDependentContext() || ClassDecl->isUnion())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003441 return;
John McCall58e6f342010-03-16 05:22:47 +00003442
3443 // FIXME: all the access-control diagnostics are positioned on the
3444 // field/base declaration. That's probably good; that said, the
3445 // user might reasonably want to know why the destructor is being
3446 // emitted, and we currently don't say.
Anders Carlsson9f853df2009-11-17 04:44:12 +00003447
Anders Carlsson9f853df2009-11-17 04:44:12 +00003448 // Non-static data members.
3449 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
3450 E = ClassDecl->field_end(); I != E; ++I) {
David Blaikie581deb32012-06-06 20:45:41 +00003451 FieldDecl *Field = *I;
Fariborz Jahanian9614dc02010-05-17 18:15:18 +00003452 if (Field->isInvalidDecl())
3453 continue;
Douglas Gregorddb21472011-11-02 23:04:16 +00003454
3455 // Don't destroy incomplete or zero-length arrays.
3456 if (isIncompleteOrZeroLengthArrayType(Context, Field->getType()))
3457 continue;
3458
Anders Carlsson9f853df2009-11-17 04:44:12 +00003459 QualType FieldType = Context.getBaseElementType(Field->getType());
3460
3461 const RecordType* RT = FieldType->getAs<RecordType>();
3462 if (!RT)
3463 continue;
3464
3465 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003466 if (FieldClassDecl->isInvalidDecl())
3467 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003468 if (FieldClassDecl->hasIrrelevantDestructor())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003469 continue;
Richard Smith9a561d52012-02-26 09:11:52 +00003470 // The destructor for an implicit anonymous union member is never invoked.
3471 if (FieldClassDecl->isUnion() && FieldClassDecl->isAnonymousStructOrUnion())
3472 continue;
Anders Carlsson9f853df2009-11-17 04:44:12 +00003473
Douglas Gregordb89f282010-07-01 22:47:18 +00003474 CXXDestructorDecl *Dtor = LookupDestructor(FieldClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003475 assert(Dtor && "No dtor found for FieldClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003476 CheckDestructorAccess(Field->getLocation(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003477 PDiag(diag::err_access_dtor_field)
John McCall58e6f342010-03-16 05:22:47 +00003478 << Field->getDeclName()
3479 << FieldType);
3480
Eli Friedman5f2987c2012-02-02 03:46:19 +00003481 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003482 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003483 }
3484
John McCall58e6f342010-03-16 05:22:47 +00003485 llvm::SmallPtrSet<const RecordType *, 8> DirectVirtualBases;
3486
Anders Carlsson9f853df2009-11-17 04:44:12 +00003487 // Bases.
3488 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
3489 E = ClassDecl->bases_end(); Base != E; ++Base) {
John McCall58e6f342010-03-16 05:22:47 +00003490 // Bases are always records in a well-formed non-dependent class.
3491 const RecordType *RT = Base->getType()->getAs<RecordType>();
3492
3493 // Remember direct virtual bases.
Anders Carlsson9f853df2009-11-17 04:44:12 +00003494 if (Base->isVirtual())
John McCall58e6f342010-03-16 05:22:47 +00003495 DirectVirtualBases.insert(RT);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003496
John McCall58e6f342010-03-16 05:22:47 +00003497 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003498 // If our base class is invalid, we probably can't get its dtor anyway.
3499 if (BaseClassDecl->isInvalidDecl())
3500 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003501 if (BaseClassDecl->hasIrrelevantDestructor())
Anders Carlsson9f853df2009-11-17 04:44:12 +00003502 continue;
John McCall58e6f342010-03-16 05:22:47 +00003503
Douglas Gregordb89f282010-07-01 22:47:18 +00003504 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003505 assert(Dtor && "No dtor found for BaseClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003506
3507 // FIXME: caret should be on the start of the class name
Daniel Dunbar96a00142012-03-09 18:35:03 +00003508 CheckDestructorAccess(Base->getLocStart(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003509 PDiag(diag::err_access_dtor_base)
John McCall58e6f342010-03-16 05:22:47 +00003510 << Base->getType()
John McCallb9abd8722012-04-07 03:04:20 +00003511 << Base->getSourceRange(),
3512 Context.getTypeDeclType(ClassDecl));
Anders Carlsson9f853df2009-11-17 04:44:12 +00003513
Eli Friedman5f2987c2012-02-02 03:46:19 +00003514 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003515 DiagnoseUseOfDecl(Dtor, Location);
Anders Carlsson9f853df2009-11-17 04:44:12 +00003516 }
3517
3518 // Virtual bases.
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003519 for (CXXRecordDecl::base_class_iterator VBase = ClassDecl->vbases_begin(),
3520 E = ClassDecl->vbases_end(); VBase != E; ++VBase) {
John McCall58e6f342010-03-16 05:22:47 +00003521
3522 // Bases are always records in a well-formed non-dependent class.
John McCall63f55782012-04-09 21:51:56 +00003523 const RecordType *RT = VBase->getType()->castAs<RecordType>();
John McCall58e6f342010-03-16 05:22:47 +00003524
3525 // Ignore direct virtual bases.
3526 if (DirectVirtualBases.count(RT))
3527 continue;
3528
John McCall58e6f342010-03-16 05:22:47 +00003529 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003530 // If our base class is invalid, we probably can't get its dtor anyway.
3531 if (BaseClassDecl->isInvalidDecl())
3532 continue;
Richard Smith213d70b2012-02-18 04:13:32 +00003533 if (BaseClassDecl->hasIrrelevantDestructor())
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003534 continue;
John McCall58e6f342010-03-16 05:22:47 +00003535
Douglas Gregordb89f282010-07-01 22:47:18 +00003536 CXXDestructorDecl *Dtor = LookupDestructor(BaseClassDecl);
Matt Beaumont-Gay3334b0b2011-03-28 01:39:13 +00003537 assert(Dtor && "No dtor found for BaseClassDecl!");
John McCall58e6f342010-03-16 05:22:47 +00003538 CheckDestructorAccess(ClassDecl->getLocation(), Dtor,
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00003539 PDiag(diag::err_access_dtor_vbase)
John McCall63f55782012-04-09 21:51:56 +00003540 << VBase->getType(),
3541 Context.getTypeDeclType(ClassDecl));
John McCall58e6f342010-03-16 05:22:47 +00003542
Eli Friedman5f2987c2012-02-02 03:46:19 +00003543 MarkFunctionReferenced(Location, const_cast<CXXDestructorDecl*>(Dtor));
Richard Smith213d70b2012-02-18 04:13:32 +00003544 DiagnoseUseOfDecl(Dtor, Location);
Fariborz Jahanian34374e62009-09-03 23:18:17 +00003545 }
3546}
3547
John McCalld226f652010-08-21 09:40:31 +00003548void Sema::ActOnDefaultCtorInitializers(Decl *CDtorDecl) {
Fariborz Jahanian560de452009-07-15 22:34:08 +00003549 if (!CDtorDecl)
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00003550 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003551
Mike Stump1eb44332009-09-09 15:08:12 +00003552 if (CXXConstructorDecl *Constructor
John McCalld226f652010-08-21 09:40:31 +00003553 = dyn_cast<CXXConstructorDecl>(CDtorDecl))
Sean Huntcbb67482011-01-08 20:30:50 +00003554 SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false);
Fariborz Jahaniand01c9152009-07-14 18:24:21 +00003555}
3556
Mike Stump1eb44332009-09-09 15:08:12 +00003557bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
John McCall94c3b562010-08-18 09:41:07 +00003558 unsigned DiagID, AbstractDiagSelID SelID) {
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003559 class NonAbstractTypeDiagnoser : public TypeDiagnoser {
3560 unsigned DiagID;
3561 AbstractDiagSelID SelID;
3562
3563 public:
3564 NonAbstractTypeDiagnoser(unsigned DiagID, AbstractDiagSelID SelID)
3565 : TypeDiagnoser(DiagID == 0), DiagID(DiagID), SelID(SelID) { }
3566
3567 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
Eli Friedman2217f852012-08-14 02:06:07 +00003568 if (Suppressed) return;
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003569 if (SelID == -1)
3570 S.Diag(Loc, DiagID) << T;
3571 else
3572 S.Diag(Loc, DiagID) << SelID << T;
3573 }
3574 } Diagnoser(DiagID, SelID);
3575
3576 return RequireNonAbstractType(Loc, T, Diagnoser);
Mike Stump1eb44332009-09-09 15:08:12 +00003577}
3578
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00003579bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003580 TypeDiagnoser &Diagnoser) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003581 if (!getLangOpts().CPlusPlus)
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003582 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003583
Anders Carlsson11f21a02009-03-23 19:10:31 +00003584 if (const ArrayType *AT = Context.getAsArrayType(T))
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003585 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Mike Stump1eb44332009-09-09 15:08:12 +00003586
Ted Kremenek6217b802009-07-29 21:53:49 +00003587 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003588 // Find the innermost pointer type.
Ted Kremenek6217b802009-07-29 21:53:49 +00003589 while (const PointerType *T = PT->getPointeeType()->getAs<PointerType>())
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003590 PT = T;
Mike Stump1eb44332009-09-09 15:08:12 +00003591
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003592 if (const ArrayType *AT = Context.getAsArrayType(PT->getPointeeType()))
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003593 return RequireNonAbstractType(Loc, AT->getElementType(), Diagnoser);
Anders Carlsson5eff73c2009-03-24 01:46:45 +00003594 }
Mike Stump1eb44332009-09-09 15:08:12 +00003595
Ted Kremenek6217b802009-07-29 21:53:49 +00003596 const RecordType *RT = T->getAs<RecordType>();
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003597 if (!RT)
3598 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003599
John McCall86ff3082010-02-04 22:26:26 +00003600 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003601
John McCall94c3b562010-08-18 09:41:07 +00003602 // We can't answer whether something is abstract until it has a
3603 // definition. If it's currently being defined, we'll walk back
3604 // over all the declarations when we have a full definition.
3605 const CXXRecordDecl *Def = RD->getDefinition();
3606 if (!Def || Def->isBeingDefined())
John McCall86ff3082010-02-04 22:26:26 +00003607 return false;
3608
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003609 if (!RD->isAbstract())
3610 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003611
Douglas Gregor6a26e2e2012-05-04 17:09:59 +00003612 Diagnoser.diagnose(*this, Loc, T);
John McCall94c3b562010-08-18 09:41:07 +00003613 DiagnoseAbstractType(RD);
Mike Stump1eb44332009-09-09 15:08:12 +00003614
John McCall94c3b562010-08-18 09:41:07 +00003615 return true;
3616}
3617
3618void Sema::DiagnoseAbstractType(const CXXRecordDecl *RD) {
3619 // Check if we've already emitted the list of pure virtual functions
3620 // for this class.
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003621 if (PureVirtualClassDiagSet && PureVirtualClassDiagSet->count(RD))
John McCall94c3b562010-08-18 09:41:07 +00003622 return;
Mike Stump1eb44332009-09-09 15:08:12 +00003623
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003624 CXXFinalOverriderMap FinalOverriders;
3625 RD->getFinalOverriders(FinalOverriders);
Mike Stump1eb44332009-09-09 15:08:12 +00003626
Anders Carlssonffdb2d22010-06-03 01:00:02 +00003627 // Keep a set of seen pure methods so we won't diagnose the same method
3628 // more than once.
3629 llvm::SmallPtrSet<const CXXMethodDecl *, 8> SeenPureMethods;
3630
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003631 for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
3632 MEnd = FinalOverriders.end();
3633 M != MEnd;
3634 ++M) {
3635 for (OverridingMethods::iterator SO = M->second.begin(),
3636 SOEnd = M->second.end();
3637 SO != SOEnd; ++SO) {
3638 // C++ [class.abstract]p4:
3639 // A class is abstract if it contains or inherits at least one
3640 // pure virtual function for which the final overrider is pure
3641 // virtual.
Mike Stump1eb44332009-09-09 15:08:12 +00003642
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003643 //
3644 if (SO->second.size() != 1)
3645 continue;
3646
3647 if (!SO->second.front().Method->isPure())
3648 continue;
3649
Anders Carlssonffdb2d22010-06-03 01:00:02 +00003650 if (!SeenPureMethods.insert(SO->second.front().Method))
3651 continue;
3652
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003653 Diag(SO->second.front().Method->getLocation(),
3654 diag::note_pure_virtual_function)
Chandler Carruth45f11b72011-02-18 23:59:51 +00003655 << SO->second.front().Method->getDeclName() << RD->getDeclName();
Douglas Gregor7b2fc9d2010-03-23 23:47:56 +00003656 }
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003657 }
3658
3659 if (!PureVirtualClassDiagSet)
3660 PureVirtualClassDiagSet.reset(new RecordDeclSetTy);
3661 PureVirtualClassDiagSet->insert(RD);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00003662}
3663
Anders Carlsson8211eff2009-03-24 01:19:16 +00003664namespace {
John McCall94c3b562010-08-18 09:41:07 +00003665struct AbstractUsageInfo {
3666 Sema &S;
3667 CXXRecordDecl *Record;
3668 CanQualType AbstractType;
3669 bool Invalid;
Mike Stump1eb44332009-09-09 15:08:12 +00003670
John McCall94c3b562010-08-18 09:41:07 +00003671 AbstractUsageInfo(Sema &S, CXXRecordDecl *Record)
3672 : S(S), Record(Record),
3673 AbstractType(S.Context.getCanonicalType(
3674 S.Context.getTypeDeclType(Record))),
3675 Invalid(false) {}
Anders Carlsson8211eff2009-03-24 01:19:16 +00003676
John McCall94c3b562010-08-18 09:41:07 +00003677 void DiagnoseAbstractType() {
3678 if (Invalid) return;
3679 S.DiagnoseAbstractType(Record);
3680 Invalid = true;
3681 }
Anders Carlssone65a3c82009-03-24 17:23:42 +00003682
John McCall94c3b562010-08-18 09:41:07 +00003683 void CheckType(const NamedDecl *D, TypeLoc TL, Sema::AbstractDiagSelID Sel);
3684};
3685
3686struct CheckAbstractUsage {
3687 AbstractUsageInfo &Info;
3688 const NamedDecl *Ctx;
3689
3690 CheckAbstractUsage(AbstractUsageInfo &Info, const NamedDecl *Ctx)
3691 : Info(Info), Ctx(Ctx) {}
3692
3693 void Visit(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
3694 switch (TL.getTypeLocClass()) {
3695#define ABSTRACT_TYPELOC(CLASS, PARENT)
3696#define TYPELOC(CLASS, PARENT) \
3697 case TypeLoc::CLASS: Check(cast<CLASS##TypeLoc>(TL), Sel); break;
3698#include "clang/AST/TypeLocNodes.def"
Anders Carlsson8211eff2009-03-24 01:19:16 +00003699 }
John McCall94c3b562010-08-18 09:41:07 +00003700 }
Mike Stump1eb44332009-09-09 15:08:12 +00003701
John McCall94c3b562010-08-18 09:41:07 +00003702 void Check(FunctionProtoTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3703 Visit(TL.getResultLoc(), Sema::AbstractReturnType);
3704 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
Douglas Gregor70191862011-02-22 23:21:06 +00003705 if (!TL.getArg(I))
3706 continue;
3707
John McCall94c3b562010-08-18 09:41:07 +00003708 TypeSourceInfo *TSI = TL.getArg(I)->getTypeSourceInfo();
3709 if (TSI) Visit(TSI->getTypeLoc(), Sema::AbstractParamType);
Anders Carlssone65a3c82009-03-24 17:23:42 +00003710 }
John McCall94c3b562010-08-18 09:41:07 +00003711 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00003712
John McCall94c3b562010-08-18 09:41:07 +00003713 void Check(ArrayTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3714 Visit(TL.getElementLoc(), Sema::AbstractArrayType);
3715 }
Mike Stump1eb44332009-09-09 15:08:12 +00003716
John McCall94c3b562010-08-18 09:41:07 +00003717 void Check(TemplateSpecializationTypeLoc TL, Sema::AbstractDiagSelID Sel) {
3718 // Visit the type parameters from a permissive context.
3719 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
3720 TemplateArgumentLoc TAL = TL.getArgLoc(I);
3721 if (TAL.getArgument().getKind() == TemplateArgument::Type)
3722 if (TypeSourceInfo *TSI = TAL.getTypeSourceInfo())
3723 Visit(TSI->getTypeLoc(), Sema::AbstractNone);
3724 // TODO: other template argument types?
Anders Carlsson8211eff2009-03-24 01:19:16 +00003725 }
John McCall94c3b562010-08-18 09:41:07 +00003726 }
Mike Stump1eb44332009-09-09 15:08:12 +00003727
John McCall94c3b562010-08-18 09:41:07 +00003728 // Visit pointee types from a permissive context.
3729#define CheckPolymorphic(Type) \
3730 void Check(Type TL, Sema::AbstractDiagSelID Sel) { \
3731 Visit(TL.getNextTypeLoc(), Sema::AbstractNone); \
3732 }
3733 CheckPolymorphic(PointerTypeLoc)
3734 CheckPolymorphic(ReferenceTypeLoc)
3735 CheckPolymorphic(MemberPointerTypeLoc)
3736 CheckPolymorphic(BlockPointerTypeLoc)
Eli Friedmanb001de72011-10-06 23:00:33 +00003737 CheckPolymorphic(AtomicTypeLoc)
Mike Stump1eb44332009-09-09 15:08:12 +00003738
John McCall94c3b562010-08-18 09:41:07 +00003739 /// Handle all the types we haven't given a more specific
3740 /// implementation for above.
3741 void Check(TypeLoc TL, Sema::AbstractDiagSelID Sel) {
3742 // Every other kind of type that we haven't called out already
3743 // that has an inner type is either (1) sugar or (2) contains that
3744 // inner type in some way as a subobject.
3745 if (TypeLoc Next = TL.getNextTypeLoc())
3746 return Visit(Next, Sel);
3747
3748 // If there's no inner type and we're in a permissive context,
3749 // don't diagnose.
3750 if (Sel == Sema::AbstractNone) return;
3751
3752 // Check whether the type matches the abstract type.
3753 QualType T = TL.getType();
3754 if (T->isArrayType()) {
3755 Sel = Sema::AbstractArrayType;
3756 T = Info.S.Context.getBaseElementType(T);
Anders Carlssone65a3c82009-03-24 17:23:42 +00003757 }
John McCall94c3b562010-08-18 09:41:07 +00003758 CanQualType CT = T->getCanonicalTypeUnqualified().getUnqualifiedType();
3759 if (CT != Info.AbstractType) return;
3760
3761 // It matched; do some magic.
3762 if (Sel == Sema::AbstractArrayType) {
3763 Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)
3764 << T << TL.getSourceRange();
3765 } else {
3766 Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)
3767 << Sel << T << TL.getSourceRange();
3768 }
3769 Info.DiagnoseAbstractType();
3770 }
3771};
3772
3773void AbstractUsageInfo::CheckType(const NamedDecl *D, TypeLoc TL,
3774 Sema::AbstractDiagSelID Sel) {
3775 CheckAbstractUsage(*this, D).Visit(TL, Sel);
3776}
3777
3778}
3779
3780/// Check for invalid uses of an abstract type in a method declaration.
3781static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
3782 CXXMethodDecl *MD) {
3783 // No need to do the check on definitions, which require that
3784 // the return/param types be complete.
Sean Hunt10620eb2011-05-06 20:44:56 +00003785 if (MD->doesThisDeclarationHaveABody())
John McCall94c3b562010-08-18 09:41:07 +00003786 return;
3787
3788 // For safety's sake, just ignore it if we don't have type source
3789 // information. This should never happen for non-implicit methods,
3790 // but...
3791 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
3792 Info.CheckType(MD, TSI->getTypeLoc(), Sema::AbstractNone);
3793}
3794
3795/// Check for invalid uses of an abstract type within a class definition.
3796static void CheckAbstractClassUsage(AbstractUsageInfo &Info,
3797 CXXRecordDecl *RD) {
3798 for (CXXRecordDecl::decl_iterator
3799 I = RD->decls_begin(), E = RD->decls_end(); I != E; ++I) {
3800 Decl *D = *I;
3801 if (D->isImplicit()) continue;
3802
3803 // Methods and method templates.
3804 if (isa<CXXMethodDecl>(D)) {
3805 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(D));
3806 } else if (isa<FunctionTemplateDecl>(D)) {
3807 FunctionDecl *FD = cast<FunctionTemplateDecl>(D)->getTemplatedDecl();
3808 CheckAbstractClassUsage(Info, cast<CXXMethodDecl>(FD));
3809
3810 // Fields and static variables.
3811 } else if (isa<FieldDecl>(D)) {
3812 FieldDecl *FD = cast<FieldDecl>(D);
3813 if (TypeSourceInfo *TSI = FD->getTypeSourceInfo())
3814 Info.CheckType(FD, TSI->getTypeLoc(), Sema::AbstractFieldType);
3815 } else if (isa<VarDecl>(D)) {
3816 VarDecl *VD = cast<VarDecl>(D);
3817 if (TypeSourceInfo *TSI = VD->getTypeSourceInfo())
3818 Info.CheckType(VD, TSI->getTypeLoc(), Sema::AbstractVariableType);
3819
3820 // Nested classes and class templates.
3821 } else if (isa<CXXRecordDecl>(D)) {
3822 CheckAbstractClassUsage(Info, cast<CXXRecordDecl>(D));
3823 } else if (isa<ClassTemplateDecl>(D)) {
3824 CheckAbstractClassUsage(Info,
3825 cast<ClassTemplateDecl>(D)->getTemplatedDecl());
3826 }
3827 }
Anders Carlsson8211eff2009-03-24 01:19:16 +00003828}
3829
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003830/// \brief Perform semantic checks on a class definition that has been
3831/// completing, introducing implicitly-declared members, checking for
3832/// abstract types, etc.
Douglas Gregor23c94db2010-07-02 17:43:08 +00003833void Sema::CheckCompletedCXXClass(CXXRecordDecl *Record) {
Douglas Gregor7a39dd02010-09-29 00:15:42 +00003834 if (!Record)
Douglas Gregor1ab537b2009-12-03 18:33:45 +00003835 return;
3836
John McCall94c3b562010-08-18 09:41:07 +00003837 if (Record->isAbstract() && !Record->isInvalidDecl()) {
3838 AbstractUsageInfo Info(*this, Record);
3839 CheckAbstractClassUsage(Info, Record);
3840 }
Douglas Gregor325e5932010-04-15 00:00:53 +00003841
3842 // If this is not an aggregate type and has no user-declared constructor,
3843 // complain about any non-static data members of reference or const scalar
3844 // type, since they will never get initializers.
3845 if (!Record->isInvalidDecl() && !Record->isDependentType() &&
Douglas Gregor5e058eb2012-02-09 02:20:38 +00003846 !Record->isAggregate() && !Record->hasUserDeclaredConstructor() &&
3847 !Record->isLambda()) {
Douglas Gregor325e5932010-04-15 00:00:53 +00003848 bool Complained = false;
3849 for (RecordDecl::field_iterator F = Record->field_begin(),
3850 FEnd = Record->field_end();
3851 F != FEnd; ++F) {
Douglas Gregord61db332011-10-10 17:22:13 +00003852 if (F->hasInClassInitializer() || F->isUnnamedBitfield())
Richard Smith7a614d82011-06-11 17:19:42 +00003853 continue;
3854
Douglas Gregor325e5932010-04-15 00:00:53 +00003855 if (F->getType()->isReferenceType() ||
Benjamin Kramer1deea662010-04-16 17:43:15 +00003856 (F->getType().isConstQualified() && F->getType()->isScalarType())) {
Douglas Gregor325e5932010-04-15 00:00:53 +00003857 if (!Complained) {
3858 Diag(Record->getLocation(), diag::warn_no_constructor_for_refconst)
3859 << Record->getTagKind() << Record;
3860 Complained = true;
3861 }
3862
3863 Diag(F->getLocation(), diag::note_refconst_member_not_initialized)
3864 << F->getType()->isReferenceType()
3865 << F->getDeclName();
3866 }
3867 }
3868 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +00003869
Anders Carlssona5c6c2a2011-01-25 18:08:22 +00003870 if (Record->isDynamicClass() && !Record->isDependentType())
Douglas Gregor6fb745b2010-05-13 16:44:06 +00003871 DynamicClasses.push_back(Record);
Douglas Gregora6e937c2010-10-15 13:21:21 +00003872
3873 if (Record->getIdentifier()) {
3874 // C++ [class.mem]p13:
3875 // If T is the name of a class, then each of the following shall have a
3876 // name different from T:
3877 // - every member of every anonymous union that is a member of class T.
3878 //
3879 // C++ [class.mem]p14:
3880 // In addition, if class T has a user-declared constructor (12.1), every
3881 // non-static data member of class T shall have a name different from T.
3882 for (DeclContext::lookup_result R = Record->lookup(Record->getDeclName());
Francois Pichet87c2e122010-11-21 06:08:52 +00003883 R.first != R.second; ++R.first) {
3884 NamedDecl *D = *R.first;
3885 if ((isa<FieldDecl>(D) && Record->hasUserDeclaredConstructor()) ||
3886 isa<IndirectFieldDecl>(D)) {
3887 Diag(D->getLocation(), diag::err_member_name_of_class)
3888 << D->getDeclName();
Douglas Gregora6e937c2010-10-15 13:21:21 +00003889 break;
3890 }
Francois Pichet87c2e122010-11-21 06:08:52 +00003891 }
Douglas Gregora6e937c2010-10-15 13:21:21 +00003892 }
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003893
Argyrios Kyrtzidis9641fc82011-01-31 17:10:25 +00003894 // Warn if the class has virtual methods but non-virtual public destructor.
Douglas Gregorf4b793c2011-02-19 19:14:36 +00003895 if (Record->isPolymorphic() && !Record->isDependentType()) {
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003896 CXXDestructorDecl *dtor = Record->getDestructor();
Argyrios Kyrtzidis9641fc82011-01-31 17:10:25 +00003897 if (!dtor || (!dtor->isVirtual() && dtor->getAccess() == AS_public))
Argyrios Kyrtzidisdef4e2a2011-01-31 07:05:00 +00003898 Diag(dtor ? dtor->getLocation() : Record->getLocation(),
3899 diag::warn_non_virtual_dtor) << Context.getRecordType(Record);
3900 }
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003901
David Blaikieb6b5b972012-09-21 03:21:07 +00003902 if (Record->isAbstract() && Record->hasAttr<FinalAttr>()) {
3903 Diag(Record->getLocation(), diag::warn_abstract_final_class);
3904 DiagnoseAbstractType(Record);
3905 }
3906
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003907 // See if a method overloads virtual methods in a base
3908 /// class without overriding any.
3909 if (!Record->isDependentType()) {
3910 for (CXXRecordDecl::method_iterator M = Record->method_begin(),
3911 MEnd = Record->method_end();
3912 M != MEnd; ++M) {
David Blaikie262bc182012-04-30 02:36:29 +00003913 if (!M->isStatic())
David Blaikie581deb32012-06-06 20:45:41 +00003914 DiagnoseHiddenVirtualMethods(Record, *M);
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00003915 }
3916 }
Sebastian Redlf677ea32011-02-05 19:23:19 +00003917
Richard Smith9f569cc2011-10-01 02:31:28 +00003918 // C++0x [dcl.constexpr]p8: A constexpr specifier for a non-static member
3919 // function that is not a constructor declares that member function to be
3920 // const. [...] The class of which that function is a member shall be
3921 // a literal type.
3922 //
Richard Smith9f569cc2011-10-01 02:31:28 +00003923 // If the class has virtual bases, any constexpr members will already have
3924 // been diagnosed by the checks performed on the member declaration, so
3925 // suppress this (less useful) diagnostic.
3926 if (LangOpts.CPlusPlus0x && !Record->isDependentType() &&
3927 !Record->isLiteral() && !Record->getNumVBases()) {
3928 for (CXXRecordDecl::method_iterator M = Record->method_begin(),
3929 MEnd = Record->method_end();
3930 M != MEnd; ++M) {
Richard Smith86c3ae42012-02-13 03:54:03 +00003931 if (M->isConstexpr() && M->isInstance() && !isa<CXXConstructorDecl>(*M)) {
Richard Smith9f569cc2011-10-01 02:31:28 +00003932 switch (Record->getTemplateSpecializationKind()) {
3933 case TSK_ImplicitInstantiation:
3934 case TSK_ExplicitInstantiationDeclaration:
3935 case TSK_ExplicitInstantiationDefinition:
3936 // If a template instantiates to a non-literal type, but its members
3937 // instantiate to constexpr functions, the template is technically
Richard Smith86c3ae42012-02-13 03:54:03 +00003938 // ill-formed, but we allow it for sanity.
Richard Smith9f569cc2011-10-01 02:31:28 +00003939 continue;
3940
3941 case TSK_Undeclared:
3942 case TSK_ExplicitSpecialization:
David Blaikie262bc182012-04-30 02:36:29 +00003943 RequireLiteralType(M->getLocation(), Context.getRecordType(Record),
Douglas Gregorf502d8e2012-05-04 16:48:41 +00003944 diag::err_constexpr_method_non_literal);
Richard Smith9f569cc2011-10-01 02:31:28 +00003945 break;
3946 }
3947
3948 // Only produce one error per class.
3949 break;
3950 }
3951 }
3952 }
3953
Sebastian Redlf677ea32011-02-05 19:23:19 +00003954 // Declare inherited constructors. We do this eagerly here because:
3955 // - The standard requires an eager diagnostic for conflicting inherited
3956 // constructors from different classes.
3957 // - The lazy declaration of the other implicit constructors is so as to not
3958 // waste space and performance on classes that are not meant to be
3959 // instantiated (e.g. meta-functions). This doesn't apply to classes that
3960 // have inherited constructors.
Sebastian Redlcaa35e42011-03-12 13:44:32 +00003961 DeclareInheritedConstructors(Record);
Sean Hunt001cad92011-05-10 00:49:42 +00003962}
3963
3964void Sema::CheckExplicitlyDefaultedMethods(CXXRecordDecl *Record) {
Sean Huntcb45a0f2011-05-12 22:46:25 +00003965 for (CXXRecordDecl::method_iterator MI = Record->method_begin(),
3966 ME = Record->method_end();
Richard Smith3003e1d2012-05-15 04:39:51 +00003967 MI != ME; ++MI)
3968 if (!MI->isInvalidDecl() && MI->isExplicitlyDefaulted())
David Blaikie581deb32012-06-06 20:45:41 +00003969 CheckExplicitlyDefaultedSpecialMember(*MI);
Sean Hunt001cad92011-05-10 00:49:42 +00003970}
3971
Richard Smith7756afa2012-06-10 05:43:50 +00003972/// Is the special member function which would be selected to perform the
3973/// specified operation on the specified class type a constexpr constructor?
3974static bool specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
3975 Sema::CXXSpecialMember CSM,
3976 bool ConstArg) {
3977 Sema::SpecialMemberOverloadResult *SMOR =
3978 S.LookupSpecialMember(ClassDecl, CSM, ConstArg,
3979 false, false, false, false);
3980 if (!SMOR || !SMOR->getMethod())
3981 // A constructor we wouldn't select can't be "involved in initializing"
3982 // anything.
3983 return true;
3984 return SMOR->getMethod()->isConstexpr();
3985}
3986
3987/// Determine whether the specified special member function would be constexpr
3988/// if it were implicitly defined.
3989static bool defaultedSpecialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
3990 Sema::CXXSpecialMember CSM,
3991 bool ConstArg) {
3992 if (!S.getLangOpts().CPlusPlus0x)
3993 return false;
3994
3995 // C++11 [dcl.constexpr]p4:
3996 // In the definition of a constexpr constructor [...]
3997 switch (CSM) {
3998 case Sema::CXXDefaultConstructor:
Richard Smithd3861ce2012-06-10 07:07:24 +00003999 // Since default constructor lookup is essentially trivial (and cannot
4000 // involve, for instance, template instantiation), we compute whether a
4001 // defaulted default constructor is constexpr directly within CXXRecordDecl.
4002 //
4003 // This is important for performance; we need to know whether the default
4004 // constructor is constexpr to determine whether the type is a literal type.
4005 return ClassDecl->defaultedDefaultConstructorIsConstexpr();
4006
Richard Smith7756afa2012-06-10 05:43:50 +00004007 case Sema::CXXCopyConstructor:
4008 case Sema::CXXMoveConstructor:
Richard Smithd3861ce2012-06-10 07:07:24 +00004009 // For copy or move constructors, we need to perform overload resolution.
Richard Smith7756afa2012-06-10 05:43:50 +00004010 break;
4011
4012 case Sema::CXXCopyAssignment:
4013 case Sema::CXXMoveAssignment:
4014 case Sema::CXXDestructor:
4015 case Sema::CXXInvalid:
4016 return false;
4017 }
4018
4019 // -- if the class is a non-empty union, or for each non-empty anonymous
4020 // union member of a non-union class, exactly one non-static data member
4021 // shall be initialized; [DR1359]
Richard Smithd3861ce2012-06-10 07:07:24 +00004022 //
4023 // If we squint, this is guaranteed, since exactly one non-static data member
4024 // will be initialized (if the constructor isn't deleted), we just don't know
4025 // which one.
Richard Smith7756afa2012-06-10 05:43:50 +00004026 if (ClassDecl->isUnion())
Richard Smithd3861ce2012-06-10 07:07:24 +00004027 return true;
Richard Smith7756afa2012-06-10 05:43:50 +00004028
4029 // -- the class shall not have any virtual base classes;
4030 if (ClassDecl->getNumVBases())
4031 return false;
4032
4033 // -- every constructor involved in initializing [...] base class
4034 // sub-objects shall be a constexpr constructor;
4035 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
4036 BEnd = ClassDecl->bases_end();
4037 B != BEnd; ++B) {
4038 const RecordType *BaseType = B->getType()->getAs<RecordType>();
4039 if (!BaseType) continue;
4040
4041 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
4042 if (!specialMemberIsConstexpr(S, BaseClassDecl, CSM, ConstArg))
4043 return false;
4044 }
4045
4046 // -- every constructor involved in initializing non-static data members
4047 // [...] shall be a constexpr constructor;
4048 // -- every non-static data member and base class sub-object shall be
4049 // initialized
4050 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
4051 FEnd = ClassDecl->field_end();
4052 F != FEnd; ++F) {
4053 if (F->isInvalidDecl())
4054 continue;
Richard Smithd3861ce2012-06-10 07:07:24 +00004055 if (const RecordType *RecordTy =
4056 S.Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
Richard Smith7756afa2012-06-10 05:43:50 +00004057 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
4058 if (!specialMemberIsConstexpr(S, FieldRecDecl, CSM, ConstArg))
4059 return false;
Richard Smith7756afa2012-06-10 05:43:50 +00004060 }
4061 }
4062
4063 // All OK, it's constexpr!
4064 return true;
4065}
4066
Richard Smithb9d0b762012-07-27 04:22:15 +00004067static Sema::ImplicitExceptionSpecification
4068computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, CXXMethodDecl *MD) {
4069 switch (S.getSpecialMember(MD)) {
4070 case Sema::CXXDefaultConstructor:
4071 return S.ComputeDefaultedDefaultCtorExceptionSpec(Loc, MD);
4072 case Sema::CXXCopyConstructor:
4073 return S.ComputeDefaultedCopyCtorExceptionSpec(MD);
4074 case Sema::CXXCopyAssignment:
4075 return S.ComputeDefaultedCopyAssignmentExceptionSpec(MD);
4076 case Sema::CXXMoveConstructor:
4077 return S.ComputeDefaultedMoveCtorExceptionSpec(MD);
4078 case Sema::CXXMoveAssignment:
4079 return S.ComputeDefaultedMoveAssignmentExceptionSpec(MD);
4080 case Sema::CXXDestructor:
4081 return S.ComputeDefaultedDtorExceptionSpec(MD);
4082 case Sema::CXXInvalid:
4083 break;
4084 }
4085 llvm_unreachable("only special members have implicit exception specs");
4086}
4087
Richard Smithdd25e802012-07-30 23:48:14 +00004088static void
4089updateExceptionSpec(Sema &S, FunctionDecl *FD, const FunctionProtoType *FPT,
4090 const Sema::ImplicitExceptionSpecification &ExceptSpec) {
4091 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
4092 ExceptSpec.getEPI(EPI);
4093 const FunctionProtoType *NewFPT = cast<FunctionProtoType>(
4094 S.Context.getFunctionType(FPT->getResultType(), FPT->arg_type_begin(),
4095 FPT->getNumArgs(), EPI));
4096 FD->setType(QualType(NewFPT, 0));
4097}
4098
Richard Smithb9d0b762012-07-27 04:22:15 +00004099void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD) {
4100 const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
4101 if (FPT->getExceptionSpecType() != EST_Unevaluated)
4102 return;
4103
Richard Smithdd25e802012-07-30 23:48:14 +00004104 // Evaluate the exception specification.
4105 ImplicitExceptionSpecification ExceptSpec =
4106 computeImplicitExceptionSpec(*this, Loc, MD);
4107
4108 // Update the type of the special member to use it.
4109 updateExceptionSpec(*this, MD, FPT, ExceptSpec);
4110
4111 // A user-provided destructor can be defined outside the class. When that
4112 // happens, be sure to update the exception specification on both
4113 // declarations.
4114 const FunctionProtoType *CanonicalFPT =
4115 MD->getCanonicalDecl()->getType()->castAs<FunctionProtoType>();
4116 if (CanonicalFPT->getExceptionSpecType() == EST_Unevaluated)
4117 updateExceptionSpec(*this, MD->getCanonicalDecl(),
4118 CanonicalFPT, ExceptSpec);
Richard Smithb9d0b762012-07-27 04:22:15 +00004119}
4120
4121static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl);
4122static bool isImplicitCopyAssignmentArgConst(Sema &S, CXXRecordDecl *ClassDecl);
4123
Richard Smith3003e1d2012-05-15 04:39:51 +00004124void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
4125 CXXRecordDecl *RD = MD->getParent();
4126 CXXSpecialMember CSM = getSpecialMember(MD);
Sean Hunt001cad92011-05-10 00:49:42 +00004127
Richard Smith3003e1d2012-05-15 04:39:51 +00004128 assert(MD->isExplicitlyDefaulted() && CSM != CXXInvalid &&
4129 "not an explicitly-defaulted special member");
Sean Hunt49634cf2011-05-13 06:10:58 +00004130
4131 // Whether this was the first-declared instance of the constructor.
Richard Smith3003e1d2012-05-15 04:39:51 +00004132 // This affects whether we implicitly add an exception spec and constexpr.
Sean Hunt2b188082011-05-14 05:23:28 +00004133 bool First = MD == MD->getCanonicalDecl();
4134
4135 bool HadError = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004136
4137 // C++11 [dcl.fct.def.default]p1:
4138 // A function that is explicitly defaulted shall
4139 // -- be a special member function (checked elsewhere),
4140 // -- have the same type (except for ref-qualifiers, and except that a
4141 // copy operation can take a non-const reference) as an implicit
4142 // declaration, and
4143 // -- not have default arguments.
4144 unsigned ExpectedParams = 1;
4145 if (CSM == CXXDefaultConstructor || CSM == CXXDestructor)
4146 ExpectedParams = 0;
4147 if (MD->getNumParams() != ExpectedParams) {
4148 // This also checks for default arguments: a copy or move constructor with a
4149 // default argument is classified as a default constructor, and assignment
4150 // operations and destructors can't have default arguments.
4151 Diag(MD->getLocation(), diag::err_defaulted_special_member_params)
4152 << CSM << MD->getSourceRange();
Sean Hunt2b188082011-05-14 05:23:28 +00004153 HadError = true;
4154 }
4155
Richard Smith3003e1d2012-05-15 04:39:51 +00004156 const FunctionProtoType *Type = MD->getType()->getAs<FunctionProtoType>();
Sean Hunt2b188082011-05-14 05:23:28 +00004157
Richard Smithb9d0b762012-07-27 04:22:15 +00004158 // Compute argument constness, constexpr, and triviality.
Richard Smith7756afa2012-06-10 05:43:50 +00004159 bool CanHaveConstParam = false;
Axel Naumann8f411c32012-09-17 14:26:53 +00004160 bool Trivial = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004161 switch (CSM) {
4162 case CXXDefaultConstructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004163 Trivial = RD->hasTrivialDefaultConstructor();
4164 break;
4165 case CXXCopyConstructor:
Richard Smithb9d0b762012-07-27 04:22:15 +00004166 CanHaveConstParam = isImplicitCopyCtorArgConst(*this, RD);
Richard Smith3003e1d2012-05-15 04:39:51 +00004167 Trivial = RD->hasTrivialCopyConstructor();
4168 break;
4169 case CXXCopyAssignment:
Richard Smithb9d0b762012-07-27 04:22:15 +00004170 CanHaveConstParam = isImplicitCopyAssignmentArgConst(*this, RD);
Richard Smith3003e1d2012-05-15 04:39:51 +00004171 Trivial = RD->hasTrivialCopyAssignment();
4172 break;
4173 case CXXMoveConstructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004174 Trivial = RD->hasTrivialMoveConstructor();
4175 break;
4176 case CXXMoveAssignment:
Richard Smith3003e1d2012-05-15 04:39:51 +00004177 Trivial = RD->hasTrivialMoveAssignment();
4178 break;
4179 case CXXDestructor:
Richard Smith3003e1d2012-05-15 04:39:51 +00004180 Trivial = RD->hasTrivialDestructor();
4181 break;
4182 case CXXInvalid:
4183 llvm_unreachable("non-special member explicitly defaulted!");
4184 }
Sean Hunt2b188082011-05-14 05:23:28 +00004185
Richard Smith3003e1d2012-05-15 04:39:51 +00004186 QualType ReturnType = Context.VoidTy;
4187 if (CSM == CXXCopyAssignment || CSM == CXXMoveAssignment) {
4188 // Check for return type matching.
4189 ReturnType = Type->getResultType();
4190 QualType ExpectedReturnType =
4191 Context.getLValueReferenceType(Context.getTypeDeclType(RD));
4192 if (!Context.hasSameType(ReturnType, ExpectedReturnType)) {
4193 Diag(MD->getLocation(), diag::err_defaulted_special_member_return_type)
4194 << (CSM == CXXMoveAssignment) << ExpectedReturnType;
4195 HadError = true;
4196 }
4197
4198 // A defaulted special member cannot have cv-qualifiers.
4199 if (Type->getTypeQuals()) {
4200 Diag(MD->getLocation(), diag::err_defaulted_special_member_quals)
4201 << (CSM == CXXMoveAssignment);
4202 HadError = true;
4203 }
4204 }
4205
4206 // Check for parameter type matching.
4207 QualType ArgType = ExpectedParams ? Type->getArgType(0) : QualType();
Richard Smith7756afa2012-06-10 05:43:50 +00004208 bool HasConstParam = false;
Richard Smith3003e1d2012-05-15 04:39:51 +00004209 if (ExpectedParams && ArgType->isReferenceType()) {
4210 // Argument must be reference to possibly-const T.
4211 QualType ReferentType = ArgType->getPointeeType();
Richard Smith7756afa2012-06-10 05:43:50 +00004212 HasConstParam = ReferentType.isConstQualified();
Richard Smith3003e1d2012-05-15 04:39:51 +00004213
4214 if (ReferentType.isVolatileQualified()) {
4215 Diag(MD->getLocation(),
4216 diag::err_defaulted_special_member_volatile_param) << CSM;
4217 HadError = true;
4218 }
4219
Richard Smith7756afa2012-06-10 05:43:50 +00004220 if (HasConstParam && !CanHaveConstParam) {
Richard Smith3003e1d2012-05-15 04:39:51 +00004221 if (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment) {
4222 Diag(MD->getLocation(),
4223 diag::err_defaulted_special_member_copy_const_param)
4224 << (CSM == CXXCopyAssignment);
4225 // FIXME: Explain why this special member can't be const.
4226 } else {
4227 Diag(MD->getLocation(),
4228 diag::err_defaulted_special_member_move_const_param)
4229 << (CSM == CXXMoveAssignment);
4230 }
4231 HadError = true;
4232 }
4233
4234 // If a function is explicitly defaulted on its first declaration, it shall
4235 // have the same parameter type as if it had been implicitly declared.
4236 // (Presumably this is to prevent it from being trivial?)
Richard Smith7756afa2012-06-10 05:43:50 +00004237 if (!HasConstParam && CanHaveConstParam && First)
Richard Smith3003e1d2012-05-15 04:39:51 +00004238 Diag(MD->getLocation(),
4239 diag::err_defaulted_special_member_copy_non_const_param)
4240 << (CSM == CXXCopyAssignment);
4241 } else if (ExpectedParams) {
4242 // A copy assignment operator can take its argument by value, but a
4243 // defaulted one cannot.
4244 assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
Sean Huntbe631222011-05-17 20:44:43 +00004245 Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
Sean Hunt2b188082011-05-14 05:23:28 +00004246 HadError = true;
4247 }
Sean Huntbe631222011-05-17 20:44:43 +00004248
Richard Smithb9d0b762012-07-27 04:22:15 +00004249 // Rebuild the type with the implicit exception specification added, if we
4250 // are going to need it.
4251 const FunctionProtoType *ImplicitType = 0;
4252 if (First || Type->hasExceptionSpec()) {
4253 FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
4254 computeImplicitExceptionSpec(*this, MD->getLocation(), MD).getEPI(EPI);
4255 ImplicitType = cast<FunctionProtoType>(
4256 Context.getFunctionType(ReturnType, &ArgType, ExpectedParams, EPI));
4257 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004258
Richard Smith61802452011-12-22 02:22:31 +00004259 // C++11 [dcl.fct.def.default]p2:
4260 // An explicitly-defaulted function may be declared constexpr only if it
4261 // would have been implicitly declared as constexpr,
Richard Smith3003e1d2012-05-15 04:39:51 +00004262 // Do not apply this rule to members of class templates, since core issue 1358
4263 // makes such functions always instantiate to constexpr functions. For
4264 // non-constructors, this is checked elsewhere.
Richard Smith7756afa2012-06-10 05:43:50 +00004265 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
4266 HasConstParam);
Richard Smith3003e1d2012-05-15 04:39:51 +00004267 if (isa<CXXConstructorDecl>(MD) && MD->isConstexpr() && !Constexpr &&
4268 MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
4269 Diag(MD->getLocStart(), diag::err_incorrect_defaulted_constexpr) << CSM;
Richard Smith7756afa2012-06-10 05:43:50 +00004270 // FIXME: Explain why the constructor can't be constexpr.
Richard Smith3003e1d2012-05-15 04:39:51 +00004271 HadError = true;
Richard Smith61802452011-12-22 02:22:31 +00004272 }
4273 // and may have an explicit exception-specification only if it is compatible
4274 // with the exception-specification on the implicit declaration.
Richard Smith3003e1d2012-05-15 04:39:51 +00004275 if (Type->hasExceptionSpec() &&
4276 CheckEquivalentExceptionSpec(
4277 PDiag(diag::err_incorrect_defaulted_exception_spec) << CSM,
4278 PDiag(), ImplicitType, SourceLocation(), Type, MD->getLocation()))
4279 HadError = true;
Richard Smith61802452011-12-22 02:22:31 +00004280
4281 // If a function is explicitly defaulted on its first declaration,
4282 if (First) {
4283 // -- it is implicitly considered to be constexpr if the implicit
4284 // definition would be,
Richard Smith3003e1d2012-05-15 04:39:51 +00004285 MD->setConstexpr(Constexpr);
Richard Smith61802452011-12-22 02:22:31 +00004286
Richard Smith3003e1d2012-05-15 04:39:51 +00004287 // -- it is implicitly considered to have the same exception-specification
4288 // as if it had been implicitly declared,
4289 MD->setType(QualType(ImplicitType, 0));
Richard Smithe653ba22012-02-26 00:31:33 +00004290
4291 // Such a function is also trivial if the implicitly-declared function
4292 // would have been.
Richard Smith3003e1d2012-05-15 04:39:51 +00004293 MD->setTrivial(Trivial);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004294 }
4295
Richard Smith3003e1d2012-05-15 04:39:51 +00004296 if (ShouldDeleteSpecialMember(MD, CSM)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004297 if (First) {
4298 MD->setDeletedAsWritten();
4299 } else {
Richard Smith3003e1d2012-05-15 04:39:51 +00004300 // C++11 [dcl.fct.def.default]p4:
4301 // [For a] user-provided explicitly-defaulted function [...] if such a
4302 // function is implicitly defined as deleted, the program is ill-formed.
4303 Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;
4304 HadError = true;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004305 }
4306 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00004307
Richard Smith3003e1d2012-05-15 04:39:51 +00004308 if (HadError)
4309 MD->setInvalidDecl();
Sean Huntcb45a0f2011-05-12 22:46:25 +00004310}
4311
Richard Smith7d5088a2012-02-18 02:02:13 +00004312namespace {
4313struct SpecialMemberDeletionInfo {
4314 Sema &S;
4315 CXXMethodDecl *MD;
4316 Sema::CXXSpecialMember CSM;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004317 bool Diagnose;
Richard Smith7d5088a2012-02-18 02:02:13 +00004318
4319 // Properties of the special member, computed for convenience.
4320 bool IsConstructor, IsAssignment, IsMove, ConstArg, VolatileArg;
4321 SourceLocation Loc;
4322
4323 bool AllFieldsAreConst;
4324
4325 SpecialMemberDeletionInfo(Sema &S, CXXMethodDecl *MD,
Richard Smith6c4c36c2012-03-30 20:53:28 +00004326 Sema::CXXSpecialMember CSM, bool Diagnose)
4327 : S(S), MD(MD), CSM(CSM), Diagnose(Diagnose),
Richard Smith7d5088a2012-02-18 02:02:13 +00004328 IsConstructor(false), IsAssignment(false), IsMove(false),
4329 ConstArg(false), VolatileArg(false), Loc(MD->getLocation()),
4330 AllFieldsAreConst(true) {
4331 switch (CSM) {
4332 case Sema::CXXDefaultConstructor:
4333 case Sema::CXXCopyConstructor:
4334 IsConstructor = true;
4335 break;
4336 case Sema::CXXMoveConstructor:
4337 IsConstructor = true;
4338 IsMove = true;
4339 break;
4340 case Sema::CXXCopyAssignment:
4341 IsAssignment = true;
4342 break;
4343 case Sema::CXXMoveAssignment:
4344 IsAssignment = true;
4345 IsMove = true;
4346 break;
4347 case Sema::CXXDestructor:
4348 break;
4349 case Sema::CXXInvalid:
4350 llvm_unreachable("invalid special member kind");
4351 }
4352
4353 if (MD->getNumParams()) {
4354 ConstArg = MD->getParamDecl(0)->getType().isConstQualified();
4355 VolatileArg = MD->getParamDecl(0)->getType().isVolatileQualified();
4356 }
4357 }
4358
4359 bool inUnion() const { return MD->getParent()->isUnion(); }
4360
4361 /// Look up the corresponding special member in the given class.
Richard Smith517bb842012-07-18 03:51:16 +00004362 Sema::SpecialMemberOverloadResult *lookupIn(CXXRecordDecl *Class,
4363 unsigned Quals) {
Richard Smith7d5088a2012-02-18 02:02:13 +00004364 unsigned TQ = MD->getTypeQualifiers();
Richard Smith517bb842012-07-18 03:51:16 +00004365 // cv-qualifiers on class members don't affect default ctor / dtor calls.
4366 if (CSM == Sema::CXXDefaultConstructor || CSM == Sema::CXXDestructor)
4367 Quals = 0;
4368 return S.LookupSpecialMember(Class, CSM,
4369 ConstArg || (Quals & Qualifiers::Const),
4370 VolatileArg || (Quals & Qualifiers::Volatile),
Richard Smith7d5088a2012-02-18 02:02:13 +00004371 MD->getRefQualifier() == RQ_RValue,
4372 TQ & Qualifiers::Const,
4373 TQ & Qualifiers::Volatile);
4374 }
4375
Richard Smith6c4c36c2012-03-30 20:53:28 +00004376 typedef llvm::PointerUnion<CXXBaseSpecifier*, FieldDecl*> Subobject;
Richard Smith9a561d52012-02-26 09:11:52 +00004377
Richard Smith6c4c36c2012-03-30 20:53:28 +00004378 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
Richard Smith7d5088a2012-02-18 02:02:13 +00004379 bool shouldDeleteForField(FieldDecl *FD);
4380 bool shouldDeleteForAllConstMembers();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004381
Richard Smith517bb842012-07-18 03:51:16 +00004382 bool shouldDeleteForClassSubobject(CXXRecordDecl *Class, Subobject Subobj,
4383 unsigned Quals);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004384 bool shouldDeleteForSubobjectCall(Subobject Subobj,
4385 Sema::SpecialMemberOverloadResult *SMOR,
4386 bool IsDtorCallInCtor);
John McCall12d8d802012-04-09 20:53:23 +00004387
4388 bool isAccessible(Subobject Subobj, CXXMethodDecl *D);
Richard Smith7d5088a2012-02-18 02:02:13 +00004389};
4390}
4391
John McCall12d8d802012-04-09 20:53:23 +00004392/// Is the given special member inaccessible when used on the given
4393/// sub-object.
4394bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj,
4395 CXXMethodDecl *target) {
4396 /// If we're operating on a base class, the object type is the
4397 /// type of this special member.
4398 QualType objectTy;
Dmitri Gribenko1ad23d62012-09-10 21:20:09 +00004399 AccessSpecifier access = target->getAccess();
John McCall12d8d802012-04-09 20:53:23 +00004400 if (CXXBaseSpecifier *base = Subobj.dyn_cast<CXXBaseSpecifier*>()) {
4401 objectTy = S.Context.getTypeDeclType(MD->getParent());
4402 access = CXXRecordDecl::MergeAccess(base->getAccessSpecifier(), access);
4403
4404 // If we're operating on a field, the object type is the type of the field.
4405 } else {
4406 objectTy = S.Context.getTypeDeclType(target->getParent());
4407 }
4408
4409 return S.isSpecialMemberAccessibleForDeletion(target, access, objectTy);
4410}
4411
Richard Smith6c4c36c2012-03-30 20:53:28 +00004412/// Check whether we should delete a special member due to the implicit
4413/// definition containing a call to a special member of a subobject.
4414bool SpecialMemberDeletionInfo::shouldDeleteForSubobjectCall(
4415 Subobject Subobj, Sema::SpecialMemberOverloadResult *SMOR,
4416 bool IsDtorCallInCtor) {
4417 CXXMethodDecl *Decl = SMOR->getMethod();
4418 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
4419
4420 int DiagKind = -1;
4421
4422 if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::NoMemberOrDeleted)
4423 DiagKind = !Decl ? 0 : 1;
4424 else if (SMOR->getKind() == Sema::SpecialMemberOverloadResult::Ambiguous)
4425 DiagKind = 2;
John McCall12d8d802012-04-09 20:53:23 +00004426 else if (!isAccessible(Subobj, Decl))
Richard Smith6c4c36c2012-03-30 20:53:28 +00004427 DiagKind = 3;
4428 else if (!IsDtorCallInCtor && Field && Field->getParent()->isUnion() &&
4429 !Decl->isTrivial()) {
4430 // A member of a union must have a trivial corresponding special member.
4431 // As a weird special case, a destructor call from a union's constructor
4432 // must be accessible and non-deleted, but need not be trivial. Such a
4433 // destructor is never actually called, but is semantically checked as
4434 // if it were.
4435 DiagKind = 4;
4436 }
4437
4438 if (DiagKind == -1)
4439 return false;
4440
4441 if (Diagnose) {
4442 if (Field) {
4443 S.Diag(Field->getLocation(),
4444 diag::note_deleted_special_member_class_subobject)
4445 << CSM << MD->getParent() << /*IsField*/true
4446 << Field << DiagKind << IsDtorCallInCtor;
4447 } else {
4448 CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
4449 S.Diag(Base->getLocStart(),
4450 diag::note_deleted_special_member_class_subobject)
4451 << CSM << MD->getParent() << /*IsField*/false
4452 << Base->getType() << DiagKind << IsDtorCallInCtor;
4453 }
4454
4455 if (DiagKind == 1)
4456 S.NoteDeletedFunction(Decl);
4457 // FIXME: Explain inaccessibility if DiagKind == 3.
4458 }
4459
4460 return true;
4461}
4462
Richard Smith9a561d52012-02-26 09:11:52 +00004463/// Check whether we should delete a special member function due to having a
Richard Smith517bb842012-07-18 03:51:16 +00004464/// direct or virtual base class or non-static data member of class type M.
Richard Smith9a561d52012-02-26 09:11:52 +00004465bool SpecialMemberDeletionInfo::shouldDeleteForClassSubobject(
Richard Smith517bb842012-07-18 03:51:16 +00004466 CXXRecordDecl *Class, Subobject Subobj, unsigned Quals) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00004467 FieldDecl *Field = Subobj.dyn_cast<FieldDecl*>();
Richard Smith7d5088a2012-02-18 02:02:13 +00004468
4469 // C++11 [class.ctor]p5:
Richard Smithdf8dc862012-03-29 19:00:10 +00004470 // -- any direct or virtual base class, or non-static data member with no
4471 // brace-or-equal-initializer, has class type M (or array thereof) and
Richard Smith7d5088a2012-02-18 02:02:13 +00004472 // either M has no default constructor or overload resolution as applied
4473 // to M's default constructor results in an ambiguity or in a function
4474 // that is deleted or inaccessible
4475 // C++11 [class.copy]p11, C++11 [class.copy]p23:
4476 // -- a direct or virtual base class B that cannot be copied/moved because
4477 // overload resolution, as applied to B's corresponding special member,
4478 // results in an ambiguity or a function that is deleted or inaccessible
4479 // from the defaulted special member
Richard Smith6c4c36c2012-03-30 20:53:28 +00004480 // C++11 [class.dtor]p5:
4481 // -- any direct or virtual base class [...] has a type with a destructor
4482 // that is deleted or inaccessible
4483 if (!(CSM == Sema::CXXDefaultConstructor &&
Richard Smith1c931be2012-04-02 18:40:40 +00004484 Field && Field->hasInClassInitializer()) &&
Richard Smith517bb842012-07-18 03:51:16 +00004485 shouldDeleteForSubobjectCall(Subobj, lookupIn(Class, Quals), false))
Richard Smith1c931be2012-04-02 18:40:40 +00004486 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004487
Richard Smith6c4c36c2012-03-30 20:53:28 +00004488 // C++11 [class.ctor]p5, C++11 [class.copy]p11:
4489 // -- any direct or virtual base class or non-static data member has a
4490 // type with a destructor that is deleted or inaccessible
4491 if (IsConstructor) {
4492 Sema::SpecialMemberOverloadResult *SMOR =
4493 S.LookupSpecialMember(Class, Sema::CXXDestructor,
4494 false, false, false, false, false);
4495 if (shouldDeleteForSubobjectCall(Subobj, SMOR, true))
4496 return true;
4497 }
4498
Richard Smith9a561d52012-02-26 09:11:52 +00004499 return false;
4500}
4501
4502/// Check whether we should delete a special member function due to the class
4503/// having a particular direct or virtual base class.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004504bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
Richard Smith1c931be2012-04-02 18:40:40 +00004505 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
Richard Smith517bb842012-07-18 03:51:16 +00004506 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
Richard Smith7d5088a2012-02-18 02:02:13 +00004507}
4508
4509/// Check whether we should delete a special member function due to the class
4510/// having a particular non-static data member.
4511bool SpecialMemberDeletionInfo::shouldDeleteForField(FieldDecl *FD) {
4512 QualType FieldType = S.Context.getBaseElementType(FD->getType());
4513 CXXRecordDecl *FieldRecord = FieldType->getAsCXXRecordDecl();
4514
4515 if (CSM == Sema::CXXDefaultConstructor) {
4516 // For a default constructor, all references must be initialized in-class
4517 // and, if a union, it must have a non-const member.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004518 if (FieldType->isReferenceType() && !FD->hasInClassInitializer()) {
4519 if (Diagnose)
4520 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
4521 << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smith7d5088a2012-02-18 02:02:13 +00004522 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004523 }
Richard Smith79363f52012-02-27 06:07:25 +00004524 // C++11 [class.ctor]p5: any non-variant non-static data member of
4525 // const-qualified type (or array thereof) with no
4526 // brace-or-equal-initializer does not have a user-provided default
4527 // constructor.
4528 if (!inUnion() && FieldType.isConstQualified() &&
4529 !FD->hasInClassInitializer() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004530 (!FieldRecord || !FieldRecord->hasUserProvidedDefaultConstructor())) {
4531 if (Diagnose)
4532 S.Diag(FD->getLocation(), diag::note_deleted_default_ctor_uninit_field)
Richard Smitha2e76f52012-04-29 06:32:34 +00004533 << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith79363f52012-02-27 06:07:25 +00004534 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004535 }
4536
4537 if (inUnion() && !FieldType.isConstQualified())
4538 AllFieldsAreConst = false;
Richard Smith7d5088a2012-02-18 02:02:13 +00004539 } else if (CSM == Sema::CXXCopyConstructor) {
4540 // For a copy constructor, data members must not be of rvalue reference
4541 // type.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004542 if (FieldType->isRValueReferenceType()) {
4543 if (Diagnose)
4544 S.Diag(FD->getLocation(), diag::note_deleted_copy_ctor_rvalue_reference)
4545 << MD->getParent() << FD << FieldType;
Richard Smith7d5088a2012-02-18 02:02:13 +00004546 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004547 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004548 } else if (IsAssignment) {
4549 // For an assignment operator, data members must not be of reference type.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004550 if (FieldType->isReferenceType()) {
4551 if (Diagnose)
4552 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
4553 << IsMove << MD->getParent() << FD << FieldType << /*Reference*/0;
Richard Smith7d5088a2012-02-18 02:02:13 +00004554 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004555 }
4556 if (!FieldRecord && FieldType.isConstQualified()) {
4557 // C++11 [class.copy]p23:
4558 // -- a non-static data member of const non-class type (or array thereof)
4559 if (Diagnose)
4560 S.Diag(FD->getLocation(), diag::note_deleted_assign_field)
Richard Smitha2e76f52012-04-29 06:32:34 +00004561 << IsMove << MD->getParent() << FD << FD->getType() << /*Const*/1;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004562 return true;
4563 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004564 }
4565
4566 if (FieldRecord) {
Richard Smith7d5088a2012-02-18 02:02:13 +00004567 // Some additional restrictions exist on the variant members.
4568 if (!inUnion() && FieldRecord->isUnion() &&
4569 FieldRecord->isAnonymousStructOrUnion()) {
4570 bool AllVariantFieldsAreConst = true;
4571
Richard Smithdf8dc862012-03-29 19:00:10 +00004572 // FIXME: Handle anonymous unions declared within anonymous unions.
Richard Smith7d5088a2012-02-18 02:02:13 +00004573 for (CXXRecordDecl::field_iterator UI = FieldRecord->field_begin(),
4574 UE = FieldRecord->field_end();
4575 UI != UE; ++UI) {
4576 QualType UnionFieldType = S.Context.getBaseElementType(UI->getType());
Richard Smith7d5088a2012-02-18 02:02:13 +00004577
4578 if (!UnionFieldType.isConstQualified())
4579 AllVariantFieldsAreConst = false;
4580
Richard Smith9a561d52012-02-26 09:11:52 +00004581 CXXRecordDecl *UnionFieldRecord = UnionFieldType->getAsCXXRecordDecl();
4582 if (UnionFieldRecord &&
Richard Smith517bb842012-07-18 03:51:16 +00004583 shouldDeleteForClassSubobject(UnionFieldRecord, *UI,
4584 UnionFieldType.getCVRQualifiers()))
Richard Smith9a561d52012-02-26 09:11:52 +00004585 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004586 }
4587
4588 // At least one member in each anonymous union must be non-const
Douglas Gregor221c27f2012-02-24 21:25:53 +00004589 if (CSM == Sema::CXXDefaultConstructor && AllVariantFieldsAreConst &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004590 FieldRecord->field_begin() != FieldRecord->field_end()) {
4591 if (Diagnose)
4592 S.Diag(FieldRecord->getLocation(),
4593 diag::note_deleted_default_ctor_all_const)
4594 << MD->getParent() << /*anonymous union*/1;
Richard Smith7d5088a2012-02-18 02:02:13 +00004595 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004596 }
Richard Smith7d5088a2012-02-18 02:02:13 +00004597
Richard Smithdf8dc862012-03-29 19:00:10 +00004598 // Don't check the implicit member of the anonymous union type.
Richard Smith7d5088a2012-02-18 02:02:13 +00004599 // This is technically non-conformant, but sanity demands it.
4600 return false;
4601 }
4602
Richard Smith517bb842012-07-18 03:51:16 +00004603 if (shouldDeleteForClassSubobject(FieldRecord, FD,
4604 FieldType.getCVRQualifiers()))
Richard Smithdf8dc862012-03-29 19:00:10 +00004605 return true;
Richard Smith7d5088a2012-02-18 02:02:13 +00004606 }
4607
4608 return false;
4609}
4610
4611/// C++11 [class.ctor] p5:
4612/// A defaulted default constructor for a class X is defined as deleted if
4613/// X is a union and all of its variant members are of const-qualified type.
4614bool SpecialMemberDeletionInfo::shouldDeleteForAllConstMembers() {
Douglas Gregor221c27f2012-02-24 21:25:53 +00004615 // This is a silly definition, because it gives an empty union a deleted
4616 // default constructor. Don't do that.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004617 if (CSM == Sema::CXXDefaultConstructor && inUnion() && AllFieldsAreConst &&
4618 (MD->getParent()->field_begin() != MD->getParent()->field_end())) {
4619 if (Diagnose)
4620 S.Diag(MD->getParent()->getLocation(),
4621 diag::note_deleted_default_ctor_all_const)
4622 << MD->getParent() << /*not anonymous union*/0;
4623 return true;
4624 }
4625 return false;
Richard Smith7d5088a2012-02-18 02:02:13 +00004626}
4627
4628/// Determine whether a defaulted special member function should be defined as
4629/// deleted, as specified in C++11 [class.ctor]p5, C++11 [class.copy]p11,
4630/// C++11 [class.copy]p23, and C++11 [class.dtor]p5.
Richard Smith6c4c36c2012-03-30 20:53:28 +00004631bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
4632 bool Diagnose) {
Richard Smitheef00292012-08-06 02:25:10 +00004633 if (MD->isInvalidDecl())
4634 return false;
Sean Hunte16da072011-10-10 06:18:57 +00004635 CXXRecordDecl *RD = MD->getParent();
Sean Huntcdee3fe2011-05-11 22:34:38 +00004636 assert(!RD->isDependentType() && "do deletion after instantiation");
Abramo Bagnaracdb80762011-07-11 08:52:40 +00004637 if (!LangOpts.CPlusPlus0x || RD->isInvalidDecl())
Sean Huntcdee3fe2011-05-11 22:34:38 +00004638 return false;
4639
Richard Smith7d5088a2012-02-18 02:02:13 +00004640 // C++11 [expr.lambda.prim]p19:
4641 // The closure type associated with a lambda-expression has a
4642 // deleted (8.4.3) default constructor and a deleted copy
4643 // assignment operator.
4644 if (RD->isLambda() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004645 (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
4646 if (Diagnose)
4647 Diag(RD->getLocation(), diag::note_lambda_decl);
Richard Smith7d5088a2012-02-18 02:02:13 +00004648 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004649 }
4650
Richard Smith5bdaac52012-04-02 20:59:25 +00004651 // For an anonymous struct or union, the copy and assignment special members
4652 // will never be used, so skip the check. For an anonymous union declared at
4653 // namespace scope, the constructor and destructor are used.
4654 if (CSM != CXXDefaultConstructor && CSM != CXXDestructor &&
4655 RD->isAnonymousStructOrUnion())
4656 return false;
4657
Richard Smith6c4c36c2012-03-30 20:53:28 +00004658 // C++11 [class.copy]p7, p18:
4659 // If the class definition declares a move constructor or move assignment
4660 // operator, an implicitly declared copy constructor or copy assignment
4661 // operator is defined as deleted.
4662 if (MD->isImplicit() &&
4663 (CSM == CXXCopyConstructor || CSM == CXXCopyAssignment)) {
4664 CXXMethodDecl *UserDeclaredMove = 0;
4665
4666 // In Microsoft mode, a user-declared move only causes the deletion of the
4667 // corresponding copy operation, not both copy operations.
4668 if (RD->hasUserDeclaredMoveConstructor() &&
4669 (!getLangOpts().MicrosoftMode || CSM == CXXCopyConstructor)) {
4670 if (!Diagnose) return true;
4671 UserDeclaredMove = RD->getMoveConstructor();
Richard Smith1c931be2012-04-02 18:40:40 +00004672 assert(UserDeclaredMove);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004673 } else if (RD->hasUserDeclaredMoveAssignment() &&
4674 (!getLangOpts().MicrosoftMode || CSM == CXXCopyAssignment)) {
4675 if (!Diagnose) return true;
4676 UserDeclaredMove = RD->getMoveAssignmentOperator();
Richard Smith1c931be2012-04-02 18:40:40 +00004677 assert(UserDeclaredMove);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004678 }
4679
4680 if (UserDeclaredMove) {
4681 Diag(UserDeclaredMove->getLocation(),
4682 diag::note_deleted_copy_user_declared_move)
Richard Smithe6af6602012-04-02 21:07:48 +00004683 << (CSM == CXXCopyAssignment) << RD
Richard Smith6c4c36c2012-03-30 20:53:28 +00004684 << UserDeclaredMove->isMoveAssignmentOperator();
4685 return true;
4686 }
4687 }
Sean Hunte16da072011-10-10 06:18:57 +00004688
Richard Smith5bdaac52012-04-02 20:59:25 +00004689 // Do access control from the special member function
4690 ContextRAII MethodContext(*this, MD);
4691
Richard Smith9a561d52012-02-26 09:11:52 +00004692 // C++11 [class.dtor]p5:
4693 // -- for a virtual destructor, lookup of the non-array deallocation function
4694 // results in an ambiguity or in a function that is deleted or inaccessible
Richard Smith6c4c36c2012-03-30 20:53:28 +00004695 if (CSM == CXXDestructor && MD->isVirtual()) {
Richard Smith9a561d52012-02-26 09:11:52 +00004696 FunctionDecl *OperatorDelete = 0;
4697 DeclarationName Name =
4698 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
4699 if (FindDeallocationFunction(MD->getLocation(), MD->getParent(), Name,
Richard Smith6c4c36c2012-03-30 20:53:28 +00004700 OperatorDelete, false)) {
4701 if (Diagnose)
4702 Diag(RD->getLocation(), diag::note_deleted_dtor_no_operator_delete);
Richard Smith9a561d52012-02-26 09:11:52 +00004703 return true;
Richard Smith6c4c36c2012-03-30 20:53:28 +00004704 }
Richard Smith9a561d52012-02-26 09:11:52 +00004705 }
4706
Richard Smith6c4c36c2012-03-30 20:53:28 +00004707 SpecialMemberDeletionInfo SMI(*this, MD, CSM, Diagnose);
Sean Huntcdee3fe2011-05-11 22:34:38 +00004708
Sean Huntcdee3fe2011-05-11 22:34:38 +00004709 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004710 BE = RD->bases_end(); BI != BE; ++BI)
4711 if (!BI->isVirtual() &&
Richard Smith6c4c36c2012-03-30 20:53:28 +00004712 SMI.shouldDeleteForBase(BI))
Richard Smith7d5088a2012-02-18 02:02:13 +00004713 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004714
4715 for (CXXRecordDecl::base_class_iterator BI = RD->vbases_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004716 BE = RD->vbases_end(); BI != BE; ++BI)
Richard Smith6c4c36c2012-03-30 20:53:28 +00004717 if (SMI.shouldDeleteForBase(BI))
Richard Smith7d5088a2012-02-18 02:02:13 +00004718 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004719
4720 for (CXXRecordDecl::field_iterator FI = RD->field_begin(),
Richard Smith7d5088a2012-02-18 02:02:13 +00004721 FE = RD->field_end(); FI != FE; ++FI)
4722 if (!FI->isInvalidDecl() && !FI->isUnnamedBitfield() &&
David Blaikie581deb32012-06-06 20:45:41 +00004723 SMI.shouldDeleteForField(*FI))
Sean Hunte3406822011-05-20 21:43:47 +00004724 return true;
Sean Huntcdee3fe2011-05-11 22:34:38 +00004725
Richard Smith7d5088a2012-02-18 02:02:13 +00004726 if (SMI.shouldDeleteForAllConstMembers())
Sean Huntcdee3fe2011-05-11 22:34:38 +00004727 return true;
4728
4729 return false;
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004730}
4731
4732/// \brief Data used with FindHiddenVirtualMethod
Benjamin Kramerc54061a2011-03-04 13:12:48 +00004733namespace {
4734 struct FindHiddenVirtualMethodData {
4735 Sema *S;
4736 CXXMethodDecl *Method;
4737 llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverridenAndUsingBaseMethods;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004738 SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
Benjamin Kramerc54061a2011-03-04 13:12:48 +00004739 };
4740}
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004741
4742/// \brief Member lookup function that determines whether a given C++
4743/// method overloads virtual methods in a base class without overriding any,
4744/// to be used with CXXRecordDecl::lookupInBases().
4745static bool FindHiddenVirtualMethod(const CXXBaseSpecifier *Specifier,
4746 CXXBasePath &Path,
4747 void *UserData) {
4748 RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
4749
4750 FindHiddenVirtualMethodData &Data
4751 = *static_cast<FindHiddenVirtualMethodData*>(UserData);
4752
4753 DeclarationName Name = Data.Method->getDeclName();
4754 assert(Name.getNameKind() == DeclarationName::Identifier);
4755
4756 bool foundSameNameMethod = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00004757 SmallVector<CXXMethodDecl *, 8> overloadedMethods;
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004758 for (Path.Decls = BaseRecord->lookup(Name);
4759 Path.Decls.first != Path.Decls.second;
4760 ++Path.Decls.first) {
4761 NamedDecl *D = *Path.Decls.first;
4762 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004763 MD = MD->getCanonicalDecl();
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004764 foundSameNameMethod = true;
4765 // Interested only in hidden virtual methods.
4766 if (!MD->isVirtual())
4767 continue;
4768 // If the method we are checking overrides a method from its base
4769 // don't warn about the other overloaded methods.
4770 if (!Data.S->IsOverload(Data.Method, MD, false))
4771 return true;
4772 // Collect the overload only if its hidden.
4773 if (!Data.OverridenAndUsingBaseMethods.count(MD))
4774 overloadedMethods.push_back(MD);
4775 }
4776 }
4777
4778 if (foundSameNameMethod)
4779 Data.OverloadedMethods.append(overloadedMethods.begin(),
4780 overloadedMethods.end());
4781 return foundSameNameMethod;
4782}
4783
4784/// \brief See if a method overloads virtual methods in a base class without
4785/// overriding any.
4786void Sema::DiagnoseHiddenVirtualMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
4787 if (Diags.getDiagnosticLevel(diag::warn_overloaded_virtual,
David Blaikied6471f72011-09-25 23:23:43 +00004788 MD->getLocation()) == DiagnosticsEngine::Ignored)
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004789 return;
Benjamin Kramerc4704422012-05-19 16:03:58 +00004790 if (!MD->getDeclName().isIdentifier())
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004791 return;
4792
4793 CXXBasePaths Paths(/*FindAmbiguities=*/true, // true to look in all bases.
4794 /*bool RecordPaths=*/false,
4795 /*bool DetectVirtual=*/false);
4796 FindHiddenVirtualMethodData Data;
4797 Data.Method = MD;
4798 Data.S = this;
4799
4800 // Keep the base methods that were overriden or introduced in the subclass
4801 // by 'using' in a set. A base method not in this set is hidden.
4802 for (DeclContext::lookup_result res = DC->lookup(MD->getDeclName());
4803 res.first != res.second; ++res.first) {
4804 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*res.first))
4805 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
4806 E = MD->end_overridden_methods();
4807 I != E; ++I)
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004808 Data.OverridenAndUsingBaseMethods.insert((*I)->getCanonicalDecl());
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004809 if (UsingShadowDecl *shad = dyn_cast<UsingShadowDecl>(*res.first))
4810 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(shad->getTargetDecl()))
Argyrios Kyrtzidis74b47f92011-02-10 18:13:41 +00004811 Data.OverridenAndUsingBaseMethods.insert(MD->getCanonicalDecl());
Argyrios Kyrtzidis799ef662011-02-03 18:01:15 +00004812 }
4813
4814 if (DC->lookupInBases(&FindHiddenVirtualMethod, &Data, Paths) &&
4815 !Data.OverloadedMethods.empty()) {
4816 Diag(MD->getLocation(), diag::warn_overloaded_virtual)
4817 << MD << (Data.OverloadedMethods.size() > 1);
4818
4819 for (unsigned i = 0, e = Data.OverloadedMethods.size(); i != e; ++i) {
4820 CXXMethodDecl *overloadedMD = Data.OverloadedMethods[i];
4821 Diag(overloadedMD->getLocation(),
4822 diag::note_hidden_overloaded_virtual_declared_here) << overloadedMD;
4823 }
4824 }
Douglas Gregor1ab537b2009-12-03 18:33:45 +00004825}
4826
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004827void Sema::ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
John McCalld226f652010-08-21 09:40:31 +00004828 Decl *TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004829 SourceLocation LBrac,
Douglas Gregor0b4c9b52010-03-29 14:42:08 +00004830 SourceLocation RBrac,
4831 AttributeList *AttrList) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004832 if (!TagDecl)
4833 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004834
Douglas Gregor42af25f2009-05-11 19:58:34 +00004835 AdjustDeclIfTemplate(TagDecl);
Douglas Gregor1ab537b2009-12-03 18:33:45 +00004836
Rafael Espindolaf729ce02012-07-12 04:32:30 +00004837 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
4838 if (l->getKind() != AttributeList::AT_Visibility)
4839 continue;
4840 l->setInvalid();
4841 Diag(l->getLoc(), diag::warn_attribute_after_definition_ignored) <<
4842 l->getName();
4843 }
4844
David Blaikie77b6de02011-09-22 02:58:26 +00004845 ActOnFields(S, RLoc, TagDecl, llvm::makeArrayRef(
John McCalld226f652010-08-21 09:40:31 +00004846 // strict aliasing violation!
4847 reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
David Blaikie77b6de02011-09-22 02:58:26 +00004848 FieldCollector->getCurNumFields()), LBrac, RBrac, AttrList);
Douglas Gregor2943aed2009-03-03 04:44:36 +00004849
Douglas Gregor23c94db2010-07-02 17:43:08 +00004850 CheckCompletedCXXClass(
John McCalld226f652010-08-21 09:40:31 +00004851 dyn_cast_or_null<CXXRecordDecl>(TagDecl));
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00004852}
4853
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004854/// AddImplicitlyDeclaredMembersToClass - Adds any implicitly-declared
4855/// special functions, such as the default constructor, copy
4856/// constructor, or destructor, to the given C++ class (C++
4857/// [special]p1). This routine can only be executed just before the
4858/// definition of the class is complete.
Douglas Gregor23c94db2010-07-02 17:43:08 +00004859void Sema::AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl) {
Douglas Gregor32df23e2010-07-01 22:02:46 +00004860 if (!ClassDecl->hasUserDeclaredConstructor())
Douglas Gregor18274032010-07-03 00:47:00 +00004861 ++ASTContext::NumImplicitDefaultConstructors;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004862
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00004863 if (!ClassDecl->hasUserDeclaredCopyConstructor())
Douglas Gregor22584312010-07-02 23:41:54 +00004864 ++ASTContext::NumImplicitCopyConstructors;
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004865
David Blaikie4e4d0842012-03-11 07:00:24 +00004866 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveConstructor())
Richard Smithb701d3d2011-12-24 21:56:24 +00004867 ++ASTContext::NumImplicitMoveConstructors;
4868
Douglas Gregora376d102010-07-02 21:50:04 +00004869 if (!ClassDecl->hasUserDeclaredCopyAssignment()) {
4870 ++ASTContext::NumImplicitCopyAssignmentOperators;
4871
4872 // If we have a dynamic class, then the copy assignment operator may be
4873 // virtual, so we have to declare it immediately. This ensures that, e.g.,
4874 // it shows up in the right place in the vtable and that we diagnose
4875 // problems with the implicit exception specification.
4876 if (ClassDecl->isDynamicClass())
4877 DeclareImplicitCopyAssignment(ClassDecl);
4878 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00004879
Richard Smith1c931be2012-04-02 18:40:40 +00004880 if (getLangOpts().CPlusPlus0x && ClassDecl->needsImplicitMoveAssignment()) {
Richard Smithb701d3d2011-12-24 21:56:24 +00004881 ++ASTContext::NumImplicitMoveAssignmentOperators;
4882
4883 // Likewise for the move assignment operator.
4884 if (ClassDecl->isDynamicClass())
4885 DeclareImplicitMoveAssignment(ClassDecl);
4886 }
4887
Douglas Gregor4923aa22010-07-02 20:37:36 +00004888 if (!ClassDecl->hasUserDeclaredDestructor()) {
4889 ++ASTContext::NumImplicitDestructors;
4890
4891 // If we have a dynamic class, then the destructor may be virtual, so we
4892 // have to declare the destructor immediately. This ensures that, e.g., it
4893 // shows up in the right place in the vtable and that we diagnose problems
4894 // with the implicit exception specification.
4895 if (ClassDecl->isDynamicClass())
4896 DeclareImplicitDestructor(ClassDecl);
4897 }
Douglas Gregor396b7cd2008-11-03 17:51:48 +00004898}
4899
Francois Pichet8387e2a2011-04-22 22:18:13 +00004900void Sema::ActOnReenterDeclaratorTemplateScope(Scope *S, DeclaratorDecl *D) {
4901 if (!D)
4902 return;
4903
4904 int NumParamList = D->getNumTemplateParameterLists();
4905 for (int i = 0; i < NumParamList; i++) {
4906 TemplateParameterList* Params = D->getTemplateParameterList(i);
4907 for (TemplateParameterList::iterator Param = Params->begin(),
4908 ParamEnd = Params->end();
4909 Param != ParamEnd; ++Param) {
4910 NamedDecl *Named = cast<NamedDecl>(*Param);
4911 if (Named->getDeclName()) {
4912 S->AddDecl(Named);
4913 IdResolver.AddDecl(Named);
4914 }
4915 }
4916 }
4917}
4918
John McCalld226f652010-08-21 09:40:31 +00004919void Sema::ActOnReenterTemplateScope(Scope *S, Decl *D) {
Douglas Gregor1cdcc572009-09-10 00:12:48 +00004920 if (!D)
4921 return;
4922
4923 TemplateParameterList *Params = 0;
4924 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
4925 Params = Template->getTemplateParameters();
4926 else if (ClassTemplatePartialSpecializationDecl *PartialSpec
4927 = dyn_cast<ClassTemplatePartialSpecializationDecl>(D))
4928 Params = PartialSpec->getTemplateParameters();
4929 else
Douglas Gregor6569d682009-05-27 23:11:45 +00004930 return;
4931
Douglas Gregor6569d682009-05-27 23:11:45 +00004932 for (TemplateParameterList::iterator Param = Params->begin(),
4933 ParamEnd = Params->end();
4934 Param != ParamEnd; ++Param) {
4935 NamedDecl *Named = cast<NamedDecl>(*Param);
4936 if (Named->getDeclName()) {
John McCalld226f652010-08-21 09:40:31 +00004937 S->AddDecl(Named);
Douglas Gregor6569d682009-05-27 23:11:45 +00004938 IdResolver.AddDecl(Named);
4939 }
4940 }
4941}
4942
John McCalld226f652010-08-21 09:40:31 +00004943void Sema::ActOnStartDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall7a1dc562009-12-19 10:49:29 +00004944 if (!RecordD) return;
4945 AdjustDeclIfTemplate(RecordD);
John McCalld226f652010-08-21 09:40:31 +00004946 CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordD);
John McCall7a1dc562009-12-19 10:49:29 +00004947 PushDeclContext(S, Record);
4948}
4949
John McCalld226f652010-08-21 09:40:31 +00004950void Sema::ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *RecordD) {
John McCall7a1dc562009-12-19 10:49:29 +00004951 if (!RecordD) return;
4952 PopDeclContext();
4953}
4954
Douglas Gregor72b505b2008-12-16 21:30:33 +00004955/// ActOnStartDelayedCXXMethodDeclaration - We have completed
4956/// parsing a top-level (non-nested) C++ class, and we are now
4957/// parsing those parts of the given Method declaration that could
4958/// not be parsed earlier (C++ [class.mem]p2), such as default
4959/// arguments. This action should enter the scope of the given
4960/// Method declaration as if we had just parsed the qualified method
4961/// name. However, it should not bring the parameters into scope;
4962/// that will be performed by ActOnDelayedCXXMethodParameter.
John McCalld226f652010-08-21 09:40:31 +00004963void Sema::ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00004964}
4965
4966/// ActOnDelayedCXXMethodParameter - We've already started a delayed
4967/// C++ method declaration. We're (re-)introducing the given
4968/// function parameter into scope for use in parsing later parts of
4969/// the method declaration. For example, we could see an
4970/// ActOnParamDefaultArgument event for this parameter.
John McCalld226f652010-08-21 09:40:31 +00004971void Sema::ActOnDelayedCXXMethodParameter(Scope *S, Decl *ParamD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004972 if (!ParamD)
4973 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004974
John McCalld226f652010-08-21 09:40:31 +00004975 ParmVarDecl *Param = cast<ParmVarDecl>(ParamD);
Douglas Gregor61366e92008-12-24 00:01:03 +00004976
4977 // If this parameter has an unparsed default argument, clear it out
4978 // to make way for the parsed default argument.
4979 if (Param->hasUnparsedDefaultArg())
4980 Param->setDefaultArg(0);
4981
John McCalld226f652010-08-21 09:40:31 +00004982 S->AddDecl(Param);
Douglas Gregor72b505b2008-12-16 21:30:33 +00004983 if (Param->getDeclName())
4984 IdResolver.AddDecl(Param);
4985}
4986
4987/// ActOnFinishDelayedCXXMethodDeclaration - We have finished
4988/// processing the delayed method declaration for Method. The method
4989/// declaration is now considered finished. There may be a separate
4990/// ActOnStartOfFunctionDef action later (not necessarily
4991/// immediately!) for this method, if it was also defined inside the
4992/// class body.
John McCalld226f652010-08-21 09:40:31 +00004993void Sema::ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *MethodD) {
Douglas Gregor4c4f7cb2009-06-22 23:20:33 +00004994 if (!MethodD)
4995 return;
Mike Stump1eb44332009-09-09 15:08:12 +00004996
Douglas Gregorefd5bda2009-08-24 11:57:43 +00004997 AdjustDeclIfTemplate(MethodD);
Mike Stump1eb44332009-09-09 15:08:12 +00004998
John McCalld226f652010-08-21 09:40:31 +00004999 FunctionDecl *Method = cast<FunctionDecl>(MethodD);
Douglas Gregor72b505b2008-12-16 21:30:33 +00005000
5001 // Now that we have our default arguments, check the constructor
5002 // again. It could produce additional diagnostics or affect whether
5003 // the class has implicitly-declared destructors, among other
5004 // things.
Chris Lattner6e475012009-04-25 08:35:12 +00005005 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Method))
5006 CheckConstructor(Constructor);
Douglas Gregor72b505b2008-12-16 21:30:33 +00005007
5008 // Check the default arguments, which we may have added.
5009 if (!Method->isInvalidDecl())
5010 CheckCXXDefaultArguments(Method);
5011}
5012
Douglas Gregor42a552f2008-11-05 20:51:48 +00005013/// CheckConstructorDeclarator - Called by ActOnDeclarator to check
Douglas Gregor72b505b2008-12-16 21:30:33 +00005014/// the well-formedness of the constructor declarator @p D with type @p
Douglas Gregor42a552f2008-11-05 20:51:48 +00005015/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00005016/// emit diagnostics and set the invalid bit to true. In any case, the type
5017/// will be updated to reflect a well-formed type for the constructor and
5018/// returned.
5019QualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R,
John McCalld931b082010-08-26 03:08:43 +00005020 StorageClass &SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005021 bool isVirtual = D.getDeclSpec().isVirtualSpecified();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005022
5023 // C++ [class.ctor]p3:
5024 // A constructor shall not be virtual (10.3) or static (9.4). A
5025 // constructor can be invoked for a const, volatile or const
5026 // volatile object. A constructor shall not be declared const,
5027 // volatile, or const volatile (9.3.2).
5028 if (isVirtual) {
Chris Lattner65401802009-04-25 08:28:21 +00005029 if (!D.isInvalidType())
5030 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
5031 << "virtual" << SourceRange(D.getDeclSpec().getVirtualSpecLoc())
5032 << SourceRange(D.getIdentifierLoc());
5033 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005034 }
John McCalld931b082010-08-26 03:08:43 +00005035 if (SC == SC_Static) {
Chris Lattner65401802009-04-25 08:28:21 +00005036 if (!D.isInvalidType())
5037 Diag(D.getIdentifierLoc(), diag::err_constructor_cannot_be)
5038 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
5039 << SourceRange(D.getIdentifierLoc());
5040 D.setInvalidType();
John McCalld931b082010-08-26 03:08:43 +00005041 SC = SC_None;
Douglas Gregor42a552f2008-11-05 20:51:48 +00005042 }
Mike Stump1eb44332009-09-09 15:08:12 +00005043
Abramo Bagnara075f8f12010-12-10 16:29:40 +00005044 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner65401802009-04-25 08:28:21 +00005045 if (FTI.TypeQuals != 0) {
John McCall0953e762009-09-24 19:53:00 +00005046 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005047 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
5048 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005049 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005050 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
5051 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005052 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005053 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_constructor)
5054 << "restrict" << SourceRange(D.getIdentifierLoc());
John McCalle23cf432010-12-14 08:05:40 +00005055 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005056 }
Mike Stump1eb44332009-09-09 15:08:12 +00005057
Douglas Gregorc938c162011-01-26 05:01:58 +00005058 // C++0x [class.ctor]p4:
5059 // A constructor shall not be declared with a ref-qualifier.
5060 if (FTI.hasRefQualifier()) {
5061 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor)
5062 << FTI.RefQualifierIsLValueRef
5063 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
5064 D.setInvalidType();
5065 }
5066
Douglas Gregor42a552f2008-11-05 20:51:48 +00005067 // Rebuild the function type "R" without any type qualifiers (in
5068 // case any of the errors above fired) and with "void" as the
Douglas Gregord92ec472010-07-01 05:10:53 +00005069 // return type, since constructors don't have return types.
John McCall183700f2009-09-21 23:43:11 +00005070 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00005071 if (Proto->getResultType() == Context.VoidTy && !D.isInvalidType())
5072 return R;
5073
5074 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
5075 EPI.TypeQuals = 0;
Douglas Gregorc938c162011-01-26 05:01:58 +00005076 EPI.RefQualifier = RQ_None;
5077
Chris Lattner65401802009-04-25 08:28:21 +00005078 return Context.getFunctionType(Context.VoidTy, Proto->arg_type_begin(),
John McCalle23cf432010-12-14 08:05:40 +00005079 Proto->getNumArgs(), EPI);
Douglas Gregor42a552f2008-11-05 20:51:48 +00005080}
5081
Douglas Gregor72b505b2008-12-16 21:30:33 +00005082/// CheckConstructor - Checks a fully-formed constructor for
5083/// well-formedness, issuing any diagnostics required. Returns true if
5084/// the constructor declarator is invalid.
Chris Lattner6e475012009-04-25 08:35:12 +00005085void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
Mike Stump1eb44332009-09-09 15:08:12 +00005086 CXXRecordDecl *ClassDecl
Douglas Gregor33297562009-03-27 04:38:56 +00005087 = dyn_cast<CXXRecordDecl>(Constructor->getDeclContext());
5088 if (!ClassDecl)
Chris Lattner6e475012009-04-25 08:35:12 +00005089 return Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00005090
5091 // C++ [class.copy]p3:
5092 // A declaration of a constructor for a class X is ill-formed if
5093 // its first parameter is of type (optionally cv-qualified) X and
5094 // either there are no other parameters or else all other
5095 // parameters have default arguments.
Douglas Gregor33297562009-03-27 04:38:56 +00005096 if (!Constructor->isInvalidDecl() &&
Mike Stump1eb44332009-09-09 15:08:12 +00005097 ((Constructor->getNumParams() == 1) ||
5098 (Constructor->getNumParams() > 1 &&
Douglas Gregor66724ea2009-11-14 01:20:54 +00005099 Constructor->getParamDecl(1)->hasDefaultArg())) &&
5100 Constructor->getTemplateSpecializationKind()
5101 != TSK_ImplicitInstantiation) {
Douglas Gregor72b505b2008-12-16 21:30:33 +00005102 QualType ParamType = Constructor->getParamDecl(0)->getType();
5103 QualType ClassTy = Context.getTagDeclType(ClassDecl);
5104 if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {
Douglas Gregora3a83512009-04-01 23:51:29 +00005105 SourceLocation ParamLoc = Constructor->getParamDecl(0)->getLocation();
Douglas Gregoraeb4a282010-05-27 21:28:21 +00005106 const char *ConstRef
5107 = Constructor->getParamDecl(0)->getIdentifier() ? "const &"
5108 : " const &";
Douglas Gregora3a83512009-04-01 23:51:29 +00005109 Diag(ParamLoc, diag::err_constructor_byvalue_arg)
Douglas Gregoraeb4a282010-05-27 21:28:21 +00005110 << FixItHint::CreateInsertion(ParamLoc, ConstRef);
Douglas Gregor66724ea2009-11-14 01:20:54 +00005111
5112 // FIXME: Rather that making the constructor invalid, we should endeavor
5113 // to fix the type.
Chris Lattner6e475012009-04-25 08:35:12 +00005114 Constructor->setInvalidDecl();
Douglas Gregor72b505b2008-12-16 21:30:33 +00005115 }
5116 }
Douglas Gregor72b505b2008-12-16 21:30:33 +00005117}
5118
John McCall15442822010-08-04 01:04:25 +00005119/// CheckDestructor - Checks a fully-formed destructor definition for
5120/// well-formedness, issuing any diagnostics required. Returns true
5121/// on error.
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005122bool Sema::CheckDestructor(CXXDestructorDecl *Destructor) {
Anders Carlsson6d701392009-11-15 22:49:34 +00005123 CXXRecordDecl *RD = Destructor->getParent();
5124
5125 if (Destructor->isVirtual()) {
5126 SourceLocation Loc;
5127
5128 if (!Destructor->isImplicit())
5129 Loc = Destructor->getLocation();
5130 else
5131 Loc = RD->getLocation();
5132
5133 // If we have a virtual destructor, look up the deallocation function
5134 FunctionDecl *OperatorDelete = 0;
5135 DeclarationName Name =
5136 Context.DeclarationNames.getCXXOperatorName(OO_Delete);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00005137 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete))
Anders Carlsson37909802009-11-30 21:24:50 +00005138 return true;
John McCall5efd91a2010-07-03 18:33:00 +00005139
Eli Friedman5f2987c2012-02-02 03:46:19 +00005140 MarkFunctionReferenced(Loc, OperatorDelete);
Anders Carlsson37909802009-11-30 21:24:50 +00005141
5142 Destructor->setOperatorDelete(OperatorDelete);
Anders Carlsson6d701392009-11-15 22:49:34 +00005143 }
Anders Carlsson37909802009-11-30 21:24:50 +00005144
5145 return false;
Anders Carlsson6d701392009-11-15 22:49:34 +00005146}
5147
Mike Stump1eb44332009-09-09 15:08:12 +00005148static inline bool
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005149FTIHasSingleVoidArgument(DeclaratorChunk::FunctionTypeInfo &FTI) {
5150 return (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5151 FTI.ArgInfo[0].Param &&
John McCalld226f652010-08-21 09:40:31 +00005152 cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType());
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005153}
5154
Douglas Gregor42a552f2008-11-05 20:51:48 +00005155/// CheckDestructorDeclarator - Called by ActOnDeclarator to check
5156/// the well-formednes of the destructor declarator @p D with type @p
5157/// R. If there are any errors in the declarator, this routine will
Chris Lattner65401802009-04-25 08:28:21 +00005158/// emit diagnostics and set the declarator to invalid. Even if this happens,
5159/// will be updated to reflect a well-formed type for the destructor and
5160/// returned.
Douglas Gregord92ec472010-07-01 05:10:53 +00005161QualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R,
John McCalld931b082010-08-26 03:08:43 +00005162 StorageClass& SC) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005163 // C++ [class.dtor]p1:
5164 // [...] A typedef-name that names a class is a class-name
5165 // (7.1.3); however, a typedef-name that names a class shall not
5166 // be used as the identifier in the declarator for a destructor
5167 // declaration.
Douglas Gregor3f9a0562009-11-03 01:35:08 +00005168 QualType DeclaratorType = GetTypeFromParser(D.getName().DestructorName);
Richard Smith162e1c12011-04-15 14:24:37 +00005169 if (const TypedefType *TT = DeclaratorType->getAs<TypedefType>())
Chris Lattner65401802009-04-25 08:28:21 +00005170 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
Richard Smith162e1c12011-04-15 14:24:37 +00005171 << DeclaratorType << isa<TypeAliasDecl>(TT->getDecl());
Richard Smith3e4c6c42011-05-05 21:57:07 +00005172 else if (const TemplateSpecializationType *TST =
5173 DeclaratorType->getAs<TemplateSpecializationType>())
5174 if (TST->isTypeAlias())
5175 Diag(D.getIdentifierLoc(), diag::err_destructor_typedef_name)
5176 << DeclaratorType << 1;
Douglas Gregor42a552f2008-11-05 20:51:48 +00005177
5178 // C++ [class.dtor]p2:
5179 // A destructor is used to destroy objects of its class type. A
5180 // destructor takes no parameters, and no return type can be
5181 // specified for it (not even void). The address of a destructor
5182 // shall not be taken. A destructor shall not be static. A
5183 // destructor can be invoked for a const, volatile or const
5184 // volatile object. A destructor shall not be declared const,
5185 // volatile or const volatile (9.3.2).
John McCalld931b082010-08-26 03:08:43 +00005186 if (SC == SC_Static) {
Chris Lattner65401802009-04-25 08:28:21 +00005187 if (!D.isInvalidType())
5188 Diag(D.getIdentifierLoc(), diag::err_destructor_cannot_be)
5189 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
Douglas Gregord92ec472010-07-01 05:10:53 +00005190 << SourceRange(D.getIdentifierLoc())
5191 << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5192
John McCalld931b082010-08-26 03:08:43 +00005193 SC = SC_None;
Douglas Gregor42a552f2008-11-05 20:51:48 +00005194 }
Chris Lattner65401802009-04-25 08:28:21 +00005195 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005196 // Destructors don't have return types, but the parser will
5197 // happily parse something like:
5198 //
5199 // class X {
5200 // float ~X();
5201 // };
5202 //
5203 // The return type will be eliminated later.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005204 Diag(D.getIdentifierLoc(), diag::err_destructor_return_type)
5205 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
5206 << SourceRange(D.getIdentifierLoc());
Douglas Gregor42a552f2008-11-05 20:51:48 +00005207 }
Mike Stump1eb44332009-09-09 15:08:12 +00005208
Abramo Bagnara075f8f12010-12-10 16:29:40 +00005209 DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
Chris Lattner65401802009-04-25 08:28:21 +00005210 if (FTI.TypeQuals != 0 && !D.isInvalidType()) {
John McCall0953e762009-09-24 19:53:00 +00005211 if (FTI.TypeQuals & Qualifiers::Const)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005212 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5213 << "const" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005214 if (FTI.TypeQuals & Qualifiers::Volatile)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005215 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5216 << "volatile" << SourceRange(D.getIdentifierLoc());
John McCall0953e762009-09-24 19:53:00 +00005217 if (FTI.TypeQuals & Qualifiers::Restrict)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005218 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_destructor)
5219 << "restrict" << SourceRange(D.getIdentifierLoc());
Chris Lattner65401802009-04-25 08:28:21 +00005220 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005221 }
5222
Douglas Gregorc938c162011-01-26 05:01:58 +00005223 // C++0x [class.dtor]p2:
5224 // A destructor shall not be declared with a ref-qualifier.
5225 if (FTI.hasRefQualifier()) {
5226 Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor)
5227 << FTI.RefQualifierIsLValueRef
5228 << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());
5229 D.setInvalidType();
5230 }
5231
Douglas Gregor42a552f2008-11-05 20:51:48 +00005232 // Make sure we don't have any parameters.
Anders Carlsson7786d1c2009-04-30 23:18:11 +00005233 if (FTI.NumArgs > 0 && !FTIHasSingleVoidArgument(FTI)) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005234 Diag(D.getIdentifierLoc(), diag::err_destructor_with_params);
5235
5236 // Delete the parameters.
Chris Lattner65401802009-04-25 08:28:21 +00005237 FTI.freeArgs();
5238 D.setInvalidType();
Douglas Gregor42a552f2008-11-05 20:51:48 +00005239 }
5240
Mike Stump1eb44332009-09-09 15:08:12 +00005241 // Make sure the destructor isn't variadic.
Chris Lattner65401802009-04-25 08:28:21 +00005242 if (FTI.isVariadic) {
Douglas Gregor42a552f2008-11-05 20:51:48 +00005243 Diag(D.getIdentifierLoc(), diag::err_destructor_variadic);
Chris Lattner65401802009-04-25 08:28:21 +00005244 D.setInvalidType();
5245 }
Douglas Gregor42a552f2008-11-05 20:51:48 +00005246
5247 // Rebuild the function type "R" without any type qualifiers or
5248 // parameters (in case any of the errors above fired) and with
5249 // "void" as the return type, since destructors don't have return
Douglas Gregord92ec472010-07-01 05:10:53 +00005250 // types.
John McCalle23cf432010-12-14 08:05:40 +00005251 if (!D.isInvalidType())
5252 return R;
5253
Douglas Gregord92ec472010-07-01 05:10:53 +00005254 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
John McCalle23cf432010-12-14 08:05:40 +00005255 FunctionProtoType::ExtProtoInfo EPI = Proto->getExtProtoInfo();
5256 EPI.Variadic = false;
5257 EPI.TypeQuals = 0;
Douglas Gregorc938c162011-01-26 05:01:58 +00005258 EPI.RefQualifier = RQ_None;
John McCalle23cf432010-12-14 08:05:40 +00005259 return Context.getFunctionType(Context.VoidTy, 0, 0, EPI);
Douglas Gregor42a552f2008-11-05 20:51:48 +00005260}
5261
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005262/// CheckConversionDeclarator - Called by ActOnDeclarator to check the
5263/// well-formednes of the conversion function declarator @p D with
5264/// type @p R. If there are any errors in the declarator, this routine
5265/// will emit diagnostics and return true. Otherwise, it will return
5266/// false. Either way, the type @p R will be updated to reflect a
5267/// well-formed type for the conversion operator.
Chris Lattner6e475012009-04-25 08:35:12 +00005268void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
John McCalld931b082010-08-26 03:08:43 +00005269 StorageClass& SC) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005270 // C++ [class.conv.fct]p1:
5271 // Neither parameter types nor return type can be specified. The
Eli Friedman33a31382009-08-05 19:21:58 +00005272 // type of a conversion function (8.3.5) is "function taking no
Mike Stump1eb44332009-09-09 15:08:12 +00005273 // parameter returning conversion-type-id."
John McCalld931b082010-08-26 03:08:43 +00005274 if (SC == SC_Static) {
Chris Lattner6e475012009-04-25 08:35:12 +00005275 if (!D.isInvalidType())
5276 Diag(D.getIdentifierLoc(), diag::err_conv_function_not_member)
5277 << "static" << SourceRange(D.getDeclSpec().getStorageClassSpecLoc())
5278 << SourceRange(D.getIdentifierLoc());
5279 D.setInvalidType();
John McCalld931b082010-08-26 03:08:43 +00005280 SC = SC_None;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005281 }
John McCalla3f81372010-04-13 00:04:31 +00005282
5283 QualType ConvType = GetTypeFromParser(D.getName().ConversionFunctionId);
5284
Chris Lattner6e475012009-04-25 08:35:12 +00005285 if (D.getDeclSpec().hasTypeSpecifier() && !D.isInvalidType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005286 // Conversion functions don't have return types, but the parser will
5287 // happily parse something like:
5288 //
5289 // class X {
5290 // float operator bool();
5291 // };
5292 //
5293 // The return type will be changed later anyway.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00005294 Diag(D.getIdentifierLoc(), diag::err_conv_function_return_type)
5295 << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
5296 << SourceRange(D.getIdentifierLoc());
John McCalla3f81372010-04-13 00:04:31 +00005297 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005298 }
5299
John McCalla3f81372010-04-13 00:04:31 +00005300 const FunctionProtoType *Proto = R->getAs<FunctionProtoType>();
5301
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005302 // Make sure we don't have any parameters.
John McCalla3f81372010-04-13 00:04:31 +00005303 if (Proto->getNumArgs() > 0) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005304 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_params);
5305
5306 // Delete the parameters.
Abramo Bagnara075f8f12010-12-10 16:29:40 +00005307 D.getFunctionTypeInfo().freeArgs();
Chris Lattner6e475012009-04-25 08:35:12 +00005308 D.setInvalidType();
John McCalla3f81372010-04-13 00:04:31 +00005309 } else if (Proto->isVariadic()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005310 Diag(D.getIdentifierLoc(), diag::err_conv_function_variadic);
Chris Lattner6e475012009-04-25 08:35:12 +00005311 D.setInvalidType();
5312 }
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005313
John McCalla3f81372010-04-13 00:04:31 +00005314 // Diagnose "&operator bool()" and other such nonsense. This
5315 // is actually a gcc extension which we don't support.
5316 if (Proto->getResultType() != ConvType) {
5317 Diag(D.getIdentifierLoc(), diag::err_conv_function_with_complex_decl)
5318 << Proto->getResultType();
5319 D.setInvalidType();
5320 ConvType = Proto->getResultType();
5321 }
5322
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005323 // C++ [class.conv.fct]p4:
5324 // The conversion-type-id shall not represent a function type nor
5325 // an array type.
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005326 if (ConvType->isArrayType()) {
5327 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_array);
5328 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00005329 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005330 } else if (ConvType->isFunctionType()) {
5331 Diag(D.getIdentifierLoc(), diag::err_conv_function_to_function);
5332 ConvType = Context.getPointerType(ConvType);
Chris Lattner6e475012009-04-25 08:35:12 +00005333 D.setInvalidType();
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005334 }
5335
5336 // Rebuild the function type "R" without any parameters (in case any
5337 // of the errors above fired) and with the conversion type as the
Mike Stump1eb44332009-09-09 15:08:12 +00005338 // return type.
John McCalle23cf432010-12-14 08:05:40 +00005339 if (D.isInvalidType())
5340 R = Context.getFunctionType(ConvType, 0, 0, Proto->getExtProtoInfo());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005341
Douglas Gregor09f41cf2009-01-14 15:45:31 +00005342 // C++0x explicit conversion operators.
Richard Smithebaf0e62011-10-18 20:49:44 +00005343 if (D.getDeclSpec().isExplicitSpecified())
Mike Stump1eb44332009-09-09 15:08:12 +00005344 Diag(D.getDeclSpec().getExplicitSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +00005345 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +00005346 diag::warn_cxx98_compat_explicit_conversion_functions :
5347 diag::ext_explicit_conversion_functions)
Douglas Gregor09f41cf2009-01-14 15:45:31 +00005348 << SourceRange(D.getDeclSpec().getExplicitSpecLoc());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005349}
5350
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005351/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
5352/// the declaration of the given C++ conversion function. This routine
5353/// is responsible for recording the conversion function in the C++
5354/// class, if possible.
John McCalld226f652010-08-21 09:40:31 +00005355Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005356 assert(Conversion && "Expected to receive a conversion function declaration");
5357
Douglas Gregor9d350972008-12-12 08:25:50 +00005358 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Conversion->getDeclContext());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005359
5360 // Make sure we aren't redeclaring the conversion function.
5361 QualType ConvType = Context.getCanonicalType(Conversion->getConversionType());
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005362
5363 // C++ [class.conv.fct]p1:
5364 // [...] A conversion function is never used to convert a
5365 // (possibly cv-qualified) object to the (possibly cv-qualified)
5366 // same object type (or a reference to it), to a (possibly
5367 // cv-qualified) base class of that type (or a reference to it),
5368 // or to (possibly cv-qualified) void.
Mike Stump390b4cc2009-05-16 07:39:55 +00005369 // FIXME: Suppress this warning if the conversion function ends up being a
5370 // virtual function that overrides a virtual function in a base class.
Mike Stump1eb44332009-09-09 15:08:12 +00005371 QualType ClassType
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005372 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Ted Kremenek6217b802009-07-29 21:53:49 +00005373 if (const ReferenceType *ConvTypeRef = ConvType->getAs<ReferenceType>())
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005374 ConvType = ConvTypeRef->getPointeeType();
Douglas Gregorda0fd9a2010-09-12 07:22:28 +00005375 if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared &&
5376 Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
Douglas Gregor10341702010-09-13 16:44:26 +00005377 /* Suppress diagnostics for instantiations. */;
Douglas Gregorda0fd9a2010-09-12 07:22:28 +00005378 else if (ConvType->isRecordType()) {
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005379 ConvType = Context.getCanonicalType(ConvType).getUnqualifiedType();
5380 if (ConvType == ClassType)
Chris Lattner5dc266a2008-11-20 06:13:02 +00005381 Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005382 << ClassType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005383 else if (IsDerivedFrom(ClassType, ConvType))
Chris Lattner5dc266a2008-11-20 06:13:02 +00005384 Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005385 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005386 } else if (ConvType->isVoidType()) {
Chris Lattner5dc266a2008-11-20 06:13:02 +00005387 Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used)
Chris Lattnerd1625842008-11-24 06:25:27 +00005388 << ClassType << ConvType;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005389 }
5390
Douglas Gregore80622f2010-09-29 04:25:11 +00005391 if (FunctionTemplateDecl *ConversionTemplate
5392 = Conversion->getDescribedFunctionTemplate())
5393 return ConversionTemplate;
5394
John McCalld226f652010-08-21 09:40:31 +00005395 return Conversion;
Douglas Gregor2f1bc522008-11-07 20:08:42 +00005396}
5397
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005398//===----------------------------------------------------------------------===//
5399// Namespace Handling
5400//===----------------------------------------------------------------------===//
5401
Richard Smithd1a55a62012-10-04 22:13:39 +00005402/// \brief Diagnose a mismatch in 'inline' qualifiers when a namespace is
5403/// reopened.
5404static void DiagnoseNamespaceInlineMismatch(Sema &S, SourceLocation KeywordLoc,
5405 SourceLocation Loc,
5406 IdentifierInfo *II, bool *IsInline,
5407 NamespaceDecl *PrevNS) {
5408 assert(*IsInline != PrevNS->isInline());
John McCallea318642010-08-26 09:15:37 +00005409
Richard Smithc969e6a2012-10-05 01:46:25 +00005410 // HACK: Work around a bug in libstdc++4.6's <atomic>, where
5411 // std::__atomic[0,1,2] are defined as non-inline namespaces, then reopened as
5412 // inline namespaces, with the intention of bringing names into namespace std.
5413 //
5414 // We support this just well enough to get that case working; this is not
5415 // sufficient to support reopening namespaces as inline in general.
Richard Smithd1a55a62012-10-04 22:13:39 +00005416 if (*IsInline && II && II->getName().startswith("__atomic") &&
5417 S.getSourceManager().isInSystemHeader(Loc)) {
Richard Smithc969e6a2012-10-05 01:46:25 +00005418 // Mark all prior declarations of the namespace as inline.
Richard Smithd1a55a62012-10-04 22:13:39 +00005419 for (NamespaceDecl *NS = PrevNS->getMostRecentDecl(); NS;
5420 NS = NS->getPreviousDecl())
5421 NS->setInline(*IsInline);
5422 // Patch up the lookup table for the containing namespace. This isn't really
5423 // correct, but it's good enough for this particular case.
5424 for (DeclContext::decl_iterator I = PrevNS->decls_begin(),
5425 E = PrevNS->decls_end(); I != E; ++I)
5426 if (NamedDecl *ND = dyn_cast<NamedDecl>(*I))
5427 PrevNS->getParent()->makeDeclVisibleInContext(ND);
5428 return;
5429 }
5430
5431 if (PrevNS->isInline())
5432 // The user probably just forgot the 'inline', so suggest that it
5433 // be added back.
5434 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
5435 << FixItHint::CreateInsertion(KeywordLoc, "inline ");
5436 else
5437 S.Diag(Loc, diag::err_inline_namespace_mismatch)
5438 << IsInline;
5439
5440 S.Diag(PrevNS->getLocation(), diag::note_previous_definition);
5441 *IsInline = PrevNS->isInline();
5442}
John McCallea318642010-08-26 09:15:37 +00005443
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005444/// ActOnStartNamespaceDef - This is called at the start of a namespace
5445/// definition.
John McCalld226f652010-08-21 09:40:31 +00005446Decl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope,
Sebastian Redld078e642010-08-27 23:12:46 +00005447 SourceLocation InlineLoc,
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005448 SourceLocation NamespaceLoc,
John McCallea318642010-08-26 09:15:37 +00005449 SourceLocation IdentLoc,
5450 IdentifierInfo *II,
5451 SourceLocation LBrace,
5452 AttributeList *AttrList) {
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005453 SourceLocation StartLoc = InlineLoc.isValid() ? InlineLoc : NamespaceLoc;
5454 // For anonymous namespace, take the location of the left brace.
5455 SourceLocation Loc = II ? IdentLoc : LBrace;
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005456 bool IsInline = InlineLoc.isValid();
Douglas Gregor67310742012-01-10 22:14:10 +00005457 bool IsInvalid = false;
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005458 bool IsStd = false;
5459 bool AddToKnown = false;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005460 Scope *DeclRegionScope = NamespcScope->getParent();
5461
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005462 NamespaceDecl *PrevNS = 0;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005463 if (II) {
5464 // C++ [namespace.def]p2:
Douglas Gregorfe7574b2010-10-22 15:24:46 +00005465 // The identifier in an original-namespace-definition shall not
5466 // have been previously defined in the declarative region in
5467 // which the original-namespace-definition appears. The
5468 // identifier in an original-namespace-definition is the name of
5469 // the namespace. Subsequently in that declarative region, it is
5470 // treated as an original-namespace-name.
5471 //
5472 // Since namespace names are unique in their scope, and we don't
Douglas Gregor010157f2011-05-06 23:28:47 +00005473 // look through using directives, just look for any ordinary names.
5474
5475 const unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_Member |
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005476 Decl::IDNS_Type | Decl::IDNS_Using | Decl::IDNS_Tag |
5477 Decl::IDNS_Namespace;
Douglas Gregor010157f2011-05-06 23:28:47 +00005478 NamedDecl *PrevDecl = 0;
5479 for (DeclContext::lookup_result R
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005480 = CurContext->getRedeclContext()->lookup(II);
Douglas Gregor010157f2011-05-06 23:28:47 +00005481 R.first != R.second; ++R.first) {
5482 if ((*R.first)->getIdentifierNamespace() & IDNS) {
5483 PrevDecl = *R.first;
5484 break;
5485 }
5486 }
5487
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005488 PrevNS = dyn_cast_or_null<NamespaceDecl>(PrevDecl);
5489
5490 if (PrevNS) {
Douglas Gregor44b43212008-12-11 16:49:14 +00005491 // This is an extended namespace definition.
Richard Smithd1a55a62012-10-04 22:13:39 +00005492 if (IsInline != PrevNS->isInline())
5493 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
5494 &IsInline, PrevNS);
Douglas Gregor44b43212008-12-11 16:49:14 +00005495 } else if (PrevDecl) {
5496 // This is an invalid name redefinition.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005497 Diag(Loc, diag::err_redefinition_different_kind)
5498 << II;
Douglas Gregor44b43212008-12-11 16:49:14 +00005499 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Douglas Gregor67310742012-01-10 22:14:10 +00005500 IsInvalid = true;
Douglas Gregor44b43212008-12-11 16:49:14 +00005501 // Continue on to push Namespc as current DeclContext and return it.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005502 } else if (II->isStr("std") &&
Sebastian Redl7a126a42010-08-31 00:36:30 +00005503 CurContext->getRedeclContext()->isTranslationUnit()) {
Douglas Gregor7adb10f2009-09-15 22:30:29 +00005504 // This is the first "real" definition of the namespace "std", so update
5505 // our cache of the "std" namespace to point at this definition.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005506 PrevNS = getStdNamespace();
5507 IsStd = true;
5508 AddToKnown = !IsInline;
5509 } else {
5510 // We've seen this namespace for the first time.
5511 AddToKnown = !IsInline;
Mike Stump1eb44332009-09-09 15:08:12 +00005512 }
Douglas Gregor44b43212008-12-11 16:49:14 +00005513 } else {
John McCall9aeed322009-10-01 00:25:31 +00005514 // Anonymous namespaces.
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005515
5516 // Determine whether the parent already has an anonymous namespace.
Sebastian Redl7a126a42010-08-31 00:36:30 +00005517 DeclContext *Parent = CurContext->getRedeclContext();
John McCall5fdd7642009-12-16 02:06:49 +00005518 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005519 PrevNS = TU->getAnonymousNamespace();
John McCall5fdd7642009-12-16 02:06:49 +00005520 } else {
5521 NamespaceDecl *ND = cast<NamespaceDecl>(Parent);
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005522 PrevNS = ND->getAnonymousNamespace();
John McCall5fdd7642009-12-16 02:06:49 +00005523 }
5524
Richard Smithd1a55a62012-10-04 22:13:39 +00005525 if (PrevNS && IsInline != PrevNS->isInline())
5526 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, NamespaceLoc, II,
5527 &IsInline, PrevNS);
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005528 }
5529
5530 NamespaceDecl *Namespc = NamespaceDecl::Create(Context, CurContext, IsInline,
5531 StartLoc, Loc, II, PrevNS);
Douglas Gregor67310742012-01-10 22:14:10 +00005532 if (IsInvalid)
5533 Namespc->setInvalidDecl();
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005534
5535 ProcessDeclAttributeList(DeclRegionScope, Namespc, AttrList);
Sebastian Redl4e4d5702010-08-31 00:36:36 +00005536
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005537 // FIXME: Should we be merging attributes?
5538 if (const VisibilityAttr *Attr = Namespc->getAttr<VisibilityAttr>())
Rafael Espindola20039ae2012-02-01 23:24:59 +00005539 PushNamespaceVisibilityAttr(Attr, Loc);
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005540
5541 if (IsStd)
5542 StdNamespace = Namespc;
5543 if (AddToKnown)
5544 KnownNamespaces[Namespc] = false;
5545
5546 if (II) {
5547 PushOnScopeChains(Namespc, DeclRegionScope);
5548 } else {
5549 // Link the anonymous namespace into its parent.
5550 DeclContext *Parent = CurContext->getRedeclContext();
5551 if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(Parent)) {
5552 TU->setAnonymousNamespace(Namespc);
5553 } else {
5554 cast<NamespaceDecl>(Parent)->setAnonymousNamespace(Namespc);
John McCall5fdd7642009-12-16 02:06:49 +00005555 }
John McCall9aeed322009-10-01 00:25:31 +00005556
Douglas Gregora4181472010-03-24 00:46:35 +00005557 CurContext->addDecl(Namespc);
5558
John McCall9aeed322009-10-01 00:25:31 +00005559 // C++ [namespace.unnamed]p1. An unnamed-namespace-definition
5560 // behaves as if it were replaced by
5561 // namespace unique { /* empty body */ }
5562 // using namespace unique;
5563 // namespace unique { namespace-body }
5564 // where all occurrences of 'unique' in a translation unit are
5565 // replaced by the same identifier and this identifier differs
5566 // from all other identifiers in the entire program.
5567
5568 // We just create the namespace with an empty name and then add an
5569 // implicit using declaration, just like the standard suggests.
5570 //
5571 // CodeGen enforces the "universally unique" aspect by giving all
5572 // declarations semantically contained within an anonymous
5573 // namespace internal linkage.
5574
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005575 if (!PrevNS) {
John McCall5fdd7642009-12-16 02:06:49 +00005576 UsingDirectiveDecl* UD
5577 = UsingDirectiveDecl::Create(Context, CurContext,
5578 /* 'using' */ LBrace,
5579 /* 'namespace' */ SourceLocation(),
Douglas Gregordb992412011-02-25 16:33:46 +00005580 /* qualifier */ NestedNameSpecifierLoc(),
John McCall5fdd7642009-12-16 02:06:49 +00005581 /* identifier */ SourceLocation(),
5582 Namespc,
5583 /* Ancestor */ CurContext);
5584 UD->setImplicit();
5585 CurContext->addDecl(UD);
5586 }
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005587 }
5588
Dmitri Gribenkoa5ef44f2012-07-11 21:38:39 +00005589 ActOnDocumentableDecl(Namespc);
5590
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005591 // Although we could have an invalid decl (i.e. the namespace name is a
5592 // redefinition), push it as current DeclContext and try to continue parsing.
Mike Stump390b4cc2009-05-16 07:39:55 +00005593 // FIXME: We should be able to push Namespc here, so that the each DeclContext
5594 // for the namespace has the declarations that showed up in that particular
5595 // namespace definition.
Douglas Gregor44b43212008-12-11 16:49:14 +00005596 PushDeclContext(NamespcScope, Namespc);
John McCalld226f652010-08-21 09:40:31 +00005597 return Namespc;
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005598}
5599
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005600/// getNamespaceDecl - Returns the namespace a decl represents. If the decl
5601/// is a namespace alias, returns the namespace it points to.
5602static inline NamespaceDecl *getNamespaceDecl(NamedDecl *D) {
5603 if (NamespaceAliasDecl *AD = dyn_cast_or_null<NamespaceAliasDecl>(D))
5604 return AD->getNamespace();
5605 return dyn_cast_or_null<NamespaceDecl>(D);
5606}
5607
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005608/// ActOnFinishNamespaceDef - This callback is called after a namespace is
5609/// exited. Decl is the DeclTy returned by ActOnStartNamespaceDef.
John McCalld226f652010-08-21 09:40:31 +00005610void Sema::ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace) {
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005611 NamespaceDecl *Namespc = dyn_cast_or_null<NamespaceDecl>(Dcl);
5612 assert(Namespc && "Invalid parameter, expected NamespaceDecl");
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005613 Namespc->setRBraceLoc(RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005614 PopDeclContext();
Eli Friedmanaa8b0d12010-08-05 06:57:20 +00005615 if (Namespc->hasAttr<VisibilityAttr>())
Rafael Espindola20039ae2012-02-01 23:24:59 +00005616 PopPragmaVisibility(true, RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00005617}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00005618
John McCall384aff82010-08-25 07:42:41 +00005619CXXRecordDecl *Sema::getStdBadAlloc() const {
5620 return cast_or_null<CXXRecordDecl>(
5621 StdBadAlloc.get(Context.getExternalSource()));
5622}
5623
5624NamespaceDecl *Sema::getStdNamespace() const {
5625 return cast_or_null<NamespaceDecl>(
5626 StdNamespace.get(Context.getExternalSource()));
5627}
5628
Douglas Gregor66992202010-06-29 17:53:46 +00005629/// \brief Retrieve the special "std" namespace, which may require us to
5630/// implicitly define the namespace.
Argyrios Kyrtzidis26faaac2010-08-02 07:14:39 +00005631NamespaceDecl *Sema::getOrCreateStdNamespace() {
Douglas Gregor66992202010-06-29 17:53:46 +00005632 if (!StdNamespace) {
5633 // The "std" namespace has not yet been defined, so build one implicitly.
5634 StdNamespace = NamespaceDecl::Create(Context,
5635 Context.getTranslationUnitDecl(),
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005636 /*Inline=*/false,
Abramo Bagnaraacba90f2011-03-08 12:38:20 +00005637 SourceLocation(), SourceLocation(),
Douglas Gregorf5c9f9f2012-01-07 09:11:48 +00005638 &PP.getIdentifierTable().get("std"),
5639 /*PrevDecl=*/0);
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005640 getStdNamespace()->setImplicit(true);
Douglas Gregor66992202010-06-29 17:53:46 +00005641 }
5642
Argyrios Kyrtzidis76c38d32010-08-02 07:14:54 +00005643 return getStdNamespace();
Douglas Gregor66992202010-06-29 17:53:46 +00005644}
5645
Sebastian Redl395e04d2012-01-17 22:49:33 +00005646bool Sema::isStdInitializerList(QualType Ty, QualType *Element) {
David Blaikie4e4d0842012-03-11 07:00:24 +00005647 assert(getLangOpts().CPlusPlus &&
Sebastian Redl395e04d2012-01-17 22:49:33 +00005648 "Looking for std::initializer_list outside of C++.");
5649
5650 // We're looking for implicit instantiations of
5651 // template <typename E> class std::initializer_list.
5652
5653 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
5654 return false;
5655
Sebastian Redl84760e32012-01-17 22:49:58 +00005656 ClassTemplateDecl *Template = 0;
5657 const TemplateArgument *Arguments = 0;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005658
Sebastian Redl84760e32012-01-17 22:49:58 +00005659 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Sebastian Redl395e04d2012-01-17 22:49:33 +00005660
Sebastian Redl84760e32012-01-17 22:49:58 +00005661 ClassTemplateSpecializationDecl *Specialization =
5662 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
5663 if (!Specialization)
5664 return false;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005665
Sebastian Redl84760e32012-01-17 22:49:58 +00005666 Template = Specialization->getSpecializedTemplate();
5667 Arguments = Specialization->getTemplateArgs().data();
5668 } else if (const TemplateSpecializationType *TST =
5669 Ty->getAs<TemplateSpecializationType>()) {
5670 Template = dyn_cast_or_null<ClassTemplateDecl>(
5671 TST->getTemplateName().getAsTemplateDecl());
5672 Arguments = TST->getArgs();
5673 }
5674 if (!Template)
5675 return false;
Sebastian Redl395e04d2012-01-17 22:49:33 +00005676
5677 if (!StdInitializerList) {
5678 // Haven't recognized std::initializer_list yet, maybe this is it.
5679 CXXRecordDecl *TemplateClass = Template->getTemplatedDecl();
5680 if (TemplateClass->getIdentifier() !=
5681 &PP.getIdentifierTable().get("initializer_list") ||
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005682 !getStdNamespace()->InEnclosingNamespaceSetOf(
5683 TemplateClass->getDeclContext()))
Sebastian Redl395e04d2012-01-17 22:49:33 +00005684 return false;
5685 // This is a template called std::initializer_list, but is it the right
5686 // template?
5687 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005688 if (Params->getMinRequiredArguments() != 1)
Sebastian Redl395e04d2012-01-17 22:49:33 +00005689 return false;
5690 if (!isa<TemplateTypeParmDecl>(Params->getParam(0)))
5691 return false;
5692
5693 // It's the right template.
5694 StdInitializerList = Template;
5695 }
5696
5697 if (Template != StdInitializerList)
5698 return false;
5699
5700 // This is an instance of std::initializer_list. Find the argument type.
Sebastian Redl84760e32012-01-17 22:49:58 +00005701 if (Element)
5702 *Element = Arguments[0].getAsType();
Sebastian Redl395e04d2012-01-17 22:49:33 +00005703 return true;
5704}
5705
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00005706static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
5707 NamespaceDecl *Std = S.getStdNamespace();
5708 if (!Std) {
5709 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
5710 return 0;
5711 }
5712
5713 LookupResult Result(S, &S.PP.getIdentifierTable().get("initializer_list"),
5714 Loc, Sema::LookupOrdinaryName);
5715 if (!S.LookupQualifiedName(Result, Std)) {
5716 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
5717 return 0;
5718 }
5719 ClassTemplateDecl *Template = Result.getAsSingle<ClassTemplateDecl>();
5720 if (!Template) {
5721 Result.suppressDiagnostics();
5722 // We found something weird. Complain about the first thing we found.
5723 NamedDecl *Found = *Result.begin();
5724 S.Diag(Found->getLocation(), diag::err_malformed_std_initializer_list);
5725 return 0;
5726 }
5727
5728 // We found some template called std::initializer_list. Now verify that it's
5729 // correct.
5730 TemplateParameterList *Params = Template->getTemplateParameters();
Sebastian Redlb832f6d2012-01-23 22:09:39 +00005731 if (Params->getMinRequiredArguments() != 1 ||
5732 !isa<TemplateTypeParmDecl>(Params->getParam(0))) {
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00005733 S.Diag(Template->getLocation(), diag::err_malformed_std_initializer_list);
5734 return 0;
5735 }
5736
5737 return Template;
5738}
5739
5740QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
5741 if (!StdInitializerList) {
5742 StdInitializerList = LookupStdInitializerList(*this, Loc);
5743 if (!StdInitializerList)
5744 return QualType();
5745 }
5746
5747 TemplateArgumentListInfo Args(Loc, Loc);
5748 Args.addArgument(TemplateArgumentLoc(TemplateArgument(Element),
5749 Context.getTrivialTypeSourceInfo(Element,
5750 Loc)));
5751 return Context.getCanonicalType(
5752 CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
5753}
5754
Sebastian Redl98d36062012-01-17 22:50:14 +00005755bool Sema::isInitListConstructor(const CXXConstructorDecl* Ctor) {
5756 // C++ [dcl.init.list]p2:
5757 // A constructor is an initializer-list constructor if its first parameter
5758 // is of type std::initializer_list<E> or reference to possibly cv-qualified
5759 // std::initializer_list<E> for some type E, and either there are no other
5760 // parameters or else all other parameters have default arguments.
5761 if (Ctor->getNumParams() < 1 ||
5762 (Ctor->getNumParams() > 1 && !Ctor->getParamDecl(1)->hasDefaultArg()))
5763 return false;
5764
5765 QualType ArgType = Ctor->getParamDecl(0)->getType();
5766 if (const ReferenceType *RT = ArgType->getAs<ReferenceType>())
5767 ArgType = RT->getPointeeType().getUnqualifiedType();
5768
5769 return isStdInitializerList(ArgType, 0);
5770}
5771
Douglas Gregor9172aa62011-03-26 22:25:30 +00005772/// \brief Determine whether a using statement is in a context where it will be
5773/// apply in all contexts.
5774static bool IsUsingDirectiveInToplevelContext(DeclContext *CurContext) {
5775 switch (CurContext->getDeclKind()) {
5776 case Decl::TranslationUnit:
5777 return true;
5778 case Decl::LinkageSpec:
5779 return IsUsingDirectiveInToplevelContext(CurContext->getParent());
5780 default:
5781 return false;
5782 }
5783}
5784
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005785namespace {
5786
5787// Callback to only accept typo corrections that are namespaces.
5788class NamespaceValidatorCCC : public CorrectionCandidateCallback {
5789 public:
5790 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
5791 if (NamedDecl *ND = candidate.getCorrectionDecl()) {
5792 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
5793 }
5794 return false;
5795 }
5796};
5797
5798}
5799
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005800static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc,
5801 CXXScopeSpec &SS,
5802 SourceLocation IdentLoc,
5803 IdentifierInfo *Ident) {
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005804 NamespaceValidatorCCC Validator;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005805 R.clear();
5806 if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(),
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005807 R.getLookupKind(), Sc, &SS,
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00005808 Validator)) {
David Blaikie4e4d0842012-03-11 07:00:24 +00005809 std::string CorrectedStr(Corrected.getAsString(S.getLangOpts()));
5810 std::string CorrectedQuotedStr(Corrected.getQuoted(S.getLangOpts()));
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005811 if (DeclContext *DC = S.computeDeclContext(SS, false))
5812 S.Diag(IdentLoc, diag::err_using_directive_member_suggest)
5813 << Ident << DC << CorrectedQuotedStr << SS.getRange()
David Blaikie6952c012012-10-12 20:00:44 +00005814 << FixItHint::CreateReplacement(Corrected.getCorrectionRange(),
5815 CorrectedStr);
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005816 else
5817 S.Diag(IdentLoc, diag::err_using_directive_suggest)
5818 << Ident << CorrectedQuotedStr
5819 << FixItHint::CreateReplacement(IdentLoc, CorrectedStr);
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005820
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005821 S.Diag(Corrected.getCorrectionDecl()->getLocation(),
5822 diag::note_namespace_defined_here) << CorrectedQuotedStr;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005823
Kaelyn Uhrain7d5e6942012-01-11 19:37:46 +00005824 R.addDecl(Corrected.getCorrectionDecl());
5825 return true;
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005826 }
5827 return false;
5828}
5829
John McCalld226f652010-08-21 09:40:31 +00005830Decl *Sema::ActOnUsingDirective(Scope *S,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005831 SourceLocation UsingLoc,
5832 SourceLocation NamespcLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00005833 CXXScopeSpec &SS,
Chris Lattnerb28317a2009-03-28 19:18:32 +00005834 SourceLocation IdentLoc,
5835 IdentifierInfo *NamespcName,
5836 AttributeList *AttrList) {
Douglas Gregorf780abc2008-12-30 03:27:21 +00005837 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
5838 assert(NamespcName && "Invalid NamespcName.");
5839 assert(IdentLoc.isValid() && "Invalid NamespceName location.");
John McCall78b81052010-11-10 02:40:36 +00005840
5841 // This can only happen along a recovery path.
5842 while (S->getFlags() & Scope::TemplateParamScope)
5843 S = S->getParent();
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005844 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Douglas Gregorf780abc2008-12-30 03:27:21 +00005845
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005846 UsingDirectiveDecl *UDir = 0;
Douglas Gregor66992202010-06-29 17:53:46 +00005847 NestedNameSpecifier *Qualifier = 0;
5848 if (SS.isSet())
5849 Qualifier = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
5850
Douglas Gregoreb11cd02009-01-14 22:20:51 +00005851 // Lookup namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00005852 LookupResult R(*this, NamespcName, IdentLoc, LookupNamespaceName);
5853 LookupParsedName(R, S, &SS);
5854 if (R.isAmbiguous())
John McCalld226f652010-08-21 09:40:31 +00005855 return 0;
John McCalla24dc2e2009-11-17 02:14:36 +00005856
Douglas Gregor66992202010-06-29 17:53:46 +00005857 if (R.empty()) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005858 R.clear();
Douglas Gregor66992202010-06-29 17:53:46 +00005859 // Allow "using namespace std;" or "using namespace ::std;" even if
5860 // "std" hasn't been defined yet, for GCC compatibility.
5861 if ((!Qualifier || Qualifier->getKind() == NestedNameSpecifier::Global) &&
5862 NamespcName->isStr("std")) {
5863 Diag(IdentLoc, diag::ext_using_undefined_std);
Argyrios Kyrtzidis26faaac2010-08-02 07:14:39 +00005864 R.addDecl(getOrCreateStdNamespace());
Douglas Gregor66992202010-06-29 17:53:46 +00005865 R.resolveKind();
5866 }
5867 // Otherwise, attempt typo correction.
Douglas Gregord8bba9c2011-06-28 16:20:02 +00005868 else TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, NamespcName);
Douglas Gregor66992202010-06-29 17:53:46 +00005869 }
5870
John McCallf36e02d2009-10-09 21:13:30 +00005871 if (!R.empty()) {
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005872 NamedDecl *Named = R.getFoundDecl();
5873 assert((isa<NamespaceDecl>(Named) || isa<NamespaceAliasDecl>(Named))
5874 && "expected namespace decl");
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005875 // C++ [namespace.udir]p1:
5876 // A using-directive specifies that the names in the nominated
5877 // namespace can be used in the scope in which the
5878 // using-directive appears after the using-directive. During
5879 // unqualified name lookup (3.4.1), the names appear as if they
5880 // were declared in the nearest enclosing namespace which
5881 // contains both the using-directive and the nominated
Eli Friedman33a31382009-08-05 19:21:58 +00005882 // namespace. [Note: in this context, "contains" means "contains
5883 // directly or indirectly". ]
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005884
5885 // Find enclosing context containing both using-directive and
5886 // nominated namespace.
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005887 NamespaceDecl *NS = getNamespaceDecl(Named);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005888 DeclContext *CommonAncestor = cast<DeclContext>(NS);
5889 while (CommonAncestor && !CommonAncestor->Encloses(CurContext))
5890 CommonAncestor = CommonAncestor->getParent();
5891
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005892 UDir = UsingDirectiveDecl::Create(Context, CurContext, UsingLoc, NamespcLoc,
Douglas Gregordb992412011-02-25 16:33:46 +00005893 SS.getWithLocInContext(Context),
Sebastian Redleb0d8c92009-11-23 15:34:23 +00005894 IdentLoc, Named, CommonAncestor);
Douglas Gregord6a49bb2011-03-18 16:10:52 +00005895
Douglas Gregor9172aa62011-03-26 22:25:30 +00005896 if (IsUsingDirectiveInToplevelContext(CurContext) &&
Chandler Carruth40278532011-07-25 16:49:02 +00005897 !SourceMgr.isFromMainFile(SourceMgr.getExpansionLoc(IdentLoc))) {
Douglas Gregord6a49bb2011-03-18 16:10:52 +00005898 Diag(IdentLoc, diag::warn_using_directive_in_header);
5899 }
5900
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005901 PushUsingDirective(S, UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00005902 } else {
Chris Lattneread013e2009-01-06 07:24:29 +00005903 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
Douglas Gregorf780abc2008-12-30 03:27:21 +00005904 }
5905
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005906 // FIXME: We ignore attributes for now.
John McCalld226f652010-08-21 09:40:31 +00005907 return UDir;
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005908}
5909
5910void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
Richard Smith1b7f9cb2012-03-13 03:12:56 +00005911 // If the scope has an associated entity and the using directive is at
5912 // namespace or translation unit scope, add the UsingDirectiveDecl into
5913 // its lookup structure so qualified name lookup can find it.
5914 DeclContext *Ctx = static_cast<DeclContext*>(S->getEntity());
5915 if (Ctx && !Ctx->isFunctionOrMethod())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00005916 Ctx->addDecl(UDir);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00005917 else
Richard Smith1b7f9cb2012-03-13 03:12:56 +00005918 // Otherwise, it is at block sope. The using-directives will affect lookup
5919 // only to the end of the scope.
John McCalld226f652010-08-21 09:40:31 +00005920 S->PushUsingDirective(UDir);
Douglas Gregorf780abc2008-12-30 03:27:21 +00005921}
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00005922
Douglas Gregor9cfbe482009-06-20 00:51:54 +00005923
John McCalld226f652010-08-21 09:40:31 +00005924Decl *Sema::ActOnUsingDeclaration(Scope *S,
John McCall78b81052010-11-10 02:40:36 +00005925 AccessSpecifier AS,
5926 bool HasUsingKeyword,
5927 SourceLocation UsingLoc,
5928 CXXScopeSpec &SS,
5929 UnqualifiedId &Name,
5930 AttributeList *AttrList,
5931 bool IsTypeName,
5932 SourceLocation TypenameLoc) {
Douglas Gregor9cfbe482009-06-20 00:51:54 +00005933 assert(S->getFlags() & Scope::DeclScope && "Invalid Scope.");
Mike Stump1eb44332009-09-09 15:08:12 +00005934
Douglas Gregor12c118a2009-11-04 16:30:06 +00005935 switch (Name.getKind()) {
Fariborz Jahanian98a54032011-07-12 17:16:56 +00005936 case UnqualifiedId::IK_ImplicitSelfParam:
Douglas Gregor12c118a2009-11-04 16:30:06 +00005937 case UnqualifiedId::IK_Identifier:
5938 case UnqualifiedId::IK_OperatorFunctionId:
Sean Hunt0486d742009-11-28 04:44:28 +00005939 case UnqualifiedId::IK_LiteralOperatorId:
Douglas Gregor12c118a2009-11-04 16:30:06 +00005940 case UnqualifiedId::IK_ConversionFunctionId:
5941 break;
5942
5943 case UnqualifiedId::IK_ConstructorName:
Douglas Gregor0efc2c12010-01-13 17:31:36 +00005944 case UnqualifiedId::IK_ConstructorTemplateId:
Richard Smitha1366cb2012-04-27 19:33:05 +00005945 // C++11 inheriting constructors.
Daniel Dunbar96a00142012-03-09 18:35:03 +00005946 Diag(Name.getLocStart(),
David Blaikie4e4d0842012-03-11 07:00:24 +00005947 getLangOpts().CPlusPlus0x ?
Richard Smitha1366cb2012-04-27 19:33:05 +00005948 // FIXME: Produce warn_cxx98_compat_using_decl_constructor
5949 // instead once inheriting constructors work.
5950 diag::err_using_decl_constructor_unsupported :
Richard Smithebaf0e62011-10-18 20:49:44 +00005951 diag::err_using_decl_constructor)
5952 << SS.getRange();
5953
David Blaikie4e4d0842012-03-11 07:00:24 +00005954 if (getLangOpts().CPlusPlus0x) break;
John McCall604e7f12009-12-08 07:46:18 +00005955
John McCalld226f652010-08-21 09:40:31 +00005956 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005957
5958 case UnqualifiedId::IK_DestructorName:
Daniel Dunbar96a00142012-03-09 18:35:03 +00005959 Diag(Name.getLocStart(), diag::err_using_decl_destructor)
Douglas Gregor12c118a2009-11-04 16:30:06 +00005960 << SS.getRange();
John McCalld226f652010-08-21 09:40:31 +00005961 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005962
5963 case UnqualifiedId::IK_TemplateId:
Daniel Dunbar96a00142012-03-09 18:35:03 +00005964 Diag(Name.getLocStart(), diag::err_using_decl_template_id)
Douglas Gregor12c118a2009-11-04 16:30:06 +00005965 << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);
John McCalld226f652010-08-21 09:40:31 +00005966 return 0;
Douglas Gregor12c118a2009-11-04 16:30:06 +00005967 }
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00005968
5969 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name);
5970 DeclarationName TargetName = TargetNameInfo.getName();
John McCall604e7f12009-12-08 07:46:18 +00005971 if (!TargetName)
John McCalld226f652010-08-21 09:40:31 +00005972 return 0;
John McCall604e7f12009-12-08 07:46:18 +00005973
John McCall60fa3cf2009-12-11 02:10:03 +00005974 // Warn about using declarations.
5975 // TODO: store that the declaration was written without 'using' and
5976 // talk about access decls instead of using decls in the
5977 // diagnostics.
5978 if (!HasUsingKeyword) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00005979 UsingLoc = Name.getLocStart();
John McCall60fa3cf2009-12-11 02:10:03 +00005980
5981 Diag(UsingLoc, diag::warn_access_decl_deprecated)
Douglas Gregor849b2432010-03-31 17:46:05 +00005982 << FixItHint::CreateInsertion(SS.getRange().getBegin(), "using ");
John McCall60fa3cf2009-12-11 02:10:03 +00005983 }
5984
Douglas Gregor56c04582010-12-16 00:46:58 +00005985 if (DiagnoseUnexpandedParameterPack(SS, UPPC_UsingDeclaration) ||
5986 DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC_UsingDeclaration))
5987 return 0;
5988
John McCall9488ea12009-11-17 05:59:44 +00005989 NamedDecl *UD = BuildUsingDeclaration(S, AS, UsingLoc, SS,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00005990 TargetNameInfo, AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00005991 /* IsInstantiation */ false,
5992 IsTypeName, TypenameLoc);
John McCalled976492009-12-04 22:46:56 +00005993 if (UD)
5994 PushOnScopeChains(UD, S, /*AddToContext*/ false);
Mike Stump1eb44332009-09-09 15:08:12 +00005995
John McCalld226f652010-08-21 09:40:31 +00005996 return UD;
Anders Carlssonc72160b2009-08-28 05:40:36 +00005997}
5998
Douglas Gregor09acc982010-07-07 23:08:52 +00005999/// \brief Determine whether a using declaration considers the given
6000/// declarations as "equivalent", e.g., if they are redeclarations of
6001/// the same entity or are both typedefs of the same type.
6002static bool
6003IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2,
6004 bool &SuppressRedeclaration) {
6005 if (D1->getCanonicalDecl() == D2->getCanonicalDecl()) {
6006 SuppressRedeclaration = false;
6007 return true;
6008 }
6009
Richard Smith162e1c12011-04-15 14:24:37 +00006010 if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
6011 if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2)) {
Douglas Gregor09acc982010-07-07 23:08:52 +00006012 SuppressRedeclaration = true;
6013 return Context.hasSameType(TD1->getUnderlyingType(),
6014 TD2->getUnderlyingType());
6015 }
6016
6017 return false;
6018}
6019
6020
John McCall9f54ad42009-12-10 09:41:52 +00006021/// Determines whether to create a using shadow decl for a particular
6022/// decl, given the set of decls existing prior to this using lookup.
6023bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
6024 const LookupResult &Previous) {
6025 // Diagnose finding a decl which is not from a base class of the
6026 // current class. We do this now because there are cases where this
6027 // function will silently decide not to build a shadow decl, which
6028 // will pre-empt further diagnostics.
6029 //
6030 // We don't need to do this in C++0x because we do the check once on
6031 // the qualifier.
6032 //
6033 // FIXME: diagnose the following if we care enough:
6034 // struct A { int foo; };
6035 // struct B : A { using A::foo; };
6036 // template <class T> struct C : A {};
6037 // template <class T> struct D : C<T> { using B::foo; } // <---
6038 // This is invalid (during instantiation) in C++03 because B::foo
6039 // resolves to the using decl in B, which is not a base class of D<T>.
6040 // We can't diagnose it immediately because C<T> is an unknown
6041 // specialization. The UsingShadowDecl in D<T> then points directly
6042 // to A::foo, which will look well-formed when we instantiate.
6043 // The right solution is to not collapse the shadow-decl chain.
David Blaikie4e4d0842012-03-11 07:00:24 +00006044 if (!getLangOpts().CPlusPlus0x && CurContext->isRecord()) {
John McCall9f54ad42009-12-10 09:41:52 +00006045 DeclContext *OrigDC = Orig->getDeclContext();
6046
6047 // Handle enums and anonymous structs.
6048 if (isa<EnumDecl>(OrigDC)) OrigDC = OrigDC->getParent();
6049 CXXRecordDecl *OrigRec = cast<CXXRecordDecl>(OrigDC);
6050 while (OrigRec->isAnonymousStructOrUnion())
6051 OrigRec = cast<CXXRecordDecl>(OrigRec->getDeclContext());
6052
6053 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {
6054 if (OrigDC == CurContext) {
6055 Diag(Using->getLocation(),
6056 diag::err_using_decl_nested_name_specifier_is_current_class)
Douglas Gregordc355712011-02-25 00:36:19 +00006057 << Using->getQualifierLoc().getSourceRange();
John McCall9f54ad42009-12-10 09:41:52 +00006058 Diag(Orig->getLocation(), diag::note_using_decl_target);
6059 return true;
6060 }
6061
Douglas Gregordc355712011-02-25 00:36:19 +00006062 Diag(Using->getQualifierLoc().getBeginLoc(),
John McCall9f54ad42009-12-10 09:41:52 +00006063 diag::err_using_decl_nested_name_specifier_is_not_base_class)
Douglas Gregordc355712011-02-25 00:36:19 +00006064 << Using->getQualifier()
John McCall9f54ad42009-12-10 09:41:52 +00006065 << cast<CXXRecordDecl>(CurContext)
Douglas Gregordc355712011-02-25 00:36:19 +00006066 << Using->getQualifierLoc().getSourceRange();
John McCall9f54ad42009-12-10 09:41:52 +00006067 Diag(Orig->getLocation(), diag::note_using_decl_target);
6068 return true;
6069 }
6070 }
6071
6072 if (Previous.empty()) return false;
6073
6074 NamedDecl *Target = Orig;
6075 if (isa<UsingShadowDecl>(Target))
6076 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
6077
John McCalld7533ec2009-12-11 02:33:26 +00006078 // If the target happens to be one of the previous declarations, we
6079 // don't have a conflict.
6080 //
6081 // FIXME: but we might be increasing its access, in which case we
6082 // should redeclare it.
6083 NamedDecl *NonTag = 0, *Tag = 0;
6084 for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6085 I != E; ++I) {
6086 NamedDecl *D = (*I)->getUnderlyingDecl();
Douglas Gregor09acc982010-07-07 23:08:52 +00006087 bool Result;
6088 if (IsEquivalentForUsingDecl(Context, D, Target, Result))
6089 return Result;
John McCalld7533ec2009-12-11 02:33:26 +00006090
6091 (isa<TagDecl>(D) ? Tag : NonTag) = D;
6092 }
6093
John McCall9f54ad42009-12-10 09:41:52 +00006094 if (Target->isFunctionOrFunctionTemplate()) {
6095 FunctionDecl *FD;
6096 if (isa<FunctionTemplateDecl>(Target))
6097 FD = cast<FunctionTemplateDecl>(Target)->getTemplatedDecl();
6098 else
6099 FD = cast<FunctionDecl>(Target);
6100
6101 NamedDecl *OldDecl = 0;
John McCallad00b772010-06-16 08:42:20 +00006102 switch (CheckOverload(0, FD, Previous, OldDecl, /*IsForUsingDecl*/ true)) {
John McCall9f54ad42009-12-10 09:41:52 +00006103 case Ovl_Overload:
6104 return false;
6105
6106 case Ovl_NonFunction:
John McCall41ce66f2009-12-10 19:51:03 +00006107 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006108 break;
6109
6110 // We found a decl with the exact signature.
6111 case Ovl_Match:
John McCall9f54ad42009-12-10 09:41:52 +00006112 // If we're in a record, we want to hide the target, so we
6113 // return true (without a diagnostic) to tell the caller not to
6114 // build a shadow decl.
6115 if (CurContext->isRecord())
6116 return true;
6117
6118 // If we're not in a record, this is an error.
John McCall41ce66f2009-12-10 19:51:03 +00006119 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006120 break;
6121 }
6122
6123 Diag(Target->getLocation(), diag::note_using_decl_target);
6124 Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);
6125 return true;
6126 }
6127
6128 // Target is not a function.
6129
John McCall9f54ad42009-12-10 09:41:52 +00006130 if (isa<TagDecl>(Target)) {
6131 // No conflict between a tag and a non-tag.
6132 if (!Tag) return false;
6133
John McCall41ce66f2009-12-10 19:51:03 +00006134 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006135 Diag(Target->getLocation(), diag::note_using_decl_target);
6136 Diag(Tag->getLocation(), diag::note_using_decl_conflict);
6137 return true;
6138 }
6139
6140 // No conflict between a tag and a non-tag.
6141 if (!NonTag) return false;
6142
John McCall41ce66f2009-12-10 19:51:03 +00006143 Diag(Using->getLocation(), diag::err_using_decl_conflict);
John McCall9f54ad42009-12-10 09:41:52 +00006144 Diag(Target->getLocation(), diag::note_using_decl_target);
6145 Diag(NonTag->getLocation(), diag::note_using_decl_conflict);
6146 return true;
6147}
6148
John McCall9488ea12009-11-17 05:59:44 +00006149/// Builds a shadow declaration corresponding to a 'using' declaration.
John McCall604e7f12009-12-08 07:46:18 +00006150UsingShadowDecl *Sema::BuildUsingShadowDecl(Scope *S,
John McCall604e7f12009-12-08 07:46:18 +00006151 UsingDecl *UD,
6152 NamedDecl *Orig) {
John McCall9488ea12009-11-17 05:59:44 +00006153
6154 // If we resolved to another shadow declaration, just coalesce them.
John McCall604e7f12009-12-08 07:46:18 +00006155 NamedDecl *Target = Orig;
6156 if (isa<UsingShadowDecl>(Target)) {
6157 Target = cast<UsingShadowDecl>(Target)->getTargetDecl();
6158 assert(!isa<UsingShadowDecl>(Target) && "nested shadow declaration");
John McCall9488ea12009-11-17 05:59:44 +00006159 }
6160
6161 UsingShadowDecl *Shadow
John McCall604e7f12009-12-08 07:46:18 +00006162 = UsingShadowDecl::Create(Context, CurContext,
6163 UD->getLocation(), UD, Target);
John McCall9488ea12009-11-17 05:59:44 +00006164 UD->addShadowDecl(Shadow);
Douglas Gregore80622f2010-09-29 04:25:11 +00006165
6166 Shadow->setAccess(UD->getAccess());
6167 if (Orig->isInvalidDecl() || UD->isInvalidDecl())
6168 Shadow->setInvalidDecl();
6169
John McCall9488ea12009-11-17 05:59:44 +00006170 if (S)
John McCall604e7f12009-12-08 07:46:18 +00006171 PushOnScopeChains(Shadow, S);
John McCall9488ea12009-11-17 05:59:44 +00006172 else
John McCall604e7f12009-12-08 07:46:18 +00006173 CurContext->addDecl(Shadow);
John McCall9488ea12009-11-17 05:59:44 +00006174
John McCall604e7f12009-12-08 07:46:18 +00006175
John McCall9f54ad42009-12-10 09:41:52 +00006176 return Shadow;
6177}
John McCall604e7f12009-12-08 07:46:18 +00006178
John McCall9f54ad42009-12-10 09:41:52 +00006179/// Hides a using shadow declaration. This is required by the current
6180/// using-decl implementation when a resolvable using declaration in a
6181/// class is followed by a declaration which would hide or override
6182/// one or more of the using decl's targets; for example:
6183///
6184/// struct Base { void foo(int); };
6185/// struct Derived : Base {
6186/// using Base::foo;
6187/// void foo(int);
6188/// };
6189///
6190/// The governing language is C++03 [namespace.udecl]p12:
6191///
6192/// When a using-declaration brings names from a base class into a
6193/// derived class scope, member functions in the derived class
6194/// override and/or hide member functions with the same name and
6195/// parameter types in a base class (rather than conflicting).
6196///
6197/// There are two ways to implement this:
6198/// (1) optimistically create shadow decls when they're not hidden
6199/// by existing declarations, or
6200/// (2) don't create any shadow decls (or at least don't make them
6201/// visible) until we've fully parsed/instantiated the class.
6202/// The problem with (1) is that we might have to retroactively remove
6203/// a shadow decl, which requires several O(n) operations because the
6204/// decl structures are (very reasonably) not designed for removal.
6205/// (2) avoids this but is very fiddly and phase-dependent.
6206void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
John McCall32daa422010-03-31 01:36:47 +00006207 if (Shadow->getDeclName().getNameKind() ==
6208 DeclarationName::CXXConversionFunctionName)
6209 cast<CXXRecordDecl>(Shadow->getDeclContext())->removeConversion(Shadow);
6210
John McCall9f54ad42009-12-10 09:41:52 +00006211 // Remove it from the DeclContext...
6212 Shadow->getDeclContext()->removeDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00006213
John McCall9f54ad42009-12-10 09:41:52 +00006214 // ...and the scope, if applicable...
6215 if (S) {
John McCalld226f652010-08-21 09:40:31 +00006216 S->RemoveDecl(Shadow);
John McCall9f54ad42009-12-10 09:41:52 +00006217 IdResolver.RemoveDecl(Shadow);
John McCall604e7f12009-12-08 07:46:18 +00006218 }
6219
John McCall9f54ad42009-12-10 09:41:52 +00006220 // ...and the using decl.
6221 Shadow->getUsingDecl()->removeShadowDecl(Shadow);
6222
6223 // TODO: complain somehow if Shadow was used. It shouldn't
John McCall32daa422010-03-31 01:36:47 +00006224 // be possible for this to happen, because...?
John McCall9488ea12009-11-17 05:59:44 +00006225}
6226
John McCall7ba107a2009-11-18 02:36:19 +00006227/// Builds a using declaration.
6228///
6229/// \param IsInstantiation - Whether this call arises from an
6230/// instantiation of an unresolved using declaration. We treat
6231/// the lookup differently for these declarations.
John McCall9488ea12009-11-17 05:59:44 +00006232NamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
6233 SourceLocation UsingLoc,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00006234 CXXScopeSpec &SS,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006235 const DeclarationNameInfo &NameInfo,
Anders Carlssonc72160b2009-08-28 05:40:36 +00006236 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00006237 bool IsInstantiation,
6238 bool IsTypeName,
6239 SourceLocation TypenameLoc) {
Anders Carlssonc72160b2009-08-28 05:40:36 +00006240 assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006241 SourceLocation IdentLoc = NameInfo.getLoc();
Anders Carlssonc72160b2009-08-28 05:40:36 +00006242 assert(IdentLoc.isValid() && "Invalid TargetName location.");
Eli Friedman2a16a132009-08-27 05:09:36 +00006243
Anders Carlsson550b14b2009-08-28 05:49:21 +00006244 // FIXME: We ignore attributes for now.
Mike Stump1eb44332009-09-09 15:08:12 +00006245
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006246 if (SS.isEmpty()) {
6247 Diag(IdentLoc, diag::err_using_requires_qualname);
Anders Carlssonc72160b2009-08-28 05:40:36 +00006248 return 0;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006249 }
Mike Stump1eb44332009-09-09 15:08:12 +00006250
John McCall9f54ad42009-12-10 09:41:52 +00006251 // Do the redeclaration lookup in the current scope.
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006252 LookupResult Previous(*this, NameInfo, LookupUsingDeclName,
John McCall9f54ad42009-12-10 09:41:52 +00006253 ForRedeclaration);
6254 Previous.setHideTags(false);
6255 if (S) {
6256 LookupName(Previous, S);
6257
6258 // It is really dumb that we have to do this.
6259 LookupResult::Filter F = Previous.makeFilter();
6260 while (F.hasNext()) {
6261 NamedDecl *D = F.next();
6262 if (!isDeclInScope(D, CurContext, S))
6263 F.erase();
6264 }
6265 F.done();
6266 } else {
6267 assert(IsInstantiation && "no scope in non-instantiation");
6268 assert(CurContext->isRecord() && "scope not record in instantiation");
6269 LookupQualifiedName(Previous, CurContext);
6270 }
6271
John McCall9f54ad42009-12-10 09:41:52 +00006272 // Check for invalid redeclarations.
6273 if (CheckUsingDeclRedeclaration(UsingLoc, IsTypeName, SS, IdentLoc, Previous))
6274 return 0;
6275
6276 // Check for bad qualifiers.
John McCalled976492009-12-04 22:46:56 +00006277 if (CheckUsingDeclQualifier(UsingLoc, SS, IdentLoc))
6278 return 0;
6279
John McCallaf8e6ed2009-11-12 03:15:40 +00006280 DeclContext *LookupContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00006281 NamedDecl *D;
Douglas Gregordc355712011-02-25 00:36:19 +00006282 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCallaf8e6ed2009-11-12 03:15:40 +00006283 if (!LookupContext) {
John McCall7ba107a2009-11-18 02:36:19 +00006284 if (IsTypeName) {
John McCalled976492009-12-04 22:46:56 +00006285 // FIXME: not all declaration name kinds are legal here
6286 D = UnresolvedUsingTypenameDecl::Create(Context, CurContext,
6287 UsingLoc, TypenameLoc,
Douglas Gregordc355712011-02-25 00:36:19 +00006288 QualifierLoc,
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006289 IdentLoc, NameInfo.getName());
John McCalled976492009-12-04 22:46:56 +00006290 } else {
Douglas Gregordc355712011-02-25 00:36:19 +00006291 D = UnresolvedUsingValueDecl::Create(Context, CurContext, UsingLoc,
6292 QualifierLoc, NameInfo);
John McCall7ba107a2009-11-18 02:36:19 +00006293 }
John McCalled976492009-12-04 22:46:56 +00006294 } else {
Douglas Gregordc355712011-02-25 00:36:19 +00006295 D = UsingDecl::Create(Context, CurContext, UsingLoc, QualifierLoc,
6296 NameInfo, IsTypeName);
Anders Carlsson550b14b2009-08-28 05:49:21 +00006297 }
John McCalled976492009-12-04 22:46:56 +00006298 D->setAccess(AS);
6299 CurContext->addDecl(D);
6300
6301 if (!LookupContext) return D;
6302 UsingDecl *UD = cast<UsingDecl>(D);
Mike Stump1eb44332009-09-09 15:08:12 +00006303
John McCall77bb1aa2010-05-01 00:40:08 +00006304 if (RequireCompleteDeclContext(SS, LookupContext)) {
John McCall604e7f12009-12-08 07:46:18 +00006305 UD->setInvalidDecl();
6306 return UD;
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006307 }
6308
Richard Smithc5a89a12012-04-02 01:30:27 +00006309 // The normal rules do not apply to inheriting constructor declarations.
Sebastian Redlf677ea32011-02-05 19:23:19 +00006310 if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName) {
Richard Smithc5a89a12012-04-02 01:30:27 +00006311 if (CheckInheritingConstructorUsingDecl(UD))
Sebastian Redlcaa35e42011-03-12 13:44:32 +00006312 UD->setInvalidDecl();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006313 return UD;
6314 }
6315
6316 // Otherwise, look up the target name.
John McCall604e7f12009-12-08 07:46:18 +00006317
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006318 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCall7ba107a2009-11-18 02:36:19 +00006319
John McCall604e7f12009-12-08 07:46:18 +00006320 // Unlike most lookups, we don't always want to hide tag
6321 // declarations: tag names are visible through the using declaration
6322 // even if hidden by ordinary names, *except* in a dependent context
6323 // where it's important for the sanity of two-phase lookup.
John McCall7ba107a2009-11-18 02:36:19 +00006324 if (!IsInstantiation)
6325 R.setHideTags(false);
John McCall9488ea12009-11-17 05:59:44 +00006326
John McCallb9abd8722012-04-07 03:04:20 +00006327 // For the purposes of this lookup, we have a base object type
6328 // equal to that of the current context.
6329 if (CurContext->isRecord()) {
6330 R.setBaseObjectType(
6331 Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
6332 }
6333
John McCalla24dc2e2009-11-17 02:14:36 +00006334 LookupQualifiedName(R, LookupContext);
Mike Stump1eb44332009-09-09 15:08:12 +00006335
John McCallf36e02d2009-10-09 21:13:30 +00006336 if (R.empty()) {
Douglas Gregor3f093272009-10-13 21:16:44 +00006337 Diag(IdentLoc, diag::err_no_member)
Abramo Bagnaraef3dce82010-08-12 11:46:03 +00006338 << NameInfo.getName() << LookupContext << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00006339 UD->setInvalidDecl();
6340 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00006341 }
6342
John McCalled976492009-12-04 22:46:56 +00006343 if (R.isAmbiguous()) {
6344 UD->setInvalidDecl();
6345 return UD;
6346 }
Mike Stump1eb44332009-09-09 15:08:12 +00006347
John McCall7ba107a2009-11-18 02:36:19 +00006348 if (IsTypeName) {
6349 // If we asked for a typename and got a non-type decl, error out.
John McCalled976492009-12-04 22:46:56 +00006350 if (!R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00006351 Diag(IdentLoc, diag::err_using_typename_non_type);
6352 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
6353 Diag((*I)->getUnderlyingDecl()->getLocation(),
6354 diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00006355 UD->setInvalidDecl();
6356 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00006357 }
6358 } else {
6359 // If we asked for a non-typename and we got a type, error out,
6360 // but only if this is an instantiation of an unresolved using
6361 // decl. Otherwise just silently find the type name.
John McCalled976492009-12-04 22:46:56 +00006362 if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
John McCall7ba107a2009-11-18 02:36:19 +00006363 Diag(IdentLoc, diag::err_using_dependent_value_is_type);
6364 Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
John McCalled976492009-12-04 22:46:56 +00006365 UD->setInvalidDecl();
6366 return UD;
John McCall7ba107a2009-11-18 02:36:19 +00006367 }
Anders Carlssoncf9f9212009-08-28 03:16:11 +00006368 }
6369
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006370 // C++0x N2914 [namespace.udecl]p6:
6371 // A using-declaration shall not name a namespace.
John McCalled976492009-12-04 22:46:56 +00006372 if (R.getAsSingle<NamespaceDecl>()) {
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006373 Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
6374 << SS.getRange();
John McCalled976492009-12-04 22:46:56 +00006375 UD->setInvalidDecl();
6376 return UD;
Anders Carlsson73b39cf2009-08-28 03:35:18 +00006377 }
Mike Stump1eb44332009-09-09 15:08:12 +00006378
John McCall9f54ad42009-12-10 09:41:52 +00006379 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
6380 if (!CheckUsingShadowDecl(UD, *I, Previous))
6381 BuildUsingShadowDecl(S, UD, *I);
6382 }
John McCall9488ea12009-11-17 05:59:44 +00006383
6384 return UD;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00006385}
6386
Sebastian Redlf677ea32011-02-05 19:23:19 +00006387/// Additional checks for a using declaration referring to a constructor name.
Richard Smithc5a89a12012-04-02 01:30:27 +00006388bool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {
6389 assert(!UD->isTypeName() && "expecting a constructor name");
Sebastian Redlf677ea32011-02-05 19:23:19 +00006390
Douglas Gregordc355712011-02-25 00:36:19 +00006391 const Type *SourceType = UD->getQualifier()->getAsType();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006392 assert(SourceType &&
6393 "Using decl naming constructor doesn't have type in scope spec.");
6394 CXXRecordDecl *TargetClass = cast<CXXRecordDecl>(CurContext);
6395
6396 // Check whether the named type is a direct base class.
6397 CanQualType CanonicalSourceType = SourceType->getCanonicalTypeUnqualified();
6398 CXXRecordDecl::base_class_iterator BaseIt, BaseE;
6399 for (BaseIt = TargetClass->bases_begin(), BaseE = TargetClass->bases_end();
6400 BaseIt != BaseE; ++BaseIt) {
6401 CanQualType BaseType = BaseIt->getType()->getCanonicalTypeUnqualified();
6402 if (CanonicalSourceType == BaseType)
6403 break;
Richard Smithc5a89a12012-04-02 01:30:27 +00006404 if (BaseIt->getType()->isDependentType())
6405 break;
Sebastian Redlf677ea32011-02-05 19:23:19 +00006406 }
6407
6408 if (BaseIt == BaseE) {
6409 // Did not find SourceType in the bases.
6410 Diag(UD->getUsingLocation(),
6411 diag::err_using_decl_constructor_not_in_direct_base)
6412 << UD->getNameInfo().getSourceRange()
6413 << QualType(SourceType, 0) << TargetClass;
6414 return true;
6415 }
6416
Richard Smithc5a89a12012-04-02 01:30:27 +00006417 if (!CurContext->isDependentContext())
6418 BaseIt->setInheritConstructors();
Sebastian Redlf677ea32011-02-05 19:23:19 +00006419
6420 return false;
6421}
6422
John McCall9f54ad42009-12-10 09:41:52 +00006423/// Checks that the given using declaration is not an invalid
6424/// redeclaration. Note that this is checking only for the using decl
6425/// itself, not for any ill-formedness among the UsingShadowDecls.
6426bool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
6427 bool isTypeName,
6428 const CXXScopeSpec &SS,
6429 SourceLocation NameLoc,
6430 const LookupResult &Prev) {
6431 // C++03 [namespace.udecl]p8:
6432 // C++0x [namespace.udecl]p10:
6433 // A using-declaration is a declaration and can therefore be used
6434 // repeatedly where (and only where) multiple declarations are
6435 // allowed.
Douglas Gregora97badf2010-05-06 23:31:27 +00006436 //
John McCall8a726212010-11-29 18:01:58 +00006437 // That's in non-member contexts.
6438 if (!CurContext->getRedeclContext()->isRecord())
John McCall9f54ad42009-12-10 09:41:52 +00006439 return false;
6440
6441 NestedNameSpecifier *Qual
6442 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
6443
6444 for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {
6445 NamedDecl *D = *I;
6446
6447 bool DTypename;
6448 NestedNameSpecifier *DQual;
6449 if (UsingDecl *UD = dyn_cast<UsingDecl>(D)) {
6450 DTypename = UD->isTypeName();
Douglas Gregordc355712011-02-25 00:36:19 +00006451 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006452 } else if (UnresolvedUsingValueDecl *UD
6453 = dyn_cast<UnresolvedUsingValueDecl>(D)) {
6454 DTypename = false;
Douglas Gregordc355712011-02-25 00:36:19 +00006455 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006456 } else if (UnresolvedUsingTypenameDecl *UD
6457 = dyn_cast<UnresolvedUsingTypenameDecl>(D)) {
6458 DTypename = true;
Douglas Gregordc355712011-02-25 00:36:19 +00006459 DQual = UD->getQualifier();
John McCall9f54ad42009-12-10 09:41:52 +00006460 } else continue;
6461
6462 // using decls differ if one says 'typename' and the other doesn't.
6463 // FIXME: non-dependent using decls?
6464 if (isTypeName != DTypename) continue;
6465
6466 // using decls differ if they name different scopes (but note that
6467 // template instantiation can cause this check to trigger when it
6468 // didn't before instantiation).
6469 if (Context.getCanonicalNestedNameSpecifier(Qual) !=
6470 Context.getCanonicalNestedNameSpecifier(DQual))
6471 continue;
6472
6473 Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();
John McCall41ce66f2009-12-10 19:51:03 +00006474 Diag(D->getLocation(), diag::note_using_decl) << 1;
John McCall9f54ad42009-12-10 09:41:52 +00006475 return true;
6476 }
6477
6478 return false;
6479}
6480
John McCall604e7f12009-12-08 07:46:18 +00006481
John McCalled976492009-12-04 22:46:56 +00006482/// Checks that the given nested-name qualifier used in a using decl
6483/// in the current context is appropriately related to the current
6484/// scope. If an error is found, diagnoses it and returns true.
6485bool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc,
6486 const CXXScopeSpec &SS,
6487 SourceLocation NameLoc) {
John McCall604e7f12009-12-08 07:46:18 +00006488 DeclContext *NamedContext = computeDeclContext(SS);
John McCalled976492009-12-04 22:46:56 +00006489
John McCall604e7f12009-12-08 07:46:18 +00006490 if (!CurContext->isRecord()) {
6491 // C++03 [namespace.udecl]p3:
6492 // C++0x [namespace.udecl]p8:
6493 // A using-declaration for a class member shall be a member-declaration.
6494
6495 // If we weren't able to compute a valid scope, it must be a
6496 // dependent class scope.
6497 if (!NamedContext || NamedContext->isRecord()) {
6498 Diag(NameLoc, diag::err_using_decl_can_not_refer_to_class_member)
6499 << SS.getRange();
6500 return true;
6501 }
6502
6503 // Otherwise, everything is known to be fine.
6504 return false;
6505 }
6506
6507 // The current scope is a record.
6508
6509 // If the named context is dependent, we can't decide much.
6510 if (!NamedContext) {
6511 // FIXME: in C++0x, we can diagnose if we can prove that the
6512 // nested-name-specifier does not refer to a base class, which is
6513 // still possible in some cases.
6514
6515 // Otherwise we have to conservatively report that things might be
6516 // okay.
6517 return false;
6518 }
6519
6520 if (!NamedContext->isRecord()) {
6521 // Ideally this would point at the last name in the specifier,
6522 // but we don't have that level of source info.
6523 Diag(SS.getRange().getBegin(),
6524 diag::err_using_decl_nested_name_specifier_is_not_class)
6525 << (NestedNameSpecifier*) SS.getScopeRep() << SS.getRange();
6526 return true;
6527 }
6528
Douglas Gregor6fb07292010-12-21 07:41:49 +00006529 if (!NamedContext->isDependentContext() &&
6530 RequireCompleteDeclContext(const_cast<CXXScopeSpec&>(SS), NamedContext))
6531 return true;
6532
David Blaikie4e4d0842012-03-11 07:00:24 +00006533 if (getLangOpts().CPlusPlus0x) {
John McCall604e7f12009-12-08 07:46:18 +00006534 // C++0x [namespace.udecl]p3:
6535 // In a using-declaration used as a member-declaration, the
6536 // nested-name-specifier shall name a base class of the class
6537 // being defined.
6538
6539 if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(
6540 cast<CXXRecordDecl>(NamedContext))) {
6541 if (CurContext == NamedContext) {
6542 Diag(NameLoc,
6543 diag::err_using_decl_nested_name_specifier_is_current_class)
6544 << SS.getRange();
6545 return true;
6546 }
6547
6548 Diag(SS.getRange().getBegin(),
6549 diag::err_using_decl_nested_name_specifier_is_not_base_class)
6550 << (NestedNameSpecifier*) SS.getScopeRep()
6551 << cast<CXXRecordDecl>(CurContext)
6552 << SS.getRange();
6553 return true;
6554 }
6555
6556 return false;
6557 }
6558
6559 // C++03 [namespace.udecl]p4:
6560 // A using-declaration used as a member-declaration shall refer
6561 // to a member of a base class of the class being defined [etc.].
6562
6563 // Salient point: SS doesn't have to name a base class as long as
6564 // lookup only finds members from base classes. Therefore we can
6565 // diagnose here only if we can prove that that can't happen,
6566 // i.e. if the class hierarchies provably don't intersect.
6567
6568 // TODO: it would be nice if "definitely valid" results were cached
6569 // in the UsingDecl and UsingShadowDecl so that these checks didn't
6570 // need to be repeated.
6571
6572 struct UserData {
Benjamin Kramer8c43dcc2012-02-23 16:06:01 +00006573 llvm::SmallPtrSet<const CXXRecordDecl*, 4> Bases;
John McCall604e7f12009-12-08 07:46:18 +00006574
6575 static bool collect(const CXXRecordDecl *Base, void *OpaqueData) {
6576 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
6577 Data->Bases.insert(Base);
6578 return true;
6579 }
6580
6581 bool hasDependentBases(const CXXRecordDecl *Class) {
6582 return !Class->forallBases(collect, this);
6583 }
6584
6585 /// Returns true if the base is dependent or is one of the
6586 /// accumulated base classes.
6587 static bool doesNotContain(const CXXRecordDecl *Base, void *OpaqueData) {
6588 UserData *Data = reinterpret_cast<UserData*>(OpaqueData);
6589 return !Data->Bases.count(Base);
6590 }
6591
6592 bool mightShareBases(const CXXRecordDecl *Class) {
6593 return Bases.count(Class) || !Class->forallBases(doesNotContain, this);
6594 }
6595 };
6596
6597 UserData Data;
6598
6599 // Returns false if we find a dependent base.
6600 if (Data.hasDependentBases(cast<CXXRecordDecl>(CurContext)))
6601 return false;
6602
6603 // Returns false if the class has a dependent base or if it or one
6604 // of its bases is present in the base set of the current context.
6605 if (Data.mightShareBases(cast<CXXRecordDecl>(NamedContext)))
6606 return false;
6607
6608 Diag(SS.getRange().getBegin(),
6609 diag::err_using_decl_nested_name_specifier_is_not_base_class)
6610 << (NestedNameSpecifier*) SS.getScopeRep()
6611 << cast<CXXRecordDecl>(CurContext)
6612 << SS.getRange();
6613
6614 return true;
John McCalled976492009-12-04 22:46:56 +00006615}
6616
Richard Smith162e1c12011-04-15 14:24:37 +00006617Decl *Sema::ActOnAliasDeclaration(Scope *S,
6618 AccessSpecifier AS,
Richard Smith3e4c6c42011-05-05 21:57:07 +00006619 MultiTemplateParamsArg TemplateParamLists,
Richard Smith162e1c12011-04-15 14:24:37 +00006620 SourceLocation UsingLoc,
6621 UnqualifiedId &Name,
6622 TypeResult Type) {
Richard Smith3e4c6c42011-05-05 21:57:07 +00006623 // Skip up to the relevant declaration scope.
6624 while (S->getFlags() & Scope::TemplateParamScope)
6625 S = S->getParent();
Richard Smith162e1c12011-04-15 14:24:37 +00006626 assert((S->getFlags() & Scope::DeclScope) &&
6627 "got alias-declaration outside of declaration scope");
6628
6629 if (Type.isInvalid())
6630 return 0;
6631
6632 bool Invalid = false;
6633 DeclarationNameInfo NameInfo = GetNameFromUnqualifiedId(Name);
6634 TypeSourceInfo *TInfo = 0;
Nick Lewyckyb79bf1d2011-05-02 01:07:19 +00006635 GetTypeFromParser(Type.get(), &TInfo);
Richard Smith162e1c12011-04-15 14:24:37 +00006636
6637 if (DiagnoseClassNameShadow(CurContext, NameInfo))
6638 return 0;
6639
6640 if (DiagnoseUnexpandedParameterPack(Name.StartLocation, TInfo,
Richard Smith3e4c6c42011-05-05 21:57:07 +00006641 UPPC_DeclarationType)) {
Richard Smith162e1c12011-04-15 14:24:37 +00006642 Invalid = true;
Richard Smith3e4c6c42011-05-05 21:57:07 +00006643 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
6644 TInfo->getTypeLoc().getBeginLoc());
6645 }
Richard Smith162e1c12011-04-15 14:24:37 +00006646
6647 LookupResult Previous(*this, NameInfo, LookupOrdinaryName, ForRedeclaration);
6648 LookupName(Previous, S);
6649
6650 // Warn about shadowing the name of a template parameter.
6651 if (Previous.isSingleResult() &&
6652 Previous.getFoundDecl()->isTemplateParameter()) {
Douglas Gregorcb8f9512011-10-20 17:58:49 +00006653 DiagnoseTemplateParameterShadow(Name.StartLocation,Previous.getFoundDecl());
Richard Smith162e1c12011-04-15 14:24:37 +00006654 Previous.clear();
6655 }
6656
6657 assert(Name.Kind == UnqualifiedId::IK_Identifier &&
6658 "name in alias declaration must be an identifier");
6659 TypeAliasDecl *NewTD = TypeAliasDecl::Create(Context, CurContext, UsingLoc,
6660 Name.StartLocation,
6661 Name.Identifier, TInfo);
6662
6663 NewTD->setAccess(AS);
6664
6665 if (Invalid)
6666 NewTD->setInvalidDecl();
6667
Richard Smith3e4c6c42011-05-05 21:57:07 +00006668 CheckTypedefForVariablyModifiedType(S, NewTD);
6669 Invalid |= NewTD->isInvalidDecl();
6670
Richard Smith162e1c12011-04-15 14:24:37 +00006671 bool Redeclaration = false;
Richard Smith3e4c6c42011-05-05 21:57:07 +00006672
6673 NamedDecl *NewND;
6674 if (TemplateParamLists.size()) {
6675 TypeAliasTemplateDecl *OldDecl = 0;
6676 TemplateParameterList *OldTemplateParams = 0;
6677
6678 if (TemplateParamLists.size() != 1) {
6679 Diag(UsingLoc, diag::err_alias_template_extra_headers)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006680 << SourceRange(TemplateParamLists[1]->getTemplateLoc(),
6681 TemplateParamLists[TemplateParamLists.size()-1]->getRAngleLoc());
Richard Smith3e4c6c42011-05-05 21:57:07 +00006682 }
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006683 TemplateParameterList *TemplateParams = TemplateParamLists[0];
Richard Smith3e4c6c42011-05-05 21:57:07 +00006684
6685 // Only consider previous declarations in the same scope.
6686 FilterLookupForScope(Previous, CurContext, S, /*ConsiderLinkage*/false,
6687 /*ExplicitInstantiationOrSpecialization*/false);
6688 if (!Previous.empty()) {
6689 Redeclaration = true;
6690
6691 OldDecl = Previous.getAsSingle<TypeAliasTemplateDecl>();
6692 if (!OldDecl && !Invalid) {
6693 Diag(UsingLoc, diag::err_redefinition_different_kind)
6694 << Name.Identifier;
6695
6696 NamedDecl *OldD = Previous.getRepresentativeDecl();
6697 if (OldD->getLocation().isValid())
6698 Diag(OldD->getLocation(), diag::note_previous_definition);
6699
6700 Invalid = true;
6701 }
6702
6703 if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {
6704 if (TemplateParameterListsAreEqual(TemplateParams,
6705 OldDecl->getTemplateParameters(),
6706 /*Complain=*/true,
6707 TPL_TemplateMatch))
6708 OldTemplateParams = OldDecl->getTemplateParameters();
6709 else
6710 Invalid = true;
6711
6712 TypeAliasDecl *OldTD = OldDecl->getTemplatedDecl();
6713 if (!Invalid &&
6714 !Context.hasSameType(OldTD->getUnderlyingType(),
6715 NewTD->getUnderlyingType())) {
6716 // FIXME: The C++0x standard does not clearly say this is ill-formed,
6717 // but we can't reasonably accept it.
6718 Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef)
6719 << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();
6720 if (OldTD->getLocation().isValid())
6721 Diag(OldTD->getLocation(), diag::note_previous_definition);
6722 Invalid = true;
6723 }
6724 }
6725 }
6726
6727 // Merge any previous default template arguments into our parameters,
6728 // and check the parameter list.
6729 if (CheckTemplateParameterList(TemplateParams, OldTemplateParams,
6730 TPC_TypeAliasTemplate))
6731 return 0;
6732
6733 TypeAliasTemplateDecl *NewDecl =
6734 TypeAliasTemplateDecl::Create(Context, CurContext, UsingLoc,
6735 Name.Identifier, TemplateParams,
6736 NewTD);
6737
6738 NewDecl->setAccess(AS);
6739
6740 if (Invalid)
6741 NewDecl->setInvalidDecl();
6742 else if (OldDecl)
6743 NewDecl->setPreviousDeclaration(OldDecl);
6744
6745 NewND = NewDecl;
6746 } else {
6747 ActOnTypedefNameDecl(S, CurContext, NewTD, Previous, Redeclaration);
6748 NewND = NewTD;
6749 }
Richard Smith162e1c12011-04-15 14:24:37 +00006750
6751 if (!Redeclaration)
Richard Smith3e4c6c42011-05-05 21:57:07 +00006752 PushOnScopeChains(NewND, S);
Richard Smith162e1c12011-04-15 14:24:37 +00006753
Dmitri Gribenkoc27bc802012-08-02 20:49:51 +00006754 ActOnDocumentableDecl(NewND);
Richard Smith3e4c6c42011-05-05 21:57:07 +00006755 return NewND;
Richard Smith162e1c12011-04-15 14:24:37 +00006756}
6757
John McCalld226f652010-08-21 09:40:31 +00006758Decl *Sema::ActOnNamespaceAliasDef(Scope *S,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00006759 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00006760 SourceLocation AliasLoc,
6761 IdentifierInfo *Alias,
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00006762 CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00006763 SourceLocation IdentLoc,
6764 IdentifierInfo *Ident) {
Mike Stump1eb44332009-09-09 15:08:12 +00006765
Anders Carlsson81c85c42009-03-28 23:53:49 +00006766 // Lookup the namespace name.
John McCalla24dc2e2009-11-17 02:14:36 +00006767 LookupResult R(*this, Ident, IdentLoc, LookupNamespaceName);
6768 LookupParsedName(R, S, &SS);
Anders Carlsson81c85c42009-03-28 23:53:49 +00006769
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006770 // Check if we have a previous declaration with the same name.
Douglas Gregorae374752010-05-03 15:37:31 +00006771 NamedDecl *PrevDecl
6772 = LookupSingleName(S, Alias, AliasLoc, LookupOrdinaryName,
6773 ForRedeclaration);
6774 if (PrevDecl && !isDeclInScope(PrevDecl, CurContext, S))
6775 PrevDecl = 0;
6776
6777 if (PrevDecl) {
Anders Carlsson81c85c42009-03-28 23:53:49 +00006778 if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {
Mike Stump1eb44332009-09-09 15:08:12 +00006779 // We already have an alias with the same name that points to the same
Anders Carlsson81c85c42009-03-28 23:53:49 +00006780 // namespace, so don't create a new one.
Douglas Gregorc67b0322010-03-26 22:59:39 +00006781 // FIXME: At some point, we'll want to create the (redundant)
6782 // declaration to maintain better source information.
John McCallf36e02d2009-10-09 21:13:30 +00006783 if (!R.isAmbiguous() && !R.empty() &&
Douglas Gregorc67b0322010-03-26 22:59:39 +00006784 AD->getNamespace()->Equals(getNamespaceDecl(R.getFoundDecl())))
John McCalld226f652010-08-21 09:40:31 +00006785 return 0;
Anders Carlsson81c85c42009-03-28 23:53:49 +00006786 }
Mike Stump1eb44332009-09-09 15:08:12 +00006787
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006788 unsigned DiagID = isa<NamespaceDecl>(PrevDecl) ? diag::err_redefinition :
6789 diag::err_redefinition_different_kind;
6790 Diag(AliasLoc, DiagID) << Alias;
6791 Diag(PrevDecl->getLocation(), diag::note_previous_definition);
John McCalld226f652010-08-21 09:40:31 +00006792 return 0;
Anders Carlsson8d7ba402009-03-28 06:23:46 +00006793 }
6794
John McCalla24dc2e2009-11-17 02:14:36 +00006795 if (R.isAmbiguous())
John McCalld226f652010-08-21 09:40:31 +00006796 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00006797
John McCallf36e02d2009-10-09 21:13:30 +00006798 if (R.empty()) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00006799 if (!TryNamespaceTypoCorrection(*this, R, S, SS, IdentLoc, Ident)) {
Richard Smithbf9658c2012-04-05 23:13:23 +00006800 Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
John McCalld226f652010-08-21 09:40:31 +00006801 return 0;
Douglas Gregor0e8c4b92010-06-29 18:55:19 +00006802 }
Anders Carlsson5721c682009-03-28 06:42:02 +00006803 }
Mike Stump1eb44332009-09-09 15:08:12 +00006804
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006805 NamespaceAliasDecl *AliasDecl =
Mike Stump1eb44332009-09-09 15:08:12 +00006806 NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
Douglas Gregor0cfaf6a2011-02-25 17:08:07 +00006807 Alias, SS.getWithLocInContext(Context),
John McCallf36e02d2009-10-09 21:13:30 +00006808 IdentLoc, R.getFoundDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00006809
John McCall3dbd3d52010-02-16 06:53:13 +00006810 PushOnScopeChains(AliasDecl, S);
John McCalld226f652010-08-21 09:40:31 +00006811 return AliasDecl;
Anders Carlssondbb00942009-03-28 05:27:17 +00006812}
6813
Douglas Gregor39957dc2010-05-01 15:04:51 +00006814namespace {
6815 /// \brief Scoped object used to handle the state changes required in Sema
6816 /// to implicitly define the body of a C++ member function;
6817 class ImplicitlyDefinedFunctionScope {
6818 Sema &S;
John McCalleee1d542011-02-14 07:13:47 +00006819 Sema::ContextRAII SavedContext;
Douglas Gregor39957dc2010-05-01 15:04:51 +00006820
6821 public:
6822 ImplicitlyDefinedFunctionScope(Sema &S, CXXMethodDecl *Method)
John McCalleee1d542011-02-14 07:13:47 +00006823 : S(S), SavedContext(S, Method)
Douglas Gregor39957dc2010-05-01 15:04:51 +00006824 {
Douglas Gregor39957dc2010-05-01 15:04:51 +00006825 S.PushFunctionScope();
6826 S.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated);
6827 }
6828
6829 ~ImplicitlyDefinedFunctionScope() {
6830 S.PopExpressionEvaluationContext();
Eli Friedmanec9ea722012-01-05 03:35:19 +00006831 S.PopFunctionScopeInfo();
Douglas Gregor39957dc2010-05-01 15:04:51 +00006832 }
6833 };
6834}
6835
Sean Hunt001cad92011-05-10 00:49:42 +00006836Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00006837Sema::ComputeDefaultedDefaultCtorExceptionSpec(SourceLocation Loc,
6838 CXXMethodDecl *MD) {
6839 CXXRecordDecl *ClassDecl = MD->getParent();
6840
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006841 // C++ [except.spec]p14:
6842 // An implicitly declared special member function (Clause 12) shall have an
6843 // exception-specification. [...]
Richard Smithe6975e92012-04-17 00:58:00 +00006844 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00006845 if (ClassDecl->isInvalidDecl())
6846 return ExceptSpec;
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006847
Sebastian Redl60618fa2011-03-12 11:50:43 +00006848 // Direct base-class constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006849 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
6850 BEnd = ClassDecl->bases_end();
6851 B != BEnd; ++B) {
6852 if (B->isVirtual()) // Handled below.
6853 continue;
6854
Douglas Gregor18274032010-07-03 00:47:00 +00006855 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
6856 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Sean Huntb320e0c2011-06-10 03:50:41 +00006857 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
6858 // If this is a deleted function, add it anyway. This might be conformant
6859 // with the standard. This might not. I'm not sure. It might not matter.
6860 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006861 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006862 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006863 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00006864
6865 // Virtual base-class constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006866 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
6867 BEnd = ClassDecl->vbases_end();
6868 B != BEnd; ++B) {
Douglas Gregor18274032010-07-03 00:47:00 +00006869 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
6870 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Sean Huntb320e0c2011-06-10 03:50:41 +00006871 CXXConstructorDecl *Constructor = LookupDefaultConstructor(BaseClassDecl);
6872 // If this is a deleted function, add it anyway. This might be conformant
6873 // with the standard. This might not. I'm not sure. It might not matter.
6874 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006875 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006876 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006877 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00006878
6879 // Field constructors.
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006880 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
6881 FEnd = ClassDecl->field_end();
6882 F != FEnd; ++F) {
Richard Smith7a614d82011-06-11 17:19:42 +00006883 if (F->hasInClassInitializer()) {
6884 if (Expr *E = F->getInClassInitializer())
6885 ExceptSpec.CalledExpr(E);
6886 else if (!F->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00006887 // DR1351:
6888 // If the brace-or-equal-initializer of a non-static data member
6889 // invokes a defaulted default constructor of its class or of an
6890 // enclosing class in a potentially evaluated subexpression, the
6891 // program is ill-formed.
6892 //
6893 // This resolution is unworkable: the exception specification of the
6894 // default constructor can be needed in an unevaluated context, in
6895 // particular, in the operand of a noexcept-expression, and we can be
6896 // unable to compute an exception specification for an enclosed class.
6897 //
6898 // We do not allow an in-class initializer to require the evaluation
6899 // of the exception specification for any in-class initializer whose
6900 // definition is not lexically complete.
6901 Diag(Loc, diag::err_in_class_initializer_references_def_ctor) << MD;
Richard Smith7a614d82011-06-11 17:19:42 +00006902 } else if (const RecordType *RecordTy
Douglas Gregor18274032010-07-03 00:47:00 +00006903 = Context.getBaseElementType(F->getType())->getAs<RecordType>()) {
Sean Huntb320e0c2011-06-10 03:50:41 +00006904 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
6905 CXXConstructorDecl *Constructor = LookupDefaultConstructor(FieldRecDecl);
6906 // If this is a deleted function, add it anyway. This might be conformant
6907 // with the standard. This might not. I'm not sure. It might not matter.
6908 // In particular, the problem is that this function never gets called. It
6909 // might just be ill-formed because this function attempts to refer to
6910 // a deleted function here.
6911 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00006912 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Douglas Gregor18274032010-07-03 00:47:00 +00006913 }
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006914 }
John McCalle23cf432010-12-14 08:05:40 +00006915
Sean Hunt001cad92011-05-10 00:49:42 +00006916 return ExceptSpec;
6917}
6918
6919CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
6920 CXXRecordDecl *ClassDecl) {
6921 // C++ [class.ctor]p5:
6922 // A default constructor for a class X is a constructor of class X
6923 // that can be called without an argument. If there is no
6924 // user-declared constructor for class X, a default constructor is
6925 // implicitly declared. An implicitly-declared default constructor
6926 // is an inline public member of its class.
6927 assert(!ClassDecl->hasUserDeclaredConstructor() &&
6928 "Should not build implicit default constructor!");
6929
Richard Smith7756afa2012-06-10 05:43:50 +00006930 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
6931 CXXDefaultConstructor,
6932 false);
6933
Douglas Gregoreb8c6702010-07-01 22:31:05 +00006934 // Create the actual constructor declaration.
Douglas Gregor32df23e2010-07-01 22:02:46 +00006935 CanQualType ClassType
6936 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00006937 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregor32df23e2010-07-01 22:02:46 +00006938 DeclarationName Name
6939 = Context.DeclarationNames.getCXXConstructorName(ClassType);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00006940 DeclarationNameInfo NameInfo(Name, ClassLoc);
Richard Smith61802452011-12-22 02:22:31 +00006941 CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00006942 Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00006943 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00006944 Constexpr);
Douglas Gregor32df23e2010-07-01 22:02:46 +00006945 DefaultCon->setAccess(AS_public);
Sean Hunt1e238652011-05-12 03:51:51 +00006946 DefaultCon->setDefaulted();
Douglas Gregor32df23e2010-07-01 22:02:46 +00006947 DefaultCon->setImplicit();
Sean Hunt023df372011-05-09 18:22:59 +00006948 DefaultCon->setTrivial(ClassDecl->hasTrivialDefaultConstructor());
Richard Smithb9d0b762012-07-27 04:22:15 +00006949
6950 // Build an exception specification pointing back at this constructor.
6951 FunctionProtoType::ExtProtoInfo EPI;
6952 EPI.ExceptionSpecType = EST_Unevaluated;
6953 EPI.ExceptionSpecDecl = DefaultCon;
6954 DefaultCon->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
6955
Douglas Gregor18274032010-07-03 00:47:00 +00006956 // Note that we have declared this constructor.
Douglas Gregor18274032010-07-03 00:47:00 +00006957 ++ASTContext::NumImplicitDefaultConstructorsDeclared;
6958
Douglas Gregor23c94db2010-07-02 17:43:08 +00006959 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor18274032010-07-03 00:47:00 +00006960 PushOnScopeChains(DefaultCon, S, false);
6961 ClassDecl->addDecl(DefaultCon);
Sean Hunt71a682f2011-05-18 03:41:58 +00006962
Sean Hunte16da072011-10-10 06:18:57 +00006963 if (ShouldDeleteSpecialMember(DefaultCon, CXXDefaultConstructor))
Sean Hunt71a682f2011-05-18 03:41:58 +00006964 DefaultCon->setDeletedAsWritten();
Douglas Gregor18274032010-07-03 00:47:00 +00006965
Douglas Gregor32df23e2010-07-01 22:02:46 +00006966 return DefaultCon;
6967}
6968
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006969void Sema::DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
6970 CXXConstructorDecl *Constructor) {
Sean Hunt1e238652011-05-12 03:51:51 +00006971 assert((Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Sean Huntcd10dec2011-05-23 23:14:04 +00006972 !Constructor->doesThisDeclarationHaveABody() &&
6973 !Constructor->isDeleted()) &&
Fariborz Jahanian05a5c452009-06-22 20:37:23 +00006974 "DefineImplicitDefaultConstructor - call it for implicit default ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00006975
Anders Carlssonf6513ed2010-04-23 16:04:08 +00006976 CXXRecordDecl *ClassDecl = Constructor->getParent();
Eli Friedman80c30da2009-11-09 19:20:36 +00006977 assert(ClassDecl && "DefineImplicitDefaultConstructor - invalid constructor");
Eli Friedman49c16da2009-11-09 01:05:47 +00006978
Douglas Gregor39957dc2010-05-01 15:04:51 +00006979 ImplicitlyDefinedFunctionScope Scope(*this, Constructor);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00006980 DiagnosticErrorTrap Trap(Diags);
Sean Huntcbb67482011-01-08 20:30:50 +00006981 if (SetCtorInitializers(Constructor, 0, 0, /*AnyErrors=*/false) ||
Douglas Gregorc63d2c82010-05-12 16:39:35 +00006982 Trap.hasErrorOccurred()) {
Anders Carlsson37909802009-11-30 21:24:50 +00006983 Diag(CurrentLocation, diag::note_member_synthesized_at)
Sean Huntf961ea52011-05-10 19:08:14 +00006984 << CXXDefaultConstructor << Context.getTagDeclType(ClassDecl);
Eli Friedman80c30da2009-11-09 19:20:36 +00006985 Constructor->setInvalidDecl();
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006986 return;
Eli Friedman80c30da2009-11-09 19:20:36 +00006987 }
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006988
6989 SourceLocation Loc = Constructor->getLocation();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00006990 Constructor->setBody(new (Context) CompoundStmt(Loc));
Douglas Gregor4ada9d32010-09-20 16:48:21 +00006991
6992 Constructor->setUsed();
6993 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redl58a2cd82011-04-24 16:28:06 +00006994
6995 if (ASTMutationListener *L = getASTMutationListener()) {
6996 L->CompletedImplicitDefinition(Constructor);
6997 }
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00006998}
6999
Richard Smith7a614d82011-06-11 17:19:42 +00007000void Sema::ActOnFinishDelayedMemberInitializers(Decl *D) {
7001 if (!D) return;
7002 AdjustDeclIfTemplate(D);
7003
7004 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D);
Richard Smith7a614d82011-06-11 17:19:42 +00007005
Richard Smithb9d0b762012-07-27 04:22:15 +00007006 if (!ClassDecl->isDependentType())
7007 CheckExplicitlyDefaultedMethods(ClassDecl);
Richard Smith7a614d82011-06-11 17:19:42 +00007008}
7009
Sebastian Redlf677ea32011-02-05 19:23:19 +00007010void Sema::DeclareInheritedConstructors(CXXRecordDecl *ClassDecl) {
7011 // We start with an initial pass over the base classes to collect those that
7012 // inherit constructors from. If there are none, we can forgo all further
7013 // processing.
Chris Lattner5f9e2722011-07-23 10:55:15 +00007014 typedef SmallVector<const RecordType *, 4> BasesVector;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007015 BasesVector BasesToInheritFrom;
7016 for (CXXRecordDecl::base_class_iterator BaseIt = ClassDecl->bases_begin(),
7017 BaseE = ClassDecl->bases_end();
7018 BaseIt != BaseE; ++BaseIt) {
7019 if (BaseIt->getInheritConstructors()) {
7020 QualType Base = BaseIt->getType();
7021 if (Base->isDependentType()) {
7022 // If we inherit constructors from anything that is dependent, just
7023 // abort processing altogether. We'll get another chance for the
7024 // instantiations.
7025 return;
7026 }
7027 BasesToInheritFrom.push_back(Base->castAs<RecordType>());
7028 }
7029 }
7030 if (BasesToInheritFrom.empty())
7031 return;
7032
7033 // Now collect the constructors that we already have in the current class.
7034 // Those take precedence over inherited constructors.
7035 // C++0x [class.inhctor]p3: [...] a constructor is implicitly declared [...]
7036 // unless there is a user-declared constructor with the same signature in
7037 // the class where the using-declaration appears.
7038 llvm::SmallSet<const Type *, 8> ExistingConstructors;
7039 for (CXXRecordDecl::ctor_iterator CtorIt = ClassDecl->ctor_begin(),
7040 CtorE = ClassDecl->ctor_end();
7041 CtorIt != CtorE; ++CtorIt) {
7042 ExistingConstructors.insert(
7043 Context.getCanonicalType(CtorIt->getType()).getTypePtr());
7044 }
7045
Sebastian Redlf677ea32011-02-05 19:23:19 +00007046 DeclarationName CreatedCtorName =
7047 Context.DeclarationNames.getCXXConstructorName(
7048 ClassDecl->getTypeForDecl()->getCanonicalTypeUnqualified());
7049
7050 // Now comes the true work.
7051 // First, we keep a map from constructor types to the base that introduced
7052 // them. Needed for finding conflicting constructors. We also keep the
7053 // actually inserted declarations in there, for pretty diagnostics.
7054 typedef std::pair<CanQualType, CXXConstructorDecl *> ConstructorInfo;
7055 typedef llvm::DenseMap<const Type *, ConstructorInfo> ConstructorToSourceMap;
7056 ConstructorToSourceMap InheritedConstructors;
7057 for (BasesVector::iterator BaseIt = BasesToInheritFrom.begin(),
7058 BaseE = BasesToInheritFrom.end();
7059 BaseIt != BaseE; ++BaseIt) {
7060 const RecordType *Base = *BaseIt;
7061 CanQualType CanonicalBase = Base->getCanonicalTypeUnqualified();
7062 CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(Base->getDecl());
7063 for (CXXRecordDecl::ctor_iterator CtorIt = BaseDecl->ctor_begin(),
7064 CtorE = BaseDecl->ctor_end();
7065 CtorIt != CtorE; ++CtorIt) {
7066 // Find the using declaration for inheriting this base's constructors.
Richard Smithc5a89a12012-04-02 01:30:27 +00007067 // FIXME: Don't perform name lookup just to obtain a source location!
Sebastian Redlf677ea32011-02-05 19:23:19 +00007068 DeclarationName Name =
7069 Context.DeclarationNames.getCXXConstructorName(CanonicalBase);
Richard Smithc5a89a12012-04-02 01:30:27 +00007070 LookupResult Result(*this, Name, SourceLocation(), LookupUsingDeclName);
7071 LookupQualifiedName(Result, CurContext);
7072 UsingDecl *UD = Result.getAsSingle<UsingDecl>();
Sebastian Redlf677ea32011-02-05 19:23:19 +00007073 SourceLocation UsingLoc = UD ? UD->getLocation() :
7074 ClassDecl->getLocation();
7075
7076 // C++0x [class.inhctor]p1: The candidate set of inherited constructors
7077 // from the class X named in the using-declaration consists of actual
7078 // constructors and notional constructors that result from the
7079 // transformation of defaulted parameters as follows:
7080 // - all non-template default constructors of X, and
7081 // - for each non-template constructor of X that has at least one
7082 // parameter with a default argument, the set of constructors that
7083 // results from omitting any ellipsis parameter specification and
7084 // successively omitting parameters with a default argument from the
7085 // end of the parameter-type-list.
David Blaikie581deb32012-06-06 20:45:41 +00007086 CXXConstructorDecl *BaseCtor = *CtorIt;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007087 bool CanBeCopyOrMove = BaseCtor->isCopyOrMoveConstructor();
7088 const FunctionProtoType *BaseCtorType =
7089 BaseCtor->getType()->getAs<FunctionProtoType>();
7090
7091 for (unsigned params = BaseCtor->getMinRequiredArguments(),
7092 maxParams = BaseCtor->getNumParams();
7093 params <= maxParams; ++params) {
7094 // Skip default constructors. They're never inherited.
7095 if (params == 0)
7096 continue;
7097 // Skip copy and move constructors for the same reason.
7098 if (CanBeCopyOrMove && params == 1)
7099 continue;
7100
7101 // Build up a function type for this particular constructor.
7102 // FIXME: The working paper does not consider that the exception spec
7103 // for the inheriting constructor might be larger than that of the
Richard Smith7a614d82011-06-11 17:19:42 +00007104 // source. This code doesn't yet, either. When it does, this code will
7105 // need to be delayed until after exception specifications and in-class
7106 // member initializers are attached.
Sebastian Redlf677ea32011-02-05 19:23:19 +00007107 const Type *NewCtorType;
7108 if (params == maxParams)
7109 NewCtorType = BaseCtorType;
7110 else {
Chris Lattner5f9e2722011-07-23 10:55:15 +00007111 SmallVector<QualType, 16> Args;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007112 for (unsigned i = 0; i < params; ++i) {
7113 Args.push_back(BaseCtorType->getArgType(i));
7114 }
7115 FunctionProtoType::ExtProtoInfo ExtInfo =
7116 BaseCtorType->getExtProtoInfo();
7117 ExtInfo.Variadic = false;
7118 NewCtorType = Context.getFunctionType(BaseCtorType->getResultType(),
7119 Args.data(), params, ExtInfo)
7120 .getTypePtr();
7121 }
7122 const Type *CanonicalNewCtorType =
7123 Context.getCanonicalType(NewCtorType);
7124
7125 // Now that we have the type, first check if the class already has a
7126 // constructor with this signature.
7127 if (ExistingConstructors.count(CanonicalNewCtorType))
7128 continue;
7129
7130 // Then we check if we have already declared an inherited constructor
7131 // with this signature.
7132 std::pair<ConstructorToSourceMap::iterator, bool> result =
7133 InheritedConstructors.insert(std::make_pair(
7134 CanonicalNewCtorType,
7135 std::make_pair(CanonicalBase, (CXXConstructorDecl*)0)));
7136 if (!result.second) {
7137 // Already in the map. If it came from a different class, that's an
7138 // error. Not if it's from the same.
7139 CanQualType PreviousBase = result.first->second.first;
7140 if (CanonicalBase != PreviousBase) {
7141 const CXXConstructorDecl *PrevCtor = result.first->second.second;
7142 const CXXConstructorDecl *PrevBaseCtor =
7143 PrevCtor->getInheritedConstructor();
7144 assert(PrevBaseCtor && "Conflicting constructor was not inherited");
7145
7146 Diag(UsingLoc, diag::err_using_decl_constructor_conflict);
7147 Diag(BaseCtor->getLocation(),
7148 diag::note_using_decl_constructor_conflict_current_ctor);
7149 Diag(PrevBaseCtor->getLocation(),
7150 diag::note_using_decl_constructor_conflict_previous_ctor);
7151 Diag(PrevCtor->getLocation(),
7152 diag::note_using_decl_constructor_conflict_previous_using);
7153 }
7154 continue;
7155 }
7156
7157 // OK, we're there, now add the constructor.
7158 // C++0x [class.inhctor]p8: [...] that would be performed by a
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007159 // user-written inline constructor [...]
Sebastian Redlf677ea32011-02-05 19:23:19 +00007160 DeclarationNameInfo DNI(CreatedCtorName, UsingLoc);
7161 CXXConstructorDecl *NewCtor = CXXConstructorDecl::Create(
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007162 Context, ClassDecl, UsingLoc, DNI, QualType(NewCtorType, 0),
7163 /*TInfo=*/0, BaseCtor->isExplicit(), /*Inline=*/true,
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007164 /*ImplicitlyDeclared=*/true,
7165 // FIXME: Due to a defect in the standard, we treat inherited
7166 // constructors as constexpr even if that makes them ill-formed.
7167 /*Constexpr=*/BaseCtor->isConstexpr());
Sebastian Redlf677ea32011-02-05 19:23:19 +00007168 NewCtor->setAccess(BaseCtor->getAccess());
7169
7170 // Build up the parameter decls and add them.
Chris Lattner5f9e2722011-07-23 10:55:15 +00007171 SmallVector<ParmVarDecl *, 16> ParamDecls;
Sebastian Redlf677ea32011-02-05 19:23:19 +00007172 for (unsigned i = 0; i < params; ++i) {
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007173 ParamDecls.push_back(ParmVarDecl::Create(Context, NewCtor,
7174 UsingLoc, UsingLoc,
Sebastian Redlf677ea32011-02-05 19:23:19 +00007175 /*IdentifierInfo=*/0,
7176 BaseCtorType->getArgType(i),
7177 /*TInfo=*/0, SC_None,
7178 SC_None, /*DefaultArg=*/0));
7179 }
David Blaikie4278c652011-09-21 18:16:56 +00007180 NewCtor->setParams(ParamDecls);
Sebastian Redlf677ea32011-02-05 19:23:19 +00007181 NewCtor->setInheritedConstructor(BaseCtor);
7182
Sebastian Redlf677ea32011-02-05 19:23:19 +00007183 ClassDecl->addDecl(NewCtor);
7184 result.first->second.second = NewCtor;
7185 }
7186 }
7187 }
7188}
7189
Sean Huntcb45a0f2011-05-12 22:46:25 +00007190Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00007191Sema::ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD) {
7192 CXXRecordDecl *ClassDecl = MD->getParent();
7193
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007194 // C++ [except.spec]p14:
7195 // An implicitly declared special member function (Clause 12) shall have
7196 // an exception-specification.
Richard Smithe6975e92012-04-17 00:58:00 +00007197 ImplicitExceptionSpecification ExceptSpec(*this);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007198 if (ClassDecl->isInvalidDecl())
7199 return ExceptSpec;
7200
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007201 // Direct base-class destructors.
7202 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
7203 BEnd = ClassDecl->bases_end();
7204 B != BEnd; ++B) {
7205 if (B->isVirtual()) // Handled below.
7206 continue;
7207
7208 if (const RecordType *BaseType = B->getType()->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007209 ExceptSpec.CalledDecl(B->getLocStart(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007210 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007211 }
Sebastian Redl0ee33912011-05-19 05:13:44 +00007212
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007213 // Virtual base-class destructors.
7214 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
7215 BEnd = ClassDecl->vbases_end();
7216 B != BEnd; ++B) {
7217 if (const RecordType *BaseType = B->getType()->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007218 ExceptSpec.CalledDecl(B->getLocStart(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007219 LookupDestructor(cast<CXXRecordDecl>(BaseType->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007220 }
Sebastian Redl0ee33912011-05-19 05:13:44 +00007221
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007222 // Field destructors.
7223 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
7224 FEnd = ClassDecl->field_end();
7225 F != FEnd; ++F) {
7226 if (const RecordType *RecordTy
7227 = Context.getBaseElementType(F->getType())->getAs<RecordType>())
Richard Smithe6975e92012-04-17 00:58:00 +00007228 ExceptSpec.CalledDecl(F->getLocation(),
Sebastian Redl0ee33912011-05-19 05:13:44 +00007229 LookupDestructor(cast<CXXRecordDecl>(RecordTy->getDecl())));
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007230 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00007231
Sean Huntcb45a0f2011-05-12 22:46:25 +00007232 return ExceptSpec;
7233}
7234
7235CXXDestructorDecl *Sema::DeclareImplicitDestructor(CXXRecordDecl *ClassDecl) {
7236 // C++ [class.dtor]p2:
7237 // If a class has no user-declared destructor, a destructor is
7238 // declared implicitly. An implicitly-declared destructor is an
7239 // inline public member of its class.
Sean Huntcb45a0f2011-05-12 22:46:25 +00007240
Douglas Gregor4923aa22010-07-02 20:37:36 +00007241 // Create the actual destructor declaration.
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007242 CanQualType ClassType
7243 = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007244 SourceLocation ClassLoc = ClassDecl->getLocation();
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007245 DeclarationName Name
7246 = Context.DeclarationNames.getCXXDestructorName(ClassType);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007247 DeclarationNameInfo NameInfo(Name, ClassLoc);
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007248 CXXDestructorDecl *Destructor
Richard Smithb9d0b762012-07-27 04:22:15 +00007249 = CXXDestructorDecl::Create(Context, ClassDecl, ClassLoc, NameInfo,
7250 QualType(), 0, /*isInline=*/true,
Sebastian Redl60618fa2011-03-12 11:50:43 +00007251 /*isImplicitlyDeclared=*/true);
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007252 Destructor->setAccess(AS_public);
Sean Huntcb45a0f2011-05-12 22:46:25 +00007253 Destructor->setDefaulted();
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007254 Destructor->setImplicit();
7255 Destructor->setTrivial(ClassDecl->hasTrivialDestructor());
Richard Smithb9d0b762012-07-27 04:22:15 +00007256
7257 // Build an exception specification pointing back at this destructor.
7258 FunctionProtoType::ExtProtoInfo EPI;
7259 EPI.ExceptionSpecType = EST_Unevaluated;
7260 EPI.ExceptionSpecDecl = Destructor;
7261 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
7262
Douglas Gregor4923aa22010-07-02 20:37:36 +00007263 // Note that we have declared this destructor.
Douglas Gregor4923aa22010-07-02 20:37:36 +00007264 ++ASTContext::NumImplicitDestructorsDeclared;
Richard Smithb9d0b762012-07-27 04:22:15 +00007265
Douglas Gregor4923aa22010-07-02 20:37:36 +00007266 // Introduce this destructor into its scope.
Douglas Gregor23c94db2010-07-02 17:43:08 +00007267 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor4923aa22010-07-02 20:37:36 +00007268 PushOnScopeChains(Destructor, S, false);
7269 ClassDecl->addDecl(Destructor);
Sean Huntcb45a0f2011-05-12 22:46:25 +00007270
Richard Smith9a561d52012-02-26 09:11:52 +00007271 AddOverriddenMethods(ClassDecl, Destructor);
7272
Richard Smith7d5088a2012-02-18 02:02:13 +00007273 if (ShouldDeleteSpecialMember(Destructor, CXXDestructor))
Sean Huntcb45a0f2011-05-12 22:46:25 +00007274 Destructor->setDeletedAsWritten();
Richard Smith9a561d52012-02-26 09:11:52 +00007275
Douglas Gregorfabd43a2010-07-01 19:09:28 +00007276 return Destructor;
7277}
7278
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007279void Sema::DefineImplicitDestructor(SourceLocation CurrentLocation,
Douglas Gregor4fe95f92009-09-04 19:04:08 +00007280 CXXDestructorDecl *Destructor) {
Sean Huntcd10dec2011-05-23 23:14:04 +00007281 assert((Destructor->isDefaulted() &&
Richard Smith03f68782012-02-26 07:51:39 +00007282 !Destructor->doesThisDeclarationHaveABody() &&
7283 !Destructor->isDeleted()) &&
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007284 "DefineImplicitDestructor - call it for implicit default dtor");
Anders Carlsson6d701392009-11-15 22:49:34 +00007285 CXXRecordDecl *ClassDecl = Destructor->getParent();
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007286 assert(ClassDecl && "DefineImplicitDestructor - invalid destructor");
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00007287
Douglas Gregorc63d2c82010-05-12 16:39:35 +00007288 if (Destructor->isInvalidDecl())
7289 return;
7290
Douglas Gregor39957dc2010-05-01 15:04:51 +00007291 ImplicitlyDefinedFunctionScope Scope(*this, Destructor);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00007292
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00007293 DiagnosticErrorTrap Trap(Diags);
John McCallef027fe2010-03-16 21:39:52 +00007294 MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
7295 Destructor->getParent());
Mike Stump1eb44332009-09-09 15:08:12 +00007296
Douglas Gregorc63d2c82010-05-12 16:39:35 +00007297 if (CheckDestructor(Destructor) || Trap.hasErrorOccurred()) {
Anders Carlsson37909802009-11-30 21:24:50 +00007298 Diag(CurrentLocation, diag::note_member_synthesized_at)
7299 << CXXDestructor << Context.getTagDeclType(ClassDecl);
7300
7301 Destructor->setInvalidDecl();
7302 return;
7303 }
7304
Douglas Gregor4ada9d32010-09-20 16:48:21 +00007305 SourceLocation Loc = Destructor->getLocation();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00007306 Destructor->setBody(new (Context) CompoundStmt(Loc));
Douglas Gregor690b2db2011-09-22 20:32:43 +00007307 Destructor->setImplicitlyDefined(true);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007308 Destructor->setUsed();
Douglas Gregor6fb745b2010-05-13 16:44:06 +00007309 MarkVTableUsed(CurrentLocation, ClassDecl);
Sebastian Redl58a2cd82011-04-24 16:28:06 +00007310
7311 if (ASTMutationListener *L = getASTMutationListener()) {
7312 L->CompletedImplicitDefinition(Destructor);
7313 }
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00007314}
7315
Richard Smitha4156b82012-04-21 18:42:51 +00007316/// \brief Perform any semantic analysis which needs to be delayed until all
7317/// pending class member declarations have been parsed.
7318void Sema::ActOnFinishCXXMemberDecls() {
Richard Smitha4156b82012-04-21 18:42:51 +00007319 // Perform any deferred checking of exception specifications for virtual
7320 // destructors.
7321 for (unsigned i = 0, e = DelayedDestructorExceptionSpecChecks.size();
7322 i != e; ++i) {
7323 const CXXDestructorDecl *Dtor =
7324 DelayedDestructorExceptionSpecChecks[i].first;
7325 assert(!Dtor->getParent()->isDependentType() &&
7326 "Should not ever add destructors of templates into the list.");
7327 CheckOverridingFunctionExceptionSpec(Dtor,
7328 DelayedDestructorExceptionSpecChecks[i].second);
7329 }
7330 DelayedDestructorExceptionSpecChecks.clear();
7331}
7332
Richard Smithb9d0b762012-07-27 04:22:15 +00007333void Sema::AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl,
7334 CXXDestructorDecl *Destructor) {
7335 assert(getLangOpts().CPlusPlus0x &&
7336 "adjusting dtor exception specs was introduced in c++11");
7337
Sebastian Redl0ee33912011-05-19 05:13:44 +00007338 // C++11 [class.dtor]p3:
7339 // A declaration of a destructor that does not have an exception-
7340 // specification is implicitly considered to have the same exception-
7341 // specification as an implicit declaration.
Richard Smithb9d0b762012-07-27 04:22:15 +00007342 const FunctionProtoType *DtorType = Destructor->getType()->
Sebastian Redl0ee33912011-05-19 05:13:44 +00007343 getAs<FunctionProtoType>();
Richard Smithb9d0b762012-07-27 04:22:15 +00007344 if (DtorType->hasExceptionSpec())
Sebastian Redl0ee33912011-05-19 05:13:44 +00007345 return;
7346
Chandler Carruth3f224b22011-09-20 04:55:26 +00007347 // Replace the destructor's type, building off the existing one. Fortunately,
7348 // the only thing of interest in the destructor type is its extended info.
7349 // The return and arguments are fixed.
Richard Smithb9d0b762012-07-27 04:22:15 +00007350 FunctionProtoType::ExtProtoInfo EPI = DtorType->getExtProtoInfo();
7351 EPI.ExceptionSpecType = EST_Unevaluated;
7352 EPI.ExceptionSpecDecl = Destructor;
7353 Destructor->setType(Context.getFunctionType(Context.VoidTy, 0, 0, EPI));
Richard Smitha4156b82012-04-21 18:42:51 +00007354
Sebastian Redl0ee33912011-05-19 05:13:44 +00007355 // FIXME: If the destructor has a body that could throw, and the newly created
7356 // spec doesn't allow exceptions, we should emit a warning, because this
7357 // change in behavior can break conforming C++03 programs at runtime.
Richard Smithb9d0b762012-07-27 04:22:15 +00007358 // However, we don't have a body or an exception specification yet, so it
7359 // needs to be done somewhere else.
Sebastian Redl0ee33912011-05-19 05:13:44 +00007360}
7361
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007362/// \brief Builds a statement that copies/moves the given entity from \p From to
Douglas Gregor06a9f362010-05-01 20:49:11 +00007363/// \c To.
7364///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007365/// This routine is used to copy/move the members of a class with an
7366/// implicitly-declared copy/move assignment operator. When the entities being
Douglas Gregor06a9f362010-05-01 20:49:11 +00007367/// copied are arrays, this routine builds for loops to copy them.
7368///
7369/// \param S The Sema object used for type-checking.
7370///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007371/// \param Loc The location where the implicit copy/move is being generated.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007372///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007373/// \param T The type of the expressions being copied/moved. Both expressions
7374/// must have this type.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007375///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007376/// \param To The expression we are copying/moving to.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007377///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007378/// \param From The expression we are copying/moving from.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007379///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007380/// \param CopyingBaseSubobject Whether we're copying/moving a base subobject.
Douglas Gregor6cdc1612010-05-04 15:20:55 +00007381/// Otherwise, it's a non-static member subobject.
7382///
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007383/// \param Copying Whether we're copying or moving.
7384///
Douglas Gregor06a9f362010-05-01 20:49:11 +00007385/// \param Depth Internal parameter recording the depth of the recursion.
7386///
7387/// \returns A statement or a loop that copies the expressions.
John McCall60d7b3a2010-08-24 06:29:42 +00007388static StmtResult
Douglas Gregor06a9f362010-05-01 20:49:11 +00007389BuildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
John McCall9ae2f072010-08-23 23:25:46 +00007390 Expr *To, Expr *From,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007391 bool CopyingBaseSubobject, bool Copying,
7392 unsigned Depth = 0) {
7393 // C++0x [class.copy]p28:
Douglas Gregor06a9f362010-05-01 20:49:11 +00007394 // Each subobject is assigned in the manner appropriate to its type:
7395 //
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007396 // - if the subobject is of class type, as if by a call to operator= with
7397 // the subobject as the object expression and the corresponding
7398 // subobject of x as a single function argument (as if by explicit
7399 // qualification; that is, ignoring any possible virtual overriding
7400 // functions in more derived classes);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007401 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
7402 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RecordTy->getDecl());
7403
7404 // Look for operator=.
7405 DeclarationName Name
7406 = S.Context.DeclarationNames.getCXXOperatorName(OO_Equal);
7407 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
7408 S.LookupQualifiedName(OpLookup, ClassDecl, false);
7409
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007410 // Filter out any result that isn't a copy/move-assignment operator.
Douglas Gregor06a9f362010-05-01 20:49:11 +00007411 LookupResult::Filter F = OpLookup.makeFilter();
7412 while (F.hasNext()) {
7413 NamedDecl *D = F.next();
7414 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
Richard Smith1c931be2012-04-02 18:40:40 +00007415 if (Method->isCopyAssignmentOperator() ||
7416 (!Copying && Method->isMoveAssignmentOperator()))
Douglas Gregor06a9f362010-05-01 20:49:11 +00007417 continue;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007418
Douglas Gregor06a9f362010-05-01 20:49:11 +00007419 F.erase();
John McCallb0207482010-03-16 06:11:48 +00007420 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007421 F.done();
7422
Douglas Gregor6cdc1612010-05-04 15:20:55 +00007423 // Suppress the protected check (C++ [class.protected]) for each of the
7424 // assignment operators we found. This strange dance is required when
7425 // we're assigning via a base classes's copy-assignment operator. To
7426 // ensure that we're getting the right base class subobject (without
7427 // ambiguities), we need to cast "this" to that subobject type; to
7428 // ensure that we don't go through the virtual call mechanism, we need
7429 // to qualify the operator= name with the base class (see below). However,
7430 // this means that if the base class has a protected copy assignment
7431 // operator, the protected member access check will fail. So, we
7432 // rewrite "protected" access to "public" access in this case, since we
7433 // know by construction that we're calling from a derived class.
7434 if (CopyingBaseSubobject) {
7435 for (LookupResult::iterator L = OpLookup.begin(), LEnd = OpLookup.end();
7436 L != LEnd; ++L) {
7437 if (L.getAccess() == AS_protected)
7438 L.setAccess(AS_public);
7439 }
7440 }
7441
Douglas Gregor06a9f362010-05-01 20:49:11 +00007442 // Create the nested-name-specifier that will be used to qualify the
7443 // reference to operator=; this is required to suppress the virtual
7444 // call mechanism.
7445 CXXScopeSpec SS;
Manuel Klimek5b6a3dd2012-02-06 21:51:39 +00007446 const Type *CanonicalT = S.Context.getCanonicalType(T.getTypePtr());
Douglas Gregorc34348a2011-02-24 17:54:50 +00007447 SS.MakeTrivial(S.Context,
7448 NestedNameSpecifier::Create(S.Context, 0, false,
Manuel Klimek5b6a3dd2012-02-06 21:51:39 +00007449 CanonicalT),
Douglas Gregorc34348a2011-02-24 17:54:50 +00007450 Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007451
7452 // Create the reference to operator=.
John McCall60d7b3a2010-08-24 06:29:42 +00007453 ExprResult OpEqualRef
John McCall9ae2f072010-08-23 23:25:46 +00007454 = S.BuildMemberReferenceExpr(To, T, Loc, /*isArrow=*/false, SS,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007455 /*TemplateKWLoc=*/SourceLocation(),
7456 /*FirstQualifierInScope=*/0,
7457 OpLookup,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007458 /*TemplateArgs=*/0,
7459 /*SuppressQualifierCheck=*/true);
7460 if (OpEqualRef.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007461 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007462
7463 // Build the call to the assignment operator.
John McCall9ae2f072010-08-23 23:25:46 +00007464
John McCall60d7b3a2010-08-24 06:29:42 +00007465 ExprResult Call = S.BuildCallToMemberFunction(/*Scope=*/0,
Douglas Gregora1a04782010-09-09 16:33:13 +00007466 OpEqualRef.takeAs<Expr>(),
7467 Loc, &From, 1, Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007468 if (Call.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007469 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007470
7471 return S.Owned(Call.takeAs<Stmt>());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007472 }
John McCallb0207482010-03-16 06:11:48 +00007473
Douglas Gregor06a9f362010-05-01 20:49:11 +00007474 // - if the subobject is of scalar type, the built-in assignment
7475 // operator is used.
7476 const ConstantArrayType *ArrayTy = S.Context.getAsConstantArrayType(T);
7477 if (!ArrayTy) {
John McCall2de56d12010-08-25 11:45:40 +00007478 ExprResult Assignment = S.CreateBuiltinBinOp(Loc, BO_Assign, To, From);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007479 if (Assignment.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007480 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007481
7482 return S.Owned(Assignment.takeAs<Stmt>());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007483 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007484
7485 // - if the subobject is an array, each element is assigned, in the
7486 // manner appropriate to the element type;
7487
7488 // Construct a loop over the array bounds, e.g.,
7489 //
7490 // for (__SIZE_TYPE__ i0 = 0; i0 != array-size; ++i0)
7491 //
7492 // that will copy each of the array elements.
7493 QualType SizeType = S.Context.getSizeType();
7494
7495 // Create the iteration variable.
7496 IdentifierInfo *IterationVarName = 0;
7497 {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00007498 SmallString<8> Str;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007499 llvm::raw_svector_ostream OS(Str);
7500 OS << "__i" << Depth;
7501 IterationVarName = &S.Context.Idents.get(OS.str());
7502 }
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007503 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007504 IterationVarName, SizeType,
7505 S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
John McCalld931b082010-08-26 03:08:43 +00007506 SC_None, SC_None);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007507
7508 // Initialize the iteration variable to zero.
7509 llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00007510 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
Douglas Gregor06a9f362010-05-01 20:49:11 +00007511
7512 // Create a reference to the iteration variable; we'll use this several
7513 // times throughout.
7514 Expr *IterationVarRef
Eli Friedman8c382062012-01-23 02:35:22 +00007515 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007516 assert(IterationVarRef && "Reference to invented variable cannot fail!");
Eli Friedman8c382062012-01-23 02:35:22 +00007517 Expr *IterationVarRefRVal = S.DefaultLvalueConversion(IterationVarRef).take();
7518 assert(IterationVarRefRVal && "Conversion of invented variable cannot fail!");
7519
Douglas Gregor06a9f362010-05-01 20:49:11 +00007520 // Create the DeclStmt that holds the iteration variable.
7521 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
7522
7523 // Create the comparison against the array bound.
Jay Foad9f71a8f2010-12-07 08:25:34 +00007524 llvm::APInt Upper
7525 = ArrayTy->getSize().zextOrTrunc(S.Context.getTypeSize(SizeType));
John McCall9ae2f072010-08-23 23:25:46 +00007526 Expr *Comparison
Eli Friedman8c382062012-01-23 02:35:22 +00007527 = new (S.Context) BinaryOperator(IterationVarRefRVal,
John McCallf89e55a2010-11-18 06:31:45 +00007528 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
7529 BO_NE, S.Context.BoolTy,
Lang Hamesbe9af122012-10-02 04:45:10 +00007530 VK_RValue, OK_Ordinary, Loc, false);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007531
7532 // Create the pre-increment of the iteration variable.
John McCall9ae2f072010-08-23 23:25:46 +00007533 Expr *Increment
John McCallf89e55a2010-11-18 06:31:45 +00007534 = new (S.Context) UnaryOperator(IterationVarRef, UO_PreInc, SizeType,
7535 VK_LValue, OK_Ordinary, Loc);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007536
7537 // Subscript the "from" and "to" expressions with the iteration variable.
John McCall9ae2f072010-08-23 23:25:46 +00007538 From = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(From, Loc,
Eli Friedman8c382062012-01-23 02:35:22 +00007539 IterationVarRefRVal,
7540 Loc));
John McCall9ae2f072010-08-23 23:25:46 +00007541 To = AssertSuccess(S.CreateBuiltinArraySubscriptExpr(To, Loc,
Eli Friedman8c382062012-01-23 02:35:22 +00007542 IterationVarRefRVal,
7543 Loc));
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007544 if (!Copying) // Cast to rvalue
7545 From = CastForMoving(S, From);
7546
7547 // Build the copy/move for an individual element of the array.
John McCallf89e55a2010-11-18 06:31:45 +00007548 StmtResult Copy = BuildSingleCopyAssign(S, Loc, ArrayTy->getElementType(),
7549 To, From, CopyingBaseSubobject,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007550 Copying, Depth + 1);
Douglas Gregorff331c12010-07-25 18:17:45 +00007551 if (Copy.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00007552 return StmtError();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007553
7554 // Construct the loop that copies all elements of this array.
John McCall9ae2f072010-08-23 23:25:46 +00007555 return S.ActOnForStmt(Loc, Loc, InitStmt,
Douglas Gregor06a9f362010-05-01 20:49:11 +00007556 S.MakeFullExpr(Comparison),
John McCalld226f652010-08-21 09:40:31 +00007557 0, S.MakeFullExpr(Increment),
John McCall9ae2f072010-08-23 23:25:46 +00007558 Loc, Copy.take());
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00007559}
7560
Richard Smithb9d0b762012-07-27 04:22:15 +00007561/// Determine whether an implicit copy assignment operator for ClassDecl has a
7562/// const argument.
7563/// FIXME: It ought to be possible to store this on the record.
7564static bool isImplicitCopyAssignmentArgConst(Sema &S,
7565 CXXRecordDecl *ClassDecl) {
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007566 if (ClassDecl->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00007567 return true;
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007568
Douglas Gregord3c35902010-07-01 16:36:15 +00007569 // C++ [class.copy]p10:
7570 // If the class definition does not explicitly declare a copy
7571 // assignment operator, one is declared implicitly.
7572 // The implicitly-defined copy assignment operator for a class X
7573 // will have the form
7574 //
7575 // X& X::operator=(const X&)
7576 //
7577 // if
Douglas Gregord3c35902010-07-01 16:36:15 +00007578 // -- each direct base class B of X has a copy assignment operator
7579 // whose parameter is of type const B&, const volatile B& or B,
7580 // and
7581 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7582 BaseEnd = ClassDecl->bases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007583 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007584 // We'll handle this below
Richard Smithb9d0b762012-07-27 04:22:15 +00007585 if (S.getLangOpts().CPlusPlus0x && Base->isVirtual())
Sean Hunt661c67a2011-06-21 23:42:56 +00007586 continue;
7587
Douglas Gregord3c35902010-07-01 16:36:15 +00007588 assert(!Base->getType()->isDependentType() &&
7589 "Cannot generate implicit members for class with dependent bases.");
Sean Hunt661c67a2011-06-21 23:42:56 +00007590 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl();
Richard Smithb9d0b762012-07-27 04:22:15 +00007591 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const, false, 0))
7592 return false;
Sean Hunt661c67a2011-06-21 23:42:56 +00007593 }
7594
Richard Smithebaf0e62011-10-18 20:49:44 +00007595 // In C++11, the above citation has "or virtual" added
Richard Smithb9d0b762012-07-27 04:22:15 +00007596 if (S.getLangOpts().CPlusPlus0x) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007597 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
7598 BaseEnd = ClassDecl->vbases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007599 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007600 assert(!Base->getType()->isDependentType() &&
7601 "Cannot generate implicit members for class with dependent bases.");
7602 CXXRecordDecl *BaseClassDecl = Base->getType()->getAsCXXRecordDecl();
Richard Smithb9d0b762012-07-27 04:22:15 +00007603 if (!S.LookupCopyingAssignment(BaseClassDecl, Qualifiers::Const,
7604 false, 0))
7605 return false;
Sean Hunt661c67a2011-06-21 23:42:56 +00007606 }
Douglas Gregord3c35902010-07-01 16:36:15 +00007607 }
7608
7609 // -- for all the nonstatic data members of X that are of a class
7610 // type M (or array thereof), each such class type has a copy
7611 // assignment operator whose parameter is of type const M&,
7612 // const volatile M& or M.
7613 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7614 FieldEnd = ClassDecl->field_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00007615 Field != FieldEnd; ++Field) {
7616 QualType FieldType = S.Context.getBaseElementType(Field->getType());
7617 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl())
7618 if (!S.LookupCopyingAssignment(FieldClassDecl, Qualifiers::Const,
7619 false, 0))
7620 return false;
Douglas Gregord3c35902010-07-01 16:36:15 +00007621 }
7622
7623 // Otherwise, the implicitly declared copy assignment operator will
7624 // have the form
7625 //
7626 // X& X::operator=(X&)
Richard Smithb9d0b762012-07-27 04:22:15 +00007627
7628 return true;
7629}
7630
7631Sema::ImplicitExceptionSpecification
7632Sema::ComputeDefaultedCopyAssignmentExceptionSpec(CXXMethodDecl *MD) {
7633 CXXRecordDecl *ClassDecl = MD->getParent();
7634
7635 ImplicitExceptionSpecification ExceptSpec(*this);
7636 if (ClassDecl->isInvalidDecl())
7637 return ExceptSpec;
7638
7639 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
7640 assert(T->getNumArgs() == 1 && "not a copy assignment op");
7641 unsigned ArgQuals = T->getArgType(0).getNonReferenceType().getCVRQualifiers();
7642
Douglas Gregorb87786f2010-07-01 17:48:08 +00007643 // C++ [except.spec]p14:
Richard Smithb9d0b762012-07-27 04:22:15 +00007644 // An implicitly declared special member function (Clause 12) shall have an
Douglas Gregorb87786f2010-07-01 17:48:08 +00007645 // exception-specification. [...]
Sean Hunt661c67a2011-06-21 23:42:56 +00007646
7647 // It is unspecified whether or not an implicit copy assignment operator
7648 // attempts to deduplicate calls to assignment operators of virtual bases are
7649 // made. As such, this exception specification is effectively unspecified.
7650 // Based on a similar decision made for constness in C++0x, we're erring on
7651 // the side of assuming such calls to be made regardless of whether they
7652 // actually happen.
Douglas Gregorb87786f2010-07-01 17:48:08 +00007653 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7654 BaseEnd = ClassDecl->bases_end();
7655 Base != BaseEnd; ++Base) {
Sean Hunt661c67a2011-06-21 23:42:56 +00007656 if (Base->isVirtual())
7657 continue;
7658
Douglas Gregora376d102010-07-02 21:50:04 +00007659 CXXRecordDecl *BaseClassDecl
Douglas Gregorb87786f2010-07-01 17:48:08 +00007660 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Hunt661c67a2011-06-21 23:42:56 +00007661 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
7662 ArgQuals, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007663 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign);
Douglas Gregorb87786f2010-07-01 17:48:08 +00007664 }
Sean Hunt661c67a2011-06-21 23:42:56 +00007665
7666 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
7667 BaseEnd = ClassDecl->vbases_end();
7668 Base != BaseEnd; ++Base) {
7669 CXXRecordDecl *BaseClassDecl
7670 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
7671 if (CXXMethodDecl *CopyAssign = LookupCopyingAssignment(BaseClassDecl,
7672 ArgQuals, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007673 ExceptSpec.CalledDecl(Base->getLocStart(), CopyAssign);
Sean Hunt661c67a2011-06-21 23:42:56 +00007674 }
7675
Douglas Gregorb87786f2010-07-01 17:48:08 +00007676 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7677 FieldEnd = ClassDecl->field_end();
7678 Field != FieldEnd;
7679 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00007680 QualType FieldType = Context.getBaseElementType(Field->getType());
Sean Hunt661c67a2011-06-21 23:42:56 +00007681 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
7682 if (CXXMethodDecl *CopyAssign =
Richard Smith6a06e5f2012-07-18 03:36:00 +00007683 LookupCopyingAssignment(FieldClassDecl,
7684 ArgQuals | FieldType.getCVRQualifiers(),
7685 false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00007686 ExceptSpec.CalledDecl(Field->getLocation(), CopyAssign);
Abramo Bagnaracdb80762011-07-11 08:52:40 +00007687 }
Douglas Gregorb87786f2010-07-01 17:48:08 +00007688 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00007689
Richard Smithb9d0b762012-07-27 04:22:15 +00007690 return ExceptSpec;
Sean Hunt30de05c2011-05-14 05:23:20 +00007691}
7692
7693CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
7694 // Note: The following rules are largely analoguous to the copy
7695 // constructor rules. Note that virtual bases are not taken into account
7696 // for determining the argument type of the operator. Note also that
7697 // operators taking an object instead of a reference are allowed.
7698
Sean Hunt30de05c2011-05-14 05:23:20 +00007699 QualType ArgType = Context.getTypeDeclType(ClassDecl);
7700 QualType RetType = Context.getLValueReferenceType(ArgType);
Richard Smithb9d0b762012-07-27 04:22:15 +00007701 if (isImplicitCopyAssignmentArgConst(*this, ClassDecl))
Sean Hunt30de05c2011-05-14 05:23:20 +00007702 ArgType = ArgType.withConst();
7703 ArgType = Context.getLValueReferenceType(ArgType);
7704
Douglas Gregord3c35902010-07-01 16:36:15 +00007705 // An implicitly-declared copy assignment operator is an inline public
7706 // member of its class.
7707 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007708 SourceLocation ClassLoc = ClassDecl->getLocation();
7709 DeclarationNameInfo NameInfo(Name, ClassLoc);
Douglas Gregord3c35902010-07-01 16:36:15 +00007710 CXXMethodDecl *CopyAssignment
Richard Smithb9d0b762012-07-27 04:22:15 +00007711 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Douglas Gregord3c35902010-07-01 16:36:15 +00007712 /*TInfo=*/0, /*isStatic=*/false,
John McCalld931b082010-08-26 03:08:43 +00007713 /*StorageClassAsWritten=*/SC_None,
Richard Smithaf1fc7a2011-08-15 21:04:07 +00007714 /*isInline=*/true, /*isConstexpr=*/false,
Douglas Gregorf5251602011-03-08 17:10:18 +00007715 SourceLocation());
Douglas Gregord3c35902010-07-01 16:36:15 +00007716 CopyAssignment->setAccess(AS_public);
Sean Hunt7f410192011-05-14 05:23:24 +00007717 CopyAssignment->setDefaulted();
Douglas Gregord3c35902010-07-01 16:36:15 +00007718 CopyAssignment->setImplicit();
7719 CopyAssignment->setTrivial(ClassDecl->hasTrivialCopyAssignment());
Richard Smithb9d0b762012-07-27 04:22:15 +00007720
7721 // Build an exception specification pointing back at this member.
7722 FunctionProtoType::ExtProtoInfo EPI;
7723 EPI.ExceptionSpecType = EST_Unevaluated;
7724 EPI.ExceptionSpecDecl = CopyAssignment;
7725 CopyAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI));
7726
Douglas Gregord3c35902010-07-01 16:36:15 +00007727 // Add the parameter to the operator.
7728 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00007729 ClassLoc, ClassLoc, /*Id=*/0,
Douglas Gregord3c35902010-07-01 16:36:15 +00007730 ArgType, /*TInfo=*/0,
John McCalld931b082010-08-26 03:08:43 +00007731 SC_None,
7732 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00007733 CopyAssignment->setParams(FromParam);
Douglas Gregord3c35902010-07-01 16:36:15 +00007734
Douglas Gregora376d102010-07-02 21:50:04 +00007735 // Note that we have added this copy-assignment operator.
Douglas Gregora376d102010-07-02 21:50:04 +00007736 ++ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
Sean Hunt7f410192011-05-14 05:23:24 +00007737
Douglas Gregor23c94db2010-07-02 17:43:08 +00007738 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregora376d102010-07-02 21:50:04 +00007739 PushOnScopeChains(CopyAssignment, S, false);
7740 ClassDecl->addDecl(CopyAssignment);
Douglas Gregord3c35902010-07-01 16:36:15 +00007741
Nico Weberafcc96a2012-01-23 03:19:29 +00007742 // C++0x [class.copy]p19:
7743 // .... If the class definition does not explicitly declare a copy
7744 // assignment operator, there is no user-declared move constructor, and
7745 // there is no user-declared move assignment operator, a copy assignment
7746 // operator is implicitly declared as defaulted.
Richard Smith6c4c36c2012-03-30 20:53:28 +00007747 if (ShouldDeleteSpecialMember(CopyAssignment, CXXCopyAssignment))
Sean Hunt71a682f2011-05-18 03:41:58 +00007748 CopyAssignment->setDeletedAsWritten();
Richard Smith6c4c36c2012-03-30 20:53:28 +00007749
Douglas Gregord3c35902010-07-01 16:36:15 +00007750 AddOverriddenMethods(ClassDecl, CopyAssignment);
7751 return CopyAssignment;
7752}
7753
Douglas Gregor06a9f362010-05-01 20:49:11 +00007754void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
7755 CXXMethodDecl *CopyAssignOperator) {
Sean Hunt7f410192011-05-14 05:23:24 +00007756 assert((CopyAssignOperator->isDefaulted() &&
Douglas Gregor06a9f362010-05-01 20:49:11 +00007757 CopyAssignOperator->isOverloadedOperator() &&
7758 CopyAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith03f68782012-02-26 07:51:39 +00007759 !CopyAssignOperator->doesThisDeclarationHaveABody() &&
7760 !CopyAssignOperator->isDeleted()) &&
Douglas Gregor06a9f362010-05-01 20:49:11 +00007761 "DefineImplicitCopyAssignment called for wrong function");
7762
7763 CXXRecordDecl *ClassDecl = CopyAssignOperator->getParent();
7764
7765 if (ClassDecl->isInvalidDecl() || CopyAssignOperator->isInvalidDecl()) {
7766 CopyAssignOperator->setInvalidDecl();
7767 return;
7768 }
7769
7770 CopyAssignOperator->setUsed();
7771
7772 ImplicitlyDefinedFunctionScope Scope(*this, CopyAssignOperator);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00007773 DiagnosticErrorTrap Trap(Diags);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007774
7775 // C++0x [class.copy]p30:
7776 // The implicitly-defined or explicitly-defaulted copy assignment operator
7777 // for a non-union class X performs memberwise copy assignment of its
7778 // subobjects. The direct base classes of X are assigned first, in the
7779 // order of their declaration in the base-specifier-list, and then the
7780 // immediate non-static data members of X are assigned, in the order in
7781 // which they were declared in the class definition.
7782
7783 // The statements that form the synthesized function body.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00007784 SmallVector<Stmt*, 8> Statements;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007785
7786 // The parameter for the "other" object, which we are copying from.
7787 ParmVarDecl *Other = CopyAssignOperator->getParamDecl(0);
7788 Qualifiers OtherQuals = Other->getType().getQualifiers();
7789 QualType OtherRefType = Other->getType();
7790 if (const LValueReferenceType *OtherRef
7791 = OtherRefType->getAs<LValueReferenceType>()) {
7792 OtherRefType = OtherRef->getPointeeType();
7793 OtherQuals = OtherRefType.getQualifiers();
7794 }
7795
7796 // Our location for everything implicitly-generated.
7797 SourceLocation Loc = CopyAssignOperator->getLocation();
7798
7799 // Construct a reference to the "other" object. We'll be using this
7800 // throughout the generated ASTs.
John McCall09431682010-11-18 19:01:18 +00007801 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007802 assert(OtherRef && "Reference to parameter cannot fail!");
7803
7804 // Construct the "this" pointer. We'll be using this throughout the generated
7805 // ASTs.
7806 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>();
7807 assert(This && "Reference to this cannot fail!");
7808
7809 // Assign base classes.
7810 bool Invalid = false;
7811 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
7812 E = ClassDecl->bases_end(); Base != E; ++Base) {
7813 // Form the assignment:
7814 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
7815 QualType BaseType = Base->getType().getUnqualifiedType();
Jeffrey Yasskindec09842011-01-18 02:00:16 +00007816 if (!BaseType->isRecordType()) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007817 Invalid = true;
7818 continue;
7819 }
7820
John McCallf871d0c2010-08-07 06:22:56 +00007821 CXXCastPath BasePath;
7822 BasePath.push_back(Base);
7823
Douglas Gregor06a9f362010-05-01 20:49:11 +00007824 // Construct the "from" expression, which is an implicit cast to the
7825 // appropriately-qualified base type.
John McCall3fa5cae2010-10-26 07:05:15 +00007826 Expr *From = OtherRef;
John Wiegley429bb272011-04-08 18:41:53 +00007827 From = ImpCastExprToType(From, Context.getQualifiedType(BaseType, OtherQuals),
7828 CK_UncheckedDerivedToBase,
7829 VK_LValue, &BasePath).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007830
7831 // Dereference "this".
John McCall5baba9d2010-08-25 10:28:54 +00007832 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007833
7834 // Implicitly cast "this" to the appropriately-qualified base type.
John Wiegley429bb272011-04-08 18:41:53 +00007835 To = ImpCastExprToType(To.take(),
7836 Context.getCVRQualifiedType(BaseType,
7837 CopyAssignOperator->getTypeQualifiers()),
7838 CK_UncheckedDerivedToBase,
7839 VK_LValue, &BasePath);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007840
7841 // Build the copy.
John McCall60d7b3a2010-08-24 06:29:42 +00007842 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00007843 To.get(), From,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007844 /*CopyingBaseSubobject=*/true,
7845 /*Copying=*/true);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007846 if (Copy.isInvalid()) {
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007847 Diag(CurrentLocation, diag::note_member_synthesized_at)
7848 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
7849 CopyAssignOperator->setInvalidDecl();
7850 return;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007851 }
7852
7853 // Success! Record the copy.
7854 Statements.push_back(Copy.takeAs<Expr>());
7855 }
7856
7857 // \brief Reference to the __builtin_memcpy function.
7858 Expr *BuiltinMemCpyRef = 0;
Fariborz Jahanian8e2eab22010-06-16 16:22:04 +00007859 // \brief Reference to the __builtin_objc_memmove_collectable function.
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007860 Expr *CollectableMemCpyRef = 0;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007861
7862 // Assign non-static members.
7863 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
7864 FieldEnd = ClassDecl->field_end();
7865 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +00007866 if (Field->isUnnamedBitfield())
7867 continue;
7868
Douglas Gregor06a9f362010-05-01 20:49:11 +00007869 // Check for members of reference type; we can't copy those.
7870 if (Field->getType()->isReferenceType()) {
7871 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
7872 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
7873 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007874 Diag(CurrentLocation, diag::note_member_synthesized_at)
7875 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007876 Invalid = true;
7877 continue;
7878 }
7879
7880 // Check for members of const-qualified, non-class type.
7881 QualType BaseType = Context.getBaseElementType(Field->getType());
7882 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
7883 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
7884 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
7885 Diag(Field->getLocation(), diag::note_declared_at);
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00007886 Diag(CurrentLocation, diag::note_member_synthesized_at)
7887 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007888 Invalid = true;
7889 continue;
7890 }
John McCallb77115d2011-06-17 00:18:42 +00007891
7892 // Suppress assigning zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00007893 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
7894 continue;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007895
7896 QualType FieldType = Field->getType().getNonReferenceType();
Fariborz Jahanian4142ceb2010-05-26 20:19:07 +00007897 if (FieldType->isIncompleteArrayType()) {
7898 assert(ClassDecl->hasFlexibleArrayMember() &&
7899 "Incomplete array type is not valid");
7900 continue;
7901 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007902
7903 // Build references to the field in the object we're copying from and to.
7904 CXXScopeSpec SS; // Intentionally empty
7905 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
7906 LookupMemberName);
David Blaikie581deb32012-06-06 20:45:41 +00007907 MemberLookup.addDecl(*Field);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007908 MemberLookup.resolveKind();
John McCall60d7b3a2010-08-24 06:29:42 +00007909 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType,
John McCall09431682010-11-18 19:01:18 +00007910 Loc, /*IsArrow=*/false,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007911 SS, SourceLocation(), 0,
7912 MemberLookup, 0);
John McCall60d7b3a2010-08-24 06:29:42 +00007913 ExprResult To = BuildMemberReferenceExpr(This, This->getType(),
John McCall09431682010-11-18 19:01:18 +00007914 Loc, /*IsArrow=*/true,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00007915 SS, SourceLocation(), 0,
7916 MemberLookup, 0);
Douglas Gregor06a9f362010-05-01 20:49:11 +00007917 assert(!From.isInvalid() && "Implicit field reference cannot fail");
7918 assert(!To.isInvalid() && "Implicit field reference cannot fail");
7919
7920 // If the field should be copied with __builtin_memcpy rather than via
7921 // explicit assignments, do so. This optimization only applies for arrays
7922 // of scalars and arrays of class type with trivial copy-assignment
7923 // operators.
Fariborz Jahanian6b167f42011-08-09 00:26:11 +00007924 if (FieldType->isArrayType() && !FieldType.isVolatileQualified()
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00007925 && BaseType.hasTrivialAssignment(Context, /*Copying=*/true)) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007926 // Compute the size of the memory buffer to be copied.
7927 QualType SizeType = Context.getSizeType();
7928 llvm::APInt Size(Context.getTypeSize(SizeType),
7929 Context.getTypeSizeInChars(BaseType).getQuantity());
7930 for (const ConstantArrayType *Array
7931 = Context.getAsConstantArrayType(FieldType);
7932 Array;
7933 Array = Context.getAsConstantArrayType(Array->getElementType())) {
Jay Foad9f71a8f2010-12-07 08:25:34 +00007934 llvm::APInt ArraySize
7935 = Array->getSize().zextOrTrunc(Size.getBitWidth());
Douglas Gregor06a9f362010-05-01 20:49:11 +00007936 Size *= ArraySize;
7937 }
7938
7939 // Take the address of the field references for "from" and "to".
John McCall2de56d12010-08-25 11:45:40 +00007940 From = CreateBuiltinUnaryOp(Loc, UO_AddrOf, From.get());
7941 To = CreateBuiltinUnaryOp(Loc, UO_AddrOf, To.get());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007942
7943 bool NeedsCollectableMemCpy =
7944 (BaseType->isRecordType() &&
7945 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember());
7946
7947 if (NeedsCollectableMemCpy) {
7948 if (!CollectableMemCpyRef) {
Fariborz Jahanian8e2eab22010-06-16 16:22:04 +00007949 // Create a reference to the __builtin_objc_memmove_collectable function.
7950 LookupResult R(*this,
7951 &Context.Idents.get("__builtin_objc_memmove_collectable"),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007952 Loc, LookupOrdinaryName);
7953 LookupName(R, TUScope, true);
7954
7955 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>();
7956 if (!CollectableMemCpy) {
7957 // Something went horribly wrong earlier, and we will have
7958 // complained about it.
7959 Invalid = true;
7960 continue;
7961 }
7962
7963 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00007964 Context.BuiltinFnTy,
7965 VK_RValue, Loc, 0).take();
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007966 assert(CollectableMemCpyRef && "Builtin reference cannot fail");
7967 }
7968 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00007969 // Create a reference to the __builtin_memcpy builtin function.
Fariborz Jahanian55bcace2010-06-15 22:44:06 +00007970 else if (!BuiltinMemCpyRef) {
Douglas Gregor06a9f362010-05-01 20:49:11 +00007971 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc,
7972 LookupOrdinaryName);
7973 LookupName(R, TUScope, true);
7974
7975 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>();
7976 if (!BuiltinMemCpy) {
7977 // Something went horribly wrong earlier, and we will have complained
7978 // about it.
7979 Invalid = true;
7980 continue;
7981 }
7982
7983 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00007984 Context.BuiltinFnTy,
7985 VK_RValue, Loc, 0).take();
Douglas Gregor06a9f362010-05-01 20:49:11 +00007986 assert(BuiltinMemCpyRef && "Builtin reference cannot fail");
7987 }
7988
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00007989 SmallVector<Expr*, 8> CallArgs;
Douglas Gregor06a9f362010-05-01 20:49:11 +00007990 CallArgs.push_back(To.takeAs<Expr>());
7991 CallArgs.push_back(From.takeAs<Expr>());
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +00007992 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc));
John McCall60d7b3a2010-08-24 06:29:42 +00007993 ExprResult Call = ExprError();
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00007994 if (NeedsCollectableMemCpy)
7995 Call = ActOnCallExpr(/*Scope=*/0,
John McCall9ae2f072010-08-23 23:25:46 +00007996 CollectableMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00007997 Loc, CallArgs,
Douglas Gregora1a04782010-09-09 16:33:13 +00007998 Loc);
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00007999 else
8000 Call = ActOnCallExpr(/*Scope=*/0,
John McCall9ae2f072010-08-23 23:25:46 +00008001 BuiltinMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008002 Loc, CallArgs,
Douglas Gregora1a04782010-09-09 16:33:13 +00008003 Loc);
Fariborz Jahanianff2d05f2010-06-16 00:16:38 +00008004
Douglas Gregor06a9f362010-05-01 20:49:11 +00008005 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
8006 Statements.push_back(Call.takeAs<Expr>());
8007 continue;
8008 }
8009
8010 // Build the copy of this field.
John McCall60d7b3a2010-08-24 06:29:42 +00008011 StmtResult Copy = BuildSingleCopyAssign(*this, Loc, FieldType,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008012 To.get(), From.get(),
8013 /*CopyingBaseSubobject=*/false,
8014 /*Copying=*/true);
Douglas Gregor06a9f362010-05-01 20:49:11 +00008015 if (Copy.isInvalid()) {
Douglas Gregor60a8fbb2010-05-05 22:38:15 +00008016 Diag(CurrentLocation, diag::note_member_synthesized_at)
8017 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
8018 CopyAssignOperator->setInvalidDecl();
8019 return;
Douglas Gregor06a9f362010-05-01 20:49:11 +00008020 }
8021
8022 // Success! Record the copy.
8023 Statements.push_back(Copy.takeAs<Stmt>());
8024 }
8025
8026 if (!Invalid) {
8027 // Add a "return *this;"
John McCall2de56d12010-08-25 11:45:40 +00008028 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
Douglas Gregor06a9f362010-05-01 20:49:11 +00008029
John McCall60d7b3a2010-08-24 06:29:42 +00008030 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get());
Douglas Gregor06a9f362010-05-01 20:49:11 +00008031 if (Return.isInvalid())
8032 Invalid = true;
8033 else {
8034 Statements.push_back(Return.takeAs<Stmt>());
Douglas Gregorc63d2c82010-05-12 16:39:35 +00008035
8036 if (Trap.hasErrorOccurred()) {
8037 Diag(CurrentLocation, diag::note_member_synthesized_at)
8038 << CXXCopyAssignment << Context.getTagDeclType(ClassDecl);
8039 Invalid = true;
8040 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00008041 }
8042 }
8043
8044 if (Invalid) {
8045 CopyAssignOperator->setInvalidDecl();
8046 return;
8047 }
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008048
8049 StmtResult Body;
8050 {
8051 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008052 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008053 /*isStmtExpr=*/false);
8054 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
8055 }
Douglas Gregor06a9f362010-05-01 20:49:11 +00008056 CopyAssignOperator->setBody(Body.takeAs<Stmt>());
Sebastian Redl58a2cd82011-04-24 16:28:06 +00008057
8058 if (ASTMutationListener *L = getASTMutationListener()) {
8059 L->CompletedImplicitDefinition(CopyAssignOperator);
8060 }
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00008061}
8062
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008063Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00008064Sema::ComputeDefaultedMoveAssignmentExceptionSpec(CXXMethodDecl *MD) {
8065 CXXRecordDecl *ClassDecl = MD->getParent();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008066
Richard Smithb9d0b762012-07-27 04:22:15 +00008067 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008068 if (ClassDecl->isInvalidDecl())
8069 return ExceptSpec;
8070
8071 // C++0x [except.spec]p14:
8072 // An implicitly declared special member function (Clause 12) shall have an
8073 // exception-specification. [...]
8074
8075 // It is unspecified whether or not an implicit move assignment operator
8076 // attempts to deduplicate calls to assignment operators of virtual bases are
8077 // made. As such, this exception specification is effectively unspecified.
8078 // Based on a similar decision made for constness in C++0x, we're erring on
8079 // the side of assuming such calls to be made regardless of whether they
8080 // actually happen.
8081 // Note that a move constructor is not implicitly declared when there are
8082 // virtual bases, but it can still be user-declared and explicitly defaulted.
8083 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8084 BaseEnd = ClassDecl->bases_end();
8085 Base != BaseEnd; ++Base) {
8086 if (Base->isVirtual())
8087 continue;
8088
8089 CXXRecordDecl *BaseClassDecl
8090 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8091 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith6a06e5f2012-07-18 03:36:00 +00008092 0, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008093 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008094 }
8095
8096 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8097 BaseEnd = ClassDecl->vbases_end();
8098 Base != BaseEnd; ++Base) {
8099 CXXRecordDecl *BaseClassDecl
8100 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8101 if (CXXMethodDecl *MoveAssign = LookupMovingAssignment(BaseClassDecl,
Richard Smith6a06e5f2012-07-18 03:36:00 +00008102 0, false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008103 ExceptSpec.CalledDecl(Base->getLocStart(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008104 }
8105
8106 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8107 FieldEnd = ClassDecl->field_end();
8108 Field != FieldEnd;
8109 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008110 QualType FieldType = Context.getBaseElementType(Field->getType());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008111 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
Richard Smith6a06e5f2012-07-18 03:36:00 +00008112 if (CXXMethodDecl *MoveAssign =
8113 LookupMovingAssignment(FieldClassDecl,
8114 FieldType.getCVRQualifiers(),
8115 false, 0))
Richard Smithe6975e92012-04-17 00:58:00 +00008116 ExceptSpec.CalledDecl(Field->getLocation(), MoveAssign);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008117 }
8118 }
8119
8120 return ExceptSpec;
8121}
8122
Richard Smith1c931be2012-04-02 18:40:40 +00008123/// Determine whether the class type has any direct or indirect virtual base
8124/// classes which have a non-trivial move assignment operator.
8125static bool
8126hasVirtualBaseWithNonTrivialMoveAssignment(Sema &S, CXXRecordDecl *ClassDecl) {
8127 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8128 BaseEnd = ClassDecl->vbases_end();
8129 Base != BaseEnd; ++Base) {
8130 CXXRecordDecl *BaseClass =
8131 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
8132
8133 // Try to declare the move assignment. If it would be deleted, then the
8134 // class does not have a non-trivial move assignment.
8135 if (BaseClass->needsImplicitMoveAssignment())
8136 S.DeclareImplicitMoveAssignment(BaseClass);
8137
8138 // If the class has both a trivial move assignment and a non-trivial move
8139 // assignment, hasTrivialMoveAssignment() is false.
8140 if (BaseClass->hasDeclaredMoveAssignment() &&
8141 !BaseClass->hasTrivialMoveAssignment())
8142 return true;
8143 }
8144
8145 return false;
8146}
8147
8148/// Determine whether the given type either has a move constructor or is
8149/// trivially copyable.
8150static bool
8151hasMoveOrIsTriviallyCopyable(Sema &S, QualType Type, bool IsConstructor) {
8152 Type = S.Context.getBaseElementType(Type);
8153
8154 // FIXME: Technically, non-trivially-copyable non-class types, such as
8155 // reference types, are supposed to return false here, but that appears
8156 // to be a standard defect.
8157 CXXRecordDecl *ClassDecl = Type->getAsCXXRecordDecl();
Argyrios Kyrtzidisb5e4ace2012-10-10 16:14:06 +00008158 if (!ClassDecl || !ClassDecl->getDefinition() || ClassDecl->isInvalidDecl())
Richard Smith1c931be2012-04-02 18:40:40 +00008159 return true;
8160
8161 if (Type.isTriviallyCopyableType(S.Context))
8162 return true;
8163
8164 if (IsConstructor) {
8165 if (ClassDecl->needsImplicitMoveConstructor())
8166 S.DeclareImplicitMoveConstructor(ClassDecl);
8167 return ClassDecl->hasDeclaredMoveConstructor();
8168 }
8169
8170 if (ClassDecl->needsImplicitMoveAssignment())
8171 S.DeclareImplicitMoveAssignment(ClassDecl);
8172 return ClassDecl->hasDeclaredMoveAssignment();
8173}
8174
8175/// Determine whether all non-static data members and direct or virtual bases
8176/// of class \p ClassDecl have either a move operation, or are trivially
8177/// copyable.
8178static bool subobjectsHaveMoveOrTrivialCopy(Sema &S, CXXRecordDecl *ClassDecl,
8179 bool IsConstructor) {
8180 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8181 BaseEnd = ClassDecl->bases_end();
8182 Base != BaseEnd; ++Base) {
8183 if (Base->isVirtual())
8184 continue;
8185
8186 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor))
8187 return false;
8188 }
8189
8190 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8191 BaseEnd = ClassDecl->vbases_end();
8192 Base != BaseEnd; ++Base) {
8193 if (!hasMoveOrIsTriviallyCopyable(S, Base->getType(), IsConstructor))
8194 return false;
8195 }
8196
8197 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8198 FieldEnd = ClassDecl->field_end();
8199 Field != FieldEnd; ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008200 if (!hasMoveOrIsTriviallyCopyable(S, Field->getType(), IsConstructor))
Richard Smith1c931be2012-04-02 18:40:40 +00008201 return false;
8202 }
8203
8204 return true;
8205}
8206
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008207CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
Richard Smith1c931be2012-04-02 18:40:40 +00008208 // C++11 [class.copy]p20:
8209 // If the definition of a class X does not explicitly declare a move
8210 // assignment operator, one will be implicitly declared as defaulted
8211 // if and only if:
8212 //
8213 // - [first 4 bullets]
8214 assert(ClassDecl->needsImplicitMoveAssignment());
8215
8216 // [Checked after we build the declaration]
8217 // - the move assignment operator would not be implicitly defined as
8218 // deleted,
8219
8220 // [DR1402]:
8221 // - X has no direct or indirect virtual base class with a non-trivial
8222 // move assignment operator, and
8223 // - each of X's non-static data members and direct or virtual base classes
8224 // has a type that either has a move assignment operator or is trivially
8225 // copyable.
8226 if (hasVirtualBaseWithNonTrivialMoveAssignment(*this, ClassDecl) ||
8227 !subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl,/*Constructor*/false)) {
8228 ClassDecl->setFailedImplicitMoveAssignment();
8229 return 0;
8230 }
8231
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008232 // Note: The following rules are largely analoguous to the move
8233 // constructor rules.
8234
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008235 QualType ArgType = Context.getTypeDeclType(ClassDecl);
8236 QualType RetType = Context.getLValueReferenceType(ArgType);
8237 ArgType = Context.getRValueReferenceType(ArgType);
8238
8239 // An implicitly-declared move assignment operator is an inline public
8240 // member of its class.
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008241 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
8242 SourceLocation ClassLoc = ClassDecl->getLocation();
8243 DeclarationNameInfo NameInfo(Name, ClassLoc);
8244 CXXMethodDecl *MoveAssignment
Richard Smithb9d0b762012-07-27 04:22:15 +00008245 = CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008246 /*TInfo=*/0, /*isStatic=*/false,
8247 /*StorageClassAsWritten=*/SC_None,
8248 /*isInline=*/true,
8249 /*isConstexpr=*/false,
8250 SourceLocation());
8251 MoveAssignment->setAccess(AS_public);
8252 MoveAssignment->setDefaulted();
8253 MoveAssignment->setImplicit();
8254 MoveAssignment->setTrivial(ClassDecl->hasTrivialMoveAssignment());
8255
Richard Smithb9d0b762012-07-27 04:22:15 +00008256 // Build an exception specification pointing back at this member.
8257 FunctionProtoType::ExtProtoInfo EPI;
8258 EPI.ExceptionSpecType = EST_Unevaluated;
8259 EPI.ExceptionSpecDecl = MoveAssignment;
8260 MoveAssignment->setType(Context.getFunctionType(RetType, &ArgType, 1, EPI));
8261
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008262 // Add the parameter to the operator.
8263 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
8264 ClassLoc, ClassLoc, /*Id=*/0,
8265 ArgType, /*TInfo=*/0,
8266 SC_None,
8267 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008268 MoveAssignment->setParams(FromParam);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008269
8270 // Note that we have added this copy-assignment operator.
8271 ++ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
8272
8273 // C++0x [class.copy]p9:
8274 // If the definition of a class X does not explicitly declare a move
8275 // assignment operator, one will be implicitly declared as defaulted if and
8276 // only if:
8277 // [...]
8278 // - the move assignment operator would not be implicitly defined as
8279 // deleted.
Richard Smith7d5088a2012-02-18 02:02:13 +00008280 if (ShouldDeleteSpecialMember(MoveAssignment, CXXMoveAssignment)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008281 // Cache this result so that we don't try to generate this over and over
8282 // on every lookup, leaking memory and wasting time.
8283 ClassDecl->setFailedImplicitMoveAssignment();
8284 return 0;
8285 }
8286
8287 if (Scope *S = getScopeForContext(ClassDecl))
8288 PushOnScopeChains(MoveAssignment, S, false);
8289 ClassDecl->addDecl(MoveAssignment);
8290
8291 AddOverriddenMethods(ClassDecl, MoveAssignment);
8292 return MoveAssignment;
8293}
8294
8295void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
8296 CXXMethodDecl *MoveAssignOperator) {
8297 assert((MoveAssignOperator->isDefaulted() &&
8298 MoveAssignOperator->isOverloadedOperator() &&
8299 MoveAssignOperator->getOverloadedOperator() == OO_Equal &&
Richard Smith03f68782012-02-26 07:51:39 +00008300 !MoveAssignOperator->doesThisDeclarationHaveABody() &&
8301 !MoveAssignOperator->isDeleted()) &&
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008302 "DefineImplicitMoveAssignment called for wrong function");
8303
8304 CXXRecordDecl *ClassDecl = MoveAssignOperator->getParent();
8305
8306 if (ClassDecl->isInvalidDecl() || MoveAssignOperator->isInvalidDecl()) {
8307 MoveAssignOperator->setInvalidDecl();
8308 return;
8309 }
8310
8311 MoveAssignOperator->setUsed();
8312
8313 ImplicitlyDefinedFunctionScope Scope(*this, MoveAssignOperator);
8314 DiagnosticErrorTrap Trap(Diags);
8315
8316 // C++0x [class.copy]p28:
8317 // The implicitly-defined or move assignment operator for a non-union class
8318 // X performs memberwise move assignment of its subobjects. The direct base
8319 // classes of X are assigned first, in the order of their declaration in the
8320 // base-specifier-list, and then the immediate non-static data members of X
8321 // are assigned, in the order in which they were declared in the class
8322 // definition.
8323
8324 // The statements that form the synthesized function body.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00008325 SmallVector<Stmt*, 8> Statements;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008326
8327 // The parameter for the "other" object, which we are move from.
8328 ParmVarDecl *Other = MoveAssignOperator->getParamDecl(0);
8329 QualType OtherRefType = Other->getType()->
8330 getAs<RValueReferenceType>()->getPointeeType();
8331 assert(OtherRefType.getQualifiers() == 0 &&
8332 "Bad argument type of defaulted move assignment");
8333
8334 // Our location for everything implicitly-generated.
8335 SourceLocation Loc = MoveAssignOperator->getLocation();
8336
8337 // Construct a reference to the "other" object. We'll be using this
8338 // throughout the generated ASTs.
8339 Expr *OtherRef = BuildDeclRefExpr(Other, OtherRefType, VK_LValue, Loc).take();
8340 assert(OtherRef && "Reference to parameter cannot fail!");
8341 // Cast to rvalue.
8342 OtherRef = CastForMoving(*this, OtherRef);
8343
8344 // Construct the "this" pointer. We'll be using this throughout the generated
8345 // ASTs.
8346 Expr *This = ActOnCXXThis(Loc).takeAs<Expr>();
8347 assert(This && "Reference to this cannot fail!");
Richard Smith1c931be2012-04-02 18:40:40 +00008348
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008349 // Assign base classes.
8350 bool Invalid = false;
8351 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8352 E = ClassDecl->bases_end(); Base != E; ++Base) {
8353 // Form the assignment:
8354 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
8355 QualType BaseType = Base->getType().getUnqualifiedType();
8356 if (!BaseType->isRecordType()) {
8357 Invalid = true;
8358 continue;
8359 }
8360
8361 CXXCastPath BasePath;
8362 BasePath.push_back(Base);
8363
8364 // Construct the "from" expression, which is an implicit cast to the
8365 // appropriately-qualified base type.
8366 Expr *From = OtherRef;
8367 From = ImpCastExprToType(From, BaseType, CK_UncheckedDerivedToBase,
Douglas Gregorb2b56582011-09-06 16:26:56 +00008368 VK_XValue, &BasePath).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008369
8370 // Dereference "this".
8371 ExprResult To = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
8372
8373 // Implicitly cast "this" to the appropriately-qualified base type.
8374 To = ImpCastExprToType(To.take(),
8375 Context.getCVRQualifiedType(BaseType,
8376 MoveAssignOperator->getTypeQualifiers()),
8377 CK_UncheckedDerivedToBase,
8378 VK_LValue, &BasePath);
8379
8380 // Build the move.
8381 StmtResult Move = BuildSingleCopyAssign(*this, Loc, BaseType,
8382 To.get(), From,
8383 /*CopyingBaseSubobject=*/true,
8384 /*Copying=*/false);
8385 if (Move.isInvalid()) {
8386 Diag(CurrentLocation, diag::note_member_synthesized_at)
8387 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8388 MoveAssignOperator->setInvalidDecl();
8389 return;
8390 }
8391
8392 // Success! Record the move.
8393 Statements.push_back(Move.takeAs<Expr>());
8394 }
8395
8396 // \brief Reference to the __builtin_memcpy function.
8397 Expr *BuiltinMemCpyRef = 0;
8398 // \brief Reference to the __builtin_objc_memmove_collectable function.
8399 Expr *CollectableMemCpyRef = 0;
8400
8401 // Assign non-static members.
8402 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8403 FieldEnd = ClassDecl->field_end();
8404 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +00008405 if (Field->isUnnamedBitfield())
8406 continue;
8407
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008408 // Check for members of reference type; we can't move those.
8409 if (Field->getType()->isReferenceType()) {
8410 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
8411 << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();
8412 Diag(Field->getLocation(), diag::note_declared_at);
8413 Diag(CurrentLocation, diag::note_member_synthesized_at)
8414 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8415 Invalid = true;
8416 continue;
8417 }
8418
8419 // Check for members of const-qualified, non-class type.
8420 QualType BaseType = Context.getBaseElementType(Field->getType());
8421 if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {
8422 Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign)
8423 << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();
8424 Diag(Field->getLocation(), diag::note_declared_at);
8425 Diag(CurrentLocation, diag::note_member_synthesized_at)
8426 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8427 Invalid = true;
8428 continue;
8429 }
8430
8431 // Suppress assigning zero-width bitfields.
Richard Smitha6b8b2c2011-10-10 18:28:20 +00008432 if (Field->isBitField() && Field->getBitWidthValue(Context) == 0)
8433 continue;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008434
8435 QualType FieldType = Field->getType().getNonReferenceType();
8436 if (FieldType->isIncompleteArrayType()) {
8437 assert(ClassDecl->hasFlexibleArrayMember() &&
8438 "Incomplete array type is not valid");
8439 continue;
8440 }
8441
8442 // Build references to the field in the object we're copying from and to.
8443 CXXScopeSpec SS; // Intentionally empty
8444 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
8445 LookupMemberName);
David Blaikie581deb32012-06-06 20:45:41 +00008446 MemberLookup.addDecl(*Field);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008447 MemberLookup.resolveKind();
8448 ExprResult From = BuildMemberReferenceExpr(OtherRef, OtherRefType,
8449 Loc, /*IsArrow=*/false,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00008450 SS, SourceLocation(), 0,
8451 MemberLookup, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008452 ExprResult To = BuildMemberReferenceExpr(This, This->getType(),
8453 Loc, /*IsArrow=*/true,
Abramo Bagnarae4b92762012-01-27 09:46:47 +00008454 SS, SourceLocation(), 0,
8455 MemberLookup, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008456 assert(!From.isInvalid() && "Implicit field reference cannot fail");
8457 assert(!To.isInvalid() && "Implicit field reference cannot fail");
8458
8459 assert(!From.get()->isLValue() && // could be xvalue or prvalue
8460 "Member reference with rvalue base must be rvalue except for reference "
8461 "members, which aren't allowed for move assignment.");
8462
8463 // If the field should be copied with __builtin_memcpy rather than via
8464 // explicit assignments, do so. This optimization only applies for arrays
8465 // of scalars and arrays of class type with trivial move-assignment
8466 // operators.
8467 if (FieldType->isArrayType() && !FieldType.isVolatileQualified()
8468 && BaseType.hasTrivialAssignment(Context, /*Copying=*/false)) {
8469 // Compute the size of the memory buffer to be copied.
8470 QualType SizeType = Context.getSizeType();
8471 llvm::APInt Size(Context.getTypeSize(SizeType),
8472 Context.getTypeSizeInChars(BaseType).getQuantity());
8473 for (const ConstantArrayType *Array
8474 = Context.getAsConstantArrayType(FieldType);
8475 Array;
8476 Array = Context.getAsConstantArrayType(Array->getElementType())) {
8477 llvm::APInt ArraySize
8478 = Array->getSize().zextOrTrunc(Size.getBitWidth());
8479 Size *= ArraySize;
8480 }
8481
Douglas Gregor45d3d712011-09-01 02:09:07 +00008482 // Take the address of the field references for "from" and "to". We
8483 // directly construct UnaryOperators here because semantic analysis
8484 // does not permit us to take the address of an xvalue.
8485 From = new (Context) UnaryOperator(From.get(), UO_AddrOf,
8486 Context.getPointerType(From.get()->getType()),
8487 VK_RValue, OK_Ordinary, Loc);
8488 To = new (Context) UnaryOperator(To.get(), UO_AddrOf,
8489 Context.getPointerType(To.get()->getType()),
8490 VK_RValue, OK_Ordinary, Loc);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008491
8492 bool NeedsCollectableMemCpy =
8493 (BaseType->isRecordType() &&
8494 BaseType->getAs<RecordType>()->getDecl()->hasObjectMember());
8495
8496 if (NeedsCollectableMemCpy) {
8497 if (!CollectableMemCpyRef) {
8498 // Create a reference to the __builtin_objc_memmove_collectable function.
8499 LookupResult R(*this,
8500 &Context.Idents.get("__builtin_objc_memmove_collectable"),
8501 Loc, LookupOrdinaryName);
8502 LookupName(R, TUScope, true);
8503
8504 FunctionDecl *CollectableMemCpy = R.getAsSingle<FunctionDecl>();
8505 if (!CollectableMemCpy) {
8506 // Something went horribly wrong earlier, and we will have
8507 // complained about it.
8508 Invalid = true;
8509 continue;
8510 }
8511
8512 CollectableMemCpyRef = BuildDeclRefExpr(CollectableMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00008513 Context.BuiltinFnTy,
8514 VK_RValue, Loc, 0).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008515 assert(CollectableMemCpyRef && "Builtin reference cannot fail");
8516 }
8517 }
8518 // Create a reference to the __builtin_memcpy builtin function.
8519 else if (!BuiltinMemCpyRef) {
8520 LookupResult R(*this, &Context.Idents.get("__builtin_memcpy"), Loc,
8521 LookupOrdinaryName);
8522 LookupName(R, TUScope, true);
8523
8524 FunctionDecl *BuiltinMemCpy = R.getAsSingle<FunctionDecl>();
8525 if (!BuiltinMemCpy) {
8526 // Something went horribly wrong earlier, and we will have complained
8527 // about it.
8528 Invalid = true;
8529 continue;
8530 }
8531
8532 BuiltinMemCpyRef = BuildDeclRefExpr(BuiltinMemCpy,
Eli Friedmana6c66ce2012-08-31 00:14:07 +00008533 Context.BuiltinFnTy,
8534 VK_RValue, Loc, 0).take();
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008535 assert(BuiltinMemCpyRef && "Builtin reference cannot fail");
8536 }
8537
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00008538 SmallVector<Expr*, 8> CallArgs;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008539 CallArgs.push_back(To.takeAs<Expr>());
8540 CallArgs.push_back(From.takeAs<Expr>());
8541 CallArgs.push_back(IntegerLiteral::Create(Context, Size, SizeType, Loc));
8542 ExprResult Call = ExprError();
8543 if (NeedsCollectableMemCpy)
8544 Call = ActOnCallExpr(/*Scope=*/0,
8545 CollectableMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008546 Loc, CallArgs,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008547 Loc);
8548 else
8549 Call = ActOnCallExpr(/*Scope=*/0,
8550 BuiltinMemCpyRef,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008551 Loc, CallArgs,
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008552 Loc);
8553
8554 assert(!Call.isInvalid() && "Call to __builtin_memcpy cannot fail!");
8555 Statements.push_back(Call.takeAs<Expr>());
8556 continue;
8557 }
8558
8559 // Build the move of this field.
8560 StmtResult Move = BuildSingleCopyAssign(*this, Loc, FieldType,
8561 To.get(), From.get(),
8562 /*CopyingBaseSubobject=*/false,
8563 /*Copying=*/false);
8564 if (Move.isInvalid()) {
8565 Diag(CurrentLocation, diag::note_member_synthesized_at)
8566 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8567 MoveAssignOperator->setInvalidDecl();
8568 return;
8569 }
8570
8571 // Success! Record the copy.
8572 Statements.push_back(Move.takeAs<Stmt>());
8573 }
8574
8575 if (!Invalid) {
8576 // Add a "return *this;"
8577 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
8578
8579 StmtResult Return = ActOnReturnStmt(Loc, ThisObj.get());
8580 if (Return.isInvalid())
8581 Invalid = true;
8582 else {
8583 Statements.push_back(Return.takeAs<Stmt>());
8584
8585 if (Trap.hasErrorOccurred()) {
8586 Diag(CurrentLocation, diag::note_member_synthesized_at)
8587 << CXXMoveAssignment << Context.getTagDeclType(ClassDecl);
8588 Invalid = true;
8589 }
8590 }
8591 }
8592
8593 if (Invalid) {
8594 MoveAssignOperator->setInvalidDecl();
8595 return;
8596 }
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008597
8598 StmtResult Body;
8599 {
8600 CompoundScopeRAII CompoundScope(*this);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00008601 Body = ActOnCompoundStmt(Loc, Loc, Statements,
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008602 /*isStmtExpr=*/false);
8603 assert(!Body.isInvalid() && "Compound statement creation cannot fail");
8604 }
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008605 MoveAssignOperator->setBody(Body.takeAs<Stmt>());
8606
8607 if (ASTMutationListener *L = getASTMutationListener()) {
8608 L->CompletedImplicitDefinition(MoveAssignOperator);
8609 }
8610}
8611
Richard Smithb9d0b762012-07-27 04:22:15 +00008612/// Determine whether an implicit copy constructor for ClassDecl has a const
8613/// argument.
8614/// FIXME: It ought to be possible to store this on the record.
8615static bool isImplicitCopyCtorArgConst(Sema &S, CXXRecordDecl *ClassDecl) {
Abramo Bagnaracdb80762011-07-11 08:52:40 +00008616 if (ClassDecl->isInvalidDecl())
Richard Smithb9d0b762012-07-27 04:22:15 +00008617 return true;
Abramo Bagnaracdb80762011-07-11 08:52:40 +00008618
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008619 // C++ [class.copy]p5:
8620 // The implicitly-declared copy constructor for a class X will
8621 // have the form
8622 //
8623 // X::X(const X&)
8624 //
8625 // if
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008626 // -- each direct or virtual base class B of X has a copy
8627 // constructor whose first parameter is of type const B& or
8628 // const volatile B&, and
8629 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8630 BaseEnd = ClassDecl->bases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008631 Base != BaseEnd; ++Base) {
Douglas Gregor598a8542010-07-01 18:27:03 +00008632 // Virtual bases are handled below.
8633 if (Base->isVirtual())
8634 continue;
Richard Smithb9d0b762012-07-27 04:22:15 +00008635
Douglas Gregor22584312010-07-02 23:41:54 +00008636 CXXRecordDecl *BaseClassDecl
Douglas Gregor598a8542010-07-01 18:27:03 +00008637 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Richard Smithb9d0b762012-07-27 04:22:15 +00008638 // FIXME: This lookup is wrong. If the copy ctor for a member or base is
8639 // ambiguous, we should still produce a constructor with a const-qualified
8640 // parameter.
8641 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const))
8642 return false;
Douglas Gregor598a8542010-07-01 18:27:03 +00008643 }
8644
8645 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8646 BaseEnd = ClassDecl->vbases_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008647 Base != BaseEnd; ++Base) {
Douglas Gregor22584312010-07-02 23:41:54 +00008648 CXXRecordDecl *BaseClassDecl
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008649 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Richard Smithb9d0b762012-07-27 04:22:15 +00008650 if (!S.LookupCopyingConstructor(BaseClassDecl, Qualifiers::Const))
8651 return false;
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008652 }
Richard Smithb9d0b762012-07-27 04:22:15 +00008653
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008654 // -- for all the nonstatic data members of X that are of a
8655 // class type M (or array thereof), each such class type
8656 // has a copy constructor whose first parameter is of type
8657 // const M& or const volatile M&.
8658 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8659 FieldEnd = ClassDecl->field_end();
Richard Smithb9d0b762012-07-27 04:22:15 +00008660 Field != FieldEnd; ++Field) {
8661 QualType FieldType = S.Context.getBaseElementType(Field->getType());
Sean Huntc530d172011-06-10 04:44:37 +00008662 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
Richard Smithb9d0b762012-07-27 04:22:15 +00008663 if (!S.LookupCopyingConstructor(FieldClassDecl, Qualifiers::Const))
8664 return false;
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008665 }
8666 }
Richard Smithb9d0b762012-07-27 04:22:15 +00008667
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008668 // Otherwise, the implicitly declared copy constructor will have
8669 // the form
8670 //
8671 // X::X(X&)
Richard Smithb9d0b762012-07-27 04:22:15 +00008672
8673 return true;
8674}
8675
8676Sema::ImplicitExceptionSpecification
8677Sema::ComputeDefaultedCopyCtorExceptionSpec(CXXMethodDecl *MD) {
8678 CXXRecordDecl *ClassDecl = MD->getParent();
8679
8680 ImplicitExceptionSpecification ExceptSpec(*this);
8681 if (ClassDecl->isInvalidDecl())
8682 return ExceptSpec;
8683
8684 const FunctionProtoType *T = MD->getType()->castAs<FunctionProtoType>();
8685 assert(T->getNumArgs() >= 1 && "not a copy ctor");
8686 unsigned Quals = T->getArgType(0).getNonReferenceType().getCVRQualifiers();
8687
Douglas Gregor0d405db2010-07-01 20:59:04 +00008688 // C++ [except.spec]p14:
8689 // An implicitly declared special member function (Clause 12) shall have an
8690 // exception-specification. [...]
Douglas Gregor0d405db2010-07-01 20:59:04 +00008691 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
8692 BaseEnd = ClassDecl->bases_end();
8693 Base != BaseEnd;
8694 ++Base) {
8695 // Virtual bases are handled below.
8696 if (Base->isVirtual())
8697 continue;
8698
Douglas Gregor22584312010-07-02 23:41:54 +00008699 CXXRecordDecl *BaseClassDecl
Douglas Gregor0d405db2010-07-01 20:59:04 +00008700 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Huntc530d172011-06-10 04:44:37 +00008701 if (CXXConstructorDecl *CopyConstructor =
Sean Hunt661c67a2011-06-21 23:42:56 +00008702 LookupCopyingConstructor(BaseClassDecl, Quals))
Richard Smithe6975e92012-04-17 00:58:00 +00008703 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008704 }
8705 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
8706 BaseEnd = ClassDecl->vbases_end();
8707 Base != BaseEnd;
8708 ++Base) {
Douglas Gregor22584312010-07-02 23:41:54 +00008709 CXXRecordDecl *BaseClassDecl
Douglas Gregor0d405db2010-07-01 20:59:04 +00008710 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
Sean Huntc530d172011-06-10 04:44:37 +00008711 if (CXXConstructorDecl *CopyConstructor =
Sean Hunt661c67a2011-06-21 23:42:56 +00008712 LookupCopyingConstructor(BaseClassDecl, Quals))
Richard Smithe6975e92012-04-17 00:58:00 +00008713 ExceptSpec.CalledDecl(Base->getLocStart(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008714 }
8715 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
8716 FieldEnd = ClassDecl->field_end();
8717 Field != FieldEnd;
8718 ++Field) {
David Blaikie262bc182012-04-30 02:36:29 +00008719 QualType FieldType = Context.getBaseElementType(Field->getType());
Sean Huntc530d172011-06-10 04:44:37 +00008720 if (CXXRecordDecl *FieldClassDecl = FieldType->getAsCXXRecordDecl()) {
8721 if (CXXConstructorDecl *CopyConstructor =
Richard Smith6a06e5f2012-07-18 03:36:00 +00008722 LookupCopyingConstructor(FieldClassDecl,
8723 Quals | FieldType.getCVRQualifiers()))
Richard Smithe6975e92012-04-17 00:58:00 +00008724 ExceptSpec.CalledDecl(Field->getLocation(), CopyConstructor);
Douglas Gregor0d405db2010-07-01 20:59:04 +00008725 }
8726 }
Sebastian Redl60618fa2011-03-12 11:50:43 +00008727
Richard Smithb9d0b762012-07-27 04:22:15 +00008728 return ExceptSpec;
Sean Hunt49634cf2011-05-13 06:10:58 +00008729}
8730
8731CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
8732 CXXRecordDecl *ClassDecl) {
8733 // C++ [class.copy]p4:
8734 // If the class definition does not explicitly declare a copy
8735 // constructor, one is declared implicitly.
8736
Sean Hunt49634cf2011-05-13 06:10:58 +00008737 QualType ClassType = Context.getTypeDeclType(ClassDecl);
8738 QualType ArgType = ClassType;
Richard Smithb9d0b762012-07-27 04:22:15 +00008739 bool Const = isImplicitCopyCtorArgConst(*this, ClassDecl);
Sean Hunt49634cf2011-05-13 06:10:58 +00008740 if (Const)
8741 ArgType = ArgType.withConst();
8742 ArgType = Context.getLValueReferenceType(ArgType);
Sean Hunt49634cf2011-05-13 06:10:58 +00008743
Richard Smith7756afa2012-06-10 05:43:50 +00008744 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8745 CXXCopyConstructor,
8746 Const);
8747
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008748 DeclarationName Name
8749 = Context.DeclarationNames.getCXXConstructorName(
8750 Context.getCanonicalType(ClassType));
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00008751 SourceLocation ClassLoc = ClassDecl->getLocation();
8752 DeclarationNameInfo NameInfo(Name, ClassLoc);
Sean Hunt49634cf2011-05-13 06:10:58 +00008753
8754 // An implicitly-declared copy constructor is an inline public
Richard Smith61802452011-12-22 02:22:31 +00008755 // member of its class.
8756 CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00008757 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00008758 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00008759 Constexpr);
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008760 CopyConstructor->setAccess(AS_public);
Sean Hunt49634cf2011-05-13 06:10:58 +00008761 CopyConstructor->setDefaulted();
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008762 CopyConstructor->setTrivial(ClassDecl->hasTrivialCopyConstructor());
Richard Smith61802452011-12-22 02:22:31 +00008763
Richard Smithb9d0b762012-07-27 04:22:15 +00008764 // Build an exception specification pointing back at this member.
8765 FunctionProtoType::ExtProtoInfo EPI;
8766 EPI.ExceptionSpecType = EST_Unevaluated;
8767 EPI.ExceptionSpecDecl = CopyConstructor;
8768 CopyConstructor->setType(
8769 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI));
8770
Douglas Gregor22584312010-07-02 23:41:54 +00008771 // Note that we have declared this constructor.
Douglas Gregor22584312010-07-02 23:41:54 +00008772 ++ASTContext::NumImplicitCopyConstructorsDeclared;
8773
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008774 // Add the parameter to the constructor.
8775 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyConstructor,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00008776 ClassLoc, ClassLoc,
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008777 /*IdentifierInfo=*/0,
8778 ArgType, /*TInfo=*/0,
John McCalld931b082010-08-26 03:08:43 +00008779 SC_None,
8780 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008781 CopyConstructor->setParams(FromParam);
Sean Hunt49634cf2011-05-13 06:10:58 +00008782
Douglas Gregor23c94db2010-07-02 17:43:08 +00008783 if (Scope *S = getScopeForContext(ClassDecl))
Douglas Gregor22584312010-07-02 23:41:54 +00008784 PushOnScopeChains(CopyConstructor, S, false);
8785 ClassDecl->addDecl(CopyConstructor);
Sean Hunt71a682f2011-05-18 03:41:58 +00008786
Nico Weberafcc96a2012-01-23 03:19:29 +00008787 // C++11 [class.copy]p8:
8788 // ... If the class definition does not explicitly declare a copy
8789 // constructor, there is no user-declared move constructor, and there is no
8790 // user-declared move assignment operator, a copy constructor is implicitly
8791 // declared as defaulted.
Richard Smith6c4c36c2012-03-30 20:53:28 +00008792 if (ShouldDeleteSpecialMember(CopyConstructor, CXXCopyConstructor))
Sean Hunt71a682f2011-05-18 03:41:58 +00008793 CopyConstructor->setDeletedAsWritten();
Richard Smith6c4c36c2012-03-30 20:53:28 +00008794
Douglas Gregor4a0c26f2010-07-01 17:57:27 +00008795 return CopyConstructor;
8796}
8797
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008798void Sema::DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
Sean Hunt49634cf2011-05-13 06:10:58 +00008799 CXXConstructorDecl *CopyConstructor) {
8800 assert((CopyConstructor->isDefaulted() &&
8801 CopyConstructor->isCopyConstructor() &&
Richard Smith03f68782012-02-26 07:51:39 +00008802 !CopyConstructor->doesThisDeclarationHaveABody() &&
8803 !CopyConstructor->isDeleted()) &&
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008804 "DefineImplicitCopyConstructor - call it for implicit copy ctor");
Mike Stump1eb44332009-09-09 15:08:12 +00008805
Anders Carlsson63010a72010-04-23 16:24:12 +00008806 CXXRecordDecl *ClassDecl = CopyConstructor->getParent();
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008807 assert(ClassDecl && "DefineImplicitCopyConstructor - invalid constructor");
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00008808
Douglas Gregor39957dc2010-05-01 15:04:51 +00008809 ImplicitlyDefinedFunctionScope Scope(*this, CopyConstructor);
Argyrios Kyrtzidis9c4eb1f2010-11-19 00:19:12 +00008810 DiagnosticErrorTrap Trap(Diags);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00008811
Sean Huntcbb67482011-01-08 20:30:50 +00008812 if (SetCtorInitializers(CopyConstructor, 0, 0, /*AnyErrors=*/false) ||
Douglas Gregorc63d2c82010-05-12 16:39:35 +00008813 Trap.hasErrorOccurred()) {
Anders Carlsson59b7f152010-05-01 16:39:01 +00008814 Diag(CurrentLocation, diag::note_member_synthesized_at)
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008815 << CXXCopyConstructor << Context.getTagDeclType(ClassDecl);
Anders Carlsson59b7f152010-05-01 16:39:01 +00008816 CopyConstructor->setInvalidDecl();
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008817 } else {
Dmitri Gribenko625bb562012-02-14 22:14:32 +00008818 Sema::CompoundScopeRAII CompoundScope(*this);
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008819 CopyConstructor->setBody(ActOnCompoundStmt(CopyConstructor->getLocation(),
8820 CopyConstructor->getLocation(),
Benjamin Kramer5354e772012-08-23 23:38:35 +00008821 MultiStmtArg(),
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008822 /*isStmtExpr=*/false)
8823 .takeAs<Stmt>());
Douglas Gregor690b2db2011-09-22 20:32:43 +00008824 CopyConstructor->setImplicitlyDefined(true);
Anders Carlsson8e142cc2010-04-25 00:52:09 +00008825 }
Douglas Gregorfb8cc252010-05-05 05:51:00 +00008826
8827 CopyConstructor->setUsed();
Sebastian Redl58a2cd82011-04-24 16:28:06 +00008828 if (ASTMutationListener *L = getASTMutationListener()) {
8829 L->CompletedImplicitDefinition(CopyConstructor);
8830 }
Fariborz Jahanian485f0872009-06-22 23:34:40 +00008831}
8832
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008833Sema::ImplicitExceptionSpecification
Richard Smithb9d0b762012-07-27 04:22:15 +00008834Sema::ComputeDefaultedMoveCtorExceptionSpec(CXXMethodDecl *MD) {
8835 CXXRecordDecl *ClassDecl = MD->getParent();
8836
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008837 // C++ [except.spec]p14:
8838 // An implicitly declared special member function (Clause 12) shall have an
8839 // exception-specification. [...]
Richard Smithe6975e92012-04-17 00:58:00 +00008840 ImplicitExceptionSpecification ExceptSpec(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008841 if (ClassDecl->isInvalidDecl())
8842 return ExceptSpec;
8843
8844 // Direct base-class constructors.
8845 for (CXXRecordDecl::base_class_iterator B = ClassDecl->bases_begin(),
8846 BEnd = ClassDecl->bases_end();
8847 B != BEnd; ++B) {
8848 if (B->isVirtual()) // Handled below.
8849 continue;
8850
8851 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
8852 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith6a06e5f2012-07-18 03:36:00 +00008853 CXXConstructorDecl *Constructor =
8854 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008855 // If this is a deleted function, add it anyway. This might be conformant
8856 // with the standard. This might not. I'm not sure. It might not matter.
8857 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008858 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008859 }
8860 }
8861
8862 // Virtual base-class constructors.
8863 for (CXXRecordDecl::base_class_iterator B = ClassDecl->vbases_begin(),
8864 BEnd = ClassDecl->vbases_end();
8865 B != BEnd; ++B) {
8866 if (const RecordType *BaseType = B->getType()->getAs<RecordType>()) {
8867 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
Richard Smith6a06e5f2012-07-18 03:36:00 +00008868 CXXConstructorDecl *Constructor =
8869 LookupMovingConstructor(BaseClassDecl, 0);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008870 // If this is a deleted function, add it anyway. This might be conformant
8871 // with the standard. This might not. I'm not sure. It might not matter.
8872 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008873 ExceptSpec.CalledDecl(B->getLocStart(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008874 }
8875 }
8876
8877 // Field constructors.
8878 for (RecordDecl::field_iterator F = ClassDecl->field_begin(),
8879 FEnd = ClassDecl->field_end();
8880 F != FEnd; ++F) {
Richard Smith6a06e5f2012-07-18 03:36:00 +00008881 QualType FieldType = Context.getBaseElementType(F->getType());
8882 if (CXXRecordDecl *FieldRecDecl = FieldType->getAsCXXRecordDecl()) {
8883 CXXConstructorDecl *Constructor =
8884 LookupMovingConstructor(FieldRecDecl, FieldType.getCVRQualifiers());
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008885 // If this is a deleted function, add it anyway. This might be conformant
8886 // with the standard. This might not. I'm not sure. It might not matter.
8887 // In particular, the problem is that this function never gets called. It
8888 // might just be ill-formed because this function attempts to refer to
8889 // a deleted function here.
8890 if (Constructor)
Richard Smithe6975e92012-04-17 00:58:00 +00008891 ExceptSpec.CalledDecl(F->getLocation(), Constructor);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008892 }
8893 }
8894
8895 return ExceptSpec;
8896}
8897
8898CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
8899 CXXRecordDecl *ClassDecl) {
Richard Smith1c931be2012-04-02 18:40:40 +00008900 // C++11 [class.copy]p9:
8901 // If the definition of a class X does not explicitly declare a move
8902 // constructor, one will be implicitly declared as defaulted if and only if:
8903 //
8904 // - [first 4 bullets]
8905 assert(ClassDecl->needsImplicitMoveConstructor());
8906
8907 // [Checked after we build the declaration]
8908 // - the move assignment operator would not be implicitly defined as
8909 // deleted,
8910
8911 // [DR1402]:
8912 // - each of X's non-static data members and direct or virtual base classes
8913 // has a type that either has a move constructor or is trivially copyable.
8914 if (!subobjectsHaveMoveOrTrivialCopy(*this, ClassDecl, /*Constructor*/true)) {
8915 ClassDecl->setFailedImplicitMoveConstructor();
8916 return 0;
8917 }
8918
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008919 QualType ClassType = Context.getTypeDeclType(ClassDecl);
8920 QualType ArgType = Context.getRValueReferenceType(ClassType);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008921
Richard Smith7756afa2012-06-10 05:43:50 +00008922 bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
8923 CXXMoveConstructor,
8924 false);
8925
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008926 DeclarationName Name
8927 = Context.DeclarationNames.getCXXConstructorName(
8928 Context.getCanonicalType(ClassType));
8929 SourceLocation ClassLoc = ClassDecl->getLocation();
8930 DeclarationNameInfo NameInfo(Name, ClassLoc);
8931
8932 // C++0x [class.copy]p11:
8933 // An implicitly-declared copy/move constructor is an inline public
Richard Smith61802452011-12-22 02:22:31 +00008934 // member of its class.
8935 CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
Richard Smithb9d0b762012-07-27 04:22:15 +00008936 Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/0,
Richard Smith61802452011-12-22 02:22:31 +00008937 /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
Richard Smith7756afa2012-06-10 05:43:50 +00008938 Constexpr);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008939 MoveConstructor->setAccess(AS_public);
8940 MoveConstructor->setDefaulted();
8941 MoveConstructor->setTrivial(ClassDecl->hasTrivialMoveConstructor());
Richard Smith61802452011-12-22 02:22:31 +00008942
Richard Smithb9d0b762012-07-27 04:22:15 +00008943 // Build an exception specification pointing back at this member.
8944 FunctionProtoType::ExtProtoInfo EPI;
8945 EPI.ExceptionSpecType = EST_Unevaluated;
8946 EPI.ExceptionSpecDecl = MoveConstructor;
8947 MoveConstructor->setType(
8948 Context.getFunctionType(Context.VoidTy, &ArgType, 1, EPI));
8949
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008950 // Add the parameter to the constructor.
8951 ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveConstructor,
8952 ClassLoc, ClassLoc,
8953 /*IdentifierInfo=*/0,
8954 ArgType, /*TInfo=*/0,
8955 SC_None,
8956 SC_None, 0);
David Blaikie4278c652011-09-21 18:16:56 +00008957 MoveConstructor->setParams(FromParam);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008958
8959 // C++0x [class.copy]p9:
8960 // If the definition of a class X does not explicitly declare a move
8961 // constructor, one will be implicitly declared as defaulted if and only if:
8962 // [...]
8963 // - the move constructor would not be implicitly defined as deleted.
Sean Hunt769bb2d2011-10-11 06:43:29 +00008964 if (ShouldDeleteSpecialMember(MoveConstructor, CXXMoveConstructor)) {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008965 // Cache this result so that we don't try to generate this over and over
8966 // on every lookup, leaking memory and wasting time.
8967 ClassDecl->setFailedImplicitMoveConstructor();
8968 return 0;
8969 }
8970
8971 // Note that we have declared this constructor.
8972 ++ASTContext::NumImplicitMoveConstructorsDeclared;
8973
8974 if (Scope *S = getScopeForContext(ClassDecl))
8975 PushOnScopeChains(MoveConstructor, S, false);
8976 ClassDecl->addDecl(MoveConstructor);
8977
8978 return MoveConstructor;
8979}
8980
8981void Sema::DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
8982 CXXConstructorDecl *MoveConstructor) {
8983 assert((MoveConstructor->isDefaulted() &&
8984 MoveConstructor->isMoveConstructor() &&
Richard Smith03f68782012-02-26 07:51:39 +00008985 !MoveConstructor->doesThisDeclarationHaveABody() &&
8986 !MoveConstructor->isDeleted()) &&
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00008987 "DefineImplicitMoveConstructor - call it for implicit move ctor");
8988
8989 CXXRecordDecl *ClassDecl = MoveConstructor->getParent();
8990 assert(ClassDecl && "DefineImplicitMoveConstructor - invalid constructor");
8991
8992 ImplicitlyDefinedFunctionScope Scope(*this, MoveConstructor);
8993 DiagnosticErrorTrap Trap(Diags);
8994
8995 if (SetCtorInitializers(MoveConstructor, 0, 0, /*AnyErrors=*/false) ||
8996 Trap.hasErrorOccurred()) {
8997 Diag(CurrentLocation, diag::note_member_synthesized_at)
8998 << CXXMoveConstructor << Context.getTagDeclType(ClassDecl);
8999 MoveConstructor->setInvalidDecl();
9000 } else {
Dmitri Gribenko625bb562012-02-14 22:14:32 +00009001 Sema::CompoundScopeRAII CompoundScope(*this);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00009002 MoveConstructor->setBody(ActOnCompoundStmt(MoveConstructor->getLocation(),
9003 MoveConstructor->getLocation(),
Benjamin Kramer5354e772012-08-23 23:38:35 +00009004 MultiStmtArg(),
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00009005 /*isStmtExpr=*/false)
9006 .takeAs<Stmt>());
Douglas Gregor690b2db2011-09-22 20:32:43 +00009007 MoveConstructor->setImplicitlyDefined(true);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +00009008 }
9009
9010 MoveConstructor->setUsed();
9011
9012 if (ASTMutationListener *L = getASTMutationListener()) {
9013 L->CompletedImplicitDefinition(MoveConstructor);
9014 }
9015}
9016
Douglas Gregore4e68d42012-02-15 19:33:52 +00009017bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
9018 return FD->isDeleted() &&
9019 (FD->isDefaulted() || FD->isImplicit()) &&
9020 isa<CXXMethodDecl>(FD);
9021}
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009022
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009023/// \brief Mark the call operator of the given lambda closure type as "used".
9024static void markLambdaCallOperatorUsed(Sema &S, CXXRecordDecl *Lambda) {
9025 CXXMethodDecl *CallOperator
Douglas Gregorac1303e2012-02-22 05:02:47 +00009026 = cast<CXXMethodDecl>(
9027 *Lambda->lookup(
9028 S.Context.DeclarationNames.getCXXOperatorName(OO_Call)).first);
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009029 CallOperator->setReferenced();
9030 CallOperator->setUsed();
9031}
9032
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009033void Sema::DefineImplicitLambdaToFunctionPointerConversion(
9034 SourceLocation CurrentLocation,
9035 CXXConversionDecl *Conv)
9036{
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009037 CXXRecordDecl *Lambda = Conv->getParent();
9038
9039 // Make sure that the lambda call operator is marked used.
9040 markLambdaCallOperatorUsed(*this, Lambda);
9041
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009042 Conv->setUsed();
9043
9044 ImplicitlyDefinedFunctionScope Scope(*this, Conv);
9045 DiagnosticErrorTrap Trap(Diags);
9046
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009047 // Return the address of the __invoke function.
9048 DeclarationName InvokeName = &Context.Idents.get("__invoke");
9049 CXXMethodDecl *Invoke
9050 = cast<CXXMethodDecl>(*Lambda->lookup(InvokeName).first);
9051 Expr *FunctionRef = BuildDeclRefExpr(Invoke, Invoke->getType(),
9052 VK_LValue, Conv->getLocation()).take();
9053 assert(FunctionRef && "Can't refer to __invoke function?");
9054 Stmt *Return = ActOnReturnStmt(Conv->getLocation(), FunctionRef).take();
9055 Conv->setBody(new (Context) CompoundStmt(Context, &Return, 1,
9056 Conv->getLocation(),
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009057 Conv->getLocation()));
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009058
9059 // Fill in the __invoke function with a dummy implementation. IR generation
9060 // will fill in the actual details.
9061 Invoke->setUsed();
9062 Invoke->setReferenced();
Benjamin Kramer3a2d0fb2012-07-04 17:03:41 +00009063 Invoke->setBody(new (Context) CompoundStmt(Conv->getLocation()));
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009064
9065 if (ASTMutationListener *L = getASTMutationListener()) {
9066 L->CompletedImplicitDefinition(Conv);
Douglas Gregor27dd7d92012-02-17 03:02:34 +00009067 L->CompletedImplicitDefinition(Invoke);
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009068 }
9069}
9070
9071void Sema::DefineImplicitLambdaToBlockPointerConversion(
9072 SourceLocation CurrentLocation,
9073 CXXConversionDecl *Conv)
9074{
9075 Conv->setUsed();
9076
9077 ImplicitlyDefinedFunctionScope Scope(*this, Conv);
9078 DiagnosticErrorTrap Trap(Diags);
9079
Douglas Gregorac1303e2012-02-22 05:02:47 +00009080 // Copy-initialize the lambda object as needed to capture it.
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009081 Expr *This = ActOnCXXThis(CurrentLocation).take();
9082 Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).take();
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009083
Eli Friedman23f02672012-03-01 04:01:32 +00009084 ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
9085 Conv->getLocation(),
9086 Conv, DerefThis);
9087
9088 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
9089 // behavior. Note that only the general conversion function does this
9090 // (since it's unusable otherwise); in the case where we inline the
9091 // block literal, it has block literal lifetime semantics.
David Blaikie4e4d0842012-03-11 07:00:24 +00009092 if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
Eli Friedman23f02672012-03-01 04:01:32 +00009093 BuildBlock = ImplicitCastExpr::Create(Context, BuildBlock.get()->getType(),
9094 CK_CopyAndAutoreleaseBlockObject,
9095 BuildBlock.get(), 0, VK_RValue);
9096
9097 if (BuildBlock.isInvalid()) {
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009098 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
Douglas Gregorac1303e2012-02-22 05:02:47 +00009099 Conv->setInvalidDecl();
9100 return;
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009101 }
Douglas Gregorac1303e2012-02-22 05:02:47 +00009102
Douglas Gregorac1303e2012-02-22 05:02:47 +00009103 // Create the return statement that returns the block from the conversion
9104 // function.
Eli Friedman23f02672012-03-01 04:01:32 +00009105 StmtResult Return = ActOnReturnStmt(Conv->getLocation(), BuildBlock.get());
Douglas Gregorac1303e2012-02-22 05:02:47 +00009106 if (Return.isInvalid()) {
9107 Diag(CurrentLocation, diag::note_lambda_to_block_conv);
9108 Conv->setInvalidDecl();
9109 return;
9110 }
9111
9112 // Set the body of the conversion function.
9113 Stmt *ReturnS = Return.take();
9114 Conv->setBody(new (Context) CompoundStmt(Context, &ReturnS, 1,
9115 Conv->getLocation(),
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009116 Conv->getLocation()));
9117
Douglas Gregorac1303e2012-02-22 05:02:47 +00009118 // We're done; notify the mutation listener, if any.
Douglas Gregorf6e2e022012-02-16 01:06:16 +00009119 if (ASTMutationListener *L = getASTMutationListener()) {
9120 L->CompletedImplicitDefinition(Conv);
9121 }
9122}
9123
Douglas Gregorf52757d2012-03-10 06:53:13 +00009124/// \brief Determine whether the given list arguments contains exactly one
9125/// "real" (non-default) argument.
9126static bool hasOneRealArgument(MultiExprArg Args) {
9127 switch (Args.size()) {
9128 case 0:
9129 return false;
9130
9131 default:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009132 if (!Args[1]->isDefaultArgument())
Douglas Gregorf52757d2012-03-10 06:53:13 +00009133 return false;
9134
9135 // fall through
9136 case 1:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009137 return !Args[0]->isDefaultArgument();
Douglas Gregorf52757d2012-03-10 06:53:13 +00009138 }
9139
9140 return false;
9141}
9142
John McCall60d7b3a2010-08-24 06:29:42 +00009143ExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00009144Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
Mike Stump1eb44332009-09-09 15:08:12 +00009145 CXXConstructorDecl *Constructor,
Douglas Gregor16006c92009-12-16 18:50:27 +00009146 MultiExprArg ExprArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009147 bool HadMultipleCandidates,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00009148 bool RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009149 unsigned ConstructKind,
9150 SourceRange ParenRange) {
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009151 bool Elidable = false;
Mike Stump1eb44332009-09-09 15:08:12 +00009152
Douglas Gregor2f599792010-04-02 18:24:57 +00009153 // C++0x [class.copy]p34:
9154 // When certain criteria are met, an implementation is allowed to
9155 // omit the copy/move construction of a class object, even if the
9156 // copy/move constructor and/or destructor for the object have
9157 // side effects. [...]
9158 // - when a temporary class object that has not been bound to a
9159 // reference (12.2) would be copied/moved to a class object
9160 // with the same cv-unqualified type, the copy/move operation
9161 // can be omitted by constructing the temporary object
9162 // directly into the target of the omitted copy/move
John McCall558d2ab2010-09-15 10:14:12 +00009163 if (ConstructKind == CXXConstructExpr::CK_Complete &&
Douglas Gregorf52757d2012-03-10 06:53:13 +00009164 Constructor->isCopyOrMoveConstructor() && hasOneRealArgument(ExprArgs)) {
Benjamin Kramer5354e772012-08-23 23:38:35 +00009165 Expr *SubExpr = ExprArgs[0];
John McCall558d2ab2010-09-15 10:14:12 +00009166 Elidable = SubExpr->isTemporaryObject(Context, Constructor->getParent());
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009167 }
Mike Stump1eb44332009-09-09 15:08:12 +00009168
9169 return BuildCXXConstructExpr(ConstructLoc, DeclInitType, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009170 Elidable, ExprArgs, HadMultipleCandidates,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009171 RequiresZeroInit, ConstructKind, ParenRange);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00009172}
9173
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009174/// BuildCXXConstructExpr - Creates a complete call to a constructor,
9175/// including handling of its default argument expressions.
John McCall60d7b3a2010-08-24 06:29:42 +00009176ExprResult
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00009177Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
9178 CXXConstructorDecl *Constructor, bool Elidable,
Douglas Gregor16006c92009-12-16 18:50:27 +00009179 MultiExprArg ExprArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009180 bool HadMultipleCandidates,
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00009181 bool RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009182 unsigned ConstructKind,
9183 SourceRange ParenRange) {
Eli Friedman5f2987c2012-02-02 03:46:19 +00009184 MarkFunctionReferenced(ConstructLoc, Constructor);
Douglas Gregor99a2e602009-12-16 01:38:02 +00009185 return Owned(CXXConstructExpr::Create(Context, DeclInitType, ConstructLoc,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00009186 Constructor, Elidable, ExprArgs,
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00009187 HadMultipleCandidates, /*FIXME*/false,
9188 RequiresZeroInit,
Chandler Carruth428edaf2010-10-25 08:47:36 +00009189 static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
9190 ParenRange));
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009191}
9192
Mike Stump1eb44332009-09-09 15:08:12 +00009193bool Sema::InitializeVarWithConstructor(VarDecl *VD,
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00009194 CXXConstructorDecl *Constructor,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009195 MultiExprArg Exprs,
9196 bool HadMultipleCandidates) {
Chandler Carruth428edaf2010-10-25 08:47:36 +00009197 // FIXME: Provide the correct paren SourceRange when available.
John McCall60d7b3a2010-08-24 06:29:42 +00009198 ExprResult TempResult =
Fariborz Jahanianc0fcce42009-10-28 18:41:06 +00009199 BuildCXXConstructExpr(VD->getLocation(), VD->getType(), Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00009200 Exprs, HadMultipleCandidates, false,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00009201 CXXConstructExpr::CK_Complete, SourceRange());
Anders Carlssonfe2de492009-08-25 05:18:00 +00009202 if (TempResult.isInvalid())
9203 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00009204
Anders Carlssonda3f4e22009-08-25 05:12:04 +00009205 Expr *Temp = TempResult.takeAs<Expr>();
John McCallb4eb64d2010-10-08 02:01:28 +00009206 CheckImplicitConversions(Temp, VD->getLocation());
Eli Friedman5f2987c2012-02-02 03:46:19 +00009207 MarkFunctionReferenced(VD->getLocation(), Constructor);
John McCall4765fa02010-12-06 08:20:24 +00009208 Temp = MaybeCreateExprWithCleanups(Temp);
Douglas Gregor838db382010-02-11 01:19:42 +00009209 VD->setInit(Temp);
Mike Stump1eb44332009-09-09 15:08:12 +00009210
Anders Carlssonfe2de492009-08-25 05:18:00 +00009211 return false;
Anders Carlsson930e8d02009-04-16 23:50:50 +00009212}
9213
John McCall68c6c9a2010-02-02 09:10:11 +00009214void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009215 if (VD->isInvalidDecl()) return;
9216
John McCall68c6c9a2010-02-02 09:10:11 +00009217 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Record->getDecl());
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009218 if (ClassDecl->isInvalidDecl()) return;
Richard Smith213d70b2012-02-18 04:13:32 +00009219 if (ClassDecl->hasIrrelevantDestructor()) return;
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009220 if (ClassDecl->isDependentContext()) return;
John McCall626e96e2010-08-01 20:20:59 +00009221
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009222 CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
Eli Friedman5f2987c2012-02-02 03:46:19 +00009223 MarkFunctionReferenced(VD->getLocation(), Destructor);
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009224 CheckDestructorAccess(VD->getLocation(), Destructor,
9225 PDiag(diag::err_access_dtor_var)
9226 << VD->getDeclName()
9227 << VD->getType());
Richard Smith213d70b2012-02-18 04:13:32 +00009228 DiagnoseUseOfDecl(Destructor, VD->getLocation());
Anders Carlsson2b32dad2011-03-24 01:01:41 +00009229
Chandler Carruth1d71cbf2011-03-27 21:26:48 +00009230 if (!VD->hasGlobalStorage()) return;
9231
9232 // Emit warning for non-trivial dtor in global scope (a real global,
9233 // class-static, function-static).
9234 Diag(VD->getLocation(), diag::warn_exit_time_destructor);
9235
9236 // TODO: this should be re-enabled for static locals by !CXAAtExit
9237 if (!VD->isStaticLocal())
9238 Diag(VD->getLocation(), diag::warn_global_destructor);
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00009239}
9240
Douglas Gregor39da0b82009-09-09 23:08:42 +00009241/// \brief Given a constructor and the set of arguments provided for the
9242/// constructor, convert the arguments and add any required default arguments
9243/// to form a proper call to this constructor.
9244///
9245/// \returns true if an error occurred, false otherwise.
9246bool
9247Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
9248 MultiExprArg ArgsPtr,
Richard Smith831421f2012-06-25 20:30:08 +00009249 SourceLocation Loc,
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00009250 SmallVectorImpl<Expr*> &ConvertedArgs,
Douglas Gregored878af2012-02-24 23:56:31 +00009251 bool AllowExplicit) {
Douglas Gregor39da0b82009-09-09 23:08:42 +00009252 // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
9253 unsigned NumArgs = ArgsPtr.size();
Benjamin Kramer5354e772012-08-23 23:38:35 +00009254 Expr **Args = ArgsPtr.data();
Douglas Gregor39da0b82009-09-09 23:08:42 +00009255
9256 const FunctionProtoType *Proto
9257 = Constructor->getType()->getAs<FunctionProtoType>();
9258 assert(Proto && "Constructor without a prototype?");
9259 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregor39da0b82009-09-09 23:08:42 +00009260
9261 // If too few arguments are available, we'll fill in the rest with defaults.
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009262 if (NumArgs < NumArgsInProto)
Douglas Gregor39da0b82009-09-09 23:08:42 +00009263 ConvertedArgs.reserve(NumArgsInProto);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009264 else
Douglas Gregor39da0b82009-09-09 23:08:42 +00009265 ConvertedArgs.reserve(NumArgs);
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009266
9267 VariadicCallType CallType =
9268 Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
Chris Lattner5f9e2722011-07-23 10:55:15 +00009269 SmallVector<Expr *, 8> AllArgs;
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009270 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
9271 Proto, 0, Args, NumArgs, AllArgs,
Douglas Gregored878af2012-02-24 23:56:31 +00009272 CallType, AllowExplicit);
Benjamin Kramer14c59822012-02-14 12:06:21 +00009273 ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
Eli Friedmane61eb042012-02-18 04:48:30 +00009274
9275 DiagnoseSentinelCalls(Constructor, Loc, AllArgs.data(), AllArgs.size());
9276
Richard Smith831421f2012-06-25 20:30:08 +00009277 CheckConstructorCall(Constructor, AllArgs.data(), AllArgs.size(),
9278 Proto, Loc);
Eli Friedmane61eb042012-02-18 04:48:30 +00009279
Fariborz Jahanian2fe168f2009-11-24 21:37:28 +00009280 return Invalid;
Douglas Gregor18fe5682008-11-03 20:45:27 +00009281}
9282
Anders Carlsson20d45d22009-12-12 00:32:00 +00009283static inline bool
9284CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,
9285 const FunctionDecl *FnDecl) {
Sebastian Redl7a126a42010-08-31 00:36:30 +00009286 const DeclContext *DC = FnDecl->getDeclContext()->getRedeclContext();
Anders Carlsson20d45d22009-12-12 00:32:00 +00009287 if (isa<NamespaceDecl>(DC)) {
9288 return SemaRef.Diag(FnDecl->getLocation(),
9289 diag::err_operator_new_delete_declared_in_namespace)
9290 << FnDecl->getDeclName();
9291 }
9292
9293 if (isa<TranslationUnitDecl>(DC) &&
John McCalld931b082010-08-26 03:08:43 +00009294 FnDecl->getStorageClass() == SC_Static) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00009295 return SemaRef.Diag(FnDecl->getLocation(),
9296 diag::err_operator_new_delete_declared_static)
9297 << FnDecl->getDeclName();
9298 }
9299
Anders Carlssonfcfdb2b2009-12-12 02:43:16 +00009300 return false;
Anders Carlsson20d45d22009-12-12 00:32:00 +00009301}
9302
Anders Carlsson156c78e2009-12-13 17:53:43 +00009303static inline bool
9304CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl,
9305 CanQualType ExpectedResultType,
9306 CanQualType ExpectedFirstParamType,
9307 unsigned DependentParamTypeDiag,
9308 unsigned InvalidParamTypeDiag) {
9309 QualType ResultType =
9310 FnDecl->getType()->getAs<FunctionType>()->getResultType();
9311
9312 // Check that the result type is not dependent.
9313 if (ResultType->isDependentType())
9314 return SemaRef.Diag(FnDecl->getLocation(),
9315 diag::err_operator_new_delete_dependent_result_type)
9316 << FnDecl->getDeclName() << ExpectedResultType;
9317
9318 // Check that the result type is what we expect.
9319 if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType)
9320 return SemaRef.Diag(FnDecl->getLocation(),
9321 diag::err_operator_new_delete_invalid_result_type)
9322 << FnDecl->getDeclName() << ExpectedResultType;
9323
9324 // A function template must have at least 2 parameters.
9325 if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)
9326 return SemaRef.Diag(FnDecl->getLocation(),
9327 diag::err_operator_new_delete_template_too_few_parameters)
9328 << FnDecl->getDeclName();
9329
9330 // The function decl must have at least 1 parameter.
9331 if (FnDecl->getNumParams() == 0)
9332 return SemaRef.Diag(FnDecl->getLocation(),
9333 diag::err_operator_new_delete_too_few_parameters)
9334 << FnDecl->getDeclName();
9335
Sylvestre Ledrubed28ac2012-07-23 08:59:39 +00009336 // Check the first parameter type is not dependent.
Anders Carlsson156c78e2009-12-13 17:53:43 +00009337 QualType FirstParamType = FnDecl->getParamDecl(0)->getType();
9338 if (FirstParamType->isDependentType())
9339 return SemaRef.Diag(FnDecl->getLocation(), DependentParamTypeDiag)
9340 << FnDecl->getDeclName() << ExpectedFirstParamType;
9341
9342 // Check that the first parameter type is what we expect.
Douglas Gregor6e790ab2009-12-22 23:42:49 +00009343 if (SemaRef.Context.getCanonicalType(FirstParamType).getUnqualifiedType() !=
Anders Carlsson156c78e2009-12-13 17:53:43 +00009344 ExpectedFirstParamType)
9345 return SemaRef.Diag(FnDecl->getLocation(), InvalidParamTypeDiag)
9346 << FnDecl->getDeclName() << ExpectedFirstParamType;
9347
9348 return false;
9349}
9350
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009351static bool
Anders Carlsson156c78e2009-12-13 17:53:43 +00009352CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
Anders Carlsson20d45d22009-12-12 00:32:00 +00009353 // C++ [basic.stc.dynamic.allocation]p1:
9354 // A program is ill-formed if an allocation function is declared in a
9355 // namespace scope other than global scope or declared static in global
9356 // scope.
9357 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
9358 return true;
Anders Carlsson156c78e2009-12-13 17:53:43 +00009359
9360 CanQualType SizeTy =
9361 SemaRef.Context.getCanonicalType(SemaRef.Context.getSizeType());
9362
9363 // C++ [basic.stc.dynamic.allocation]p1:
9364 // The return type shall be void*. The first parameter shall have type
9365 // std::size_t.
9366 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy,
9367 SizeTy,
9368 diag::err_operator_new_dependent_param_type,
9369 diag::err_operator_new_param_type))
9370 return true;
9371
9372 // C++ [basic.stc.dynamic.allocation]p1:
9373 // The first parameter shall not have an associated default argument.
9374 if (FnDecl->getParamDecl(0)->hasDefaultArg())
Anders Carlssona3ccda52009-12-12 00:26:23 +00009375 return SemaRef.Diag(FnDecl->getLocation(),
Anders Carlsson156c78e2009-12-13 17:53:43 +00009376 diag::err_operator_new_default_arg)
9377 << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();
9378
9379 return false;
Anders Carlssona3ccda52009-12-12 00:26:23 +00009380}
9381
9382static bool
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009383CheckOperatorDeleteDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {
9384 // C++ [basic.stc.dynamic.deallocation]p1:
9385 // A program is ill-formed if deallocation functions are declared in a
9386 // namespace scope other than global scope or declared static in global
9387 // scope.
Anders Carlsson20d45d22009-12-12 00:32:00 +00009388 if (CheckOperatorNewDeleteDeclarationScope(SemaRef, FnDecl))
9389 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009390
9391 // C++ [basic.stc.dynamic.deallocation]p2:
9392 // Each deallocation function shall return void and its first parameter
9393 // shall be void*.
Anders Carlsson156c78e2009-12-13 17:53:43 +00009394 if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy,
9395 SemaRef.Context.VoidPtrTy,
9396 diag::err_operator_delete_dependent_param_type,
9397 diag::err_operator_delete_param_type))
9398 return true;
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009399
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009400 return false;
9401}
9402
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009403/// CheckOverloadedOperatorDeclaration - Check whether the declaration
9404/// of this overloaded operator is well-formed. If so, returns false;
9405/// otherwise, emits appropriate diagnostics and returns true.
9406bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009407 assert(FnDecl && FnDecl->isOverloadedOperator() &&
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009408 "Expected an overloaded operator declaration");
9409
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009410 OverloadedOperatorKind Op = FnDecl->getOverloadedOperator();
9411
Mike Stump1eb44332009-09-09 15:08:12 +00009412 // C++ [over.oper]p5:
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009413 // The allocation and deallocation functions, operator new,
9414 // operator new[], operator delete and operator delete[], are
9415 // described completely in 3.7.3. The attributes and restrictions
9416 // found in the rest of this subclause do not apply to them unless
9417 // explicitly stated in 3.7.3.
Anders Carlsson1152c392009-12-11 23:31:21 +00009418 if (Op == OO_Delete || Op == OO_Array_Delete)
Anders Carlsson9d59ecb2009-12-11 23:23:22 +00009419 return CheckOperatorDeleteDeclaration(*this, FnDecl);
Fariborz Jahanianb03bfa52009-11-10 23:47:18 +00009420
Anders Carlssona3ccda52009-12-12 00:26:23 +00009421 if (Op == OO_New || Op == OO_Array_New)
9422 return CheckOperatorNewDeclaration(*this, FnDecl);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009423
9424 // C++ [over.oper]p6:
9425 // An operator function shall either be a non-static member
9426 // function or be a non-member function and have at least one
9427 // parameter whose type is a class, a reference to a class, an
9428 // enumeration, or a reference to an enumeration.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009429 if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
9430 if (MethodDecl->isStatic())
9431 return Diag(FnDecl->getLocation(),
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009432 diag::err_operator_overload_static) << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009433 } else {
9434 bool ClassOrEnumParam = false;
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009435 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
9436 ParamEnd = FnDecl->param_end();
9437 Param != ParamEnd; ++Param) {
9438 QualType ParamType = (*Param)->getType().getNonReferenceType();
Eli Friedman5d39dee2009-06-27 05:59:59 +00009439 if (ParamType->isDependentType() || ParamType->isRecordType() ||
9440 ParamType->isEnumeralType()) {
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009441 ClassOrEnumParam = true;
9442 break;
9443 }
9444 }
9445
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009446 if (!ClassOrEnumParam)
9447 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009448 diag::err_operator_overload_needs_class_or_enum)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009449 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009450 }
9451
9452 // C++ [over.oper]p8:
9453 // An operator function cannot have default arguments (8.3.6),
9454 // except where explicitly stated below.
9455 //
Mike Stump1eb44332009-09-09 15:08:12 +00009456 // Only the function-call operator allows default arguments
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009457 // (C++ [over.call]p1).
9458 if (Op != OO_Call) {
9459 for (FunctionDecl::param_iterator Param = FnDecl->param_begin();
9460 Param != FnDecl->param_end(); ++Param) {
Anders Carlsson156c78e2009-12-13 17:53:43 +00009461 if ((*Param)->hasDefaultArg())
Mike Stump1eb44332009-09-09 15:08:12 +00009462 return Diag((*Param)->getLocation(),
Douglas Gregor61366e92008-12-24 00:01:03 +00009463 diag::err_operator_overload_default_arg)
Anders Carlsson156c78e2009-12-13 17:53:43 +00009464 << FnDecl->getDeclName() << (*Param)->getDefaultArgRange();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009465 }
9466 }
9467
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009468 static const bool OperatorUses[NUM_OVERLOADED_OPERATORS][3] = {
9469 { false, false, false }
9470#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
9471 , { Unary, Binary, MemberOnly }
9472#include "clang/Basic/OperatorKinds.def"
9473 };
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009474
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009475 bool CanBeUnaryOperator = OperatorUses[Op][0];
9476 bool CanBeBinaryOperator = OperatorUses[Op][1];
9477 bool MustBeMemberOperator = OperatorUses[Op][2];
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009478
9479 // C++ [over.oper]p8:
9480 // [...] Operator functions cannot have more or fewer parameters
9481 // than the number required for the corresponding operator, as
9482 // described in the rest of this subclause.
Mike Stump1eb44332009-09-09 15:08:12 +00009483 unsigned NumParams = FnDecl->getNumParams()
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009484 + (isa<CXXMethodDecl>(FnDecl)? 1 : 0);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009485 if (Op != OO_Call &&
9486 ((NumParams == 1 && !CanBeUnaryOperator) ||
9487 (NumParams == 2 && !CanBeBinaryOperator) ||
9488 (NumParams < 1) || (NumParams > 2))) {
9489 // We have the wrong number of parameters.
Chris Lattner416e46f2008-11-21 07:57:12 +00009490 unsigned ErrorKind;
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009491 if (CanBeUnaryOperator && CanBeBinaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00009492 ErrorKind = 2; // 2 -> unary or binary.
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009493 } else if (CanBeUnaryOperator) {
Chris Lattner416e46f2008-11-21 07:57:12 +00009494 ErrorKind = 0; // 0 -> unary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009495 } else {
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00009496 assert(CanBeBinaryOperator &&
9497 "All non-call overloaded operators are unary or binary!");
Chris Lattner416e46f2008-11-21 07:57:12 +00009498 ErrorKind = 1; // 1 -> binary
Douglas Gregor02bcd4c2008-11-10 13:38:07 +00009499 }
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009500
Chris Lattner416e46f2008-11-21 07:57:12 +00009501 return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009502 << FnDecl->getDeclName() << NumParams << ErrorKind;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009503 }
Sebastian Redl64b45f72009-01-05 20:52:13 +00009504
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009505 // Overloaded operators other than operator() cannot be variadic.
9506 if (Op != OO_Call &&
John McCall183700f2009-09-21 23:43:11 +00009507 FnDecl->getType()->getAs<FunctionProtoType>()->isVariadic()) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009508 return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009509 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009510 }
9511
9512 // Some operators must be non-static member functions.
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009513 if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
9514 return Diag(FnDecl->getLocation(),
Chris Lattnerf3a41af2008-11-20 06:38:18 +00009515 diag::err_operator_overload_must_be_member)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00009516 << FnDecl->getDeclName();
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009517 }
9518
9519 // C++ [over.inc]p1:
9520 // The user-defined function called operator++ implements the
9521 // prefix and postfix ++ operator. If this function is a member
9522 // function with no parameters, or a non-member function with one
9523 // parameter of class or enumeration type, it defines the prefix
9524 // increment operator ++ for objects of that type. If the function
9525 // is a member function with one parameter (which shall be of type
9526 // int) or a non-member function with two parameters (the second
9527 // of which shall be of type int), it defines the postfix
9528 // increment operator ++ for objects of that type.
9529 if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {
9530 ParmVarDecl *LastParam = FnDecl->getParamDecl(FnDecl->getNumParams() - 1);
9531 bool ParamIsInt = false;
John McCall183700f2009-09-21 23:43:11 +00009532 if (const BuiltinType *BT = LastParam->getType()->getAs<BuiltinType>())
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009533 ParamIsInt = BT->getKind() == BuiltinType::Int;
9534
Chris Lattneraf7ae4e2008-11-21 07:50:02 +00009535 if (!ParamIsInt)
9536 return Diag(LastParam->getLocation(),
Mike Stump1eb44332009-09-09 15:08:12 +00009537 diag::err_operator_overload_post_incdec_must_be_int)
Chris Lattnerd1625842008-11-24 06:25:27 +00009538 << LastParam->getType() << (Op == OO_MinusMinus);
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009539 }
9540
Douglas Gregor43c7bad2008-11-17 16:14:12 +00009541 return false;
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00009542}
Chris Lattner5a003a42008-12-17 07:09:26 +00009543
Sean Hunta6c058d2010-01-13 09:01:02 +00009544/// CheckLiteralOperatorDeclaration - Check whether the declaration
9545/// of this literal operator function is well-formed. If so, returns
9546/// false; otherwise, emits appropriate diagnostics and returns true.
9547bool Sema::CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl) {
Richard Smithe5658f02012-03-10 22:18:57 +00009548 if (isa<CXXMethodDecl>(FnDecl)) {
Sean Hunta6c058d2010-01-13 09:01:02 +00009549 Diag(FnDecl->getLocation(), diag::err_literal_operator_outside_namespace)
9550 << FnDecl->getDeclName();
9551 return true;
9552 }
9553
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009554 if (FnDecl->isExternC()) {
9555 Diag(FnDecl->getLocation(), diag::err_literal_operator_extern_c);
9556 return true;
9557 }
9558
Sean Hunta6c058d2010-01-13 09:01:02 +00009559 bool Valid = false;
9560
Richard Smith36f5cfe2012-03-09 08:00:36 +00009561 // This might be the definition of a literal operator template.
9562 FunctionTemplateDecl *TpDecl = FnDecl->getDescribedFunctionTemplate();
9563 // This might be a specialization of a literal operator template.
9564 if (!TpDecl)
9565 TpDecl = FnDecl->getPrimaryTemplate();
9566
Sean Hunt216c2782010-04-07 23:11:06 +00009567 // template <char...> type operator "" name() is the only valid template
9568 // signature, and the only valid signature with no parameters.
Richard Smith36f5cfe2012-03-09 08:00:36 +00009569 if (TpDecl) {
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009570 if (FnDecl->param_size() == 0) {
Sean Hunt216c2782010-04-07 23:11:06 +00009571 // Must have only one template parameter
9572 TemplateParameterList *Params = TpDecl->getTemplateParameters();
9573 if (Params->size() == 1) {
9574 NonTypeTemplateParmDecl *PmDecl =
Richard Smith5295b972012-08-03 21:14:57 +00009575 dyn_cast<NonTypeTemplateParmDecl>(Params->getParam(0));
Sean Hunta6c058d2010-01-13 09:01:02 +00009576
Sean Hunt216c2782010-04-07 23:11:06 +00009577 // The template parameter must be a char parameter pack.
Sean Hunt216c2782010-04-07 23:11:06 +00009578 if (PmDecl && PmDecl->isTemplateParameterPack() &&
9579 Context.hasSameType(PmDecl->getType(), Context.CharTy))
9580 Valid = true;
9581 }
9582 }
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009583 } else if (FnDecl->param_size()) {
Sean Hunta6c058d2010-01-13 09:01:02 +00009584 // Check the first parameter
Sean Hunt216c2782010-04-07 23:11:06 +00009585 FunctionDecl::param_iterator Param = FnDecl->param_begin();
9586
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009587 QualType T = (*Param)->getType().getUnqualifiedType();
Sean Hunta6c058d2010-01-13 09:01:02 +00009588
Sean Hunt30019c02010-04-07 22:57:35 +00009589 // unsigned long long int, long double, and any character type are allowed
9590 // as the only parameters.
Sean Hunta6c058d2010-01-13 09:01:02 +00009591 if (Context.hasSameType(T, Context.UnsignedLongLongTy) ||
9592 Context.hasSameType(T, Context.LongDoubleTy) ||
9593 Context.hasSameType(T, Context.CharTy) ||
9594 Context.hasSameType(T, Context.WCharTy) ||
9595 Context.hasSameType(T, Context.Char16Ty) ||
9596 Context.hasSameType(T, Context.Char32Ty)) {
9597 if (++Param == FnDecl->param_end())
9598 Valid = true;
9599 goto FinishedParams;
9600 }
9601
Sean Hunt30019c02010-04-07 22:57:35 +00009602 // Otherwise it must be a pointer to const; let's strip those qualifiers.
Sean Hunta6c058d2010-01-13 09:01:02 +00009603 const PointerType *PT = T->getAs<PointerType>();
9604 if (!PT)
9605 goto FinishedParams;
9606 T = PT->getPointeeType();
Richard Smithb4a7b1e2012-03-04 09:41:16 +00009607 if (!T.isConstQualified() || T.isVolatileQualified())
Sean Hunta6c058d2010-01-13 09:01:02 +00009608 goto FinishedParams;
9609 T = T.getUnqualifiedType();
9610
9611 // Move on to the second parameter;
9612 ++Param;
9613
9614 // If there is no second parameter, the first must be a const char *
9615 if (Param == FnDecl->param_end()) {
9616 if (Context.hasSameType(T, Context.CharTy))
9617 Valid = true;
9618 goto FinishedParams;
9619 }
9620
9621 // const char *, const wchar_t*, const char16_t*, and const char32_t*
9622 // are allowed as the first parameter to a two-parameter function
9623 if (!(Context.hasSameType(T, Context.CharTy) ||
9624 Context.hasSameType(T, Context.WCharTy) ||
9625 Context.hasSameType(T, Context.Char16Ty) ||
9626 Context.hasSameType(T, Context.Char32Ty)))
9627 goto FinishedParams;
9628
9629 // The second and final parameter must be an std::size_t
9630 T = (*Param)->getType().getUnqualifiedType();
9631 if (Context.hasSameType(T, Context.getSizeType()) &&
9632 ++Param == FnDecl->param_end())
9633 Valid = true;
9634 }
9635
9636 // FIXME: This diagnostic is absolutely terrible.
9637FinishedParams:
9638 if (!Valid) {
9639 Diag(FnDecl->getLocation(), diag::err_literal_operator_params)
9640 << FnDecl->getDeclName();
9641 return true;
9642 }
9643
Richard Smitha9e88b22012-03-09 08:16:22 +00009644 // A parameter-declaration-clause containing a default argument is not
9645 // equivalent to any of the permitted forms.
9646 for (FunctionDecl::param_iterator Param = FnDecl->param_begin(),
9647 ParamEnd = FnDecl->param_end();
9648 Param != ParamEnd; ++Param) {
9649 if ((*Param)->hasDefaultArg()) {
9650 Diag((*Param)->getDefaultArgRange().getBegin(),
9651 diag::err_literal_operator_default_argument)
9652 << (*Param)->getDefaultArgRange();
9653 break;
9654 }
9655 }
9656
Richard Smith2fb4ae32012-03-08 02:39:21 +00009657 StringRef LiteralName
Douglas Gregor1155c422011-08-30 22:40:35 +00009658 = FnDecl->getDeclName().getCXXLiteralIdentifier()->getName();
9659 if (LiteralName[0] != '_') {
Richard Smith2fb4ae32012-03-08 02:39:21 +00009660 // C++11 [usrlit.suffix]p1:
9661 // Literal suffix identifiers that do not start with an underscore
9662 // are reserved for future standardization.
9663 Diag(FnDecl->getLocation(), diag::warn_user_literal_reserved);
Douglas Gregor1155c422011-08-30 22:40:35 +00009664 }
Richard Smith2fb4ae32012-03-08 02:39:21 +00009665
Sean Hunta6c058d2010-01-13 09:01:02 +00009666 return false;
9667}
9668
Douglas Gregor074149e2009-01-05 19:45:36 +00009669/// ActOnStartLinkageSpecification - Parsed the beginning of a C++
9670/// linkage specification, including the language and (if present)
9671/// the '{'. ExternLoc is the location of the 'extern', LangLoc is
9672/// the location of the language string literal, which is provided
9673/// by Lang/StrSize. LBraceLoc, if valid, provides the location of
9674/// the '{' brace. Otherwise, this linkage specification does not
9675/// have any braces.
Chris Lattner7d642712010-11-09 20:15:55 +00009676Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
9677 SourceLocation LangLoc,
Chris Lattner5f9e2722011-07-23 10:55:15 +00009678 StringRef Lang,
Chris Lattner7d642712010-11-09 20:15:55 +00009679 SourceLocation LBraceLoc) {
Chris Lattnercc98eac2008-12-17 07:13:27 +00009680 LinkageSpecDecl::LanguageIDs Language;
Benjamin Kramerd5663812010-05-03 13:08:54 +00009681 if (Lang == "\"C\"")
Chris Lattnercc98eac2008-12-17 07:13:27 +00009682 Language = LinkageSpecDecl::lang_c;
Benjamin Kramerd5663812010-05-03 13:08:54 +00009683 else if (Lang == "\"C++\"")
Chris Lattnercc98eac2008-12-17 07:13:27 +00009684 Language = LinkageSpecDecl::lang_cxx;
9685 else {
Douglas Gregor074149e2009-01-05 19:45:36 +00009686 Diag(LangLoc, diag::err_bad_language);
John McCalld226f652010-08-21 09:40:31 +00009687 return 0;
Chris Lattnercc98eac2008-12-17 07:13:27 +00009688 }
Mike Stump1eb44332009-09-09 15:08:12 +00009689
Chris Lattnercc98eac2008-12-17 07:13:27 +00009690 // FIXME: Add all the various semantics of linkage specifications
Mike Stump1eb44332009-09-09 15:08:12 +00009691
Douglas Gregor074149e2009-01-05 19:45:36 +00009692 LinkageSpecDecl *D = LinkageSpecDecl::Create(Context, CurContext,
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009693 ExternLoc, LangLoc, Language);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009694 CurContext->addDecl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +00009695 PushDeclContext(S, D);
John McCalld226f652010-08-21 09:40:31 +00009696 return D;
Chris Lattnercc98eac2008-12-17 07:13:27 +00009697}
9698
Abramo Bagnara35f9a192010-07-30 16:47:02 +00009699/// ActOnFinishLinkageSpecification - Complete the definition of
Douglas Gregor074149e2009-01-05 19:45:36 +00009700/// the C++ linkage specification LinkageSpec. If RBraceLoc is
9701/// valid, it's the position of the closing '}' brace in a linkage
9702/// specification that uses braces.
John McCalld226f652010-08-21 09:40:31 +00009703Decl *Sema::ActOnFinishLinkageSpecification(Scope *S,
Abramo Bagnara5f6bcbe2011-03-03 14:52:38 +00009704 Decl *LinkageSpec,
9705 SourceLocation RBraceLoc) {
9706 if (LinkageSpec) {
9707 if (RBraceLoc.isValid()) {
9708 LinkageSpecDecl* LSDecl = cast<LinkageSpecDecl>(LinkageSpec);
9709 LSDecl->setRBraceLoc(RBraceLoc);
9710 }
Douglas Gregor074149e2009-01-05 19:45:36 +00009711 PopDeclContext();
Abramo Bagnara5f6bcbe2011-03-03 14:52:38 +00009712 }
Douglas Gregor074149e2009-01-05 19:45:36 +00009713 return LinkageSpec;
Chris Lattner5a003a42008-12-17 07:09:26 +00009714}
9715
Douglas Gregord308e622009-05-18 20:51:54 +00009716/// \brief Perform semantic analysis for the variable declaration that
9717/// occurs within a C++ catch clause, returning the newly-created
9718/// variable.
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009719VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
John McCalla93c9342009-12-07 02:54:59 +00009720 TypeSourceInfo *TInfo,
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009721 SourceLocation StartLoc,
9722 SourceLocation Loc,
9723 IdentifierInfo *Name) {
Douglas Gregord308e622009-05-18 20:51:54 +00009724 bool Invalid = false;
Douglas Gregor83cb9422010-09-09 17:09:21 +00009725 QualType ExDeclType = TInfo->getType();
9726
Sebastian Redl4b07b292008-12-22 19:15:10 +00009727 // Arrays and functions decay.
9728 if (ExDeclType->isArrayType())
9729 ExDeclType = Context.getArrayDecayedType(ExDeclType);
9730 else if (ExDeclType->isFunctionType())
9731 ExDeclType = Context.getPointerType(ExDeclType);
9732
9733 // C++ 15.3p1: The exception-declaration shall not denote an incomplete type.
9734 // The exception-declaration shall not denote a pointer or reference to an
9735 // incomplete type, other than [cv] void*.
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009736 // N2844 forbids rvalue references.
Mike Stump1eb44332009-09-09 15:08:12 +00009737 if (!ExDeclType->isDependentType() && ExDeclType->isRValueReferenceType()) {
Douglas Gregor83cb9422010-09-09 17:09:21 +00009738 Diag(Loc, diag::err_catch_rvalue_ref);
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009739 Invalid = true;
9740 }
Douglas Gregord308e622009-05-18 20:51:54 +00009741
Sebastian Redl4b07b292008-12-22 19:15:10 +00009742 QualType BaseType = ExDeclType;
9743 int Mode = 0; // 0 for direct type, 1 for pointer, 2 for reference
Douglas Gregor4ec339f2009-01-19 19:26:10 +00009744 unsigned DK = diag::err_catch_incomplete;
Ted Kremenek6217b802009-07-29 21:53:49 +00009745 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009746 BaseType = Ptr->getPointeeType();
9747 Mode = 1;
Douglas Gregorecd7b042012-01-24 19:01:26 +00009748 DK = diag::err_catch_incomplete_ptr;
Mike Stump1eb44332009-09-09 15:08:12 +00009749 } else if (const ReferenceType *Ref = BaseType->getAs<ReferenceType>()) {
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009750 // For the purpose of error recovery, we treat rvalue refs like lvalue refs.
Sebastian Redl4b07b292008-12-22 19:15:10 +00009751 BaseType = Ref->getPointeeType();
9752 Mode = 2;
Douglas Gregorecd7b042012-01-24 19:01:26 +00009753 DK = diag::err_catch_incomplete_ref;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009754 }
Sebastian Redlf2e21e52009-03-22 23:49:27 +00009755 if (!Invalid && (Mode == 0 || !BaseType->isVoidType()) &&
Douglas Gregorecd7b042012-01-24 19:01:26 +00009756 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
Sebastian Redl4b07b292008-12-22 19:15:10 +00009757 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009758
Mike Stump1eb44332009-09-09 15:08:12 +00009759 if (!Invalid && !ExDeclType->isDependentType() &&
Douglas Gregord308e622009-05-18 20:51:54 +00009760 RequireNonAbstractType(Loc, ExDeclType,
9761 diag::err_abstract_type_in_decl,
9762 AbstractVariableType))
Sebastian Redlfef9f592009-04-27 21:03:30 +00009763 Invalid = true;
9764
John McCall5a180392010-07-24 00:37:23 +00009765 // Only the non-fragile NeXT runtime currently supports C++ catches
9766 // of ObjC types, and no runtime supports catching ObjC types by value.
David Blaikie4e4d0842012-03-11 07:00:24 +00009767 if (!Invalid && getLangOpts().ObjC1) {
John McCall5a180392010-07-24 00:37:23 +00009768 QualType T = ExDeclType;
9769 if (const ReferenceType *RT = T->getAs<ReferenceType>())
9770 T = RT->getPointeeType();
9771
9772 if (T->isObjCObjectType()) {
9773 Diag(Loc, diag::err_objc_object_catch);
9774 Invalid = true;
9775 } else if (T->isObjCObjectPointerType()) {
John McCall260611a2012-06-20 06:18:46 +00009776 // FIXME: should this be a test for macosx-fragile specifically?
9777 if (getLangOpts().ObjCRuntime.isFragile())
Fariborz Jahaniancf5abc72011-06-23 19:00:08 +00009778 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
John McCall5a180392010-07-24 00:37:23 +00009779 }
9780 }
9781
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009782 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
9783 ExDeclType, TInfo, SC_None, SC_None);
Douglas Gregor324b54d2010-05-03 18:51:14 +00009784 ExDecl->setExceptionVariable(true);
9785
Douglas Gregor9aab9c42011-12-10 01:22:52 +00009786 // In ARC, infer 'retaining' for variables of retainable type.
David Blaikie4e4d0842012-03-11 07:00:24 +00009787 if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(ExDecl))
Douglas Gregor9aab9c42011-12-10 01:22:52 +00009788 Invalid = true;
9789
Douglas Gregorc41b8782011-07-06 18:14:43 +00009790 if (!Invalid && !ExDeclType->isDependentType()) {
John McCalle996ffd2011-02-16 08:02:54 +00009791 if (const RecordType *recordType = ExDeclType->getAs<RecordType>()) {
Douglas Gregor6d182892010-03-05 23:38:39 +00009792 // C++ [except.handle]p16:
9793 // The object declared in an exception-declaration or, if the
9794 // exception-declaration does not specify a name, a temporary (12.2) is
9795 // copy-initialized (8.5) from the exception object. [...]
9796 // The object is destroyed when the handler exits, after the destruction
9797 // of any automatic objects initialized within the handler.
9798 //
9799 // We just pretend to initialize the object with itself, then make sure
9800 // it can be destroyed later.
John McCalle996ffd2011-02-16 08:02:54 +00009801 QualType initType = ExDeclType;
9802
9803 InitializedEntity entity =
9804 InitializedEntity::InitializeVariable(ExDecl);
9805 InitializationKind initKind =
9806 InitializationKind::CreateCopy(Loc, SourceLocation());
9807
9808 Expr *opaqueValue =
9809 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
9810 InitializationSequence sequence(*this, entity, initKind, &opaqueValue, 1);
9811 ExprResult result = sequence.Perform(*this, entity, initKind,
9812 MultiExprArg(&opaqueValue, 1));
9813 if (result.isInvalid())
Douglas Gregor6d182892010-03-05 23:38:39 +00009814 Invalid = true;
John McCalle996ffd2011-02-16 08:02:54 +00009815 else {
9816 // If the constructor used was non-trivial, set this as the
9817 // "initializer".
9818 CXXConstructExpr *construct = cast<CXXConstructExpr>(result.take());
9819 if (!construct->getConstructor()->isTrivial()) {
9820 Expr *init = MaybeCreateExprWithCleanups(construct);
9821 ExDecl->setInit(init);
9822 }
9823
9824 // And make sure it's destructable.
9825 FinalizeVarWithDestructor(ExDecl, recordType);
9826 }
Douglas Gregor6d182892010-03-05 23:38:39 +00009827 }
9828 }
9829
Douglas Gregord308e622009-05-18 20:51:54 +00009830 if (Invalid)
9831 ExDecl->setInvalidDecl();
9832
9833 return ExDecl;
9834}
9835
9836/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch
9837/// handler.
John McCalld226f652010-08-21 09:40:31 +00009838Decl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {
John McCallbf1a0282010-06-04 23:28:52 +00009839 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
Douglas Gregora669c532010-12-16 17:48:04 +00009840 bool Invalid = D.isInvalidType();
9841
9842 // Check for unexpanded parameter packs.
9843 if (TInfo && DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
9844 UPPC_ExceptionType)) {
9845 TInfo = Context.getTrivialTypeSourceInfo(Context.IntTy,
9846 D.getIdentifierLoc());
9847 Invalid = true;
9848 }
9849
Sebastian Redl4b07b292008-12-22 19:15:10 +00009850 IdentifierInfo *II = D.getIdentifier();
Douglas Gregorc83c6872010-04-15 22:33:43 +00009851 if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(),
Douglas Gregorc0b39642010-04-15 23:40:53 +00009852 LookupOrdinaryName,
9853 ForRedeclaration)) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009854 // The scope should be freshly made just for us. There is just no way
9855 // it contains any previous declaration.
John McCalld226f652010-08-21 09:40:31 +00009856 assert(!S->isDeclScope(PrevDecl));
Sebastian Redl4b07b292008-12-22 19:15:10 +00009857 if (PrevDecl->isTemplateParameter()) {
9858 // Maybe we will complain about the shadowed template parameter.
9859 DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
Douglas Gregorcb8f9512011-10-20 17:58:49 +00009860 PrevDecl = 0;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009861 }
9862 }
9863
Chris Lattnereaaebc72009-04-25 08:06:05 +00009864 if (D.getCXXScopeSpec().isSet() && !Invalid) {
Sebastian Redl4b07b292008-12-22 19:15:10 +00009865 Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator)
9866 << D.getCXXScopeSpec().getRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +00009867 Invalid = true;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009868 }
9869
Douglas Gregor83cb9422010-09-09 17:09:21 +00009870 VarDecl *ExDecl = BuildExceptionDeclaration(S, TInfo,
Daniel Dunbar96a00142012-03-09 18:35:03 +00009871 D.getLocStart(),
Abramo Bagnaraff676cb2011-03-08 08:55:46 +00009872 D.getIdentifierLoc(),
9873 D.getIdentifier());
Chris Lattnereaaebc72009-04-25 08:06:05 +00009874 if (Invalid)
9875 ExDecl->setInvalidDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00009876
Sebastian Redl4b07b292008-12-22 19:15:10 +00009877 // Add the exception declaration into this scope.
Sebastian Redl4b07b292008-12-22 19:15:10 +00009878 if (II)
Douglas Gregord308e622009-05-18 20:51:54 +00009879 PushOnScopeChains(ExDecl, S);
9880 else
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009881 CurContext->addDecl(ExDecl);
Sebastian Redl4b07b292008-12-22 19:15:10 +00009882
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00009883 ProcessDeclAttributes(S, ExDecl, D);
John McCalld226f652010-08-21 09:40:31 +00009884 return ExDecl;
Sebastian Redl4b07b292008-12-22 19:15:10 +00009885}
Anders Carlssonfb311762009-03-14 00:25:26 +00009886
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009887Decl *Sema::ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
John McCall9ae2f072010-08-23 23:25:46 +00009888 Expr *AssertExpr,
Richard Smithe3f470a2012-07-11 22:37:56 +00009889 Expr *AssertMessageExpr,
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009890 SourceLocation RParenLoc) {
Richard Smithe3f470a2012-07-11 22:37:56 +00009891 StringLiteral *AssertMessage = cast<StringLiteral>(AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00009892
Richard Smithe3f470a2012-07-11 22:37:56 +00009893 if (DiagnoseUnexpandedParameterPack(AssertExpr, UPPC_StaticAssertExpression))
9894 return 0;
9895
9896 return BuildStaticAssertDeclaration(StaticAssertLoc, AssertExpr,
9897 AssertMessage, RParenLoc, false);
9898}
9899
9900Decl *Sema::BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
9901 Expr *AssertExpr,
9902 StringLiteral *AssertMessage,
9903 SourceLocation RParenLoc,
9904 bool Failed) {
9905 if (!AssertExpr->isTypeDependent() && !AssertExpr->isValueDependent() &&
9906 !Failed) {
Richard Smith282e7e62012-02-04 09:53:13 +00009907 // In a static_assert-declaration, the constant-expression shall be a
9908 // constant expression that can be contextually converted to bool.
9909 ExprResult Converted = PerformContextuallyConvertToBool(AssertExpr);
9910 if (Converted.isInvalid())
Richard Smithe3f470a2012-07-11 22:37:56 +00009911 Failed = true;
Richard Smith282e7e62012-02-04 09:53:13 +00009912
Richard Smithdaaefc52011-12-14 23:32:26 +00009913 llvm::APSInt Cond;
Richard Smithe3f470a2012-07-11 22:37:56 +00009914 if (!Failed && VerifyIntegerConstantExpression(Converted.get(), &Cond,
Douglas Gregorab41fe92012-05-04 22:38:52 +00009915 diag::err_static_assert_expression_is_not_constant,
Richard Smith282e7e62012-02-04 09:53:13 +00009916 /*AllowFold=*/false).isInvalid())
Richard Smithe3f470a2012-07-11 22:37:56 +00009917 Failed = true;
Anders Carlssonfb311762009-03-14 00:25:26 +00009918
Richard Smithe3f470a2012-07-11 22:37:56 +00009919 if (!Failed && !Cond) {
Richard Smith0cc323c2012-03-05 23:20:05 +00009920 llvm::SmallString<256> MsgBuffer;
9921 llvm::raw_svector_ostream Msg(MsgBuffer);
Richard Smithd1420c62012-08-16 03:56:14 +00009922 AssertMessage->printPretty(Msg, 0, getPrintingPolicy());
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009923 Diag(StaticAssertLoc, diag::err_static_assert_failed)
Richard Smith0cc323c2012-03-05 23:20:05 +00009924 << Msg.str() << AssertExpr->getSourceRange();
Richard Smithe3f470a2012-07-11 22:37:56 +00009925 Failed = true;
Richard Smith0cc323c2012-03-05 23:20:05 +00009926 }
Anders Carlssonc3082412009-03-14 00:33:21 +00009927 }
Mike Stump1eb44332009-09-09 15:08:12 +00009928
Abramo Bagnaraa2026c92011-03-08 16:41:52 +00009929 Decl *Decl = StaticAssertDecl::Create(Context, CurContext, StaticAssertLoc,
Richard Smithe3f470a2012-07-11 22:37:56 +00009930 AssertExpr, AssertMessage, RParenLoc,
9931 Failed);
Mike Stump1eb44332009-09-09 15:08:12 +00009932
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00009933 CurContext->addDecl(Decl);
John McCalld226f652010-08-21 09:40:31 +00009934 return Decl;
Anders Carlssonfb311762009-03-14 00:25:26 +00009935}
Sebastian Redl50de12f2009-03-24 22:27:57 +00009936
Douglas Gregor1d869352010-04-07 16:53:43 +00009937/// \brief Perform semantic analysis of the given friend type declaration.
9938///
9939/// \returns A friend declaration that.
Richard Smithd6f80da2012-09-20 01:31:00 +00009940FriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart,
Abramo Bagnara0216df82011-10-29 20:52:52 +00009941 SourceLocation FriendLoc,
Douglas Gregor1d869352010-04-07 16:53:43 +00009942 TypeSourceInfo *TSInfo) {
9943 assert(TSInfo && "NULL TypeSourceInfo for friend type declaration");
9944
9945 QualType T = TSInfo->getType();
Abramo Bagnarabd054db2010-05-20 10:00:11 +00009946 SourceRange TypeRange = TSInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor1d869352010-04-07 16:53:43 +00009947
Richard Smith6b130222011-10-18 21:39:00 +00009948 // C++03 [class.friend]p2:
9949 // An elaborated-type-specifier shall be used in a friend declaration
9950 // for a class.*
9951 //
9952 // * The class-key of the elaborated-type-specifier is required.
9953 if (!ActiveTemplateInstantiations.empty()) {
9954 // Do not complain about the form of friend template types during
9955 // template instantiation; we will already have complained when the
9956 // template was declared.
9957 } else if (!T->isElaboratedTypeSpecifier()) {
9958 // If we evaluated the type to a record type, suggest putting
9959 // a tag in front.
9960 if (const RecordType *RT = T->getAs<RecordType>()) {
9961 RecordDecl *RD = RT->getDecl();
9962
9963 std::string InsertionText = std::string(" ") + RD->getKindName();
9964
9965 Diag(TypeRange.getBegin(),
David Blaikie4e4d0842012-03-11 07:00:24 +00009966 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009967 diag::warn_cxx98_compat_unelaborated_friend_type :
9968 diag::ext_unelaborated_friend_type)
9969 << (unsigned) RD->getTagKind()
9970 << T
9971 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(FriendLoc),
9972 InsertionText);
9973 } else {
9974 Diag(FriendLoc,
David Blaikie4e4d0842012-03-11 07:00:24 +00009975 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009976 diag::warn_cxx98_compat_nonclass_type_friend :
9977 diag::ext_nonclass_type_friend)
Douglas Gregor1d869352010-04-07 16:53:43 +00009978 << T
Richard Smithd6f80da2012-09-20 01:31:00 +00009979 << TypeRange;
Douglas Gregor1d869352010-04-07 16:53:43 +00009980 }
Richard Smith6b130222011-10-18 21:39:00 +00009981 } else if (T->getAs<EnumType>()) {
9982 Diag(FriendLoc,
David Blaikie4e4d0842012-03-11 07:00:24 +00009983 getLangOpts().CPlusPlus0x ?
Richard Smith6b130222011-10-18 21:39:00 +00009984 diag::warn_cxx98_compat_enum_friend :
9985 diag::ext_enum_friend)
9986 << T
Richard Smithd6f80da2012-09-20 01:31:00 +00009987 << TypeRange;
Douglas Gregor1d869352010-04-07 16:53:43 +00009988 }
9989
Richard Smithd6f80da2012-09-20 01:31:00 +00009990 // C++11 [class.friend]p3:
9991 // A friend declaration that does not declare a function shall have one
9992 // of the following forms:
9993 // friend elaborated-type-specifier ;
9994 // friend simple-type-specifier ;
9995 // friend typename-specifier ;
9996 if (getLangOpts().CPlusPlus0x && LocStart != FriendLoc)
9997 Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;
9998
Douglas Gregor06245bf2010-04-07 17:57:12 +00009999 // If the type specifier in a friend declaration designates a (possibly
Richard Smithd6f80da2012-09-20 01:31:00 +000010000 // cv-qualified) class type, that class is declared as a friend; otherwise,
Douglas Gregor06245bf2010-04-07 17:57:12 +000010001 // the friend declaration is ignored.
Richard Smithd6f80da2012-09-20 01:31:00 +000010002 return FriendDecl::Create(Context, CurContext, LocStart, TSInfo, FriendLoc);
Douglas Gregor1d869352010-04-07 16:53:43 +000010003}
10004
John McCall9a34edb2010-10-19 01:40:49 +000010005/// Handle a friend tag declaration where the scope specifier was
10006/// templated.
10007Decl *Sema::ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
10008 unsigned TagSpec, SourceLocation TagLoc,
10009 CXXScopeSpec &SS,
10010 IdentifierInfo *Name, SourceLocation NameLoc,
10011 AttributeList *Attr,
10012 MultiTemplateParamsArg TempParamLists) {
10013 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
10014
10015 bool isExplicitSpecialization = false;
John McCall9a34edb2010-10-19 01:40:49 +000010016 bool Invalid = false;
10017
10018 if (TemplateParameterList *TemplateParams
Douglas Gregorc8406492011-05-10 18:27:06 +000010019 = MatchTemplateParametersToScopeSpecifier(TagLoc, NameLoc, SS,
Benjamin Kramer5354e772012-08-23 23:38:35 +000010020 TempParamLists.data(),
John McCall9a34edb2010-10-19 01:40:49 +000010021 TempParamLists.size(),
10022 /*friend*/ true,
10023 isExplicitSpecialization,
10024 Invalid)) {
John McCall9a34edb2010-10-19 01:40:49 +000010025 if (TemplateParams->size() > 0) {
10026 // This is a declaration of a class template.
10027 if (Invalid)
10028 return 0;
Abramo Bagnarac57c17d2011-03-10 13:28:31 +000010029
Eric Christopher4110e132011-07-21 05:34:24 +000010030 return CheckClassTemplate(S, TagSpec, TUK_Friend, TagLoc,
10031 SS, Name, NameLoc, Attr,
10032 TemplateParams, AS_public,
Douglas Gregore7612302011-09-09 19:05:14 +000010033 /*ModulePrivateLoc=*/SourceLocation(),
Eric Christopher4110e132011-07-21 05:34:24 +000010034 TempParamLists.size() - 1,
Benjamin Kramer5354e772012-08-23 23:38:35 +000010035 TempParamLists.data()).take();
John McCall9a34edb2010-10-19 01:40:49 +000010036 } else {
10037 // The "template<>" header is extraneous.
10038 Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
10039 << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
10040 isExplicitSpecialization = true;
10041 }
10042 }
10043
10044 if (Invalid) return 0;
10045
John McCall9a34edb2010-10-19 01:40:49 +000010046 bool isAllExplicitSpecializations = true;
Abramo Bagnara7f0a9152011-03-18 15:16:37 +000010047 for (unsigned I = TempParamLists.size(); I-- > 0; ) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +000010048 if (TempParamLists[I]->size()) {
John McCall9a34edb2010-10-19 01:40:49 +000010049 isAllExplicitSpecializations = false;
10050 break;
10051 }
10052 }
10053
10054 // FIXME: don't ignore attributes.
10055
10056 // If it's explicit specializations all the way down, just forget
10057 // about the template header and build an appropriate non-templated
10058 // friend. TODO: for source fidelity, remember the headers.
10059 if (isAllExplicitSpecializations) {
Douglas Gregorba4ee9a2011-10-20 15:58:54 +000010060 if (SS.isEmpty()) {
10061 bool Owned = false;
10062 bool IsDependent = false;
10063 return ActOnTag(S, TagSpec, TUK_Friend, TagLoc, SS, Name, NameLoc,
10064 Attr, AS_public,
10065 /*ModulePrivateLoc=*/SourceLocation(),
10066 MultiTemplateParamsArg(), Owned, IsDependent,
Richard Smithbdad7a22012-01-10 01:33:14 +000010067 /*ScopedEnumKWLoc=*/SourceLocation(),
Douglas Gregorba4ee9a2011-10-20 15:58:54 +000010068 /*ScopedEnumUsesClassTag=*/false,
10069 /*UnderlyingType=*/TypeResult());
10070 }
10071
Douglas Gregor2494dd02011-03-01 01:34:45 +000010072 NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
John McCall9a34edb2010-10-19 01:40:49 +000010073 ElaboratedTypeKeyword Keyword
10074 = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
Douglas Gregor2494dd02011-03-01 01:34:45 +000010075 QualType T = CheckTypenameType(Keyword, TagLoc, QualifierLoc,
Douglas Gregore29425b2011-02-28 22:42:13 +000010076 *Name, NameLoc);
John McCall9a34edb2010-10-19 01:40:49 +000010077 if (T.isNull())
10078 return 0;
10079
10080 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
10081 if (isa<DependentNameType>(T)) {
10082 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010083 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor2494dd02011-03-01 01:34:45 +000010084 TL.setQualifierLoc(QualifierLoc);
John McCall9a34edb2010-10-19 01:40:49 +000010085 TL.setNameLoc(NameLoc);
10086 } else {
10087 ElaboratedTypeLoc TL = cast<ElaboratedTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010088 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor9e876872011-03-01 18:12:44 +000010089 TL.setQualifierLoc(QualifierLoc);
John McCall9a34edb2010-10-19 01:40:49 +000010090 cast<TypeSpecTypeLoc>(TL.getNamedTypeLoc()).setNameLoc(NameLoc);
10091 }
10092
10093 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
10094 TSI, FriendLoc);
10095 Friend->setAccess(AS_public);
10096 CurContext->addDecl(Friend);
10097 return Friend;
10098 }
Douglas Gregorba4ee9a2011-10-20 15:58:54 +000010099
10100 assert(SS.isNotEmpty() && "valid templated tag with no SS and no direct?");
10101
10102
John McCall9a34edb2010-10-19 01:40:49 +000010103
10104 // Handle the case of a templated-scope friend class. e.g.
10105 // template <class T> class A<T>::B;
10106 // FIXME: we don't support these right now.
10107 ElaboratedTypeKeyword ETK = TypeWithKeyword::getKeywordForTagTypeKind(Kind);
10108 QualType T = Context.getDependentNameType(ETK, SS.getScopeRep(), Name);
10109 TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
10110 DependentNameTypeLoc TL = cast<DependentNameTypeLoc>(TSI->getTypeLoc());
Abramo Bagnara38a42912012-02-06 19:09:27 +000010111 TL.setElaboratedKeywordLoc(TagLoc);
Douglas Gregor2494dd02011-03-01 01:34:45 +000010112 TL.setQualifierLoc(SS.getWithLocInContext(Context));
John McCall9a34edb2010-10-19 01:40:49 +000010113 TL.setNameLoc(NameLoc);
10114
10115 FriendDecl *Friend = FriendDecl::Create(Context, CurContext, NameLoc,
10116 TSI, FriendLoc);
10117 Friend->setAccess(AS_public);
10118 Friend->setUnsupportedFriend(true);
10119 CurContext->addDecl(Friend);
10120 return Friend;
10121}
10122
10123
John McCalldd4a3b02009-09-16 22:47:08 +000010124/// Handle a friend type declaration. This works in tandem with
10125/// ActOnTag.
10126///
10127/// Notes on friend class templates:
10128///
10129/// We generally treat friend class declarations as if they were
10130/// declaring a class. So, for example, the elaborated type specifier
10131/// in a friend declaration is required to obey the restrictions of a
10132/// class-head (i.e. no typedefs in the scope chain), template
10133/// parameters are required to match up with simple template-ids, &c.
10134/// However, unlike when declaring a template specialization, it's
10135/// okay to refer to a template specialization without an empty
10136/// template parameter declaration, e.g.
10137/// friend class A<T>::B<unsigned>;
10138/// We permit this as a special case; if there are any template
10139/// parameters present at all, require proper matching, i.e.
James Dennettef2b5b32012-06-15 22:23:43 +000010140/// template <> template \<class T> friend class A<int>::B;
John McCalld226f652010-08-21 09:40:31 +000010141Decl *Sema::ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
John McCallbe04b6d2010-10-16 07:23:36 +000010142 MultiTemplateParamsArg TempParams) {
Daniel Dunbar96a00142012-03-09 18:35:03 +000010143 SourceLocation Loc = DS.getLocStart();
John McCall67d1a672009-08-06 02:15:43 +000010144
10145 assert(DS.isFriendSpecified());
10146 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
10147
John McCalldd4a3b02009-09-16 22:47:08 +000010148 // Try to convert the decl specifier to a type. This works for
10149 // friend templates because ActOnTag never produces a ClassTemplateDecl
10150 // for a TUK_Friend.
Chris Lattnerc7f19042009-10-25 17:47:27 +000010151 Declarator TheDeclarator(DS, Declarator::MemberContext);
John McCallbf1a0282010-06-04 23:28:52 +000010152 TypeSourceInfo *TSI = GetTypeForDeclarator(TheDeclarator, S);
10153 QualType T = TSI->getType();
Chris Lattnerc7f19042009-10-25 17:47:27 +000010154 if (TheDeclarator.isInvalidType())
John McCalld226f652010-08-21 09:40:31 +000010155 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010156
Douglas Gregor6ccab972010-12-16 01:14:37 +000010157 if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
10158 return 0;
10159
John McCalldd4a3b02009-09-16 22:47:08 +000010160 // This is definitely an error in C++98. It's probably meant to
10161 // be forbidden in C++0x, too, but the specification is just
10162 // poorly written.
10163 //
10164 // The problem is with declarations like the following:
10165 // template <T> friend A<T>::foo;
10166 // where deciding whether a class C is a friend or not now hinges
10167 // on whether there exists an instantiation of A that causes
10168 // 'foo' to equal C. There are restrictions on class-heads
10169 // (which we declare (by fiat) elaborated friend declarations to
10170 // be) that makes this tractable.
10171 //
10172 // FIXME: handle "template <> friend class A<T>;", which
10173 // is possibly well-formed? Who even knows?
Douglas Gregor40336422010-03-31 22:19:08 +000010174 if (TempParams.size() && !T->isElaboratedTypeSpecifier()) {
John McCalldd4a3b02009-09-16 22:47:08 +000010175 Diag(Loc, diag::err_tagless_friend_type_template)
10176 << DS.getSourceRange();
John McCalld226f652010-08-21 09:40:31 +000010177 return 0;
John McCalldd4a3b02009-09-16 22:47:08 +000010178 }
Douglas Gregor1d869352010-04-07 16:53:43 +000010179
John McCall02cace72009-08-28 07:59:38 +000010180 // C++98 [class.friend]p1: A friend of a class is a function
10181 // or class that is not a member of the class . . .
John McCalla236a552009-12-22 00:59:39 +000010182 // This is fixed in DR77, which just barely didn't make the C++03
10183 // deadline. It's also a very silly restriction that seriously
10184 // affects inner classes and which nobody else seems to implement;
10185 // thus we never diagnose it, not even in -pedantic.
John McCall32f2fb52010-03-25 18:04:51 +000010186 //
10187 // But note that we could warn about it: it's always useless to
10188 // friend one of your own members (it's not, however, worthless to
10189 // friend a member of an arbitrary specialization of your template).
John McCall02cace72009-08-28 07:59:38 +000010190
John McCalldd4a3b02009-09-16 22:47:08 +000010191 Decl *D;
Douglas Gregor1d869352010-04-07 16:53:43 +000010192 if (unsigned NumTempParamLists = TempParams.size())
John McCalldd4a3b02009-09-16 22:47:08 +000010193 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
Douglas Gregor1d869352010-04-07 16:53:43 +000010194 NumTempParamLists,
Benjamin Kramer5354e772012-08-23 23:38:35 +000010195 TempParams.data(),
John McCall32f2fb52010-03-25 18:04:51 +000010196 TSI,
John McCalldd4a3b02009-09-16 22:47:08 +000010197 DS.getFriendSpecLoc());
10198 else
Abramo Bagnara0216df82011-10-29 20:52:52 +000010199 D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
Douglas Gregor1d869352010-04-07 16:53:43 +000010200
10201 if (!D)
John McCalld226f652010-08-21 09:40:31 +000010202 return 0;
Douglas Gregor1d869352010-04-07 16:53:43 +000010203
John McCalldd4a3b02009-09-16 22:47:08 +000010204 D->setAccess(AS_public);
10205 CurContext->addDecl(D);
John McCall02cace72009-08-28 07:59:38 +000010206
John McCalld226f652010-08-21 09:40:31 +000010207 return D;
John McCall02cace72009-08-28 07:59:38 +000010208}
10209
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010210Decl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D,
John McCall337ec3d2010-10-12 23:13:28 +000010211 MultiTemplateParamsArg TemplateParams) {
John McCall02cace72009-08-28 07:59:38 +000010212 const DeclSpec &DS = D.getDeclSpec();
10213
10214 assert(DS.isFriendSpecified());
10215 assert(DS.getStorageClassSpec() == DeclSpec::SCS_unspecified);
10216
10217 SourceLocation Loc = D.getIdentifierLoc();
John McCallbf1a0282010-06-04 23:28:52 +000010218 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
John McCall67d1a672009-08-06 02:15:43 +000010219
10220 // C++ [class.friend]p1
10221 // A friend of a class is a function or class....
10222 // Note that this sees through typedefs, which is intended.
John McCall02cace72009-08-28 07:59:38 +000010223 // It *doesn't* see through dependent types, which is correct
10224 // according to [temp.arg.type]p3:
10225 // If a declaration acquires a function type through a
10226 // type dependent on a template-parameter and this causes
10227 // a declaration that does not use the syntactic form of a
10228 // function declarator to have a function type, the program
10229 // is ill-formed.
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010230 if (!TInfo->getType()->isFunctionType()) {
John McCall67d1a672009-08-06 02:15:43 +000010231 Diag(Loc, diag::err_unexpected_friend);
10232
10233 // It might be worthwhile to try to recover by creating an
10234 // appropriate declaration.
John McCalld226f652010-08-21 09:40:31 +000010235 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010236 }
10237
10238 // C++ [namespace.memdef]p3
10239 // - If a friend declaration in a non-local class first declares a
10240 // class or function, the friend class or function is a member
10241 // of the innermost enclosing namespace.
10242 // - The name of the friend is not found by simple name lookup
10243 // until a matching declaration is provided in that namespace
10244 // scope (either before or after the class declaration granting
10245 // friendship).
10246 // - If a friend function is called, its name may be found by the
10247 // name lookup that considers functions from namespaces and
10248 // classes associated with the types of the function arguments.
10249 // - When looking for a prior declaration of a class or a function
10250 // declared as a friend, scopes outside the innermost enclosing
10251 // namespace scope are not considered.
10252
John McCall337ec3d2010-10-12 23:13:28 +000010253 CXXScopeSpec &SS = D.getCXXScopeSpec();
Abramo Bagnara25777432010-08-11 22:01:17 +000010254 DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
10255 DeclarationName Name = NameInfo.getName();
John McCall67d1a672009-08-06 02:15:43 +000010256 assert(Name);
10257
Douglas Gregor6ccab972010-12-16 01:14:37 +000010258 // Check for unexpanded parameter packs.
10259 if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
10260 DiagnoseUnexpandedParameterPack(NameInfo, UPPC_FriendDeclaration) ||
10261 DiagnoseUnexpandedParameterPack(SS, UPPC_FriendDeclaration))
10262 return 0;
10263
John McCall67d1a672009-08-06 02:15:43 +000010264 // The context we found the declaration in, or in which we should
10265 // create the declaration.
10266 DeclContext *DC;
John McCall380aaa42010-10-13 06:22:15 +000010267 Scope *DCScope = S;
Abramo Bagnara25777432010-08-11 22:01:17 +000010268 LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
John McCall68263142009-11-18 22:49:29 +000010269 ForRedeclaration);
John McCall67d1a672009-08-06 02:15:43 +000010270
John McCall337ec3d2010-10-12 23:13:28 +000010271 // FIXME: there are different rules in local classes
John McCall67d1a672009-08-06 02:15:43 +000010272
John McCall337ec3d2010-10-12 23:13:28 +000010273 // There are four cases here.
10274 // - There's no scope specifier, in which case we just go to the
John McCall29ae6e52010-10-13 05:45:15 +000010275 // appropriate scope and look for a function or function template
John McCall337ec3d2010-10-12 23:13:28 +000010276 // there as appropriate.
10277 // Recover from invalid scope qualifiers as if they just weren't there.
10278 if (SS.isInvalid() || !SS.isSet()) {
John McCall29ae6e52010-10-13 05:45:15 +000010279 // C++0x [namespace.memdef]p3:
10280 // If the name in a friend declaration is neither qualified nor
10281 // a template-id and the declaration is a function or an
10282 // elaborated-type-specifier, the lookup to determine whether
10283 // the entity has been previously declared shall not consider
10284 // any scopes outside the innermost enclosing namespace.
10285 // C++0x [class.friend]p11:
10286 // If a friend declaration appears in a local class and the name
10287 // specified is an unqualified name, a prior declaration is
10288 // looked up without considering scopes that are outside the
10289 // innermost enclosing non-class scope. For a friend function
10290 // declaration, if there is no prior declaration, the program is
10291 // ill-formed.
10292 bool isLocal = cast<CXXRecordDecl>(CurContext)->isLocalClass();
John McCall8a407372010-10-14 22:22:28 +000010293 bool isTemplateId = D.getName().getKind() == UnqualifiedId::IK_TemplateId;
John McCall67d1a672009-08-06 02:15:43 +000010294
John McCall29ae6e52010-10-13 05:45:15 +000010295 // Find the appropriate context according to the above.
John McCall67d1a672009-08-06 02:15:43 +000010296 DC = CurContext;
10297 while (true) {
10298 // Skip class contexts. If someone can cite chapter and verse
10299 // for this behavior, that would be nice --- it's what GCC and
10300 // EDG do, and it seems like a reasonable intent, but the spec
10301 // really only says that checks for unqualified existing
10302 // declarations should stop at the nearest enclosing namespace,
10303 // not that they should only consider the nearest enclosing
10304 // namespace.
Nick Lewycky9c6fde52012-03-16 19:51:19 +000010305 while (DC->isRecord() || DC->isTransparentContext())
Douglas Gregor182ddf02009-09-28 00:08:27 +000010306 DC = DC->getParent();
John McCall67d1a672009-08-06 02:15:43 +000010307
John McCall68263142009-11-18 22:49:29 +000010308 LookupQualifiedName(Previous, DC);
John McCall67d1a672009-08-06 02:15:43 +000010309
10310 // TODO: decide what we think about using declarations.
John McCall29ae6e52010-10-13 05:45:15 +000010311 if (isLocal || !Previous.empty())
John McCall67d1a672009-08-06 02:15:43 +000010312 break;
John McCall29ae6e52010-10-13 05:45:15 +000010313
John McCall8a407372010-10-14 22:22:28 +000010314 if (isTemplateId) {
10315 if (isa<TranslationUnitDecl>(DC)) break;
10316 } else {
10317 if (DC->isFileContext()) break;
10318 }
John McCall67d1a672009-08-06 02:15:43 +000010319 DC = DC->getParent();
10320 }
10321
10322 // C++ [class.friend]p1: A friend of a class is a function or
10323 // class that is not a member of the class . . .
Richard Smithebaf0e62011-10-18 20:49:44 +000010324 // C++11 changes this for both friend types and functions.
John McCall7f27d922009-08-06 20:49:32 +000010325 // Most C++ 98 compilers do seem to give an error here, so
10326 // we do, too.
Richard Smithebaf0e62011-10-18 20:49:44 +000010327 if (!Previous.empty() && DC->Equals(CurContext))
10328 Diag(DS.getFriendSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +000010329 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +000010330 diag::warn_cxx98_compat_friend_is_member :
10331 diag::err_friend_is_member);
John McCall337ec3d2010-10-12 23:13:28 +000010332
John McCall380aaa42010-10-13 06:22:15 +000010333 DCScope = getScopeForDeclContext(S, DC);
Douglas Gregorfb35e8f2011-11-03 16:37:14 +000010334
Douglas Gregor883af832011-10-10 01:11:59 +000010335 // C++ [class.friend]p6:
10336 // A function can be defined in a friend declaration of a class if and
10337 // only if the class is a non-local class (9.8), the function name is
10338 // unqualified, and the function has namespace scope.
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010339 if (isLocal && D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010340 Diag(NameInfo.getBeginLoc(), diag::err_friend_def_in_local_class);
10341 }
10342
John McCall337ec3d2010-10-12 23:13:28 +000010343 // - There's a non-dependent scope specifier, in which case we
10344 // compute it and do a previous lookup there for a function
10345 // or function template.
10346 } else if (!SS.getScopeRep()->isDependent()) {
10347 DC = computeDeclContext(SS);
10348 if (!DC) return 0;
10349
10350 if (RequireCompleteDeclContext(SS, DC)) return 0;
10351
10352 LookupQualifiedName(Previous, DC);
10353
10354 // Ignore things found implicitly in the wrong scope.
10355 // TODO: better diagnostics for this case. Suggesting the right
10356 // qualified scope would be nice...
10357 LookupResult::Filter F = Previous.makeFilter();
10358 while (F.hasNext()) {
10359 NamedDecl *D = F.next();
10360 if (!DC->InEnclosingNamespaceSetOf(
10361 D->getDeclContext()->getRedeclContext()))
10362 F.erase();
10363 }
10364 F.done();
10365
10366 if (Previous.empty()) {
10367 D.setInvalidType();
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010368 Diag(Loc, diag::err_qualified_friend_not_found)
10369 << Name << TInfo->getType();
John McCall337ec3d2010-10-12 23:13:28 +000010370 return 0;
10371 }
10372
10373 // C++ [class.friend]p1: A friend of a class is a function or
10374 // class that is not a member of the class . . .
Richard Smithebaf0e62011-10-18 20:49:44 +000010375 if (DC->Equals(CurContext))
10376 Diag(DS.getFriendSpecLoc(),
David Blaikie4e4d0842012-03-11 07:00:24 +000010377 getLangOpts().CPlusPlus0x ?
Richard Smithebaf0e62011-10-18 20:49:44 +000010378 diag::warn_cxx98_compat_friend_is_member :
10379 diag::err_friend_is_member);
Douglas Gregor883af832011-10-10 01:11:59 +000010380
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010381 if (D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010382 // C++ [class.friend]p6:
10383 // A function can be defined in a friend declaration of a class if and
10384 // only if the class is a non-local class (9.8), the function name is
10385 // unqualified, and the function has namespace scope.
10386 SemaDiagnosticBuilder DB
10387 = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);
10388
10389 DB << SS.getScopeRep();
10390 if (DC->isFileContext())
10391 DB << FixItHint::CreateRemoval(SS.getRange());
10392 SS.clear();
10393 }
John McCall337ec3d2010-10-12 23:13:28 +000010394
10395 // - There's a scope specifier that does not match any template
10396 // parameter lists, in which case we use some arbitrary context,
10397 // create a method or method template, and wait for instantiation.
10398 // - There's a scope specifier that does match some template
10399 // parameter lists, which we don't handle right now.
10400 } else {
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010401 if (D.isFunctionDefinition()) {
Douglas Gregor883af832011-10-10 01:11:59 +000010402 // C++ [class.friend]p6:
10403 // A function can be defined in a friend declaration of a class if and
10404 // only if the class is a non-local class (9.8), the function name is
10405 // unqualified, and the function has namespace scope.
10406 Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def)
10407 << SS.getScopeRep();
10408 }
10409
John McCall337ec3d2010-10-12 23:13:28 +000010410 DC = CurContext;
10411 assert(isa<CXXRecordDecl>(DC) && "friend declaration not in class?");
John McCall67d1a672009-08-06 02:15:43 +000010412 }
Douglas Gregor883af832011-10-10 01:11:59 +000010413
John McCall29ae6e52010-10-13 05:45:15 +000010414 if (!DC->isRecord()) {
John McCall67d1a672009-08-06 02:15:43 +000010415 // This implies that it has to be an operator or function.
Douglas Gregor3f9a0562009-11-03 01:35:08 +000010416 if (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ||
10417 D.getName().getKind() == UnqualifiedId::IK_DestructorName ||
10418 D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) {
John McCall67d1a672009-08-06 02:15:43 +000010419 Diag(Loc, diag::err_introducing_special_friend) <<
Douglas Gregor3f9a0562009-11-03 01:35:08 +000010420 (D.getName().getKind() == UnqualifiedId::IK_ConstructorName ? 0 :
10421 D.getName().getKind() == UnqualifiedId::IK_DestructorName ? 1 : 2);
John McCalld226f652010-08-21 09:40:31 +000010422 return 0;
John McCall67d1a672009-08-06 02:15:43 +000010423 }
John McCall67d1a672009-08-06 02:15:43 +000010424 }
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010425
Douglas Gregorfb35e8f2011-11-03 16:37:14 +000010426 // FIXME: This is an egregious hack to cope with cases where the scope stack
10427 // does not contain the declaration context, i.e., in an out-of-line
10428 // definition of a class.
10429 Scope FakeDCScope(S, Scope::DeclScope, Diags);
10430 if (!DCScope) {
10431 FakeDCScope.setEntity(DC);
10432 DCScope = &FakeDCScope;
10433 }
10434
Francois Pichetaf0f4d02011-08-14 03:52:19 +000010435 bool AddToScope = true;
Kaelyn Uhrain2c712f52011-10-11 00:28:45 +000010436 NamedDecl *ND = ActOnFunctionDeclarator(DCScope, D, DC, TInfo, Previous,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +000010437 TemplateParams, AddToScope);
John McCalld226f652010-08-21 09:40:31 +000010438 if (!ND) return 0;
John McCallab88d972009-08-31 22:39:49 +000010439
Douglas Gregor182ddf02009-09-28 00:08:27 +000010440 assert(ND->getDeclContext() == DC);
10441 assert(ND->getLexicalDeclContext() == CurContext);
John McCall88232aa2009-08-18 00:00:49 +000010442
John McCallab88d972009-08-31 22:39:49 +000010443 // Add the function declaration to the appropriate lookup tables,
10444 // adjusting the redeclarations list as necessary. We don't
10445 // want to do this yet if the friending class is dependent.
Mike Stump1eb44332009-09-09 15:08:12 +000010446 //
John McCallab88d972009-08-31 22:39:49 +000010447 // Also update the scope-based lookup if the target context's
10448 // lookup context is in lexical scope.
10449 if (!CurContext->isDependentContext()) {
Sebastian Redl7a126a42010-08-31 00:36:30 +000010450 DC = DC->getRedeclContext();
Richard Smith1b7f9cb2012-03-13 03:12:56 +000010451 DC->makeDeclVisibleInContext(ND);
John McCallab88d972009-08-31 22:39:49 +000010452 if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
Douglas Gregor182ddf02009-09-28 00:08:27 +000010453 PushOnScopeChains(ND, EnclosingScope, /*AddToContext=*/ false);
John McCallab88d972009-08-31 22:39:49 +000010454 }
John McCall02cace72009-08-28 07:59:38 +000010455
10456 FriendDecl *FrD = FriendDecl::Create(Context, CurContext,
Douglas Gregor182ddf02009-09-28 00:08:27 +000010457 D.getIdentifierLoc(), ND,
John McCall02cace72009-08-28 07:59:38 +000010458 DS.getFriendSpecLoc());
John McCall5fee1102009-08-29 03:50:18 +000010459 FrD->setAccess(AS_public);
John McCall02cace72009-08-28 07:59:38 +000010460 CurContext->addDecl(FrD);
John McCall67d1a672009-08-06 02:15:43 +000010461
John McCall1f2e1a92012-08-10 03:15:35 +000010462 if (ND->isInvalidDecl()) {
John McCall337ec3d2010-10-12 23:13:28 +000010463 FrD->setInvalidDecl();
John McCall1f2e1a92012-08-10 03:15:35 +000010464 } else {
10465 if (DC->isRecord()) CheckFriendAccess(ND);
10466
John McCall6102ca12010-10-16 06:59:13 +000010467 FunctionDecl *FD;
10468 if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(ND))
10469 FD = FTD->getTemplatedDecl();
10470 else
10471 FD = cast<FunctionDecl>(ND);
10472
10473 // Mark templated-scope function declarations as unsupported.
10474 if (FD->getNumTemplateParameterLists())
10475 FrD->setUnsupportedFriend(true);
10476 }
John McCall337ec3d2010-10-12 23:13:28 +000010477
John McCalld226f652010-08-21 09:40:31 +000010478 return ND;
Anders Carlsson00338362009-05-11 22:55:49 +000010479}
10480
John McCalld226f652010-08-21 09:40:31 +000010481void Sema::SetDeclDeleted(Decl *Dcl, SourceLocation DelLoc) {
10482 AdjustDeclIfTemplate(Dcl);
Mike Stump1eb44332009-09-09 15:08:12 +000010483
Sebastian Redl50de12f2009-03-24 22:27:57 +000010484 FunctionDecl *Fn = dyn_cast<FunctionDecl>(Dcl);
10485 if (!Fn) {
10486 Diag(DelLoc, diag::err_deleted_non_function);
10487 return;
10488 }
Douglas Gregoref96ee02012-01-14 16:38:05 +000010489 if (const FunctionDecl *Prev = Fn->getPreviousDecl()) {
David Blaikied9cf8262012-06-25 21:55:30 +000010490 // Don't consider the implicit declaration we generate for explicit
10491 // specializations. FIXME: Do not generate these implicit declarations.
David Blaikie619ee6a2012-06-29 18:00:25 +000010492 if ((Prev->getTemplateSpecializationKind() != TSK_ExplicitSpecialization
10493 || Prev->getPreviousDecl()) && !Prev->isDefined()) {
David Blaikied9cf8262012-06-25 21:55:30 +000010494 Diag(DelLoc, diag::err_deleted_decl_not_first);
10495 Diag(Prev->getLocation(), diag::note_previous_declaration);
10496 }
Sebastian Redl50de12f2009-03-24 22:27:57 +000010497 // If the declaration wasn't the first, we delete the function anyway for
10498 // recovery.
10499 }
Sean Hunt10620eb2011-05-06 20:44:56 +000010500 Fn->setDeletedAsWritten();
Richard Smithe653ba22012-02-26 00:31:33 +000010501
10502 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl);
10503 if (!MD)
10504 return;
10505
10506 // A deleted special member function is trivial if the corresponding
10507 // implicitly-declared function would have been.
10508 switch (getSpecialMember(MD)) {
10509 case CXXInvalid:
10510 break;
10511 case CXXDefaultConstructor:
10512 MD->setTrivial(MD->getParent()->hasTrivialDefaultConstructor());
10513 break;
10514 case CXXCopyConstructor:
10515 MD->setTrivial(MD->getParent()->hasTrivialCopyConstructor());
10516 break;
10517 case CXXMoveConstructor:
10518 MD->setTrivial(MD->getParent()->hasTrivialMoveConstructor());
10519 break;
10520 case CXXCopyAssignment:
10521 MD->setTrivial(MD->getParent()->hasTrivialCopyAssignment());
10522 break;
10523 case CXXMoveAssignment:
10524 MD->setTrivial(MD->getParent()->hasTrivialMoveAssignment());
10525 break;
10526 case CXXDestructor:
10527 MD->setTrivial(MD->getParent()->hasTrivialDestructor());
10528 break;
10529 }
Sebastian Redl50de12f2009-03-24 22:27:57 +000010530}
Sebastian Redl13e88542009-04-27 21:33:24 +000010531
Sean Hunte4246a62011-05-12 06:15:49 +000010532void Sema::SetDeclDefaulted(Decl *Dcl, SourceLocation DefaultLoc) {
10533 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Dcl);
10534
10535 if (MD) {
Sean Hunteb88ae52011-05-23 21:07:59 +000010536 if (MD->getParent()->isDependentType()) {
10537 MD->setDefaulted();
10538 MD->setExplicitlyDefaulted();
10539 return;
10540 }
10541
Sean Hunte4246a62011-05-12 06:15:49 +000010542 CXXSpecialMember Member = getSpecialMember(MD);
10543 if (Member == CXXInvalid) {
10544 Diag(DefaultLoc, diag::err_default_special_members);
10545 return;
10546 }
10547
10548 MD->setDefaulted();
10549 MD->setExplicitlyDefaulted();
10550
Sean Huntcd10dec2011-05-23 23:14:04 +000010551 // If this definition appears within the record, do the checking when
10552 // the record is complete.
10553 const FunctionDecl *Primary = MD;
Richard Smitha8eaf002012-08-23 06:16:52 +000010554 if (const FunctionDecl *Pattern = MD->getTemplateInstantiationPattern())
Sean Huntcd10dec2011-05-23 23:14:04 +000010555 // Find the uninstantiated declaration that actually had the '= default'
10556 // on it.
Richard Smitha8eaf002012-08-23 06:16:52 +000010557 Pattern->isDefined(Primary);
Sean Huntcd10dec2011-05-23 23:14:04 +000010558
10559 if (Primary == Primary->getCanonicalDecl())
Sean Hunte4246a62011-05-12 06:15:49 +000010560 return;
10561
Richard Smithb9d0b762012-07-27 04:22:15 +000010562 CheckExplicitlyDefaultedSpecialMember(MD);
10563
Sean Hunte4246a62011-05-12 06:15:49 +000010564 switch (Member) {
10565 case CXXDefaultConstructor: {
10566 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010567 if (!CD->isInvalidDecl())
10568 DefineImplicitDefaultConstructor(DefaultLoc, CD);
10569 break;
10570 }
10571
10572 case CXXCopyConstructor: {
10573 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010574 if (!CD->isInvalidDecl())
10575 DefineImplicitCopyConstructor(DefaultLoc, CD);
Sean Hunte4246a62011-05-12 06:15:49 +000010576 break;
10577 }
Sean Huntcb45a0f2011-05-12 22:46:25 +000010578
Sean Hunt2b188082011-05-14 05:23:28 +000010579 case CXXCopyAssignment: {
Sean Hunt2b188082011-05-14 05:23:28 +000010580 if (!MD->isInvalidDecl())
10581 DefineImplicitCopyAssignment(DefaultLoc, MD);
10582 break;
10583 }
10584
Sean Huntcb45a0f2011-05-12 22:46:25 +000010585 case CXXDestructor: {
10586 CXXDestructorDecl *DD = cast<CXXDestructorDecl>(MD);
Sean Hunt49634cf2011-05-13 06:10:58 +000010587 if (!DD->isInvalidDecl())
10588 DefineImplicitDestructor(DefaultLoc, DD);
Sean Huntcb45a0f2011-05-12 22:46:25 +000010589 break;
10590 }
10591
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010592 case CXXMoveConstructor: {
10593 CXXConstructorDecl *CD = cast<CXXConstructorDecl>(MD);
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010594 if (!CD->isInvalidDecl())
10595 DefineImplicitMoveConstructor(DefaultLoc, CD);
Sean Hunt82713172011-05-25 23:16:36 +000010596 break;
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010597 }
Sean Hunt82713172011-05-25 23:16:36 +000010598
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010599 case CXXMoveAssignment: {
Sebastian Redl85ea7aa2011-08-30 19:58:05 +000010600 if (!MD->isInvalidDecl())
10601 DefineImplicitMoveAssignment(DefaultLoc, MD);
10602 break;
10603 }
10604
10605 case CXXInvalid:
David Blaikieb219cfc2011-09-23 05:06:16 +000010606 llvm_unreachable("Invalid special member.");
Sean Hunte4246a62011-05-12 06:15:49 +000010607 }
10608 } else {
10609 Diag(DefaultLoc, diag::err_default_special_members);
10610 }
10611}
10612
Sebastian Redl13e88542009-04-27 21:33:24 +000010613static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
John McCall7502c1d2011-02-13 04:07:26 +000010614 for (Stmt::child_range CI = S->children(); CI; ++CI) {
Sebastian Redl13e88542009-04-27 21:33:24 +000010615 Stmt *SubStmt = *CI;
10616 if (!SubStmt)
10617 continue;
10618 if (isa<ReturnStmt>(SubStmt))
Daniel Dunbar96a00142012-03-09 18:35:03 +000010619 Self.Diag(SubStmt->getLocStart(),
Sebastian Redl13e88542009-04-27 21:33:24 +000010620 diag::err_return_in_constructor_handler);
10621 if (!isa<Expr>(SubStmt))
10622 SearchForReturnInStmt(Self, SubStmt);
10623 }
10624}
10625
10626void Sema::DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock) {
10627 for (unsigned I = 0, E = TryBlock->getNumHandlers(); I != E; ++I) {
10628 CXXCatchStmt *Handler = TryBlock->getHandler(I);
10629 SearchForReturnInStmt(*this, Handler);
10630 }
10631}
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010632
Mike Stump1eb44332009-09-09 15:08:12 +000010633bool Sema::CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010634 const CXXMethodDecl *Old) {
John McCall183700f2009-09-21 23:43:11 +000010635 QualType NewTy = New->getType()->getAs<FunctionType>()->getResultType();
10636 QualType OldTy = Old->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010637
Chandler Carruth73857792010-02-15 11:53:20 +000010638 if (Context.hasSameType(NewTy, OldTy) ||
10639 NewTy->isDependentType() || OldTy->isDependentType())
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010640 return false;
Mike Stump1eb44332009-09-09 15:08:12 +000010641
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010642 // Check if the return types are covariant
10643 QualType NewClassTy, OldClassTy;
Mike Stump1eb44332009-09-09 15:08:12 +000010644
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010645 /// Both types must be pointers or references to classes.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010646 if (const PointerType *NewPT = NewTy->getAs<PointerType>()) {
10647 if (const PointerType *OldPT = OldTy->getAs<PointerType>()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010648 NewClassTy = NewPT->getPointeeType();
10649 OldClassTy = OldPT->getPointeeType();
10650 }
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010651 } else if (const ReferenceType *NewRT = NewTy->getAs<ReferenceType>()) {
10652 if (const ReferenceType *OldRT = OldTy->getAs<ReferenceType>()) {
10653 if (NewRT->getTypeClass() == OldRT->getTypeClass()) {
10654 NewClassTy = NewRT->getPointeeType();
10655 OldClassTy = OldRT->getPointeeType();
10656 }
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010657 }
10658 }
Mike Stump1eb44332009-09-09 15:08:12 +000010659
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010660 // The return types aren't either both pointers or references to a class type.
10661 if (NewClassTy.isNull()) {
Mike Stump1eb44332009-09-09 15:08:12 +000010662 Diag(New->getLocation(),
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010663 diag::err_different_return_type_for_overriding_virtual_function)
10664 << New->getDeclName() << NewTy << OldTy;
10665 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
Mike Stump1eb44332009-09-09 15:08:12 +000010666
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010667 return true;
10668 }
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010669
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010670 // C++ [class.virtual]p6:
10671 // If the return type of D::f differs from the return type of B::f, the
10672 // class type in the return type of D::f shall be complete at the point of
10673 // declaration of D::f or shall be the class type D.
Anders Carlssonac4c9392009-12-31 18:54:35 +000010674 if (const RecordType *RT = NewClassTy->getAs<RecordType>()) {
10675 if (!RT->isBeingDefined() &&
10676 RequireCompleteType(New->getLocation(), NewClassTy,
Douglas Gregord10099e2012-05-04 16:32:21 +000010677 diag::err_covariant_return_incomplete,
10678 New->getDeclName()))
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010679 return true;
Anders Carlssonac4c9392009-12-31 18:54:35 +000010680 }
Anders Carlssonbe2e2052009-12-31 18:34:24 +000010681
Douglas Gregora4923eb2009-11-16 21:35:15 +000010682 if (!Context.hasSameUnqualifiedType(NewClassTy, OldClassTy)) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010683 // Check if the new class derives from the old class.
10684 if (!IsDerivedFrom(NewClassTy, OldClassTy)) {
10685 Diag(New->getLocation(),
10686 diag::err_covariant_return_not_derived)
10687 << New->getDeclName() << NewTy << OldTy;
10688 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10689 return true;
10690 }
Mike Stump1eb44332009-09-09 15:08:12 +000010691
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010692 // Check if we the conversion from derived to base is valid.
John McCall58e6f342010-03-16 05:22:47 +000010693 if (CheckDerivedToBaseConversion(NewClassTy, OldClassTy,
Anders Carlssone25a96c2010-04-24 17:11:09 +000010694 diag::err_covariant_return_inaccessible_base,
10695 diag::err_covariant_return_ambiguous_derived_to_base_conv,
10696 // FIXME: Should this point to the return type?
10697 New->getLocation(), SourceRange(), New->getDeclName(), 0)) {
John McCalleee1d542011-02-14 07:13:47 +000010698 // FIXME: this note won't trigger for delayed access control
10699 // diagnostics, and it's impossible to get an undelayed error
10700 // here from access control during the original parse because
10701 // the ParsingDeclSpec/ParsingDeclarator are still in scope.
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010702 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10703 return true;
10704 }
10705 }
Mike Stump1eb44332009-09-09 15:08:12 +000010706
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010707 // The qualifiers of the return types must be the same.
Anders Carlssonf2a04bf2010-01-22 17:37:20 +000010708 if (NewTy.getLocalCVRQualifiers() != OldTy.getLocalCVRQualifiers()) {
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010709 Diag(New->getLocation(),
10710 diag::err_covariant_return_type_different_qualifications)
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010711 << New->getDeclName() << NewTy << OldTy;
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010712 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10713 return true;
10714 };
Mike Stump1eb44332009-09-09 15:08:12 +000010715
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010716
10717 // The new class type must have the same or less qualifiers as the old type.
10718 if (NewClassTy.isMoreQualifiedThan(OldClassTy)) {
10719 Diag(New->getLocation(),
10720 diag::err_covariant_return_type_class_type_more_qualified)
10721 << New->getDeclName() << NewTy << OldTy;
10722 Diag(Old->getLocation(), diag::note_overridden_virtual_function);
10723 return true;
10724 };
Mike Stump1eb44332009-09-09 15:08:12 +000010725
Anders Carlssonc3a68b22009-05-14 19:52:19 +000010726 return false;
Anders Carlssond7ba27d2009-05-14 01:09:04 +000010727}
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010728
Douglas Gregor4ba31362009-12-01 17:24:26 +000010729/// \brief Mark the given method pure.
10730///
10731/// \param Method the method to be marked pure.
10732///
10733/// \param InitRange the source range that covers the "0" initializer.
10734bool Sema::CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange) {
Abramo Bagnara796aa442011-03-12 11:17:06 +000010735 SourceLocation EndLoc = InitRange.getEnd();
10736 if (EndLoc.isValid())
10737 Method->setRangeEnd(EndLoc);
10738
Douglas Gregor4ba31362009-12-01 17:24:26 +000010739 if (Method->isVirtual() || Method->getParent()->isDependentContext()) {
10740 Method->setPure();
Douglas Gregor4ba31362009-12-01 17:24:26 +000010741 return false;
Abramo Bagnara796aa442011-03-12 11:17:06 +000010742 }
Douglas Gregor4ba31362009-12-01 17:24:26 +000010743
10744 if (!Method->isInvalidDecl())
10745 Diag(Method->getLocation(), diag::err_non_virtual_pure)
10746 << Method->getDeclName() << InitRange;
10747 return true;
10748}
10749
Douglas Gregor552e2992012-02-21 02:22:07 +000010750/// \brief Determine whether the given declaration is a static data member.
10751static bool isStaticDataMember(Decl *D) {
10752 VarDecl *Var = dyn_cast_or_null<VarDecl>(D);
10753 if (!Var)
10754 return false;
10755
10756 return Var->isStaticDataMember();
10757}
John McCall731ad842009-12-19 09:28:58 +000010758/// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse
10759/// an initializer for the out-of-line declaration 'Dcl'. The scope
10760/// is a fresh scope pushed for just this purpose.
10761///
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010762/// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
10763/// static data member of class X, names should be looked up in the scope of
10764/// class X.
John McCalld226f652010-08-21 09:40:31 +000010765void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010766 // If there is no declaration, there was an error parsing it.
Argyrios Kyrtzidisb65abda2011-04-22 18:52:25 +000010767 if (D == 0 || D->isInvalidDecl()) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010768
John McCall731ad842009-12-19 09:28:58 +000010769 // We should only get called for declarations with scope specifiers, like:
10770 // int foo::bar;
10771 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +000010772 EnterDeclaratorContext(S, D->getDeclContext());
Douglas Gregor552e2992012-02-21 02:22:07 +000010773
10774 // If we are parsing the initializer for a static data member, push a
10775 // new expression evaluation context that is associated with this static
10776 // data member.
10777 if (isStaticDataMember(D))
10778 PushExpressionEvaluationContext(PotentiallyEvaluated, D);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010779}
10780
10781/// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
John McCalld226f652010-08-21 09:40:31 +000010782/// initializer for the out-of-line declaration 'D'.
10783void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010784 // If there is no declaration, there was an error parsing it.
Argyrios Kyrtzidisb65abda2011-04-22 18:52:25 +000010785 if (D == 0 || D->isInvalidDecl()) return;
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010786
Douglas Gregor552e2992012-02-21 02:22:07 +000010787 if (isStaticDataMember(D))
10788 PopExpressionEvaluationContext();
10789
John McCall731ad842009-12-19 09:28:58 +000010790 assert(D->isOutOfLine());
John McCall7a1dc562009-12-19 10:49:29 +000010791 ExitDeclaratorContext(S);
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +000010792}
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010793
10794/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
10795/// C++ if/switch/while/for statement.
10796/// e.g: "if (int x = f()) {...}"
John McCalld226f652010-08-21 09:40:31 +000010797DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010798 // C++ 6.4p2:
10799 // The declarator shall not specify a function or an array.
10800 // The type-specifier-seq shall not contain typedef and shall not declare a
10801 // new class or enumeration.
10802 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
10803 "Parser allowed 'typedef' as storage class of condition decl.");
Argyrios Kyrtzidisdb7abf72011-06-28 03:01:12 +000010804
10805 Decl *Dcl = ActOnDeclarator(S, D);
Douglas Gregor9a30c992011-07-05 16:13:20 +000010806 if (!Dcl)
10807 return true;
10808
Argyrios Kyrtzidisdb7abf72011-06-28 03:01:12 +000010809 if (isa<FunctionDecl>(Dcl)) { // The declarator shall not specify a function.
10810 Diag(Dcl->getLocation(), diag::err_invalid_use_of_function_type)
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010811 << D.getSourceRange();
Douglas Gregor9a30c992011-07-05 16:13:20 +000010812 return true;
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010813 }
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010814
Douglas Gregor99e9b4d2009-11-25 00:27:52 +000010815 return Dcl;
10816}
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010817
Douglas Gregordfe65432011-07-28 19:11:31 +000010818void Sema::LoadExternalVTableUses() {
10819 if (!ExternalSource)
10820 return;
10821
10822 SmallVector<ExternalVTableUse, 4> VTables;
10823 ExternalSource->ReadUsedVTables(VTables);
10824 SmallVector<VTableUse, 4> NewUses;
10825 for (unsigned I = 0, N = VTables.size(); I != N; ++I) {
10826 llvm::DenseMap<CXXRecordDecl *, bool>::iterator Pos
10827 = VTablesUsed.find(VTables[I].Record);
10828 // Even if a definition wasn't required before, it may be required now.
10829 if (Pos != VTablesUsed.end()) {
10830 if (!Pos->second && VTables[I].DefinitionRequired)
10831 Pos->second = true;
10832 continue;
10833 }
10834
10835 VTablesUsed[VTables[I].Record] = VTables[I].DefinitionRequired;
10836 NewUses.push_back(VTableUse(VTables[I].Record, VTables[I].Location));
10837 }
10838
10839 VTableUses.insert(VTableUses.begin(), NewUses.begin(), NewUses.end());
10840}
10841
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010842void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
10843 bool DefinitionRequired) {
10844 // Ignore any vtable uses in unevaluated operands or for classes that do
10845 // not have a vtable.
10846 if (!Class->isDynamicClass() || Class->isDependentContext() ||
10847 CurContext->isDependentContext() ||
Eli Friedman78a54242012-01-21 04:44:06 +000010848 ExprEvalContexts.back().Context == Unevaluated)
Rafael Espindolabbf58bb2010-03-10 02:19:29 +000010849 return;
10850
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010851 // Try to insert this class into the map.
Douglas Gregordfe65432011-07-28 19:11:31 +000010852 LoadExternalVTableUses();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010853 Class = cast<CXXRecordDecl>(Class->getCanonicalDecl());
10854 std::pair<llvm::DenseMap<CXXRecordDecl *, bool>::iterator, bool>
10855 Pos = VTablesUsed.insert(std::make_pair(Class, DefinitionRequired));
10856 if (!Pos.second) {
Daniel Dunbarb9aefa72010-05-25 00:33:13 +000010857 // If we already had an entry, check to see if we are promoting this vtable
10858 // to required a definition. If so, we need to reappend to the VTableUses
10859 // list, since we may have already processed the first entry.
10860 if (DefinitionRequired && !Pos.first->second) {
10861 Pos.first->second = true;
10862 } else {
10863 // Otherwise, we can early exit.
10864 return;
10865 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010866 }
10867
10868 // Local classes need to have their virtual members marked
10869 // immediately. For all other classes, we mark their virtual members
10870 // at the end of the translation unit.
10871 if (Class->isLocalClass())
10872 MarkVirtualMembersReferenced(Loc, Class);
Daniel Dunbar380c2132010-05-11 21:32:35 +000010873 else
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010874 VTableUses.push_back(std::make_pair(Class, Loc));
Douglas Gregorbbbe0742010-05-11 20:24:17 +000010875}
10876
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010877bool Sema::DefineUsedVTables() {
Douglas Gregordfe65432011-07-28 19:11:31 +000010878 LoadExternalVTableUses();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010879 if (VTableUses.empty())
Anders Carlssond6a637f2009-12-07 08:24:59 +000010880 return false;
Chandler Carruthaee543a2010-12-12 21:36:11 +000010881
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010882 // Note: The VTableUses vector could grow as a result of marking
10883 // the members of a class as "used", so we check the size each
Richard Smithb9d0b762012-07-27 04:22:15 +000010884 // time through the loop and prefer indices (which are stable) to
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010885 // iterators (which are not).
Douglas Gregor78844032011-04-22 22:25:37 +000010886 bool DefinedAnything = false;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010887 for (unsigned I = 0; I != VTableUses.size(); ++I) {
Daniel Dunbare669f892010-05-25 00:32:58 +000010888 CXXRecordDecl *Class = VTableUses[I].first->getDefinition();
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010889 if (!Class)
10890 continue;
10891
10892 SourceLocation Loc = VTableUses[I].second;
10893
Richard Smithb9d0b762012-07-27 04:22:15 +000010894 bool DefineVTable = true;
10895
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010896 // If this class has a key function, but that key function is
10897 // defined in another translation unit, we don't need to emit the
10898 // vtable even though we're using it.
10899 const CXXMethodDecl *KeyFunction = Context.getKeyFunction(Class);
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +000010900 if (KeyFunction && !KeyFunction->hasBody()) {
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010901 switch (KeyFunction->getTemplateSpecializationKind()) {
10902 case TSK_Undeclared:
10903 case TSK_ExplicitSpecialization:
10904 case TSK_ExplicitInstantiationDeclaration:
10905 // The key function is in another translation unit.
Richard Smithb9d0b762012-07-27 04:22:15 +000010906 DefineVTable = false;
10907 break;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010908
10909 case TSK_ExplicitInstantiationDefinition:
10910 case TSK_ImplicitInstantiation:
10911 // We will be instantiating the key function.
10912 break;
10913 }
10914 } else if (!KeyFunction) {
10915 // If we have a class with no key function that is the subject
10916 // of an explicit instantiation declaration, suppress the
10917 // vtable; it will live with the explicit instantiation
10918 // definition.
10919 bool IsExplicitInstantiationDeclaration
10920 = Class->getTemplateSpecializationKind()
10921 == TSK_ExplicitInstantiationDeclaration;
10922 for (TagDecl::redecl_iterator R = Class->redecls_begin(),
10923 REnd = Class->redecls_end();
10924 R != REnd; ++R) {
10925 TemplateSpecializationKind TSK
10926 = cast<CXXRecordDecl>(*R)->getTemplateSpecializationKind();
10927 if (TSK == TSK_ExplicitInstantiationDeclaration)
10928 IsExplicitInstantiationDeclaration = true;
10929 else if (TSK == TSK_ExplicitInstantiationDefinition) {
10930 IsExplicitInstantiationDeclaration = false;
10931 break;
10932 }
10933 }
10934
10935 if (IsExplicitInstantiationDeclaration)
Richard Smithb9d0b762012-07-27 04:22:15 +000010936 DefineVTable = false;
10937 }
10938
10939 // The exception specifications for all virtual members may be needed even
10940 // if we are not providing an authoritative form of the vtable in this TU.
10941 // We may choose to emit it available_externally anyway.
10942 if (!DefineVTable) {
10943 MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
10944 continue;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010945 }
10946
10947 // Mark all of the virtual members of this class as referenced, so
10948 // that we can build a vtable. Then, tell the AST consumer that a
10949 // vtable for this class is required.
Douglas Gregor78844032011-04-22 22:25:37 +000010950 DefinedAnything = true;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010951 MarkVirtualMembersReferenced(Loc, Class);
10952 CXXRecordDecl *Canonical = cast<CXXRecordDecl>(Class->getCanonicalDecl());
10953 Consumer.HandleVTable(Class, VTablesUsed[Canonical]);
10954
10955 // Optionally warn if we're emitting a weak vtable.
10956 if (Class->getLinkage() == ExternalLinkage &&
10957 Class->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
Douglas Gregora120d012011-09-23 19:04:03 +000010958 const FunctionDecl *KeyFunctionDef = 0;
10959 if (!KeyFunction ||
10960 (KeyFunction->hasBody(KeyFunctionDef) &&
10961 KeyFunctionDef->isInlined()))
David Blaikie44d95b52011-12-09 18:32:50 +000010962 Diag(Class->getLocation(), Class->getTemplateSpecializationKind() ==
10963 TSK_ExplicitInstantiationDefinition
10964 ? diag::warn_weak_template_vtable : diag::warn_weak_vtable)
10965 << Class;
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010966 }
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010967 }
Douglas Gregor6fb745b2010-05-13 16:44:06 +000010968 VTableUses.clear();
10969
Douglas Gregor78844032011-04-22 22:25:37 +000010970 return DefinedAnything;
Anders Carlsson5ec02ae2009-12-02 17:15:43 +000010971}
Anders Carlssond6a637f2009-12-07 08:24:59 +000010972
Richard Smithb9d0b762012-07-27 04:22:15 +000010973void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
10974 const CXXRecordDecl *RD) {
10975 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
10976 E = RD->method_end(); I != E; ++I)
10977 if ((*I)->isVirtual() && !(*I)->isPure())
10978 ResolveExceptionSpec(Loc, (*I)->getType()->castAs<FunctionProtoType>());
10979}
10980
Rafael Espindola3e1ae932010-03-26 00:36:59 +000010981void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
10982 const CXXRecordDecl *RD) {
Richard Smithff817f72012-07-07 06:59:51 +000010983 // Mark all functions which will appear in RD's vtable as used.
10984 CXXFinalOverriderMap FinalOverriders;
10985 RD->getFinalOverriders(FinalOverriders);
10986 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
10987 E = FinalOverriders.end();
10988 I != E; ++I) {
10989 for (OverridingMethods::const_iterator OI = I->second.begin(),
10990 OE = I->second.end();
10991 OI != OE; ++OI) {
10992 assert(OI->second.size() > 0 && "no final overrider");
10993 CXXMethodDecl *Overrider = OI->second.front().Method;
Anders Carlssond6a637f2009-12-07 08:24:59 +000010994
Richard Smithff817f72012-07-07 06:59:51 +000010995 // C++ [basic.def.odr]p2:
10996 // [...] A virtual member function is used if it is not pure. [...]
10997 if (!Overrider->isPure())
10998 MarkFunctionReferenced(Loc, Overrider);
10999 }
Anders Carlssond6a637f2009-12-07 08:24:59 +000011000 }
Rafael Espindola3e1ae932010-03-26 00:36:59 +000011001
11002 // Only classes that have virtual bases need a VTT.
11003 if (RD->getNumVBases() == 0)
11004 return;
11005
11006 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
11007 e = RD->bases_end(); i != e; ++i) {
11008 const CXXRecordDecl *Base =
11009 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Rafael Espindola3e1ae932010-03-26 00:36:59 +000011010 if (Base->getNumVBases() == 0)
11011 continue;
11012 MarkVirtualMembersReferenced(Loc, Base);
11013 }
Anders Carlssond6a637f2009-12-07 08:24:59 +000011014}
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011015
11016/// SetIvarInitializers - This routine builds initialization ASTs for the
11017/// Objective-C implementation whose ivars need be initialized.
11018void Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {
David Blaikie4e4d0842012-03-11 07:00:24 +000011019 if (!getLangOpts().CPlusPlus)
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011020 return;
Fariborz Jahanian2c18bb72010-08-20 21:21:08 +000011021 if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +000011022 SmallVector<ObjCIvarDecl*, 8> ivars;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011023 CollectIvarsToConstructOrDestruct(OID, ivars);
11024 if (ivars.empty())
11025 return;
Chris Lattner5f9e2722011-07-23 10:55:15 +000011026 SmallVector<CXXCtorInitializer*, 32> AllToInit;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011027 for (unsigned i = 0; i < ivars.size(); i++) {
11028 FieldDecl *Field = ivars[i];
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000011029 if (Field->isInvalidDecl())
11030 continue;
11031
Sean Huntcbb67482011-01-08 20:30:50 +000011032 CXXCtorInitializer *Member;
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011033 InitializedEntity InitEntity = InitializedEntity::InitializeMember(Field);
11034 InitializationKind InitKind =
11035 InitializationKind::CreateDefault(ObjCImplementation->getLocation());
11036
11037 InitializationSequence InitSeq(*this, InitEntity, InitKind, 0, 0);
John McCall60d7b3a2010-08-24 06:29:42 +000011038 ExprResult MemberInit =
John McCallf312b1e2010-08-26 23:41:50 +000011039 InitSeq.Perform(*this, InitEntity, InitKind, MultiExprArg());
Douglas Gregor53c374f2010-12-07 00:41:46 +000011040 MemberInit = MaybeCreateExprWithCleanups(MemberInit);
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011041 // Note, MemberInit could actually come back empty if no initialization
11042 // is required (e.g., because it would call a trivial default constructor)
11043 if (!MemberInit.get() || MemberInit.isInvalid())
11044 continue;
John McCallb4eb64d2010-10-08 02:01:28 +000011045
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011046 Member =
Sean Huntcbb67482011-01-08 20:30:50 +000011047 new (Context) CXXCtorInitializer(Context, Field, SourceLocation(),
11048 SourceLocation(),
11049 MemberInit.takeAs<Expr>(),
11050 SourceLocation());
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011051 AllToInit.push_back(Member);
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000011052
11053 // Be sure that the destructor is accessible and is marked as referenced.
11054 if (const RecordType *RecordTy
11055 = Context.getBaseElementType(Field->getType())
11056 ->getAs<RecordType>()) {
11057 CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
Douglas Gregordb89f282010-07-01 22:47:18 +000011058 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
Eli Friedman5f2987c2012-02-02 03:46:19 +000011059 MarkFunctionReferenced(Field->getLocation(), Destructor);
Douglas Gregor68dd3ee2010-05-20 02:24:22 +000011060 CheckDestructorAccess(Field->getLocation(), Destructor,
11061 PDiag(diag::err_access_dtor_ivar)
11062 << Context.getBaseElementType(Field->getType()));
11063 }
11064 }
Fariborz Jahaniane4498c62010-04-28 16:11:27 +000011065 }
11066 ObjCImplementation->setIvarInitializers(Context,
11067 AllToInit.data(), AllToInit.size());
11068 }
11069}
Sean Huntfe57eef2011-05-04 05:57:24 +000011070
Sean Huntebcbe1d2011-05-04 23:29:54 +000011071static
11072void DelegatingCycleHelper(CXXConstructorDecl* Ctor,
11073 llvm::SmallSet<CXXConstructorDecl*, 4> &Valid,
11074 llvm::SmallSet<CXXConstructorDecl*, 4> &Invalid,
11075 llvm::SmallSet<CXXConstructorDecl*, 4> &Current,
11076 Sema &S) {
11077 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(),
11078 CE = Current.end();
11079 if (Ctor->isInvalidDecl())
11080 return;
11081
Richard Smitha8eaf002012-08-23 06:16:52 +000011082 CXXConstructorDecl *Target = Ctor->getTargetConstructor();
11083
11084 // Target may not be determinable yet, for instance if this is a dependent
11085 // call in an uninstantiated template.
11086 if (Target) {
11087 const FunctionDecl *FNTarget = 0;
11088 (void)Target->hasBody(FNTarget);
11089 Target = const_cast<CXXConstructorDecl*>(
11090 cast_or_null<CXXConstructorDecl>(FNTarget));
11091 }
Sean Huntebcbe1d2011-05-04 23:29:54 +000011092
11093 CXXConstructorDecl *Canonical = Ctor->getCanonicalDecl(),
11094 // Avoid dereferencing a null pointer here.
11095 *TCanonical = Target ? Target->getCanonicalDecl() : 0;
11096
11097 if (!Current.insert(Canonical))
11098 return;
11099
11100 // We know that beyond here, we aren't chaining into a cycle.
11101 if (!Target || !Target->isDelegatingConstructor() ||
11102 Target->isInvalidDecl() || Valid.count(TCanonical)) {
11103 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI)
11104 Valid.insert(*CI);
11105 Current.clear();
11106 // We've hit a cycle.
11107 } else if (TCanonical == Canonical || Invalid.count(TCanonical) ||
11108 Current.count(TCanonical)) {
11109 // If we haven't diagnosed this cycle yet, do so now.
11110 if (!Invalid.count(TCanonical)) {
11111 S.Diag((*Ctor->init_begin())->getSourceLocation(),
Sean Huntc1598702011-05-05 00:05:47 +000011112 diag::warn_delegating_ctor_cycle)
Sean Huntebcbe1d2011-05-04 23:29:54 +000011113 << Ctor;
11114
Richard Smitha8eaf002012-08-23 06:16:52 +000011115 // Don't add a note for a function delegating directly to itself.
Sean Huntebcbe1d2011-05-04 23:29:54 +000011116 if (TCanonical != Canonical)
11117 S.Diag(Target->getLocation(), diag::note_it_delegates_to);
11118
11119 CXXConstructorDecl *C = Target;
11120 while (C->getCanonicalDecl() != Canonical) {
Richard Smitha8eaf002012-08-23 06:16:52 +000011121 const FunctionDecl *FNTarget = 0;
Sean Huntebcbe1d2011-05-04 23:29:54 +000011122 (void)C->getTargetConstructor()->hasBody(FNTarget);
11123 assert(FNTarget && "Ctor cycle through bodiless function");
11124
Richard Smitha8eaf002012-08-23 06:16:52 +000011125 C = const_cast<CXXConstructorDecl*>(
11126 cast<CXXConstructorDecl>(FNTarget));
Sean Huntebcbe1d2011-05-04 23:29:54 +000011127 S.Diag(C->getLocation(), diag::note_which_delegates_to);
11128 }
11129 }
11130
11131 for (CI = Current.begin(), CE = Current.end(); CI != CE; ++CI)
11132 Invalid.insert(*CI);
11133 Current.clear();
11134 } else {
11135 DelegatingCycleHelper(Target, Valid, Invalid, Current, S);
11136 }
11137}
11138
11139
Sean Huntfe57eef2011-05-04 05:57:24 +000011140void Sema::CheckDelegatingCtorCycles() {
11141 llvm::SmallSet<CXXConstructorDecl*, 4> Valid, Invalid, Current;
11142
Sean Huntebcbe1d2011-05-04 23:29:54 +000011143 llvm::SmallSet<CXXConstructorDecl*, 4>::iterator CI = Current.begin(),
11144 CE = Current.end();
Sean Huntfe57eef2011-05-04 05:57:24 +000011145
Douglas Gregor0129b562011-07-27 21:57:17 +000011146 for (DelegatingCtorDeclsType::iterator
11147 I = DelegatingCtorDecls.begin(ExternalSource),
Sean Huntebcbe1d2011-05-04 23:29:54 +000011148 E = DelegatingCtorDecls.end();
Richard Smitha8eaf002012-08-23 06:16:52 +000011149 I != E; ++I)
11150 DelegatingCycleHelper(*I, Valid, Invalid, Current, *this);
Sean Huntebcbe1d2011-05-04 23:29:54 +000011151
11152 for (CI = Invalid.begin(), CE = Invalid.end(); CI != CE; ++CI)
11153 (*CI)->setInvalidDecl();
Sean Huntfe57eef2011-05-04 05:57:24 +000011154}
Peter Collingbourne78dd67e2011-10-02 23:49:40 +000011155
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011156namespace {
11157 /// \brief AST visitor that finds references to the 'this' expression.
11158 class FindCXXThisExpr : public RecursiveASTVisitor<FindCXXThisExpr> {
11159 Sema &S;
11160
11161 public:
11162 explicit FindCXXThisExpr(Sema &S) : S(S) { }
11163
11164 bool VisitCXXThisExpr(CXXThisExpr *E) {
11165 S.Diag(E->getLocation(), diag::err_this_static_member_func)
11166 << E->isImplicit();
11167 return false;
11168 }
11169 };
11170}
11171
11172bool Sema::checkThisInStaticMemberFunctionType(CXXMethodDecl *Method) {
11173 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
11174 if (!TSInfo)
11175 return false;
11176
11177 TypeLoc TL = TSInfo->getTypeLoc();
11178 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL);
11179 if (!ProtoTL)
11180 return false;
11181
11182 // C++11 [expr.prim.general]p3:
11183 // [The expression this] shall not appear before the optional
11184 // cv-qualifier-seq and it shall not appear within the declaration of a
11185 // static member function (although its type and value category are defined
11186 // within a static member function as they are within a non-static member
11187 // function). [ Note: this is because declaration matching does not occur
NAKAMURA Takumic86d1fd2012-04-21 09:40:04 +000011188 // until the complete declarator is known. - end note ]
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011189 const FunctionProtoType *Proto = ProtoTL->getTypePtr();
11190 FindCXXThisExpr Finder(*this);
11191
11192 // If the return type came after the cv-qualifier-seq, check it now.
11193 if (Proto->hasTrailingReturn() &&
11194 !Finder.TraverseTypeLoc(ProtoTL->getResultLoc()))
11195 return true;
11196
11197 // Check the exception specification.
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011198 if (checkThisInStaticMemberFunctionExceptionSpec(Method))
11199 return true;
11200
11201 return checkThisInStaticMemberFunctionAttributes(Method);
11202}
11203
11204bool Sema::checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method) {
11205 TypeSourceInfo *TSInfo = Method->getTypeSourceInfo();
11206 if (!TSInfo)
11207 return false;
11208
11209 TypeLoc TL = TSInfo->getTypeLoc();
11210 FunctionProtoTypeLoc *ProtoTL = dyn_cast<FunctionProtoTypeLoc>(&TL);
11211 if (!ProtoTL)
11212 return false;
11213
11214 const FunctionProtoType *Proto = ProtoTL->getTypePtr();
11215 FindCXXThisExpr Finder(*this);
11216
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011217 switch (Proto->getExceptionSpecType()) {
Richard Smithe6975e92012-04-17 00:58:00 +000011218 case EST_Uninstantiated:
Richard Smithb9d0b762012-07-27 04:22:15 +000011219 case EST_Unevaluated:
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011220 case EST_BasicNoexcept:
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011221 case EST_DynamicNone:
11222 case EST_MSAny:
11223 case EST_None:
11224 break;
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011225
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011226 case EST_ComputedNoexcept:
11227 if (!Finder.TraverseStmt(Proto->getNoexceptExpr()))
11228 return true;
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011229
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011230 case EST_Dynamic:
11231 for (FunctionProtoType::exception_iterator E = Proto->exception_begin(),
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011232 EEnd = Proto->exception_end();
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011233 E != EEnd; ++E) {
11234 if (!Finder.TraverseType(*E))
11235 return true;
11236 }
11237 break;
11238 }
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011239
11240 return false;
Douglas Gregorcefc3af2012-04-16 07:05:22 +000011241}
11242
11243bool Sema::checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method) {
11244 FindCXXThisExpr Finder(*this);
11245
11246 // Check attributes.
11247 for (Decl::attr_iterator A = Method->attr_begin(), AEnd = Method->attr_end();
11248 A != AEnd; ++A) {
11249 // FIXME: This should be emitted by tblgen.
11250 Expr *Arg = 0;
11251 ArrayRef<Expr *> Args;
11252 if (GuardedByAttr *G = dyn_cast<GuardedByAttr>(*A))
11253 Arg = G->getArg();
11254 else if (PtGuardedByAttr *G = dyn_cast<PtGuardedByAttr>(*A))
11255 Arg = G->getArg();
11256 else if (AcquiredAfterAttr *AA = dyn_cast<AcquiredAfterAttr>(*A))
11257 Args = ArrayRef<Expr *>(AA->args_begin(), AA->args_size());
11258 else if (AcquiredBeforeAttr *AB = dyn_cast<AcquiredBeforeAttr>(*A))
11259 Args = ArrayRef<Expr *>(AB->args_begin(), AB->args_size());
11260 else if (ExclusiveLockFunctionAttr *ELF
11261 = dyn_cast<ExclusiveLockFunctionAttr>(*A))
11262 Args = ArrayRef<Expr *>(ELF->args_begin(), ELF->args_size());
11263 else if (SharedLockFunctionAttr *SLF
11264 = dyn_cast<SharedLockFunctionAttr>(*A))
11265 Args = ArrayRef<Expr *>(SLF->args_begin(), SLF->args_size());
11266 else if (ExclusiveTrylockFunctionAttr *ETLF
11267 = dyn_cast<ExclusiveTrylockFunctionAttr>(*A)) {
11268 Arg = ETLF->getSuccessValue();
11269 Args = ArrayRef<Expr *>(ETLF->args_begin(), ETLF->args_size());
11270 } else if (SharedTrylockFunctionAttr *STLF
11271 = dyn_cast<SharedTrylockFunctionAttr>(*A)) {
11272 Arg = STLF->getSuccessValue();
11273 Args = ArrayRef<Expr *>(STLF->args_begin(), STLF->args_size());
11274 } else if (UnlockFunctionAttr *UF = dyn_cast<UnlockFunctionAttr>(*A))
11275 Args = ArrayRef<Expr *>(UF->args_begin(), UF->args_size());
11276 else if (LockReturnedAttr *LR = dyn_cast<LockReturnedAttr>(*A))
11277 Arg = LR->getArg();
11278 else if (LocksExcludedAttr *LE = dyn_cast<LocksExcludedAttr>(*A))
11279 Args = ArrayRef<Expr *>(LE->args_begin(), LE->args_size());
11280 else if (ExclusiveLocksRequiredAttr *ELR
11281 = dyn_cast<ExclusiveLocksRequiredAttr>(*A))
11282 Args = ArrayRef<Expr *>(ELR->args_begin(), ELR->args_size());
11283 else if (SharedLocksRequiredAttr *SLR
11284 = dyn_cast<SharedLocksRequiredAttr>(*A))
11285 Args = ArrayRef<Expr *>(SLR->args_begin(), SLR->args_size());
11286
11287 if (Arg && !Finder.TraverseStmt(Arg))
11288 return true;
11289
11290 for (unsigned I = 0, N = Args.size(); I != N; ++I) {
11291 if (!Finder.TraverseStmt(Args[I]))
11292 return true;
11293 }
11294 }
11295
11296 return false;
11297}
11298
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011299void
11300Sema::checkExceptionSpecification(ExceptionSpecificationType EST,
11301 ArrayRef<ParsedType> DynamicExceptions,
11302 ArrayRef<SourceRange> DynamicExceptionRanges,
11303 Expr *NoexceptExpr,
11304 llvm::SmallVectorImpl<QualType> &Exceptions,
11305 FunctionProtoType::ExtProtoInfo &EPI) {
11306 Exceptions.clear();
11307 EPI.ExceptionSpecType = EST;
11308 if (EST == EST_Dynamic) {
11309 Exceptions.reserve(DynamicExceptions.size());
11310 for (unsigned ei = 0, ee = DynamicExceptions.size(); ei != ee; ++ei) {
11311 // FIXME: Preserve type source info.
11312 QualType ET = GetTypeFromParser(DynamicExceptions[ei]);
11313
11314 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
11315 collectUnexpandedParameterPacks(ET, Unexpanded);
11316 if (!Unexpanded.empty()) {
11317 DiagnoseUnexpandedParameterPacks(DynamicExceptionRanges[ei].getBegin(),
11318 UPPC_ExceptionType,
11319 Unexpanded);
11320 continue;
11321 }
11322
11323 // Check that the type is valid for an exception spec, and
11324 // drop it if not.
11325 if (!CheckSpecifiedExceptionType(ET, DynamicExceptionRanges[ei]))
11326 Exceptions.push_back(ET);
11327 }
11328 EPI.NumExceptions = Exceptions.size();
11329 EPI.Exceptions = Exceptions.data();
11330 return;
11331 }
11332
11333 if (EST == EST_ComputedNoexcept) {
11334 // If an error occurred, there's no expression here.
11335 if (NoexceptExpr) {
11336 assert((NoexceptExpr->isTypeDependent() ||
11337 NoexceptExpr->getType()->getCanonicalTypeUnqualified() ==
11338 Context.BoolTy) &&
11339 "Parser should have made sure that the expression is boolean");
11340 if (NoexceptExpr && DiagnoseUnexpandedParameterPack(NoexceptExpr)) {
11341 EPI.ExceptionSpecType = EST_BasicNoexcept;
11342 return;
11343 }
11344
11345 if (!NoexceptExpr->isValueDependent())
11346 NoexceptExpr = VerifyIntegerConstantExpression(NoexceptExpr, 0,
Douglas Gregorab41fe92012-05-04 22:38:52 +000011347 diag::err_noexcept_needs_constant_expression,
Douglas Gregor74e2fc32012-04-16 18:27:27 +000011348 /*AllowFold*/ false).take();
11349 EPI.NoexceptExpr = NoexceptExpr;
11350 }
11351 return;
11352 }
11353}
11354
Peter Collingbourne78dd67e2011-10-02 23:49:40 +000011355/// IdentifyCUDATarget - Determine the CUDA compilation target for this function
11356Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D) {
11357 // Implicitly declared functions (e.g. copy constructors) are
11358 // __host__ __device__
11359 if (D->isImplicit())
11360 return CFT_HostDevice;
11361
11362 if (D->hasAttr<CUDAGlobalAttr>())
11363 return CFT_Global;
11364
11365 if (D->hasAttr<CUDADeviceAttr>()) {
11366 if (D->hasAttr<CUDAHostAttr>())
11367 return CFT_HostDevice;
11368 else
11369 return CFT_Device;
11370 }
11371
11372 return CFT_Host;
11373}
11374
11375bool Sema::CheckCUDATarget(CUDAFunctionTarget CallerTarget,
11376 CUDAFunctionTarget CalleeTarget) {
11377 // CUDA B.1.1 "The __device__ qualifier declares a function that is...
11378 // Callable from the device only."
11379 if (CallerTarget == CFT_Host && CalleeTarget == CFT_Device)
11380 return true;
11381
11382 // CUDA B.1.2 "The __global__ qualifier declares a function that is...
11383 // Callable from the host only."
11384 // CUDA B.1.3 "The __host__ qualifier declares a function that is...
11385 // Callable from the host only."
11386 if ((CallerTarget == CFT_Device || CallerTarget == CFT_Global) &&
11387 (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global))
11388 return true;
11389
11390 if (CallerTarget == CFT_HostDevice && CalleeTarget != CFT_HostDevice)
11391 return true;
11392
11393 return false;
11394}